@sentry/junior 0.1.1 → 0.3.0

package/dist/{chunk-BBOVH5RF.js → chunk-PY4AI2GZ.js}

@@ -225,13 +225,21 @@ function emitSentry(level, body, attributes) {
     loggerFn(body, attributes);
     return;
   }
-  Sentry.withScope((scope) => {
-    for (const [key, value] of Object.entries(attributes)) {
-      scope.setExtra(key, value);
-    }
-    const sentryLevel = level === "warn" ? "warning" : level;
-    Sentry.captureMessage(body, sentryLevel);
-  });
+  const sentryWithScope = sentry.withScope;
+  const sentryCaptureMessage = sentry.captureMessage;
+  const sentryLevel = level === "warn" ? "warning" : level;
+  if (typeof sentryWithScope === "function" && typeof sentryCaptureMessage === "function") {
+    sentryWithScope((scope) => {
+      for (const [key, value] of Object.entries(attributes)) {
+        scope.setExtra(key, value);
+      }
+      sentryCaptureMessage(body, sentryLevel);
+    });
+    return;
+  }
+  if (typeof sentryCaptureMessage === "function") {
+    sentryCaptureMessage(body, sentryLevel);
+  }
 }
 function formatConsoleLevel(level) {
   if (level === "debug") return "DBG";
@@ -353,12 +361,22 @@ var log = {
       "exception.message": normalizedError.message,
       "exception.stacktrace": normalizedError.stack
     }, body ?? normalizedError.message);
-    Sentry.withScope((scope) => {
-      for (const [key, value] of Object.entries(mergeAttributes(contextStorage.getStore(), attrs))) {
-        scope.setExtra(key, value);
-      }
-      Sentry.captureException(normalizedError);
-    });
+    let eventId;
+    const sentryWithScope = Sentry.withScope;
+    const sentryCaptureException = Sentry.captureException;
+    if (typeof sentryWithScope === "function" && typeof sentryCaptureException === "function") {
+      sentryWithScope((scope) => {
+        for (const [key, value] of Object.entries(mergeAttributes(contextStorage.getStore(), attrs))) {
+          scope.setExtra(key, value);
+        }
+        eventId = sentryCaptureException(normalizedError);
+      });
+      return eventId;
+    }
+    if (typeof sentryCaptureException === "function") {
+      eventId = sentryCaptureException(normalizedError);
+    }
+    return eventId;
   }
 };
 function withLogContext(context, callback) {
@@ -437,7 +455,7 @@ function logError(eventName, context = {}, attributes = {}, body) {
 }
 function logException(error, eventName, context = {}, attributes = {}, body) {
   const normalizedError = error instanceof Error ? error : new Error(String(error));
-  log.exception(eventName, normalizedError, toContextAndAttributes(context, attributes), body);
+  return log.exception(eventName, normalizedError, toContextAndAttributes(context, attributes), body);
 }
 function setTags(context = {}) {
   setLogContext(context);
@@ -504,6 +522,34 @@ function setSpanStatus(status) {
 function toOptionalString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function getActiveTraceId() {
+  const sentry = Sentry2;
+  if (typeof sentry.getActiveSpan !== "function" || typeof sentry.spanToJSON !== "function") {
+    return void 0;
+  }
+  try {
+    const span = sentry.getActiveSpan();
+    if (!span) {
+      return void 0;
+    }
+    return toOptionalString(sentry.spanToJSON(span).trace_id);
+  } catch {
+    return void 0;
+  }
+}
+function resolveErrorReference(eventId) {
+  const traceId = getActiveTraceId();
+  if (!eventId && !traceId) {
+    return null;
+  }
+  if (!traceId) {
+    return null;
+  }
+  return {
+    traceId,
+    ...eventId ? { eventId } : {}
+  };
+}
 
 export {
   logInfo,
@@ -516,5 +562,6 @@ export {
   withSpan,
   setSpanAttributes,
   setSpanStatus,
-  toOptionalString
+  toOptionalString,
+  resolveErrorReference
 };

package/dist/{chunk-OVG2HBNM.js → chunk-RTQMRGZD.js}

@@ -6,13 +6,13 @@ import {
   setSpanStatus,
   withContext,
   withSpan
-} from "./chunk-BBOVH5RF.js";
+} from "./chunk-PY4AI2GZ.js";
 
 // src/handlers/webhooks.ts
 import { after } from "next/server";
 import * as Sentry from "@sentry/nextjs";
 async function loadBot() {
-  const { bot } = await import("./bot-6KXJ366H.js");
+  const { bot } = await import("./bot-JSIREVQD.js");
   return bot;
 }
 async function POST(request, context) {

package/dist/chunk-SP6LV35L.js

@@ -0,0 +1,328 @@
+// src/chat/fs-utils.ts
+import { statSync } from "fs";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/chat/discovery-roots.ts
+import { readdirSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function normalizePath(targetPath) {
+  return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) {
+      dirs.push(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile(path.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder(explicit);
+  }
+  return uniqueResolvedPathsInOrder([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(cwd, options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder([cwd, ...roots]);
+}
+function listTopLevelPackages(nodeModulesDir) {
+  const entries = readdirSync(nodeModulesDir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".") && entry.name !== ".bin" && entry.name !== ".pnpm").sort((left, right) => left.name.localeCompare(right.name));
+  const packages = [];
+  for (const entry of entries) {
+    const entryPath = path.join(nodeModulesDir, entry.name);
+    if (entry.name.startsWith("@")) {
+      if (!isDirectory(entryPath)) {
+        continue;
+      }
+      const scopedEntries = readdirSync(entryPath, { withFileTypes: true }).sort(
+        (left, right) => left.name.localeCompare(right.name)
+      );
+      for (const scopedEntry of scopedEntries) {
+        const packageName = `${entry.name}/${scopedEntry.name}`;
+        const packagePath = path.join(entryPath, scopedEntry.name);
+        if (!isDirectory(packagePath)) {
+          continue;
+        }
+        packages.push({ name: packageName, dir: packagePath });
+      }
+      continue;
+    }
+    if (!isDirectory(entryPath)) {
+      continue;
+    }
+    packages.push({ name: entry.name, dir: entryPath });
+  }
+  return packages;
+}
+
+// src/chat/plugins/package-discovery.ts
+import { createRequire } from "module";
+import path2 from "path";
+var require2 = createRequire(import.meta.url);
+function normalizeForGlob(targetPath) {
+  return targetPath.split(path2.sep).join("/");
+}
+function uniqueStringsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    resolved.push(value);
+  }
+  return resolved;
+}
+function pathWithinCwd(cwd, targetPath) {
+  const relative = path2.relative(cwd, targetPath);
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
+    return null;
+  }
+  return `./${normalizeForGlob(relative)}`;
+}
+function parseRuntimeConfiguredPackageNames(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const parsed = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  return uniqueStringsInOrder(parsed.map((entry) => entry.trim()));
+}
+function readNextRuntimeConfiguredPackageNames() {
+  try {
+    const nextConfigModule = require2("next/config");
+    const getConfig = nextConfigModule.default;
+    if (typeof getConfig !== "function") {
+      return null;
+    }
+    const runtimeConfig = getConfig();
+    return parseRuntimeConfiguredPackageNames(runtimeConfig?.serverRuntimeConfig?.juniorPluginPackages) ?? [];
+  } catch {
+    return null;
+  }
+}
+function findContainingNodeModulesDir(targetPath) {
+  let current = path2.resolve(targetPath);
+  while (true) {
+    if (path2.basename(current) === "node_modules") {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
+  for (const nodeModulesDir of candidateNodeModulesDirs) {
+    const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
+    if (isDirectory(packageDir)) {
+      return {
+        dir: path2.resolve(packageDir),
+        nodeModulesDir: path2.resolve(nodeModulesDir)
+      };
+    }
+  }
+  try {
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const dir = path2.dirname(packageJsonPath);
+    const nodeModulesDir = findContainingNodeModulesDir(dir);
+    if (!nodeModulesDir) {
+      return null;
+    }
+    return {
+      dir: path2.resolve(dir),
+      nodeModulesDir: path2.resolve(nodeModulesDir)
+    };
+  } catch {
+    return null;
+  }
+}
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs) {
+  const discovered = [];
+  const seenPackageNames = /* @__PURE__ */ new Set();
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const resolved = resolvePackageDirFromName(packageName, candidateNodeModulesDirs);
+    if (!resolved) {
+      continue;
+    }
+    if (seenPackageNames.has(packageName) || seenPackageDirs.has(resolved.dir)) {
+      continue;
+    }
+    const hasRootPluginManifest = isFile(path2.join(resolved.dir, "plugin.yaml"));
+    const hasPluginsDir = isDirectory(path2.join(resolved.dir, "plugins"));
+    const hasSkillsDir = isDirectory(path2.join(resolved.dir, "skills"));
+    if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+      continue;
+    }
+    seenPackageNames.add(packageName);
+    seenPackageDirs.add(resolved.dir);
+    discovered.push({
+      name: packageName,
+      dir: resolved.dir,
+      nodeModulesDir: resolved.nodeModulesDir,
+      hasRootPluginManifest,
+      hasPluginsDir,
+      hasSkillsDir
+    });
+  }
+  return discovered;
+}
+function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModulesDirs, packageNames) {
+  const resolvedCwd = path2.resolve(cwd);
+  const candidateNodeModulesDirs = nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
+  const configuredPackageNames = packageNames ?? readNextRuntimeConfiguredPackageNames();
+  const declaredPackages = discoverDeclaredPackages(configuredPackageNames ?? [], candidateNodeModulesDirs);
+  const useFallbackScan = configuredPackageNames === null;
+  const discovered = [...declaredPackages];
+  const seenPackageNames = /* @__PURE__ */ new Set();
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const pkg of declaredPackages) {
+    seenPackageNames.add(pkg.name);
+    seenPackageDirs.add(pkg.dir);
+  }
+  if (!useFallbackScan) {
+    return discovered;
+  }
+  for (const nodeModulesDir of candidateNodeModulesDirs) {
+    for (const pkg of listTopLevelPackages(nodeModulesDir)) {
+      const resolvedDir = path2.resolve(pkg.dir);
+      if (seenPackageNames.has(pkg.name) || seenPackageDirs.has(resolvedDir)) {
+        continue;
+      }
+      seenPackageNames.add(pkg.name);
+      seenPackageDirs.add(resolvedDir);
+      const hasRootPluginManifest = isFile(path2.join(resolvedDir, "plugin.yaml"));
+      const hasPluginsDir = isDirectory(path2.join(resolvedDir, "plugins"));
+      const hasSkillsDir = isDirectory(path2.join(resolvedDir, "skills"));
+      if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+        continue;
+      }
+      discovered.push({
+        name: pkg.name,
+        dir: resolvedDir,
+        nodeModulesDir: path2.resolve(nodeModulesDir),
+        hasRootPluginManifest,
+        hasPluginsDir,
+        hasSkillsDir
+      });
+    }
+  }
+  return discovered;
+}
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+  const resolvedCwd = path2.resolve(cwd);
+  const discoveredPackages = discoverInstalledJuniorContentPackages(resolvedCwd, options?.nodeModulesDirs, options?.packageNames);
+  const manifestRoots = [];
+  const skillRoots = [];
+  const tracingIncludes = [];
+  for (const pkg of discoveredPackages) {
+    const packagePathFromNodeModules = pathWithinCwd(resolvedCwd, path2.join(pkg.nodeModulesDir, ...pkg.name.split("/")));
+    if (pkg.hasRootPluginManifest) {
+      manifestRoots.push(pkg.dir);
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/plugin.yaml`);
+      }
+    }
+    if (pkg.hasPluginsDir) {
+      manifestRoots.push(path2.join(pkg.dir, "plugins"));
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/plugins/**/*`);
+      }
+    }
+    if (pkg.hasSkillsDir) {
+      skillRoots.push(path2.join(pkg.dir, "skills"));
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/skills/**/*`);
+      }
+    }
+  }
+  return {
+    packageNames: uniqueStringsInOrder(discoveredPackages.map((pkg) => pkg.name)),
+    manifestRoots: uniqueStringsInOrder(manifestRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots),
+    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+  };
+}
+
+export {
+  isDirectory,
+  discoverNodeModulesDirs,
+  discoverProjectRoots,
+  discoverInstalledPluginPackageContent
+};

package/dist/cli/init.d.ts

@@ -0,0 +1,3 @@
+declare function runInit(dir: string, log?: (line: string) => void): Promise<void>;
+
+export { runInit };

package/dist/cli/init.js

@@ -0,0 +1,105 @@
+// src/cli/init.ts
+import fs from "fs";
+import path from "path";
+function writeRouteModule(filePath, exportLine) {
+  fs.writeFileSync(filePath, `${exportLine}
+export const runtime = "nodejs";
+`);
+}
+function writeWrapperFiles(targetDir) {
+  const routeDir = path.join(targetDir, "app", "api", "[...path]");
+  fs.mkdirSync(routeDir, { recursive: true });
+  writeRouteModule(path.join(routeDir, "route.js"), 'export { GET, POST } from "@sentry/junior/handler";');
+  const queueRouteDir = path.join(targetDir, "app", "api", "queue", "callback");
+  fs.mkdirSync(queueRouteDir, { recursive: true });
+  writeRouteModule(
+    path.join(queueRouteDir, "route.js"),
+    'export { POST } from "@sentry/junior/handlers/queue-callback";'
+  );
+  fs.mkdirSync(path.join(targetDir, "app"), { recursive: true });
+  fs.writeFileSync(
+    path.join(targetDir, "app", "layout.js"),
+    'export { default } from "@sentry/junior/app/layout";\n'
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "next.config.mjs"),
+    'import { withJunior } from "@sentry/junior/config";\nexport default withJunior();\n'
+  );
+  fs.writeFileSync(
+    path.join(targetDir, "instrumentation.js"),
+    'export { register, onRequestError } from "@sentry/junior/instrumentation";\n'
+  );
+}
+async function runInit(dir, log = console.log) {
+  const targetDir = dir.trim();
+  if (!targetDir) {
+    throw new Error("usage: junior init <dir>");
+  }
+  const target = path.resolve(targetDir);
+  if (fs.existsSync(target)) {
+    const stat = fs.statSync(target);
+    if (!stat.isDirectory()) {
+      throw new Error(`refusing to initialize non-directory path: ${target}`);
+    }
+    if (fs.readdirSync(target).length > 0) {
+      throw new Error(`refusing to initialize non-empty directory: ${target}`);
+    }
+  } else {
+    fs.mkdirSync(target, { recursive: true });
+  }
+  const name = path.basename(target);
+  const pkg = {
+    name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start"
+    },
+    dependencies: {
+      "@sentry/junior": "latest",
+      next: "^16.0.0",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+      "@sentry/nextjs": "^10.0.0"
+    }
+  };
+  fs.writeFileSync(path.join(target, "package.json"), `${JSON.stringify(pkg, null, 2)}
+`);
+  const dataDir = path.join(target, "app", "data");
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(dataDir, "SOUL.md"), `# ${name}
+
+You are ${name}, a helpful assistant.
+`);
+  const skillsDir = path.join(target, "app", "skills");
+  fs.mkdirSync(skillsDir, { recursive: true });
+  fs.writeFileSync(path.join(skillsDir, ".gitkeep"), "");
+  const pluginsDir = path.join(target, "app", "plugins");
+  fs.mkdirSync(pluginsDir, { recursive: true });
+  fs.writeFileSync(path.join(pluginsDir, ".gitkeep"), "");
+  fs.writeFileSync(path.join(target, ".gitignore"), ["node_modules/", ".next/", ".env", ".env.local", ""].join("\n"));
+  fs.writeFileSync(
+    path.join(target, ".env.example"),
+    [
+      "SLACK_BOT_TOKEN=",
+      "SLACK_SIGNING_SECRET=",
+      "JUNIOR_BOT_NAME=",
+      "AI_MODEL=",
+      "AI_FAST_MODEL=",
+      "REDIS_URL=",
+      "NEXT_PUBLIC_SENTRY_DSN=",
+      ""
+    ].join("\n")
+  );
+  writeWrapperFiles(target);
+  log(`Created ${name} at ${target}`);
+  log("");
+  log(`  cd ${targetDir} && pnpm install && pnpm dev`);
+  log("");
+}
+export {
+  runInit
+};

package/dist/cli/run.d.ts

@@ -0,0 +1,11 @@
+declare const CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+interface CliHandlers {
+    runInit: (dir: string) => Promise<void>;
+    runSnapshotCreate: () => Promise<void>;
+}
+interface CliIo {
+    error: (line: string) => void;
+}
+declare function runCli(argv: string[], handlers: CliHandlers, io?: CliIo): Promise<number>;
+
+export { CLI_USAGE, runCli };

package/dist/cli/run.js

@@ -0,0 +1,30 @@
+// src/cli/run.ts
+var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create";
+var DEFAULT_IO = {
+  error: console.error
+};
+async function runCli(argv, handlers, io = DEFAULT_IO) {
+  const [command, subcommand, ...rest] = argv;
+  if (command === "init") {
+    if (!subcommand || rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runInit(subcommand);
+    return 0;
+  }
+  if (command === "snapshot" && subcommand === "create") {
+    if (rest.length > 0) {
+      io.error(CLI_USAGE);
+      return 1;
+    }
+    await handlers.runSnapshotCreate();
+    return 0;
+  }
+  io.error(CLI_USAGE);
+  return 1;
+}
+export {
+  CLI_USAGE,
+  runCli
+};

package/dist/cli/snapshot-warmup.d.ts

@@ -0,0 +1,3 @@
+declare function runSnapshotCreate(log?: (line: string) => void): Promise<void>;
+
+export { runSnapshotCreate };

package/dist/cli/snapshot-warmup.js

@@ -0,0 +1,58 @@
+import {
+  disconnectStateAdapter,
+  resolveRuntimeDependencySnapshot
+} from "../chunk-DPTR2FNH.js";
+import "../chunk-PY4AI2GZ.js";
+import "../chunk-SP6LV35L.js";
+
+// src/cli/snapshot-warmup.ts
+var DEFAULT_RUNTIME = "node22";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+function progressMessage(phase) {
+  if (phase === "resolve_start") {
+    return "Resolving sandbox snapshot profile...";
+  }
+  if (phase === "cache_hit") {
+    return "Using cached sandbox snapshot.";
+  }
+  if (phase === "waiting_for_lock") {
+    return "Waiting for sandbox snapshot build lock...";
+  }
+  if (phase === "building_snapshot") {
+    return "Building sandbox snapshot...";
+  }
+  return "Sandbox snapshot build complete.";
+}
+async function runSnapshotCreate(log = console.log) {
+  const runtime = DEFAULT_RUNTIME;
+  const timeoutMs = DEFAULT_TIMEOUT_MS;
+  try {
+    const emitted = /* @__PURE__ */ new Set();
+    const snapshot = await resolveRuntimeDependencySnapshot({
+      runtime,
+      timeoutMs,
+      onProgress: async (phase) => {
+        if (emitted.has(phase)) {
+          return;
+        }
+        emitted.add(phase);
+        log(progressMessage(phase));
+      }
+    });
+    const fields = [
+      `runtime=${runtime}`,
+      `resolve_outcome=${snapshot.resolveOutcome}`,
+      `cache_hit=${snapshot.cacheHit}`,
+      `dependency_count=${snapshot.dependencyCount}`,
+      ...snapshot.profileHash ? [`profile_hash=${snapshot.profileHash}`] : [],
+      ...snapshot.snapshotId ? [`snapshot_id=${snapshot.snapshotId}`] : [],
+      ...snapshot.rebuildReason ? [`rebuild_reason=${snapshot.rebuildReason}`] : []
+    ];
+    log(`Sandbox snapshot create complete: ${fields.join(" ")}`);
+  } finally {
+    await disconnectStateAdapter();
+  }
+}
+export {
+  runSnapshotCreate
+};

package/dist/handlers/health.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Returns a minimal JSON health response for runtime health checks.
+ */
 declare function GET(): Promise<Response>;
 
 export { GET };

package/dist/handlers/queue-callback.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Handles `POST /api/queue/callback` for asynchronous thread processing.
+ *
+ * Keep this route as a dedicated handler in app code. The catch-all router can
+ * mirror this path for local/dev parity, but production queue delivery should
+ * always target the dedicated endpoint.
+ */
 declare function POST(request: Request): Promise<Response>;
 
 export { POST };