@poe-platform/safe-js 0.1.0

package/dist/safe-js/runner/run-harness.d.ts

@@ -0,0 +1,32 @@
+import { type Diagnostic } from "../lint.js";
+import type { ModuleRegistry } from "../modules/registry.js";
+import type { OtelSink } from "../observability/otel.js";
+import { type RunOptions, type RunResult } from "../run.js";
+import type { SnapshotBackend } from "../snapshot/backend.js";
+type HarnessMeta = {
+    filepath: string;
+    kind: unknown;
+    version: unknown;
+};
+export type RunHarnessOptions = {
+    budget?: RunOptions["budget"];
+    modulesFor: (frontmatter: Record<string, unknown>, meta: HarnessMeta) => ModuleRegistry;
+    otelSink?: OtelSink;
+    signal?: AbortSignal;
+    snapshotBackend?: SnapshotBackend;
+    snapshotIntervalMs?: number;
+    snapshotPath?: string;
+};
+export type RunHarnessExecutionErrorResult = {
+    aborted?: true;
+    error: unknown;
+    ok: false;
+};
+export type RunHarnessResult = RunResult | RunHarnessExecutionErrorResult;
+export declare class LintError extends Error {
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(diagnostics: readonly Diagnostic[]);
+}
+export declare function runHarness(filepath: string, options: RunHarnessOptions): Promise<RunHarnessResult>;
+export declare function runHarnessPair(filepath: string, options: RunHarnessOptions): Promise<RunHarnessResult>;
+export {};

package/dist/safe-js/safe-fs-core.js

@@ -0,0 +1,130 @@
+import {
+  ACCESS_MODES,
+  FileSystemBridge,
+  FsError,
+  MemoryFileSystem,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  WebDavFileSystem,
+  assertPathWithin,
+  collectBytes,
+  compareEntries,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  dirname,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  normalizePath,
+  platform,
+  readBytes,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validatePath
+} from "./chunks/chunk-2QRYPKQQ.js";
+import "./chunks/chunk-4YIDX44G.js";
+
+// packages/safe-fs/src/contracts/portable-path.ts
+function assertString(value) {
+  if (typeof value !== "string") throw new TypeError("path must be a string");
+}
+function basename(path, suffix = "") {
+  assertString(path);
+  assertString(suffix);
+  if (suffix && path === suffix) return "";
+  let end = path.length;
+  while (end > 0 && path[end - 1] === "/") end--;
+  if (end === 0 && suffix && suffix.length <= path.length) return path;
+  const start = path.lastIndexOf("/", end - 1) + 1;
+  const base = path.slice(start, end);
+  if (suffix.length > base.length && suffix.length <= path.length && suffix.endsWith(base)) return path.slice(start);
+  return suffix && suffix.length < base.length && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+var dirname2 = dirname;
+function extname(path) {
+  const base = basename(path);
+  const position = base.lastIndexOf(".");
+  return position <= 0 || base === ".." ? "" : base.slice(position);
+}
+function isAbsolutePath(path) {
+  assertString(path);
+  return path.startsWith("/");
+}
+function joinPath(...paths) {
+  for (const path of paths) assertString(path);
+  const joined = paths.filter(Boolean).join("/");
+  if (!joined) return ".";
+  const absolute = joined.startsWith("/");
+  const components = [];
+  for (const component of joined.split("/")) {
+    if (!component || component === ".") continue;
+    if (component === "..") {
+      if (components.length && components.at(-1) !== "..") components.pop();
+      else if (!absolute) components.push(component);
+    } else components.push(component);
+  }
+  const result = `${absolute ? "/" : ""}${components.join("/")}` || ".";
+  return joined.endsWith("/") && result !== "/" ? `${result}/` : result;
+}
+var posixPath = Object.freeze({ basename, dirname: dirname2, extname, join: joinPath, isAbsolute: isAbsolutePath });
+
+// packages/safe-fs/src/bridge/index.ts
+function createFsBridge(fs, options) {
+  if (options === void 0 || options === null) throw new TypeError("An explicit filesystem codec is required");
+  return new FileSystemBridge(fs, options, {
+    codec: options.codec,
+    copyBytes(bytes) {
+      return new Uint8Array(bytes);
+    },
+    randomSuffix() {
+      return platform.randomUUID().slice(0, 6);
+    },
+    paths: {
+      isAbsolute(path) {
+        return typeof path === "string" && path.startsWith("/");
+      },
+      dirname,
+      relative: relativePath,
+      resolve: resolvePath
+    }
+  });
+}
+export {
+  ACCESS_MODES,
+  FsError,
+  MemoryFileSystem,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  WebDavFileSystem,
+  assertPathWithin,
+  basename,
+  collectBytes,
+  compareEntries,
+  createFsBridge,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  dirname2 as dirname,
+  extname,
+  isAbsolutePath,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  joinPath,
+  normalizePath,
+  posixPath,
+  readBytes,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validatePath
+};
+//# sourceMappingURL=safe-fs-core.js.map

package/dist/safe-js/safe-fs-core.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../safe-fs/src/contracts/portable-path.ts", "../../safe-fs/src/bridge/index.ts"],
+  "sourcesContent": ["import { dirname as virtualDirname } from \"./virtual-path.js\";\n\nfunction assertString(value: unknown): asserts value is string {\n  if (typeof value !== \"string\") throw new TypeError(\"path must be a string\");\n}\n\nexport function basename(path: string, suffix = \"\"): string {\n  assertString(path);\n  assertString(suffix);\n  if (suffix && path === suffix) return \"\";\n  let end = path.length;\n  while (end > 0 && path[end - 1] === \"/\") end--;\n  if (end === 0 && suffix && suffix.length <= path.length) return path;\n  const start = path.lastIndexOf(\"/\", end - 1) + 1;\n  const base = path.slice(start, end);\n  if (suffix.length > base.length && suffix.length <= path.length && suffix.endsWith(base)) return path.slice(start);\n  return suffix && suffix.length < base.length && base.endsWith(suffix)\n    ? base.slice(0, -suffix.length)\n    : base;\n}\n\nexport const dirname = virtualDirname;\n\nexport function extname(path: string): string {\n  const base = basename(path);\n  const position = base.lastIndexOf(\".\");\n  return position <= 0 || base === \"..\" ? \"\" : base.slice(position);\n}\n\nexport function isAbsolutePath(path: string): boolean {\n  assertString(path);\n  return path.startsWith(\"/\");\n}\n\nexport function joinPath(...paths: string[]): string {\n  for (const path of paths) assertString(path);\n  const joined = paths.filter(Boolean).join(\"/\");\n  if (!joined) return \".\";\n  const absolute = joined.startsWith(\"/\");\n  const components: string[] = [];\n  for (const component of joined.split(\"/\")) {\n    if (!component || component === \".\") continue;\n    if (component === \"..\") {\n      if (components.length && components.at(-1) !== \"..\") components.pop();\n      else if (!absolute) components.push(component);\n    } else components.push(component);\n  }\n  const result = `${absolute ? \"/\" : \"\"}${components.join(\"/\")}` || \".\";\n  return joined.endsWith(\"/\") && result !== \"/\" ? `${result}/` : result;\n}\n\nexport const posixPath = Object.freeze({ basename, dirname, extname, join: joinPath, isAbsolute: isAbsolutePath });\n", "import { platform } from \"#safe-fs-platform\";\nimport type { FileSystem } from \"../contracts/filesystem.js\";\nimport { dirname, relativePath, resolvePath } from \"../contracts/virtual-path.js\";\nimport { FileSystemBridge } from \"./filesystem.js\";\nimport type { FsBridgeOptions } from \"./types.js\";\n\nexport type {\n  FsBridgeCodec, FsBridgeDirent, FsBridgeEncoding, FsBridgeFileSystem, FsBridgeOptions, FsBridgeStats\n} from \"./types.js\";\nexport type FsBridge = FileSystemBridge<Uint8Array<ArrayBuffer>>;\n\nexport function createFsBridge(fs: FileSystem, options: FsBridgeOptions): FsBridge {\n  if (options === undefined || options === null) throw new TypeError(\"An explicit filesystem codec is required\");\n  return new FileSystemBridge(fs, options, {\n    codec: options.codec,\n    copyBytes(bytes) { return new Uint8Array(bytes); },\n    randomSuffix() { return platform.randomUUID().slice(0, 6); },\n    paths: {\n      isAbsolute(path) { return typeof path === \"string\" && path.startsWith(\"/\"); },\n      dirname,\n      relative: relativePath,\n      resolve: resolvePath\n    }\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAS,aAAa,OAAyC;AAC7D,MAAI,OAAO,UAAU,SAAU,OAAM,IAAI,UAAU,uBAAuB;AAC5E;AAEO,SAAS,SAAS,MAAc,SAAS,IAAY;AAC1D,eAAa,IAAI;AACjB,eAAa,MAAM;AACnB,MAAI,UAAU,SAAS,OAAQ,QAAO;AACtC,MAAI,MAAM,KAAK;AACf,SAAO,MAAM,KAAK,KAAK,MAAM,CAAC,MAAM,IAAK;AACzC,MAAI,QAAQ,KAAK,UAAU,OAAO,UAAU,KAAK,OAAQ,QAAO;AAChE,QAAM,QAAQ,KAAK,YAAY,KAAK,MAAM,CAAC,IAAI;AAC/C,QAAM,OAAO,KAAK,MAAM,OAAO,GAAG;AAClC,MAAI,OAAO,SAAS,KAAK,UAAU,OAAO,UAAU,KAAK,UAAU,OAAO,SAAS,IAAI,EAAG,QAAO,KAAK,MAAM,KAAK;AACjH,SAAO,UAAU,OAAO,SAAS,KAAK,UAAU,KAAK,SAAS,MAAM,IAChE,KAAK,MAAM,GAAG,CAAC,OAAO,MAAM,IAC5B;AACN;AAEO,IAAMA,WAAU;AAEhB,SAAS,QAAQ,MAAsB;AAC5C,QAAM,OAAO,SAAS,IAAI;AAC1B,QAAM,WAAW,KAAK,YAAY,GAAG;AACrC,SAAO,YAAY,KAAK,SAAS,OAAO,KAAK,KAAK,MAAM,QAAQ;AAClE;AAEO,SAAS,eAAe,MAAuB;AACpD,eAAa,IAAI;AACjB,SAAO,KAAK,WAAW,GAAG;AAC5B;AAEO,SAAS,YAAY,OAAyB;AACnD,aAAW,QAAQ,MAAO,cAAa,IAAI;AAC3C,QAAM,SAAS,MAAM,OAAO,OAAO,EAAE,KAAK,GAAG;AAC7C,MAAI,CAAC,OAAQ,QAAO;AACpB,QAAM,WAAW,OAAO,WAAW,GAAG;AACtC,QAAM,aAAuB,CAAC;AAC9B,aAAW,aAAa,OAAO,MAAM,GAAG,GAAG;AACzC,QAAI,CAAC,aAAa,cAAc,IAAK;AACrC,QAAI,cAAc,MAAM;AACtB,UAAI,WAAW,UAAU,WAAW,GAAG,EAAE,MAAM,KAAM,YAAW,IAAI;AAAA,eAC3D,CAAC,SAAU,YAAW,KAAK,SAAS;AAAA,IAC/C,MAAO,YAAW,KAAK,SAAS;AAAA,EAClC;AACA,QAAM,SAAS,GAAG,WAAW,MAAM,EAAE,GAAG,WAAW,KAAK,GAAG,CAAC,MAAM;AAClE,SAAO,OAAO,SAAS,GAAG,KAAK,WAAW,MAAM,GAAG,MAAM,MAAM;AACjE;AAEO,IAAM,YAAY,OAAO,OAAO,EAAE,UAAU,SAAAA,UAAS,SAAS,MAAM,UAAU,YAAY,eAAe,CAAC;;;ACxC1G,SAAS,eAAe,IAAgB,SAAoC;AACjF,MAAI,YAAY,UAAa,YAAY,KAAM,OAAM,IAAI,UAAU,0CAA0C;AAC7G,SAAO,IAAI,iBAAiB,IAAI,SAAS;AAAA,IACvC,OAAO,QAAQ;AAAA,IACf,UAAU,OAAO;AAAE,aAAO,IAAI,WAAW,KAAK;AAAA,IAAG;AAAA,IACjD,eAAe;AAAE,aAAO,SAAS,WAAW,EAAE,MAAM,GAAG,CAAC;AAAA,IAAG;AAAA,IAC3D,OAAO;AAAA,MACL,WAAW,MAAM;AAAE,eAAO,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG;AAAA,MAAG;AAAA,MAC5E;AAAA,MACA,UAAU;AAAA,MACV,SAAS;AAAA,IACX;AAAA,EACF,CAAC;AACH;",
+  "names": ["dirname"]
+}

package/dist/safe-js/safe-fs-node.js

@@ -0,0 +1,94 @@
+import {
+  MockS3Client,
+  RealFileSystem,
+  S3FileSystem,
+  S3RenameError,
+  S3ServiceError,
+  basename,
+  createFileSystem,
+  createNodeFileSystemAdapterRegistry,
+  createNodeFsBridge,
+  createRealFileSystem,
+  createS3HttpTransport,
+  createS3Transport,
+  dirname,
+  encodeCopySource,
+  extname,
+  isAbsolutePath,
+  joinPath,
+  posixPath,
+  readConfigRecord,
+  validateFileSystemConfig
+} from "./chunks/chunk-7M2SJPSZ.js";
+import {
+  ACCESS_MODES,
+  FsError,
+  MemoryFileSystem,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  WebDavFileSystem,
+  assertPathWithin,
+  collectBytes,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  normalizePath,
+  readBytes,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validatePath
+} from "./chunks/chunk-2QRYPKQQ.js";
+import "./chunks/chunk-4YIDX44G.js";
+export {
+  ACCESS_MODES,
+  FsError,
+  MemoryFileSystem,
+  MockS3Client,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  RealFileSystem,
+  S3FileSystem,
+  S3RenameError,
+  S3ServiceError,
+  WebDavFileSystem,
+  assertPathWithin,
+  basename,
+  collectBytes,
+  createFileSystem,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createNodeFileSystemAdapterRegistry,
+  createNodeFsBridge,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  createRealFileSystem,
+  createS3HttpTransport,
+  createS3Transport,
+  dirname,
+  encodeCopySource,
+  extname,
+  isAbsolutePath,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  joinPath,
+  normalizePath,
+  posixPath,
+  readBytes,
+  readConfigRecord,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validateFileSystemConfig,
+  validatePath
+};
+//# sourceMappingURL=safe-fs-node.js.map

package/dist/safe-js/safe-fs-node.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/safe-js/safe-fs.js

@@ -0,0 +1,94 @@
+import {
+  MockS3Client,
+  RealFileSystem,
+  S3FileSystem,
+  S3RenameError,
+  S3ServiceError,
+  basename,
+  createFileSystem,
+  createNodeFileSystemAdapterRegistry,
+  createNodeFsBridge,
+  createRealFileSystem,
+  createS3HttpTransport,
+  createS3Transport,
+  dirname,
+  encodeCopySource,
+  extname,
+  isAbsolutePath,
+  joinPath,
+  posixPath,
+  readConfigRecord,
+  validateFileSystemConfig
+} from "./chunks/chunk-7M2SJPSZ.js";
+import {
+  ACCESS_MODES,
+  FsError,
+  MemoryFileSystem,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  WebDavFileSystem,
+  assertPathWithin,
+  collectBytes,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  normalizePath,
+  readBytes,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validatePath
+} from "./chunks/chunk-2QRYPKQQ.js";
+import "./chunks/chunk-4YIDX44G.js";
+export {
+  ACCESS_MODES,
+  FsError,
+  MemoryFileSystem,
+  MockS3Client,
+  MountFileSystem,
+  OverlayFileSystem,
+  ReadOnlyFileSystem,
+  RealFileSystem,
+  S3FileSystem,
+  S3RenameError,
+  S3ServiceError,
+  WebDavFileSystem,
+  assertPathWithin,
+  basename,
+  collectBytes,
+  createFileSystem,
+  createMemoryFileSystem,
+  createMountFileSystem,
+  createNodeFileSystemAdapterRegistry,
+  createNodeFsBridge,
+  createOverlayFileSystem,
+  createReadOnlyFileSystem,
+  createRealFileSystem,
+  createS3HttpTransport,
+  createS3Transport,
+  dirname,
+  encodeCopySource,
+  extname,
+  isAbsolutePath,
+  isErrnoCode,
+  isFsError,
+  isPathWithin,
+  joinPath,
+  normalizePath,
+  posixPath,
+  readBytes,
+  readConfigRecord,
+  relativePath,
+  resolvePath,
+  toByteSource,
+  toFsError,
+  validateFileSystemConfig,
+  validatePath
+};
+//# sourceMappingURL=safe-fs.js.map

package/dist/safe-js/safe-fs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/safe-js/snapshot/arguments.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxObject, SandboxValue } from "../interp/values.js";
+type PropertyFlags = {
+    configurable: boolean;
+    enumerable: boolean;
+    writable: boolean;
+};
+export type SerializedArguments<TValue> = {
+    kind: "arguments";
+    extensible: boolean;
+    lengthBeforeCallee: boolean;
+    iterator: PropertyFlags | null;
+    properties: Record<string, PropertyFlags & {
+        value: TValue;
+    }>;
+};
+export declare function serializeArguments<TValue>(value: SandboxObject, serializeValue: (entry: SandboxValue, key: string) => TValue): SerializedArguments<TValue>;
+export {};

package/dist/safe-js/snapshot/backend.d.ts

@@ -0,0 +1,19 @@
+import type { SafeJSSnapshot } from "../restore.js";
+export type Snapshot = SafeJSSnapshot;
+export interface SnapshotBackend {
+    read(): Promise<Snapshot | undefined>;
+    write(snapshot: Snapshot): Promise<void>;
+    remove(): Promise<void>;
+}
+export type FileSnapshotBackendOptions = {
+    writeMaxAttempts?: number;
+    writeRetryDelayMs?: number;
+};
+export declare class FileSnapshotBackend implements SnapshotBackend {
+    #private;
+    readonly path: string;
+    constructor(path: string, options?: FileSnapshotBackendOptions);
+    read(): Promise<Snapshot | undefined>;
+    write(snapshot: Snapshot): Promise<void>;
+    remove(): Promise<void>;
+}

package/dist/safe-js/snapshot/dump-format.d.ts

@@ -0,0 +1,7 @@
+export declare const DUMP_FORMAT_VERSION = 1;
+export declare const EXECUTION_SEMANTICS = "jobs-v7";
+export type DumpableSnapshot = {
+    sourceHash: string;
+    [key: string]: unknown;
+};
+export declare function serializeSafeJSSnapshot(snapshot: DumpableSnapshot): string;

package/dist/safe-js/snapshot/dump.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncLocalStorage } from "node:async_hooks";
+import type { RunResult, RunSnapshot } from "../run.js";
+export type DumpOptions = {
+    mode?: "capture" | "replay";
+    onFailure?: "throw" | "checkpoint";
+};
+type DumpController = {
+    fail(error: unknown): void;
+    finalize(snapshot: RunSnapshot): void;
+    onYield(createSnapshot: () => RunSnapshot): void;
+    requestCurrentSnapshot(options?: DumpOptions): Promise<string>;
+    requestSnapshot(options?: DumpOptions): Promise<string>;
+};
+export type RunLifecycle = {
+    hostCallbackContext: AsyncLocalStorage<boolean>;
+    hostCallbackDepth: number;
+};
+export declare function attachDumpController(result: Promise<RunResult>, controller: DumpController): Promise<RunResult>;
+export declare function createDumpController(lifecycle?: RunLifecycle): DumpController;
+export declare function dump(result: Pick<RunResult, "snapshot"> | PromiseLike<RunResult>, options?: DumpOptions): Promise<string>;
+export declare function dumpCurrent(result: Pick<RunResult, "snapshot"> | PromiseLike<RunResult>): Promise<string>;
+export declare function serializeRunSnapshot(snapshot: RunSnapshot): string;
+export {};

package/dist/safe-js/snapshot/float32array.d.ts

@@ -0,0 +1,12 @@
+export type Float32Data<TReference> = {
+    kind: "float32array";
+    byteOffset: number;
+    length: number;
+} & ({
+    bytes: number[];
+} | {
+    buffer: TReference;
+});
+export declare function encodeFloat32Storage<TReference>(value: Float32Array, id: number, buffers: WeakMap<ArrayBuffer, number>, reference: (id: number) => TReference): Float32Data<TReference>;
+export declare function validateFloat32Storage(value: Record<string, unknown>): void;
+export declare function decodeFloat32Storage(value: Record<string, unknown>, resolve: (reference: unknown) => unknown): Float32Array;

package/dist/safe-js/snapshot/migration.d.ts

@@ -0,0 +1,35 @@
+import { type HostCallReplay } from "../interp/host-call.js";
+import { type ReplayData } from "./replay-data.js";
+import type { CompileOwner } from "../interp/budget.js";
+export type SnapshotMigrationResolution = {
+    callId: string;
+    disposition: "not-performed";
+} | {
+    callId: string;
+    disposition: "fulfilled";
+    value: unknown;
+} | {
+    callId: string;
+    disposition: "rejected";
+    reason: unknown;
+};
+export type SnapshotMigrationReconciliation = {
+    checkpointDigest: string;
+    quiescent: boolean;
+    calls: SnapshotMigrationResolution[];
+};
+export type SnapshotMigration = {
+    version: 1;
+    state: ReplayData;
+    history: Array<{
+        sourceHash: string;
+        targetSourceHash: string;
+        executionSemantics: string;
+        replay: HostCallReplay;
+        reconciliation: SnapshotMigrationReconciliation;
+    }>;
+};
+export declare function validateMigrationSemantics(value: unknown): asserts value is string;
+export declare function validateMigrationJournal(sourceHash: string, replay: unknown, hostCalls?: unknown, owner?: CompileOwner): HostCallReplay;
+export declare function validateMigrationReconciliation(value: unknown, checkpointDigest: string, calls: HostCallReplay["calls"]): asserts value is SnapshotMigrationReconciliation;
+export declare function validateSnapshotMigration(value: unknown, sourceHash: string, owner?: CompileOwner): SnapshotMigration | undefined;

package/dist/safe-js/snapshot/policy.d.ts

@@ -0,0 +1,49 @@
+type SnapshotId = number | string;
+export type PendingHostCallResumeIdentity = {
+    argumentDigest: string;
+    callId: string;
+    moduleId: string;
+    operation: string;
+    sourceHash: string;
+};
+export type PendingHostCallDescriptor = {
+    id: SnapshotId;
+    moduleId?: string;
+    operation?: string;
+};
+export type PendingHostCallSideEffectTag = {
+    kind: "host-call-side-effect";
+    callId: string;
+    moduleId: string;
+    operation: string;
+};
+export type PendingHostCallIssuePolicy = {
+    kind: "re-issue";
+} | {
+    kind: "read-side-effect";
+    sideEffectTag: PendingHostCallSideEffectTag;
+};
+export type PendingHostCallResumePolicy = PendingHostCallIssuePolicy;
+export type PendingHostCallPolicyMode = PendingHostCallIssuePolicy["kind"];
+export type PendingHostCallPolicyRegistration = {
+    moduleId: string;
+    operation: string;
+    policy: PendingHostCallPolicyMode;
+};
+export declare class HostOperationResumePolicyError extends Error {
+    readonly moduleId: string;
+    readonly operation: string;
+    constructor(moduleId: string, operation: string);
+}
+export declare function registerPendingHostCallPolicy(registration: PendingHostCallPolicyRegistration): void;
+export declare function readRegisteredPendingHostCallPolicy(moduleId: string, operation: string): PendingHostCallPolicyMode | undefined;
+export declare function resolvePendingHostCallIssuePolicy(call: PendingHostCallDescriptor): PendingHostCallIssuePolicy;
+export declare function tagPendingHostCallAtIssue<TCall extends PendingHostCallDescriptor>(call: TCall): TCall & {
+    sideEffectTag?: PendingHostCallSideEffectTag;
+};
+export declare function resolvePendingHostCallResumePolicy(call: PendingHostCallDescriptor & {
+    sideEffectTag?: PendingHostCallSideEffectTag;
+}): PendingHostCallResumePolicy;
+export declare function createPendingHostCallSideEffectTag(call: PendingHostCallDescriptor): PendingHostCallSideEffectTag;
+export declare function pendingHostCallResumeIdentityMatches(expected: PendingHostCallResumeIdentity, actual: PendingHostCallResumeIdentity): boolean;
+export {};

package/dist/safe-js/snapshot/replay-data.d.ts

@@ -0,0 +1,71 @@
+import { CompileScope } from "../interp/regex/compile-guard.js";
+import { type Float32Data } from "./float32array.js";
+import { type SandboxErrorName } from "../error/shape.js";
+import { type SandboxClosure, type SandboxPromise, type SandboxValue } from "../interp/values.js";
+import { type SerializedArguments } from "./arguments.js";
+type Atom = boolean | null | number | string | {
+    tag: "undefined";
+} | {
+    tag: "number";
+    value: "NaN" | "Infinity" | "-Infinity" | "-0";
+} | {
+    tag: "capability";
+    id: string;
+} | {
+    tag: "promise-capability";
+    id: string;
+} | {
+    tag: "ref";
+    id: number;
+};
+type Properties = Record<string, {
+    value: Atom;
+    configurable: boolean;
+    enumerable: boolean;
+    writable: boolean;
+}>;
+type DataNode = (Float32Data<Atom> & {
+    properties: Properties;
+    extensible: boolean;
+}) | {
+    kind: "capability";
+    id: string;
+    properties: Atom;
+} | {
+    kind: "array" | "object";
+    properties: Properties;
+    extensible: boolean;
+    nullPrototype: boolean;
+    errorType?: SandboxErrorName;
+} | {
+    kind: "arguments";
+    data: SerializedArguments<Atom>;
+} | {
+    kind: "map";
+    entries: Array<[Atom, Atom]>;
+} | {
+    kind: "set";
+    values: Atom[];
+} | {
+    kind: "regex";
+    source: string;
+    flags: string;
+    lastIndex: number;
+};
+export type ReplayData = {
+    root: Atom;
+    nodes: DataNode[];
+};
+export declare class MissingReplayCapabilityError extends TypeError {
+}
+export declare function encodeReplayData(value: SandboxValue, options?: {
+    identifyCapability?: (value: SandboxClosure, path: readonly string[]) => string | undefined;
+    captureCapabilityProperties?: boolean;
+    identifyPromise?: (value: SandboxPromise, path: readonly string[]) => string | undefined;
+}): ReplayData;
+export declare function decodeReplayData(input: unknown, options?: {
+    resolveCapability?: (id: string) => SandboxClosure | undefined;
+    resolvePromise?: (id: string) => SandboxPromise | undefined;
+    onCapabilityRestored?: (original: SandboxClosure, restored: SandboxClosure) => void;
+}, parent?: CompileScope): SandboxValue;
+export {};

package/dist/safe-js/snapshot/validation.d.ts

@@ -0,0 +1,15 @@
+import type { Budget } from "../interp/budget.js";
+import type { ParseResult } from "../parse/parser.js";
+export type SnapshotValidationCode = "budgetExceeded" | "danglingReference" | "duplicateId" | "invalidCycle" | "invalidState" | "invalidType" | "invalidValue" | "unknownTag" | "unsupportedVersion";
+export declare class SnapshotValidationError extends Error {
+    readonly code: SnapshotValidationCode;
+    readonly path: string;
+    constructor(code: SnapshotValidationCode, path: string, detail: string);
+}
+export declare function validateSnapshotData(value: unknown): void;
+export declare function validateDumpEnvelope(snapshot: unknown): asserts snapshot is Record<string, unknown>;
+export declare function validateInterpreterSnapshot(snapshot: unknown, nodeById: ReadonlyMap<number, ParseResult>, budget: Budget): asserts snapshot is Record<string, unknown>;
+export declare function validateSnapshotSourceHash(snapshot: unknown): asserts snapshot is {
+    sourceHash: string;
+};
+export declare function validateArgumentsProperties(record: Record<string, unknown>, path: string): void;

package/dist/task-list/backends/gh-issues-client.d.ts

@@ -0,0 +1,19 @@
+import { type Runner } from "../../process-runner/index.js";
+export interface GhClientOptions {
+    token: string;
+    endpoint?: string;
+    fetch?: typeof fetch;
+}
+export interface GhClient {
+    graphql<T>(query: string, variables: Record<string, unknown>): Promise<T>;
+}
+export declare function createGhClient(options: GhClientOptions): GhClient;
+export interface ResolveAuthOptions {
+    explicitToken?: string;
+    runner?: Runner;
+}
+export declare function resolveAuth(options: ResolveAuthOptions): Promise<string>;
+export interface ResolveEndpointOptions {
+    env?: Record<string, string | undefined>;
+}
+export declare function resolveEndpoint(options?: ResolveEndpointOptions): string;