most likely scrapping this idea

i forgor about the permissions system here... maybe users soon for fun..

package.json

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

src/rt/rfwfs/collection.ts

@@ -1,46 +0,0 @@
-import { type Entry } from "./main"
-
-import entry_search from "./index"
-
-type Files<T> = Entry<T>[]
-
-interface EntryCollectionManipulate {
-	pop: <T extends Entry<T>>(file_name: string) => Entry<T> | undefined,
-	get: <T extends Entry<T>>(file_name: string) => Entry<T> | undefined
-	push: <T extends Entry<T>>(entry: Entry<T>) => boolean,
-	sort: () => void,
-}
-interface EntryCollection<T> extends EntryCollectionManipulate {
-	readonly inner: Files<T>
-}
-
-function entry_trait<T extends Entry<T>>() {
-	const trait = {} as EntryCollection<T>
-	trait.sort = function() {
-		this.inner.sort((a,z) => a.name.localeCompare(z.name))
-	}
-	trait.push = function(entry) {
-		const no_duplicates = entry_search(this.inner, entry.name)
-		if (!no_duplicates) {
-			this.push(entry)
-			this.sort()
-			return true
-		}
-		return false
-	}
-	trait.pop = function(file_name) {
-		const file_search = entry_search(this.inner, file_name)
-		if (file_search) {
-			this.inner.splice(file_search.index, 1)
-			return file_search.result
-		}
-		return
-	}
-	return trait
-}
-
-export {
-	entry_trait,
-	type EntryCollection,
-	type Files,
-}

src/rt/rfwfs/enum.ts

@@ -0,0 +1,47 @@
+type ConstEnum = number
+
+const enum EntryType {
+	Directory,
+	Binary,
+	File,
+}
+const enum Permissions {
+	r,
+	w,
+	rw,
+	none,
+}
+const enum PermissionsBinary {
+	r,
+	w,
+	x,
+	rw,
+	rwx,
+	rx,
+	wx,
+	none,
+}
+const enum PushStatus {
+	Ok,
+	Duplicate,
+	Denied,
+}
+const enum ReadStatus {
+	Ok,
+	NotFound,
+	Denied,
+}
+const enum Result {
+	None,
+	Ok,
+}
+
+export {
+	type ConstEnum,
+	PermissionsBinary,
+	Permissions,
+	PushStatus,
+	ReadStatus,
+	EntryType,
+	Result,
+}

src/rt/rfwfs/fs/root.ts

@@ -0,0 +1,41 @@
+import { Permissions } from "../enum"
+
+import rfwfs from "../main"
+
+const time_now = (Date.now()/1000)|0
+
+// ------------ Home ------------
+const config    = rfwfs.directory(".config",   Permissions.rw, time_now)
+const local     = rfwfs.directory(".local",    Permissions.rw, time_now)
+const downloads = rfwfs.directory("Downloads", Permissions.rw, time_now)
+const pictures  = rfwfs.directory("Pictures",  Permissions.rw, time_now)
+const desktop   = rfwfs.directory("Desktop",   Permissions.rw, time_now)
+const videos    = rfwfs.directory("Videos",    Permissions.rw, time_now)
+const music     = rfwfs.directory("Music",     Permissions.rw, time_now)
+
+const user = rfwfs.directory("user", Permissions.r, time_now, [
+	config,
+	local,
+	downloads,
+	pictures,
+	videos,
+	music,
+	desktop,
+])
+
+// /home/
+const home = rfwfs.directory("home", Permissions.r, time_now, [user])
+// ------------
+
+// ------------ root ------------
+const bin  = rfwfs.directory("bin", Permissions.r, time_now)
+const vard = rfwfs.directory("var", Permissions.r, time_now)
+const etc  = rfwfs.directory("etc", Permissions.r, time_now)
+// ------------
+
+export default rfwfs.directory("/", Permissions.r, time_now, [
+	bin,
+	home,
+	vard,
+	etc,
+])

src/rt/rfwfs/hash.ts

@@ -0,0 +1,51 @@
+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("")
+}
+
+const hash_table = { inner: {} } as Hash
+
+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

@@ -1,23 +1,15 @@
 import { type Entry } from "./main"
-import { type Files } from "./collection"
+import { wrap_bsearch, type WrapBSearch } from "./wrap"
 
-interface SearchResult<T> {
-	readonly result: T,
-	readonly index: number
-}
-function wrap_result<T>(result: T, index: number): SearchResult<T> {
-	return { result: result, index: index }
-}
-
-export default function entry_search<T>(cloned_file_collection: Files<T>, file_name: string): SearchResult<Entry<T>> | undefined {
+export default function directory_search<T extends Entry>(entry_collection: T[], file_name: string): WrapBSearch<T> | undefined {
 	let start = 0
-	let end = cloned_file_collection.length-1
+	let end = entry_collection.length-1
 	while (start<=end) {
 		const median = (start+end)>>1
-		const median_name = cloned_file_collection[median].name
+		const median_name = entry_collection[median].name
 
-		if (median_name == file_name) { //left == right && (T == U) is not necessary
-			return wrap_result(cloned_file_collection[median], median)
+		if (median_name === file_name) {
+			return wrap_bsearch(median, entry_collection[median])
 		} else if (median_name<file_name) {
 			start = median+1
 		} else {
@@ -25,4 +17,4 @@ export default function entry_search<T>(cloned_file_collection: Files<T>, file_n
 		}
 	}
 	return undefined
-}
+}

src/rt/rfwfs/main.ts

@@ -1,47 +1,180 @@
-import { type EntryCollection } from "./collection"
+import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum"
+import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
 
-const enum EntryType {
-	Directory,
-	File
-}
-const enum Permissions {
-	r,
-	w,
-	rw,
-	none
-}
+import directory_search from "./index"
+import hash_table from "./hash"
 
-interface Entry<T> {
-	readonly name: string,
+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,
-	readonly inner: T,
-	readonly timestamp: number,
-	readonly collection?: EntryCollection<T>,
-	readonly permissions: Permissions,
+}
+interface EntryFile extends Entry {
+	inner: EntryFileInner,
+	hash: string,
+}
+interface EntryCollection<T extends Entry> extends Entry {
+	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 {
-	new_entry: <T extends Entry<T>>(name: string, permissions: Permissions, timestamp: number, inner: T) => Entry<T>,
-	entry_trait: <T extends Entry<T>>(inner: T) => EntryCollection<T>
-	new_entry_tree: <T>(files: T) => T,
+	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) => 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,
+}
+
+function execute_access<P extends ConstEnum>(permissions: P): boolean {
+	return permissions === PermissionsBinary.rwx
+		|| permissions === PermissionsBinary.rx
+		|| permissions === PermissionsBinary.wx
+		|| permissions === PermissionsBinary.x
+}
+function read_write_access<P extends ConstEnum>(permissions: P): boolean {
+	return permissions === Permissions.rw
+}
+function read_access<P extends ConstEnum>(permissions: P): boolean {
+	return read_write_access(permissions) || permissions === Permissions.r
+}
+function write_access<P extends ConstEnum>(permissions: P): boolean {
+	return read_write_access(permissions) || permissions === Permissions.w
+}
+
+function directory_sort<E extends Entry>(self: EntryCollectionManipulate<E>) {
+	self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
+}
+
+function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> {
+	if (write_access(self.permissions)) {
+		const no_duplicates = directory_search(self.inner.__inner, entry.name.read())
+		if (!no_duplicates) {
+			self.inner.__inner.push(entry)
+			self.inner.__inner.sort()
+			return wrap_none(PushStatus.Ok)
+		}
+		return wrap_none(PushStatus.Duplicate)
+	}
+	return wrap_none(PushStatus.Denied)
+}
+
+function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
+	if (read_access(self.permissions)) {
+		const file_search = directory_search(self.inner.__inner, file_name)
+		if (file_search) {
+			return wrap_entry(ReadStatus.Ok, file_search.result)
+		}
+		return wrap_entry(ReadStatus.NotFound)
+	}
+	return wrap_entry(ReadStatus.Denied)
+}
+
+function directory_pop<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
+	if (read_write_access(self.permissions)) {
+		const pop_find = directory_search(self.inner.__inner, file_name)
+		if (pop_find) {
+			self.inner.__inner.splice(pop_find.some, 1)
+			return wrap_entry(ReadStatus.Ok, pop_find.result)
+		}
+		return wrap_entry(ReadStatus.NotFound)
+	}
+	return wrap_entry(ReadStatus.Denied)
+}
+
+function directory_clone<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
+	if (read_write_access(self.permissions)) {
+		const clone_find = directory_search(self.inner.__inner, file_name)
+		if (clone_find) {
+			return wrap_entry(ReadStatus.Ok, { ...clone_find.result })
+		}
+		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
 
-rfwfs.new_entry = function(name, permissions, timestamp, inner) {
-	const file_type = typeof inner == "object" ? EntryType.Directory : EntryType.File
-	return {
-		name: name,
-		type: file_type,
-		inner: inner,
-		timestamp: timestamp ? timestamp : Math.floor(Date.now()/1000),
-		collection: file_type === EntryType.Directory ? this.entry_trait(inner) : undefined,
-		permissions: permissions,
-	}
+rfwfs.is_dir = function(entry) {
+	return entry.type === EntryType.Directory
+}
+rfwfs.is_file = function(entry) {
+	return entry.type === EntryType.File
+}
+rfwfs.is_binary = function(entry) {
+	return entry.type === EntryType.Binary
 }
 
+rfwfs.file = async function(default_name, default_permissions, default_timestamp, default_inner = "") {
+	const file = { type: EntryType.File } as EntryFile
+	file.permissions = default_permissions
+	file.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
+	file.inner = inner(default_permissions, default_inner)
+	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 = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
+	directory.inner = inner(default_permissions, default_inner)
+	directory.name = inner(default_permissions, default_name)
+	return directory
+}
+
+export default rfwfs
 export {
-	EntryType,
-	Permissions,
+	type EntryCollectionManipulate,
 	type EntryCollection,
+	type FileInner,
+	type EntryFile,
 	type Entry,
 }

src/rt/rfwfs/wrap.ts

@@ -0,0 +1,40 @@
+import { Result, type ConstEnum } from "./enum"
+import { type Entry } from "./main"
+
+type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
+type WrapBSearch<T extends Entry> = WrapResult<T, number>
+type WrapResultNone<T> = WrapResult<Result.None, T>
+
+interface WrapResult<T, U> {
+	/** The resulting value if `U` is a success */
+	readonly result: T,
+	/** Represents some arbitrary extra value, usually a success status */
+	readonly some: U
+}
+
+function wrap<T, U>(result: T, some: U): WrapResult<T, U> {
+	return { result: result, some: some }
+}
+
+function wrap_bsearch<T extends Entry>(index: number, result: T): WrapBSearch<T> {
+	return wrap(result, index)
+}
+
+function wrap_entry<T extends ConstEnum, U extends Entry>(status: T, result?: U): WrapResultEntry<U, T> {
+	return wrap(result, status)
+}
+
+function wrap_none<T extends ConstEnum>(status: T): WrapResultNone<T> {
+	return wrap(Result.None, status)
+}
+
+export default wrap
+export {
+	wrap_bsearch,
+	wrap_entry,
+	wrap_none,
+	type WrapResultEntry,
+	type WrapResultNone,
+	type WrapBSearch,
+	type WrapResult,
+}