--emptyOutDir for silenting a build warning

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.0",
+		"typescript": "^5.7.3",
+		"vite": "^6.1.1",
+		"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"
-	}
-}

packages/web/src/rt/shell/color.ts

@@ -1,37 +0,0 @@
-import create from "../elements/create"
-
-const enum Colors {
-	red   = "red",
-	green = "green",
-	blue  = "blue",
-	cyan  = "cyan",
-	bold  = "bold"
-}
-function newcolor(inner: string, color?: Colors, bold?: boolean) {
-	const span = create("span", color)
-	span.innerText = inner
-	if (bold) {
-		span.className = color ? color+" bold" : "bold"
-	}
-	return span
-}
-
-const red   = (s: string, bold?: boolean) => newcolor(s, Colors.red,   bold)
-const green = (s: string, bold?: boolean) => newcolor(s, Colors.green, bold)
-const blue  = (s: string, bold?: boolean) => newcolor(s, Colors.blue,  bold)
-const cyan  = (s: string, bold?: boolean) => newcolor(s, Colors.cyan,  bold)
-const bold  = (s: string)                 => newcolor(s, Colors.bold)
-
-export default function rgb(s: string, Ru8: number, Gu8: number, Bu8: number, bold?: boolean) {
-	const rgb_span = newcolor(s, undefined, bold)
-	rgb_span.style.color = `rgb(${Ru8},${Gu8},${Bu8})`
-	return rgb_span
-}
-
-export {
-	red,
-	green,
-	blue,
-	cyan,
-	bold
-}

packages/web/src/rt/shell/command/builtin/ls.ts

@@ -1,30 +0,0 @@
-import type { Args, Term } from "../list";
-import { blue } from "../../color";
-import { get_working_dir_entries } from "../../../rfwfs/library";
-import { EntryType, FsEntry } from "../../../rfwfs/core";
-
-import stdout, { stdout_horizontal_elements } from "../../../elements/stdout";
-import create from "../../../elements/create";
-
-const element_collection = <T extends HTMLElement>(): T[] => []
-
-function show_directory(entry: FsEntry) {
-	const p = create("p")
-	p.append(blue(entry.name, true), "/")
-	return p
-}
-
-export default function ls(term: Term, args: Args): boolean {
-	const ls_elements = element_collection()
-	if (args[1] === undefined) {
-		get_working_dir_entries().forEach(entry => {
-			if (entry.type === EntryType.Directory) {
-				ls_elements.push(show_directory(entry))
-			} else if (entry.type === EntryType.File) {
-				ls_elements.push(stdout(entry.name))
-			}
-		})
-	}
-	term.appendChild(stdout_horizontal_elements(ls_elements))
-	return true
-}

src/index.html

@@ -1,5 +1,5 @@
 <!doctype html>
-<html>
+<html lang="en">
 <head>
 	<meta charset="UTF-8"/>
 	<meta name="viewport" content="width=device-width"/>
@@ -56,6 +56,6 @@
 			</style>
 		</noscript>
 	</footer>
-	<script type="module" src="./rt/emulator/terminal.ts"></script>
+	<script type="module" src="./rt/terminal.ts"></script>
 </body>
 </html>

src/rt/elements/prompt.ts

@@ -1,5 +1,5 @@
 import { cyan, green } from "../shell/color"
-import { get_working_dir_name } from "../rfwfs/library"
+import { get_working_dir_name } from "../shell/fs/fn"
 
 import create from "./create"
 

src/rt/elements/stdout.ts

@@ -26,12 +26,6 @@ function stdout_grid<T extends HTMLElement>(left: string[], right: string[], hea
 	return wrap_indicator
 }
 
-function stdout_horizontal_elements<T extends HTMLElement>(elements: T[]) {
-	const h_elements_out = horizontal()
-	h_elements_out.append(...elements)
-	return h_elements_out
-}
-
 function stdout_horizontal(strs: string[]) {
 	const p = create("p")
 	strs.forEach((str, i) => {
@@ -54,8 +48,7 @@ export default function stdout(str: string) {
 }
 
 export {
-	stdout_horizontal_elements,
-	stdout_horizontal,
 	stdout_grid,
+	stdout_horizontal,
 	stdout_bold
 }

src/rt/keys.ts

@@ -1,5 +1,5 @@
-import run from "../shell/command/command"
+import run from "./shell/command/command"
-import history from "../shell/history"
+import history from "./shell/history"
 
 type InputClosure = (key_event: KeyboardEvent) => void
 interface EnterArgs {

src/rt/shell/color.ts

@@ -0,0 +1,34 @@
+import create from "../elements/create"
+
+const enum Colors {
+	red   = "red",
+	green = "green",
+	blue  = "blue",
+	cyan  = "cyan",
+	bold  = "bold"
+}
+function newcolor(inner: string, color?: Colors) {
+	const span = create("span", color)
+	span.innerText = inner
+	return span
+}
+
+const red   = (s: string) => newcolor(s, Colors.red )
+const green = (s: string) => newcolor(s, Colors.green)
+const blue  = (s: string) => newcolor(s, Colors.blue)
+const cyan  = (s: string) => newcolor(s, Colors.cyan)
+const bold  = (s: string) => newcolor(s, Colors.bold)
+
+export default function rgb(s: string, Ru8: number, Gu8: number, Bu8: number) {
+	const rgb_span = newcolor(s)
+	rgb_span.style.color = `rgb(${Ru8},${Gu8},${Bu8})`
+	return rgb_span
+}
+
+export {
+	red,
+	green,
+	blue,
+	cyan,
+	bold
+}

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

@@ -1,15 +1,13 @@
-import { set_working_dir, SetDirStatus } from "../../../rfwfs/library"
+import { set_working_dir, SetDirStatus } from "../../fs/fn"
 import type { Args, Term } from "../list"
 
-import stdout from "../../../elements/stdout"
-
 export default function cd(term: Term, args: Args): boolean {
 	const new_dir_status = set_working_dir(args[1])
 
 	if (new_dir_status === SetDirStatus.NotADirectory) {
-		term.appendChild(stdout(`cd: "${args[1]}" is not a directory`))
+		// return <p>{"cd: \""}{bold(args[1])}{"\" is not a directory"}</p>
 	} else if (new_dir_status === SetDirStatus.NotFound) {
-		term.appendChild(stdout(`cd: The directory "${args[1]}" does not exist`))
+		// return <p>{"cd: The directory \""}{bold(args[1])}{"\" does not exist"}</p>
 	}
 	return true
 }

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

@@ -7,7 +7,7 @@ import history from "../../history";
 const history_command = new SubCommand("Show and manipulate command history")
 
 history_command.add("show", "Show the history", function(term: Term, _args: Args) {
-	history.file.inner.forEach((entry, ind) => term.appendChild(stdout(`${ind+1} ${entry}`)))
+	history.file.inner.forEach((entry, ind) => term.appendChild(stdout(`${ind} ${entry}`)))
 })
 
 history_command.add("clear", "Delete the entire command history", function(term: Term, _args: Args) {

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

@@ -0,0 +1,11 @@
+import type { Args, Term } from "../list";
+
+export default function ls(term: Term, args: Args): boolean {
+	// if (args[1] === undefined) {
+	// 	for (const dir_name in working_dir) {
+
+	// 	}
+	// 	return <p>{`${working_dir}`}</p>
+	// }
+	return true
+}

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

@@ -1,4 +1,4 @@
-import { get_working_dir_name_full } from "../../../rfwfs/library";
+import { get_working_dir_name_full } from "../../fs/fn";
 import type { Args, Term } from "../list";
 
 import stdout from "../../../elements/stdout";

src/rt/shell/fs/fn.ts

@@ -0,0 +1,75 @@
+import { EntryType, fs, type FsEntrySignature } from "./fs"
+
+let working_dir = ["/", "home", "user"]
+
+function get_working_dir_name() {
+	return working_dir[working_dir.length-1]
+}
+
+function get_working_dir_name_full(): string {
+	const w_dir_clone = [...working_dir]
+	const root = w_dir_clone.shift()
+	if (root) {
+		return root+w_dir_clone.join("/")
+	}
+	return "shift-error"
+}
+
+const enum SetDirStatus {
+	Valid,
+	NotFound,
+	NotADirectory
+}
+interface FsIterEntry {
+	readonly entry: FsEntrySignature | null,
+	readonly status: SetDirStatus
+}
+function iter_fs_to_goal(w_dir_clone: string[]): FsIterEntry {
+	let next_iter = fs[0]
+
+	for (const w_dir of w_dir_clone) {
+		if (w_dir === "/") { continue }
+		if (next_iter && next_iter.inner) {
+			const found = next_iter.inner.find(entry => entry.name === w_dir)
+
+			if (!found) {
+				return { entry: null, status: SetDirStatus.NotFound }
+			}
+			if (found.type !== EntryType.Directory) {
+				return { entry: null, status: SetDirStatus.NotADirectory }
+			}
+			if (found.name === w_dir_clone[w_dir_clone.length-1]) {
+				return { entry: next_iter, status: SetDirStatus.Valid }
+			} else {
+				next_iter = found.inner as FsEntrySignature
+			}
+		}
+	}
+	return { entry: null, status: SetDirStatus.NotFound }
+}
+
+function set_working_dir(name: string): SetDirStatus {
+	if (name === ".") { return SetDirStatus.Valid }
+
+	const w_dir_clone = [...working_dir]
+	if (name === "..") { w_dir_clone.pop() } else { w_dir_clone.push(name) }
+
+	const iter_status = iter_fs_to_goal(w_dir_clone)
+	if (iter_status.status === SetDirStatus.Valid) {
+		working_dir = w_dir_clone
+	}
+	return iter_status.status
+}
+
+function working_dir_entries() {
+	const w_dir_clone = [...working_dir]
+	const iter_status = iter_fs_to_goal(w_dir_clone)
+
+}
+
+export {
+	get_working_dir_name,
+	get_working_dir_name_full,
+	set_working_dir,
+	SetDirStatus
+}

src/rt/shell/fs/fs.ts

@@ -0,0 +1,51 @@
+const enum EntryType {
+	Directory,
+	File
+}
+const enum Permissions {
+	r,
+	w,
+	rw
+}
+
+type FsEntrySignature = Entry<Entry<{}>[]> //I did this!
+
+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 fs = [
+	Entry("/", root, Permissions.r)
+]
+
+type File = string
+interface Entry<T = File> {
+	readonly inner?: T,
+	readonly name: string,
+	readonly type: EntryType,
+	readonly permissions: Permissions
+}
+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
+	}
+}
+
+export {
+	fs,
+	type FsEntrySignature,
+	EntryType,
+	Permissions,
+	Entry
+}

src/rt/terminal.ts

@@ -1,5 +1,5 @@
-import history from "../shell/history"
+import history from "./shell/history"
-import prompt from "../elements/prompt"
+import prompt from "./elements/prompt"
 import keys from "./keys"
 
 const term_win_unsafe = document.querySelector("main")

src/scss/elements/terminal.scss

@@ -1,5 +1,3 @@
-@use "../variables.scss";
-
 @mixin text-styles {
 	.red   { color: rgb(var(--color-red)) }
 	.green { color: rgb(var(--color-green)) }
@@ -32,13 +30,17 @@
 @mixin formatting {
 	@include stdout-layouts;
 	@include term-elements;
-	@include text-styles;
 
-	p, a, span {
-		font-size: variables.$default-font-size
-	}
 	p {
+		@include text-styles;
+
+		font-size: 1.2rem;
 		margin: 5px;
-		a:hover { text-decoration: underline; }
+
+		span { font-size: inherit; }
+		a {
+			font-size: inherit;
+			&:hover { text-decoration: underline; }
+		}
 	}
 }

src/scss/variables.scss

@@ -1,5 +1,3 @@
-$default-font-size: 1.2rem;
-
 $header-Y: 30px;
 $footer-Y: 30px;
 $component-padding: 20px;