functionalscript 0.16.0 → 0.17.0

package/fs/djs/transpiler/test.f.js

@@ -1,17 +1,16 @@
 import { sort } from "../../types/object/module.f.js";
-import { setReplace } from "../../types/ordered_map/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-import { createVirtualIo } from "../../io/virtual/module.f.js";
-import { encodeUtf8 } from "../../types/uint8array/module.f.js";
-const virtualFs = map => {
-    return createVirtualIo(map).fs;
+import { virtual, emptyState } from "../../types/effects/node/virtual/module.f.js";
+import { encodeUtf8, toVec } from "../../types/uint8array/module.f.js";
+const fileVec = (s) => toVec(encodeUtf8(s));
+const run = (root) => (path) => {
+    const [_, result] = virtual({ ...emptyState, root })(transpile(path));
+    return result;
 };
 export default {
     parse: () => {
-        const map = setReplace('a')(encodeUtf8('export default 1'))(null);
-        const fs = virtualFs(map);
-        const result = transpile(fs)('a');
+        const result = run({ a: fileVec('export default 1') })('a');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -21,10 +20,7 @@ export default {
         }
     },
     parseWithSubModule: () => {
-        const map = setReplace('a/b')(encodeUtf8('import c from "c"\nexport default c'))(null);
-        const map2 = setReplace('a/c')(encodeUtf8('export default 2'))(map);
-        const fs = virtualFs(map2);
-        const result = transpile(fs)('a/b');
+        const result = run({ a: { b: fileVec('import c from "c"\nexport default c'), c: fileVec('export default 2') } })('a/b');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -34,12 +30,12 @@ export default {
         }
     },
     parseWithSubModules: () => {
-        const map = setReplace('a')(encodeUtf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'))(null);
-        const map2 = setReplace('b')(encodeUtf8('import d from "d"\nexport default [0,d]'))(map);
-        const map3 = setReplace('c')(encodeUtf8('import d from "d"\nexport default [1,d]'))(map2);
-        const map4 = setReplace('d')(encodeUtf8('export default 2'))(map3);
-        const fs = virtualFs(map4);
-        const result = transpile(fs)('a');
+        const result = run({
+            a: fileVec('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
+            b: fileVec('import d from "d"\nexport default [0,d]'),
+            c: fileVec('import d from "d"\nexport default [1,d]'),
+            d: fileVec('export default 2'),
+        })('a');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -49,9 +45,7 @@ export default {
         }
     },
     parseWithFileNotFoundError: () => {
-        const map = setReplace('a')(encodeUtf8('import b from "b"\nexport default b'))(null);
-        const fs = virtualFs(map);
-        const result = transpile(fs)('a');
+        const result = run({ a: fileVec('import b from "b"\nexport default b') })('a');
         if (result[0] !== 'error') {
             throw result;
         }
@@ -60,11 +54,11 @@ export default {
         }
     },
     parseWithCycleError: () => {
-        const map = setReplace('a')(encodeUtf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'))(null);
-        const map2 = setReplace('b')(encodeUtf8('import c from "c"\nexport default c'))(map);
-        const map3 = setReplace('c')(encodeUtf8('import b from "b"\nexport default b'))(map2);
-        const fs = virtualFs(map3);
-        const result = transpile(fs)('a');
+        const result = run({
+            a: fileVec('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
+            b: fileVec('import c from "c"\nexport default c'),
+            c: fileVec('import b from "b"\nexport default b'),
+        })('a');
         if (result[0] !== 'error') {
             throw result;
         }

package/fs/fjs/module.f.js

@@ -7,9 +7,10 @@ import { fromIo } from "../io/module.f.js";
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../dev/tf/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
+import { import_ } from "../types/effects/node/module.f.js";
 export const main = async (io) => {
     const { error } = io.console;
-    const { process, asyncImport } = io;
+    const { process } = io;
     const { env } = process;
     const [command, ...rest] = process.argv.slice(2);
     const eRun = fromIo(io);
@@ -19,15 +20,20 @@ export const main = async (io) => {
             return testMain(io);
         case 'compile':
         case 'c':
-            return compile(io)(rest);
+            return eRun(compile(rest));
         case 'cas':
         case 's':
             return eRun(casMain(rest));
         case 'run':
         case 'r':
             const [file, ...args] = rest;
-            const m = await asyncImport(file);
-            return eRun(m.default(args, env));
+            return eRun(import_(file).step(result => {
+                if (result[0] === 'error') {
+                    throw result[1];
+                }
+                const options = { args, env };
+                return result[1].default(options);
+            }));
         case undefined:
             error('Error: command is required');
             return Promise.resolve(1);

package/fs/html/module.f.d.ts

@@ -1,3 +1,9 @@
+/**
+ * HTML serialization helpers: `Element`/`Attributes` builders, void-tag
+ * handling, attribute/text escaping, and a UTF-8 emitter for full documents.
+ *
+ * @module
+ */
 import { type List } from '../types/list/module.f.ts';
 import { type Vec } from '../types/bit_vec/module.f.ts';
 type Tag = string;

package/fs/html/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * HTML serialization helpers: `Element`/`Attributes` builders, void-tag
+ * handling, attribute/text escaping, and a UTF-8 emitter for full documents.
+ *
+ * @module
+ */
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
 import { concat, concat as stringConcat } from "../types/string/module.f.js";
 import { compose } from "../types/function/module.f.js";

package/fs/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, Module, NodeOp, Env } from '../types/effects/node/module.f.ts';
+import type { Headers, Module, NodeOp, Env, SandboxResult } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -73,6 +73,7 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
+export type Sandbox = <T>(f: () => T) => SandboxResult<T>;
 export type Server = {
     readonly listen: (port: number) => void;
 };
@@ -111,6 +112,8 @@ export type Io = {
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
     readonly http: Http;
     readonly childProcess: ChildProcess;
+    readonly now: () => number;
+    readonly sandbox: Sandbox;
 };
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
@@ -120,4 +123,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error: logError, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, }: Io) => EffectToPromise;

package/fs/io/module.f.js

@@ -1,3 +1,12 @@
+/**
+ * Legacy `Io` interface and adapter (`fromIo`) bridging the old IO API to the
+ * effect runner.
+ *
+ * @deprecated Use `fs/types/effects/node` (see issue
+ * [i139](../../issues/README.md)).
+ *
+ * @module
+ */
 import { normalize } from "../path/module.f.js";
 import {} from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
@@ -35,10 +44,10 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }) => {
+export const fromIo = ({ console: { error: logError, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox: ioSandbox, }) => {
     const result = asyncRun({
         all: async (...effects) => await Promise.all(effects.map(result)),
-        error: async (message) => error(message),
+        error: async (message) => logError(message),
         log: async (message) => log(message),
         fetch: async (url) => tc(async () => {
             const response = await fetch(url);
@@ -85,7 +94,9 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             const s = asBase(server);
             s.listen(port);
         },
-        forever: () => new Promise(() => { })
+        forever: () => new Promise(() => { }),
+        now: async () => ioNow(),
+        sandbox: async (f) => ioSandbox(f),
     });
     return result;
 };

package/fs/io/module.js

@@ -14,6 +14,7 @@ import { fromIo, run } from "./module.f.js";
 import { concat } from "../path/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 const prefix = 'file:///';
+const { now } = Date;
 export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
 export const io = {
     console,
@@ -44,12 +45,29 @@ export const io = {
     },
     http,
     childProcess,
+    now,
+    sandbox: (f) => {
+        let result;
+        let after;
+        const before = performance.now();
+        try {
+            const value = f();
+            after = performance.now();
+            result = ok(value);
+        }
+        catch (e) {
+            after = performance.now();
+            result = error(e);
+        }
+        return { result, duration: after - before };
+    },
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {
     const r = fromIo(io);
     const { argv, env } = io.process;
-    return p => r(p(argv, env));
+    const options = { args: argv.slice(2), env };
+    return p => r(p(options));
 };
 const effectRun = ioRun(io);
 export default effectRun;

package/fs/js/tokenizer/module.f.js

@@ -1,3 +1,10 @@
+/**
+ * JavaScript tokenizer built as a range-map state machine over code points,
+ * producing tokens for keywords, identifiers, punctuators, comments, strings,
+ * and numeric literals (including `BigFloat`).
+ *
+ * @module
+ */
 import { strictEqual } from "../../types/function/operator/module.f.js";
 import { merge, fromRange, get } from "../../types/range_map/module.f.js";
 import { empty, stateScan, flat, toArray, reduce as listReduce, scan, map as listMap } from "../../types/list/module.f.js";

package/fs/json/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * JSON tree types and utilities: `Primitive`/`Unknown` value shapes,
+ * `setProperty` for immutable nested updates, and a `stringify` built from the
+ * serializer wraps.
+ *
+ * @module
+ */
 import { type List } from '../types/list/module.f.ts';
 import { type Entry as ObjectEntry } from '../types/object/module.f.ts';
 type Object = {

package/fs/json/module.f.js

@@ -1,3 +1,10 @@
+/**
+ * JSON tree types and utilities: `Primitive`/`Unknown` value shapes,
+ * `setProperty` for immutable nested updates, and a `stringify` built from the
+ * serializer wraps.
+ *
+ * @module
+ */
 import { next, flat, map } from "../types/list/module.f.js";
 import { concat } from "../types/string/module.f.js";
 import { at } from "../types/object/module.f.js";

package/fs/text/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Indented text `Block` rendering and UTF-8 helpers: `flat` flattens a nested
+ * block into prefixed lines, while `utf8`/`utf8ToString` convert between
+ * strings and MSB-first UTF-8 bit vectors.
+ *
+ * @module
+ */
 import { type Vec } from '../types/bit_vec/module.f.ts';
 import { type List } from '../types/list/module.f.ts';
 export type Block = ItemThunk | ItemArray;

package/fs/text/module.f.js

@@ -1,3 +1,10 @@
+/**
+ * Indented text `Block` rendering and UTF-8 helpers: `flat` flattens a nested
+ * block into prefixed lines, while `utf8`/`utf8ToString` convert between
+ * strings and MSB-first UTF-8 bit vectors.
+ *
+ * @module
+ */
 import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
 import { flatMap } from "../types/list/module.f.js";
 import { fromCodePointList, toCodePointList } from "./utf8/module.f.js";

package/fs/text/utf16/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * UTF-16 utilities: convert between strings, UTF-16 code units, and Unicode
+ * code points, including surrogate-pair encoding/decoding via streaming
+ * `stateScan` operations.
+ *
+ * @module
+ */
 import { type List, type Thunk } from '../../types/list/module.f.ts';
 /**
  * Represent an unsigned UTF16, used to store one word UTF-16 (code unit).

package/fs/text/utf16/module.f.js

@@ -1,3 +1,10 @@
+/**
+ * UTF-16 utilities: convert between strings, UTF-16 code units, and Unicode
+ * code points, including surrogate-pair encoding/decoding via streaming
+ * `stateScan` operations.
+ *
+ * @module
+ */
 import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/module.f.js";
 import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";

package/fs/types/effects/node/module.f.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Node.js effect operations: filesystem (`mkdir`, `readFile`, `readdir`,
+ * `writeFile`, `rm`, `access`), networking (`fetch`, `createServer`, `listen`),
+ * subprocess `exec`, console (`log`, `error`), `import_`, `now`, `sandbox`, `forever`,
+ * and `all`/`both` parallelism; defines the `NodeOp`/`NodeProgram` types used
+ * by the Node runner.
+ *
+ * @module
+ */
 import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
@@ -82,7 +91,38 @@ export type Module = {
 };
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
-export type NodeOp = All | Fetch | Console | Fs | Http | Forever | Import;
+export type Now = readonly ['now', () => number];
+export declare const now: Func<Now>;
+export type SandboxResult<T> = {
+    readonly result: Result<T, unknown>;
+    /**
+     * Measured milliseconds but it's not limited to that.
+     * Instead, they represent times as floating-point numbers
+     * with up to microsecond precision.
+     */
+    readonly duration: number;
+};
+export type Sandbox = readonly ['sandbox', <T>(f: () => T) => SandboxResult<T>];
+/**
+ * Runs a plain synchronous function in an isolated, measured environment.
+ *
+ * Combines try/catch and high-resolution timing into a single atomic operation.
+ * Only plain synchronous functions are accepted — no effects, no promises.
+ *
+ * Using a single operation rather than separate `TryCatch` + `Perf` effects is
+ * necessary for correctness: effects execute as async tasks, so the scheduler
+ * can insert arbitrary work between two separate timing calls, making the
+ * measured delta inaccurate. Here the clock reads happen synchronously around
+ * the function call with nothing in between.
+ *
+ * Future parameters (time limit, memory limit) can be added to the payload
+ * without breaking the API. Worker-based implementations can enforce hard
+ * limits via worker termination.
+ *
+ * @see {@link SandboxResult}
+ */
+export declare const sandbox: Func<Sandbox>;
+export type NodeOp = All | Fetch | Console | Fs | Http | Forever | Import | Now | Sandbox;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
@@ -91,4 +131,8 @@ export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 export type Env = {
     readonly [k: string]: string | undefined;
 };
-export type NodeProgram = (argv: readonly string[], env: Env) => Effect<NodeOp, number>;
+export type NodeProgramOptions = {
+    readonly args: readonly string[];
+    readonly env: Env;
+};
+export type NodeProgram = (options: NodeProgramOptions) => Effect<NodeOp, number>;

package/fs/types/effects/node/module.f.js

@@ -23,3 +23,23 @@ export const createServer = do_('createServer');
 export const listen = do_('listen');
 export const forever = do_('forever');
 export const import_ = do_('import');
+export const now = do_('now');
+/**
+ * Runs a plain synchronous function in an isolated, measured environment.
+ *
+ * Combines try/catch and high-resolution timing into a single atomic operation.
+ * Only plain synchronous functions are accepted — no effects, no promises.
+ *
+ * Using a single operation rather than separate `TryCatch` + `Perf` effects is
+ * necessary for correctness: effects execute as async tasks, so the scheduler
+ * can insert arbitrary work between two separate timing calls, making the
+ * measured delta inaccurate. Here the clock reads happen synchronously around
+ * the function call with nothing in between.
+ *
+ * Future parameters (time limit, memory limit) can be added to the payload
+ * without breaking the API. Worker-based implementations can enforce hard
+ * limits via worker termination.
+ *
+ * @see {@link SandboxResult}
+ */
+export const sandbox = do_('sandbox');

package/fs/types/effects/node/test.f.d.ts

@@ -30,5 +30,10 @@ declare const _default: {
         noSuchFile: () => void;
         isDirectory: () => void;
     };
+    now: () => void;
+    sandbox: {
+        ok: () => void;
+        error: () => void;
+    };
 };
 export default _default;

package/fs/types/effects/node/test.f.js

@@ -1,6 +1,6 @@
 import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
 import { pure } from "../module.f.js";
-import { fetch, mkdir, readdir, readFile, rm, writeFile } from "./module.f.js";
+import { fetch, mkdir, now, readdir, readFile, rm, sandbox, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export default {
     map: () => {
@@ -326,4 +326,34 @@ export default {
             }
         },
     },
+    now: () => {
+        const [_, result] = virtual({ ...emptyState, epochNs: 1_000_000 })(now());
+        if (result !== 1_000_000) {
+            throw result;
+        }
+    },
+    sandbox: {
+        ok: () => {
+            const [_, { result, duration }] = virtual(emptyState)(sandbox(() => 42));
+            if (result[0] !== 'ok') {
+                throw result;
+            }
+            if (result[1] !== 42) {
+                throw result[1];
+            }
+            if (duration !== 0) {
+                throw duration;
+            }
+        },
+        error: () => {
+            const err = new Error('fail');
+            const [_, { result }] = virtual(emptyState)(sandbox(() => { throw err; }));
+            if (result[0] !== 'error') {
+                throw result;
+            }
+            if (result[1] !== err) {
+                throw result[1];
+            }
+        },
+    },
 };

package/fs/types/effects/node/virtual/module.f.d.ts

@@ -11,6 +11,7 @@ export type State = {
     internet: {
         readonly [url: string]: Vec;
     };
+    epochNs: number;
 };
 export declare const emptyState: State;
 export declare const virtual: RunInstance<NodeOp, State>;

package/fs/types/effects/node/virtual/module.f.js

@@ -13,6 +13,7 @@ export const emptyState = {
     stderr: '',
     root: {},
     internet: {},
+    epochNs: 0,
 };
 const operation = (op) => {
     const f = (dir, path) => {
@@ -146,5 +147,16 @@ const map = {
     createServer: todo,
     listen: todo,
     forever: todo,
+    now: (state) => [state, state.epochNs],
+    sandbox: (state, f) => {
+        let result;
+        try {
+            result = ok(f());
+        }
+        catch (e) {
+            result = error(e);
+        }
+        return [state, { result, duration: 0 }];
+    },
 };
 export const virtual = run(map);

package/fs/types/monoid/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Monoids: the `Monoid<T>` algebraic structure (identity plus associative
+ * binary operation) and `repeat`, which applies the operation `n` times using
+ * exponentiation by squaring.
+ *
+ * @module
+ */
 import type { Fold, Reduce } from '../function/operator/module.f.ts';
 /**
  * Represents a monoid, an algebraic structure with a binary operation

package/fs/types/number/module.f.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Numeric list reductions (`sum`, `min`, `max`), comparison via `cmp`, and
+ * `countOnes` for 32-bit population count using SWAR.
+ *
+ * @module
+ */
 import { type List } from '../list/module.f.ts';
 import { type Sign } from '../function/compare/module.f.ts';
 export declare const sum: (input: List<number>) => number;

package/fs/types/number/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Numeric list reductions (`sum`, `min`, `max`), comparison via `cmp`, and
+ * `countOnes` for 32-bit population count using SWAR.
+ *
+ * @module
+ */
 import { reduce } from "../list/module.f.js";
 import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
 import { cmp as uCmp } from "../function/compare/module.f.js";

package/fs/types/object/module.f.js

@@ -1,3 +1,10 @@
+/**
+ * Plain-object helpers and types: `Map<T>`/`Entry<T>` shapes, safe property
+ * lookup via `at`, conversions between entries and `OrderedMap`, and the
+ * `OneKey`/`SingleProperty`/`NotUnion` utility types.
+ *
+ * @module
+ */
 import { isArray } from "../array/module.f.js";
 import { iterable } from "../list/module.f.js";
 import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";

package/fs/types/prime_field/module.f.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Prime field arithmetic over `bigint`: `prime_field(p)` builds a `PrimeField`
+ * with negation, addition, subtraction, multiplication, division via modular
+ * inverse, and exponentiation; `sqrt` returns a square-root function when
+ * `p % 4 === 3`.
+ *
+ * @module
+ */
 import type { Unary, Reduce } from '../bigint/module.f.ts';
 /**
  * A type representing a prime field and its associated operations.

package/fs/types/ts/module.f.d.ts

@@ -1,3 +1,10 @@
+/**
+ * TypeScript source-emitter helpers: the `Equal`/`Assert` compile-time
+ * predicates and a `Printer` that renders tuples, structs, arrays, records,
+ * primitive literals, and unions as TypeScript type expressions.
+ *
+ * @module
+ */
 export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
 export type Assert<T extends true> = T;
 /** Functions for emitting TypeScript type expression strings. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -15,7 +15,8 @@
     "start": "node ./fs/fjs/module.ts",
     "ci-update": "node ./fs/fjs/module.ts r ./fs/ci/module.f.ts",
     "update": "npm install && npm run index && npm run ci-update",
-    "website": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts"
+    "index-html": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts",
+    "website": "npm run prepack &&npm run index-html"
   },
   "engines": {
     "node": ">=22"

package/fs/io/virtual/module.f.d.ts

@@ -1,8 +0,0 @@
-/**
- * Virtual I/O adapter implementations for deterministic testing.
- *
- * @module
- */
-import type { Io } from '../module.f.ts';
-import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-export declare const createVirtualIo: (files: OrderedMap<Uint8Array>) => Io;

package/fs/io/virtual/module.f.js

@@ -1,43 +0,0 @@
-import { at } from "../../types/ordered_map/module.f.js";
-import { todo } from "../../dev/module.f.js";
-export const createVirtualIo = (files) => ({
-    console: {
-        log: (..._d) => { },
-        error: (..._d) => { }
-    },
-    fs: {
-        writeSync: (_fd, _s) => { },
-        writeFileSync: (_file, _data) => { },
-        readFileSync: (path) => { return at(path)(files); },
-        promises: {
-            readdir: (_path) => Promise.resolve([]),
-            readFile: (_path) => Promise.resolve(new Uint8Array()),
-            writeFile: (_path, _data) => Promise.resolve(),
-            rm: (_path, _options) => Promise.resolve(),
-            mkdir: (_path, _options) => Promise.resolve(undefined),
-            copyFile: (_src, _dest) => Promise.resolve(),
-            access: (_path) => Promise.resolve(),
-        }
-    },
-    process: {
-        argv: [],
-        env: {},
-        exit: n => { throw n; },
-        cwd: () => '',
-        stdout: { fd: 1, isTTY: false },
-        stderr: { fd: 2, isTTY: false },
-    },
-    asyncImport: () => Promise.reject(),
-    performance: {
-        now: () => 0,
-    },
-    fetch: () => Promise.reject(),
-    tryCatch: f => ['ok', f()],
-    asyncTryCatch: async (f) => ['ok', await f()],
-    http: {
-        createServer: todo
-    },
-    childProcess: {
-        exec: todo,
-    },
-});