spl-lang 0.6.0 → 1.0.0

package/README.md

@@ -1,106 +1,77 @@
-# spl-lang 0.3
-
-The Semantic Prompt Language interpreter. Requires Node.js 20+.
-
-See the [project guide](../README.md), [language specification](../LANG-PRD.md),
-[EBNF](docs/syntax.ebnf), and [documentation site](../docs/index.html).
-
-## Run from a checkout
-
-```sh
-npm install
-node dist/cli.js login
-node dist/cli.js examples/hi.spl
-```
-
-`npm install` runs the TypeScript build. Installed packages expose `spl` and `spl-lang`.
-Authentication is needed only for live generation and explicit agents; raw tools and replay
-work without Copilot. Existing Copilot/CLI credentials and supported GitHub token environment
-variables are reused. `spl login` otherwise runs device authentication and saves credentials
-under `~/.spl` (override with `SPL_HOME`); `spl logout` removes those saved credentials.
-
-## Language contract
-
-- **Exact tools:** `read_file(path)`, `write_file(path, content)`, `web_fetch(url)`,
-  `web_search(query)`, `shell(command)` never call a model.
-- **Generation:** `?` and `think` have no tools or MCP access.
-- **Agency:** `agent` explicitly enables model-directed runtime and configured MCP tools.
-- **Validation:** expression-valued `schema` uses strict synchronous JSON Schema draft-07;
-  `fmt` supports `integer`, `float`, `array`, `object`, `text`, and `boolean`.
-  Non-text formats require strict JSON of the selected type; `float` accepts any finite
-  number, including whole numbers, and `object` requires a dict, not a list.
-  `fmt='json'` still accepts any JSON value. Prose and code fences are not silently extracted.
-- **Repairs:** `repairs=0..5` retries only malformed/invalid generation, not transport errors
-  or external actions. Agents require `repairs=0`. Use `assert` for business rules.
-- **Guidance:** `enforce`/`forbid` and `len` influence prompts, not runtime guarantees.
-- **Capabilities:** nested `restrict fs/net/exec/mcp` clauses intersect. Shell command
-  inspection is best effort; MCP servers are trusted services, not OS-sandboxed.
-- **Bindings:** every block has a lexical child scope. `let` declares/redeclares locally
-  and shadows outer names. Reads and assignments search outward for the first declaration;
-  child locals, loop variables and caught failures do not leak to parents.
-- **Expressions:** blocks and conditionals yield their final expression, otherwise `None`.
-  `{}` remains an empty dict. Functions still require explicit `return`.
-- **Logging:** `log(...)` defaults to info. `log{level=debug}(...)` selects error/info/debug;
-  bare level names, strings and expressions are accepted and checked at runtime.
-- **Runtime inputs:** `$env.NAME` / `$env['NAME']` reads process environment strings;
-  `$args[i]` reads repeated CLI `--arg` strings in order (empty list by default).
-  Missing environment names and out-of-range argument indexes return `None`.
-  Both are read-only snapshots, including through aliases, and are not automatically persisted.
-
-Common generation modifiers are `len`, `fmt`, `reasoning`, `show`, `schema`, `repairs`,
-and `model`. Values are evaluated once, then validated before calling the model.
-`think` and `agent` default to medium reasoning; `?` uses the model default.
-CLI `--model` overrides per-call `model`, which overrides the header directive.
-
-## Record/replay
-
-```sh
-node dist/cli.js examples/triage-issues.spl --record triage.jsonl
-node dist/cli.js examples/triage-issues.spl --replay triage.jsonl --silent
-```
-
-Record creates a new file and rejects agents. Replay performs exact, ordered request matching
-without starting Copilot/MCP. Local reads are permitted; writes, shell, network, agents,
-and persistent stores are blocked. Recordings include prompts and raw responses and must
-be protected like logs. Mismatched, missing, or unused entries fail explicitly.
-
-## CLI
-
-```text
-spl script.spl [--model id] [--mcp file.json] [--cwd dir] [--timeout seconds]
-               [--store file.json | --store-module module]
-               [--record file.jsonl | --replay file.jsonl]
-               [--log-level error|info|debug] [--silent] [--check]
-               [--arg value ...]
-```
-
-Results are printed on stdout, logs on stderr. Full prompts/responses and statement traces
-appear at every non-silent log level. Exit codes are `0` success, `1` script failure,
-`2` syntax/usage error, and `70` internal error. `--check` does not execute modifier expressions
-or compile schemas. See [CLI and MCP configuration](../docs/cli.html).
-
-## Tests and embedding
-
-```sh
-npm test
-```
-
-The default suite is offline. In PowerShell, opt into authenticated live checks with
-`$env:SPL_LIVE_TESTS='1'; npm test`, then remove the environment variable.
-
-The package exports `parse`, `run`, `Logger`, `CopilotBackend`, `RecordingBackend`,
-`ReplayBackend`, variable stores, authentication helpers, and related types.
-Call `close()` on the backend after running; replay also checks for unused entries there.
-Custom backends must honor the request kind: only `agent` may execute tools.
-Embedding callers can pass `args: ['first', 'second']` in `RunOptions`; omitted
-arguments default to `[]`, not the host's `process.argv`. Each run snapshots `process.env`.
-See [embedding](../docs/internals.html#embedding).
-
-## Migration
-
-Use `enforce` and `forbid` for scoped prompt guidance; `instruct` and `avoid` are not accepted.
-0.3 removes `think{level=...}`, tool-command syntax, and `let` before
-compound/member/index assignments. Use `reasoning`, ordinary raw functions, and explicit agents instead.
-Blocks create lexical child scopes; replace inner `let` with assignment when an outer
-binding must be updated. See the [migration table](../README.md#breaking-changes-in-03).
-`fmt='object'` is now object-only; use `fmt='array'` for lists or `fmt='json'` for any JSON value.
+# spl-lang
+
+The SPL interpreter and CLI. Runs Markdown workflows that mix Python-like `spl` fences with
+natural-language blockquotes. Requires Node.js 20+. See the
+[documentation](https://dgawlik.github.io/semantic-prompt-language/) for the full guide.
+
+## Run
+
+```sh
+npm install -g spl-lang      # or, in this folder: npm install && node dist/cli.js
+spl login
+spl examples/hi.md
+```
+
+`spl login` reuses Copilot CLI, `gh` or `GH_TOKEN`/`GITHUB_TOKEN` credentials, or runs GitHub's device
+flow. Workflows without model calls, `--check` and replay work without signing in.
+
+```text
+spl workflow.md [--arg value ...] [--model id] [--cwd dir] [--mcp file.json] [--timeout s]
+                [--store file.json | --store-module module]
+                [--trace file.jsonl | --record file.jsonl | --replay file.jsonl]
+                [--log-level error|info|debug] [--silent] [--check]
+spl workflow.md --checkpoint run.jsonl
+spl workflow.md --resume run.jsonl [--answer-for ID (--answer text | --answer-file file)]
+spl login | logout
+```
+
+The result goes to stdout and logs to stderr. Exit codes: `0` success, `1` script failure,
+`2` syntax or usage error, `3` waiting for human input, `70` internal error.
+See [CLI & runtime](../docs-template/CLI.md).
+
+## Language in brief
+
+```spl
+let Rating = {'type': 'object', 'properties': {'score': {'type': 'integer'}}, 'required': ['score']}
+let review = read_file('review.txt')
+let rating = ask(schema=Rating, repairs=2) 'Rate this review from 1 to 5: {review}'
+assert 1 <= rating.score and rating.score <= 5 'score out of range'
+restrict './out' {
+    write_file('./out/rating.json', json_stringify(rating))
+}
+success rating
+```
+
+* Exact tools `read_file`, `write_file`, `web_fetch`, `web_search` and `shell` never call a model.
+* `ask` and `think` generate values without tools; `agent` can act, within `restrict` scopes.
+* Blockquotes are translated into SPL by the model and run in the same scope.
+* `fmt`, `schema`, `repairs` and `assert` check output; `enforce`/`forbid` only guide prompts.
+
+See [Language](../docs-template/Language.md), [Natural language & models](../docs-template/LLM-commands.md)
+and [Guards & failures](../docs-template/Safety.md).
+
+## Embedding
+
+```js
+import { parseMarkdown, run, Logger, CopilotBackend } from 'spl-lang';
+
+const logger = new Logger('silent');
+const backend = new CopilotBackend({ logger, cwd: process.cwd(), timeoutMs: 300_000 });
+try {
+  const result = await run(parseMarkdown(source), { backend, logger, args: ['first'] });
+  console.log(result);
+} finally {
+  await backend.close();
+}
+```
+
+Also exported: `parse` (raw SPL), `TraceBackend`, `ReplayBackend`, `RecordingBackend`, variable stores,
+`Checkpoint`, authentication helpers and types. See [Embedding](../docs-template/CLI.md#embedding).
+
+## Tests
+
+```sh
+npm test
+```
+
+Tests are offline. In PowerShell, `$env:SPL_LIVE_TESTS='1'; npm test` adds authenticated live tests.

package/dist/ast.d.ts

@@ -79,6 +79,10 @@ export type Expr = {
     t: 'log';
     level: Expr;
     args: Expr[];
+} | {
+    t: 'human';
+    prompt: Expr;
+    line: number;
 } | {
     t: 'ask' | 'think' | 'agent';
     mods: Record<string, Expr>;
@@ -142,6 +146,9 @@ export type Stmt = Base & ({
     t: 'continue';
 } | {
     t: 'pass';
+} | {
+    t: 'natural';
+    text: string;
 } | {
     t: 'def';
     name: string;
@@ -185,5 +192,8 @@ export interface Program {
     directives: Directives;
     body: Stmt[];
     lines: string[];
+    markdown?: {
+        preamble?: string;
+    };
 }
 export {};

package/dist/checkpoint.d.ts

@@ -0,0 +1,59 @@
+export interface CheckpointContext {
+    source: string;
+    runtime: string;
+    cwd: string;
+    args?: readonly string[];
+    configuration?: unknown;
+}
+export interface HumanRequest {
+    run_id: string;
+    request_id: string;
+    question: string;
+    checkpoint: string;
+    line: number;
+}
+export declare class CheckpointError extends Error {
+    readonly kind: 'usage' | 'infrastructure';
+    constructor(message: string, kind?: 'usage' | 'infrastructure');
+}
+export declare class SuspensionSignal {
+    readonly request: HumanRequest;
+    constructor(request: HumanRequest);
+}
+export declare function checkpointFingerprint(value: unknown): string;
+/** A single-writer effect history. Only sealed human-input boundaries can resume. */
+export declare class Checkpoint {
+    readonly file: string;
+    private readonly fd;
+    private readonly lock;
+    private readonly header;
+    private readonly events;
+    private position;
+    private readonly replayLength;
+    private sequence;
+    private observedEnvironment;
+    private pending?;
+    private closed;
+    private poisoned;
+    private terminal;
+    private constructor();
+    static create(file: string, context: CheckpointContext): Checkpoint;
+    static resume(file: string, context: CheckpointContext): Checkpoint;
+    private static acquire;
+    get runId(): string;
+    get args(): readonly string[];
+    get replaying(): boolean;
+    get request(): HumanRequest | undefined;
+    private pendingRequest;
+    answer(requestId: string, value: string): void;
+    private write;
+    private append;
+    observeEnvironment(snapshot: unknown): void;
+    effect<T>(request: unknown, perform: () => Promise<T>, valid: (value: unknown) => value is T): Promise<T>;
+    human(question: string, line: number): string;
+    finish(status: 'success' | 'failure'): void;
+    assertConsumed(): void;
+    validateSource(source: string, args?: readonly string[]): void;
+    private assertActive;
+    close(): void;
+}

package/dist/checkpoint.js

@@ -0,0 +1,382 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { Failure } from './errors.js';
+import { isTraceError } from './recording.js';
+export class CheckpointError extends Error {
+    kind;
+    constructor(message, kind = 'usage') {
+        super(message);
+        this.kind = kind;
+        this.name = 'CheckpointError';
+    }
+}
+export class SuspensionSignal {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+}
+const record = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const strings = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string');
+const integer = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (record(value))
+        return `{${Object.keys(value).filter((key) => value[key] !== undefined).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        throw new CheckpointError('checkpoint identity contains an unsupported value', 'infrastructure');
+    return json;
+}
+export function checkpointFingerprint(value) {
+    return createHash('sha256').update(canonical(value)).digest('hex');
+}
+function environmentFingerprint() {
+    return checkpointFingerprint(Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined)));
+}
+function identity(context) {
+    return {
+        source: checkpointFingerprint(context.source.replace(/\r\n/g, '\n')),
+        runtime: context.runtime,
+        cwd: fs.realpathSync.native(path.resolve(context.cwd)),
+        configuration: checkpointFingerprint(context.configuration ?? null),
+    };
+}
+function parseHeader(value) {
+    if (!record(value) || value.format !== 'spl-checkpoint' || value.version !== 1
+        || typeof value.run_id !== 'string' || !value.run_id
+        || typeof value.source !== 'string' || typeof value.runtime !== 'string'
+        || typeof value.cwd !== 'string' || !strings(value.args) || typeof value.configuration !== 'string') {
+        throw new CheckpointError('unsupported or invalid checkpoint header');
+    }
+    return {
+        format: value.format, version: value.version, run_id: value.run_id, source: value.source,
+        runtime: value.runtime, cwd: value.cwd, args: value.args, configuration: value.configuration,
+    };
+}
+function parseEvent(value) {
+    if (record(value)) {
+        switch (value.type) {
+            case 'intent':
+                if (integer(value.sequence) && typeof value.request === 'string') {
+                    return { type: value.type, sequence: value.sequence, request: value.request };
+                }
+                break;
+            case 'outcome':
+                if (integer(value.sequence) && record(value.outcome)) {
+                    if (Object.hasOwn(value.outcome, 'value') && !Object.hasOwn(value.outcome, 'error')) {
+                        return { type: value.type, sequence: value.sequence, outcome: { value: value.outcome.value } };
+                    }
+                    if (!Object.hasOwn(value.outcome, 'value') && isTraceError(value.outcome.error)) {
+                        return { type: value.type, sequence: value.sequence, outcome: { error: value.outcome.error } };
+                    }
+                }
+                break;
+            case 'environment':
+                if (typeof value.fingerprint === 'string')
+                    return { type: value.type, fingerprint: value.fingerprint };
+                break;
+            case 'question':
+                if (typeof value.request_id === 'string' && value.request_id && typeof value.question === 'string' && integer(value.line)) {
+                    return { type: value.type, request_id: value.request_id, question: value.question, line: value.line };
+                }
+                break;
+            case 'answer':
+                if (typeof value.request_id === 'string' && typeof value.value === 'string') {
+                    return { type: value.type, request_id: value.request_id, value: value.value };
+                }
+                break;
+            case 'terminal':
+                if (value.status === 'success' || value.status === 'failure')
+                    return { type: value.type, status: value.status };
+        }
+    }
+    throw new CheckpointError('invalid checkpoint event');
+}
+function validateHistory(events) {
+    let sequence = 0;
+    let intent;
+    let pending;
+    let terminal = false;
+    let environment = false;
+    const requests = new Set();
+    for (const event of events) {
+        if (terminal)
+            throw new CheckpointError('events after terminal checkpoint state');
+        if (intent !== undefined && event.type !== 'outcome')
+            throw new CheckpointError('checkpoint has an unresolved effect');
+        if (pending && event.type !== 'answer')
+            throw new CheckpointError('checkpoint has an unanswered question');
+        switch (event.type) {
+            case 'intent':
+                if (event.sequence !== sequence++)
+                    throw new CheckpointError('invalid checkpoint effect sequence');
+                intent = event.sequence;
+                break;
+            case 'outcome':
+                if (intent === undefined || intent !== event.sequence)
+                    throw new CheckpointError('outcome without matching checkpoint intent');
+                intent = undefined;
+                break;
+            case 'question':
+                if (requests.has(event.request_id))
+                    throw new CheckpointError('duplicate checkpoint request ID');
+                requests.add(event.request_id);
+                pending = event;
+                break;
+            case 'answer':
+                if (!pending || pending.request_id !== event.request_id)
+                    throw new CheckpointError('answer without matching checkpoint question');
+                pending = undefined;
+                break;
+            case 'environment':
+                if (environment)
+                    throw new CheckpointError('duplicate checkpoint environment');
+                environment = true;
+                if (event.fingerprint !== environmentFingerprint())
+                    throw new CheckpointError('checkpoint environment mismatch');
+                break;
+            case 'terminal':
+                terminal = true;
+        }
+    }
+    if (terminal)
+        throw new CheckpointError('checkpoint run is already terminal');
+    if (intent !== undefined)
+        throw new CheckpointError('checkpoint has an unresolved effect; manual recovery required');
+    if (!pending)
+        throw new CheckpointError('checkpoint run was interrupted; manual recovery required');
+    return pending;
+}
+function ioMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** A single-writer effect history. Only sealed human-input boundaries can resume. */
+export class Checkpoint {
+    file;
+    fd;
+    lock;
+    header;
+    events;
+    position = 0;
+    replayLength;
+    sequence;
+    observedEnvironment = false;
+    pending;
+    closed = false;
+    poisoned = false;
+    terminal = false;
+    constructor(file, fd, lock, header, events, pending) {
+        this.file = file;
+        this.fd = fd;
+        this.lock = lock;
+        this.header = header;
+        this.events = events;
+        this.pending = pending;
+        this.replayLength = events.length;
+        this.sequence = events.filter((event) => event.type === 'intent').length;
+    }
+    static create(file, context) {
+        const resolved = path.resolve(file);
+        const lock = this.acquire(resolved);
+        let fd;
+        try {
+            const header = {
+                format: 'spl-checkpoint', version: 1, run_id: randomUUID(),
+                ...identity(context), args: [...(context.args ?? [])],
+            };
+            fd = fs.openSync(resolved, 'wx', 0o600);
+            const checkpoint = new Checkpoint(resolved, fd, lock, header, []);
+            checkpoint.write(header);
+            return checkpoint;
+        }
+        catch (error) {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+            fs.closeSync(lock);
+            fs.unlinkSync(`${resolved}.lock`);
+            if (error instanceof CheckpointError)
+                throw error;
+            throw new CheckpointError(`cannot create checkpoint: ${ioMessage(error)}`);
+        }
+    }
+    static resume(file, context) {
+        const resolved = path.resolve(file);
+        const lock = this.acquire(resolved);
+        let fd;
+        try {
+            const text = fs.readFileSync(resolved, 'utf8');
+            if (!text.endsWith('\n'))
+                throw new CheckpointError('truncated checkpoint; manual recovery required');
+            const lines = text.slice(0, -1).split('\n');
+            const header = parseHeader(JSON.parse(lines.shift() ?? ''));
+            const expected = identity(context);
+            for (const key of ['source', 'runtime', 'cwd', 'configuration']) {
+                if (expected[key] !== header[key])
+                    throw new CheckpointError(`checkpoint ${key} mismatch`);
+            }
+            if (context.args !== undefined && canonical(context.args) !== canonical(header.args)) {
+                throw new CheckpointError('checkpoint script arguments mismatch');
+            }
+            const events = lines.map((line) => parseEvent(JSON.parse(line)));
+            const pending = validateHistory(events);
+            fd = fs.openSync(resolved, 'a');
+            return new Checkpoint(resolved, fd, lock, header, events, pending);
+        }
+        catch (error) {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+            fs.closeSync(lock);
+            fs.unlinkSync(`${resolved}.lock`);
+            if (error instanceof CheckpointError)
+                throw error;
+            throw new CheckpointError(`cannot resume checkpoint: ${ioMessage(error)}`);
+        }
+    }
+    static acquire(file) {
+        try {
+            return fs.openSync(`${file}.lock`, 'wx', 0o600);
+        }
+        catch (error) {
+            throw new CheckpointError(`cannot lock checkpoint (another writer or stale lock may exist): ${ioMessage(error)}`);
+        }
+    }
+    get runId() { return this.header.run_id; }
+    get args() { return [...this.header.args]; }
+    get replaying() { return this.position < this.replayLength; }
+    get request() {
+        return this.pending ? { run_id: this.runId, checkpoint: this.file, ...this.pendingRequest(this.pending) } : undefined;
+    }
+    pendingRequest(question) {
+        return { request_id: question.request_id, question: question.question, line: question.line };
+    }
+    answer(requestId, value) {
+        this.assertActive();
+        if (!this.pending || this.pending.request_id !== requestId) {
+            throw new CheckpointError('answer does not match the pending request ID; use request_id from the latest waiting_for_input response, not run_id');
+        }
+        this.append({ type: 'answer', request_id: requestId, value });
+        this.pending = undefined;
+    }
+    write(value) {
+        this.assertActive();
+        try {
+            fs.writeFileSync(this.fd, JSON.stringify(value) + '\n');
+            fs.fsyncSync(this.fd);
+        }
+        catch (error) {
+            this.poisoned = true;
+            throw new CheckpointError(`cannot durably save checkpoint: ${ioMessage(error)}`, 'infrastructure');
+        }
+    }
+    append(event) {
+        this.write(event);
+        this.events.push(event);
+    }
+    observeEnvironment(snapshot) {
+        this.assertActive();
+        if (this.observedEnvironment)
+            return;
+        const event = { type: 'environment', fingerprint: checkpointFingerprint(snapshot) };
+        if (this.replaying) {
+            if (canonical(this.events[this.position++]) !== canonical(event))
+                throw new CheckpointError('checkpoint environment history mismatch');
+        }
+        else {
+            this.append(event);
+        }
+        this.observedEnvironment = true;
+    }
+    async effect(request, perform, valid) {
+        this.assertActive();
+        const key = canonical(request);
+        if (this.replaying) {
+            const intent = this.events[this.position++];
+            const outcome = this.events[this.position++];
+            if (intent?.type !== 'intent' || intent.request !== key || outcome?.type !== 'outcome' || outcome.sequence !== intent.sequence) {
+                throw new CheckpointError('checkpoint effect history mismatch');
+            }
+            if ('error' in outcome.outcome) {
+                const error = outcome.outcome.error;
+                throw new Failure(error.status_code, error.reason);
+            }
+            if (!valid(outcome.outcome.value))
+                throw new CheckpointError('invalid recorded checkpoint effect result');
+            return structuredClone(outcome.outcome.value);
+        }
+        if (this.pending)
+            throw new CheckpointError('cannot execute before answering the pending question');
+        const sequence = this.sequence++;
+        this.append({ type: 'intent', sequence, request: key });
+        let outcome;
+        try {
+            const value = await perform();
+            if (!valid(value))
+                throw new CheckpointError('invalid live checkpoint effect result', 'infrastructure');
+            outcome = { value };
+        }
+        catch (error) {
+            if (!(error instanceof Failure))
+                throw error;
+            outcome = { error: { status_code: error.statusCode, reason: error.reason } };
+        }
+        this.append({ type: 'outcome', sequence, outcome });
+        if ('error' in outcome)
+            throw new Failure(outcome.error.status_code, outcome.error.reason);
+        if (!valid(outcome.value))
+            throw new CheckpointError('invalid checkpoint effect result', 'infrastructure');
+        return outcome.value;
+    }
+    human(question, line) {
+        this.assertActive();
+        if (this.replaying) {
+            const event = this.events[this.position++];
+            const answer = this.events[this.position++];
+            if (event?.type !== 'question' || event.question !== question || event.line !== line
+                || answer?.type !== 'answer' || answer.request_id !== event.request_id) {
+                throw new CheckpointError('checkpoint human-input history mismatch');
+            }
+            return answer.value;
+        }
+        if (this.pending)
+            throw new CheckpointError('cannot execute before answering the pending question');
+        const event = { type: 'question', request_id: randomUUID(), question, line };
+        this.append(event);
+        this.pending = event;
+        throw new SuspensionSignal({ run_id: this.runId, checkpoint: this.file, ...this.pendingRequest(event) });
+    }
+    finish(status) {
+        this.assertConsumed();
+        this.append({ type: 'terminal', status });
+        this.terminal = true;
+    }
+    assertConsumed() {
+        if (this.replaying || this.pending)
+            throw new CheckpointError('checkpoint ended with unused history or pending input');
+    }
+    validateSource(source, args) {
+        this.assertActive();
+        if (checkpointFingerprint(source.replace(/\r\n/g, '\n')) !== this.header.source)
+            throw new CheckpointError('checkpoint source mismatch');
+        if (args !== undefined && canonical(args) !== canonical(this.header.args))
+            throw new CheckpointError('checkpoint script arguments mismatch');
+    }
+    assertActive() {
+        if (this.closed || this.poisoned || this.terminal)
+            throw new CheckpointError('checkpoint is closed, terminal, or unusable', 'infrastructure');
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            fs.closeSync(this.fd);
+        }
+        finally {
+            fs.closeSync(this.lock);
+            fs.unlinkSync(`${this.file}.lock`);
+        }
+    }
+}