@h-rig/isolation-plugin 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import { type RuntimeImageConfig, type SandboxConfig } from "@rig/contracts";
+export declare function loadSandboxConfig(projectRoot: string): SandboxConfig;
+export declare function loadRuntimeImageConfig(projectRoot: string): RuntimeImageConfig;

package/dist/src/runtime-config.js

@@ -0,0 +1,215 @@
+// @bun
+// packages/isolation-plugin/src/runtime-config.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { resolve } from "path";
+import {
+  POLICY_VERSION
+} from "@rig/contracts";
+var DEFAULT_SCOPE = {
+  fail_closed: true,
+  harness_paths_exempt: true,
+  runtime_paths_exempt: true
+};
+var DEFAULT_SANDBOX = {
+  mode: "enforce",
+  network: true,
+  read_deny: [],
+  write_allow_from_runtime: true
+};
+var DEFAULT_ISOLATION = {
+  default_mode: "worktree",
+  repo_symlink_fallback: false,
+  strict_provisioning: true,
+  fail_closed_on_provision_error: true
+};
+var DEFAULT_COMPLETION = {
+  derive_checks_from_scope: true,
+  checks: [],
+  typescript_config_probe: ["tsconfig.json"],
+  eslint_config_probe: [".eslintrc.js", ".eslintrc.json", "eslint.config.js"]
+};
+var DEFAULT_RUNTIME_IMAGE = {
+  deps: { monorepo_install: false, hp_next_install: false },
+  plugins_require_binaries: true
+};
+var DEFAULT_RUNTIME_SNAPSHOT = { enabled: true };
+var policyCache = null;
+var policyCachePath = null;
+function loadSandboxConfig(projectRoot) {
+  return loadPolicy(projectRoot).sandbox;
+}
+function loadRuntimeImageConfig(projectRoot) {
+  return loadPolicy(projectRoot).runtime_image ?? {
+    deps: { ...DEFAULT_RUNTIME_IMAGE.deps },
+    plugins_require_binaries: DEFAULT_RUNTIME_IMAGE.plugins_require_binaries
+  };
+}
+function defaultPolicy() {
+  return {
+    version: POLICY_VERSION,
+    mode: "enforce",
+    scope: { ...DEFAULT_SCOPE },
+    rules: [],
+    sandbox: { ...DEFAULT_SANDBOX },
+    isolation: { ...DEFAULT_ISOLATION },
+    completion: { ...DEFAULT_COMPLETION },
+    runtime_image: {
+      deps: { ...DEFAULT_RUNTIME_IMAGE.deps },
+      plugins_require_binaries: DEFAULT_RUNTIME_IMAGE.plugins_require_binaries
+    },
+    runtime_snapshot: { ...DEFAULT_RUNTIME_SNAPSHOT }
+  };
+}
+function loadPolicy(projectRoot) {
+  const configPath = resolve(projectRoot, "rig/policy/policy.json");
+  if (!existsSync(configPath))
+    return defaultPolicy();
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(configPath).mtimeMs;
+  } catch {
+    return defaultPolicy();
+  }
+  if (policyCache && policyCachePath === configPath && policyCache.mtimeMs === mtimeMs) {
+    return policyCache.config;
+  }
+  try {
+    const config = mergeWithDefaults(JSON.parse(readFileSync(configPath, "utf-8")));
+    policyCache = { mtimeMs, config };
+    policyCachePath = configPath;
+    return config;
+  } catch {
+    return defaultPolicy();
+  }
+}
+function mergeWithDefaults(parsed) {
+  const base = defaultPolicy();
+  if (typeof parsed.mode === "string" && isValidMode(parsed.mode))
+    base.mode = parsed.mode;
+  if (parsed.scope && typeof parsed.scope === "object" && !Array.isArray(parsed.scope)) {
+    const scope = parsed.scope;
+    if (typeof scope.fail_closed === "boolean")
+      base.scope.fail_closed = scope.fail_closed;
+    if (typeof scope.harness_paths_exempt === "boolean")
+      base.scope.harness_paths_exempt = scope.harness_paths_exempt;
+    if (typeof scope.runtime_paths_exempt === "boolean")
+      base.scope.runtime_paths_exempt = scope.runtime_paths_exempt;
+  }
+  if (Array.isArray(parsed.rules))
+    base.rules = precompilePolicyRuleRegexes(parsed.rules.filter(isValidRule));
+  if (Array.isArray(parsed.deny) && base.rules.length === 0) {
+    base.rules = precompilePolicyRuleRegexes(migrateLegacyDeny(parsed.deny));
+  }
+  if (parsed.sandbox && typeof parsed.sandbox === "object" && !Array.isArray(parsed.sandbox)) {
+    const sandbox = parsed.sandbox;
+    if (typeof sandbox.mode === "string" && isValidMode(sandbox.mode))
+      base.sandbox.mode = sandbox.mode;
+    if (typeof sandbox.network === "boolean")
+      base.sandbox.network = sandbox.network;
+    if (Array.isArray(sandbox.read_deny))
+      base.sandbox.read_deny = sandbox.read_deny.filter((value) => typeof value === "string");
+    if (typeof sandbox.write_allow_from_runtime === "boolean")
+      base.sandbox.write_allow_from_runtime = sandbox.write_allow_from_runtime;
+  }
+  if (parsed.isolation && typeof parsed.isolation === "object" && !Array.isArray(parsed.isolation)) {
+    const isolation = parsed.isolation;
+    if (isolation.default_mode === "worktree")
+      base.isolation.default_mode = isolation.default_mode;
+    if (typeof isolation.repo_symlink_fallback === "boolean")
+      base.isolation.repo_symlink_fallback = isolation.repo_symlink_fallback;
+    if (typeof isolation.strict_provisioning === "boolean")
+      base.isolation.strict_provisioning = isolation.strict_provisioning;
+    if (typeof isolation.fail_closed_on_provision_error === "boolean")
+      base.isolation.fail_closed_on_provision_error = isolation.fail_closed_on_provision_error;
+  }
+  if (parsed.completion && typeof parsed.completion === "object" && !Array.isArray(parsed.completion)) {
+    const completion = parsed.completion;
+    if (typeof completion.derive_checks_from_scope === "boolean")
+      base.completion.derive_checks_from_scope = completion.derive_checks_from_scope;
+    if (Array.isArray(completion.checks))
+      base.completion.checks = completion.checks.filter((value) => typeof value === "string");
+    if (Array.isArray(completion.typescript_config_probe))
+      base.completion.typescript_config_probe = completion.typescript_config_probe.filter((value) => typeof value === "string");
+    if (Array.isArray(completion.eslint_config_probe))
+      base.completion.eslint_config_probe = completion.eslint_config_probe.filter((value) => typeof value === "string");
+  }
+  if (parsed.runtime_image && typeof parsed.runtime_image === "object" && !Array.isArray(parsed.runtime_image)) {
+    const runtimeImage = parsed.runtime_image;
+    if (runtimeImage.deps && typeof runtimeImage.deps === "object" && !Array.isArray(runtimeImage.deps)) {
+      const deps = runtimeImage.deps;
+      if (typeof deps.monorepo_install === "boolean")
+        base.runtime_image.deps.monorepo_install = deps.monorepo_install;
+      if (typeof deps.hp_next_install === "boolean")
+        base.runtime_image.deps.hp_next_install = deps.hp_next_install;
+    }
+    if (typeof runtimeImage.plugins_require_binaries === "boolean")
+      base.runtime_image.plugins_require_binaries = runtimeImage.plugins_require_binaries;
+  }
+  if (parsed.runtime_snapshot && typeof parsed.runtime_snapshot === "object" && !Array.isArray(parsed.runtime_snapshot)) {
+    const runtimeSnapshot = parsed.runtime_snapshot;
+    if (typeof runtimeSnapshot.enabled === "boolean")
+      base.runtime_snapshot.enabled = runtimeSnapshot.enabled;
+  }
+  return base;
+}
+function isValidMode(value) {
+  return value === "off" || value === "observe" || value === "enforce";
+}
+function isValidRule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const rule = value;
+  return typeof rule.id === "string" && typeof rule.category === "string" && !!rule.match && typeof rule.match === "object";
+}
+function migrateLegacyDeny(deny) {
+  const rules = [];
+  for (const entry of deny) {
+    if (typeof entry.id !== "string")
+      continue;
+    const match = {};
+    if (typeof entry.pattern === "string")
+      match.pattern = entry.pattern;
+    if (typeof entry.regex === "string")
+      match.regex = entry.regex;
+    if (!match.pattern && !match.regex)
+      continue;
+    const rule = {
+      id: entry.id,
+      category: "command",
+      match,
+      action: entry.action === "warn" ? "warn" : "block"
+    };
+    if (typeof entry.reason === "string") {
+      rule.description = entry.reason;
+    }
+    rules.push(rule);
+  }
+  return rules;
+}
+function precompilePolicyRuleRegexes(rules) {
+  return rules.map((rule) => {
+    const compiled = { ...rule };
+    const matchRegex = compileRegex(rule.match?.regex);
+    const unlessRegex = compileRegex(rule.unless?.regex);
+    if (matchRegex) {
+      compiled.compiledRegex = matchRegex;
+    }
+    if (unlessRegex) {
+      compiled.compiledUnlessRegex = unlessRegex;
+    }
+    return compiled;
+  });
+}
+function compileRegex(pattern) {
+  if (!pattern)
+    return;
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return;
+  }
+}
+export {
+  loadSandboxConfig,
+  loadRuntimeImageConfig
+};

package/dist/src/runtime-native-sidecar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sidecar entry. Shared by two callers:
+ *  - dev/source: `bun runtime-native-sidecar.ts <json>` (the `import.meta.main` guard below),
+ *  - compiled binary: re-exec of `rig __rig_native_runtime_sidecar <json>`, routed by
+ *    `packages/cli/bin/rig.ts` → here with the request as `process.argv[3]`.
+ * Writes the JSON response to stdout and exits the process.
+ */
+export declare function runRuntimeNativeSidecarCli(rawRequest: string | undefined): never;

package/dist/src/runtime-native-sidecar.js

@@ -0,0 +1,368 @@
+// @bun
+// packages/isolation-plugin/src/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2, rmSync, statSync as statSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname, resolve as resolve2 } from "path";
+
+// packages/isolation-plugin/src/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/isolation-plugin/src/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/isolation-plugin/src/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+
+// packages/isolation-plugin/src/runtime-native.ts
+var sharedNativeRuntimeOutputDir = resolve2(tmpdir2(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve2(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
+var OPERATION_RESULT_SIZE = 24;
+var RUNTIME_SCAN_ENTRY_SIZE = 64;
+var RUNTIME_SCAN_RESULT_SIZE = 40;
+var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
+function requireNativeRuntimeLibrary(feature) {
+  if (!nativeRuntimeLibrary) {
+    throw new Error(`Native Zig runtime is required for ${feature}`);
+  }
+  return nativeRuntimeLibrary;
+}
+function runtimePrepareTrackedPathsInProcess(input) {
+  const runtimeLibrary = requireNativeRuntimeLibrary("runtime dependency layer linking");
+  const logsDir = Buffer.from(input.logsDir, "utf8");
+  const stateDir = Buffer.from(input.stateDir, "utf8");
+  const sessionDir = Buffer.from(input.sessionDir, "utf8");
+  const eventsFile = Buffer.from(input.eventsFile, "utf8");
+  const controlledBashLogFile = Buffer.from(input.controlledBashLogFile, "utf8");
+  const resultPtr = runtimeLibrary.symbols.runtime_prepare_paths(Number(ptr(logsDir)), logsDir.byteLength, Number(ptr(stateDir)), stateDir.byteLength, Number(ptr(sessionDir)), sessionDir.byteLength, Number(ptr(eventsFile)), eventsFile.byteLength, Number(ptr(controlledBashLogFile)), controlledBashLogFile.byteLength);
+  if (!resultPtr) {
+    throw new Error("runtime_prepare_paths returned null");
+  }
+  try {
+    const view = viewAt(resultPtr, OPERATION_RESULT_SIZE);
+    throwIfOperationError(view, "runtime_prepare_paths");
+  } finally {
+    runtimeLibrary.symbols.snapshot_release(resultPtr);
+  }
+}
+function runtimeLinkDependencyLayerInProcess(sourceDir, targetDir) {
+  const runtimeLibrary = requireNativeRuntimeLibrary("runtime worktree discovery");
+  const sourceBuffer = Buffer.from(sourceDir, "utf8");
+  const targetBuffer = Buffer.from(targetDir, "utf8");
+  const resultPtr = runtimeLibrary.symbols.runtime_link_dependency_layer(Number(ptr(sourceBuffer)), sourceBuffer.byteLength, Number(ptr(targetBuffer)), targetBuffer.byteLength);
+  if (!resultPtr) {
+    throw new Error("runtime_link_dependency_layer returned null");
+  }
+  try {
+    const view = viewAt(resultPtr, OPERATION_RESULT_SIZE);
+    throwIfOperationError(view, "runtime_link_dependency_layer");
+  } finally {
+    runtimeLibrary.symbols.snapshot_release(resultPtr);
+  }
+}
+function runtimeScanWorktreesInProcess(worktreesRoot) {
+  const runtimeLibrary = requireNativeRuntimeLibrary("runtime worktree discovery");
+  const rootBuffer = Buffer.from(worktreesRoot, "utf8");
+  const resultPtr = runtimeLibrary.symbols.runtime_scan_worktrees(Number(ptr(rootBuffer)), rootBuffer.byteLength);
+  if (!resultPtr) {
+    throw new Error(`runtime_scan_worktrees returned null for ${worktreesRoot}`);
+  }
+  try {
+    const view = viewAt(resultPtr, RUNTIME_SCAN_RESULT_SIZE);
+    throwIfScanError(view, "runtime_scan_worktrees");
+    const entriesPtr = readU64(view, 8);
+    const entriesLen = readU64(view, 16);
+    const entries = [];
+    for (let index = 0;index < entriesLen; index += 1) {
+      const entryView = viewAt(entriesPtr + index * RUNTIME_SCAN_ENTRY_SIZE, RUNTIME_SCAN_ENTRY_SIZE);
+      entries.push({
+        workspaceDir: readString(readU64(entryView, 0), readU64(entryView, 8)),
+        runtimeDir: readString(readU64(entryView, 16), readU64(entryView, 24)),
+        contextPath: readString(readU64(entryView, 32), readU64(entryView, 40)),
+        metadataPath: readString(readU64(entryView, 48), readU64(entryView, 56))
+      });
+    }
+    return entries;
+  } finally {
+    runtimeLibrary.symbols.snapshot_release(resultPtr);
+  }
+}
+async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
+  const explicitLib = process.env.RIG_NATIVE_RUNTIME_LIB?.trim();
+  if (explicitLib && existsSync2(explicitLib)) {
+    return explicitLib;
+  }
+  const embeddedPath = extractEmbeddedNative("snapshot");
+  if (embeddedPath) {
+    return embeddedPath;
+  }
+  if (await buildNativeRuntimeLibrary(outputPath, options)) {
+    return outputPath;
+  }
+  return !options.force && existsSync2(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  const explicitLib = process.env.RIG_NATIVE_RUNTIME_LIB?.trim();
+  if (explicitLib && existsSync2(explicitLib)) {
+    const loaded = tryDlopenNativeRuntimeLibrary(explicitLib);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const embeddedPath = extractEmbeddedNative("snapshot");
+  if (embeddedPath) {
+    const loaded = tryDlopenNativeRuntimeLibrary(embeddedPath);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync2(candidate)) {
+      continue;
+    }
+    const loaded = tryDlopenNativeRuntimeLibrary(candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const builtLibraryPath = await ensureNativeRuntimeLibraryPath(sharedNativeRuntimeOutputPath, { force: true });
+  if (!builtLibraryPath) {
+    return null;
+  }
+  return tryDlopenNativeRuntimeLibrary(builtLibraryPath);
+}
+function nativePackageLibraryCandidates(fromDir, names) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, name), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve2(cursor, "native", name), resolve2(cursor, "native", "lib", name));
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function nativeRuntimeLibraryCandidates() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve2(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, platformSpecific) : "",
+    execDir ? resolve2(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", platformSpecific) : "",
+    execDir ? resolve2(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync2(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve2(import.meta.dir, "../native/snapshot.zig");
+  return existsSync2(bundled) ? bundled : null;
+}
+async function buildNativeRuntimeLibrary(outputPath, options = {}) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return false;
+  }
+  const zigBinary = Bun.which("zig");
+  const sourcePath = resolveNativeRuntimeSourcePath();
+  if (!zigBinary || !sourcePath) {
+    return false;
+  }
+  const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync2(dirname(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync2(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync2(tempOutputPath)) {
+      rmSync(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync2(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync(tempOutputPath, { force: true });
+    return false;
+  }
+}
+function tryDlopenNativeRuntimeLibrary(outputPath) {
+  try {
+    return dlopen(outputPath, {
+      rig_scope_match: {
+        args: ["ptr", "ptr"],
+        returns: "u8"
+      },
+      snapshot_capture: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_delta: {
+        args: ["ptr", "ptr"],
+        returns: "ptr"
+      },
+      snapshot_store_delta: {
+        args: ["ptr", "ptr", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_inspect_delta: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_apply_delta: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_release: {
+        args: ["ptr"],
+        returns: "void"
+      },
+      runtime_hash_file: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_hash_tree: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_prepare_paths: {
+        args: ["ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_link_dependency_layer: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_scan_worktrees: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+function viewAt(address, size) {
+  return Buffer.from(toBuffer(address, 0, size));
+}
+function readU64(view, offset) {
+  return Number(view.readBigUInt64LE(offset));
+}
+function readString(address, length) {
+  if (!address || !length) {
+    return "";
+  }
+  return Buffer.from(toBuffer(address, 0, length)).toString("utf8");
+}
+function throwIfOperationError(view, opName) {
+  const errorPtr = readU64(view, 8);
+  const errorLen = readU64(view, 16);
+  if (!errorPtr || errorLen === 0) {
+    return;
+  }
+  throw new Error(`${opName} failed: ${readString(errorPtr, errorLen)}`);
+}
+function throwIfScanError(view, opName) {
+  const errorPtr = readU64(view, 24);
+  const errorLen = readU64(view, 32);
+  if (!errorPtr || errorLen === 0) {
+    return;
+  }
+  throw new Error(`${opName} failed: ${readString(errorPtr, errorLen)}`);
+}
+
+// packages/isolation-plugin/src/runtime-native-sidecar.ts
+function runRuntimeNativeSidecarCli(rawRequest) {
+  if (!rawRequest) {
+    console.error("usage: runtime-native-sidecar <request-json>");
+    process.exit(2);
+  }
+  try {
+    const request = JSON.parse(rawRequest);
+    const response = handleRequest(request);
+    process.stdout.write(`${JSON.stringify(response)}
+`);
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stdout.write(`${JSON.stringify({ ok: false, error: message })}
+`);
+    process.exit(1);
+  }
+}
+if (import.meta.main && !import.meta.url.includes("$bunfs")) {
+  runRuntimeNativeSidecarCli(process.argv[2]);
+}
+function handleRequest(request) {
+  switch (request.op) {
+    case "prepare-paths":
+      runtimePrepareTrackedPathsInProcess(request.input);
+      return { ok: true };
+    case "link-dependency-layer":
+      runtimeLinkDependencyLayerInProcess(request.input.sourceDir, request.input.targetDir);
+      return { ok: true };
+    case "scan-worktrees":
+      return { ok: true, entries: runtimeScanWorktreesInProcess(request.input.worktreesRoot) };
+    default:
+      return { ok: false, error: `Unsupported runtime native sidecar op: ${request.op ?? "<missing>"}` };
+  }
+}
+export {
+  runRuntimeNativeSidecarCli
+};

package/dist/src/runtime-native.d.ts

@@ -0,0 +1,51 @@
+import { RIG_NATIVE_RUNTIME_SIDECAR_ARG } from "./sidecar-arg";
+export { RIG_NATIVE_RUNTIME_SIDECAR_ARG };
+export type NativeRuntimeSymbols = {
+    rig_scope_match: (patternPtr: number, pathPtr: number) => number;
+    snapshot_capture: (rootPtr: number, rootLen: number, excludePtr: number, excludeLen: number) => number;
+    snapshot_delta: (beforeHandlePtr: number, afterHandlePtr: number) => number;
+    snapshot_store_delta: (beforeHandlePtr: number, afterHandlePtr: number, rootPtr: number, rootLen: number, taskIdPtr: number, taskIdLen: number, capturedAtPtr: number, capturedAtLen: number, outputPtr: number, outputLen: number) => number;
+    snapshot_inspect_delta: (pathPtr: number, pathLen: number) => number;
+    snapshot_apply_delta: (pathPtr: number, pathLen: number, targetPtr: number, targetLen: number) => number;
+    snapshot_release: (resourcePtr: number) => void;
+    runtime_hash_file: (pathPtr: number, pathLen: number) => number;
+    runtime_hash_tree: (pathPtr: number, pathLen: number) => number;
+    runtime_prepare_paths: (logsPtr: number, logsLen: number, statePtr: number, stateLen: number, sessionPtr: number, sessionLen: number, eventsPtr: number, eventsLen: number, bashLogPtr: number, bashLogLen: number) => number;
+    runtime_link_dependency_layer: (sourcePtr: number, sourceLen: number, targetPtr: number, targetLen: number) => number;
+    runtime_scan_worktrees: (rootPtr: number, rootLen: number) => number;
+};
+export type NativeRuntimeLibrary = {
+    symbols: NativeRuntimeSymbols;
+};
+export type NativeRuntimeWorktreeScanEntry = {
+    workspaceDir: string;
+    runtimeDir: string;
+    contextPath: string;
+    metadataPath: string;
+};
+export declare const nativeRuntimeLibrary: NativeRuntimeLibrary | null;
+export declare function requireNativeRuntimeLibrary(feature: string): NativeRuntimeLibrary;
+export declare function runtimeNativeLibraryFileName(): string;
+export declare function runtimePrepareTrackedPathsNative(input: {
+    logsDir: string;
+    stateDir: string;
+    sessionDir: string;
+    eventsFile: string;
+    controlledBashLogFile: string;
+}): void;
+export declare function runtimeLinkDependencyLayerNative(sourceDir: string, targetDir: string): void;
+export declare function runtimeScanWorktreesNative(worktreesRoot: string): NativeRuntimeWorktreeScanEntry[];
+export declare function runtimePrepareTrackedPathsInProcess(input: {
+    logsDir: string;
+    stateDir: string;
+    sessionDir: string;
+    eventsFile: string;
+    controlledBashLogFile: string;
+}): void;
+export declare function runtimeLinkDependencyLayerInProcess(sourceDir: string, targetDir: string): void;
+export declare function runtimeScanWorktreesInProcess(worktreesRoot: string): NativeRuntimeWorktreeScanEntry[];
+export declare function defaultNativeRuntimeLibraryPath(): string;
+export declare function ensureNativeRuntimeLibraryPath(outputPath?: string, options?: {
+    force?: boolean;
+}): Promise<string | null>;
+export declare function materializeNativeRuntimeLibrary(targetDir: string): Promise<string | null>;