most likely scrapping this idea

package.json

@@ -11,7 +11,7 @@
 	"devDependencies": {
 		"sass": "^1.85.1",
 		"typescript": "^5.8.2",
-		"vite": "^6.2.2",
+		"vite": "^6.2.1",
 		"vite-plugin-html": "^3.2.2"
 	}
 }

src/rt/rfwfs/hash.ts

@@ -1,11 +1,51 @@
-async function hash(inner_as_string: string) {
+import { type FileInner } from "./main"
+
+interface HashTable {
+	[index: string]: FileInner
+}
+interface Hash {
+	readonly inner: HashTable,
+	sha256: (file_inner: FileInner) => Promise<string>,
+	push: (hash: string) => void,
+	find: (hash: string) => FileInner | undefined,
+	pop: (hash: string) => FileInner | undefined,
+}
+
+async function sha256(inner_as_string: string): Promise<string> {
 	const encoder = new TextEncoder()
 	const hash = await crypto.subtle.digest("SHA-256", encoder.encode(inner_as_string))
 	const hash_as_uint8 = new Uint8Array(hash)
-    return Array.from(hash_as_uint8).map(byte => byte.toString(16).padStart(2, "0")).join("")
+	return Array.from(hash_as_uint8).map(byte => byte.toString(16).padStart(2, "0")).join("")
 }
 
-export default async function generate_sha256(inner_as_string: string) {
+const hash_table = { inner: {} } as Hash
-	const sha256 = await hash(inner_as_string)
+
-	return sha256
+hash_table.sha256 = async function(file_inner) {
+	return await sha256(file_inner.toString())
+}
+
+hash_table.find = function(hash) {
+	const hash_entry = this.inner[hash]
+	if (hash_entry) {
+		return hash_entry
+	}
+	return undefined
+}
+
+hash_table.pop = function(hash) {
+	const hash_entry = this.find(hash)
+	if (hash_entry) {
+		delete this.inner[hash_entry]
+		return hash_entry
+	}
+	return undefined
+}
+
+hash_table.push = function(hash) {
+
+}
+
+export default hash_table
+export {
+	type HashTable,
 }

src/rt/rfwfs/index.ts

@@ -6,7 +6,7 @@ export default function directory_search<T extends Entry>(entry_collection: T[],
 	let end = entry_collection.length-1
 	while (start<=end) {
 		const median = (start+end)>>1
-		const median_name = entry_collection[median].name.inner
+		const median_name = entry_collection[median].name
 
 		if (median_name === file_name) {
 			return wrap_bsearch(median, entry_collection[median])

src/rt/rfwfs/main.ts

@@ -2,28 +2,41 @@ import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsB
 import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
 
 import directory_search from "./index"
+import hash_table from "./hash"
 
 type FileInner = string | number
+type EntryFileInner = EntryValue<FileInner, FileInner | undefined>
 
+//please do not change the inner values directly on entries or else there will be catastrophic consequences
+interface EntryValue<T, U = T> {
+	__inner: T,
+	write: (value: T) => boolean,
+	read: () => U,
+}
 interface Entry {
 	permissions: Permissions,
 	timestamp: EntryValue<number>,
 	name: EntryValue<string>,
 	readonly type: EntryType,
 }
-
 interface EntryFile extends Entry {
-	inner: EntryValue<FileInner>,
+	inner: EntryFileInner,
 	hash: string,
 }
-
 interface EntryCollection<T extends Entry> extends Entry {
-	inner: RfwfsDirectory<T>,
+	inner: EntryCollectionManipulate<T>,
+}
+interface EntryCollectionManipulate<T extends Entry> {
+	__inner: T[],
+	clone: (file_name: string) => WrapResultEntry<T, ReadStatus>
+	find: (file_name: string) => WrapResultEntry<T, ReadStatus>
+	push: (entry: Entry) => WrapResultNone<PushStatus>,
+	sort: () => void,
+	pop: (file_name: string) => WrapResultEntry<T, ReadStatus>,
 }
-
 interface Rfwfs {
 	directory: <T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]) => EntryCollection<T>,
-	file: (default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: FileInner) => EntryFile,
+	file: (default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: FileInner) => Promise<EntryFile>,
 	is_binary: <T extends Entry>(entry: T) => boolean,
 	is_file: <T extends Entry>(entry: T) => boolean,
 	is_dir: <T extends Entry>(entry: T) => boolean,
@@ -45,87 +58,85 @@ function write_access<P extends ConstEnum>(permissions: P): boolean {
 	return read_write_access(permissions) || permissions === Permissions.w
 }
 
-class EntryValue<T> {
+function directory_sort<E extends Entry>(self: EntryCollectionManipulate<E>) {
-	public inner: T;
+	self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
-	protected entry: Entry
-
-	constructor(entry: Entry, inner_default: T) {
-		this.inner = inner_default
-		this.entry = entry
-	}
-
-	public write<I extends T>(item: I): boolean {
-		if (write_access(this.entry.permissions)) {
-			this.inner = item
-			return true
-		}
-		return false
-	}
-
-	public read(): T | undefined {
-		return read_access(this.entry.permissions) ? this.inner : undefined
-	}
 }
 
-class RfwfsDirectory<T extends Entry> {
+function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> {
-	public inner: T[];
+	if (write_access(self.permissions)) {
-	protected entry: Entry
+		const no_duplicates = directory_search(self.inner.__inner, entry.name.read())
-
+		if (!no_duplicates) {
-	constructor(entry: Entry, inner: T[]) {
+			self.inner.__inner.push(entry)
-		this.inner = inner
+			self.inner.__inner.sort()
-		this.entry = entry
+			return wrap_none(PushStatus.Ok)
-	}
-
-	public sort() {
-		this.inner.sort((a,z) => a.name.inner.localeCompare(z.name.inner))
-	}
-
-	public clone(file_name: string): WrapResultEntry<T, ReadStatus> {
-		if (read_write_access(this.entry.permissions)) {
-			const clone_find = directory_search(this.inner, file_name)
-			if (clone_find) {
-				return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
-			}
-			return wrap_entry(ReadStatus.NotFound)
 		}
-		return wrap_entry(ReadStatus.Denied)
+		return wrap_none(PushStatus.Duplicate)
 	}
+	return wrap_none(PushStatus.Denied)
+}
 
-	public find(file_name: string): WrapResultEntry<T, ReadStatus> {
+function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
-		if (read_write_access(this.entry.permissions)) {
+	if (read_access(self.permissions)) {
-			const file_search = directory_search(this.inner, file_name)
+		const file_search = directory_search(self.inner.__inner, file_name)
-			if (file_search) {
+		if (file_search) {
-				return wrap_entry(ReadStatus.Ok, file_search.result)
+			return wrap_entry(ReadStatus.Ok, file_search.result)
-			}
-			return wrap_entry(ReadStatus.NotFound)
 		}
-		return wrap_entry(ReadStatus.Denied)
+		return wrap_entry(ReadStatus.NotFound)
 	}
+	return wrap_entry(ReadStatus.Denied)
+}
 
-	public push<E extends T>(entry: E): WrapResultNone<PushStatus> {
+function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
-		if (read_write_access(this.entry.permissions)) {
+	if (read_write_access(self.permissions)) {
-			const no_duplicates = directory_search(this.inner, entry.name.inner)
+		const pop_find = directory_search(self.inner.__inner, file_name)
-			if (!no_duplicates) {
+		if (pop_find) {
-				this.inner.push(entry)
+			self.inner.__inner.splice(pop_find.some, 1)
-				this.inner.sort()
+			return wrap_entry(ReadStatus.Ok, pop_find.result)
-				return wrap_none(PushStatus.Ok)
-			}
-			return wrap_none(PushStatus.Duplicate)
 		}
-		return wrap_none(PushStatus.Denied)
+		return wrap_entry(ReadStatus.NotFound)
 	}
+	return wrap_entry(ReadStatus.Denied)
+}
 
-	public pop(file_name: string): WrapResultEntry<T, ReadStatus> {
+function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
-		if (read_write_access(this.entry.permissions)) {
+	if (read_write_access(self.permissions)) {
-			const pop_find = directory_search(this.inner, file_name)
+		const clone_find = directory_search(self.inner.__inner, file_name)
-			if (pop_find) {
+		if (clone_find) {
-				this.inner.splice(pop_find.some, 1)
+			return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
-				return wrap_entry(ReadStatus.Ok, pop_find.result)
-			}
-			return wrap_entry(ReadStatus.NotFound)
 		}
-		return wrap_entry(ReadStatus.Denied)
+		return wrap_entry(ReadStatus.NotFound)
 	}
+	return wrap_entry(ReadStatus.Denied)
+}
+
+function inner_read<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P): FileInner | undefined {
+	return read_access(permissions) ? self.__inner : undefined
+}
+
+function inner_write<I extends FileInner, P extends ConstEnum>(self: EntryValue<I>, permissions: P, item: I): boolean {
+	if (write_access(permissions)) {
+		self.__inner = item
+		return true
+	}
+	return false
+}
+
+function inner<P extends ConstEnum, I, R extends EntryValue<I>>(permissions: P, inner_default: I): R {
+	const inner_trait = { __inner: inner_default } as R
+	inner_trait.write = function(item) { return inner_write(this, permissions, item) }
+	inner_trait.read  = function()     { return inner_read(this, permissions) }
+	return inner_trait
+}
+
+function dir_inner<T extends Entry>(self: EntryCollection<T>, collection: T[]): EntryCollectionManipulate<T> {
+	const collection_trait = { __inner: collection } as EntryCollectionManipulate<T>
+	collection_trait.clone = function(file_name) { return directory_clone(self, file_name) }
+	collection_trait.find  = function(file_name) { return directory_find(self, file_name) }
+	collection_trait.push  = function(entry)     { return directory_push(self, entry) }
+	collection_trait.sort  = function()          { return directory_sort(this) }
+	collection_trait.pop   = function(file_name) { return directory_pop(self, file_name) }
+	collection_trait.sort() //the default collection is automatically sorted on directory creation.
+	return collection_trait
 }
 
 const rfwfs = {} as Rfwfs
@@ -140,27 +151,28 @@ rfwfs.is_binary = function(entry) {
 	return entry.type === EntryType.Binary
 }
 
-rfwfs.file = function(default_name, default_permissions, default_timestamp, default_inner) {
+rfwfs.file = async function(default_name, default_permissions, default_timestamp, default_inner = "") {
 	const file = { type: EntryType.File } as EntryFile
-	file.hash = "0"
 	file.permissions = default_permissions
-	file.timestamp = new EntryValue(file, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
+	file.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
-	file.inner     = new EntryValue(file, default_inner ? default_inner : "")
+	file.inner = inner(default_permissions, default_inner)
-	file.name      = new EntryValue(file, default_name)
+	file.name = inner(default_permissions, default_name)
+	file.hash = await hash_table.sha256(default_inner)
 	return file
 }
 
 rfwfs.directory = function<T extends Entry>(default_name: string, default_permissions: Permissions, default_timestamp?: number, default_inner?: T[]): EntryCollection<T> {
 	const directory = { type: EntryType.Directory } as EntryCollection<T>
 	directory.permissions = default_permissions
-	directory.timestamp = new EntryValue(directory, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
+	directory.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
-	directory.inner     = new RfwfsDirectory(directory, default_inner ? default_inner : [])
+	directory.inner = inner(default_permissions, default_inner)
-	directory.name      = new EntryValue(directory, default_name)
+	directory.name = inner(default_permissions, default_name)
 	return directory
 }
 
 export default rfwfs
 export {
+	type EntryCollectionManipulate,
 	type EntryCollection,
 	type FileInner,
 	type EntryFile,