the user and group system is basically finished, the fs needs progress on creating entries

`inner` -> `directory`

package.json

@@ -1,17 +1,16 @@
 {
 	"name": "rhpidfyre.io",
-	"private": true,
 	"version": "0.0.1",
+	"private": true,
 	"type": "module",
+	"devDependencies": {
+		"sass": "^1.89.0",
+		"typescript": "^5.8.3",
+		"vite": "^6.3.5"
+	},
 	"scripts": {
 		"dev": "vite",
 		"build": "tsc && vite build",
 		"preview": "vite preview"
-	},
-	"devDependencies": {
-		"sass": "^1.85.1",
-		"typescript": "^5.8.2",
-		"vite": "^6.2.1",
-		"vite-plugin-html": "^3.2.2"
 	}
 }

src/rt/crypto/generate.ts

@@ -0,0 +1,24 @@
+interface SHA256 {
+	readonly secret: string
+}
+
+class Crypto {
+	protected inner: string
+
+	constructor(inner: string) {
+		this.inner = inner
+	}
+
+	public async sha256_hash(): Promise<SHA256> {
+		const encoder = new TextEncoder()
+		const hash = await crypto.subtle.digest("SHA-256", encoder.encode(this.inner))
+		const hash_as_uint8 = new Uint8Array(hash)
+
+		return { secret: Array.from(hash_as_uint8).map(byte => byte.toString(16).padStart(2, "0")).join("") }
+	}
+}
+
+export default Crypto
+export {
+	type SHA256
+}

src/rt/elements/prompt.ts

@@ -1,6 +1,6 @@
 import { cyan, green } from "../shell/color"
-import { get_working_dir_name } from "../rfwfs/library"
 
+import librfwfs, { username } from "../rfwfs/library"
 import create from "./create"
 
 interface Ps1Prompt {
@@ -43,14 +43,20 @@ function ps1_element(user: HTMLSpanElement, dir: HTMLSpanElement) {
 	return display
 }
 
-function working_dir() {
+function working_dir_name() {
-	const dir_name = get_working_dir_name()
+	const dir = librfwfs.home.dir()
-	return dir_name === "user" ? "~" : dir_name
+	if (dir) {
+		const dir_name = dir.name.read()
+		if (dir_name) {
+			return dir_name === username ? "~" : dir_name
+		}
+	}
+	return "?"
 }
 
 function working_dir_element() {
 	const user = cyan("user")
-	const dir = green(" "+working_dir())
+	const dir = green(" "+working_dir_name())
 	return ps1_element(user, dir)
 }
 

src/rt/fs.ts

@@ -0,0 +1,15 @@
+import rfwfs, { PERMISSION_FLAGS } from "./rfwfs/main"
+
+const time_now = (Date.now()/1000) | 0
+const fs = new rfwfs()
+
+const root = fs.push_bulk_unsafe([
+	rfwfs.directory_in_root({
+		permissions: {wheel: PERMISSION_FLAGS.RWX, users: PERMISSION_FLAGS.NONE},
+		timestamp: time_now,
+		metadata: {},
+		name: "bin"
+	})
+])
+
+export default fs

src/rt/rfwfs/enum.ts

@@ -1,47 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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/groups.ts

@@ -0,0 +1,179 @@
+import { ROOT_ID } from "./main";
+
+import wrap, { type WrapResult } from "./wrap";
+import User from "./users";
+
+type User_Index = [User, number]
+type WrapUserSearch = WrapResult<User_Index | undefined, GroupSearch>
+
+type SysGroupsNames = "wheel" | "users"
+
+const enum SysGroups {
+	Wheel,
+	Users,
+}
+const enum UserMoveStatus {
+	Ok,
+	RootBlocked,
+	MovingNonExistentUser,
+	AlreadyInWheel,
+	AlreadyInUsers,
+}
+const enum GroupRemoveStatus {
+	Ok,
+	RootBlocked,
+	RemovingNonExistentUser,
+}
+const enum GroupSearch {
+	NotFound,
+	WheelResult,
+	UsersResult,
+}
+
+interface Groups {
+	wheel: Group,
+	users: Group,
+	together: () => User[]
+}
+
+class Group {
+	protected inner: User[];
+	private group_type: SysGroups;
+
+	constructor(type: SysGroups) {
+		this.group_type = type
+		this.inner = []
+	}
+
+	public users(): User[] {
+		return [...this.inner]
+	}
+	public type(): SysGroups {
+		return this.group_type
+	}
+	public type_as_name(): SysGroupsNames {
+		return this.type() === SysGroups.Wheel ? "wheel" : "users"
+	}
+
+	public add_user(user: User): boolean {
+		const duplicate = this.inner.find(user_in_group => user_in_group.uname() === user.uname())
+		if (!duplicate) {
+			this.inner.push(user)
+			return true
+		}
+		return false
+	}
+
+	public remove_user(user: User): User | undefined {
+		for (let i = 0; i<this.inner.length; i++) {
+			if (this.inner[i].uname() === user.uname()) {
+				this.inner.splice(i, 1)
+				return this.inner[i]
+			}
+		}
+		return undefined
+	}
+}
+
+const groups: Groups = {
+	wheel: new Group(SysGroups.Wheel),
+	users: new Group(SysGroups.Users),
+	together: function() {
+		return [...this.wheel.users(), ...this.users.users()]
+	}
+}
+
+function wrap_user_search(status: GroupSearch, result?: User_Index): WrapUserSearch {
+	return wrap(result, status)
+}
+
+function group_iter_for_user(uname: string, group_t: Group): User_Index | undefined {
+	const group_t_users = group_t.users()
+	for (let i = 0; i<group_t_users.length; i++) {
+		if (group_t_users[i].uname() === uname) {
+			return [group_t_users[i], i]
+		}
+	}
+	return undefined
+}
+
+function groups_find_user(uname: string): WrapUserSearch {
+	const exist_in_wheel = group_iter_for_user(uname, groups.wheel)
+	if (exist_in_wheel) {
+		return wrap_user_search(GroupSearch.WheelResult, exist_in_wheel)
+	}
+	const exist_in_users = group_iter_for_user(uname, groups.users)
+	if (exist_in_users) {
+		return wrap_user_search(GroupSearch.UsersResult, exist_in_users)
+	}
+	return wrap_user_search(GroupSearch.NotFound)
+}
+
+function group_add(new_user: User, group_t: Group): GroupSearch {
+	const dups = groups_find_user(new_user.uname())
+	if (dups.status === GroupSearch.NotFound) {
+		group_t.add_user(new_user)
+	}
+	return dups.status
+}
+
+function group_remove(uname: string, group_t: Group): GroupRemoveStatus {
+	if (uname !== ROOT_ID.NAME) {
+		const found_user = group_t.users().find(user => user.uname() === uname)
+		if (found_user) {
+			group_t.remove_user(found_user)
+			return GroupRemoveStatus.Ok
+		}
+		return GroupRemoveStatus.RemovingNonExistentUser
+	}
+	return GroupRemoveStatus.RootBlocked
+}
+
+function group_user_move(uname: string, new_group: SysGroups): UserMoveStatus {
+	if (uname === ROOT_ID.NAME) { return UserMoveStatus.RootBlocked }
+
+	const find_in_group = groups_find_user(uname)
+	if (find_in_group.status === GroupSearch.NotFound) { return UserMoveStatus.MovingNonExistentUser }
+
+	if (new_group === SysGroups.Wheel) {
+		if (find_in_group.status === GroupSearch.WheelResult) { return UserMoveStatus.AlreadyInWheel }
+
+		groups.wheel.add_user(groups.users.remove_user((find_in_group.result as User_Index)[0]) as User)
+	} else if (new_group === SysGroups.Users) {
+		if (find_in_group.status === GroupSearch.UsersResult) { return UserMoveStatus.AlreadyInUsers }
+
+		groups.users.add_user(groups.wheel.remove_user((find_in_group.result as User_Index)[0]) as User)
+	}
+	return UserMoveStatus.Ok
+}
+
+function group_wheel_add(new_user: User): GroupSearch {
+	return group_add(new_user, groups.wheel)
+}
+
+function group_wheel_remove(uname: string): GroupRemoveStatus {
+	return group_remove(uname, groups.wheel)
+}
+
+function group_users_add(new_user: User): GroupSearch {
+	return group_add(new_user, groups.users)
+}
+
+function group_users_remove(uname: string): GroupRemoveStatus {
+	return group_remove(uname, groups.users)
+}
+
+export default groups
+export {
+	group_wheel_remove,
+	group_users_remove,
+	groups_find_user,
+	group_wheel_add,
+	group_users_add,
+	group_user_move,
+	type SysGroupsNames,
+	GroupRemoveStatus,
+	GroupSearch,
+	SysGroups,
+	Group,
+}

src/rt/rfwfs/hash.ts

@@ -1,51 +0,0 @@
-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,15 +1,19 @@
 import { type Entry } from "./main"
-import { wrap_bsearch, type WrapBSearch } from "./wrap"
+import wrap, { WrapResult } from "./wrap"
 
-export default function directory_search<T extends Entry>(entry_collection: T[], file_name: string): WrapBSearch<T> | undefined {
+function wrap_bsearch<T extends Entry>(index: number, result: T): WrapResult<T, number> {
+	return wrap(result, index)
+}
+
+export default function directory_search<T extends Entry>(dir_files: T[], file_name: string): WrapResult<T, number> | undefined {
 	let start = 0
-	let end = entry_collection.length-1
+	let end = dir_files.length-1
 	while (start<=end) {
 		const median = (start+end)>>1
-		const median_name = entry_collection[median].name
+		const median_name = dir_files[median].name.__inner()
 
 		if (median_name === file_name) {
-			return wrap_bsearch(median, entry_collection[median])
+			return wrap_bsearch(median, dir_files[median])
 		} else if (median_name<file_name) {
 			start = median+1
 		} else {

src/rt/rfwfs/library.ts

@@ -0,0 +1,60 @@
+import { wrap_entry, type WrapResultEntry } from "./wrap"
+import { ReadStatus } from "./enum/status"
+
+import rfwfs, { type DirectoryAny, type EntryCollection, type DirectoryAnyDepth } from "./main"
+import fs from "../fs"
+
+type Path = string[]
+
+interface Home {
+	path: () => Path,
+	dir: () => DirectoryAny | undefined,
+}
+interface Librfwfs {
+	home: Home,
+	traverse_to: (path: Path) => WrapResultEntry<DirectoryAny, ReadStatus>
+	pwd_entry: <T extends EntryCollection<T>>(working_dir: T) => Path | undefined
+}
+
+let username: string = "user"
+
+const librfwfs = {} as Librfwfs
+
+librfwfs.traverse_to = function(path) {
+	let traverse = fs
+
+	for (const path_name of path) {
+		const find = traverse.inner.find(path_name)
+
+		if (find.status === ReadStatus.Ok) {
+			if (find.result && rfwfs.is_dir(find.result)) {
+				traverse = find.result as DirectoryAnyDepth
+			} else {
+				return wrap_entry(ReadStatus.Denied)
+			}
+		} else {
+			return wrap_entry(find.status)
+		}
+	}
+	return wrap_entry(ReadStatus.Ok, traverse)
+}
+
+librfwfs.pwd_entry = function(working_dir) {
+
+}
+
+librfwfs.home = {} as Home
+
+librfwfs.home.path = function() {
+	return ["home", username]
+}
+
+librfwfs.home.dir = function() {
+	const traverse = librfwfs.traverse_to(this.path())
+	return traverse.status === ReadStatus.Ok ? traverse.result : undefined
+}
+
+export default librfwfs
+export {
+	username
+}

src/rt/rfwfs/main.ts

@@ -1,180 +1,395 @@
-import { EntryType, PushStatus, ReadStatus, Permissions, ConstEnum, PermissionsBinary } from "./enum"
+import wrap, { type WrapResult, ConstEnum, Option } from "./wrap"
-import { wrap_entry, wrap_none, WrapResultEntry, WrapResultNone } from "./wrap"
+import { SysGroups } from "./groups"
 
 import directory_search from "./index"
-import hash_table from "./hash"
+import User, { LibUser } from "./users"
 
-type FileInner = string | number
+const enum EntryType {
-type EntryFileInner = EntryValue<FileInner, FileInner | undefined>
+	Root,
-
+	File,
-//please do not change the inner values directly on entries or else there will be catastrophic consequences
+	Directory,
-interface EntryValue<T, U = T> {
+	Binary,
-	__inner: T,
+	SymLink,
-	write: (value: T) => boolean,
-	read: () => U,
 }
-interface Entry {
+const enum PushStatus {
-	permissions: Permissions,
+	Ok,
-	timestamp: EntryValue<number>,
+	Duplicate,
-	name: EntryValue<string>,
+	Denied,
-	readonly type: EntryType,
 }
-interface EntryFile extends Entry {
+const enum ReadStatus {
-	inner: EntryFileInner,
+	Ok,
-	hash: string,
+	NotFound,
+	NotInGroup,
+	Denied,
 }
-interface EntryCollection<T extends Entry> extends Entry {
+const enum ModifyStatus {
-	inner: EntryCollectionManipulate<T>,
+	Ok,
+	NotInGroup,
+	Denied,
 }
-interface EntryCollectionManipulate<T extends Entry> {
+const enum ModifyAccessType {
-	__inner: T[],
+	Read,
-	clone: (file_name: string) => WrapResultEntry<T, ReadStatus>
+	Write,
-	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) => 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 {
+const enum ROOT_ID {
-	return permissions === PermissionsBinary.rwx
+	TRUNK = "/",
-		|| permissions === PermissionsBinary.rx
+	NAME  = "root",
-		|| permissions === PermissionsBinary.wx
+	UID   = 0,
-		|| permissions === PermissionsBinary.x
 }
-function read_write_access<P extends ConstEnum>(permissions: P): boolean {
+const enum PERMISSION_FLAGS {
-	return permissions === Permissions.rw
+	NONE = -1,
-}
+	R    = 1 << 0,
-function read_access<P extends ConstEnum>(permissions: P): boolean {
+	W    = 1 << 1,
-	return read_write_access(permissions) || permissions === Permissions.r
+	X    = 1 << 2,
-}
+	RWX  = PERMISSION_FLAGS.R | PERMISSION_FLAGS.W | PERMISSION_FLAGS.X
-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>) {
+interface Permissions<W = Gate<PERMISSION_FLAGS>, U = Gate<PERMISSION_FLAGS>> {
-	self.__inner.sort((a,z) => a.name.read().localeCompare(z.name.read()))
+	wheel: W,
+	users: U,
+}
+type GroupPermissionsRoot = Permissions<Gate<PERMISSION_FLAGS>, Gate<PERMISSION_FLAGS.NONE>>
+
+interface Metadata {
+	[index: string]: string
 }
 
-function directory_push<E extends Entry>(self: EntryCollection<E>, entry: E): WrapResultNone<PushStatus> {
+interface Entry<
-	if (write_access(self.permissions)) {
+	T extends EntryType = EntryType,
-		const no_duplicates = directory_search(self.inner.__inner, entry.name.read())
+	P extends Permissions = Permissions,
+	N = Gate<string>
+> {
+	readonly type: T,
+	permissions: P,
+	timestamp: Gate<number>,
+	metadata: Gate<Metadata>,
+	group: Gate<SysGroups>,
+	owner: Gate<User>,
+	name: N,
+}
+
+type Directory<T extends Entry> = DirectoryContainer<RfwfsDirectory<T>>
+
+interface DirectoryContainer<T> extends Entry {
+	files: Gate<Entry[]>,
+	parent: Gate<T> | null,
+}
+
+interface Root extends Entry<EntryType.Root, GroupPermissionsRoot, ROOT_ID.TRUNK> {
+	parent: null,
+	files: Gate<Entry[]>,
+}
+
+interface DirectoryInRoot extends Entry<EntryType.Root, Permissions {
+
+}
+
+interface DirectoryInRootProperties {
+	permissions: Permissions<PERMISSION_FLAGS, PERMISSION_FLAGS.NONE>,
+	timestamp: number,
+	metadata: Metadata,
+	name: string,
+}
+
+/** Other directory types that can be treated as a single arbitrary directory.
+
+Do not cast.
+*/
+type DirectoryAssociates<T extends Entry> = Directory<T> | DirectoryInRoot | Root
+/** Other entry types that can be treated as a single arbitrary entry.
+
+Do not cast.
+*/
+type EntryAssociates = Entry | Root
+
+type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
+type WrapResultNone<T>                   = WrapResult<Option.None, T>
+type WrapEntryRead<V>                    = WrapResult<V | undefined, ModifyStatus>
+
+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(Option.None, status)
+}
+
+function wrap_entry_read<V>(status: ModifyStatus, result?: V): WrapEntryRead<V> {
+	return wrap(result, status)
+}
+
+function fs_dir_sort<T extends Entry>(dir: DirectoryAssociates<T>) {
+	dir.files.__inner().sort((a,z) => a.name.__inner().localeCompare(z.name.__inner()))
+}
+
+function fs_dir_clone<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
+	const clone_find = directory_search(dir.files.__inner(), file_name)
+	if (clone_find) {
+		return wrap_entry(ReadStatus.Ok, { ...clone_find.result as T })
+	}
+	return wrap_entry(ReadStatus.NotFound)
+}
+
+function fs_dir_find<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
+	const file_search = directory_search(dir.files.__inner(), file_name)
+	if (file_search) {
+		return wrap_entry(ReadStatus.Ok, file_search.result as T)
+	}
+	return wrap_entry(ReadStatus.NotFound)
+}
+
+function fs_dir_push<T extends Entry>(dir: DirectoryAssociates<T>, entry: Entry) {
+	const no_duplicates = directory_search(dir.files.__inner(), entry.name.__inner())
 	if (!no_duplicates) {
-			self.inner.__inner.push(entry)
+		dir.files.__inner().push(entry)
-			self.inner.__inner.sort()
+		fs_dir_sort(dir)
 		return wrap_none(PushStatus.Ok)
 	}
 	return wrap_none(PushStatus.Duplicate)
 }
+
+function fs_dir_pop<T extends Entry>(dir: DirectoryAssociates<T>, file_name: string): WrapResultEntry<T, ReadStatus> {
+	const pop_find = directory_search(dir.files.__inner(), file_name)
+	if (pop_find) {
+		dir.files.__inner().splice(pop_find.status, 1)
+		return wrap_entry(ReadStatus.Ok, pop_find.result as T)
+	}
+	return wrap_entry(ReadStatus.NotFound)
+}
+
+function user_group_perms(entry: EntryAssociates): PERMISSION_FLAGS | undefined {
+	const user               = LibUser.current_sys_user
+	const current_user_group = user.group()
+
+	if (user.is_root() || current_user_group.type() === entry.group.__inner()) {
+		return entry.permissions[current_user_group.type_as_name()].__inner()
+	}
+	return undefined
+}
+
+function user_group_read_write<T extends Entry>(entry: DirectoryAssociates<T>): ModifyStatus {
+	if (LibUser.current_sys_user.is_root()) {
+		return ModifyStatus.Ok
+	}
+	const group_perms = user_group_perms(entry)
+	if (group_perms) {
+		return LibRfwfs.read_write_access(group_perms) ? ModifyStatus.Ok : ModifyStatus.Denied
+	}
+	return ModifyStatus.NotInGroup
+}
+
+class Gate<V> {
+	private inner: V;
+	protected entry: EntryAssociates;
+
+	constructor(entry: EntryAssociates, value: V) {
+		this.inner = value
+		this.entry = entry
+	}
+
+	private access_read_write(accessType: ModifyAccessType): ModifyStatus {
+		const group_perms = user_group_perms(this.entry)
+		if (group_perms) {
+			switch (accessType) {
+				case ModifyAccessType.Read:
+					return LibRfwfs.read_access(group_perms)  ? ModifyStatus.Ok : ModifyStatus.Denied
+				case ModifyAccessType.Write:
+					return LibRfwfs.write_access(group_perms) ? ModifyStatus.Ok : ModifyStatus.Denied
+			}
+		}
+		return ModifyStatus.NotInGroup
+	}
+
+	public __inner(): V {
+		return this.inner
+	}
+
+	public read(): WrapEntryRead<V> {
+		switch (this.access_read_write(ModifyAccessType.Read)) {
+			case ModifyStatus.Ok:
+				return wrap_entry_read(ModifyStatus.Ok, this.inner)
+			case ModifyStatus.NotInGroup:
+				return wrap_entry_read(ModifyStatus.NotInGroup)
+			case ModifyStatus.Denied:
+				return wrap_entry_read(ModifyStatus.Denied)
+		}
+	}
+
+	public write<T extends V>(new_value: T): ModifyStatus {
+		switch (this.access_read_write(ModifyAccessType.Read)) {
+			case ModifyStatus.Ok:
+				this.inner = new_value
+				return ModifyStatus.Ok
+			case ModifyStatus.NotInGroup:
+				return ModifyStatus.NotInGroup
+			case ModifyStatus.Denied:
+				return ModifyStatus.Denied
+		}
+	}
+}
+
+class RfwfsDirectory<T extends Entry> {
+	public dir: DirectoryAssociates<T>;
+
+	constructor(dir: DirectoryAssociates<T>) {
+		this.dir = dir
+	}
+
+	public sort() {
+		fs_dir_sort(this.dir)
+	}
+
+	public clone(file_name: string): WrapResultEntry<Entry, ReadStatus> {
+		if (user_group_read_write(this.dir)) {
+			return fs_dir_clone(this.dir, file_name)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public find(file_name: string): WrapResultEntry<Entry, ReadStatus> {
+		if (user_group_read_write(this.dir)) {
+			return fs_dir_find(this.dir, file_name)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public push<E extends Entry>(entry: E): WrapResultNone<PushStatus> {
+		if (user_group_read_write(this.dir)) {
+			return fs_dir_push(this.dir, entry)
+		}
 		return wrap_none(PushStatus.Denied)
 	}
 
-function directory_find<E extends Entry>(self: EntryCollection<E>, file_name: string): WrapResultEntry<E, ReadStatus> {
+	public pop(file_name: string): WrapResultEntry<Entry, ReadStatus> {
-	if (read_access(self.permissions)) {
+		if (user_group_read_write(this.dir)) {
-		const file_search = directory_search(self.inner.__inner, file_name)
+			fs_dir_pop(this.dir, 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> {
+	public push_bulk_unsafe(dirs: T[]) {
-	if (read_write_access(self.permissions)) {
+		dirs.forEach(dir => this.dir.files.__inner().push(dir))
-		const pop_find = directory_search(self.inner.__inner, file_name)
+		this.sort()
-		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> {
+	public push_unsafe(dir: T) {
-	if (read_write_access(self.permissions)) {
+		this.dir.files.__inner().push(dir)
-		const clone_find = directory_search(self.inner.__inner, file_name)
+		this.sort()
-		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 {
+class LibRfwfs {
-	return read_access(permissions) ? self.__inner : undefined
+	public static is_root<T extends Entry>(entry: T): boolean {
+		return entry.type === EntryType.Root
 	}
-
+	public static is_dir<T extends Entry>(entry: T): boolean {
-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.is_dir = function(entry) {
 		return entry.type === EntryType.Directory
 	}
-rfwfs.is_file = function(entry) {
+	public static is_file<T extends Entry>(entry: T): boolean {
 		return entry.type === EntryType.File
 	}
-rfwfs.is_binary = function(entry) {
+	public static is_binary<T extends Entry>(entry: T): boolean {
 		return entry.type === EntryType.Binary
 	}
-
+	public static is_symlink<T extends Entry>(entry: T): boolean {
-rfwfs.file = async function(default_name, default_permissions, default_timestamp, default_inner = "") {
+		return entry.type === EntryType.SymLink
-	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> {
+	public static read_access(permissions: PERMISSION_FLAGS): boolean {
-	const directory = { type: EntryType.Directory } as EntryCollection<T>
+		return (permissions & PERMISSION_FLAGS.R) !== 0
-	directory.permissions = default_permissions
+	}
-	directory.timestamp = inner(default_permissions, default_timestamp ? default_timestamp : (Date.now()/1000)|0)
+	public static write_access(permissions: PERMISSION_FLAGS): boolean {
-	directory.inner = inner(default_permissions, default_inner)
+		return (permissions & PERMISSION_FLAGS.W) !== 0
-	directory.name = inner(default_permissions, default_name)
+	}
-	return directory
+	public static execute_access(permissions: PERMISSION_FLAGS): boolean {
+		return (permissions & PERMISSION_FLAGS.X) !== 0
+	}
+	public static read_write_access(permissions: PERMISSION_FLAGS): boolean {
+		return LibRfwfs.read_access(permissions) && LibRfwfs.write_access(permissions)
 	}
 
-export default rfwfs
+	public static directory_in_root(properties: DirectoryInRootProperties): RfwfsDirectory<DirectoryInRoot> {
+		const dir_o = { type: EntryType.Directory } as DirectoryInRoot
+		dir_o.permissions = {
+			wheel: new Gate(dir_o, properties.permissions.wheel),
+			users: new Gate(dir_o, properties.permissions.users),
+		}
+		dir_o.metadata    = new Gate(dir_o, properties.metadata)
+		dir_o.timestamp   = new Gate(dir_o, properties.timestamp)
+		dir_o.files       = new Gate(dir_o, [])
+		dir_o.name        = new Gate(dir_o, properties.name)
+		dir_o.parent      = null
+		return new RfwfsDirectory(dir_o)
+	}
+}
+
+class Rfwfs extends LibRfwfs {
+	public root: Root;
+
+	constructor() {
+		super()
+		this.root = { type: EntryType.Root } as Root
+		this.root.permissions = {
+			wheel: new Gate(this.root, PERMISSION_FLAGS.RWX),
+			users: new Gate(this.root, PERMISSION_FLAGS.NONE)
+		}
+		this.root.timestamp = new Gate(this.root, (Date.now()/1000) | 0)
+		this.root.parent = null
+		this.root.files = new Gate(this.root, [])
+		this.root.name = ROOT_ID.TRUNK
+	}
+
+	public sort() {
+		fs_dir_sort(this.root)
+	}
+
+	public clone(file_name: string): WrapResultEntry<Entry, ReadStatus> {
+		if (user_group_read_write(this.root)) {
+			return fs_dir_clone(this.root, file_name)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public find(file_name: string): WrapResultEntry<Entry, ReadStatus> {
+		if (user_group_read_write(this.root)) {
+			return fs_dir_find(this.root, file_name)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public push<T extends Entry>(entry: T): WrapResultNone<PushStatus> {
+		if (user_group_read_write(this.root)) {
+			return fs_dir_push(this.root, entry)
+		}
+		return wrap_none(PushStatus.Denied)
+	}
+
+	public pop(file_name: string): WrapResultEntry<Entry, ReadStatus> {
+		if (user_group_read_write(this.root)) {
+			fs_dir_pop(this.root, file_name)
+		}
+		return wrap_entry(ReadStatus.Denied)
+	}
+
+	public push_bulk_unsafe(dirs: DirectoryInRoot[]) {
+		dirs.forEach(dir => this.root.files.__inner().push(dir))
+		this.sort()
+	}
+
+	public push_unsafe(dir: DirectoryInRoot) {
+		this.root.files.__inner().push(dir)
+		this.sort()
+	}
+}
+
+export default Rfwfs
 export {
-	type EntryCollectionManipulate,
+	type DirectoryInRoot,
-	type EntryCollection,
+	type RfwfsDirectory,
-	type FileInner,
+	type Directory,
-	type EntryFile,
 	type Entry,
+	PERMISSION_FLAGS,
+	EntryType,
+	ROOT_ID,
 }

src/rt/rfwfs/users.ts

@@ -0,0 +1,182 @@
+import { ROOT_ID } from "./main";
+
+import Crypto, { type SHA256 } from "../crypto/generate";
+import groups, { groups_find_user, GroupSearch, SysGroups, Group } from "./groups";
+
+const enum UserSet {
+	Ok,
+	AlreadyLoggedIn,
+	UserDoesNotExist,
+}
+const enum PasswordCheckStatus {
+	Ok,
+	MinBound,
+	MaxBound,
+}
+const enum PasswordSetStatus {
+	Ok,
+	RootRequiresPassword,
+	MinBound,
+	MaxBound,
+	Incorrect,
+}
+const enum SetUnameStatus {
+	Ok,
+	CantChangeRootName,
+	NotFound,
+	WheelResult,
+	UsersResult,
+}
+
+const enum PASS_BOUNDS {
+	MIN = 4,
+	MAX = 1 << 12, //64 ^ 2
+}
+
+let uid_count: number = 0
+
+class LibUser {
+	public static current_sys_user: User;
+
+	public static get_sys_user(): User {
+		return groups.together().find(user => user.is_logged_in()) as User
+	}
+
+	public static set_sys_user(uname: string): UserSet {
+		const found_user    = groups_find_user(uname)
+		const result_user_i = found_user.result
+		if (!result_user_i)                  { return UserSet.UserDoesNotExist }
+		if (result_user_i[0].is_logged_in()) { return UserSet.AlreadyLoggedIn }
+
+		LibUser.current_sys_user = result_user_i[0]
+		return UserSet.Ok
+	}
+
+	public static in_password_bounds(password: string): PasswordCheckStatus {
+		//Math.min(Math.max(PASS_BOUNDS.MIN, password.length), PASS_BOUNDS.MAX) < PASS_BOUNDS.MAX
+		if (password.length > PASS_BOUNDS.MIN) {
+			if (password.length < PASS_BOUNDS.MAX) {
+				return PasswordCheckStatus.Ok
+			}
+			return PasswordCheckStatus.MaxBound
+		}
+		return PasswordCheckStatus.MinBound
+	}
+}
+
+class User {
+	private inner_password?: SHA256;
+	private inner_group: Group;
+	private inner_name: string;
+	private inner_uid: number;
+	private current: boolean;
+
+	constructor(name: string, group: Group, password?: SHA256) {
+		const root_creation = name === ROOT_ID.NAME
+		if (root_creation) {
+			this.inner_uid = 0
+			this.inner_group = group
+		} else {
+			uid_count += 1
+			this.inner_uid = uid_count
+			this.inner_group = group
+		}
+
+		this.inner_name = name
+		this.current = root_creation
+		this.inner_password = password
+	}
+
+	private set_as_current(): boolean {
+		LibUser.get_sys_user().current = false
+		LibUser.current_sys_user = this
+		this.current = true
+		return this.current
+	}
+
+	public is_logged_in(): boolean {
+		return this.current
+	}
+	public in_wheel(): boolean {
+		return this.inner_group.type() === SysGroups.Wheel
+	}
+	public password(): SHA256 | undefined {
+		return this.inner_password
+	}
+	public is_root(): boolean {
+		return this.inner_name === ROOT_ID.NAME && this.inner_uid === ROOT_ID.UID
+	}
+	public group(): Group {
+		return this.inner_group
+	}
+	public uname(): string {
+		return this.inner_name
+	}
+	public uid(): number {
+		return this.inner_uid
+	}
+
+	public async check_password(password?: string): Promise<boolean> {
+		if (!(password && this.inner_password) || (await new Crypto(password).sha256_hash()).secret === this.inner_password.secret) {
+			return true
+		}
+		return false
+	}
+
+	public async login(password?: string): Promise<boolean> {
+		if (!this.inner_password || (password && await this.check_password(password))) {
+			return this.set_as_current()
+		}
+		return false
+	}
+
+	public set_uname(new_uname: string): SetUnameStatus {
+		if (this.is_root()) { return SetUnameStatus.CantChangeRootName }
+
+		const search = groups_find_user(new_uname)
+		switch (search.status) {
+			case GroupSearch.NotFound:
+				this.inner_name = new_uname
+				break
+			case GroupSearch.UsersResult:
+				return SetUnameStatus.UsersResult
+			case GroupSearch.WheelResult:
+				return SetUnameStatus.WheelResult
+		}
+		return SetUnameStatus.Ok
+	}
+
+	public async set_password(current_password: string, new_password?: string): Promise<PasswordSetStatus> {
+		if (await this.check_password(current_password)) {
+			if (new_password) {
+				switch (LibUser.in_password_bounds(new_password)) {
+					case PasswordCheckStatus.Ok:
+						this.inner_password = await new Crypto(new_password).sha256_hash()
+						break
+					case PasswordCheckStatus.MinBound:
+						return PasswordSetStatus.MinBound
+					case PasswordCheckStatus.MaxBound:
+						return PasswordSetStatus.MaxBound
+				}
+			} else {
+				if (this.is_root()) { return PasswordSetStatus.RootRequiresPassword }
+				//This user has no password
+				this.inner_password = undefined
+			}
+			return PasswordSetStatus.Ok
+		}
+		return PasswordSetStatus.Incorrect
+	}
+}
+
+groups.wheel.add_user(
+	new User(ROOT_ID.NAME, groups.wheel, { secret: "90a956efae97cca5ec584977d96a236aa76b0a07def9fcafab87fd221a1d2cfe" })
+)
+groups.users.add_user(
+	new User("user", groups.users)
+)
+
+export default User
+export {
+	LibUser
+}

src/rt/rfwfs/wrap.ts

@@ -1,40 +1,24 @@
-import { Result, type ConstEnum } from "./enum"
+const enum Option {
-import { type Entry } from "./main"
+	None,
+	Some,
+}
 
-type WrapResultEntry<T extends Entry, U> = WrapResult<T | undefined, U>
+type ConstEnum = number
-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 */
+	/** The resulting value if `U` is a success status */
 	readonly result: T,
-	/** Represents some arbitrary extra value, usually a success status */
+	/** Represents some arbitrary extra value, usually a status */
-	readonly some: U
+	readonly status: U,
 }
 
 function wrap<T, U>(result: T, some: U): WrapResult<T, U> {
-	return { result: result, some: some }
+	return { result: result, status: 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,
+	type ConstEnum,
+	Option,
 }

src/rt/shell/command/builtin/cd.ts

@@ -1,10 +1,11 @@
-import { set_working_dir, SetDirStatus } from "../../../rfwfs/library"
+import { ReadStatus } from "../../../rfwfs/enum"
 import type { Args, Term } from "../list"
 
+import lib from "../../../rfwfs/library"
 import stdout from "../../../elements/stdout"
 
 export default function cd(term: Term, args: Args): boolean {
-	const new_dir_status = set_working_dir(args[1])
+	const new_dir_status = lib.traverse_to(args)
 
 	if (new_dir_status === SetDirStatus.NotADirectory) {
 		term.appendChild(stdout(`cd: "${args[1]}" is not a directory`))

tsconfig.json

@@ -16,6 +16,7 @@
     /* Linting */
     "strict": true,
     "noUnusedLocals": true,
+    "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true,
     "noImplicitAny": true,

vite.config.js

@@ -1,10 +1,6 @@
 import { defineConfig } from 'vite'
-import { createHtmlPlugin } from 'vite-plugin-html'
 
 export default defineConfig({
-	plugins: [
-		createHtmlPlugin({minify: true}),
-	],
 	root: "src",
 	build: {
 		outDir: "../dist"