@agent-native/core 0.153.9 → 0.154.0

package/corpus/templates/slides/app/lib/image-download.ts

@@ -0,0 +1,84 @@
+import { appBasePath } from "@agent-native/core/client/api-path";
+
+function imageProxyUrl(src: string): string {
+  return `${appBasePath()}/api/image-proxy?url=${encodeURIComponent(src)}`;
+}
+
+function isRemoteHttpUrl(src: string): boolean {
+  try {
+    const url = new URL(src, window.location.href);
+    return (
+      (url.protocol === "http:" || url.protocol === "https:") &&
+      url.origin !== window.location.origin
+    );
+  } catch {
+    // coercion-ok: malformed image sources are treated as non-remote candidates.
+    return false;
+  }
+}
+
+export function imageDownloadFilename(src: string): string {
+  if (/^(?:data|blob):/i.test(src)) return "image";
+
+  try {
+    const pathname = new URL(src, window.location.href).pathname;
+    const filename = pathname.split("/").filter(Boolean).pop();
+    const decoded = filename ? decodeURIComponent(filename) : "";
+    const sanitized = decoded.replace(/[^a-z0-9._-]+/gi, "-");
+    if (sanitized) return sanitized;
+  } catch {
+    // coercion-ok: malformed image sources use the generic download filename.
+    // Use the generic name for malformed or non-URL image sources.
+  }
+  return "image";
+}
+
+function triggerBlobDownload(blob: Blob, filename: string): void {
+  const objectUrl = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = objectUrl;
+  anchor.download = filename;
+  anchor.hidden = true;
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+  URL.revokeObjectURL(objectUrl);
+}
+
+function openImageInNewTab(src: string, filename: string): void {
+  const anchor = document.createElement("a");
+  anchor.href = src;
+  anchor.download = filename;
+  anchor.target = "_blank";
+  anchor.rel = "noopener noreferrer";
+  anchor.hidden = true;
+  document.body.append(anchor);
+  anchor.click();
+  anchor.remove();
+}
+
+/** Download the selected image, proxying external sources when CORS blocks the browser. */
+export async function downloadImage(src: string): Promise<void> {
+  const normalizedSrc = src.trim();
+  if (!normalizedSrc || typeof document === "undefined") return;
+
+  const candidates = [normalizedSrc];
+  if (isRemoteHttpUrl(normalizedSrc)) {
+    candidates.push(imageProxyUrl(normalizedSrc));
+  }
+
+  const filename = imageDownloadFilename(normalizedSrc);
+  for (const candidate of candidates) {
+    try {
+      const response = await fetch(candidate, { credentials: "include" });
+      if (!response.ok) continue;
+      triggerBlobDownload(await response.blob(), filename);
+      return;
+    } catch {
+      // coercion-ok: a failed candidate is retried or falls back to opening the source.
+      // Try the authenticated image proxy before falling back to the source URL.
+    }
+  }
+
+  openImageInNewTab(normalizedSrc, filename);
+}

package/corpus/templates/slides/app/lib/utils.ts

@@ -27,5 +27,5 @@ export function shortcutLabel(shortcut: string): string {
       if (lower === "space") return "Space";
       return token.length === 1 ? token.toUpperCase() : token;
     })
-    .join("+");
+    .join(" ");
 }

package/corpus/templates/slides/app/pages/Index.tsx

@@ -67,6 +67,12 @@ import { useWorkspaceDefaults } from "@/hooks/use-workspace-defaults";
 import { createDeckAgentMessage } from "@/lib/agent-visible-message";
 import { savePromptToComposerDraft } from "@/lib/composer-draft";
 import { isSourceImprovementRequest } from "@/lib/create-deck-generation";
+import {
+  readStoredDeckFilter,
+  resolveDeckFilter,
+  writeStoredDeckFilter,
+  type DeckFilter,
+} from "@/lib/deck-filter";
 import { sortDecksByRecency } from "@/lib/deck-sorting";
 import {
   IMPORT_ACTION_TIMEOUT_MS,
@@ -291,6 +297,7 @@ export default function Index() {
     string | null
   >(null);
   const [deckSearch, setDeckSearch] = useState("");
+  const [storedDeckFilter, setStoredDeckFilter] = useState<DeckFilter>("mine");
   // True while the picker still reflects an auto-applied default rather than
   // an explicit user choice. `useWorkspaceDefaults()`/`useDesignSystems()`
   // resolve asynchronously, so the initial value set on dialog open can be a
@@ -324,7 +331,8 @@ export default function Index() {
   const initialDesignSystemId =
     lastUsedDesignSystemId ?? workspaceDesignSystemId;
   const initialReferenceDeckId = lastUsedReferenceDeckId;
-  const deckFilter = searchParams.get("createdBy") === "me" ? "mine" : "all";
+  const createdByParam = searchParams.get("createdBy");
+  const deckFilter = resolveDeckFilter(createdByParam, storedDeckFilter);
   const normalizedDeckSearch = deckSearch.trim().toLowerCase();
   const visibleDecks = useMemo(
     () =>
@@ -356,6 +364,12 @@ export default function Index() {
     if (result.readable) setRecentReferences(result.items);
   }, []);
 
+  useEffect(() => {
+    if (createdByParam !== null) return;
+    const savedFilter = readStoredDeckFilter();
+    if (savedFilter) setStoredDeckFilter(savedFilter);
+  }, [createdByParam]);
+
   const initialPrompt = searchParams.get("initialPrompt")?.trim() ?? "";
   const onboardingPreview = searchParams.get("onboarding") === "preview";
   const firstRunOnboardingEnabled =
@@ -417,6 +431,8 @@ export default function Index() {
   const setDeckFilter = useCallback(
     (value: string) => {
       const nextFilter = value === "mine" ? "mine" : "all";
+      setStoredDeckFilter(nextFilter);
+      writeStoredDeckFilter(nextFilter);
       setSearchParams(
         (prev) => {
           const next = new URLSearchParams(prev);
@@ -1377,14 +1393,6 @@ export default function Index() {
               className="w-fit rounded-lg border border-border bg-card p-0.5"
               size="sm"
             >
-              <ToggleGroupItem
-                value="all"
-                aria-label={t("home.showAllDecks")}
-                className="h-7 rounded-md px-3 text-xs data-[state=on]:bg-accent"
-              >
-                <IconStack2 className="me-1.5 h-3.5 w-3.5" />
-                {t("home.all")}
-              </ToggleGroupItem>
               <ToggleGroupItem
                 value="mine"
                 aria-label={t("home.showMineDecks")}
@@ -1393,6 +1401,14 @@ export default function Index() {
                 <IconUserCircle className="me-1.5 h-3.5 w-3.5" />
                 {t("home.mine")}
               </ToggleGroupItem>
+              <ToggleGroupItem
+                value="all"
+                aria-label={t("home.showAllDecks")}
+                className="h-7 rounded-md px-3 text-xs data-[state=on]:bg-accent"
+              >
+                <IconStack2 className="me-1.5 h-3.5 w-3.5" />
+                {t("home.all")}
+              </ToggleGroupItem>
             </ToggleGroup>
             <label className="flex h-8 w-full items-center gap-2 rounded-lg border border-border bg-card px-2.5 text-muted-foreground sm:w-60">
               <IconSearch className="size-3.5 shrink-0" aria-hidden="true" />

package/corpus/templates/slides/netlify.toml

@@ -7,6 +7,7 @@ publish = "templates/slides/dist"
 functions = "templates/slides/.netlify/functions-internal"
 
 [build.environment]
+NODE_VERSION = "24.14.0"
 GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 GTM_CONTAINER_ID = "GTM-N3WSTXZ"
 NITRO_PRESET = "netlify"

package/corpus/templates/slides/server/lib/builder-design-system-proxy.ts

@@ -2,6 +2,7 @@ import {
   createBuilderDesignSystemProxyFields,
   localBuilderDesignSystemId,
   type BuilderDesignSystemIndexResult,
+  type BuilderDesignSystemGitHubSource,
   type BuilderDesignSystemSourceKind,
 } from "@agent-native/core/server";
 import { and, eq, isNull } from "drizzle-orm";
@@ -16,6 +17,8 @@ export async function upsertBuilderProxyDesignSystem({
   projectName,
   description,
   sourceKind,
+  githubSources,
+  localDesignSystemId: requestedLocalDesignSystemId,
 }: {
   result: BuilderDesignSystemIndexResult;
   ownerEmail: string;
@@ -23,6 +26,8 @@ export async function upsertBuilderProxyDesignSystem({
   projectName?: string;
   description?: string;
   sourceKind?: BuilderDesignSystemSourceKind;
+  githubSources?: BuilderDesignSystemGitHubSource[];
+  localDesignSystemId?: string;
 }) {
   const db = getDb();
   const now = new Date().toISOString();
@@ -35,6 +40,8 @@ export async function upsertBuilderProxyDesignSystem({
     description,
     surface: "slides",
     sourceKind,
+    githubSources,
+    syncedAt: githubSources?.length ? now : undefined,
   });
   const [existing] = await db
     .select({
@@ -43,7 +50,12 @@ export async function upsertBuilderProxyDesignSystem({
       orgId: schema.designSystems.orgId,
     })
     .from(schema.designSystems)
-    .where(eq(schema.designSystems.id, baseLocalDesignSystemId))
+    .where(
+      eq(
+        schema.designSystems.id,
+        requestedLocalDesignSystemId ?? baseLocalDesignSystemId,
+      ),
+    )
     .limit(1);
   const existingBelongsToScope =
     existing?.ownerEmail === ownerEmail &&
@@ -51,7 +63,7 @@ export async function upsertBuilderProxyDesignSystem({
   const localDesignSystemId =
     existing && !existingBelongsToScope
       ? `${baseLocalDesignSystemId}-${nanoid(8)}`
-      : baseLocalDesignSystemId;
+      : (requestedLocalDesignSystemId ?? baseLocalDesignSystemId);
   if (existingBelongsToScope) {
     await db
       .update(schema.designSystems)

package/dist/agent/production-agent.js

@@ -6499,7 +6499,7 @@ export function createProductionAgentHandler(options) {
                 const capturedAt = typeof sel.capturedAt === "number" ? sel.capturedAt : 0;
                 if (Date.now() - capturedAt > SELECTION_TTL_MS)
                     return "";
-                return (`\n\nThe user has selected the following text and pressed Cmd+I to focus the agent. ` +
+                return (`\n\nThe user has selected the following text and pressed Cmd I to focus the agent. ` +
                     `Treat this as the immediate context to act on:\n` +
                     `<selection>\n${capSelectionContext(sel.text)}\n</selection>`);
             }

package/dist/brand-kit/types.d.ts

@@ -23,8 +23,16 @@ export interface BrandKitColors {
     text: string;
     textMuted: string;
 }
-/** Semantic category a {@link BrandKitToken} belongs to. */
-export type BrandKitTokenType = "color" | "typography" | "spacing" | "radius" | "shadow" | "other";
+/**
+ * Semantic category a {@link BrandKitToken} belongs to.
+ *
+ * `motion` covers durations, easings, and transitions — the DTCG `duration`,
+ * `cubicBezier`, and `transition` types. It exists because a design system's
+ * motion is part of its identity, and a category-less token is a dropped one:
+ * extractors discard what they cannot classify, so "no bucket" silently became
+ * "no motion in any imported system".
+ */
+export type BrandKitTokenType = "color" | "typography" | "spacing" | "radius" | "shadow" | "motion" | "other";
 /**
  * One token under the name its source design system uses. The seven
  * {@link BrandKitColors} roles are a summary view, not a substitute: collapsing

package/dist/cli/code.js

@@ -946,7 +946,7 @@ async function attachCodeAgentRun(runs, args, output) {
     const printed = new Set();
     writeLine(output, "");
     writeLine(output, `Attaching to Agent-Native Code run ${run.id}`);
-    writeLine(output, "Press Ctrl+C to detach. The session keeps its transcript.");
+    writeLine(output, "Press Ctrl C to detach. The session keeps its transcript.");
     writeLine(output, "");
     const printNewEvents = () => {
         const events = listCodeAgentTranscriptEvents(run.id);

package/dist/cli/index.js

@@ -7,6 +7,7 @@ import { fileURLToPath } from "url";
 import * as Sentry from "@sentry/node";
 import { clearAgentNativeNitroPresetMarker, resolveAgentNativeNitroPreset, } from "../deploy/nitro-preset.js";
 import { resolveDeployPostBuildInvocation } from "./deploy-build.js";
+import { assertNativeDependencies, assertNodeRuntimeMarker, ensureNativeDependencies, writeNodeRuntimeMarker, } from "./native-dependencies.js";
 import { cliSpawnOptions } from "./process.js";
 import { shouldTrackCliRun } from "./telemetry-routing.js";
 import { createCliTelemetry } from "./telemetry.js";
@@ -527,6 +528,13 @@ if (shouldTrackCliRun(command, args))
     trackCli("cli.run");
 switch (command) {
     case "dev": {
+        try {
+            ensureNativeDependencies({ repair: true, label: "dev" });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
         if (isWorkspaceRoot()) {
             import("./workspace-dev.js")
                 .then((m) => m.runWorkspaceDev({ args }))
@@ -586,6 +594,7 @@ switch (command) {
         // child exits non-zero, runBuildStep calls process.exit itself; the
         // continuation only runs on success.
         (async () => {
+            ensureNativeDependencies({ repair: true, label: "build" });
             // Doctor pre-step: scans app source for the security-critical guard
             // invariants (see `agent-native doctor --help`). Findings fail by
             // default; only an explicit `doctor.failOnBuild: false` opt-out keeps
@@ -640,6 +649,14 @@ switch (command) {
                     console.warn("[build] Deploy build script not found and no deploy preset is configured. Skipping post-build step.");
                 }
             }
+            const serverDirectory = path.resolve(".output/server");
+            if (fs.existsSync(serverDirectory)) {
+                assertNativeDependencies({
+                    fromDirectory: serverDirectory,
+                    label: "build output",
+                });
+                writeNodeRuntimeMarker(serverDirectory);
+            }
             console.log("\nBuild complete.");
         })().catch((err) => {
             // runBuildStep handles its own failures and exits, so reaching here
@@ -662,7 +679,19 @@ switch (command) {
             console.error('No production build found. Run "agent-native build" first.');
             process.exit(1);
         }
-        run("node", [serverEntry, ...args]);
+        const serverDirectory = path.dirname(serverEntry);
+        try {
+            assertNodeRuntimeMarker(serverDirectory);
+            assertNativeDependencies({
+                fromDirectory: serverDirectory,
+                label: "start output",
+            });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        run(process.execPath, [serverEntry, ...args]);
         break;
     }
     case "action": {

package/dist/cli/native-dependencies.d.ts

@@ -0,0 +1,24 @@
+type NativeDependencyCheck = {
+    status: "absent";
+    packageName: string;
+} | {
+    status: "healthy";
+    packageName: string;
+    packageDir: string;
+} | {
+    status: "broken";
+    packageName: string;
+    packageDir: string;
+    error: unknown;
+};
+export interface NativeDependencyOptions {
+    fromDirectory?: string;
+    label?: string;
+    repair?: boolean;
+}
+export declare function checkNativeDependencies(fromDirectory?: string): NativeDependencyCheck;
+export declare function ensureNativeDependencies(options?: NativeDependencyOptions): NativeDependencyCheck;
+export declare function assertNativeDependencies(options?: Omit<NativeDependencyOptions, "repair">): NativeDependencyCheck;
+export declare function writeNodeRuntimeMarker(serverDirectory: string): string | null;
+export declare function assertNodeRuntimeMarker(serverDirectory: string): void;
+export {};

package/dist/cli/native-dependencies.js

@@ -0,0 +1,264 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const BETTER_SQLITE3 = "better-sqlite3";
+const REBUILD_LOCK = ".agent-native-better-sqlite3-rebuild.lock";
+const RUNTIME_MARKER = ".agent-native-node-runtime.json";
+const LOCK_INITIALIZATION_TIMEOUT_MS = 5_000;
+const REBUILD_WAIT_MS = 250;
+const REBUILD_TIMEOUT_MS = 10 * 60 * 1000;
+function corePackageDirectory() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+function packageRootFromManifest(packageName, manifestPath) {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    return manifest.name === packageName ? path.dirname(manifestPath) : null;
+}
+function resolvePackageDirectory(packageName, fromDirectory) {
+    const requireFromDirectory = createRequire(path.join(path.resolve(fromDirectory), "package.json"));
+    try {
+        const manifestPath = requireFromDirectory.resolve(`${packageName}/package.json`);
+        return packageRootFromManifest(packageName, manifestPath);
+    }
+    catch {
+        try {
+            const entryPath = requireFromDirectory.resolve(packageName);
+            let current = path.dirname(entryPath);
+            while (true) {
+                const manifestPath = path.join(current, "package.json");
+                if (fs.existsSync(manifestPath)) {
+                    const packageDir = packageRootFromManifest(packageName, manifestPath);
+                    if (packageDir)
+                        return packageDir;
+                }
+                const parent = path.dirname(current);
+                if (parent === current)
+                    return null;
+                current = parent;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function probeBetterSqlite3(packageDir) {
+    try {
+        const requireFromPackage = createRequire(path.join(packageDir, "package.json"));
+        const Database = requireFromPackage(BETTER_SQLITE3);
+        const database = new Database(":memory:");
+        database.prepare("select 1 as ok").get();
+        database.close();
+        return null;
+    }
+    catch (error) {
+        return error;
+    }
+}
+export function checkNativeDependencies(fromDirectory = corePackageDirectory()) {
+    const packageDir = resolvePackageDirectory(BETTER_SQLITE3, fromDirectory);
+    if (!packageDir) {
+        return { status: "absent", packageName: BETTER_SQLITE3 };
+    }
+    const error = probeBetterSqlite3(packageDir);
+    return error === null
+        ? { status: "healthy", packageName: BETTER_SQLITE3, packageDir }
+        : { status: "broken", packageName: BETTER_SQLITE3, packageDir, error };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function npmExecutable() {
+    const sibling = path.join(path.dirname(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
+    return fs.existsSync(sibling) ? sibling : "npm";
+}
+function sleepSync(milliseconds) {
+    const signal = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(signal, 0, 0, milliseconds);
+}
+function processIsRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error instanceof Error && "code" in error && error.code !== "ESRCH";
+    }
+}
+function acquireRebuildLock(packageDir, label) {
+    const lockPath = path.join(packageDir, REBUILD_LOCK);
+    const startedWaiting = Date.now();
+    while (true) {
+        try {
+            const lockFd = fs.openSync(lockPath, "wx");
+            fs.writeSync(lockFd, JSON.stringify({
+                pid: process.pid,
+                startedAt: new Date().toISOString(),
+            }));
+            return () => {
+                try {
+                    fs.closeSync(lockFd);
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (error) {
+                        if (!(error instanceof Error &&
+                            "code" in error &&
+                            error.code === "ENOENT")) {
+                            throw error;
+                        }
+                    }
+                }
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+                throw error;
+            }
+            let ownerPid = null;
+            let lockAge = 0;
+            try {
+                const lock = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+                ownerPid = typeof lock.pid === "number" ? lock.pid : null;
+            }
+            catch {
+                // The owner may be between creating and writing the lock metadata.
+            }
+            try {
+                lockAge = Date.now() - fs.statSync(lockPath).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if ((ownerPid !== null && !processIsRunning(ownerPid)) ||
+                (ownerPid === null && lockAge > LOCK_INITIALIZATION_TIMEOUT_MS)) {
+                try {
+                    fs.unlinkSync(lockPath);
+                    continue;
+                }
+                catch (unlinkError) {
+                    if (!(unlinkError instanceof Error &&
+                        "code" in unlinkError &&
+                        unlinkError.code === "ENOENT")) {
+                        throw unlinkError;
+                    }
+                    continue;
+                }
+            }
+            if (Date.now() - startedWaiting > REBUILD_TIMEOUT_MS) {
+                throw new Error(`[${label}] Timed out waiting for another process to finish rebuilding ${BETTER_SQLITE3}.`);
+            }
+            sleepSync(REBUILD_WAIT_MS);
+        }
+    }
+}
+function rebuildNativeDependency(packageDir) {
+    execFileSync(npmExecutable(), ["run", "build-release", "--prefix", packageDir], {
+        cwd: packageDir,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+}
+function brokenDependencyMessage(check, label) {
+    return [
+        `[${label}] ${check.packageName} cannot load its native binding.`,
+        `Package: ${check.packageDir}`,
+        `Node: ${process.version} (ABI ${process.versions.modules}, ${process.platform}-${process.arch})`,
+        `Original error: ${errorMessage(check.error)}`,
+        "The installed native binary was built for a different Node runtime or is otherwise stale.",
+    ].join("\n");
+}
+export function ensureNativeDependencies(options = {}) {
+    const label = options.label ?? "native preflight";
+    const check = checkNativeDependencies(options.fromDirectory);
+    if (check.status !== "broken")
+        return check;
+    if (!options.repair) {
+        throw new Error(brokenDependencyMessage(check, label));
+    }
+    console.warn(`${brokenDependencyMessage(check, label)}\n[${label}] Rebuilding it with the current Node runtime...`);
+    const releaseLock = acquireRebuildLock(check.packageDir, label);
+    try {
+        const current = checkNativeDependencies(options.fromDirectory);
+        if (current.status === "healthy")
+            return current;
+        if (current.status !== "broken") {
+            throw new Error(`[${label}] ${BETTER_SQLITE3} disappeared before its native rebuild.`);
+        }
+        rebuildNativeDependency(current.packageDir);
+        const repaired = checkNativeDependencies(options.fromDirectory);
+        if (repaired.status === "healthy") {
+            console.log(`[${label}] ${repaired.packageName} is ready for Node ABI ${process.versions.modules}.`);
+            return repaired;
+        }
+        if (repaired.status === "broken") {
+            throw new Error(brokenDependencyMessage(repaired, label));
+        }
+        throw new Error(`[${label}] ${BETTER_SQLITE3} disappeared after its native rebuild.`);
+    }
+    finally {
+        releaseLock();
+    }
+}
+export function assertNativeDependencies(options = {}) {
+    const check = checkNativeDependencies(options.fromDirectory);
+    if (check.status === "broken") {
+        throw new Error(brokenDependencyMessage(check, options.label ?? "runtime"));
+    }
+    return check;
+}
+export function writeNodeRuntimeMarker(serverDirectory) {
+    if (!fs.existsSync(serverDirectory))
+        return null;
+    const markerPath = path.join(serverDirectory, RUNTIME_MARKER);
+    const marker = {
+        nodeVersion: process.version,
+        nodeAbi: process.versions.modules,
+        platform: process.platform,
+        arch: process.arch,
+    };
+    fs.writeFileSync(markerPath, `${JSON.stringify(marker)}\n`);
+    return markerPath;
+}
+export function assertNodeRuntimeMarker(serverDirectory) {
+    const markerPath = path.join(serverDirectory, RUNTIME_MARKER);
+    if (!fs.existsSync(markerPath))
+        return;
+    let marker;
+    try {
+        marker = JSON.parse(fs.readFileSync(markerPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`[runtime] Could not read ${RUNTIME_MARKER}: ${errorMessage(error)}`);
+    }
+    const mismatches = [
+        marker.nodeAbi !== process.versions.modules
+            ? `Node ABI ${marker.nodeAbi} (build) vs ${process.versions.modules} (runtime)`
+            : null,
+        marker.platform !== process.platform
+            ? `platform ${marker.platform} (build) vs ${process.platform} (runtime)`
+            : null,
+        marker.arch !== process.arch
+            ? `architecture ${marker.arch} (build) vs ${process.arch} (runtime)`
+            : null,
+    ].filter((value) => value !== null);
+    if (mismatches.length > 0) {
+        throw new Error([
+            `[runtime] Production output was built for a different Node runtime: ${mismatches.join(", ")}.`,
+            `Build Node: ${marker.nodeVersion}; runtime Node: ${process.version}.`,
+            "Run the build and start commands with the same Node installation.",
+        ].join("\n"));
+    }
+}
+function isDirectExecution() {
+    const entryPoint = process.argv[1];
+    return (entryPoint !== undefined &&
+        path.resolve(entryPoint) === path.resolve(fileURLToPath(import.meta.url)));
+}
+if (isDirectExecution() && process.argv.includes("--repair")) {
+    ensureNativeDependencies({ repair: true, label: "native repair" });
+}

package/dist/cli/plan-local.js

@@ -2169,7 +2169,7 @@ async function runServe(args) {
             bridgeUrl: bridge.result.bridgeUrl,
         }),
         "Keep this bridge command running while the Plan page is open; stopping it makes this URL unreachable.",
-        "Press Ctrl+C to stop.",
+        "Press Ctrl C to stop.",
     ]
         .filter(Boolean)
         .join("\n") + "\n");