functionalscript 0.23.0 → 0.24.0

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

@@ -5,8 +5,8 @@
  */
 import { type Sha2 } from '../crypto/sha2/module.f.ts';
 import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
-import { type Fs, type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
+import { type Fs, type NodeOp } from '../effects/node/module.f.ts';
 export type KvStore<O extends Operation> = {
     /** Reads a value by key; returns `undefined` when the key does not exist. */
     readonly read: (key: Vec) => Effect<O, Vec | undefined>;

package/fs/cas/module.f.js

@@ -6,8 +6,8 @@
 import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
 import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../cbase32/module.f.js";
-import { begin, forEachStep, pure } from "../types/effects/module.f.js";
-import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { begin, forEachStep, pure } from "../effects/module.f.js";
+import { errorExit, log, mkdir, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };

package/fs/cas/proof.f.js

@@ -1,9 +1,9 @@
 import { cas, main } from "./module.f.js";
 import { sha256 } from "../crypto/sha2/module.f.js";
 import { empty, length, vec8 } from "../types/bit_vec/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { run } from "../types/effects/mock/module.f.js";
-import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { run } from "../effects/mock/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 export const proof = {
     mainAdd: () => {
         const content = vec8(0x2an);

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

@@ -1,5 +1,5 @@
-import { type Effect } from '../types/effects/module.f.ts';
-import { type NodeOp } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type NodeOp } from '../effects/node/module.f.ts';
 import { type MetaStep, type Os } from './common/module.f.ts';
 export type Setup = {
     readonly rust: boolean;

package/fs/ci/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8 } from "../text/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
+import { begin, pure } from "../effects/module.f.js";
+import { writeFile } from "../effects/node/module.f.js";
 import { images } from "./config/module.f.js";
 import { architecture, findTgz, os, test, toSteps } from "./common/module.f.js";
 import { rustSteps } from "./rust/module.f.js";

package/fs/ci/proof.f.js

@@ -3,7 +3,7 @@ import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../asserts/module.f.js";
-import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import { emptyState, virtual } from "../effects/node/virtual/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));

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

@@ -1,11 +1,5 @@
-/**
- * Development utilities for indexing modules and loading FunctionalScript files.
- *
- * @module
- */
-import type { Io } from '../io/module.f.ts';
-import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../types/effects/node/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
+import { type Access, type All, type Env, type Import, type NodeProgram, type Readdir } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
 export type Module = {
     readonly proof?: unknown;
     readonly [k: string]: unknown;
@@ -13,7 +7,6 @@ export type Module = {
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
-export declare const env: (io: Io) => (v: string) => string | undefined;
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *

package/fs/dev/module.f.js

@@ -1,19 +1,18 @@
+/**
+ * Development utilities for indexing modules and loading FunctionalScript files.
+ *
+ * @module
+ */
 import { updateVersion } from "./version/module.f.js";
-import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { all, both, import_, readdir, readFile, writeFile } from "../effects/node/module.f.js";
 import { cmp as strCmp } from "../types/string/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 import { unwrap } from "../types/result/module.f.js";
-import { begin, pure } from "../types/effects/module.f.js";
+import { begin, pure } from "../effects/module.f.js";
 import { parse as jsonParse } from "../json/module.f.js";
 import { record, unknown as rttiUnknown } from "../types/rtti/module.f.js";
 import { parse as rttiParse } from "../types/rtti/parse/module.f.js";
 import { relativize, toPosix } from "../path/module.f.js";
-export const env = ({ process: { env } }) => a => {
-    const r = Object.getOwnPropertyDescriptor(env, a);
-    return r === undefined ? undefined :
-        typeof r.get === 'function' ? r.get() :
-            r.value;
-};
 /**
  * Returns `true` if the file should be loaded for proof discovery.
  *
@@ -92,7 +91,9 @@ const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = updateVersion
     .step(() => readFile(denoJson))
     .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
-const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'))
+const allFiles2aa = allFiles('.', v => v.endsWith('/module.f.ts') ||
+    v.endsWith('/module.ts') ||
+    v.endsWith('/all.test.ts'))
     .step(files => {
     const exportsA = files.map(v => [v, `./${v.substring(2)}`]);
     return pure(Object.fromEntries(exportsA));

package/fs/dev/proof.f.d.ts

@@ -9,5 +9,4 @@ export declare const proof: {
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
     throw: () => void;
-    env: () => void;
 };

package/fs/dev/proof.f.js

@@ -1,5 +1,4 @@
 import { todo } from "../asserts/module.f.js";
-import { env } from "./module.f.js";
 export const proof = {
     shouldPass: () => ({
         then: () => undefined
@@ -57,24 +56,4 @@ export const proof = {
     throw: () => {
         todo();
     },
-    env: () => {
-        const mockIo = { process: { env: { MY_VAR: 'hello' } } };
-        // missing key → undefined
-        const r1 = env(mockIo)('MISSING');
-        if (r1 !== undefined) {
-            throw r1;
-        }
-        // regular value property → returns value
-        const r2 = env(mockIo)('MY_VAR');
-        if (r2 !== 'hello') {
-            throw r2;
-        }
-        // getter property → calls get()
-        const envWithGetter = Object.defineProperty({}, 'GETTER_VAR', { get: () => 'from-getter', enumerable: true, configurable: true });
-        const mockIo2 = { process: { env: envWithGetter } };
-        const r3 = env(mockIo2)('GETTER_VAR');
-        if (r3 !== 'from-getter') {
-            throw r3;
-        }
-    }
 };

package/fs/dev/version/module.f.d.ts

@@ -1,3 +1,3 @@
-import { type Effect } from '../../types/effects/module.f.ts';
-import { type All, type ReadFile, type WriteFile } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
+import { type All, type ReadFile, type WriteFile } from '../../effects/node/module.f.ts';
 export declare const updateVersion: Effect<ReadFile | WriteFile | All, number>;

package/fs/dev/version/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { begin, pure } from "../../types/effects/module.f.js";
-import { all, readFile, writeFile } from "../../types/effects/node/module.f.js";
+import { begin, pure } from "../../effects/module.f.js";
+import { all, readFile, writeFile } from "../../effects/node/module.f.js";
 import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;

package/fs/dev/version/proof.f.js

@@ -1,7 +1,7 @@
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { isVec } from "../../types/bit_vec/module.f.js";
-import { all, writeFile } from "../../types/effects/node/module.f.js";
-import { emptyState, virtual } from "../../types/effects/node/virtual/module.f.js";
+import { all, writeFile } from "../../effects/node/module.f.js";
+import { emptyState, virtual } from "../../effects/node/virtual/module.f.js";
 import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {

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

@@ -4,8 +4,8 @@
  * @module
  */
 import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
-import { type WriteFile, type ReadFile, type Write } from '../types/effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
+import { type WriteFile, type ReadFile, type Write } from '../effects/node/module.f.ts';
 export type Object = {
     readonly [k in string]: Unknown;
 };

package/fs/djs/module.f.js

@@ -1,8 +1,8 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-import { pure } from "../types/effects/module.f.js";
-import { writeFile, error, } from "../types/effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { writeFile, error, } from "../effects/node/module.f.js";
 import { utf8 } from "../text/module.f.js";
 export const compile = args => {
     if (args.length < 2) {

package/fs/djs/parser/module.f.d.ts

@@ -7,11 +7,9 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-import type { Fs } from '../../io/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
 export type ParseContext = {
-    readonly fs: Fs;
     readonly complete: OrderedMap<Result<AstModule, string>>;
     readonly stack: List<string>;
 };

package/fs/djs/proof.f.js

@@ -1,5 +1,5 @@
 import { compile } from "./module.f.js";
-import { virtual, emptyState } from "../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../text/module.f.js";
 const readOutput = (root, path) => {

package/fs/djs/transpiler/module.f.d.ts

@@ -8,8 +8,8 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import { type ParseError } from '../parser/module.f.ts';
-import { type Effect } from '../../types/effects/module.f.ts';
-import { type ReadFile } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
+import { type ReadFile } from '../../effects/node/module.f.ts';
 /**
  * State threaded through the recursive transpilation of a DJS module graph.
  *

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

@@ -12,8 +12,8 @@ import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
-import { foldStep, pure } from "../../types/effects/module.f.js";
-import { readFile } from "../../types/effects/node/module.f.js";
+import { foldStep, pure } from "../../effects/module.f.js";
+import { readFile } from "../../effects/node/module.f.js";
 import { utf8ToString } from "../../text/module.f.js";
 const mapDjs = context => path => {
     const res = at(path)(context.complete);

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

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
-import { virtual, emptyState } from "../../types/effects/node/virtual/module.f.js";
+import { virtual, emptyState } from "../../effects/node/virtual/module.f.js";
 import { utf8 } from "../../text/module.f.js";
 const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));

package/fs/{types/effects → effects}/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { type List } from '../list/module.f.ts';
+import { type List } from '../types/list/module.f.ts';
 export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;

package/fs/{types/effects → effects}/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { fold } from "../list/module.f.js";
+import { fold } from "../types/list/module.f.js";
 export const pure = (v) => ({
     value: [v],
     step: f => f(v)

package/fs/{io → effects/node}/module.d.ts

@@ -1,10 +1,4 @@
-import { type Io } from './module.f.ts';
-import type { Module, NodeProgram } from '../types/effects/node/module.f.ts';
-import { type Result } from '../types/result/module.f.ts';
-export declare const asyncImport: (v: string) => Promise<Module>;
-export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
-export declare const io: Io;
-export type NodeRun = (p: NodeProgram) => Promise<never>;
+import { type NodeProgram } from './module.f.ts';
 /**
  * Runs a `NodeProgram` against the real Node `io` and process arguments,
  * resolving to its exit code **without** terminating the process.
@@ -12,7 +6,7 @@ export type NodeRun = (p: NodeProgram) => Promise<never>;
  * Use this when the caller must stay alive afterwards — e.g. when proofs are
  * registered under an external test runner (Node `--test`, Bun, Playwright)
  * that owns the process lifecycle. For a standalone CLI entry point that should
- * exit with the program's code, use the default {@link run} export instead.
+ * exit with the program's code, use {@link run} instead.
  */
 export declare const runEffect: (p: NodeProgram) => Promise<number>;
 /**
@@ -20,8 +14,7 @@ export declare const runEffect: (p: NodeProgram) => Promise<number>;
  * `process.exit` with its exit code. The `Promise<never>` return type reflects
  * that control never returns to the caller — the process terminates.
  *
- * This is the default export so a `bin` script can simply
- * `import run from '.../io/module.js'; run(main)`.
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
  */
-declare const run: NodeRun;
-export default run;
+export declare const run: (p: NodeProgram) => Promise<never>;

package/fs/{types/effects → effects}/node/module.f.d.ts

@@ -1,6 +1,6 @@
-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';
+import type { Vec } from '../../types/bit_vec/module.f.ts';
+import type { Nominal } from '../../types/nominal/module.f.ts';
+import type { Result } from '../../types/result/module.f.ts';
 import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
 export type All = ['all', <T>(...effects: Effect<never, T>[]) => readonly T[]];

package/fs/{types/effects → effects}/node/module.f.js

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import { utf8 } from "../../../text/module.f.js";
+import { utf8 } from "../../text/module.f.js";
 import { begin, do_, pure } from "../module.f.js";
 const doAll = do_('all');
 /**

package/fs/{io → effects/node}/module.js

@@ -10,12 +10,97 @@ import http from 'node:http';
 import childProcess from 'node:child_process';
 import fs from 'node:fs';
 import process from 'node:process';
-import { concat } from "../path/module.f.js";
 import { once } from 'node:events';
-import { runProgram } from "./module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { fromVec } from "../types/uint8array/module.f.js";
 import * as testContext from 'node:test';
+import { concat } from "../../path/module.f.js";
+import { normalize } from "../../path/module.f.js";
+import {} from "../module.f.js";
+import { asyncRun } from "../module.js";
+import {} from "./module.f.js";
+import { asBase, asNominal } from "../../types/nominal/module.f.js";
+import { error, ok } from "../../types/result/module.f.js";
+import { fromVec, listToVec, toVec } from "../../types/uint8array/module.f.js";
+const tc = async (f) => {
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+const collect = async (v) => {
+    let result = [];
+    for await (const a of v) {
+        result = [...result, a];
+    }
+    return result;
+};
+const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
+    const result = asyncRun({
+        all: async (...effects) => await Promise.all(effects.map(result)),
+        fetch: async (url) => tc(async () => {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
+            }
+            return toVec(new Uint8Array(await response.arrayBuffer()));
+        }),
+        mkdir: (...p) => tc(async () => { await mkdir(...p); }),
+        readFile: path => tc(async () => toVec(await readFile(path))),
+        readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+            .map(v => ({
+            name: v.name,
+            parentPath: normalize(v.parentPath),
+            isFile: v.isFile()
+        }))),
+        writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
+        rm: path => tc(() => rm(path)),
+        access: path => tc(() => access(path)),
+        import: path => tc(() => asyncImport(path)),
+        exec: (command, stdin) => new Promise(resolve => {
+            const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
+            child.stdin?.end(stdin);
+        }),
+        createServer: async (requestListener) => {
+            const erl = requestListener;
+            const nodeRl = async (req, res) => {
+                const reqBody = await collect(req);
+                const { method, url, headers } = req;
+                const { status, headers: outHeaders, body: outBody } = await result(erl({
+                    method,
+                    url,
+                    headers,
+                    body: listToVec(reqBody)
+                }));
+                res
+                    .writeHead(status, outHeaders)
+                    .end(fromVec(outBody));
+            };
+            const server = asNominal(createServer(nodeRl));
+            return server;
+        },
+        listen: async (server, port) => {
+            const s = asBase(server);
+            s.listen(port);
+        },
+        forever: () => new Promise(() => { }),
+        now: async () => ioNow(),
+        sandbox,
+        await: awaitPromise,
+        write,
+        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
+    });
+    return result;
+};
+const runProgram = (io) => {
+    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
+    const std = { stdout, stderr };
+    const f = fromIo(io);
+    return args => {
+        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
+        return program => f(program(options));
+    };
+};
 const isPlaywright = 'PLAYWRIGHT_TEST' in (process?.env ?? {});
 const pwTest = isPlaywright
     ? (await import('@playwright/test')).test
@@ -66,8 +151,8 @@ const writeAll = async (stream, data) => {
         await once(stream, 'drain');
     }
 };
-export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
-export const tryCatch = f => {
+const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
+const tryCatch = f => {
     try {
         return ok(f());
     }
@@ -76,7 +161,7 @@ export const tryCatch = f => {
     }
 };
 const awaitPromise = async (p) => [p instanceof Promise ? await p : p];
-export const io = {
+const io = {
     console,
     fs,
     process,
@@ -132,7 +217,7 @@ export const io = {
  * Use this when the caller must stay alive afterwards — e.g. when proofs are
  * registered under an external test runner (Node `--test`, Bun, Playwright)
  * that owns the process lifecycle. For a standalone CLI entry point that should
- * exit with the program's code, use the default {@link run} export instead.
+ * exit with the program's code, use {@link run} instead.
  */
 export const runEffect = runProgram(io)(io.process.argv.slice(2));
 /**
@@ -140,8 +225,7 @@ export const runEffect = runProgram(io)(io.process.argv.slice(2));
  * `process.exit` with its exit code. The `Promise<never>` return type reflects
  * that control never returns to the caller — the process terminates.
  *
- * This is the default export so a `bin` script can simply
- * `import run from '.../io/module.js'; run(main)`.
+ * A `bin` script can simply
+ * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
  */
-const run = async (p) => process.exit(await runEffect(p));
-export default run;
+export const run = async (p) => process.exit(await runEffect(p));

package/fs/{types/effects → effects}/node/proof.f.js

@@ -1,4 +1,4 @@
-import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
+import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
 import { pure } 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";

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

@@ -1,4 +1,4 @@
-import { type Vec } from '../../../bit_vec/module.f.ts';
+import { type Vec } from '../../../types/bit_vec/module.f.ts';
 import { type RunInstance } from '../../mock/module.f.ts';
 import type { Module, NodeOp } from '../module.f.ts';
 /**

package/fs/{types/effects → effects}/node/virtual/module.f.js

@@ -3,11 +3,11 @@
  *
  * @module
  */
-import { assert, todo } from "../../../../asserts/module.f.js";
-import { parse } from "../../../../path/module.f.js";
-import { utf8ToString } from "../../../../text/module.f.js";
-import { isVec } from "../../../bit_vec/module.f.js";
-import { error, ok } from "../../../result/module.f.js";
+import { todo } from "../../../asserts/module.f.js";
+import { parse } from "../../../path/module.f.js";
+import { utf8ToString } from "../../../text/module.f.js";
+import { isVec } from "../../../types/bit_vec/module.f.js";
+import { error, ok } from "../../../types/result/module.f.js";
 import { run } from "../../mock/module.f.js";
 export const emptyState = {
     stdout: '',

package/fs/emergent_testing/all.test.d.ts

@@ -1 +1 @@
-import './module.ts';
+export {};

package/fs/emergent_testing/all.test.js

@@ -1,3 +1,4 @@
-import "./module.js";
+import { runEffect } from "../effects/node/module.js";
+import { register } from "./module.f.js";
 // we need `await` for Playwright.
-// await run()
+await runEffect(register);

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

@@ -1,5 +1,5 @@
-import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../types/effects/node/module.f.ts';
-import { type Effect, type Operation } from '../types/effects/module.f.ts';
+import { type All, type Await, type NodeProgram, type NodeProgramOptions, type Program, type Sandbox, type SandboxResult, type Test, type TestContext, type Write } from '../effects/node/module.f.ts';
+import { type Effect, type Operation } from '../effects/module.f.ts';
 import { type LoadModuleOperations, type ModuleMap } from '../dev/module.f.ts';
 /** A zero-argument test function whose return value may contain sub-tests. */
 export type TestFn = () => unknown;

package/fs/emergent_testing/module.f.js

@@ -11,8 +11,8 @@
  * @module
  */
 import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/module.f.js";
-import { all, awaitIfPromise, sandbox, test } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { all, awaitIfPromise, sandbox, test } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
 import { loadModuleMap, shouldLoad } from "../dev/module.f.js";
 import { invert } from "../types/result/module.f.js";
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });

package/fs/emergent_testing/proof.f.js

@@ -1,9 +1,9 @@
-import { pure } from "../types/effects/module.f.js";
-import { emptyState } from "../types/effects/node/virtual/module.f.js";
-import { virtual } from "../types/effects/node/virtual/module.f.js";
+import { pure } from "../effects/module.f.js";
+import { emptyState } from "../effects/node/virtual/module.f.js";
+import { virtual } from "../effects/node/virtual/module.f.js";
 import { assert, assertEq, todo } from "../asserts/module.f.js";
 import { testAll, defaultReporter, fmtPath, fmtTerm, fmtImport, ghEscape, isInteger, isIdentifier, registerModule, defaultTest, } from "./module.f.js";
-import { run as mockRun } from "../types/effects/mock/module.f.js";
+import { run as mockRun } from "../effects/mock/module.f.js";
 import { shouldLoad } from "../dev/module.f.js";
 const makeReporter = () => {
     const events = [];

package/fs/emergent_testing/scenarios/all.d.ts

@@ -1 +1 @@
-import '../module.ts';
+import '../all.test.ts';

package/fs/emergent_testing/scenarios/all.js

@@ -1 +1 @@
-import "../module.js";
+import "../all.test.js";

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

@@ -1,2 +1,2 @@
-import { type NodeProgram } from '../types/effects/node/module.f.ts';
+import { type NodeProgram } from '../effects/node/module.f.ts';
 export declare const main: NodeProgram;

package/fs/fjs/module.f.js

@@ -6,7 +6,7 @@
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../emergent_testing/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
-import { import_, errorExit } from "../types/effects/node/module.f.js";
+import { import_, errorExit } from "../effects/node/module.f.js";
 export const main = options => {
     const [command, ...rest] = options.args;
     switch (command) {

package/fs/fjs/module.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { main } from "./module.f.js";
-import run from "../io/module.js";
-run(main);
+import { run } from "../effects/node/module.js";
+await run(main);

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

@@ -4,9 +4,8 @@
  *
  * @module
  */
-import type { Io, Writable } from "../../io/module.f.ts";
-import { type Write, type WriteConsoles, type NodeProgramOptions } from '../../types/effects/node/module.f.ts';
-import { type Effect } from '../../types/effects/module.f.ts';
+import { type Write, type WriteConsoles, type NodeProgramOptions } from '../../effects/node/module.f.ts';
+import { type Effect } from '../../effects/module.f.ts';
 export declare const backspace: string;
 type End = 'm';
 type Csi = (code: number | string) => string;
@@ -45,20 +44,6 @@ export type WriteText = (text: string) => WriteText;
  */
 export declare const createConsoleText: (stdout: Stdout) => WriteText;
 export type CsiConsole = (s: string) => void;
-/**
- * Creates a TTY-aware console function. Appends `\n` to each string before writing.
- *
- * For TTY destinations, ANSI SGR sequences are preserved.
- * For non-TTY destinations, ANSI SGR sequences are stripped.
- *
- * @param io - Runtime IO bindings.
- * @returns A function that targets a writable stream.
- */
-export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => CsiConsole;
-/** Writes to process stdout using a TTY-aware CSI console. */
-export declare const stdio: (io: Io) => CsiConsole;
-/** Writes to process stderr using a TTY-aware CSI console. */
-export declare const stderr: (io: Io) => CsiConsole;
 /**
  * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.

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

@@ -4,8 +4,10 @@
  *
  * @module
  */
-import { write } from "../../types/effects/node/module.f.js";
-import {} from "../../types/effects/module.f.js";
+// C0 control codes
+// https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
+import { write } from "../../effects/node/module.f.js";
+import {} from "../../effects/module.f.js";
 import { utf8 } from "../module.f.js";
 export const backspace = '\x08';
 const begin = '\x1b[';
@@ -50,23 +52,6 @@ export const createConsoleText = (stdout) => {
     return f('');
 };
 const str = (isTTY) => (s) => isTTY ? s : s.replace(/\x1b\[[0-9;]*m/g, '');
-/**
- * Creates a TTY-aware console function. Appends `\n` to each string before writing.
- *
- * For TTY destinations, ANSI SGR sequences are preserved.
- * For non-TTY destinations, ANSI SGR sequences are stripped.
- *
- * @param io - Runtime IO bindings.
- * @returns A function that targets a writable stream.
- */
-export const console = ({ fs: { writeSync } }) => (w) => {
-    const toStr = str(w.isTTY);
-    return (s) => writeSync(w.fd, toStr(s) + '\n');
-};
-/** Writes to process stdout using a TTY-aware CSI console. */
-export const stdio = (io) => console(io)(io.process.stdout);
-/** Writes to process stderr using a TTY-aware CSI console. */
-export const stderr = (io) => console(io)(io.process.stderr);
 /**
  * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
  * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.

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

@@ -1,4 +1,4 @@
-import { type WriteFile } from '../types/effects/node/module.f.ts';
-import { type Effect } from '../types/effects/module.f.ts';
+import { type WriteFile } from '../effects/node/module.f.ts';
+import { type Effect } from '../effects/module.f.ts';
 declare const _default: () => Effect<WriteFile, number>;
 export default _default;

package/fs/website/module.f.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { htmlUtf8 } from "../html/module.f.js";
-import { writeFile } from "../types/effects/node/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import { writeFile } from "../effects/node/module.f.js";
+import { pure } from "../effects/module.f.js";
 const html = htmlUtf8()(['a',
     { href: 'https://github.com/functionalscript/functionalscript' },
     'GitHub Repository'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "type": "module",
   "files": [
     "**/*.js",

package/fs/emergent_testing/module.d.ts

@@ -1 +0,0 @@
-export {};

package/fs/emergent_testing/module.js

@@ -1,4 +0,0 @@
-import { runEffect } from "../io/module.js";
-import { register } from "./module.f.js";
-// we need `await` for Playwright.
-await runEffect(register);

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

@@ -1,134 +0,0 @@
-import { type Effect } from '../types/effects/module.f.ts';
-import { type Headers, type Module, type NodeOp, type Env, type SandboxResult, type NodeProgram, type WriteConsoles, type TestContext, type Engine } from '../types/effects/node/module.f.ts';
-import type { Vec } from '../types/bit_vec/module.f.ts';
-import { type Result } from '../types/result/module.f.ts';
-/**
- * Represents a directory entry (file or directory) in the filesystem
- * @see https://nodejs.org/api/fs.html#class-fsdirent
- */
-export type Dirent = {
-    readonly name: string;
-    readonly parentPath: string;
-    readonly isDirectory: () => boolean;
-    readonly isFile: () => boolean;
-};
-export type RmOptions = {
-    readonly force?: boolean;
-    readonly recursive?: boolean;
-};
-export type MakeDirectoryOptions = {
-    readonly recursive?: boolean;
-};
-export type ReadDir = ((path: string, options: {
-    withFileTypes: true;
-}) => Promise<Dirent[]>) & ((path: string, options: {
-    recursive?: true;
-}) => Promise<readonly string[]>);
-/**
- * File system operations interface
- * @see https://nodejs.org/api/fs.html
- */
-export type Fs = {
-    readonly writeSync: (fd: number, s: string) => void;
-    readonly writeFileSync: (file: string, data: Uint8Array) => void;
-    readonly readFileSync: (path: string) => Uint8Array | null;
-    readonly promises: {
-        readonly readFile: (path: string) => Promise<Uint8Array>;
-        readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
-        readonly readdir: ReadDir;
-        readonly rm: (path: string, options?: RmOptions) => Promise<void>;
-        readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
-        readonly copyFile: (src: string, dest: string) => Promise<void>;
-        readonly access: (path: string) => Promise<void>;
-    };
-};
-/**
- * Console operations interface
- * @see https://nodejs.org/api/console.html
- */
-export type Console = {
-    readonly log: (...d: unknown[]) => void;
-    readonly error: (...d: unknown[]) => void;
-};
-/**
- * High-resolution time measurement interface
- * @see https://nodejs.org/api/perf_hooks.html#performance-now
- */
-export type Performance = {
-    readonly now: () => number;
-};
-export type Writable = {
-    readonly fd: number;
-    readonly isTTY: boolean;
-};
-/**
- * Node.js Process interface
- * @see https://nodejs.org/api/process.html
- */
-export type Process = {
-    readonly argv: string[];
-    readonly env: Env;
-    readonly exit: (code: number) => never;
-    readonly cwd: () => string;
-    readonly stdout: Writable;
-    readonly stderr: Writable;
-};
-export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
-export type Sandbox = <T>(f: () => T) => Promise<SandboxResult<T>>;
-export type Server = {
-    readonly listen: (port: number) => void;
-};
-export type Readable = AsyncIterable<Uint8Array>;
-export type IncomingMessage = Readable & {
-    readonly method: string;
-    readonly url: string;
-    readonly headers: Headers;
-};
-export type ServerResponse = {
-    readonly writeHead: (status: number, headers: Record<string, string>) => ServerResponse;
-    readonly end: (body: Uint8Array) => void;
-};
-export type RequestListener = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export type Http = {
-    readonly createServer: (_: RequestListener) => Server;
-};
-export type ChildProcess = {
-    readonly exec: (command: string, callback: (error: unknown, stdout: string, stderr: string) => void) => {
-        readonly stdin: null | {
-            readonly end: (data?: string) => void;
-        };
-    };
-};
-/**
- * Core IO operations interface providing access to system resources
- */
-export type Io = {
-    readonly console: Console;
-    readonly fs: Fs;
-    readonly process: Process;
-    readonly asyncImport: (s: string) => Promise<Module>;
-    readonly performance: Performance;
-    readonly fetch: (url: string) => Promise<Response>;
-    readonly tryCatch: TryCatch;
-    readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
-    readonly http: Http;
-    readonly childProcess: ChildProcess;
-    readonly now: () => number;
-    readonly sandbox: Sandbox;
-    readonly write: (stream: WriteConsoles, data: Vec) => Promise<void>;
-    readonly testContext: TestContext;
-    readonly bunTestContext: TestContext;
-    readonly playwrightTestContext: TestContext;
-    readonly engine: Engine;
-    readonly await: (p: unknown) => Promise<readonly [unknown]>;
-};
-export type App = (io: Io) => Promise<number>;
-export type Run = (f: App) => Promise<never>;
-/**
- * Runs a function and exits the process with the returned code
- * Handles errors by exiting with code 1
- */
-export declare const run: (io: Io) => Run;
-export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }: Io) => EffectToPromise;
-export declare const runProgram: (io: Io) => (args: readonly string[]) => (program: NodeProgram) => Promise<number>;

package/fs/io/module.f.js

@@ -1,113 +0,0 @@
-/**
- * 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";
-import {} from "../types/effects/node/module.f.js";
-import { asBase, asNominal } from "../types/nominal/module.f.js";
-import { error, ok } from "../types/result/module.f.js";
-import { fromVec, listToVec, toVec } from "../types/uint8array/module.f.js";
-/**
- * Runs a function and exits the process with the returned code
- * Handles errors by exiting with code 1
- */
-export const run = (io) => {
-    const exitCode = ([x, b]) => {
-        if (x === 'error') {
-            io.console.error(b);
-            return 1;
-        }
-        else {
-            return b;
-        }
-    };
-    return async (f) => io.process.exit(exitCode(await io.asyncTryCatch(() => f(io))));
-};
-const tc = async (f) => {
-    try {
-        return ok(await f());
-    }
-    catch (e) {
-        return error(e);
-    }
-};
-const collect = async (v) => {
-    let result = [];
-    for await (const a of v) {
-        result = [...result, a];
-    }
-    return result;
-};
-export const fromIo = ({ fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, now: ioNow, sandbox, write, await: awaitPromise, }) => {
-    const result = asyncRun({
-        all: async (...effects) => await Promise.all(effects.map(result)),
-        fetch: async (url) => tc(async () => {
-            const response = await fetch(url);
-            if (!response.ok) {
-                throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
-            }
-            return toVec(new Uint8Array(await response.arrayBuffer()));
-        }),
-        mkdir: (...p) => tc(async () => { await mkdir(...p); }),
-        readFile: path => tc(async () => toVec(await readFile(path))),
-        readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
-            .map(v => ({
-            name: v.name,
-            parentPath: normalize(v.parentPath),
-            isFile: v.isFile()
-        }))),
-        writeFile: (path, data) => tc(() => writeFile(path, fromVec(data))),
-        rm: path => tc(() => rm(path)),
-        access: path => tc(() => access(path)),
-        import: path => tc(() => asyncImport(path)),
-        exec: (command, stdin) => new Promise(resolve => {
-            const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
-            child.stdin?.end(stdin);
-        }),
-        createServer: async (requestListener) => {
-            const erl = requestListener;
-            const nodeRl = async (req, res) => {
-                const reqBody = await collect(req);
-                const { method, url, headers } = req;
-                const { status, headers: outHeaders, body: outBody } = await result(erl({
-                    method,
-                    url,
-                    headers,
-                    body: listToVec(reqBody)
-                }));
-                res
-                    .writeHead(status, outHeaders)
-                    .end(fromVec(outBody));
-            };
-            const server = asNominal(createServer(nodeRl));
-            return server;
-        },
-        listen: async (server, port) => {
-            const s = asBase(server);
-            s.listen(port);
-        },
-        forever: () => new Promise(() => { }),
-        now: async () => ioNow(),
-        sandbox,
-        await: awaitPromise,
-        write,
-        test: async (ctx, name, expectFailure, test) => ctx.test(name, { expectFailure }, async (t) => result(test(t))),
-    });
-    return result;
-};
-export const runProgram = (io) => {
-    const { process: { env, stdout, stderr }, testContext, bunTestContext, playwrightTestContext, engine } = io;
-    const std = { stdout, stderr };
-    const f = fromIo(io);
-    return args => {
-        const options = { args, env, std, testContext, bunTestContext, playwrightTestContext, engine };
-        return program => f(program(options));
-    };
-};