@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/bare/registry/registry-client.js

@@ -1,8 +1,8 @@
-import { QVACRegistryClient } from "@qvac/registry-client";
-import { getCacheDir } from "../../utils/cache/paths.js";
-import { registerSwarm, unregisterSwarm, registerCorestore, unregisterCorestore, } from "../runtime-lifecycle.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { DEFAULT_REGISTRY_CORE_KEY } from "../../../constants/index.js";
+import { QVACRegistryClient } from '@qvac/registry-client';
+import { getCacheDir } from '../../utils/cache/paths.js';
+import { registerSwarm, unregisterSwarm, registerCorestore, unregisterCorestore } from '../runtime-lifecycle.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { DEFAULT_REGISTRY_CORE_KEY } from '../../../constants/index.js';
 const logger = getServerLogger();
 // fd-lock retry budget for the registry corestore.
 //
@@ -24,7 +24,7 @@ let registryClient = null;
 let inflightInit = null;
 function isFdLockError(error) {
     if (error instanceof Error) {
-        return error.message.includes("File descriptor could not be locked");
+        return error.message.includes('File descriptor could not be locked');
     }
     return false;
 }
@@ -39,23 +39,23 @@ async function initRegistryClient() {
             const client = new QVACRegistryClient({
                 registryCoreKey: DEFAULT_REGISTRY_CORE_KEY,
                 storage: getCacheDir(`registry-corestore/${DEFAULT_REGISTRY_CORE_KEY}`),
-                corestoreOpts: { wait: false },
+                corestoreOpts: { wait: false }
             });
             await client.ready();
             registryClient = client;
             if (registryClient.corestore) {
                 registerCorestore(registryClient.corestore, {
-                    label: "registry-client",
-                    createdAt: Date.now(),
+                    label: 'registry-client',
+                    createdAt: Date.now()
                 });
             }
             if (registryClient.hyperswarm) {
                 registerSwarm(registryClient.hyperswarm, {
-                    label: "registry-client",
-                    createdAt: Date.now(),
+                    label: 'registry-client',
+                    createdAt: Date.now()
                 });
             }
-            logger.info("✅ Registry client ready");
+            logger.info('✅ Registry client ready');
             return client;
         }
         catch (error) {
@@ -78,14 +78,14 @@ async function initRegistryClient() {
 }
 export async function getRegistryClient() {
     if (registryClient) {
-        logger.debug("Registry client reused");
+        logger.debug('Registry client reused');
         return registryClient;
     }
     if (inflightInit) {
-        logger.debug("Registry client init already in progress, waiting...");
+        logger.debug('Registry client init already in progress, waiting...');
         return inflightInit;
     }
-    logger.info("🔗 Creating new registry client...");
+    logger.info('🔗 Creating new registry client...');
     inflightInit = initRegistryClient().finally(() => {
         inflightInit = null;
     });
@@ -98,13 +98,13 @@ export async function closeRegistryClient() {
     registryClient = null;
     const corestore = client.corestore;
     const hyperswarm = client.hyperswarm;
-    logger.info("🔌 Closing registry client...");
+    logger.info('🔌 Closing registry client...');
     try {
         await client.close();
-        logger.info("✅ Registry client closed");
+        logger.info('✅ Registry client closed');
     }
     catch (error) {
-        logger.error("❌ Error closing registry client:", error instanceof Error ? error.message : String(error));
+        logger.error('❌ Error closing registry client:', error instanceof Error ? error.message : String(error));
     }
     finally {
         if (corestore)

package/dist/server/bare/registry/runtime-context-registry.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeContext } from "../../../schemas/index";
+import type { RuntimeContext } from '../../../schemas/index';
 export declare function setRuntimeContext(ctx: RuntimeContext): void;
 export declare function getRuntimeContext(): RuntimeContext;
 export declare function isMobile(): boolean;

package/dist/server/bare/registry/runtime-context-registry.js

@@ -16,11 +16,11 @@ export function getRuntimeContext() {
 // Convenience helpers
 // ============================================
 export function isMobile() {
-    return context.runtime === "react-native";
+    return context.runtime === 'react-native';
 }
 export function isAndroid() {
-    return context.platform === "android";
+    return context.platform === 'android';
 }
 export function isIOS() {
-    return context.platform === "ios";
+    return context.platform === 'ios';
 }

package/dist/server/bare/runtime/disposable-scope.js

@@ -1,4 +1,4 @@
-import { AsyncDisposeUnavailableError } from "../../../utils/errors-server.js";
+import { AsyncDisposeUnavailableError } from '../../../utils/errors-server.js';
 /**
  * Module-load guard. The whole request-lifecycle primitive stack (scopes,
  * the registry's `ManagedRequestContext`, `await using ctx = ...`) is
@@ -10,7 +10,7 @@ import { AsyncDisposeUnavailableError } from "../../../utils/errors-server.js";
  * registry entries forever. Better to fail loudly at import time with a
  * clear error than to debug a slow registry leak in production.
  */
-if (typeof Symbol.asyncDispose !== "symbol") {
+if (typeof Symbol.asyncDispose !== 'symbol') {
     throw new AsyncDisposeUnavailableError();
 }
 export function createDisposableScope() {
@@ -64,6 +64,6 @@ export function createDisposableScope() {
         [Symbol.asyncDispose]: dispose,
         get disposed() {
             return disposed;
-        },
+        }
     };
 }

package/dist/server/bare/runtime/index.d.ts

@@ -1,8 +1,8 @@
-export { createDisposableScope } from "./disposable-scope";
-export type { DisposableScope } from "./disposable-scope";
-export type { RequestContext, RequestKind, RequestState, } from "./request-context";
-export { createRequestRegistry, getRequestRegistry, } from "./request-registry-singleton";
-export type { BeginOpts, CancelByModelId, CancelByRequestId, CancelTarget, ConcurrencyPolicy, ManagedRequestContext, RequestOutcome, RequestRegistry, } from "./request-registry";
-export { withRequestContext } from "./with-request-context";
-export type { RequestLogContext } from "./with-request-context";
+export { createDisposableScope } from './disposable-scope';
+export type { DisposableScope } from './disposable-scope';
+export type { RequestContext, RequestKind, RequestState } from './request-context';
+export { createRequestRegistry, getRequestRegistry } from './request-registry-singleton';
+export type { BeginOpts, CancelByModelId, CancelByRequestId, CancelTarget, ConcurrencyPolicy, ManagedRequestContext, RequestOutcome, RequestRegistry } from './request-registry';
+export { withRequestContext } from './with-request-context';
+export type { RequestLogContext } from './with-request-context';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/runtime/index.js

@@ -1,3 +1,3 @@
-export { createDisposableScope } from "./disposable-scope.js";
-export { createRequestRegistry, getRequestRegistry, } from "./request-registry-singleton.js";
-export { withRequestContext } from "./with-request-context.js";
+export { createDisposableScope } from './disposable-scope.js';
+export { createRequestRegistry, getRequestRegistry } from './request-registry-singleton.js';
+export { withRequestContext } from './with-request-context.js';

package/dist/server/bare/runtime/request-context.d.ts

@@ -1,5 +1,5 @@
-import type { AbortSignal } from "bare-abort-controller";
-import type { DisposableScope } from "./disposable-scope";
+import type { AbortSignal } from 'bare-abort-controller';
+import type { DisposableScope } from './disposable-scope';
 /**
  * Coarse classification of a long-running request. Used by
  * `RequestRegistry.cancel({ modelId, kind })` so a broad cancel can target
@@ -9,7 +9,7 @@ import type { DisposableScope } from "./disposable-scope";
  * The set is intentionally open-coded — adding a new kind is a one-line
  * change and the union surfaces in editor autocomplete at every call site.
  */
-export type RequestKind = "completion" | "embeddings" | "transcribe" | "translate" | "diffusion" | "tts" | "ocr" | "vla" | "finetune" | "loadModel" | "downloadAsset" | "rag";
+export type RequestKind = 'completion' | 'batchCompletion' | 'embeddings' | 'transcribe' | 'translate' | 'diffusion' | 'tts' | 'ocr' | 'vla' | 'finetune' | 'loadModel' | 'downloadAsset' | 'rag';
 /**
  * Lifecycle states a request transitions through. A new context starts in
  * `"running"`. `cancel(...)` flips it to `"cancelling"` and aborts the
@@ -20,7 +20,7 @@ export type RequestKind = "completion" | "embeddings" | "transcribe" | "translat
  * `state` defensively at most a couple of points and a flat enum is easier
  * to log/assert than a transition table.
  */
-export type RequestState = "running" | "cancelling" | "completed" | "failed" | "cancelled";
+export type RequestState = 'running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
 /**
  * Per-request lifecycle handle. Created by `RequestRegistry.begin(...)`
  * and consumed by long-running handlers as the single owner of:

package/dist/server/bare/runtime/request-id.js

@@ -1,4 +1,4 @@
-import { randomUUID } from "bare-crypto";
+import { randomUUID } from 'bare-crypto';
 /**
  * Server-side fallback for `requestId`. The new wire contract is that
  * the client generates the id (UUIDv4) at call time so it's surfaced

package/dist/server/bare/runtime/request-registry-singleton.d.ts

@@ -1,4 +1,4 @@
-import { createRequestRegistry as createRegistry, type RequestRegistry } from "./request-registry";
+import { createRequestRegistry as createRegistry, type RequestRegistry } from './request-registry';
 export declare function getRequestRegistry(): RequestRegistry;
 export { createRegistry as createRequestRegistry };
 //# sourceMappingURL=request-registry-singleton.d.ts.map

package/dist/server/bare/runtime/request-registry-singleton.js

@@ -1,4 +1,4 @@
-import { createRequestRegistry as createRegistry, } from "./request-registry.js";
+import { createRequestRegistry as createRegistry } from './request-registry.js';
 /**
  * Worker-process singleton. Every long-running request in this Bare
  * worker registers under this registry, so a `cancel({ requestId })` RPC
@@ -11,17 +11,36 @@ import { createRequestRegistry as createRegistry, } from "./request-registry.js"
  * baseline concurrency policies.
  */
 let registry = null;
+// `completion` and `batchCompletion` both run on the same `@qvac/llm-llamacpp`
+// instance, which funnels every `run()` (single-prompt and batch alike) through
+// one per-instance exclusive run queue plus a single-job native runner. They
+// therefore can't actually execute at once on the same model. Sharing one
+// admission lane makes the SDK queue reflect that reality: a completion and a
+// batch on the same model serialize FIFO at the SDK layer instead of both being
+// admitted and silently serializing inside the addon (which hides them from the
+// registry's queue-depth accounting, `requestId` diagnostics, and cancel).
+const LLAMACPP_COMPLETION_SLOT_GROUP = 'llamacppCompletion';
 function installDefaultPolicies(r) {
     // A loaded model is a single native context (one KV-cache, single-slot
     // decode), so two same-model completions can't run in parallel. Serialize
     // rather than reject: the second waits FIFO. maxConcurrentPerModel: 1 is
     // today's reality — raise it once continuous batching lands. The depth cap
-    // bounds queue memory.
+    // bounds queue memory. The shared slot group extends that serialization
+    // across `completion` + `batchCompletion` on the same model (see note
+    // above).
     r.policy({
-        kind: "completion",
+        kind: 'completion',
         maxConcurrentPerModel: 1,
-        onOverflow: "queue",
+        onOverflow: 'queue',
         maxQueueDepthPerModel: 64,
+        sharedSlotGroup: LLAMACPP_COMPLETION_SLOT_GROUP
+    });
+    r.policy({
+        kind: 'batchCompletion',
+        maxConcurrentPerModel: 1,
+        onOverflow: 'queue',
+        maxQueueDepthPerModel: 64,
+        sharedSlotGroup: LLAMACPP_COMPLETION_SLOT_GROUP
     });
 }
 export function getRequestRegistry() {

package/dist/server/bare/runtime/request-registry.d.ts

@@ -1,12 +1,12 @@
-import { type AbortSignal } from "bare-abort-controller";
-import type { RequestContext, RequestKind } from "./request-context";
-import type { Logger } from "../../../logging/types";
+import { type AbortSignal } from 'bare-abort-controller';
+import type { RequestContext, RequestKind } from './request-context';
+import type { Logger } from '../../../logging/types';
 /**
  * Outcome the caller declares when terminating a request through
  * `registry.end(...)`. The registry maps it to a terminal `RequestState`
  * before disposing the scope so observers see a coherent final state.
  */
-export type RequestOutcome = "completed" | "failed" | "cancelled";
+export type RequestOutcome = 'completed' | 'failed' | 'cancelled';
 export interface BeginOpts {
     /** Stable identity. Caller-provided so the client and server agree. */
     requestId: string;
@@ -35,9 +35,9 @@ export type CancelTarget = CancelByRequestId | CancelByModelId;
  * admission control (every `begin(...)` is accepted as long as the
  * request id is unique).
  *
- * The policy turns admission into a per-`(kind, modelId)` FIFO queue with
+ * The policy turns admission into a per-`(lane, modelId)` FIFO queue with
  * a configurable concurrency limit. A second concurrent request to the
- * same `(kind, modelId)` *waits its turn* (default) rather than colliding
+ * same `(lane, modelId)` *waits its turn* (default) rather than colliding
  * on the single native llama.cpp context. The limit is forward-compatible
  * with addon-side continuous batching: bump `maxConcurrentPerModel` to the
  * addon's slot count to flip serial execution to N-way concurrent without
@@ -49,21 +49,21 @@ export type CancelTarget = CancelByRequestId | CancelByModelId;
 export interface ConcurrencyPolicy {
     kind: RequestKind;
     /**
-     * Max simultaneously in-flight requests per `(kind, modelId)`.
+     * Max simultaneously in-flight requests per `(lane, modelId)`.
      * Default: `Infinity` (no admission limit). Set `1` to serialize, or
      * `N` for N-way concurrency (the future continuous-batching slot
      * count). Non-finite values disable gating entirely.
      */
     maxConcurrentPerModel?: number;
     /**
-     * What a `begin(...)` does when the `(kind, modelId)` is at capacity:
+     * What a `begin(...)` does when the `(lane, modelId)` is at capacity:
      *  - `"queue"` (default): wait FIFO for a slot to free.
      *  - `"reject"`: throw `RequestRejectedByPolicyError` immediately
      *    (the legacy `oneAtATimePerModel` behavior).
      */
-    onOverflow?: "queue" | "reject";
+    onOverflow?: 'queue' | 'reject';
     /**
-     * Max waiters allowed to queue per `(kind, modelId)` before further
+     * Max waiters allowed to queue per `(lane, modelId)` before further
      * begins reject with `RequestRejectedByPolicyError`. Bounds memory so a
      * runaway client can't grow the queue without limit. Default: `64`.
      * Only consulted when `onOverflow` is `"queue"`.
@@ -82,6 +82,21 @@ export interface ConcurrencyPolicy {
      * `maxConcurrentPerModel` is set explicitly.
      */
     oneAtATimePerModel?: boolean;
+    /**
+     * Opt several kinds into one shared admission lane per model. When set,
+     * the slot is keyed on `(sharedSlotGroup, modelId)` instead of
+     * `(kind, modelId)`, so requests of *different* kinds that target the
+     * same model contend for the same slot pool.
+     *
+     * This exists to mirror an addon that serializes unrelated request
+     * kinds on a single native context — e.g. `@qvac/llm-llamacpp` funnels
+     * single-prompt `completion` and `batchCompletion` through one
+     * per-instance run queue, so the two can't actually run at once on the
+     * same model. Sharing a lane makes the SDK's admission queue the
+     * authoritative serialization point rather than relying on the addon's
+     * internal queue.
+     */
+    sharedSlotGroup?: string;
 }
 /**
  * `ManagedRequestContext` is the value `begin(...)` resolves to. It extends
@@ -100,7 +115,7 @@ export interface ManagedRequestContext extends RequestContext {
 export interface RequestRegistry {
     /**
      * Open a new request. Returns a promise because admission may *queue*:
-     * when a concurrency policy caps the `(kind, modelId)` and it's at
+     * when a concurrency policy caps the `(lane, modelId)` and it's at
      * capacity with `onOverflow: "queue"`, the promise resolves once a slot
      * frees (FIFO). Callers write `await using ctx = await registry.begin(...)`.
      *
@@ -153,7 +168,7 @@ export interface RequestRegistry {
      * Resolves once all targeted contexts have flipped to `"cancelling"`;
      * scope unwinding still happens on each handler's own dispose path.
      */
-    cancelAll(reason: "shutdown" | "modelUnload"): Promise<void>;
+    cancelAll(reason: 'shutdown' | 'modelUnload'): Promise<void>;
     /**
      * Mark a request finished and dispose its scope. Equivalent to
      * `await ctx[Symbol.asyncDispose]()` with an explicit outcome.

package/dist/server/bare/runtime/request-registry.js

@@ -1,7 +1,7 @@
-import { AbortController } from "bare-abort-controller";
-import { createDisposableScope, } from "./disposable-scope.js";
-import { RequestIdConflictError, RequestRejectedByPolicyError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { AbortController } from 'bare-abort-controller';
+import { createDisposableScope } from './disposable-scope.js';
+import { RequestIdConflictError, RequestRejectedByPolicyError } from '../../../utils/errors-server.js';
+import { getServerLogger } from '../../../logging/index.js';
 /**
  * Tuning knobs for the "cancelled-before-begin" bookkeeping set.
  *
@@ -25,7 +25,7 @@ import { getServerLogger } from "../../../logging/index.js";
 const CANCEL_BEFORE_BEGIN_MAX_ENTRIES = 128;
 const CANCEL_BEFORE_BEGIN_TTL_MS = 30_000;
 /**
- * Default cap on waiters queued per `(kind, modelId)` when a policy uses
+ * Default cap on waiters queued per `(lane, modelId)` when a policy uses
  * `onOverflow: "queue"` without an explicit `maxQueueDepthPerModel`.
  * Bounds memory so a misbehaving client firing a flood of same-model
  * requests can't grow the queue without limit — the (depth + 1)th begin
@@ -49,13 +49,13 @@ export function createRequestRegistry(options) {
      */
     const waitersById = new Map();
     function logLifecycle(event, ctx, durationMs) {
-        const modelId = ctx.modelId !== undefined ? ctx.modelId : "-";
+        const modelId = ctx.modelId !== undefined ? ctx.modelId : '-';
         const base = `[request-lifecycle] ${event} requestId=${ctx.requestId} kind=${ctx.kind} modelId=${modelId} state=${ctx.state}`;
         const line = durationMs !== undefined ? `${base} durationMs=${durationMs}` : base;
         // `failed` end emits at `warn` so log shippers can alert on
         // `level>=warn` for this prefix without parsing `state=failed`
         // out of the message body. Everything else stays at `info`.
-        if (event === "end" && ctx.state === "failed") {
+        if (event === 'end' && ctx.state === 'failed') {
             logger.warn(line);
         }
         else {
@@ -119,10 +119,11 @@ export function createRequestRegistry(options) {
         cancelledBeforeBegin.delete(requestId);
         return entry;
     }
-    function slotKey(kind, modelId) {
-        // NUL separator can't appear in a kind (closed union) or a modelId
-        // (sdkModelId is a generated handle), so the join is unambiguous.
-        return `${kind}\u0000${modelId}`;
+    function slotKey(lane, modelId) {
+        // NUL separator can't appear in a lane (a closed-union kind or an
+        // SDK-controlled `sharedSlotGroup` label) or a modelId (sdkModelId is a
+        // generated handle), so the join is unambiguous.
+        return `${lane}\u0000${modelId}`;
     }
     /**
      * Pull a waiter out of its queue and tidy up: clear its timeout, drop
@@ -173,7 +174,10 @@ export function createRequestRegistry(options) {
         if (opts.parentSignal?.aborted)
             return { slotKey: undefined };
         const modelId = opts.modelId;
-        const key = slotKey(opts.kind, modelId);
+        // A shared lane lets unrelated kinds (e.g. completion + batchCompletion)
+        // contend for one slot pool per model, matching an addon that serializes
+        // them on a single native context.
+        const key = slotKey(policy.slotGroup ?? opts.kind, modelId);
         let st = keyStates.get(key);
         if (!st) {
             st = { active: 0, waiters: [] };
@@ -183,7 +187,7 @@ export function createRequestRegistry(options) {
             st.active++;
             return { slotKey: key };
         }
-        if (policy.onOverflow === "reject") {
+        if (policy.onOverflow === 'reject') {
             throw new RequestRejectedByPolicyError(opts.requestId, opts.kind, modelId, `another ${opts.kind} request is already running on this model`);
         }
         if (st.waiters.length >= policy.maxQueueDepth) {
@@ -198,7 +202,7 @@ export function createRequestRegistry(options) {
                 enqueuedAt: Date.now(),
                 resolve,
                 reject,
-                timer: undefined,
+                timer: undefined
             };
             if (policy.queueTimeoutMs !== undefined) {
                 const timeoutMs = policy.queueTimeoutMs;
@@ -240,9 +244,9 @@ export function createRequestRegistry(options) {
     function cancelEntry(entry, reason) {
         if (entry.controller.signal.aborted)
             return false;
-        entry.ctx.state = "cancelling";
+        entry.ctx.state = 'cancelling';
         entry.controller.abort(reason);
-        logLifecycle("cancel", entry.ctx);
+        logLifecycle('cancel', entry.ctx);
         return true;
     }
     async function disposeEntry(entry, outcome) {
@@ -250,7 +254,7 @@ export function createRequestRegistry(options) {
             return;
         entry.ctx.state = outcome;
         entry.detachParent();
-        logLifecycle("end", entry.ctx, Date.now() - entry.startedAt);
+        logLifecycle('end', entry.ctx, Date.now() - entry.startedAt);
         // Pull the entry out before unwinding so observers (e.g. a `cancel(...)`
         // racing with dispose) don't see a half-disposed context.
         entries.delete(entry.ctx.requestId);
@@ -313,8 +317,8 @@ export function createRequestRegistry(options) {
             }
             else {
                 const onParentAbort = () => controller.abort(parent.reason);
-                parent.addEventListener("abort", onParentAbort, { once: true });
-                detachParent = () => parent.removeEventListener("abort", onParentAbort);
+                parent.addEventListener('abort', onParentAbort, { once: true });
+                detachParent = () => parent.removeEventListener('abort', onParentAbort);
             }
         }
         const ctx = {
@@ -329,7 +333,7 @@ export function createRequestRegistry(options) {
             // already aborted at begin time. Both branches abort the
             // controller above, so without this guard observers would see a
             // momentarily-`running` context with an already-aborted signal.
-            state: preCancel || opts.parentSignal?.aborted ? "cancelling" : "running",
+            state: preCancel || opts.parentSignal?.aborted ? 'cancelling' : 'running'
         };
         const entry = {
             ctx,
@@ -337,10 +341,10 @@ export function createRequestRegistry(options) {
             scope,
             detachParent,
             startedAt: Date.now(),
-            slotKey,
+            slotKey
         };
         entries.set(opts.requestId, entry);
-        logLifecycle("begin", ctx);
+        logLifecycle('begin', ctx);
         return {
             get requestId() {
                 return ctx.requestId;
@@ -365,7 +369,7 @@ export function createRequestRegistry(options) {
             },
             [Symbol.asyncDispose]: async () => {
                 await disposeEntry(entry, derivedTerminalState(ctx));
-            },
+            }
         };
     }
     function get(requestId) {
@@ -388,7 +392,7 @@ export function createRequestRegistry(options) {
     }
     function cancel(target) {
         let cancelled = 0;
-        if ("requestId" in target) {
+        if ('requestId' in target) {
             const entry = entries.get(target.requestId);
             if (entry) {
                 if (cancelEntry(entry, target.reason))
@@ -483,7 +487,7 @@ export function createRequestRegistry(options) {
         // Test-only: the number of live per-`(kind, modelId)` admission
         // states. Lets the queue tests assert the map empties on drain /
         // dispose (no `KeyState` leak). Also off the public interface.
-        __keyStateSize: () => keyStates.size,
+        __keyStateSize: () => keyStates.size
     };
 }
 /**
@@ -496,17 +500,17 @@ function normalizePolicy(opts) {
     let onOverflow;
     if (opts.maxConcurrentPerModel !== undefined) {
         maxConcurrent = opts.maxConcurrentPerModel;
-        onOverflow = opts.onOverflow ?? "queue";
+        onOverflow = opts.onOverflow ?? 'queue';
     }
     else if (opts.oneAtATimePerModel === true) {
         // Legacy alias: at most one in-flight per model, reject the rest.
         maxConcurrent = 1;
-        onOverflow = opts.onOverflow ?? "reject";
+        onOverflow = opts.onOverflow ?? 'reject';
     }
     else {
         // Nothing configured (includes `oneAtATimePerModel: false`) ⇒ no gating.
         maxConcurrent = Infinity;
-        onOverflow = opts.onOverflow ?? "queue";
+        onOverflow = opts.onOverflow ?? 'queue';
     }
     // A finite limit below 1 would gate every request forever; clamp to the
     // smallest sensible serial limit.
@@ -517,6 +521,7 @@ function normalizePolicy(opts) {
         onOverflow,
         maxQueueDepth: opts.maxQueueDepthPerModel ?? DEFAULT_MAX_QUEUE_DEPTH_PER_MODEL,
         queueTimeoutMs: opts.queueTimeoutMs,
+        slotGroup: opts.sharedSlotGroup
     };
 }
 /**
@@ -529,12 +534,12 @@ function normalizePolicy(opts) {
 export const __requestRegistryTestHooks = {
     cancelBeforeBeginMaxEntries: CANCEL_BEFORE_BEGIN_MAX_ENTRIES,
     cancelBeforeBeginTtlMs: CANCEL_BEFORE_BEGIN_TTL_MS,
-    defaultMaxQueueDepthPerModel: DEFAULT_MAX_QUEUE_DEPTH_PER_MODEL,
+    defaultMaxQueueDepthPerModel: DEFAULT_MAX_QUEUE_DEPTH_PER_MODEL
 };
 function derivedTerminalState(ctx) {
-    if (ctx.state === "failed")
-        return "failed";
-    if (ctx.signal.aborted || ctx.state === "cancelled")
-        return "cancelled";
-    return "completed";
+    if (ctx.state === 'failed')
+        return 'failed';
+    if (ctx.signal.aborted || ctx.state === 'cancelled')
+        return 'cancelled';
+    return 'completed';
 }

package/dist/server/bare/runtime/with-request-context.d.ts

@@ -1,4 +1,4 @@
-import type { Logger } from "../../../logging/types";
+import type { Logger } from '../../../logging/types';
 export interface RequestLogContext {
     requestId: string;
     kind: string;

package/dist/server/bare/runtime/with-request-context.js

@@ -18,15 +18,15 @@ export function withRequestContext(logger, ctx) {
         : `[request-lifecycle ${ctx.kind} requestId=${ctx.requestId}] `;
     function pick(method) {
         switch (method) {
-            case "error":
+            case 'error':
                 return logger.error;
-            case "warn":
+            case 'warn':
                 return logger.warn;
-            case "info":
+            case 'info':
                 return logger.info;
-            case "debug":
+            case 'debug':
                 return logger.debug;
-            case "trace":
+            case 'trace':
                 return logger.trace;
         }
     }
@@ -40,14 +40,14 @@ export function withRequestContext(logger, ctx) {
         sink(prefix + String(first), ...rest);
     }
     return {
-        error: (...args) => emit("error", args),
-        warn: (...args) => emit("warn", args),
-        info: (...args) => emit("info", args),
-        debug: (...args) => emit("debug", args),
-        trace: (...args) => emit("trace", args),
+        error: (...args) => emit('error', args),
+        warn: (...args) => emit('warn', args),
+        info: (...args) => emit('info', args),
+        debug: (...args) => emit('debug', args),
+        trace: (...args) => emit('trace', args),
         setLevel: (level) => logger.setLevel(level),
         getLevel: () => logger.getLevel(),
         addTransport: (transport) => logger.addTransport(transport),
-        setConsoleOutput: (enabled) => logger.setConsoleOutput(enabled),
+        setConsoleOutput: (enabled) => logger.setConsoleOutput(enabled)
     };
 }

package/dist/server/bare/runtime-lifecycle.d.ts

@@ -1,4 +1,4 @@
-import type { LifecycleState, Request } from "../../schemas/index";
+import type { LifecycleState, Request } from '../../schemas/index';
 export interface SuspendableSwarm {
     readonly suspended: boolean;
     suspend(): Promise<void>;