functionalscript 0.14.8 → 0.16.0

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

@@ -1,30 +1,63 @@
 import { images } from '../config/module.f.ts';
+import { type Ts } from '../../types/rtti/ts/module.f.ts';
 export declare const os: readonly ["ubuntu", "macos", "windows"];
 export type Os = typeof os[number];
 export declare const architecture: readonly ["intel", "arm"];
 export type Architecture = typeof architecture[number];
 export type Image = typeof images[Os][Architecture];
-export type Step = {
-    readonly run?: string;
-    readonly uses?: string;
-    readonly with?: {
-        readonly [k: string]: string;
-    };
-};
-export type Job = {
-    readonly 'runs-on': Image;
-    readonly steps: readonly Step[];
+declare const stepSchema: {
+    readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+    readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
 };
-export type Jobs = {
-    readonly [jobs: string]: Job;
+declare const jobSchema: {
+    readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
+    readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
+        readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+    }>;
 };
-export type GitHubAction = {
-    readonly name: string;
+declare const jobsSchema: import("../../types/rtti/module.f.ts").Type1<"record", {
+    readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
+    readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
+        readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+        readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+    }>;
+}>;
+declare const gitHubActionSchema: {
+    readonly name: import("../../types/rtti/module.f.ts").String;
     readonly on: {
-        readonly pull_request?: {};
+        readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
     };
-    readonly jobs: Jobs;
+    readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
+        readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
+        readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
+            readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+            readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+            readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+        }>;
+    }>;
 };
+export type Step = Ts<typeof stepSchema>;
+export type Job = Ts<typeof jobSchema>;
+export type Jobs = Ts<typeof jobsSchema>;
+export type GitHubAction = Ts<typeof gitHubActionSchema>;
+export declare const parseGitHubAction: import("../../types/rtti/parse/module.f.ts").Parse<{
+    readonly name: import("../../types/rtti/module.f.ts").String;
+    readonly on: {
+        readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
+    };
+    readonly jobs: import("../../types/rtti/module.f.ts").Type1<"record", {
+        readonly 'runs-on': import("../../types/rtti/module.f.ts").String;
+        readonly steps: import("../../types/rtti/module.f.ts").Type1<"array", {
+            readonly run: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+            readonly uses: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").String, undefined]>;
+            readonly with: import("../../types/rtti/module.f.ts").Or<readonly [import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>, undefined]>;
+        }>;
+    }>;
+}>;
 export type StepType = 'install' | 'test';
 export type MetaStep = {
     readonly type: StepType;
@@ -42,3 +75,4 @@ export declare const clean: (steps: readonly MetaStep[]) => readonly MetaStep[];
 export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
 export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
 export declare const findTgz: (v: Os) => "(Get-ChildItem *.tgz).FullName" | "./*.tgz";
+export {};

package/fs/ci/common/module.f.js

@@ -1,6 +1,25 @@
 import { images, rust } from "../config/module.f.js";
+import { option, array, record, string } from "../../types/rtti/module.f.js";
+import {} from "../../types/rtti/ts/module.f.js";
+import { parse as rttiParse } from "../../types/rtti/parse/module.f.js";
 export const os = ['ubuntu', 'macos', 'windows'];
 export const architecture = ['intel', 'arm'];
+const stepSchema = {
+    run: option(string),
+    uses: option(string),
+    with: option(record(string))
+};
+const jobSchema = {
+    'runs-on': string,
+    steps: array(stepSchema)
+};
+const jobsSchema = record(jobSchema);
+const gitHubActionSchema = {
+    name: string,
+    on: { pull_request: option({}) },
+    jobs: jobsSchema
+};
+export const parseGitHubAction = rttiParse(gitHubActionSchema);
 export const install = (step) => ({ type: 'install', step });
 export const test = (step) => ({ type: 'test', step });
 export const clean = (steps) => [

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

@@ -18,8 +18,8 @@ export declare const playwright = "1.60.0";
 export declare const rust = "1.95.0";
 export declare const node: {
     readonly default: "26.1.0";
-    readonly others: readonly ["22.22.2", "24.15.0"];
+    readonly others: readonly ["22.22.3", "24.15.0"];
 };
 export declare const wasmtime = "44.0.1";
 export declare const wasmer = "7.1.0";
-export declare const tsgo = "7.0.0-dev.20260512.1";
+export declare const tsgo = "7.0.0-dev.20260517.1";

package/fs/ci/config/module.f.js

@@ -24,11 +24,11 @@ export const rust = '1.95.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.1.0',
-    others: ['22.22.2', '24.15.0'],
+    others: ['22.22.3', '24.15.0'],
 };
 // https://github.com/bytecodealliance/wasmtime/releases
 export const wasmtime = '44.0.1';
 // https://github.com/wasmerio/wasmer/releases
 export const wasmer = '7.1.0';
 // https://www.npmjs.com/package/@typescript/native-preview?activeTab=versions
-export const tsgo = '7.0.0-dev.20260512.1';
+export const tsgo = '7.0.0-dev.20260517.1';

package/fs/ci/module.f.js

@@ -51,7 +51,7 @@ const defaultEffect = ci({
     denoExtra: [
         test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
         test({ run: 'deno task fjs t' }),
-        test({ run: 'deno publish --dry-run' }),
+        test({ run: 'deno publish --dry-run --allow-slow-types' }),
     ],
     bunExtra: [
         test({ run: 'bun ./fs/fjs/module.ts t' }),

package/fs/ci/test.f.js

@@ -1,9 +1,13 @@
 import { ci } from "./module.f.js";
 import { utf8ToString } from "../text/module.f.js";
 import { isVec } from "../types/bit_vec/module.f.js";
-import { test } from "./common/module.f.js";
+import { test, parseGitHubAction } from "./common/module.f.js";
 import { assert } from "../dev/module.f.js";
 import { emptyState, virtual } from "../types/effects/node/virtual/module.f.js";
+import {} from "../types/rtti/ts/module.f.js";
+import { parse as jsonParse } from "../json/module.f.js";
+import { unwrap } from "../types/result/module.f.js";
+// type Gha = Ts<typeof gitHubActionSchema>
 const hasRun = (cmd) => (gha) => Object.values(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
 const githubState = {
@@ -19,7 +23,7 @@ const run = (rust, nodeExtra = () => []) => {
     assert(workflows !== undefined && !isVec(workflows), workflows);
     const file = workflows['ci.yml'];
     assert(isVec(file), file);
-    return JSON.parse(utf8ToString(file));
+    return unwrap(parseGitHubAction(jsonParse(utf8ToString(file))));
 };
 export default {
     rust: () => {

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

@@ -11,11 +11,12 @@ export declare const assert: (v: boolean, msg?: unknown) => asserts v;
 export declare const assertEq: <T>(a: T, b: T) => void;
 export type Module = {
     readonly default?: unknown;
+    readonly [k: string]: unknown;
 };
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
-export declare const allFiles2: (s: string) => Effect<Readdir | All, readonly string[]>;
+export declare const allFiles: (s: string) => Effect<Readdir | All, readonly string[]>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
 export declare const index4: NodeProgram;

package/fs/dev/module.f.js

@@ -5,10 +5,13 @@
  */
 import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
-import { all, both, readdir, readFile, writeFile } from "../types/effects/node/module.f.js";
+import { access, all, both, import_, readdir, readFile, writeFile } from "../types/effects/node/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 { 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";
 export const todo = () => { throw 'not implemented'; };
 export const assert = (v, msg = 'assertion failed') => {
     if (!v)
@@ -22,7 +25,7 @@ export const env = ({ process: { env } }) => a => {
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles2 = (s) => {
+export const allFiles = (s) => {
     const load = (p) => begin
         .step(() => readdir(p, {}))
         .step(d => {
@@ -49,28 +52,34 @@ export const allFiles2 = (s) => {
         .step(v => pure(v.flat()));
     return load(s);
 };
-const allFiles = (io) => (s) => fromIo(io)(allFiles2(s));
+const loadFile = (f) => {
+    const doImport = import_(f).step(r => pure([[f, unwrap(r)]]));
+    if (f.endsWith('.f.js')) {
+        return doImport;
+    }
+    if (f.endsWith('.f.ts')) {
+        return access(f.substring(0, f.length - 3) + '.js')
+            .step(r => r[0] === 'ok' ? pure([]) : doImport);
+    }
+    return pure([]);
+};
 export const loadModuleMap = async (io) => {
-    const { fs: { existsSync }, asyncImport } = io;
-    let map = [];
-    const initCwd = env(io)('INIT_CWD');
+    const { process: { env } } = io;
+    const initCwd = env['INIT_CWD'];
     const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
-    for (const f of await allFiles(io)(s)) {
-        if (f.endsWith('.f.js') ||
-            (f.endsWith('.f.ts') && !existsSync(f.substring(0, f.length - 3) + '.js'))) {
-            const source = await asyncImport(f);
-            map = [...map, [f, source]];
-        }
-    }
-    return Object.fromEntries(map.toSorted(cmp));
+    const effect = allFiles(s)
+        .step(files => all(...files.map(loadFile)))
+        .step(entries => pure(Object.fromEntries(entries.flat().toSorted(cmp))));
+    return fromIo(io)(effect);
 };
 const denoJson = './deno.json';
+const parseDenoJson = rttiParse(record(rttiUnknown));
 const index2 = begin
     .step(() => updateVersion)
     .step(() => readFile(denoJson))
-    .step(v => pure(JSON.parse(utf8ToString(unwrap(v)))));
+    .step(v => pure(unwrap(parseDenoJson(jsonParse(utf8ToString(unwrap(v)))))));
 const allFiles2aa = begin
-    .step(() => allFiles2('.'))
+    .step(() => allFiles('.'))
     .step(files => {
     const list = files.filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);

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

@@ -93,6 +93,16 @@ export const test = (input) => {
             if (isTest(k)) {
                 log(`testing ${k}`);
                 [ts, state] = test('| ')(false)(v.default)([ts, state]);
+                // Non-default exports are walked as a sibling test group so
+                // a test file can spread its tests across multiple named
+                // exports (see issue 27 in `issues/README.md`). Skip exports
+                // that parseTestSet would treat as empty (constants, types,
+                // non-test helpers) to avoid noisy empty entries in output.
+                const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
+                    (typeof val === 'object' && val !== null))));
+                if (Object.keys(others).length !== 0) {
+                    [ts, state] = test('| ')(false)(others)([ts, state]);
+                }
             }
             return [ts, state];
         };

package/fs/dev/tf/test.f.d.ts

@@ -14,3 +14,8 @@ declare const _default: {
     };
 };
 export default _default;
+export declare const namedExportTest: () => void;
+export declare const namedExportGroup: {
+    nested: () => void;
+    throw: () => never;
+};

package/fs/dev/tf/test.f.js

@@ -20,3 +20,17 @@ export default {
         },
     },
 };
+// Non-default exports are walked as a sibling test group (see issue 27).
+export const namedExportTest = () => {
+    if (2 + 2 !== 4) {
+        throw 'arithmetic broken';
+    }
+};
+export const namedExportGroup = {
+    nested: () => {
+        if ('a' + 'b' !== 'ab') {
+            throw 'string concat broken';
+        }
+    },
+    throw: () => { throw 'expected to throw'; },
+};

package/fs/fjs/module.f.js

@@ -9,7 +9,9 @@ import { main as testMain } from "../dev/tf/module.f.js";
 import { main as casMain } from "../cas/module.f.js";
 export const main = async (io) => {
     const { error } = io.console;
-    const [command, ...rest] = io.process.argv.slice(2);
+    const { process, asyncImport } = io;
+    const { env } = process;
+    const [command, ...rest] = process.argv.slice(2);
     const eRun = fromIo(io);
     switch (command) {
         case 'test':
@@ -24,8 +26,8 @@ export const main = async (io) => {
         case 'run':
         case 'r':
             const [file, ...args] = rest;
-            const m = await io.asyncImport(file);
-            return eRun(m.default(args));
+            const m = await asyncImport(file);
+            return eRun(m.default(args, env));
         case undefined:
             error('Error: command is required');
             return Promise.resolve(1);

package/fs/io/module.d.ts

@@ -1,5 +1,5 @@
-import { type Io, type Module, type Run } from './module.f.ts';
-import type { NodeProgram } from '../types/effects/node/module.f.ts';
+import { type Io, type Run } from './module.f.ts';
+import type { Module, NodeProgram } from '../types/effects/node/module.f.ts';
 export declare const asyncImport: (v: string) => Promise<Module>;
 export declare const io: Io;
 export declare const legacyRun: Run;

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

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, NodeOp } from '../types/effects/node/module.f.ts';
+import type { Headers, Module, NodeOp, Env } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -31,7 +31,6 @@ export type Fs = {
     readonly writeSync: (fd: number, s: string) => void;
     readonly writeFileSync: (file: string, data: Uint8Array) => void;
     readonly readFileSync: (path: string) => Uint8Array | null;
-    readonly existsSync: (path: string) => boolean;
     readonly promises: {
         readonly readFile: (path: string) => Promise<Uint8Array>;
         readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
@@ -39,6 +38,7 @@ export type Fs = {
         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>;
     };
 };
 /**
@@ -49,12 +49,6 @@ export type Console = {
     readonly log: (...d: unknown[]) => void;
     readonly error: (...d: unknown[]) => void;
 };
-/**
- * Represents an ES module with a default export
- */
-export type Module = {
-    readonly default: unknown;
-};
 /**
  * High-resolution time measurement interface
  * @see https://nodejs.org/api/perf_hooks.html#performance-now
@@ -118,12 +112,6 @@ export type Io = {
     readonly http: Http;
     readonly childProcess: ChildProcess;
 };
-/**
- * The environment variables.
- */
-export type Env = {
-    readonly [k: string]: string | undefined;
-};
 export type App = (io: Io) => Promise<number>;
 export type Run = (f: App) => Promise<never>;
 /**
@@ -132,4 +120,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }: Io) => EffectToPromise;

package/fs/io/module.f.js

@@ -35,9 +35,9 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm, access } }, fetch, http: { createServer }, childProcess, asyncImport, }) => {
     const result = asyncRun({
-        all: async (effects) => await Promise.all(effects.map(result)),
+        all: async (...effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
         log: async (message) => log(message),
         fetch: async (url) => tc(async () => {
@@ -47,13 +47,19 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             }
             return toVec(new Uint8Array(await response.arrayBuffer()));
         }),
-        mkdir: param => tc(async () => { await mkdir(...param); }),
+        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))),
+        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)),
-        exec: ([command, stdin]) => new Promise(resolve => {
+        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);
         }),
@@ -75,7 +81,7 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             const server = asNominal(createServer(nodeRl));
             return server;
         },
-        listen: async ([server, port]) => {
+        listen: async (server, port) => {
             const s = asBase(server);
             s.listen(port);
         },

package/fs/io/module.js

@@ -48,8 +48,8 @@ export const io = {
 export const legacyRun = run(io);
 export const ioRun = (io) => {
     const r = fromIo(io);
-    const { argv } = io.process;
-    return p => r(p(argv));
+    const { argv, env } = io.process;
+    return p => r(p(argv, env));
 };
 const effectRun = ioRun(io);
 export default effectRun;

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

@@ -6,10 +6,9 @@ export const createVirtualIo = (files) => ({
         error: (..._d) => { }
     },
     fs: {
-        writeSync: (fd, s) => { },
+        writeSync: (_fd, _s) => { },
         writeFileSync: (_file, _data) => { },
         readFileSync: (path) => { return at(path)(files); },
-        existsSync: (path) => { return at(path)(files) !== null; },
         promises: {
             readdir: (_path) => Promise.resolve([]),
             readFile: (_path) => Promise.resolve(new Uint8Array()),
@@ -17,6 +16,7 @@ export const createVirtualIo = (files) => ({
             rm: (_path, _options) => Promise.resolve(),
             mkdir: (_path, _options) => Promise.resolve(undefined),
             copyFile: (_src, _dest) => Promise.resolve(),
+            access: (_path) => Promise.resolve(),
         }
     },
     process: {

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

@@ -5,7 +5,7 @@
  */
 import type { Effect, Operation, Pr } from "../module.f.ts";
 export type MemOperationMap<O extends Operation, S> = {
-    readonly [K in O[0]]: (state: S, payload: Pr<O, K>[0]) => readonly [S, Pr<O, K>[1]];
+    readonly [K in O[0]]: (state: S, ...payload: Pr<O, K>[0]) => readonly [S, Pr<O, K>[1]];
 };
 export type RunInstance<O extends Operation, S> = (state: S) => <O1 extends O, T>(effect: Effect<O1, T>) => readonly [S, T];
 export declare const run: <O extends Operation, S>(o: MemOperationMap<O, S>) => RunInstance<O, S>;

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

@@ -9,7 +9,7 @@ export const run = (o) => state => effect => {
         }
         const [cmd, payload, cont] = value;
         const operation = o[cmd];
-        const [ns, m] = operation(s, payload);
+        const [ns, m] = operation(s, ...payload);
         s = ns;
         e = cont(m);
     }

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-export type Operation = readonly [string, (_: never) => unknown];
+export type Operation = readonly [string, (..._: readonly never[]) => unknown];
 export type Effect<O extends Operation, T> = {
     value: Value<O, T>;
     step: <Q extends Operation, R>(f: (p: T) => Effect<Q, R>) => Effect<O | Q, R>;
@@ -11,20 +11,18 @@ export type Effect<O extends Operation, T> = {
 export type Value<O extends Operation, T> = Pure<T> | Do<O, T>;
 export type Pure<T> = readonly [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, (_: infer P) => infer R] ? readonly [P, R] : never;
+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>;
 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];
-export declare const do_: <O extends Operation>(cmd: O[0]) => (param: Param<O>) => Effect<O, Return<O>>;
-export declare const doRest: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
+export declare const do_: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
 export declare const begin: Effect<never, void>;
 export type ToAsyncOperationMap<O extends Operation> = {
-    readonly [K in O[0]]: (payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
+    readonly [K in O[0]]: (...payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
 };
 export type F<O extends Operation> = Pr<O, O[0]>;
-export type Func<O extends Operation> = (_: Param<O>) => Effect<O, Return<O>>;
-export type RestFunc<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;
+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/types/effects/module.f.js

@@ -11,6 +11,5 @@ export const doFull = (cmd, param, cont) => ({
     value: [cmd, param, cont],
     step: (f) => doFull(cmd, param, x => cont(x).step(f)),
 });
-export const do_ = (cmd) => (param) => doFull(cmd, param, pure);
-export const doRest = (cmd) => (...param) => do_(cmd)(param);
+export const do_ = (cmd) => (...param) => doFull(cmd, param, pure);
 export const begin = pure(undefined);

package/fs/types/effects/module.js

@@ -6,7 +6,7 @@ export const asyncRun = (map) => async (effect) => {
         }
         const [command, payload, continuation] = value;
         const operation = map[command];
-        const result = await operation(payload);
+        const result = await operation(...payload);
         effect = continuation(result);
     }
 };