functionalscript 0.35.2 → 0.37.0

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

@@ -1,10 +1,10 @@
-import { parseFromTokens } from "./module.f.js";
-import { tokenize } from "../tokenizer/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { stringToList } from "../../text/utf16/module.f.js";
-import { stringifyAsTree } from "../serializer/module.f.js";
-import { stringify } from "../../json/module.f.js";
+import { parseFromTokens } from './module.f.js';
+import { tokenize } from '../tokenizer/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { stringToList } from '../../text/utf16/module.f.js';
+import { stringifyAsTree } from '../serializer/module.f.js';
+import { stringify } from '../../media/json/module.f.js';
 const tokenizeString = s => toArray(tokenize(stringToList(s))(''));
 const stringifyDjsModule = stringifyAsTree(sort);
 export const proof = {
@@ -251,6 +251,18 @@ export const proof = {
                 throw obj[1].message;
             }
         },
+        // A literal control character inside a string is not valid JSON
+        // syntax (RFC 8259 §7), and DJS string literals are JSON strings.
+        () => {
+            const tokenList = tokenizeString('export default "\t"');
+            const obj = parseFromTokens(tokenList);
+            if (obj[0] !== 'error') {
+                throw obj;
+            }
+            if (obj[1].message !== 'unexpected token') {
+                throw obj[1].message;
+            }
+        },
         () => {
             const tokenList = tokenizeString('export default [,]');
             const obj = parseFromTokens(tokenList);

package/fs/djs/proof.f.js

@@ -1,6 +1,6 @@
-import { compile } from "./module.f.js";
-import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
-import { utf8, utf8ToString } from "../text/module.f.js";
+import { compile } from './module.f.js';
+import { virtual, emptyState } from '../effects/node/virtual/module.f.js';
+import { utf8, utf8ToString } from '../text/module.f.js';
 const readOutput = (root, path) => {
     const file = root[path];
     if (!Array.isArray(file) || file.length === 0) {

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

@@ -1,10 +1,10 @@
-import { fold } from "../../types/list/module.f.js";
-import { concat } from "../../types/string/module.f.js";
-import { flat, flatMap, map, concat as listConcat } from "../../types/list/module.f.js";
+import { fold } from '../../types/list/module.f.js';
+import { concat } from '../../types/string/module.f.js';
+import { flat, flatMap, map, concat as listConcat } from '../../types/list/module.f.js';
 const { entries } = Object;
-import { compose, fn } from "../../types/function/module.f.js";
-import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
-import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "../../json/serializer/module.f.js";
+import { compose, fn } from '../../types/function/module.f.js';
+import { serialize as bigintSerialize } from '../../types/bigint/module.f.js';
+import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from '../../media/json/serializer/module.f.js';
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
 /**

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

@@ -1,7 +1,7 @@
-import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { identity } from "../../types/function/module.f.js";
-import { setProperty } from "../../json/module.f.js";
+import { countRefs, stringify, stringifyAsTree } from './module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { identity } from '../../types/function/module.f.js';
+import { setProperty } from '../../media/json/module.f.js';
 export const proof = {
     stringify: [
         {

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

@@ -1,6 +1,6 @@
-import { empty, flat, map, stateScan } from "../../types/list/module.f.js";
-import { multiply } from "../../types/bigfloat/module.f.js";
-import * as jsTokenizer from "../../js/tokenizer/module.f.js";
+import { empty, flat, map, stateScan } from '../../types/list/module.f.js';
+import { multiply } from '../../types/bigfloat/module.f.js';
+import * as jsTokenizer from '../../js/tokenizer/module.f.js';
 const mapToken = input => {
     switch (input.kind) {
         case 'id':

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

@@ -1,8 +1,8 @@
-import { tokenize } from "./module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-import { stringifyAsTree } from "../serializer/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { stringToList } from "../../text/utf16/module.f.js";
+import { tokenize } from './module.f.js';
+import { map, toArray } from '../../types/list/module.f.js';
+import { stringifyAsTree } from '../serializer/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { stringToList } from '../../text/utf16/module.f.js';
 const tokenizeString = s => toArray(map(withoutMetada)(tokenize(stringToList(s))('')));
 const tokenizeStringWithMetadata = s => toArray(tokenize(stringToList(s))(''));
 const stringify = stringifyAsTree(sort);

package/fs/djs/tokenizer-new/proof.f.js

@@ -1,9 +1,9 @@
-import { descentParser } from "../../bnf/descent/module.f.js";
-import { backspace, ht, lf, ff, cr, quotationMark, solidus, reverseSolidus, digitRange, digit0, latinCapitalLetterA, latinSmallLetterA, latinSmallLetterB, latinSmallLetterF, latinSmallLetterN, latinSmallLetterR, latinSmallLetterT, latinSmallLetterU, range, } from "../../text/ascii/module.f.js";
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { contains } from "../../types/range/module.f.js";
-import { concat, filter, flat, flatMap, map, stateScan, toArray } from "../../types/list/module.f.js";
-import { jsGrammar, parse } from "./module.f.js";
+import { descentParser } from '../../bnf/descent/module.f.js';
+import { backspace, ht, lf, ff, cr, quotationMark, solidus, reverseSolidus, digitRange, digit0, latinCapitalLetterA, latinSmallLetterA, latinSmallLetterB, latinSmallLetterF, latinSmallLetterN, latinSmallLetterR, latinSmallLetterT, latinSmallLetterU, range, } from '../../text/ascii/module.f.js';
+import { stringToCodePointList } from '../../text/utf16/module.f.js';
+import { contains } from '../../types/range/module.f.js';
+import { concat, filter, flat, flatMap, map, stateScan, toArray } from '../../types/list/module.f.js';
+import { jsGrammar, parse } from './module.f.js';
 const mapCodePoint = (cp) => [cp, undefined];
 const descentParserCpOnly = (m, name, cp) => {
     const cpm = toArray(map(mapCodePoint)(cp));

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

@@ -34,3 +34,8 @@ export type djsResult = {
  * on a parse failure or circular dependency.
  */
 export declare const transpile: (path: string) => Effect<ReadFile, Result<Unknown, ParseError>>;
+export declare const proof: {
+    throw: {
+        mapDjsUnresolvedImport: () => Unknown;
+    };
+};

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

@@ -3,17 +3,17 @@
  *
  * @module
  */
-import {} from "../module.f.js";
-import { error, ok } from "../../types/result/module.f.js";
-import { drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
-import { tokenize } from "../tokenizer/module.f.js";
-import { setReplace, at } from "../../types/ordered_map/module.f.js";
-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 "../../effects/module.f.js";
-import { readUtf8File } from "../../effects/node/module.f.js";
+import {} from '../module.f.js';
+import { error, ok } from '../../types/result/module.f.js';
+import { drop, map as listMap, toArray, includes } from '../../types/list/module.f.js';
+import { tokenize } from '../tokenizer/module.f.js';
+import { setReplace, at } from '../../types/ordered_map/module.f.js';
+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 '../../effects/module.f.js';
+import { readUtf8File } from '../../effects/node/module.f.js';
 const mapDjs = context => path => {
     const res = at(path)(context.complete);
     if (res === null) {
@@ -76,3 +76,13 @@ export const transpile = path => foldNextModuleOp(path)({ stack: null, complete:
     const result = at(path)(context.complete)?.djs;
     return pure(ok(result));
 });
+// ── Tests ────────────────────────────────────────────────────────────────────
+export const proof = {
+    throw: {
+        // `mapDjs` is only ever called with an import path that `foldNextModuleOp`
+        // has already resolved into `context.complete`, so the `res === null`
+        // guard is an internal-invariant check unreachable through `transpile`'s
+        // public API. Call it directly with an empty `complete` map to cover it.
+        mapDjsUnresolvedImport: () => mapDjs({ complete: null, stack: null, error: null })('missing.djs'),
+    },
+};

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

@@ -1,8 +1,8 @@
-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 "../../effects/node/virtual/module.f.js";
-import { utf8 } from "../../text/module.f.js";
+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 '../../effects/node/virtual/module.f.js';
+import { utf8 } from '../../text/module.f.js';
 const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));
     return result;

package/fs/effects/memory/module.f.js

@@ -12,10 +12,10 @@
  *
  * @module
  */
-import { asBase as nominalAsBase, asNominal as nominalAsNominal } from "../../types/nominal/module.f.js";
-import { do_ } from "../module.f.js";
-export const asBase = (nominalAsBase);
-export const asNominal = (nominalAsNominal);
+import { asBase as nominalAsBase, asNominal as nominalAsNominal } from '../../types/nominal/module.f.js';
+import { do_ } from '../module.f.js';
+export const asBase = nominalAsBase;
+export const asNominal = nominalAsNominal;
 /** Creates a new typed memory slot with `value` as its initial contents. */
 export const create = do_('memCreate');
 /** Reads the current contents of a typed memory slot. */

package/fs/effects/memory/proof.f.js

@@ -1,6 +1,6 @@
-import { run } from "../mock/module.f.js";
-import { pure } from "../module.f.js";
-import { asBase, asNominal, create, read, write, } from "./module.f.js";
+import { run } from '../mock/module.f.js';
+import { pure } from '../module.f.js';
+import { asBase, asNominal, create, read, write, } from './module.f.js';
 const initial = { next: 0, values: {} };
 const mock = {
     memCreate: value => state => {

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

@@ -1,9 +1,17 @@
 /**
  * Core effect type constructors and combinators.
  *
+ * Effect helpers are **step adapters**: functions that return a continuation
+ * `(t: T) => Effect<Q, R>` meant to be passed into `.step`, never wrappers
+ * that take the effect itself as an argument. `Effect` has no pipeline
+ * operator to lean on and must not be extended with new methods, so
+ * `.step(adapterA).step(adapterB)` is how helpers compose — flat,
+ * left-to-right, in evaluation order. See {@link okStep} for an example.
+ *
  * @module
  */
 import { type List } from '../types/list/module.f.ts';
+import type { Result } from '../types/result/module.f.ts';
 export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;
@@ -43,6 +51,13 @@ export declare const foldStep: <O extends Operation, T, S>(f: (item: T) => (stat
  * results. The `void` accumulator sibling of `foldStep`.
  */
 export declare const forEachStep: <O extends Operation, T>(f: (item: T) => Effect<O, void>) => (items: List<T>) => Effect<O, void>;
+/**
+ * A step adapter for the `error` short-circuit: `error` → pass it through
+ * unchanged as `pure`, `ok` → continue with `f`. Collapses the hand-written
+ * `r[0] === 'error' ? pure(r) : f(r[1])` check that recurs at every site
+ * chaining `Effect<O, Result<T, E>>` steps.
+ */
+export declare const okStep: <T, E, O extends Operation, R>(f: (value: T) => Effect<O, Result<R, E>>) => (r: Result<T, E>) => Effect<O, Result<R, E>>;
 /**
  * The decoded form of an effect's next step: either a final `result`, or a
  * `command` to perform with its `payload` and the `continuation` to resume

package/fs/effects/module.f.js

@@ -1,9 +1,16 @@
 /**
  * Core effect type constructors and combinators.
  *
+ * Effect helpers are **step adapters**: functions that return a continuation
+ * `(t: T) => Effect<Q, R>` meant to be passed into `.step`, never wrappers
+ * that take the effect itself as an argument. `Effect` has no pipeline
+ * operator to lean on and must not be extended with new methods, so
+ * `.step(adapterA).step(adapterB)` is how helpers compose — flat,
+ * left-to-right, in evaluation order. See {@link okStep} for an example.
+ *
  * @module
  */
-import { fold } from "../types/list/module.f.js";
+import { fold } from '../types/list/module.f.js';
 export const pure = (v) => ({
     value: () => v,
     step: f => f(v)
@@ -39,6 +46,13 @@ export const foldStep = (f) => (init) => (items) => fold(item => acc => acc.step
  * results. The `void` accumulator sibling of `foldStep`.
  */
 export const forEachStep = (f) => (items) => foldStep((item) => () => f(item))(undefined)(items);
+/**
+ * A step adapter for the `error` short-circuit: `error` → pass it through
+ * unchanged as `pure`, `ok` → continue with `f`. Collapses the hand-written
+ * `r[0] === 'error' ? pure(r) : f(r[1])` check that recurs at every site
+ * chaining `Effect<O, Result<T, E>>` steps.
+ */
+export const okStep = (f) => (r) => r[0] === 'error' ? pure(r) : f(r[1]);
 /**
  * Decodes an effect's next step: a pure result, or a command to perform.
  *

package/fs/effects/node/memory/module.js

@@ -4,8 +4,8 @@
  * @module
  */
 import { randomUUID } from 'node:crypto';
-import { asyncRun } from "../../module.js";
-import { asBase, asNominal } from "../../memory/module.f.js";
+import { asyncRun } from '../../module.js';
+import { asBase, asNominal } from '../../memory/module.f.js';
 const missingKey = (id) => new Error(`memory key not found: ${id}`);
 /**
  * Creates a stateful operation map backed by an immutable `Map` snapshot.

package/fs/effects/node/memory/proof.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { asyncRun } from "../../module.js";
-import { asNominal, create, read, write, } from "../../memory/module.f.js";
-import { memoryOperationMap, run } from "./module.js";
+import { asyncRun } from '../../module.js';
+import { asNominal, create, read, write, } from '../../memory/module.f.js';
+import { memoryOperationMap, run } from './module.js';
 export const proof = {
     nodeInterpreter: async () => {
         const result = await run(create(1).step(key => write(key, 2).step(() => read(key))));

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

@@ -8,13 +8,13 @@
  *
  * @module
  */
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { toCodePointList } from "../../text/utf8/module.f.js";
-import { codePointListToString } from "../../text/utf16/module.f.js";
-import { reverse } from "../../types/list/module.f.js";
-import { length } from "../../types/bit_vec/module.f.js";
-import { ok, error as resultError } from "../../types/result/module.f.js";
-import { do_, pure } from "../module.f.js";
+import { utf8, utf8ToString } from '../../text/module.f.js';
+import { toCodePointList } from '../../text/utf8/module.f.js';
+import { codePointListToString } from '../../text/utf16/module.f.js';
+import { reverse } from '../../types/list/module.f.js';
+import { length } from '../../types/bit_vec/module.f.js';
+import { ok, error as resultError, mapOk } from '../../types/result/module.f.js';
+import { do_, okStep, pure } from '../module.f.js';
 /**
  * True if `e` is a "file or directory does not exist" (`ENOENT`) error.
  *
@@ -43,7 +43,7 @@ export const readFile = do_('readFile');
  * on errors (e.g. convert them into domain-specific errors) or `unwrap` at the
  * call site.
  */
-export const readUtf8File = (path) => readFile(path).step(r => pure(r[0] === 'ok' ? ok(utf8ToString(r[1])) : r));
+export const readUtf8File = (path) => readFile(path).step(r => pure(mapOk(utf8ToString)(r)));
 export const readdir = do_('readdir');
 export const writeFile = do_('writeFile');
 /** Writes a string to `path` as UTF-8 bytes. */
@@ -70,22 +70,12 @@ const writeLoop = (path) => {
             return pure(resultError('invalid buffer size'));
         }
         return writeBytes(path, offset, v)
-            .step((r) => {
-            if (r[0] === 'error') {
-                return pure(r);
-            }
-            return f(offset + Number(lenV >> 3n), tail);
-        });
+            .step(okStep(() => f(offset + Number(lenV >> 3n), tail)));
     });
     return f;
 };
 export const writeFromStream = (path, e) => createExclusive(path)
-    .step(([r, v]) => {
-    if (r === 'error') {
-        return pure(resultError(v));
-    }
-    return writeLoop(path)(0, e);
-});
+    .step(okStep(() => writeLoop(path)(0, e)));
 export const stat = do_('stat');
 export const createServer = do_('createServer');
 export const listen = do_('listen');

package/fs/effects/node/module.js

@@ -28,16 +28,16 @@ import os from 'node:os';
 import process from 'node:process';
 import { once } from 'node:events';
 import * as testContext from 'node:test';
-import { concat, normalize, toPosix } from "../../path/module.f.js";
-import {} from "../module.f.js";
-import { asyncRun } from "../module.js";
-import { memoryOperationMap } from "./memory/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 { asyncTryCatch } from "../../types/result/module.js";
-import { fromVec, listToVec, toVec } from "../../types/uint8array/module.f.js";
-import { maxLengthBytes } from "../../types/bit_vec/module.f.js";
+import { concat, normalize, toPosix } from '../../path/module.f.js';
+import {} from '../module.f.js';
+import { asyncRun } from '../module.js';
+import { memoryOperationMap } from './memory/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 { asyncTryCatch } from '../../types/result/module.js';
+import { fromVec, listToVec, toVec } from '../../types/uint8array/module.f.js';
+import { maxLengthBytes } from '../../types/bit_vec/module.f.js';
 /**
  * Narrowed structural view of `node:http`'s `createServer`. The official types
  * declare `method`/`url` optional and header values as
@@ -146,6 +146,8 @@ const readStdinByte = async () => {
         }
     }
 };
+const randomMax = Number(1n << 32n);
+const { randomInt } = crypto;
 const runNodeEffect = asyncRun({
     ...memoryOperationMap(),
     all: async (...effects) => await Promise.all(effects.map(runNodeEffect)),
@@ -191,7 +193,7 @@ const runNodeEffect = asyncRun({
             await fh.close();
         }
     }),
-    randomInt: async () => crypto.randomInt(2 ** 32),
+    randomInt: async () => randomInt(randomMax),
     access: path => asyncTryCatch(() => access(path)),
     createExclusive: path => asyncTryCatch(async () => {
         const fh = await open(path, 'wx');

package/fs/effects/node/proof.f.d.ts

@@ -61,4 +61,7 @@ export declare const proof: {
     randomInt: {
         increments: () => void;
     };
+    writeFromStream: {
+        createExclusiveFails: () => void;
+    };
 };

package/fs/effects/node/proof.f.js

@@ -1,8 +1,9 @@
 import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../../text/module.f.js";
 import { decode, pure } from "../module.f.js";
-import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt } from "./module.f.js";
+import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream } from "./module.f.js";
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
+import { empty as listEmpty } from "../list/module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export const proof = {
     map: () => {
@@ -553,4 +554,21 @@ export const proof = {
             }
         },
     },
+    writeFromStream: {
+        createExclusiveFails: () => {
+            // The destination already exists, so `createExclusive` fails (EEXIST) and
+            // the error propagates without ever touching `writeBytes`.
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { hello: [vec8(0x2an)] },
+            })(writeFromStream('hello', listEmpty()));
+            if (t !== 'error') {
+                throw result;
+            }
+            const file = state.root.hello;
+            if (!Array.isArray(file) || uint(file[0]) !== 0x2an) {
+                throw file;
+            }
+        },
+    },
 };

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

@@ -3,13 +3,13 @@
  *
  * @module
  */
-import { todo } from "../../../asserts/module.f.js";
-import { join, parse } from "../../../path/module.f.js";
-import { utf8ToString } from "../../../text/module.f.js";
-import { empty, length, maxLengthBytes, msb, vec } from "../../../types/bit_vec/module.f.js";
-import { error, ok } from "../../../types/result/module.f.js";
-import { run } from "../../mock/module.f.js";
-import { asBase, asNominal } from "../../memory/module.f.js";
+import { todo } from '../../../asserts/module.f.js';
+import { isProperPrefix, join, parse } from '../../../path/module.f.js';
+import { utf8ToString } from '../../../text/module.f.js';
+import { empty, length, maxLengthBytes, msb, vec } from '../../../types/bit_vec/module.f.js';
+import { error, ok } from '../../../types/result/module.f.js';
+import { run } from '../../mock/module.f.js';
+import { asBase, asNominal } from '../../memory/module.f.js';
 export const emptyState = {
     stdout: '',
     stderr: '',
@@ -218,7 +218,6 @@ const insertEntityAt = (dir, path, entity) => {
     }
     return [{ ...dir, [first]: newSub }, result];
 };
-const isProperPrefix = (prefix, path) => prefix.length < path.length && prefix.every((seg, i) => seg === path[i]);
 const rename = (src, dst) => (state) => {
     const srcParsed = parse(src);
     const dstParsed = parse(dst);

package/fs/effects/node/virtual/proof.f.d.ts

@@ -27,5 +27,6 @@ export declare const proof: {
     readBytesFractionalSize: () => void;
     readBytesFractionalOffset: () => void;
     readBytesAcrossChunkBoundary: () => void;
+    writeBytesWrongOffset: () => void;
     largeFileReadBytes: () => void;
 };

package/fs/effects/node/virtual/proof.f.js

@@ -1,7 +1,7 @@
-import { assertEq } from "../../../asserts/module.f.js";
-import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes } from "../module.f.js";
-import { maxLengthBytes, vec, vec8 } from "../../../types/bit_vec/module.f.js";
-import { emptyState, virtual } from "./module.f.js";
+import { assertEq } from '../../../asserts/module.f.js';
+import { awaitIfPromise, fetch, rm, writeFile, readFile, readdir, import_, rename, readBytes, writeBytes } from '../module.f.js';
+import { maxLengthBytes, vec, vec8 } from '../../../types/bit_vec/module.f.js';
+import { emptyState, virtual } from './module.f.js';
 export const proof = {
     rm: {
         success: () => {
@@ -159,6 +159,13 @@ export const proof = {
         const [, result] = virtual({ ...emptyState, root })(readBytes('big', chunkSize - 1, 2));
         assertEq(result[0], 'ok');
     },
+    writeBytesWrongOffset: () => {
+        // writeBytes is append-only; an offset that doesn't match the current
+        // file size must fail rather than silently create a hole.
+        const root = { 'file': [vec8(0x42n)] };
+        const [, result] = virtual({ ...emptyState, root })(writeBytes('file', 5, vec8(0x43n)));
+        assertEq(result[0], 'error');
+    },
     largeFileReadBytes: () => {
         // A file stored as two 128 KiB chunks is larger than maxLengthBytes.
         // readBytes within the second chunk (offset = 128 KiB, size = 1) should succeed.

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

@@ -2,6 +2,7 @@ export declare const proof: {
     lazy: {
         value: () => void;
         deferred: () => void;
+        step: () => void;
     };
     foldStep: {
         empty: () => void;
@@ -12,6 +13,10 @@ export declare const proof: {
         empty: () => void;
         runs: () => void;
     };
+    okStep: {
+        ok: () => void;
+        error: () => void;
+    };
     decode: () => void;
     match: {
         done: () => void;

package/fs/effects/proof.f.js

@@ -1,4 +1,5 @@
-import { decode, do_, foldStep, forEachStep, lazy, match, pure } from "./module.f.js";
+import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } from './module.f.js';
+import { error, ok } from '../types/result/module.f.js';
 const assertPure = (e, expected) => {
     const d = decode(e);
     if (!d.done) {
@@ -26,6 +27,10 @@ export const proof = {
                 throw 'decode must force the thunk';
             }
         },
+        step: () => {
+            const e = lazy(() => 5).step(v => pure(v * 2));
+            assertPure(e, 10);
+        },
     },
     foldStep: {
         empty: () => {
@@ -51,6 +56,22 @@ export const proof = {
             assertPure(e, undefined);
         },
     },
+    okStep: {
+        ok: () => {
+            const e = pure(ok(5)).step(okStep((v) => pure(ok(v * 2))));
+            const d = decode(e);
+            if (!d.done || d.result[0] !== 'ok' || d.result[1] !== 10) {
+                throw e.value;
+            }
+        },
+        error: () => {
+            const e = pure(error('oops')).step(okStep(v => pure(ok(v * 2))));
+            const d = decode(e);
+            if (!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops') {
+                throw e.value;
+            }
+        },
+    },
     decode: () => {
         const d = decode(do_('add')(2, 3));
         if (d.done) {

package/fs/emergent_testing/all.test.js

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

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

@@ -6,7 +6,7 @@ export declare const proof: {
     addTest: () => void;
     mulTest: (() => void)[];
     throw: {
-        todo: () => never;
+        todo: typeof todo;
         divByZero: () => bigint;
     };
     generateSqrTests: () => (() => void)[];

package/fs/emergent_testing/module.f.js

@@ -10,12 +10,12 @@
  *
  * @module
  */
-import { reset, fgGreen, fgRed, bold, csiWrite } from "../text/sgr/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";
-import { definedEntries } from "../types/object/module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from '../text/sgr/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';
+import { definedEntries } from '../types/object/module.f.js';
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {