functionalscript 0.43.1 → 0.45.0

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

@@ -1,88 +0,0 @@
-/**
- * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
- * `MetaStep` representation used by tool-specific modules, and assemblers like
- * `install`, `test`, `ubuntu`, and `toSteps`.
- *
- * @module
- */
-import { actions, 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 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 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 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]>;
-    }>;
-}>;
-export declare const gitHubActionSchema: {
-    readonly name: import("../../types/rtti/module.f.ts").String;
-    readonly on: {
-        readonly pull_request: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
-        readonly merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
-    };
-    readonly permissions: import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>;
-    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 merge_group: import("../../types/rtti/module.f.ts").Or<readonly [{}, undefined]>;
-    };
-    readonly permissions: import("../../types/rtti/module.f.ts").Type1<"record", import("../../types/rtti/module.f.ts").String>;
-    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;
-    readonly step: Step;
-} | {
-    readonly type: 'rust';
-    readonly target?: string;
-} | {
-    readonly type: 'apt-get';
-    readonly package: string;
-};
-export declare const uses: (name: keyof typeof actions, w?: Record<string, string>) => Step;
-export declare const install: (step: Step) => MetaStep;
-export declare const test: (step: Step) => MetaStep;
-export declare const toSteps: (m: readonly MetaStep[]) => readonly Step[];
-export declare const ubuntu: (ms: readonly MetaStep[]) => Job;
-export declare const ubuntuArm: (ms: readonly MetaStep[]) => Job;

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

@@ -1,63 +0,0 @@
-/**
- * Shared CI types and helpers: GitHub Actions step/job RTTI schemas, the
- * `MetaStep` representation used by tool-specific modules, and assemblers like
- * `install`, `test`, `ubuntu`, and `toSteps`.
- *
- * @module
- */
-import { actions, images } 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'];
-export const stepSchema = {
-    run: option(string),
-    uses: option(string),
-    with: option(record(string))
-};
-export const jobSchema = {
-    'runs-on': string,
-    steps: array(stepSchema)
-};
-export const jobsSchema = record(jobSchema);
-export const gitHubActionSchema = {
-    name: string,
-    on: {
-        pull_request: option({}),
-        merge_group: option({})
-    },
-    permissions: record(string),
-    jobs: jobsSchema
-};
-export const parseGitHubAction = rttiParse(gitHubActionSchema);
-export const uses = (name, w) => ({
-    uses: `${name}@${actions[name]}`,
-    ...(w === undefined ? {} : { with: w })
-});
-export const install = (step) => ({ type: 'install', step });
-export const test = (step) => ({ type: 'test', step });
-export const toSteps = (m) => {
-    const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
-    const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');
-    const needRust = m.find(v => v.type === 'rust') !== undefined;
-    const targets = m.flatMap(v => v.type === 'rust' && v.target !== undefined ? [v.target] : []).join(',');
-    return [
-        ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
-        ...(needRust ? [uses('dtolnay/rust-toolchain', {
-                components: 'rustfmt,clippy',
-                ...(targets === '' ? {} : { targets }),
-            })] : []),
-        ...filter('install'),
-        uses('actions/checkout'),
-        ...filter('test'),
-    ];
-};
-export const ubuntu = (ms) => ({
-    'runs-on': images.ubuntu.intel,
-    steps: toSteps(ms)
-});
-export const ubuntuArm = (ms) => ({
-    'runs-on': images.ubuntu.arm,
-    steps: toSteps(ms)
-});

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

@@ -1,45 +0,0 @@
-/**
- * Centralized version pins and OS images used by the CI generator: runner
- * images, tool versions (Bun, Deno, Rust, Node, Wasmtime, Wasmer, TSGO).
- *
- * @module
- */
-export declare const images: {
-    readonly ubuntu: {
-        readonly intel: 'ubuntu-26.04';
-        readonly arm: 'ubuntu-26.04-arm';
-    };
-    readonly macos: {
-        readonly intel: 'macos-26-intel';
-        readonly arm: 'macos-26';
-    };
-    readonly windows: {
-        readonly intel: 'windows-2025';
-        readonly arm: 'windows-11-arm';
-    };
-};
-export declare const functionalscript: '0.41.0';
-export declare const bun = "1.3.14";
-export declare const deno = "2.9.4";
-export declare const node: {
-    readonly default: '26.6.0';
-    readonly node22: '22.23.2';
-    readonly node24: '24.18.0';
-};
-export declare const nixpkgs: {
-    readonly ref: 'nixos-26.05';
-    readonly commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555';
-};
-export declare const wasmtime = "47.0.3";
-export declare const wasmer = "7.2.1";
-export declare const actions: {
-    readonly 'actions/checkout': 'v7.0.1';
-    readonly 'actions/setup-node': 'v7.0.0';
-    readonly 'actions/cache': 'v6.1.0';
-    readonly 'denoland/setup-deno': 'v2.0.5';
-    readonly 'oven-sh/setup-bun': 'v2.2.0';
-    readonly 'bytecodealliance/actions/wasmtime/setup': 'v1.1.3';
-    readonly 'wasmerio/setup-wasmer': 'v3.1';
-    readonly 'cachix/install-nix-action': 'v31.11.0';
-    readonly 'dtolnay/rust-toolchain': '1.97.1';
-};

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

@@ -1,80 +0,0 @@
-/**
- * Centralized version pins and OS images used by the CI generator: runner
- * images, tool versions (Bun, Deno, Rust, Node, Wasmtime, Wasmer, TSGO).
- *
- * @module
- */
-// https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
-export const images = {
-    ubuntu: {
-        intel: 'ubuntu-26.04',
-        arm: 'ubuntu-26.04-arm'
-    },
-    macos: {
-        intel: 'macos-26-intel',
-        arm: 'macos-26'
-    },
-    windows: {
-        intel: 'windows-2025',
-        arm: 'windows-11-arm',
-    }
-};
-// Bootstrap package version used by generated smoke tests. Keep this on a
-// published FunctionalScript release; do not tie it to package.json's current
-// in-repo version.
-// https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.41.0';
-// https://bun.sh/
-export const bun = '1.3.14';
-// https://deno.com/
-export const deno = '2.9.4';
-// The Node versions the pinned Nixpkgs snapshot below provides — read from
-// `pkgs/development/web/nodejs/v{22,24,26}.nix` at that commit. Every runtime
-// uses these: `setup-node` on the GitHub-hosted runners and the generated
-// flakes on the Nix jobs, which assert the version they actually get. Nixpkgs
-// usually trails nodejs.org, so bump the snapshot first and copy the versions
-// it offers rather than the latest release.
-// https://nodejs.org/en/download
-export const node = {
-    default: '26.6.0',
-    node22: '22.23.2',
-    node24: '24.18.0',
-};
-// Official Nixpkgs snapshot used by the generated CI flakes. `ref` is the
-// stable channel the commit is accepted from; `commit` is the exact revision
-// every generated `flake.nix` pins. The Node versions above come from this
-// snapshot, so the two move together.
-// https://channels.nixos.org/nixos-26.05/git-revision
-export const nixpkgs = {
-    ref: 'nixos-26.05',
-    commit: '04607e1165ac22c5fde6dcc54c9e0b3c0487c555',
-};
-// https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '47.0.3';
-// https://github.com/wasmerio/wasmer/releases
-export const wasmer = '7.2.1';
-// GitHub Action versions used by CI step builders. The key is the action
-// `owner/name`; call sites compose the full ref as
-// `` `${name}@${actions[name]}` ``.
-// Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
-export const actions = {
-    // https://github.com/marketplace/actions/checkout
-    'actions/checkout': 'v7.0.1',
-    // https://github.com/marketplace/actions/setup-node-js-environment
-    'actions/setup-node': 'v7.0.0',
-    // https://github.com/marketplace/actions/cache
-    'actions/cache': 'v6.1.0',
-    // https://github.com/marketplace/actions/setup-deno
-    'denoland/setup-deno': 'v2.0.5',
-    // https://github.com/marketplace/actions/setup-bun
-    'oven-sh/setup-bun': 'v2.2.0',
-    // https://github.com/bytecodealliance/actions
-    'bytecodealliance/actions/wasmtime/setup': 'v1.1.3',
-    // https://github.com/wasmerio/setup-wasmer
-    'wasmerio/setup-wasmer': 'v3.1',
-    // https://github.com/marketplace/actions/install-nix
-    // Enables the `nix-command` and `flakes` experimental features by default.
-    'cachix/install-nix-action': 'v31.11.0',
-    // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.97.1',
-};

package/fjs/ci/deno/module.f.d.ts

@@ -1,10 +0,0 @@
-import { type MetaStep } from '../common/module.f.ts';
-/**
- * The regular expression selecting FunctionalScript implementation modules for
- * Deno coverage. Both authored extensions are included so a module migrated
- * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
- * the `--test-coverage-include` list in `package.json` and to the `cov` task in
- * `deno.json`.
- */
-export declare const coverageInclude: '.*module\\.f\\.(ts|mjs)';
-export declare const denoSteps: (version: string) => readonly MetaStep[];

package/fjs/ci/deno/module.f.js

@@ -1,28 +0,0 @@
-/**
- * CI step builder for Deno: installs the pinned Deno version and runs the
- * FunctionalScript package smoke test plus Deno coverage in one canonical job.
- *
- * @module
- */
-import { deno } from '../config/module.f.js';
-import { install, test, uses } from '../common/module.f.js';
-const denoTest = 'deno test --allow-read --allow-env --allow-sys';
-/**
- * The regular expression selecting FunctionalScript implementation modules for
- * Deno coverage. Both authored extensions are included so a module migrated
- * from `.f.ts` to `.f.mjs` stays in the report. Keep it semantically equal to
- * the `--test-coverage-include` list in `package.json` and to the `cov` task in
- * `deno.json`.
- */
-export const coverageInclude = '.*module\\.f\\.(ts|mjs)';
-export const denoSteps = (version) => [
-    install(uses('denoland/setup-deno', { 'deno-version': deno })),
-    // We need --minimum-dependency-age=0 for functionalscript because we would like to use
-    // the latest version of the package even if it is not yet 24 hours old,
-    // which is the default minimum dependency age for Deno installs.
-    // This way we can test the latest version of the package in CI without waiting for 24 hours.
-    install({ run: `deno install -g -A --minimum-dependency-age=0 npm:functionalscript@${version}` }),
-    test({ run: `deno run -A --minimum-dependency-age=0 npm:functionalscript@${version} t` }),
-    test({ run: 'deno install --frozen' }),
-    test({ run: `${denoTest} --coverage && deno coverage --include='${coverageInclude}'` }),
-];

package/fjs/ci/deno/proof.f.d.ts

@@ -1,5 +0,0 @@
-export declare const proof: {
-    coverageInclude: () => void;
-    coverageStep: () => void;
-    installsPinnedVersion: () => void;
-};

package/fjs/ci/deno/proof.f.js

@@ -1,26 +0,0 @@
-import { coverageInclude, denoSteps } from './module.f.js';
-import { toSteps } from '../common/module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-const coverageRuns = (version) => toSteps(denoSteps(version))
-    .flatMap(s => s.run !== undefined && s.run.includes('deno coverage') ? [s.run] : []);
-export const proof = {
-    // A regression guard: dropping either authored implementation extension
-    // from the Deno coverage filter silently removes those modules from the
-    // CI coverage report while CI still passes.
-    coverageInclude: () => {
-        assertEq(coverageInclude, '.*module\\.f\\.(ts|mjs)');
-    },
-    coverageStep: () => {
-        const runs = coverageRuns('0.0.0');
-        assertEq(runs.length, 1);
-        const [run] = runs;
-        assert(run !== undefined);
-        assert(run.includes(`deno coverage --include='${coverageInclude}'`));
-    },
-    installsPinnedVersion: () => {
-        const runs = toSteps(denoSteps('1.2.3'))
-            .flatMap(s => s.run !== undefined && s.run.includes('npm:functionalscript@') ? [s.run] : []);
-        assertEq(runs.length, 2);
-        assert(runs.every(r => r.includes('npm:functionalscript@1.2.3')));
-    },
-};

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

@@ -1,13 +0,0 @@
-/**
- * Continuous integration helper commands for repository automation tasks.
- *
- * @module
- */
-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 nodeExtra: (os: Os) => readonly MetaStep[];
-};
-export declare const ci: ({ nodeExtra }: Setup) => Effect<NodeOp, number>;
-export declare const main: () => Effect<NodeOp, number>;

package/fjs/ci/module.f.js

@@ -1,58 +0,0 @@
-/**
- * Continuous integration helper commands for repository automation tasks.
- *
- * @module
- */
-import { mapStep, step } from '../effects/module.f.js';
-import { access, writeUtf8File } from '../effects/node/module.f.js';
-import { functionalscript, images } from './config/module.f.js';
-import { architecture, os, toSteps, ubuntuArm } from './common/module.f.js';
-import { rustPlatformSteps, rustWasmSteps } from './rust/module.f.js';
-import { nodeMainSteps, nodeNixJobs, nodeNixVersionSteps, nodeVersionJobs } from './node/module.f.js';
-import { nixFlakes, nixInstall } from './nix/module.f.js';
-import { bunSteps } from './bun/module.f.js';
-import { denoSteps } from './deno/module.f.js';
-const job = (rust, nodeExtra) => (o) => (a) => {
-    const id = `${o}-${a}`;
-    const image = images[o][a];
-    const result = [
-        ...(rust ? rustPlatformSteps(o, a) : []),
-        ...nodeMainSteps(functionalscript),
-        ...nodeExtra,
-    ];
-    return [id, { 'runs-on': image, steps: toSteps(result) }];
-};
-// Every generated flake, across all job families that own one.
-const nixJobs = nodeNixJobs;
-// Temporary: proves the not-yet-migrated flakes still evaluate. Removed once
-// the canonical Node jobs check their own flake by running through it.
-const nixFlakeJob = ubuntuArm([nixInstall, ...nodeNixVersionSteps]);
-const canonicalJobs = (rust) => ({
-    ...(rust ? { wasm: ubuntuArm(rustWasmSteps) } : {}),
-    deno: ubuntuArm(denoSteps(functionalscript)),
-    bun: ubuntuArm(bunSteps(functionalscript)),
-    ...nodeVersionJobs(functionalscript),
-    'nix-flakes': nixFlakeJob,
-});
-export const ci = ({ nodeExtra }) => step(access('Cargo.toml'), result => {
-    const rust = result[0] === 'ok';
-    const jobs = {
-        ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o))(o)))),
-        ...canonicalJobs(rust),
-    };
-    const gha = {
-        name: 'CI',
-        on: {
-            pull_request: {},
-            merge_group: {},
-        },
-        permissions: {
-            contents: 'read',
-        },
-        jobs,
-    };
-    const workflowWritten = writeUtf8File('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '));
-    const flakesWritten = step(workflowWritten, () => nixFlakes(nixJobs));
-    return mapStep(flakesWritten, () => 0);
-});
-export const main = () => ci({ nodeExtra: () => [] });

package/fjs/ci/nix/module.f.d.ts

@@ -1,61 +0,0 @@
-/**
- * Generates one self-contained Nix flake per declared CI job.
- *
- * Each job gets its own `nix/generated/<id>/flake.nix` pinning the exact
- * Nixpkgs commit from `../config/module.f.ts` and exposing a single
- * `devShells.<system>.default` development shell. The files are static and
- * readable on purpose: no job selection, no shared Nix modules, no helper
- * libraries.
- *
- * @module
- */
-import { type Effect } from '../../effects/module.f.ts';
-import { type Mkdir, type WriteFile } from '../../effects/node/module.f.ts';
-import { type MetaStep } from '../common/module.f.ts';
-/** A CI job's development environment, one generated flake each. */
-export type NixJob = {
-    /** Generated directory name under `nix/generated`, matching the CI job id. */
-    readonly id: string;
-    /** Nix system of the job's runner, e.g. `aarch64-linux`. */
-    readonly system: string;
-    /** Nixpkgs attribute names made available in the job's shell. */
-    readonly packages: readonly string[];
-    /** Job-local shell initialization, when the job needs one. */
-    readonly shellHook?: string;
-};
-/** Directory owned by this generator. */
-export declare const generatedDirectory: 'nix/generated';
-/**
- * Serializes a job's flake.
- *
- * The serializer rejects invalid *identifiers*, and every identifier in a flake
- * is written here — a job only contributes attribute names and strings, which
- * are quoted when they are not identifiers. The unwrap is therefore a totality
- * assertion, not an input check.
- */
-export declare const flakeText: (job: NixJob) => string;
-/** Writes one generated flake per job. */
-export declare const nixFlakes: (jobs: readonly NixJob[]) => Effect<Mkdir | WriteFile, void>;
-/** Path a workflow passes to `nix develop`, for the job of the given id. */
-export declare const flakePath: (id: string) => string;
-/** Installs Nix, with `nix-command` and `flakes` enabled by the action's defaults. */
-export declare const nixInstall: MetaStep;
-/** Runs one command inside a job's generated development shell. */
-export declare const nixDevelop: (id: string, command: string) => string;
-/**
- * Runs a migrated job's whole command sequence in one development shell, so the
- * shell's packages and environment reach every command without exporting a
- * profile across GitHub Actions steps.
- *
- * The commands are a shell script, joined so a failure stops the rest, and are
- * quoted as one argument — a command may contain quotes of its own.
- */
-export declare const nixDevelopAll: (id: string, commands: readonly string[]) => string;
-/**
- * Checks a job's generated flake end to end: the shell builds, and the Node it
- * puts on `PATH` is exactly the pinned version. The pinned Nixpkgs commit
- * already determines the version, so this is the only place the expectation
- * is stated — the generated flakes stay declarative instead of carrying an
- * `assert` that restates the commit they pin.
- */
-export declare const nixVersionCheckStep: (id: string, version: string) => MetaStep;

package/fjs/ci/nix/module.f.js

@@ -1,92 +0,0 @@
-/**
- * Generates one self-contained Nix flake per declared CI job.
- *
- * Each job gets its own `nix/generated/<id>/flake.nix` pinning the exact
- * Nixpkgs commit from `../config/module.f.ts` and exposing a single
- * `devShells.<system>.default` development shell. The files are static and
- * readable on purpose: no job selection, no shared Nix modules, no helper
- * libraries.
- *
- * @module
- */
-import { forEachStep, mapStep, pure, step } from '../../effects/module.f.js';
-import { mkdir, writeUtf8File } from '../../effects/node/module.f.js';
-import { nixToString } from '../../media/nix/module.f.js';
-import { fromUndefined, unwrap as unwrapNullable } from '../../types/nullable/module.f.js';
-import { unwrap } from '../../types/result/module.f.js';
-import { install, test, uses } from '../common/module.f.js';
-import { nixpkgs } from '../config/module.f.js';
-/** Directory owned by this generator. */
-export const generatedDirectory = 'nix/generated';
-const { commit } = nixpkgs;
-const url = `github:NixOS/nixpkgs/${commit}`;
-const flake = ({ system, packages, shellHook }) => ['set',
-    ['=', ['inputs', 'nixpkgs', 'url'], url],
-    ['=', ['outputs'], ['lambda',
-            ['open-set-pattern', 'nixpkgs'],
-            ['set',
-                ['=', ['devShells', system, 'default'], ['let',
-                        [['=', ['pkgs'], ['apply',
-                                    ['ref', 'import'],
-                                    ['ref', 'nixpkgs'],
-                                    ['set', ['=', ['system'], system]]
-                                ]]],
-                        ['apply',
-                            ['ref', 'pkgs', 'mkShell'],
-                            ['set',
-                                ['=', ['packages'], ['list', ...packages.map(p => ['ref', 'pkgs', p])]],
-                                ...(shellHook === undefined
-                                    ? []
-                                    : [['=', ['shellHook'], ['indented-string', shellHook]]])
-                            ]
-                        ]
-                    ]]
-            ]
-        ]]
-];
-/**
- * Serializes a job's flake.
- *
- * The serializer rejects invalid *identifiers*, and every identifier in a flake
- * is written here — a job only contributes attribute names and strings, which
- * are quoted when they are not identifiers. The unwrap is therefore a totality
- * assertion, not an input check.
- */
-export const flakeText = (job) => unwrapNullable(fromUndefined(nixToString(flake(job))));
-const writeFlake = (job) => {
-    const directory = `${generatedDirectory}/${job.id}`;
-    const created = mapStep(mkdir(directory, { recursive: true }), unwrap);
-    const written = step(created, () => writeUtf8File(`${directory}/flake.nix`, flakeText(job)));
-    return mapStep(written, unwrap);
-};
-/** Writes one generated flake per job. */
-export const nixFlakes = (jobs) => forEachStep(pure(jobs), writeFlake);
-/** Path a workflow passes to `nix develop`, for the job of the given id. */
-export const flakePath = (id) => `./${generatedDirectory}/${id}`;
-/** Installs Nix, with `nix-command` and `flakes` enabled by the action's defaults. */
-export const nixInstall = install(uses('cachix/install-nix-action'));
-/** Runs one command inside a job's generated development shell. */
-export const nixDevelop = (id, command) => `nix develop ${flakePath(id)} --command ${command}`;
-/**
- * Wraps a string so a POSIX shell reproduces it exactly. Single quotes protect
- * every other character, so only the quote itself needs handling: leave the
- * literal, reopen it, and escape the quote outside (`'` becomes `'\''`).
- */
-const singleQuoted = (value) => `'${value.replaceAll("'", "'\\''")}'`;
-/**
- * Runs a migrated job's whole command sequence in one development shell, so the
- * shell's packages and environment reach every command without exporting a
- * profile across GitHub Actions steps.
- *
- * The commands are a shell script, joined so a failure stops the rest, and are
- * quoted as one argument — a command may contain quotes of its own.
- */
-export const nixDevelopAll = (id, commands) => nixDevelop(id, `bash -euo pipefail -c ${singleQuoted(commands.join(' && '))}`);
-/**
- * Checks a job's generated flake end to end: the shell builds, and the Node it
- * puts on `PATH` is exactly the pinned version. The pinned Nixpkgs commit
- * already determines the version, so this is the only place the expectation
- * is stated — the generated flakes stay declarative instead of carrying an
- * `assert` that restates the commit they pin.
- */
-export const nixVersionCheckStep = (id, version) => test({ run: `test "$(${nixDevelop(id, 'node --version')})" = v${version}` });

package/fjs/ci/nix/proof.f.d.ts

@@ -1,23 +0,0 @@
-export declare const proof: {
-    flakeText: {
-        plain: () => void;
-        shellHook: () => void;
-    };
-    nixFlakes: {
-        write: () => void;
-        every: () => void;
-        nodeShellHook: () => void;
-        packages: () => void;
-        quotedPackage: () => void;
-        multiplePackages: () => void;
-    };
-    workflow: {
-        flakePath: () => void;
-        nixDevelop: () => void;
-        nixDevelopAll: {
-            sequence: () => void;
-            quote: () => void;
-        };
-        nixInstall: () => void;
-    };
-};