@gmickel/gno 1.46.0 → 2.0.0

package/src/serve/public/lib/shiki-language-ids.ts

@@ -3,9 +3,13 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "1c",
   "1c-query",
   "abap",
+  "actionscript",
   "actionscript-3",
   "ada",
   "adoc",
+  "ahk",
+  "ahk1",
+  "ahk2",
   "angular-html",
   "angular-ts",
   "apache",
@@ -13,6 +17,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "apl",
   "applescript",
   "ara",
+  "as3",
   "asciidoc",
   "asm",
   "astro",
@@ -37,6 +42,8 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "cadence",
   "cairo",
   "cdc",
+  "chapel",
+  "chpl",
   "cjs",
   "clarity",
   "clj",
@@ -151,6 +158,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "jsx",
   "julia",
   "just",
+  "justfile",
   "kdl",
   "kotlin",
   "kql",
@@ -197,6 +205,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "nginx",
   "nim",
   "nix",
+  "nsis",
   "nu",
   "nushell",
   "objc",
@@ -205,6 +214,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "ocaml",
   "odin",
   "openscad",
+  "org",
   "pascal",
   "perl",
   "perl6",
@@ -228,6 +238,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "pug",
   "puppet",
   "purescript",
+  "pwsh",
   "py",
   "python",
   "ql",
@@ -239,6 +250,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "raku",
   "razor",
   "rb",
+  "rbs",
   "reg",
   "regex",
   "regexp",
@@ -249,6 +261,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "rs",
   "rst",
   "ruby",
+  "ruby-signature",
   "rust",
   "sas",
   "sass",
@@ -264,6 +277,7 @@ export const BUNDLED_LANGUAGE_IDS: ReadonlySet<string> = new Set([
   "shellscript",
   "shellsession",
   "smalltalk",
+  "smithy",
   "solidity",
   "soy",
   "sparql",

package/src/serve/resident-admission.ts

@@ -2,6 +2,8 @@
 
 import type { ResidentRequestHandle } from "./resident-runtime";
 
+import { settlesBy } from "../core/shutdown-budget";
+
 const DEFAULT_READER_LIMIT = 8;
 const DEFAULT_READER_QUEUE_LIMIT = 64;
 
@@ -63,21 +65,32 @@ export class ReaderGate {
         signal?.addEventListener("abort", entry.onAbort, { once: true });
         this.#queue.push(entry);
       });
+      // Release reserved capacity if cancellation won the handoff race.
+      if (signal?.aborted) {
+        this.#releaseSlot();
+        throw new Error("Resident request aborted");
+      }
+    } else {
+      this.#active += 1;
     }
-    if (signal?.aborted) throw new Error("Resident request aborted");
-    this.#active += 1;
     let released = false;
     return () => {
       if (released) return;
       released = true;
-      this.#active -= 1;
-      const next = this.#queue.shift();
-      if (next) {
-        next.signal?.removeEventListener("abort", next.onAbort!);
-        next.resolve();
-      }
+      this.#releaseSlot();
     };
   }
+
+  #releaseSlot(): void {
+    const next = this.#queue.shift();
+    if (next) {
+      // Transfer ownership synchronously, before any fresh acquire can run.
+      next.signal?.removeEventListener("abort", next.onAbort!);
+      next.resolve();
+    } else {
+      this.#active -= 1;
+    }
+  }
 }
 
 export class AdmissionController {
@@ -122,38 +135,25 @@ export class AdmissionController {
     deadlineMs: number,
     abortSettleMs = deadlineMs
   ): Promise<boolean> {
+    this.stop();
+    const deadline = performance.now() + deadlineMs;
+    if (await settlesBy(this.drain(), deadline)) return false;
+    this.cancel();
+    await settlesBy(this.drain(), deadline + abortSettleMs);
+    return true;
+  }
+
+  stop(): void {
     this.#accepting = false;
-    if (this.#requests.size === 0) return false;
-
-    let timeout: ReturnType<typeof setTimeout> | undefined;
-    let deadlineReached = false;
-    await Promise.race([
-      new Promise<void>((resolve) => this.#drainWaiters.add(resolve)),
-      new Promise<void>((resolve) => {
-        timeout = setTimeout(
-          () => {
-            deadlineReached = true;
-            resolve();
-          },
-          Math.max(0, deadlineMs)
-        );
-      }),
-    ]);
-    if (timeout) clearTimeout(timeout);
-
-    if (!deadlineReached) return false;
+  }
 
+  cancel(): void {
     for (const controller of this.#requests.values())
       controller.abort(new Error("Resident runtime is shutting down"));
+  }
 
-    if (this.#requests.size > 0) {
-      await Promise.race([
-        new Promise<void>((resolve) => this.#drainWaiters.add(resolve)),
-        new Promise<void>((resolve) =>
-          setTimeout(resolve, Math.max(0, abortSettleMs))
-        ),
-      ]);
-    }
-    return deadlineReached;
+  drain(): Promise<void> {
+    if (!this.#requests.size) return Promise.resolve();
+    return new Promise<void>((resolve) => this.#drainWaiters.add(resolve));
   }
 }

package/src/serve/resident-background-work.ts

@@ -1,4 +1,8 @@
 /** Tracks cancellable work that intentionally outlives its initiating request. */
+import {
+  withBackgroundInference,
+  withOwnedInferenceScope,
+} from "../llm/inference-scope";
 
 interface BackgroundWorkEntry {
   controller: AbortController;
@@ -21,19 +25,33 @@ export class ResidentBackgroundWork {
       promise: Promise.resolve(),
     };
     entry.promise = Promise.resolve()
-      .then(() => operation(controller.signal))
+      .then(() =>
+        withBackgroundInference(() =>
+          withOwnedInferenceScope({ signal: controller.signal }, () =>
+            operation(controller.signal)
+          )
+        )
+      )
       .catch(() => undefined)
       .finally(() => this.#entries.delete(entry));
     this.#entries.add(entry);
     return true;
   }
 
-  async cancelAndDrain(): Promise<void> {
+  cancel(): void {
     for (const entry of this.#entries) {
       entry.controller.abort(new Error("Resident runtime is shutting down"));
     }
+  }
+
+  async drain(): Promise<void> {
     await Promise.allSettled(
       Array.from(this.#entries, (entry) => entry.promise)
     );
   }
+
+  async cancelAndDrain(): Promise<void> {
+    this.cancel();
+    await this.drain();
+  }
 }

package/src/serve/resident-request.ts

@@ -1,6 +1,7 @@
-/** Admission, bounded-reader, and model-lease boundary for resident REST reads. */
-
 import type { ResidentRuntime } from "./resident-runtime";
+/** Admission and bounded-reader boundary for resident REST reads. */
+
+import { withInferenceScope } from "../llm/inference-scope";
 
 function unavailableResponse(): Response {
   return Response.json(
@@ -100,8 +101,9 @@ export async function handleResidentRead(
   try {
     releaseReader = await runtime.readerGate.acquire(admitted.signal);
     if (admitted.signal.aborted) return unavailableResponse();
-    const response = await runtime.withModelLease(() =>
-      Promise.resolve(operation(admitted.signal))
+    const response = await withInferenceScope(
+      { signal: admitted.signal },
+      async () => operation(admitted.signal)
     );
     if (admitted.signal.aborted) return unavailableResponse();
     if (!isAuthorizationEpochCurrent()) {
@@ -109,7 +111,11 @@ export async function handleResidentRead(
     }
     if (response.headers.get("content-type")?.includes("text/event-stream")) {
       deferredFinish = true;
-      return wrapResidentStream(response, isAuthorizationEpochCurrent, finish);
+      return wrapResidentStream(
+        response,
+        () => !admitted.signal.aborted && isAuthorizationEpochCurrent(),
+        finish
+      );
     }
     return response;
   } catch (error) {

package/src/serve/resident-runtime.ts

@@ -42,9 +42,13 @@ import {
 } from "../core/findings-run-state";
 import { JobManager } from "../core/job-manager";
 import { recordContentMutation } from "../core/mutation-generations";
+import {
+  shutdownDuration,
+  SHUTDOWN_DRAIN_MS,
+  SHUTDOWN_ABORT_MS,
+} from "../core/shutdown-budget";
 import { defaultSyncService, withContentTypeRules } from "../ingestion";
-import { getModelManager } from "../llm/nodeLlamaCpp/lifecycle";
-import { getModelConfig } from "../llm/registry";
+import { withOwnedInferenceScope } from "../llm/inference-scope";
 import { getActivePreset } from "../llm/registry";
 import { createToolContext, Mutex } from "../mcp/context";
 import { SqliteAdapter } from "../store/sqlite/adapter";
@@ -58,10 +62,13 @@ import { createEmbedScheduler } from "./embed-scheduler";
 import { FindingsScheduler, type FindingsPassResult } from "./findings-pass";
 import { AdmissionController, ReaderGate } from "./resident-admission";
 import { ResidentBackgroundWork } from "./resident-background-work";
-import { buildResidentStatusSnapshot } from "./resident-status";
+import { disposeResidentResources } from "./resident-shutdown";
+import {
+  createStandaloneResidentStatus,
+  buildResidentStatusSnapshot,
+} from "./resident-status";
 import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
 
-const DEFAULT_SHUTDOWN_DEADLINE_MS = 5_000;
 const OWNER_LOCK_TIMEOUT_MS = 0;
 
 export type ResidentMode = "serve" | "daemon";
@@ -110,7 +117,10 @@ export interface ResidentRuntime {
   readonly capsuleReverificationScheduler: SavedCapsuleReverificationScheduler;
   /** Present only when daemon mode runs with `findings.enabled`. */
   readonly findingsScheduler: FindingsScheduler | null;
-  readonly modelManager: ModelManager;
+  readonly modelManager: Pick<
+    ModelManager,
+    "acquireLease" | "getLifecycleStats" | "disposeAll"
+  >;
   readonly mcpContext: ToolContext;
   readonly generations: ResidentGeneration;
   readonly activeRequests: number;
@@ -136,7 +146,7 @@ export interface ResidentRuntime {
     runUpdateCmd?: boolean;
     triggerEmbed?: boolean;
   }): Promise<{ syncResult: SyncResult; embedResult: EmbedResult | null }>;
-  dispose(): Promise<void>;
+  dispose(closeSurface?: () => Promise<unknown>): Promise<void>;
 }
 
 export type ResidentRuntimeResult =
@@ -176,6 +186,8 @@ export async function startResidentRuntime(
   options: ResidentRuntimeOptions = {},
   deps: ResidentRuntimeDeps = {}
 ): Promise<ResidentRuntimeResult> {
+  shutdownDuration(options.shutdownDeadlineMs, SHUTDOWN_DRAIN_MS);
+  shutdownDuration(options.shutdownAbortSettleMs, SHUTDOWN_ABORT_MS);
   if (options.index !== undefined && !isValidIndexName(options.index)) {
     return {
       success: false,
@@ -274,9 +286,16 @@ export async function startResidentRuntime(
     eventBus: options.eventBus ?? null,
     watchService: null,
   };
-  const modelManager =
-    deps.modelManagerFactory?.(initialConfig) ??
-    getModelManager(getModelConfig(initialConfig));
+  const modelManager = deps.modelManagerFactory?.(initialConfig) ?? {
+    acquireLease: () =>
+      ctxHolder.current.llm?.acquireModelLease() ?? { release() {} },
+    getLifecycleStats: () =>
+      ctxHolder.current.llm?.getLifecycleStats() ??
+      createStandaloneResidentStatus("stdio").models,
+    disposeAll: async () => {
+      await ctxHolder.current.llm?.dispose();
+    },
+  };
   const generations: ResidentGeneration = { content: 0, index: 0 };
   ctxHolder.markContentMutation = () => {
     generations.content += 1;
@@ -289,7 +308,6 @@ export async function startResidentRuntime(
     getEmbedPort: () => ctxHolder.current.embedPort,
     getVectorIndex: () => ctxHolder.current.vectorIndex,
     getModelUri: () => getActivePreset(ctxHolder.config).embed,
-    acquireModelLease: () => modelManager.acquireLease(),
     onEmbedded: () => {
       generations.index += 1;
     },
@@ -350,6 +368,7 @@ export async function startResidentRuntime(
   let shutdownState: ResidentStatus["shutdown"]["state"] = "none";
   let admissionState: ResidentStatus["admission"]["state"] = "accepting";
   let disposed = false;
+  let disposal: Promise<void> | undefined;
   const backgroundWork = new ResidentBackgroundWork(
     () => !disposed && admission.accepting
   );
@@ -405,7 +424,8 @@ export async function startResidentRuntime(
     writeLockPath,
     enableWrite: false,
     isShuttingDown: () => disposed || !admission.accepting,
-    acquireModelLease: () => modelManager.acquireLease(),
+    getModelAdapter: (config) =>
+      config === ctxHolder.current.config ? ctxHolder.current.llm : undefined,
     markContentMutation: () => {
       generations.content += 1;
     },
@@ -545,60 +565,76 @@ export async function startResidentRuntime(
       policySessionInvalidator = invalidator;
     },
     async syncAll(syncOptions = {}) {
-      const config = ctxHolder.config;
-      const syncAllService = deps.syncAllService
-        ? (...args: Parameters<typeof defaultSyncService.syncAll>) =>
-            deps.syncAllService!(...args)
-        : defaultSyncService.syncAll.bind(defaultSyncService);
-      const syncResult = await syncAllService(
-        config.collections,
-        store,
-        withContentTypeRules(
-          {
-            gitPull: syncOptions.gitPull,
-            runUpdateCmd: syncOptions.runUpdateCmd,
-          },
-          config
-        )
-      );
-      recordContentMutation(syncResult, () => {
-        generations.content += 1;
-      });
-      const embedResult =
-        syncOptions.triggerEmbed === false
-          ? null
-          : await scheduler.triggerNow();
-      capsuleReverificationScheduler.notifySyncSettled();
-      return { syncResult, embedResult };
+      const request = admission.admit();
+      if (!request) throw new Error("Resident runtime is shutting down");
+      try {
+        return await withOwnedInferenceScope(
+          { signal: request.signal },
+          async () => {
+            const config = ctxHolder.config;
+            const syncAllService = deps.syncAllService
+              ? (...args: Parameters<typeof defaultSyncService.syncAll>) =>
+                  deps.syncAllService!(...args)
+              : defaultSyncService.syncAll.bind(defaultSyncService);
+            const syncResult = await syncAllService(
+              config.collections,
+              store,
+              withContentTypeRules(
+                {
+                  gitPull: syncOptions.gitPull,
+                  runUpdateCmd: syncOptions.runUpdateCmd,
+                },
+                config
+              )
+            );
+            recordContentMutation(syncResult, () => {
+              generations.content += 1;
+            });
+            const embedResult =
+              syncOptions.triggerEmbed === false
+                ? null
+                : await scheduler.triggerNow();
+            capsuleReverificationScheduler.notifySyncSettled();
+            return { syncResult, embedResult };
+          }
+        );
+      } finally {
+        request.finish();
+      }
     },
-    async dispose() {
-      if (disposed) return;
+    dispose(closeSurface) {
+      if (disposal) return disposal;
       disposed = true;
+      admission.stop();
+      jobManager.stop();
       admissionState = "draining";
       shutdownState = "graceful";
-      const deadlineReached = await admission.closeAndDrain(
-        options.shutdownDeadlineMs ?? DEFAULT_SHUTDOWN_DEADLINE_MS,
-        options.shutdownAbortSettleMs ?? DEFAULT_SHUTDOWN_DEADLINE_MS
-      );
-      if (deadlineReached) shutdownState = "deadline";
-      findingsScheduler?.dispose();
-      await backgroundWork.cancelAndDrain();
-      await capsuleReverificationScheduler.dispose();
-      await jobManager.shutdown().catch(() => undefined);
-      await Promise.allSettled([
-        Promise.resolve().then(() => watchService.dispose()),
-        Promise.resolve().then(() => options.eventBus?.close()),
-      ]);
-      await Promise.allSettled([scheduler.dispose()]);
-      await Promise.allSettled([
-        (deps.disposeServerContext ?? disposeServerContext)(ctxHolder.current),
-      ]);
-      await Promise.allSettled([modelManager.disposeAll()]);
-      await Promise.allSettled([store.close()]);
-      await Promise.allSettled([ownerLock.release()]);
-      admissionState = "closed";
-      transportStatusProvider = null;
-      listenerPort = null;
+      disposal = disposeResidentResources({
+        options,
+        admission,
+        backgroundWork,
+        jobManager,
+        scheduler,
+        store,
+        watchService,
+        context: ctxHolder.current,
+        mcpContext,
+        modelManager,
+        ownerLock,
+        stopFindings: () => findingsScheduler?.dispose(),
+        stopCapsules: () => capsuleReverificationScheduler.dispose(),
+        closeEvents: () => options.eventBus?.close(),
+        disposeContext: deps.disposeServerContext ?? disposeServerContext,
+        closeSurface,
+        onDeadline: () => {
+          shutdownState = "deadline";
+        },
+      }).then(() => {
+        admissionState = "closed";
+        transportStatusProvider = null;
+        listenerPort = null;
+      });
+      return disposal;
     },
   };
   ctxHolder.startBackgroundWork = (operation) =>

package/src/serve/resident-shutdown.ts

@@ -0,0 +1,153 @@
+import type { WriteLockHandle } from "../core/file-lock";
+/** One finite shutdown clock for the resources owned by a resident runtime. */
+import type { JobManager } from "../core/job-manager";
+import type { ToolContext } from "../mcp/context";
+import type { SqliteAdapter } from "../store/sqlite/adapter";
+import type { ServerContext } from "./context";
+import type { EmbedScheduler } from "./embed-scheduler";
+import type { AdmissionController } from "./resident-admission";
+import type { ResidentBackgroundWork } from "./resident-background-work";
+import type { ResidentRuntimeOptions } from "./resident-runtime";
+
+import {
+  settlesBy,
+  shutdownDuration,
+  SHUTDOWN_DRAIN_MS,
+  SHUTDOWN_ABORT_MS,
+  SHUTDOWN_EXIT_MS,
+} from "../core/shutdown-budget";
+
+interface ResidentShutdownResources {
+  options: ResidentRuntimeOptions;
+  admission: AdmissionController;
+  backgroundWork: ResidentBackgroundWork;
+  jobManager: JobManager;
+  scheduler: EmbedScheduler;
+  store: SqliteAdapter;
+  watchService: { dispose(): void | Promise<void> };
+  context: ServerContext;
+  mcpContext: ToolContext;
+  modelManager: { disposeAll(): Promise<void> };
+  ownerLock: WriteLockHandle;
+  stopFindings: () => void;
+  stopCapsules: () => Promise<void>;
+  closeEvents: () => void | Promise<void>;
+  disposeContext: (context: ServerContext) => Promise<void>;
+  closeSurface?: () => Promise<unknown>;
+  onDeadline: () => void;
+}
+
+export async function disposeResidentResources(
+  resources: ResidentShutdownResources
+): Promise<void> {
+  const {
+    options,
+    admission,
+    backgroundWork,
+    jobManager,
+    scheduler,
+    store,
+    watchService,
+    context,
+    mcpContext,
+    modelManager,
+    ownerLock,
+    stopFindings,
+    stopCapsules,
+    closeEvents,
+    disposeContext,
+    closeSurface,
+    onDeadline,
+  } = resources;
+  let deadlineReached = false;
+  const drainDeadline =
+    performance.now() +
+    shutdownDuration(options.shutdownDeadlineMs, SHUTDOWN_DRAIN_MS);
+  const abortDeadline =
+    drainDeadline +
+    shutdownDuration(options.shutdownAbortSettleMs, SHUTDOWN_ABORT_MS);
+  const exitDeadline = abortDeadline + SHUTDOWN_EXIT_MS;
+  let unfinishedJobs: Promise<void> = Promise.resolve();
+  let writeFailure: unknown;
+  store.beginShutdown?.(abortDeadline);
+  const observe = (operation: () => unknown): Promise<void> =>
+    Promise.resolve()
+      .then(operation)
+      .then(
+        () => {},
+        (error: unknown) => console.error("Resident cleanup failed:", error)
+      );
+  stopFindings();
+  const schedulerDrain = observe(() =>
+    scheduler.stop ? scheduler.stop() : scheduler.dispose()
+  );
+  const work = Promise.all([
+    observe(() => closeSurface?.()),
+    admission.drain(),
+    backgroundWork.drain(),
+    jobManager.shutdown(),
+    schedulerDrain,
+    observe(() => stopCapsules()),
+    observe(() => watchService.dispose()),
+    observe(() => closeEvents()),
+  ]);
+  if (!(await settlesBy(work, drainDeadline))) {
+    deadlineReached = true;
+    onDeadline();
+    admission.cancel();
+    backgroundWork.cancel();
+    jobManager.cancel();
+    const canceledScheduler = observe(() => scheduler.dispose());
+    if (
+      !(await settlesBy(Promise.all([work, canceledScheduler]), abortDeadline))
+    ) {
+      // Revoke/rollback suspended parent writers before closing their DB.
+      // The ordinary store API also fences any late noncooperative callback.
+      try {
+        store.fenceForShutdown?.();
+        // Calling close synchronously closes cached raw handles before
+        // any late callback can resume in the native-exit wait.
+        const closing = store.close();
+        unfinishedJobs = jobManager.failUnfinished();
+        if (!(await settlesBy(closing, exitDeadline)))
+          throw new Error("Store close exceeded shutdown deadline");
+      } catch (error) {
+        writeFailure = error;
+      }
+    }
+  }
+  // Reach the single native owner directly; port disposal may itself wait
+  // for that owner. Never let such a wait hide the forced-exit deadline.
+  const nativeOptions = {
+    deadline: exitDeadline,
+    force: deadlineReached,
+  };
+  const native = Promise.all([
+    context.llm?.dispose(nativeOptions),
+    mcpContext.disposeModels?.(nativeOptions),
+  ]);
+  let nativeFailure: unknown;
+  try {
+    if (!(await settlesBy(native, exitDeadline)))
+      throw new Error(
+        "Native shutdown did not settle before owned-child exit deadline"
+      );
+  } catch (error) {
+    nativeFailure = error;
+    console.error("Resident native shutdown failed:", error);
+  }
+  const cleanup = Promise.all([
+    unfinishedJobs,
+    observe(() => disposeContext(context)),
+    observe(() => modelManager.disposeAll()),
+  ]);
+  if (!(await settlesBy(cleanup, exitDeadline)))
+    console.error("Resident resource cleanup exceeded shutdown deadline");
+  // close performs synchronous rollback/revocation before disconnecting.
+  if (writeFailure) throw writeFailure;
+  if (!(await settlesBy(store.close(), exitDeadline)))
+    throw new Error("Store close exceeded shutdown deadline");
+  if (!(await settlesBy(ownerLock.release(), exitDeadline)))
+    throw new Error("Resident owner lock release exceeded shutdown deadline");
+  if (nativeFailure) throw nativeFailure;
+}

package/src/serve/routes/api.ts

@@ -4244,7 +4244,9 @@ export async function handleSearch(
       req,
       trace.session,
       "failed",
-      errorResponse("RUNTIME", result.error.message, 500)
+      result.error.code === "INVALID_INPUT"
+        ? errorResponse("VALIDATION", result.error.message, 400)
+        : errorResponse("RUNTIME", result.error.message, 500)
     );
   }