not necessary bro

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

Dockerfile

@@ -2,7 +2,7 @@ FROM oven/bun AS builder
 
 WORKDIR /rhpidfyre.io
 
-COPY ../packages/web/src ../packages/web/package.json ../packages/web/vite.config.js ../packages/web/tsconfig.json ./
+COPY src package.json vite.config.js tsconfig.json ./
 
 RUN bun run install
 RUN bun run build --emptyOutDir

package.json

@@ -1,7 +1,17 @@
 {
-    "name": "rhpidfyre.io",
+	"name": "rhpidfyre.io",
-    "private": true,
+	"private": true,
-    "workspace": [
+	"version": "0.0.1",
-        "packages/*"
+	"type": "module",
-    ]
+	"scripts": {
-}
+		"dev": "vite",
+		"build": "tsc && vite build",
+		"preview": "vite preview"
+	},
+	"devDependencies": {
+		"sass": "^1.85.1",
+		"typescript": "^5.8.2",
+		"vite": "^6.2.2",
+		"vite-plugin-html": "^3.2.2"
+	}
+}

packages/rfwfs/LICENSE

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2025 rhpidfyre
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

packages/rfwfs/package.json

@@ -1,9 +0,0 @@
-{
-	"name": "@rhpidfyre.io/rfwfs",
-	"private": true,
-	"version": "0.0.1",
-	"type": "module",
-	"devDependencies": {
-		"typescript": "^5.7.3",
-	}
-}

packages/rfwfs/src/core.ts

@@ -1,20 +0,0 @@
-import rfwfs_search from "./index"
-import rfwfs_entry_trait, {EntryType, type Entry, type EntryTree} from "./entry"
-
-
-
-function Entry<T = File>(name: string, inner: T, permissions: Permissions): Entry<T> {
-	return {
-		type: typeof inner == "object" ? EntryType.Directory : EntryType.File,
-		inner: inner,
-		name: name,
-		permissions: permissions,
-		timestamp: Math.floor(Date.now()/1000)
-	}
-}
-
-export {
-	EntryType,
-	Permissions,
-	Entry
-}

packages/rfwfs/src/entry.ts

@@ -1,89 +0,0 @@
-import rfwfs_search from "./index"
-
-const enum EntryType {
-	Directory,
-	File
-}
-
-const enum Permissions {
-	r,
-	w,
-	rw,
-	none
-}
-
-type Files<T> = Entry<T>[]
-type File = string
-
-interface EntryListManipulate {
-	push: <T extends Entry<T>>(entry: Entry<T>) => boolean,
-	pop: <T extends Entry<T>>(file_name: string) => Entry<T> | undefined,
-	sort: () => void,
-}
-
-interface EntryList<T> extends EntryListManipulate {
-	readonly tree: Files<T>
-}
-
-interface Entry<T = File> {
-	readonly inner: EntryList<T>,
-	readonly name: string,
-	readonly type: EntryType,
-	readonly timestamp: number,
-	readonly permissions: Permissions,
-}
-
-function rfwfs_entry_trait<T extends Entry<T>>(): EntryList<T> {
-	const trait = {} as EntryList<T>
-	trait.sort = function() {
-		this.tree.sort((a,z) => a.name.localeCompare(z.name))
-	}
-	trait.push = function(entry) {
-		const no_duplicates = rfwfs_search.binary_fs_name(this.tree, entry.name)
-		if (!no_duplicates) {
-			this.tree.push(entry)
-			this.sort()
-			return true
-		}
-		return false
-	}
-	trait.pop = function(file_name) {
-		const file_search = rfwfs_search.binary_fs_name(this.tree, file_name)
-		if (file_search) {
-			this.tree.splice(file_search.binary_index, 1)
-			return file_search.item
-		}
-		return
-	}
-	return trait
-}
-
-function rfwfs_new_entry_tree<T>(files: Files<T>) {
-
-}
-
-function rfwfs_new_entry<T extends EntryList<T>>(
-	name: string,
-	inner: T,
-	permissions: Permissions,
-	timestamp: number = Math.floor(Date.now()/1000)
-): Entry<T> {
-	return {
-		type: typeof inner == "object" ? EntryType.Directory : EntryType.File,
-		timestamp: timestamp,
-		name: name,
-		permissions: permissions,
-		inner: inner,
-	}
-}
-
-export {
-	rfwfs_entry_trait,
-	rfwfs_new_entry,
-	EntryType,
-	Permissions,
-	type EntryList,
-	type Entry,
-	type Files,
-	type File,
-}

packages/rfwfs/src/index.ts

@@ -1,77 +0,0 @@
-import { type Entry, type Files } from "./entry"
-
-interface SearchResult<T> {
-	item: T,
-	binary_index: number
-}
-interface Search {
-	binary_fs_name: <T extends Entry<T>>(cloned_list: Files<T>, file_name: string) => SearchResult<Entry<T>> | undefined,
-	binary_nsort: <T>(list: T[], find: T, start?: number, end?: number) => SearchResult<T> | undefined,
-	binary: <T>(list: T[], find: T) => SearchResult<T> | undefined,
-	linear: <T>(list: T[], find: T) => SearchResult<T> | undefined,
-}
-
-function wrap_result<T>(item: T, binary_index: number): SearchResult<T> {
-	return { item: item, binary_index: binary_index }
-}
-
-const rfwfs_search = {} as Search
-
-rfwfs_search.binary = function(list, find) {
-	list.sort()
-	let start = 0
-	let end = list.length-1
-	while (start<=end) {
-		const median = (start+end)>>1
-		if (list[median] === find) {
-			return wrap_result(list[median], median)
-		} else if (list[median]<find) {
-			start = median+1
-		} else {
-			end = median-1
-		}
-	}
-	return
-}
-
-rfwfs_search.binary_nsort = function(list, find, start = 0, end = list.length-1) {
-	if (start>end) { return }
-	const median = (start+end)>>1
-	if (list[median] === find) {
-		return wrap_result(list[median], median)
-	}
-	if (list[median]>find) {
-		return this.binary_nsort(list, find, start, median-1)
-	} else {
-		return this.binary_nsort(list, find, median+1, end)
-	}
-}
-
-rfwfs_search.binary_fs_name = function(cloned_entry_list, file_name) {
-	let start = 0
-	let end = cloned_entry_list.length-1
-	while (start<=end) {
-		const median = (start+end)>>1
-		const median_name = cloned_entry_list[median].name
-
-		if (median_name === file_name) {
-			return wrap_result(cloned_entry_list[median], median)
-		} else if (median_name<file_name) {
-			start = median+1
-		} else {
-			end = median-1
-		}
-	}
-	return
-}
-
-rfwfs_search.linear = function(list, find) {
-	for (let ind = 0; ind<list.length; ind++) {
-		if (list[ind] === find) {
-			return wrap_result(list[ind], ind)
-		}
-	}
-	return
-}
-
-export default rfwfs_search

packages/rfwfs/src/library.ts

@@ -1,85 +0,0 @@
-import { type FsDirectory, type FsEntry } from "./core"
-
-import fstree from "./tree"
-import index from "./index"
-
-let cached_dir = fstree[0] //start at root
-let working_path = ["/", "home", "user"]
-
-const clone_working_path = () => [...working_path]
-
-function get_working_dir_name() {
-	return working_path[working_path.length-1]
-}
-
-function get_working_dir_name_full(): string {
-	const w_dir_clone = clone_working_path()
-	const root = w_dir_clone.shift()
-	if (root) {
-		return root+w_dir_clone.join("/")
-	}
-	return "shift-error"
-}
-
-const enum SetDirStatus {
-	Valid,
-	NotFound,
-	NotADirectory,
-	Invalid
-}
-interface FsIterEntry {
-	readonly entry: FsDirectory | null,
-	readonly status: SetDirStatus
-}
-function find_fs_dir(working_dir_path_clone: string[], find_dir_name: string): FsIterEntry {
-	let cached_dir_clone = cached_dir.inner
-
-	for (let path_i = 0; path_i<working_dir_path_clone.length; path_i++) {
-		if (cached_dir_clone) {
-			let cached_dir_file_names: string[] = []
-			cached_dir_clone.forEach((file, file_i) => cached_dir_file_names.push(file.name))
-
-			const search_result = index.binary(cached_dir_clone, fstree[0])
-
-			if (working_dir_path_clone[path_i] === find_dir_name) {
-				cached_dir_clone = cached_dir_clone
-				if (path_i === working_dir_path_clone.length) {
-					const search_result = index.binary(cached_dir_file_names, find_dir_name)
-					if (search_result) {
-
-					}
-				} else {
-					continue
-				}
-			}
-		}
-		return { entry: null, status: SetDirStatus.Invalid }
-	}
-	return { entry: null, status: SetDirStatus.NotFound }
-}
-
-function set_working_dir(name: string): SetDirStatus {
-	if (name === ".") { return SetDirStatus.Valid }
-
-	const w_dir_clone = clone_working_path()
-	if (name === "..") {
-		w_dir_clone.pop()
-
-	} else {
-		w_dir_clone.push(name)
-	}
-
-
-}
-
-function get_working_dir_entries(): FsEntry[] {
-
-}
-
-export {
-	get_working_dir_name,
-	get_working_dir_name_full,
-	get_working_dir_entries,
-	set_working_dir,
-	SetDirStatus
-}

packages/rfwfs/src/tree.ts

@@ -1,19 +0,0 @@
-import { Entry, Permissions } from "./core"
-
-const user = [
-	Entry("about_me.txt", "about me inside", Permissions.rw),
-	Entry("services.txt", "services inside", Permissions.rw),
-	Entry("hi", [], Permissions.rw)
-]
-const home = [
-	Entry("user", user, Permissions.rw)
-]
-const root = [
-	Entry("home", home, Permissions.r),
-	Entry("bin", {}, Permissions.r),
-]
-const fstree = [
-	Entry("/", root, Permissions.r)
-]
-
-export default fstree

packages/web/package.json

@@ -1,17 +0,0 @@
-{
-	"name": "@rhpidfyre.io/web",
-	"private": true,
-	"version": "0.0.1",
-	"type": "module",
-	"scripts": {
-		"dev": "vite",
-		"build": "tsc && vite build",
-		"preview": "vite preview"
-	},
-	"devDependencies": {
-		"sass": "^1.85.1",
-		"typescript": "^5.7.3",
-		"vite": "^6.2.0",
-		"vite-plugin-html": "^3.2.2"
-	}
-}

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,11 @@
+async function hash(inner_as_string: 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("")
+}
+
+export default async function generate_sha256(inner_as_string: string) {
+	const sha256 = await hash(inner_as_string)
+	return sha256
+}

src/rt/rfwfs/index.ts

@@ -0,0 +1,20 @@
+import { type Entry } from "./main"
+import { wrap_bsearch, type WrapBSearch } from "./wrap"
+
+export default function directory_search<T extends Entry>(entry_collection: T[], file_name: string): WrapBSearch<T> | undefined {
+	let start = 0
+	let end = entry_collection.length-1
+	while (start<=end) {
+		const median = (start+end)>>1
+		const median_name = entry_collection[median].name
+
+		if (median_name === file_name) {
+			return wrap_bsearch(median, entry_collection[median])
+		} else if (median_name<file_name) {
+			start = median+1
+		} else {
+			end = median-1
+		}
+	}
+	return undefined
+}

src/rt/rfwfs/main.ts

@@ -0,0 +1,168 @@
+import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum"
+import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
+
+import directory_search from "./index"
+
+type FileInner = string | number
+
+interface Entry {
+	permissions: Permissions,
+	timestamp: EntryValue<number>,
+	name: EntryValue<string>,
+	readonly type: EntryType,
+}
+
+interface EntryFile extends Entry {
+	inner: EntryValue<FileInner>,
+	hash: string,
+}
+
+interface EntryCollection<T extends Entry> extends Entry {
+	inner: RfwfsDirectory<T>,
+}
+
+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,
+	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
+}
+
+class EntryValue<T> {
+	public inner: T;
+	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> {
+	public inner: T[];
+	protected entry: Entry
+
+	constructor(entry: Entry, inner: T[]) {
+		this.inner = inner
+		this.entry = entry
+	}
+
+	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)
+	}
+
+	public find(file_name: string): WrapResultEntry<T, ReadStatus> {
+		if (read_write_access(this.entry.permissions)) {
+			const file_search = directory_search(this.inner, file_name)
+			if (file_search) {
+				return wrap_entry(ReadStatus.Ok, file_search.result)
+			}
+			return wrap_entry(ReadStatus.NotFound)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public push<E extends T>(entry: E): WrapResultNone<PushStatus> {
+		if (read_write_access(this.entry.permissions)) {
+			const no_duplicates = directory_search(this.inner, entry.name.inner)
+			if (!no_duplicates) {
+				this.inner.push(entry)
+				this.inner.sort()
+				return wrap_none(PushStatus.Ok)
+			}
+			return wrap_none(PushStatus.Duplicate)
+		}
+		return wrap_none(PushStatus.Denied)
+	}
+
+	public pop(file_name: string): WrapResultEntry<T, ReadStatus> {
+		if (read_write_access(this.entry.permissions)) {
+			const pop_find = directory_search(this.inner, file_name)
+			if (pop_find) {
+				this.inner.splice(pop_find.some, 1)
+				return wrap_entry(ReadStatus.Ok, pop_find.result)
+			}
+			return wrap_entry(ReadStatus.NotFound)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+}
+
+const rfwfs = {} as Rfwfs
+
+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 = 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.inner     = new EntryValue(file, default_inner ? default_inner : "")
+	file.name      = new EntryValue(file, default_name)
+	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.inner     = new RfwfsDirectory(directory, default_inner ? default_inner : [])
+	directory.name      = new EntryValue(directory, default_name)
+	return directory
+}
+
+export default rfwfs
+export {
+	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,
+}