poe-code 8.0.0 → 8.0.1

package/packages/safejs/dist/cli.js

@@ -1,569 +1,604 @@
 #!/usr/bin/env node
+import {
+  countLineBreaks,
+  createBrokenPipeState,
+  createLintModulesFromRuntimeRegistry,
+  createSafeOutputStream,
+  extractBlock,
+  formatInterpreterError,
+  makeAgentModule,
+  makeFailModule,
+  makeFsModule,
+  makeHarnessModule,
+  makeLogModule,
+  makeMetricModule,
+  splitFrontmatter,
+  withBrokenPipeGuard
+} from "./chunks/chunk-AVDRLE3Y.js";
+import {
+  Budget,
+  SandboxError,
+  dump,
+  dumpCurrent,
+  hasOwnErrorCode,
+  lint,
+  parseModule,
+  replaceErrorStack,
+  restore,
+  run
+} from "./chunks/chunk-ME5BTAZT.js";
+
+// packages/safejs/src/cli.ts
 import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import path, { dirname, extname } from "node:path";
 import { formatWithOptions } from "node:util";
 import { fileURLToPath } from "node:url";
-import { hasOwnErrorCode } from "./error-codes.js";
-import { formatInterpreterError } from "./error/format.js";
-import { replaceErrorStack } from "./error/shape.js";
-import { Budget, SandboxError } from "./interp/budget.js";
-import { countLineBreaks, extractBlock } from "./loader/extract-block.js";
-import { splitFrontmatter } from "./loader/frontmatter.js";
-import { lint } from "./lint.js";
-import { createLintModulesFromRuntimeRegistry } from "./lint/runtime-modules.js";
-import { makeAgentModule } from "./modules/agent.js";
-import { makeFailModule } from "./modules/fail.js";
-import { makeFsModule } from "./modules/fs.js";
-import { makeHarnessModule } from "./modules/harness.js";
-import { makeLogModule } from "./modules/log.js";
-import { makeMetricModule } from "./modules/metric.js";
-import { createBrokenPipeState, createSafeOutputStream, withBrokenPipeGuard } from "./output-stream.js";
-import { parseModule } from "./parse/parser.js";
-import { restore } from "./restore.js";
-import { run } from "./run.js";
-import { dump, dumpCurrent } from "./snapshot/dump.js";
-const EXIT_RUNTIME = 1;
-const EXIT_PARSE = 2;
-const EXIT_BUDGET = 3;
-const EXIT_SIGINT = 130;
-export async function runCli(argv, options = {}) {
-    const brokenPipe = createBrokenPipeState();
-    const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
-    const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
-    return withBrokenPipeGuard([options.stdout ?? process.stdout, options.stderr ?? process.stderr], brokenPipe, async () => {
-        try {
-            if (argv.includes("--help") || argv.includes("-h")) {
-                stdout.write(`${createUsage()}\n`);
-                return 0;
-            }
-            const parsed = parseArgs(argv);
-            if (parsed.filepath === undefined) {
-                stderr.write(`${createUsage()}\n`);
-                return brokenPipe.closed ? 0 : EXIT_RUNTIME;
-            }
-            const cwd = options.cwd ?? readCurrentWorkingDirectory();
-            const filepath = path.resolve(cwd, parsed.filepath);
-            await assertHarnessFile({
-                displayPath: parsed.filepath,
-                filepath,
-                statFile: options.stat ?? stat
-            });
-            return await runScriptFile(filepath, parsed, {
-                cwd,
-                modulesFor: options.modulesFor,
-                process: options.process ?? process,
-                readFile: options.readFile ?? readFile,
-                brokenPipe,
-                stderr,
-                stdout,
-                writeFile: options.writeFile ?? writeFile
-            });
+var EXIT_RUNTIME = 1;
+var EXIT_PARSE = 2;
+var EXIT_BUDGET = 3;
+var EXIT_SIGINT = 130;
+async function runCli(argv, options = {}) {
+  const brokenPipe = createBrokenPipeState();
+  const stdout = createSafeOutputStream(options.stdout ?? process.stdout, brokenPipe);
+  const stderr = createSafeOutputStream(options.stderr ?? process.stderr, brokenPipe);
+  return withBrokenPipeGuard(
+    [options.stdout ?? process.stdout, options.stderr ?? process.stderr],
+    brokenPipe,
+    async () => {
+      try {
+        if (argv.includes("--help") || argv.includes("-h")) {
+          stdout.write(`${createUsage()}
+`);
+          return 0;
         }
-        catch (error) {
-            if (brokenPipe.closed) {
-                return 0;
-            }
-            stderr.write(`${readErrorMessage(error)}\n`);
-            return brokenPipe.closed
-                ? 0
-                : error instanceof CliExitError
-                    ? error.exitCode
-                    : exitCodeForError(error);
+        const parsed = parseArgs(argv);
+        if (parsed.filepath === void 0) {
+          stderr.write(`${createUsage()}
+`);
+          return brokenPipe.closed ? 0 : EXIT_RUNTIME;
         }
-    });
+        const cwd = options.cwd ?? readCurrentWorkingDirectory();
+        const filepath = path.resolve(cwd, parsed.filepath);
+        await assertHarnessFile({
+          displayPath: parsed.filepath,
+          filepath,
+          statFile: options.stat ?? stat
+        });
+        return await runScriptFile(filepath, parsed, {
+          cwd,
+          modulesFor: options.modulesFor,
+          process: options.process ?? process,
+          readFile: options.readFile ?? readFile,
+          brokenPipe,
+          stderr,
+          stdout,
+          writeFile: options.writeFile ?? writeFile
+        });
+      } catch (error) {
+        if (brokenPipe.closed) {
+          return 0;
+        }
+        stderr.write(`${readErrorMessage(error)}
+`);
+        return brokenPipe.closed ? 0 : error instanceof CliExitError ? error.exitCode : exitCodeForError(error);
+      }
+    }
+  );
 }
 function readCurrentWorkingDirectory() {
-    try {
-        return process.cwd();
-    }
-    catch (error) {
-        throw new Error(`Unable to resolve current working directory: ${readErrorMessage(error)}`);
-    }
+  try {
+    return process.cwd();
+  } catch (error) {
+    throw new Error(`Unable to resolve current working directory: ${readErrorMessage(error)}`);
+  }
 }
 function parseArgs(argv) {
-    const parsed = {
-        fix: false,
-        fs: false
-    };
-    for (let index = 0; index < argv.length; index += 1) {
-        const arg = argv[index];
-        if (arg === "--fix") {
-            parsed.fix = true;
-            continue;
-        }
-        if (arg === "--fs") {
-            parsed.fs = true;
-            continue;
-        }
-        if (arg === "--fs-root") {
-            parsed.fsRoot = readFlagValue(argv, index, arg);
-            index += 1;
-            continue;
-        }
-        if (arg === "--snapshot") {
-            parsed.snapshotPath = readFlagValue(argv, index, arg);
-            index += 1;
-            continue;
-        }
-        if (arg === "--restore") {
-            parsed.restorePath = readFlagValue(argv, index, arg);
-            index += 1;
-            continue;
-        }
-        if (arg === "--max-steps") {
-            parsed.maxSteps = readPositiveInteger(readFlagValue(argv, index, arg), arg);
-            index += 1;
-            continue;
-        }
-        if (arg === "--data-size") {
-            parsed.dataSize = readPositiveInteger(readFlagValue(argv, index, arg), arg);
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("-")) {
-            throw new CliExitError(`Unknown flag: ${arg}`, EXIT_RUNTIME);
-        }
-        if (parsed.filepath !== undefined) {
-            throw new CliExitError(`Unexpected argument: ${arg}`, EXIT_RUNTIME);
-        }
-        parsed.filepath = arg;
-    }
-    if (!parsed.fs && parsed.fsRoot !== undefined) {
-        throw new CliExitError("--fs-root requires --fs. Pass --fs to give the script a filesystem confined to that root, or drop --fs-root.", EXIT_RUNTIME);
-    }
-    return parsed;
+  const parsed = {
+    fix: false,
+    fs: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--fix") {
+      parsed.fix = true;
+      continue;
+    }
+    if (arg === "--fs") {
+      parsed.fs = true;
+      continue;
+    }
+    if (arg === "--fs-root") {
+      parsed.fsRoot = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--snapshot") {
+      parsed.snapshotPath = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--restore") {
+      parsed.restorePath = readFlagValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--max-steps") {
+      parsed.maxSteps = readPositiveInteger(readFlagValue(argv, index, arg), arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--data-size") {
+      parsed.dataSize = readPositiveInteger(readFlagValue(argv, index, arg), arg);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new CliExitError(`Unknown flag: ${arg}`, EXIT_RUNTIME);
+    }
+    if (parsed.filepath !== void 0) {
+      throw new CliExitError(`Unexpected argument: ${arg}`, EXIT_RUNTIME);
+    }
+    parsed.filepath = arg;
+  }
+  if (!parsed.fs && parsed.fsRoot !== void 0) {
+    throw new CliExitError(
+      "--fs-root requires --fs. Pass --fs to give the script a filesystem confined to that root, or drop --fs-root.",
+      EXIT_RUNTIME
+    );
+  }
+  return parsed;
 }
 function readFlagValue(argv, index, flag) {
-    const value = argv[index + 1];
-    if (value === undefined || value.length === 0) {
-        throw new CliExitError(`Missing value for ${flag}`, EXIT_RUNTIME);
-    }
-    return value;
+  const value = argv[index + 1];
+  if (value === void 0 || value.length === 0) {
+    throw new CliExitError(`Missing value for ${flag}`, EXIT_RUNTIME);
+  }
+  return value;
 }
 function readPositiveInteger(value, flag) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed <= 0) {
-        throw new CliExitError(`${flag} must be a positive integer`, EXIT_RUNTIME);
-    }
-    return parsed;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliExitError(`${flag} must be a positive integer`, EXIT_RUNTIME);
+  }
+  return parsed;
 }
 async function assertHarnessFile(input) {
-    let stats;
-    try {
-        stats = await input.statFile(input.filepath);
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            throw new CliExitError(`File not found: ${input.displayPath}`, EXIT_RUNTIME);
-        }
-        throw error;
-    }
-    if (!stats.isFile()) {
-        throw new CliExitError(`Harness path must point to a file: ${input.displayPath}`, EXIT_RUNTIME);
-    }
+  let stats;
+  try {
+    stats = await input.statFile(input.filepath);
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      throw new CliExitError(`File not found: ${input.displayPath}`, EXIT_RUNTIME);
+    }
+    throw error;
+  }
+  if (!stats.isFile()) {
+    throw new CliExitError(`Harness path must point to a file: ${input.displayPath}`, EXIT_RUNTIME);
+  }
 }
 async function runScriptFile(filepath, parsed, options) {
-    const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
-    const meta = {
+  const loaded = loadExecutableSource(filepath, await options.readFile(filepath, "utf8"));
+  const meta = {
+    filepath,
+    kind: loaded.frontmatter.kind,
+    version: loaded.frontmatter.version
+  };
+  const runtime = createRuntime(loaded.frontmatter, meta, {
+    fs: parsed.fs ? { root: path.resolve(options.cwd, parsed.fsRoot ?? dirname(filepath)) } : void 0,
+    modulesFor: options.modulesFor,
+    stderr: options.stderr,
+    stdout: options.stdout
+  });
+  const modules = excludeHarnessModule(runtime.registry, loaded.isRawScript);
+  let executableSource = loaded.executableSource;
+  const lintResult = parsed.fix ? lint(executableSource, {
+    allowedExportNames: ["schema"],
+    filename: filepath,
+    fix: true,
+    fixRanges: loaded.fixRanges,
+    frontmatterFields: Object.keys(loaded.frontmatter),
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  }) : lint(executableSource, {
+    allowedExportNames: ["schema"],
+    filename: filepath,
+    frontmatterFields: Object.keys(loaded.frontmatter),
+    modules: createLintModulesFromRuntimeRegistry(modules)
+  });
+  const diagnostics = Array.isArray(lintResult) ? lintResult : lintResult.diagnostics;
+  if (!Array.isArray(lintResult)) {
+    executableSource = lintResult.fixed;
+    if (lintResult.fixed !== loaded.executableSource) {
+      await options.writeFile(
         filepath,
-        kind: loaded.frontmatter.kind,
-        version: loaded.frontmatter.version
-    };
-    const runtime = createRuntime(loaded.frontmatter, meta, {
-        fs: parsed.fs
-            ? { root: path.resolve(options.cwd, parsed.fsRoot ?? dirname(filepath)) }
-            : undefined,
-        modulesFor: options.modulesFor,
-        stderr: options.stderr,
-        stdout: options.stdout
-    });
-    const modules = excludeHarnessModule(runtime.registry, loaded.isRawScript);
-    let executableSource = loaded.executableSource;
-    const lintResult = parsed.fix
-        ? lint(executableSource, {
-            allowedExportNames: ["schema"],
-            filename: filepath,
-            fix: true,
-            fixRanges: loaded.fixRanges,
-            frontmatterFields: Object.keys(loaded.frontmatter),
-            modules: createLintModulesFromRuntimeRegistry(modules)
-        })
-        : lint(executableSource, {
-            allowedExportNames: ["schema"],
-            filename: filepath,
-            frontmatterFields: Object.keys(loaded.frontmatter),
-            modules: createLintModulesFromRuntimeRegistry(modules)
-        });
-    const diagnostics = Array.isArray(lintResult) ? lintResult : lintResult.diagnostics;
-    if (!Array.isArray(lintResult)) {
-        executableSource = lintResult.fixed;
-        if (lintResult.fixed !== loaded.executableSource) {
-            await options.writeFile(filepath, replaceExecutableSource(loaded.rawSource, loaded, lintResult.fixes), {
-                encoding: "utf8"
-            });
-        }
-    }
-    const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
-    if (lintErrors.length > 0) {
-        options.stderr.write(`Lint failed:\n${formatDiagnostics(lintErrors)}\n`);
-        if (options.brokenPipe.closed) {
-            return 0;
-        }
-        return lintErrors.some((diagnostic) => diagnostic.code === "AS001") ? EXIT_PARSE : EXIT_RUNTIME;
-    }
-    const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
-    if (lintWarnings.length > 0) {
-        options.stderr.write(`Lint warnings:\n${formatDiagnostics(lintWarnings)}\n`);
-        if (options.brokenPipe.closed) {
-            return 0;
-        }
-    }
-    const snapshot = await readRestoreSnapshot(parsed.restorePath, options);
-    if (snapshot !== undefined) {
-        restore(snapshot, { source: executableSource });
-    }
-    const abortController = new AbortController();
-    let interrupted = false;
-    let runPromise;
-    let signalSnapshotWrite;
-    const onSigint = () => {
-        interrupted = true;
-        abortController.abort(createAbortError());
-        options.stderr.write("Interrupted by SIGINT\n");
-        if (parsed.snapshotPath !== undefined && runPromise !== undefined) {
-            signalSnapshotWrite = writeCurrentSnapshot(runPromise, parsed.snapshotPath, options);
-        }
-    };
-    options.process.on("SIGINT", onSigint);
-    try {
-        runPromise = run(executableSource, {
-            budget: parsed.maxSteps === undefined && parsed.dataSize === undefined
-                ? undefined
-                : new Budget({ dataSize: parsed.dataSize, maxSteps: parsed.maxSteps }),
-            entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : undefined,
-            filename: filepath,
-            modules,
-            signal: abortController.signal,
-            sink: createConsoleSink(options.stdout, options.stderr),
-            snapshot
-        });
-        const result = await runPromise;
-        await signalSnapshotWrite;
-        if (options.brokenPipe.closed) {
-            return 0;
-        }
-        if (parsed.snapshotPath !== undefined) {
-            await writeSnapshot(parsed.snapshotPath, await dump(result), options);
-        }
-        if (!result.ok) {
-            options.stderr.write(`${formatInterpreterError(result.error, {
-                filename: filepath,
-                source: executableSource
-            })}\n`);
-            if (options.brokenPipe.closed) {
-                return 0;
-            }
-            return interrupted ? EXIT_SIGINT : exitCodeForError(result.error);
-        }
-        options.stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}\n`);
-        return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : 0;
-    }
-    catch (error) {
-        await signalSnapshotWrite;
-        if (options.brokenPipe.closed) {
-            return 0;
+        replaceExecutableSource(loaded.rawSource, loaded, lintResult.fixes),
+        {
+          encoding: "utf8"
         }
-        options.stderr.write(`${formatInterpreterError(error, {
-            filename: filepath,
-            source: executableSource
-        })}\n`);
-        return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : exitCodeForError(error);
-    }
-    finally {
-        options.process.off("SIGINT", onSigint);
-    }
+      );
+    }
+  }
+  const lintErrors = diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+  if (lintErrors.length > 0) {
+    options.stderr.write(`Lint failed:
+${formatDiagnostics(lintErrors)}
+`);
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    return lintErrors.some((diagnostic) => diagnostic.code === "AS001") ? EXIT_PARSE : EXIT_RUNTIME;
+  }
+  const lintWarnings = diagnostics.filter((diagnostic) => diagnostic.severity === "warning");
+  if (lintWarnings.length > 0) {
+    options.stderr.write(`Lint warnings:
+${formatDiagnostics(lintWarnings)}
+`);
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+  }
+  const snapshot = await readRestoreSnapshot(parsed.restorePath, options);
+  if (snapshot !== void 0) {
+    restore(snapshot, { source: executableSource });
+  }
+  const abortController = new AbortController();
+  let interrupted = false;
+  let runPromise;
+  let signalSnapshotWrite;
+  const onSigint = () => {
+    interrupted = true;
+    abortController.abort(createAbortError());
+    options.stderr.write("Interrupted by SIGINT\n");
+    if (parsed.snapshotPath !== void 0 && runPromise !== void 0) {
+      signalSnapshotWrite = writeCurrentSnapshot(runPromise, parsed.snapshotPath, options);
+    }
+  };
+  options.process.on("SIGINT", onSigint);
+  try {
+    runPromise = run(executableSource, {
+      budget: parsed.maxSteps === void 0 && parsed.dataSize === void 0 ? void 0 : new Budget({ dataSize: parsed.dataSize, maxSteps: parsed.maxSteps }),
+      entryPointArgs: hasDefaultExport(executableSource, filepath) ? [] : void 0,
+      filename: filepath,
+      modules,
+      signal: abortController.signal,
+      sink: createConsoleSink(options.stdout, options.stderr),
+      snapshot
+    });
+    const result = await runPromise;
+    await signalSnapshotWrite;
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    if (parsed.snapshotPath !== void 0) {
+      await writeSnapshot(parsed.snapshotPath, await dump(result), options);
+    }
+    if (!result.ok) {
+      options.stderr.write(
+        `${formatInterpreterError(result.error, {
+          filename: filepath,
+          source: executableSource
+        })}
+`
+      );
+      if (options.brokenPipe.closed) {
+        return 0;
+      }
+      return interrupted ? EXIT_SIGINT : exitCodeForError(result.error);
+    }
+    options.stdout.write(`${JSON.stringify({ ok: true, returnValue: result.returnValue })}
+`);
+    return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : 0;
+  } catch (error) {
+    await signalSnapshotWrite;
+    if (options.brokenPipe.closed) {
+      return 0;
+    }
+    options.stderr.write(
+      `${formatInterpreterError(error, {
+        filename: filepath,
+        source: executableSource
+      })}
+`
+    );
+    return options.brokenPipe.closed ? 0 : interrupted ? EXIT_SIGINT : exitCodeForError(error);
+  } finally {
+    options.process.off("SIGINT", onSigint);
+  }
 }
 function loadExecutableSource(filepath, rawSource) {
-    const source = stripByteOrderMark(rawSource);
-    const byteOrderMarkLength = rawSource.length - source.length;
-    if (isRawScriptExtension(extname(filepath))) {
-        return {
-            sourceOffset: byteOrderMarkLength,
-            executableSource: source,
-            frontmatter: {},
-            isRawScript: true,
-            rawSource
-        };
-    }
-    const { frontmatter, body } = splitFrontmatter(source);
-    const bodyStartOffset = source.length - body.length;
-    const executableBlock = extractBlock(body, countLineBreaks(source, 0, bodyStartOffset) + 1);
-    const lineOffset = countLineBreaks(source, 0, bodyStartOffset + executableBlock.startOffset);
+  const source = stripByteOrderMark(rawSource);
+  const byteOrderMarkLength = rawSource.length - source.length;
+  if (isRawScriptExtension(extname(filepath))) {
     return {
-        sourceOffset: byteOrderMarkLength + bodyStartOffset + executableBlock.startOffset - lineOffset,
-        fixRanges: executableBlock.ranges.map(([start, end]) => [
-            start - executableBlock.startOffset + lineOffset,
-            end - executableBlock.startOffset + lineOffset
-        ]),
-        executableSource: createLineOffsetSource(executableBlock.source, lineOffset),
-        frontmatter,
-        isRawScript: false,
-        rawSource
+      sourceOffset: byteOrderMarkLength,
+      executableSource: source,
+      frontmatter: {},
+      isRawScript: true,
+      rawSource
     };
+  }
+  const { frontmatter, body } = splitFrontmatter(source);
+  const bodyStartOffset = source.length - body.length;
+  const executableBlock = extractBlock(body, countLineBreaks(source, 0, bodyStartOffset) + 1);
+  const lineOffset = countLineBreaks(source, 0, bodyStartOffset + executableBlock.startOffset);
+  return {
+    sourceOffset: byteOrderMarkLength + bodyStartOffset + executableBlock.startOffset - lineOffset,
+    fixRanges: executableBlock.ranges.map(([start, end]) => [
+      start - executableBlock.startOffset + lineOffset,
+      end - executableBlock.startOffset + lineOffset
+    ]),
+    executableSource: createLineOffsetSource(executableBlock.source, lineOffset),
+    frontmatter,
+    isRawScript: false,
+    rawSource
+  };
 }
 function isRawScriptExtension(extension) {
-    return extension === ".safejs" || extension === ".ajs";
+  return extension === ".safejs" || extension === ".ajs";
 }
 function replaceExecutableSource(source, loaded, fixes) {
-    return fixes.reduce((result, fix) => `${result.slice(0, loaded.sourceOffset + fix.range[0])}${fix.replacement}${result.slice(loaded.sourceOffset + fix.range[1])}`, source);
+  return fixes.reduce(
+    (result, fix) => `${result.slice(0, loaded.sourceOffset + fix.range[0])}${fix.replacement}${result.slice(loaded.sourceOffset + fix.range[1])}`,
+    source
+  );
 }
 function createRuntime(frontmatter, meta, options) {
-    if (options.modulesFor !== undefined) {
-        return {
-            registry: options.modulesFor(frontmatter, meta, {
-                stderr: options.stderr,
-                stdout: options.stdout
-            })
-        };
-    }
-    const state = {
-        checkpointCount: 0,
-        commitCount: 0,
-        metricCalls: new Map(),
-        spawnCount: 0
-    };
-    const harness = makeHarnessModule(frontmatter, meta);
-    const agent = makeAgentModule(async (input) => {
-        state.spawnCount += 1;
-        return {
-            exitCode: 0,
-            stdout: "",
-            stderr: "",
-            summary: `${input.agent} handled ${summarizePrompt(input.prompt)}`,
-            durationMs: 25 * state.spawnCount
-        };
-    });
-    const git = {
-        async checkpoint() {
-            state.checkpointCount += 1;
-            return {
-                head: `head-${state.checkpointCount}`,
-                stashRef: `savepoint-${state.checkpointCount}`
-            };
-        },
-        async commit() {
-            state.commitCount += 1;
-            return `commit-${state.commitCount}`;
-        },
-        async revert() {
-            return undefined;
-        }
+  if (options.modulesFor !== void 0) {
+    return {
+      registry: options.modulesFor(frontmatter, meta, {
+        stderr: options.stderr,
+        stdout: options.stdout
+      })
     };
-    const log = makeLogModule((entry) => {
-        const normalized = normalizeLogEntry(entry);
-        const stream = normalized.type === "error" ? options.stderr : options.stdout;
-        stream.write(`${JSON.stringify(normalized)}\n`);
-    });
-    const metric = makeMetricModule(async (scriptName) => `${readMetricScore(scriptName, state)}\n`);
+  }
+  const state = {
+    checkpointCount: 0,
+    commitCount: 0,
+    metricCalls: /* @__PURE__ */ new Map(),
+    spawnCount: 0
+  };
+  const harness = makeHarnessModule(frontmatter, meta);
+  const agent = makeAgentModule(async (input) => {
+    state.spawnCount += 1;
     return {
-        registry: {
-            agent: toModuleExports(agent),
-            fail: toModuleExports(new Map([["default", makeFailModule().default]])),
-            // The one module here that is not a stub, so it is registered only when asked for.
-            ...(options.fs === undefined ? {} : { fs: toModuleExports(makeFsModule(options.fs)) }),
-            git: toModuleExports(new Map([
-                ["checkpoint", git.checkpoint],
-                ["commit", git.commit],
-                ["revert", git.revert]
-            ])),
-            harness: toModuleExports(harness),
-            log: toModuleExports(log),
-            metric: toModuleExports(metric)
-        }
+      exitCode: 0,
+      stdout: "",
+      stderr: "",
+      summary: `${input.agent} handled ${summarizePrompt(input.prompt)}`,
+      durationMs: 25 * state.spawnCount
     };
+  });
+  const git = {
+    async checkpoint() {
+      state.checkpointCount += 1;
+      return {
+        head: `head-${state.checkpointCount}`,
+        stashRef: `savepoint-${state.checkpointCount}`
+      };
+    },
+    async commit() {
+      state.commitCount += 1;
+      return `commit-${state.commitCount}`;
+    },
+    async revert() {
+      return void 0;
+    }
+  };
+  const log = makeLogModule((entry) => {
+    const normalized = normalizeLogEntry(entry);
+    const stream = normalized.type === "error" ? options.stderr : options.stdout;
+    stream.write(`${JSON.stringify(normalized)}
+`);
+  });
+  const metric = makeMetricModule(async (scriptName) => `${readMetricScore(scriptName, state)}
+`);
+  return {
+    registry: {
+      agent: toModuleExports(agent),
+      fail: toModuleExports(/* @__PURE__ */ new Map([["default", makeFailModule().default]])),
+      // The one module here that is not a stub, so it is registered only when asked for.
+      ...options.fs === void 0 ? {} : { fs: toModuleExports(makeFsModule(options.fs)) },
+      git: toModuleExports(
+        /* @__PURE__ */ new Map([
+          ["checkpoint", git.checkpoint],
+          ["commit", git.commit],
+          ["revert", git.revert]
+        ])
+      ),
+      harness: toModuleExports(harness),
+      log: toModuleExports(log),
+      metric: toModuleExports(metric)
+    }
+  };
 }
 async function readRestoreSnapshot(restorePath, options) {
-    if (restorePath === undefined) {
-        return undefined;
-    }
-    const snapshotPath = path.resolve(options.cwd, restorePath);
-    let rawSnapshot;
-    try {
-        rawSnapshot = await options.readFile(snapshotPath, "utf8");
-    }
-    catch (error) {
-        if (hasErrorCode(error, "ENOENT")) {
-            throw new CliExitError(`Snapshot not found: ${restorePath}`, EXIT_RUNTIME);
-        }
-        throw error;
-    }
-    try {
-        return JSON.parse(rawSnapshot);
-    }
-    catch (error) {
-        throw new Error(`Failed to parse snapshot at ${restorePath}: ${readErrorMessage(error)}`);
-    }
+  if (restorePath === void 0) {
+    return void 0;
+  }
+  const snapshotPath = path.resolve(options.cwd, restorePath);
+  let rawSnapshot;
+  try {
+    rawSnapshot = await options.readFile(snapshotPath, "utf8");
+  } catch (error) {
+    if (hasErrorCode(error, "ENOENT")) {
+      throw new CliExitError(`Snapshot not found: ${restorePath}`, EXIT_RUNTIME);
+    }
+    throw error;
+  }
+  try {
+    return JSON.parse(rawSnapshot);
+  } catch (error) {
+    throw new Error(`Failed to parse snapshot at ${restorePath}: ${readErrorMessage(error)}`);
+  }
 }
 async function writeCurrentSnapshot(result, snapshotPath, options) {
-    try {
-        await writeSnapshot(snapshotPath, await dumpCurrent(result), options);
-    }
-    catch (error) {
-        options.stderr.write(`Failed to write snapshot at ${snapshotPath}: ${readErrorMessage(error)}\n`);
-    }
+  try {
+    await writeSnapshot(snapshotPath, await dumpCurrent(result), options);
+  } catch (error) {
+    options.stderr.write(
+      `Failed to write snapshot at ${snapshotPath}: ${readErrorMessage(error)}
+`
+    );
+  }
 }
 async function writeSnapshot(snapshotPath, content, options) {
-    const resolvedPath = path.resolve(options.cwd, snapshotPath);
-    await mkdir(dirname(resolvedPath), { recursive: true });
-    await options.writeFile(resolvedPath, content, { encoding: "utf8" });
+  const resolvedPath = path.resolve(options.cwd, snapshotPath);
+  await mkdir(dirname(resolvedPath), { recursive: true });
+  await options.writeFile(resolvedPath, content, { encoding: "utf8" });
 }
 function createConsoleSink(stdout, stderr) {
-    return {
-        error(...args) {
-            stderr.write(`${formatConsoleArgs(args)}\n`);
-        },
-        log(...args) {
-            stdout.write(`${formatConsoleArgs(args)}\n`);
-        }
-    };
+  return {
+    error(...args) {
+      stderr.write(`${formatConsoleArgs(args)}
+`);
+    },
+    log(...args) {
+      stdout.write(`${formatConsoleArgs(args)}
+`);
+    }
+  };
 }
 function formatConsoleArgs(args) {
-    return formatWithOptions({ colors: false, depth: 4 }, ...args);
+  return formatWithOptions({ colors: false, depth: 4 }, ...args);
 }
 function createUsage() {
-    return [
-        "Usage: poe-safejs [options] <script.md|script.safejs|script.ajs>",
-        "",
-        "Options:",
-        "  --fix                 apply lint fixes before running",
-        "  --fs                  register the fs module: a real filesystem, unlike the agent,",
-        "                        git, and metric stubs this runner bundles",
-        "  --fs-root <path>      directory --fs confines the script to (default: the script's",
-        "                        directory)",
-        "  --snapshot <path>     write the final snapshot, and best-effort snapshot on SIGINT",
-        "  --restore <path>      restore from a snapshot before running",
-        "  --max-steps <n>       cap interpreter step budget",
-        "  --data-size <n>       cap retained sandbox data units",
-        "  -h, --help            print this help",
-        "",
-        "Exit codes:",
-        "  0 success",
-        "  1 runtime, usage, file, or restore error",
-        "  2 parse error",
-        "  3 budget exceeded",
-        "  130 interrupted by SIGINT"
-    ].join("\n");
+  return [
+    "Usage: poe-safejs [options] <script.md|script.safejs|script.ajs>",
+    "",
+    "Options:",
+    "  --fix                 apply lint fixes before running",
+    "  --fs                  register the fs module: a real filesystem, unlike the agent,",
+    "                        git, and metric stubs this runner bundles",
+    "  --fs-root <path>      directory --fs confines the script to (default: the script's",
+    "                        directory)",
+    "  --snapshot <path>     write the final snapshot, and best-effort snapshot on SIGINT",
+    "  --restore <path>      restore from a snapshot before running",
+    "  --max-steps <n>       cap interpreter step budget",
+    "  --data-size <n>       cap retained sandbox data units",
+    "  -h, --help            print this help",
+    "",
+    "Exit codes:",
+    "  0 success",
+    "  1 runtime, usage, file, or restore error",
+    "  2 parse error",
+    "  3 budget exceeded",
+    "  130 interrupted by SIGINT"
+  ].join("\n");
 }
 function formatDiagnostics(diagnostics) {
-    return diagnostics
-        .map((diagnostic) => `${diagnostic.filename}:${diagnostic.line}:${diagnostic.column} ${diagnostic.code} ${diagnostic.message}`)
-        .join("\n");
+  return diagnostics.map(
+    (diagnostic) => `${diagnostic.filename}:${diagnostic.line}:${diagnostic.column} ${diagnostic.code} ${diagnostic.message}`
+  ).join("\n");
 }
 function exitCodeForError(error) {
-    if (error instanceof SandboxError && error.code === "budgetExceeded") {
-        return EXIT_BUDGET;
-    }
-    if (isParseError(error)) {
-        return EXIT_PARSE;
-    }
-    return EXIT_RUNTIME;
+  if (error instanceof SandboxError && error.code === "budgetExceeded") {
+    return EXIT_BUDGET;
+  }
+  if (isParseError(error)) {
+    return EXIT_PARSE;
+  }
+  return EXIT_RUNTIME;
 }
 function isParseError(error) {
-    return error instanceof Error && error.name === "ParseError";
+  return error instanceof Error && error.name === "ParseError";
 }
 function hasDefaultExport(source, filename) {
-    return parseModule(source, filename).body.some((statement) => statement.type === "ExportDefaultDeclaration");
+  return parseModule(source, filename).body.some(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
 }
 function excludeHarnessModule(modules, isRawScript) {
-    if (!isRawScript) {
-        return modules;
-    }
-    if (modules instanceof Map) {
-        const rawModules = new Map(modules);
-        rawModules.delete("harness");
-        return rawModules;
-    }
-    const rawModules = Object.create(null);
-    for (const [moduleName, moduleExports] of Object.entries(modules)) {
-        if (moduleName !== "harness") {
-            rawModules[moduleName] = moduleExports;
-        }
-    }
-    return rawModules;
+  if (!isRawScript) {
+    return modules;
+  }
+  if (modules instanceof Map) {
+    const rawModules2 = new Map(modules);
+    rawModules2.delete("harness");
+    return rawModules2;
+  }
+  const rawModules = /* @__PURE__ */ Object.create(null);
+  for (const [moduleName, moduleExports] of Object.entries(modules)) {
+    if (moduleName !== "harness") {
+      rawModules[moduleName] = moduleExports;
+    }
+  }
+  return rawModules;
 }
 function stripByteOrderMark(source) {
-    return source.startsWith("\uFEFF") ? source.slice(1) : source;
+  return source.startsWith("\uFEFF") ? source.slice(1) : source;
 }
 function createLineOffsetSource(source, lineOffset) {
-    return `${"\n".repeat(Math.max(lineOffset, 0))}${source}`;
+  return `${"\n".repeat(Math.max(lineOffset, 0))}${source}`;
 }
 function normalizeLogEntry(entry) {
-    return {
-        ...entry,
-        ts: "2026-04-29T00:00:00.000Z"
-    };
+  return {
+    ...entry,
+    ts: "2026-04-29T00:00:00.000Z"
+  };
 }
 function summarizePrompt(prompt) {
-    const normalizedPrompt = prompt.trim().replaceAll("\n", " ");
-    return normalizedPrompt.length <= 48 ? normalizedPrompt : `${normalizedPrompt.slice(0, 45)}...`;
+  const normalizedPrompt = prompt.trim().replaceAll("\n", " ");
+  return normalizedPrompt.length <= 48 ? normalizedPrompt : `${normalizedPrompt.slice(0, 45)}...`;
 }
 function readMetricScore(scriptName, state) {
-    const callCount = (state.metricCalls.get(scriptName) ?? 0) + 1;
-    state.metricCalls.set(scriptName, callCount);
-    if (scriptName === "tests" && callCount === 1) {
-        return 10;
-    }
-    if (scriptName === "tests" && callCount === 2) {
-        return 9;
-    }
-    return 9 + callCount;
+  const callCount = (state.metricCalls.get(scriptName) ?? 0) + 1;
+  state.metricCalls.set(scriptName, callCount);
+  if (scriptName === "tests" && callCount === 1) {
+    return 10;
+  }
+  if (scriptName === "tests" && callCount === 2) {
+    return 9;
+  }
+  return 9 + callCount;
 }
 function toModuleExports(value) {
-    return value;
+  return value;
 }
 function createAbortError() {
-    if (typeof DOMException === "function") {
-        const error = new DOMException("This operation was aborted", "AbortError");
-        replaceErrorStack(error);
-        return error;
-    }
-    const error = new Error("This operation was aborted");
-    error.name = "AbortError";
-    replaceErrorStack(error);
-    return error;
+  if (typeof DOMException === "function") {
+    const error2 = new DOMException("This operation was aborted", "AbortError");
+    replaceErrorStack(error2);
+    return error2;
+  }
+  const error = new Error("This operation was aborted");
+  error.name = "AbortError";
+  replaceErrorStack(error);
+  return error;
 }
 function hasErrorCode(error, code) {
-    return hasOwnErrorCode(error, code);
+  return hasOwnErrorCode(error, code);
 }
 function readErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
-class CliExitError extends Error {
-    exitCode;
-    constructor(message, exitCode) {
-        super(message);
-        this.name = "CliExitError";
-        this.exitCode = exitCode;
-    }
-}
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+var CliExitError = class extends Error {
+  exitCode;
+  constructor(message, exitCode) {
+    super(message);
+    this.name = "CliExitError";
+    this.exitCode = exitCode;
+  }
+};
 async function isDirectExecution(entryPoint) {
-    if (typeof entryPoint !== "string" || entryPoint.length === 0) {
-        return false;
-    }
-    try {
-        const [resolvedEntryPoint, resolvedModule] = await Promise.all([
-            realpath(path.resolve(entryPoint)),
-            realpath(fileURLToPath(import.meta.url))
-        ]);
-        return resolvedEntryPoint === resolvedModule;
-    }
-    catch {
-        return false;
-    }
+  if (typeof entryPoint !== "string" || entryPoint.length === 0) {
+    return false;
+  }
+  try {
+    const [resolvedEntryPoint, resolvedModule] = await Promise.all([
+      realpath(path.resolve(entryPoint)),
+      realpath(fileURLToPath(import.meta.url))
+    ]);
+    return resolvedEntryPoint === resolvedModule;
+  } catch {
+    return false;
+  }
 }
 if (await isDirectExecution(process.argv[1])) {
-    process.exitCode = await runCli(process.argv.slice(2));
+  process.exitCode = await runCli(process.argv.slice(2));
 }
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map