functionalscript 0.32.4 → 0.34.0

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

@@ -9,7 +9,7 @@ const run = (root) => (path) => {
 };
 export const proof = {
     parse: () => {
-        const result = run({ a: utf8('export default 1') })('a');
+        const result = run({ a: [utf8('export default 1')] })('a');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -19,7 +19,7 @@ export const proof = {
         }
     },
     parseWithSubModule: () => {
-        const result = run({ a: { b: utf8('import c from "c"\nexport default c'), c: utf8('export default 2') } })('a/b');
+        const result = run({ a: { b: [utf8('import c from "c"\nexport default c')], c: [utf8('export default 2')] } })('a/b');
         if (result[0] === 'error') {
             throw result[1];
         }
@@ -30,10 +30,10 @@ export const proof = {
     },
     parseWithSubModules: () => {
         const result = run({
-            a: utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
-            b: utf8('import d from "d"\nexport default [0,d]'),
-            c: utf8('import d from "d"\nexport default [1,d]'),
-            d: utf8('export default 2'),
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import d from "d"\nexport default [0,d]')],
+            c: [utf8('import d from "d"\nexport default [1,d]')],
+            d: [utf8('export default 2')],
         })('a');
         if (result[0] === 'error') {
             throw result[1];
@@ -44,7 +44,7 @@ export const proof = {
         }
     },
     parseWithFileNotFoundError: () => {
-        const result = run({ a: utf8('import b from "b"\nexport default b') })('a');
+        const result = run({ a: [utf8('import b from "b"\nexport default b')] })('a');
         if (result[0] !== 'error') {
             throw result;
         }
@@ -54,9 +54,9 @@ export const proof = {
     },
     parseWithCycleError: () => {
         const result = run({
-            a: utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'),
-            b: utf8('import c from "c"\nexport default c'),
-            c: utf8('import b from "b"\nexport default b'),
+            a: [utf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]')],
+            b: [utf8('import c from "c"\nexport default c')],
+            c: [utf8('import b from "b"\nexport default b')],
         })('a');
         if (result[0] !== 'error') {
             throw result;

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

@@ -0,0 +1,31 @@
+import { type Effect, type Operation } from "../module.f.ts";
+export type NonEmpty<O extends Operation, T> = {
+    readonly first: T;
+    readonly tail: List<O, T>;
+};
+/**
+ * The payload of a `List` effect: the next cons cell, or `undefined` at
+ * end-of-stream.
+ *
+ * Since `Pure<T>` is now itself a lazy thunk (`() => T`), the effect alone is the
+ * suspension point and the cell needs no extra wrapping thunk. `Effect<O, Next<O, T>>`
+ * is used directly in places where `List<O, T>` cannot be written as a return type
+ * (see {@link empty}).
+ */
+export type Next<O extends Operation, T> = NonEmpty<O, T> | undefined;
+export type List<O extends Operation, T> = Effect<O, Next<O, T>>;
+/**
+ * The empty `List`: a pure end-of-stream marker (`undefined`).
+ *
+ * The explicit `Effect<O, Next<O, T>>` return type lets the contextual type drive the
+ * check, so the recursive payload type-checks without a cast. Construct streams through
+ * these two combinators.
+ *
+ * Note: we use `Effect<O, Next<O, T>>` because TypeScript can't convert `pure(...)` to
+ *       `List<O, T>`.
+ */
+export declare const empty: <O extends Operation, T>() => Effect<O, Next<O, T>>;
+/**
+ * Prepends `head` to a `ListEffect` `tail`, as a pure cons cell. See {@link empty}.
+ */
+export declare const nonEmpty: <O extends Operation, T>(first: T, tail: List<O, T>) => Effect<O, Next<O, T>>;

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

@@ -0,0 +1,16 @@
+import { pure } from "../module.f.js";
+/**
+ * The empty `List`: a pure end-of-stream marker (`undefined`).
+ *
+ * The explicit `Effect<O, Next<O, T>>` return type lets the contextual type drive the
+ * check, so the recursive payload type-checks without a cast. Construct streams through
+ * these two combinators.
+ *
+ * Note: we use `Effect<O, Next<O, T>>` because TypeScript can't convert `pure(...)` to
+ *       `List<O, T>`.
+ */
+export const empty = () => pure(undefined);
+/**
+ * Prepends `head` to a `ListEffect` `tail`, as a pure cons cell. See {@link empty}.
+ */
+export const nonEmpty = (first, tail) => pure({ first, tail });

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

@@ -10,12 +10,19 @@ export type Effect<O extends Operation, T> = {
     step: <Q extends Operation, R>(f: (p: T) => Effect<Q, R>) => Effect<O | Q, R>;
 };
 export type Value<O extends Operation, T> = Pure<T> | Do<O, T>;
-export type Pure<T> = readonly [T];
+export type Pure<T> = () => T;
 export type DoKPR<O extends Operation, T, K extends string, PR extends readonly [unknown, unknown]> = readonly [K, PR[0], (_: PR[1]) => Effect<O, T>];
 export type Pr<O extends Operation, K extends O[0]> = O extends readonly [K, (...args: infer P) => infer R] ? readonly [P, R] : never;
 export type DoK<O extends Operation, T, K extends O[0]> = DoKPR<O, T, K, Pr<O, K>>;
 export type Do<O extends Operation, T> = DoK<O, T, O[0]>;
 export declare const pure: <T>(v: T) => Effect<never, T>;
+/**
+ * A lazy pure effect. Like {@link pure}, but takes a thunk and evaluates it on
+ * demand instead of holding an already-computed value. Use this to produce the
+ * next item of a list without instantiating the rest — the thunk runs only when
+ * the effect is decoded (or stepped into).
+ */
+export declare const lazy: <T>(t: () => T) => Effect<never, T>;
 export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, param: Pr<O, K>[0], cont: (input: Pr<O, K>[1]) => Effect<O, T>) => Effect<O, T>;
 export type Param<O extends Operation> = F<O>[0];
 export type Return<O extends Operation> = F<O>[1];
@@ -53,10 +60,10 @@ export type Decoded<O extends Operation, T> = {
 /**
  * Decodes an effect's next step: a pure result, or a command to perform.
  *
- * This is the only function that knows how `Value` is laid out (a length-1
- * tuple for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
+ * This is the only function that knows how `Value` is laid out (a thunk
+ * `() => T` for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
  * Interpreters and proofs must go through `decode` (or `match`) instead of
- * inspecting the tuple, so the representation can change without touching
+ * inspecting the value, so the representation can change without touching
  * them.
  */
 export declare const decode: <O extends Operation, T>({ value }: Effect<O, T>) => Decoded<O, T>;
@@ -82,4 +89,3 @@ export type ToAsyncOperationMap<O extends Operation> = {
 };
 export type F<O extends Operation> = Pr<O, O[0]>;
 export type Func<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;
-export type ListEffect<O extends Operation, T> = Effect<O, readonly [T, ListEffect<O, T>] | undefined>;

package/fs/effects/module.f.js

@@ -5,9 +5,19 @@
  */
 import { fold } from "../types/list/module.f.js";
 export const pure = (v) => ({
-    value: [v],
+    value: () => v,
     step: f => f(v)
 });
+/**
+ * A lazy pure effect. Like {@link pure}, but takes a thunk and evaluates it on
+ * demand instead of holding an already-computed value. Use this to produce the
+ * next item of a list without instantiating the rest — the thunk runs only when
+ * the effect is decoded (or stepped into).
+ */
+export const lazy = (t) => ({
+    value: t,
+    step: f => f(t())
+});
 export const doFull = (cmd, param, cont) => ({
     value: [cmd, param, cont],
     step: (f) => doFull(cmd, param, x => cont(x).step(f)),
@@ -32,14 +42,14 @@ export const forEachStep = (f) => (items) => foldStep((item) => () => f(item))(u
 /**
  * Decodes an effect's next step: a pure result, or a command to perform.
  *
- * This is the only function that knows how `Value` is laid out (a length-1
- * tuple for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
+ * This is the only function that knows how `Value` is laid out (a thunk
+ * `() => T` for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
  * Interpreters and proofs must go through `decode` (or `match`) instead of
- * inspecting the tuple, so the representation can change without touching
+ * inspecting the value, so the representation can change without touching
  * them.
  */
-export const decode = ({ value }) => value.length === 1
-    ? { done: true, result: value[0] }
+export const decode = ({ value }) => typeof value === 'function'
+    ? { done: true, result: value() }
     : { done: false, command: value[0], payload: value[1], continuation: value[2] };
 /**
  * Decodes an effect's next step and dispatches its command to `map`,

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

@@ -1,9 +1,10 @@
-import type { Vec } from '../../types/bit_vec/module.f.ts';
+import { type Vec } from '../../types/bit_vec/module.f.ts';
 import type { MemOp } from '../memory/module.f.ts';
 import type { Nominal } from '../../types/nominal/module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
 import type { StringMap } from '../../types/object/module.f.ts';
 import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
+import type { List } from '../list/module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
 /**
  * True if `e` is a "file or directory does not exist" (`ENOENT`) error.
@@ -81,7 +82,32 @@ export type Exec = readonly ['exec', (command: string, stdin?: string) => IoResu
 export declare const exec: Func<Exec>;
 export type Access = readonly ['access', (path: string) => IoResult<void>];
 export declare const access: Func<Access>;
-export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access;
+/**
+ * Creates `path` as an empty file with `O_CREAT|O_EXCL` — fails if it already
+ * exists. This is the exclusive create that claims a staging name in the
+ * lock-free upload ([staging-lease.md](../../../issues/cas/staging-lease.md));
+ * with 256 random bits in the name `EEXIST` never happens in practice, so it
+ * is just a sanity guard.
+ */
+export type CreateExclusive = readonly ['createExclusive', (path: string) => IoResult<void>];
+export declare const createExclusive: Func<CreateExclusive>;
+/**
+ * Writes the **entire** `data` vector to an **existing** `path` at byte `offset`
+ * (positional write). The mirror of {@link readBytes}: it never creates the file
+ * (a missing path is `ENOENT`), and it writes every byte or returns an error —
+ * the runner loops over short writes — so a later size check can never pass over
+ * a hole. Bounded to ≤128 KiB per call, like `readBytes`.
+ */
+export type WriteBytes = readonly ['writeBytes', (path: string, offset: number, data: Vec) => IoResult<void>];
+export declare const writeBytes: Func<WriteBytes>;
+export declare const writeFromStream: <O extends Operation>(path: string, e: List<O, IoResult<Vec>>) => Effect<O | WriteBytes | CreateExclusive, IoResult<void>>;
+/** File metadata returned by {@link stat}. Only `size` (in bytes) for now. */
+export type FileStat = {
+    readonly size: number;
+};
+export type Stat = readonly ['stat', (path: string) => IoResult<FileStat>];
+export declare const stat: Func<Stat>;
+export type Fs = Mkdir | ReadFile | ReadBytes | Readdir | WriteFile | Rm | Rename | Exec | Access | CreateExclusive | WriteBytes | Stat;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
 export type Headers = StringMap<string, string>;
 export type IncomingMessage = {
@@ -216,7 +242,7 @@ export type TestContext = {
 /** Effect operation that registers a named test with the active `TestContext`. */
 export type Test = readonly ['test', (ctx: TestContext, name: string, expectFailure: boolean, test: (t: TestContext) => Effect<Test | All | Await, void>) => void];
 export declare const test: Func<Test>;
-export type NodeOp = All | Await | Fetch | Fs | Http | Forever | Import | MemOp | Now | RandomInt | Read | Sandbox | Write | Test;
+export type NodeOp = Access | All | Await | Fetch | Fs | Http | Forever | Import | MemOp | Now | RandomInt | Read | Sandbox | Write | Test;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 /**
  * Writes an error line to `stderr` and yields exit code `1`. The canonical

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

@@ -12,7 +12,8 @@ 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 { ok } from "../../types/result/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";
 /**
  * True if `e` is a "file or directory does not exist" (`ENOENT`) error.
@@ -53,6 +54,39 @@ export const readBytes = do_('readBytes');
 export const randomInt = do_('randomInt');
 export const exec = do_('exec');
 export const access = do_('access');
+export const createExclusive = do_('createExclusive');
+export const writeBytes = do_('writeBytes');
+const writeLoop = (path) => {
+    const f = (offset, e) => e.step(r => {
+        if (r === undefined) {
+            return pure(ok(undefined));
+        }
+        const { first: [t, v], tail } = r;
+        if (t === 'error') {
+            return pure(resultError(v));
+        }
+        const lenV = length(v);
+        if ((lenV & 7n) !== 0n) {
+            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);
+        });
+    });
+    return f;
+};
+export const writeFromStream = (path, e) => createExclusive(path)
+    .step(([r, v]) => {
+    if (r === 'error') {
+        return pure(resultError(v));
+    }
+    return writeLoop(path)(0, e);
+});
+export const stat = do_('stat');
 export const createServer = do_('createServer');
 export const listen = do_('listen');
 export const forever = do_('forever');

package/fs/effects/node/module.js

@@ -35,6 +35,7 @@ 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";
 /**
@@ -44,14 +45,6 @@ import { maxLengthBytes } from "../../types/bit_vec/module.f.js";
  * requires them present; this local view keeps the narrowing in one place.
  */
 const createServer = http.createServer;
-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) {
@@ -156,15 +149,15 @@ const readStdinByte = async () => {
 const runNodeEffect = asyncRun({
     ...memoryOperationMap(),
     all: async (...effects) => await Promise.all(effects.map(runNodeEffect)),
-    fetch: async (url) => tc(async () => {
+    fetch: async (url) => asyncTryCatch(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 () => {
+    mkdir: (...p) => asyncTryCatch(async () => { await mkdir(...p); }),
+    readFile: path => asyncTryCatch(async () => {
         const fileStats = await stat(path);
         // if the file is too big, toVec should fail anyway but in this case we don't want to load the file.
         if (fileStats.size > maxFileSizeBytes) {
@@ -172,16 +165,16 @@ const runNodeEffect = asyncRun({
         }
         return toVec(await readFile(path));
     }),
-    readdir: (path, r) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+    readdir: (path, r) => asyncTryCatch(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)),
-    rename: (src, dst) => tc(() => rename(src, dst)),
-    readBytes: (path, offset, size) => tc(async () => {
+    writeFile: (path, data) => asyncTryCatch(() => writeFile(path, fromVec(data))),
+    rm: path => asyncTryCatch(() => rm(path)),
+    rename: (src, dst) => asyncTryCatch(() => rename(src, dst)),
+    readBytes: (path, offset, size) => asyncTryCatch(async () => {
         if (offset < 0) {
             throw new Error(`Offset ${offset} is negative`);
         }
@@ -199,8 +192,29 @@ const runNodeEffect = asyncRun({
         }
     }),
     randomInt: async () => crypto.randomInt(2 ** 32),
-    access: path => tc(() => access(path)),
-    import: path => tc(() => asyncImport(path)),
+    access: path => asyncTryCatch(() => access(path)),
+    createExclusive: path => asyncTryCatch(async () => {
+        const fh = await open(path, 'wx');
+        await fh.close();
+    }),
+    writeBytes: (path, offset, data) => asyncTryCatch(async () => {
+        const fh = await open(path, 'r+');
+        try {
+            const buffer = fromVec(data);
+            // Loop over short writes so the whole Vec lands — a partial pwrite would
+            // leave a hole the publish-time size check could pass over.
+            let written = 0;
+            while (written < buffer.length) {
+                const { bytesWritten } = await fh.write(buffer, written, buffer.length - written, offset + written);
+                written += bytesWritten;
+            }
+        }
+        finally {
+            await fh.close();
+        }
+    }),
+    stat: path => asyncTryCatch(async () => ({ size: (await stat(path)).size })),
+    import: path => asyncTryCatch(() => asyncImport(path)),
     exec: (command, stdin) => new Promise(resolve => {
         const child = exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
         child.stdin?.end(stdin);

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

@@ -51,7 +51,7 @@ export const proof = {
                 throw result;
             }
             const a = state.root.a;
-            if (a === undefined || isVec(a)) {
+            if (a === undefined || Array.isArray(a)) {
                 throw a;
             }
         },
@@ -61,11 +61,11 @@ export const proof = {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object') {
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
                 throw state.root;
             }
             const cache = tmp.cache;
-            if (typeof cache !== 'object') {
+            if (typeof cache !== 'object' || Array.isArray(cache)) {
                 throw tmp;
             }
         },
@@ -84,7 +84,7 @@ export const proof = {
             const initial = {
                 ...emptyState,
                 root: {
-                    hello: vec8(0x2an),
+                    hello: [vec8(0x2an)],
                 },
             };
             const [state, [t, result]] = virtual(initial)(readFile('hello'));
@@ -104,7 +104,7 @@ export const proof = {
         nested: () => {
             const [_, [tag, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } }
+                root: { tmp: { cache: [vec8(0x15n)] } }
             })(readFile('tmp/cache'));
             if (tag === 'error') {
                 throw result;
@@ -133,7 +133,7 @@ export const proof = {
             const initial = {
                 ...emptyState,
                 root: {
-                    smallFile: vec8(0x2an),
+                    smallFile: [vec8(0x2an)],
                 },
             };
             const [_, [t, result]] = virtual(initial)(readFile('smallFile'));
@@ -149,7 +149,7 @@ export const proof = {
         ok: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { hello: utf8('Hello, world!') },
+                root: { hello: [utf8('Hello, world!')] },
             })(readUtf8File('hello'));
             if (t !== 'ok') {
                 throw result;
@@ -170,9 +170,9 @@ export const proof = {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    file: vec8(0x2an),
+                    file: [vec8(0x2an)],
                     dir: {
-                        a: empty
+                        a: [empty]
                     },
                 },
             })(readdir('', { recursive: true }));
@@ -192,9 +192,9 @@ export const proof = {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    file: vec8(0x2an),
+                    file: [vec8(0x2an)],
                     dir: {
-                        a: empty
+                        a: [empty]
                     },
                 },
             })(readdir('', {}));
@@ -216,7 +216,7 @@ export const proof = {
         nested: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } }
+                root: { tmp: { cache: [vec8(0x15n)] } }
             })(readdir('tmp', { recursive: true }));
             if (t !== 'ok') {
                 throw result;
@@ -249,10 +249,10 @@ export const proof = {
                 throw result;
             }
             const file = state.root.hello;
-            if (!isVec(file)) {
+            if (!Array.isArray(file)) {
                 throw file;
             }
-            if (uint(file) !== 0x2an) {
+            if (uint(file[0]) !== 0x2an) {
                 throw file;
             }
         },
@@ -260,17 +260,17 @@ export const proof = {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: {
-                    hello: vec8(0x15n),
+                    hello: [vec8(0x15n)],
                 },
             })(writeFile('hello', vec8(0x2an)));
             if (t !== 'ok') {
                 throw result;
             }
             const file = state.root.hello;
-            if (!isVec(file)) {
+            if (!Array.isArray(file)) {
                 throw file;
             }
-            if (uint(file) !== 0x2an) {
+            if (uint(file[0]) !== 0x2an) {
                 throw file;
             }
         },
@@ -300,7 +300,7 @@ export const proof = {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (tmp === undefined || isVec(tmp)) {
+            if (tmp === undefined || Array.isArray(tmp)) {
                 throw tmp;
             }
         },
@@ -311,10 +311,10 @@ export const proof = {
             throw result;
         }
         const file = state.root.hello;
-        if (!isVec(file)) {
+        if (!Array.isArray(file)) {
             throw file;
         }
-        if (utf8ToString(file) !== 'Hello, world!') {
+        if (utf8ToString(file[0]) !== 'Hello, world!') {
             throw file;
         }
     },
@@ -322,7 +322,7 @@ export const proof = {
         one: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { hello: vec8(0x2an) },
+                root: { hello: [vec8(0x2an)] },
             })(rm('hello'));
             if (t !== 'ok') {
                 throw result;
@@ -334,13 +334,13 @@ export const proof = {
         nested: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { cache: vec8(0x15n) } },
+                root: { tmp: { cache: [vec8(0x15n)] } },
             })(rm('tmp/cache'));
             if (t !== 'ok') {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object') {
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
                 throw state.root;
             }
             if (tmp.cache !== undefined) {
@@ -376,8 +376,8 @@ export const proof = {
         const [_, results] = virtual({
             ...emptyState,
             root: {
-                a: vec8(0x2an),
-                b: vec8(0x15n),
+                a: [vec8(0x2an)],
+                b: [vec8(0x15n)],
             },
         })(both(readFile('a'))(readFile('b')));
         if (results[0][0] !== 'ok') {
@@ -446,7 +446,7 @@ export const proof = {
         fileOverFile: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { src: vec8(0x2an), dst: vec8(0x15n) },
+                root: { src: [vec8(0x2an)], dst: [vec8(0x15n)] },
             })(rename('src', 'dst'));
             if (t !== 'ok') {
                 throw result;
@@ -454,23 +454,23 @@ export const proof = {
             if (state.root.src !== undefined) {
                 throw state.root;
             }
-            if (!isVec(state.root.dst)) {
+            if (!Array.isArray(state.root.dst)) {
                 throw state.root;
             }
-            if (uint(state.root.dst) !== 0x2an) {
+            if (uint(state.root.dst[0]) !== 0x2an) {
                 throw state.root;
             }
         },
         nestedRename: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { tmp: { src: vec8(0x2an) } },
+                root: { tmp: { src: [vec8(0x2an)] } },
             })(rename('tmp/src', 'tmp/dst'));
             if (t !== 'ok') {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object') {
+            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
                 throw state.root;
             }
             if (tmp.src !== undefined) {
@@ -480,12 +480,12 @@ export const proof = {
         dirOverFile: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
-                root: { src: {}, dst: vec8(0x15n) },
+                root: { src: {}, dst: [vec8(0x15n)] },
             })(rename('src', 'dst'));
             if (t !== 'error') {
                 throw result;
             }
-            if (!isVec(state.root.dst)) {
+            if (!Array.isArray(state.root.dst)) {
                 throw state.root;
             }
         },
@@ -500,8 +500,8 @@ export const proof = {
         simple: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { file: vec8(0xabcdn) },
-            })(readBytes('file', 0, 2));
+                root: { file: [vec8(0xabn)] },
+            })(readBytes('file', 0, 1));
             if (t !== 'ok') {
                 throw result;
             }
@@ -512,7 +512,7 @@ export const proof = {
         withOffset: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { file: vec8(0xabcdn) },
+                root: { file: [vec8(0xabn), vec8(0xcdn)] },
             })(readBytes('file', 1, 1));
             if (t !== 'ok') {
                 throw result;
@@ -524,7 +524,7 @@ export const proof = {
         oversizeChunk: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
-                root: { file: vec8(0x2an) },
+                root: { file: [vec8(0x2an)] },
             })(readBytes('file', 0, Number(2n ** 32n)));
             if (t !== 'error') {
                 throw result;