lumiverse-spindle-types 0.6.5 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumiverse-spindle-types",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "types": "./src/index.ts",
   "keywords": [
     "lumiverse",

package/src/api.ts

@@ -1,4 +1,5 @@
 import type { SpindleManifest } from "./manifest";
+import type { SpindleHostDescriptorV1 } from "./host";
 import type { CouncilMemberContext } from "./council";
 import type {
   ChatLinkAttachDTO,
@@ -16,13 +17,21 @@ export type LlmMessagePartDTO =
   | { type: "text"; text: string; cache_control?: Record<string, unknown> }
   | { type: "image"; data: string; mime_type: string; cache_control?: Record<string, unknown> }
   | { type: "audio"; data: string; mime_type: string; cache_control?: Record<string, unknown> }
-  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown>; cache_control?: Record<string, unknown> }
+  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown>; cache_control?: Record<string, unknown>; thought_signature?: string }
   | { type: "tool_result"; tool_use_id: string; content: string; is_error?: boolean; cache_control?: Record<string, unknown> };
 
+export interface LlmThinkingBlockDTO {
+  type: "thinking" | "redacted_thinking";
+  thinking?: string;
+  signature?: string;
+  data?: string;
+}
+
 export interface LlmMessageDTO {
   role: "system" | "user" | "assistant";
   content: string | LlmMessagePartDTO[];
   name?: string;
+  cache_control?: Record<string, unknown>;
   /**
    * Thinking-mode reasoning content from the previous assistant turn, echoed
    * back on the next request. Required by DeepSeek's thinking-mode models
@@ -36,6 +45,8 @@ export interface LlmMessageDTO {
    * only on `role: 'assistant'` messages.
    */
   reasoning_content?: string;
+  thinking_blocks?: LlmThinkingBlockDTO[];
+  reasoning_details?: Record<string, unknown>[];
   /**
    * True when this message is a chat-history turn (as opposed to a depth-injected 
    * world-info/preset/author's-note block that was spliced into the chat-history 
@@ -57,6 +68,80 @@ export interface LlmMessageDTO {
 }
 
 export type SpindleUserRoleDTO = "operator" | "admin" | "user";
+export type InterceptorGenerationType =
+  | "normal"
+  | "continue"
+  | "regenerate"
+  | "swipe"
+  | "impersonate"
+  | "quiet";
+
+export type InterceptorMatchScalar = string | number | boolean | null;
+
+export interface InterceptorMatchDTO {
+  /**
+   * Serializable filter domain. Terminal callbacks currently run only for
+   * live `normal` and `continue`; every other value is a fail-closed filter.
+   */
+  generationTypes?: InterceptorGenerationType[];
+  /** Terminal callbacks are never invoked for dry runs. */
+  isDryRun?: boolean;
+  presetField?: {
+    path: string[];
+    exists?: boolean;
+    oneOf?: InterceptorMatchScalar[];
+    notIn?: InterceptorMatchScalar[];
+  };
+}
+
+export interface InterceptorRegistrationMatchOptions {
+  match?: InterceptorMatchDTO;
+}
+
+export interface InterceptorRegistrationOptions {
+  priority?: number;
+  match?: InterceptorMatchDTO;
+}
+
+/**
+ * Host-owned, immutable context for one bound interceptor callback.
+ * `signal` is local to the worker invocation and is never serialized.
+ */
+export interface InterceptorContextDTO {
+  readonly userId: string;
+  readonly chatId: string;
+  readonly generationId: string;
+  readonly generationType: InterceptorGenerationType;
+  readonly isDryRun: boolean;
+  readonly presetId: string | null;
+  /** Deep clone of only this extension's own preset metadata namespace. */
+  readonly presetMetadata: unknown;
+  readonly personaId: string | null;
+  readonly characterId: string | null;
+  readonly personaAddonStates: Readonly<Record<string, boolean>>;
+  readonly excludeMessageId?: string;
+  readonly rejectedSwipe?: string;
+  readonly regenFeedback?: string;
+  readonly regenFeedbackPosition?: "system" | "user";
+  readonly mainDispatch: {
+    readonly source: "main";
+    readonly descriptor: Readonly<ConnectionDispatchDescriptorDTO> | null;
+    readonly connectionDispatchRevision: string | null;
+    readonly dispatchKind: "concrete" | "roulette" | null;
+  };
+  readonly prefillCarrier: BoundPrefillAttachmentDTO;
+  readonly interceptorDeadlineAt: number;
+  readonly boundWorkDeadlineAt: number;
+  /** Worker-local cancellation signal; never serialized over the worker protocol. */
+  readonly signal: AbortSignal;
+}
+
+export interface DeferredGuidanceDTO {
+  id: string;
+  content: string;
+  role: "system";
+}
+
 
 /**
  * Optional metadata returned by an interceptor so Lumiverse can surface
@@ -73,6 +158,13 @@ export interface InterceptorBreakdownEntryDTO {
   name?: string;
 }
 
+/** Privileged response override returned by an interceptor. */
+export interface FinalResponseDTO {
+  content: string;
+  reasoning?: string;
+  fallbackMessageIndex: number;
+}
+
 /**
  * Return type for interceptor handlers.
  * Interceptors may return either a plain `LlmMessageDTO[]` (backwards-compatible)
@@ -84,8 +176,19 @@ export interface InterceptorResultDTO {
   parameters?: Record<string, unknown>;
   /** Optional prompt-breakdown entries for injected messages. */
   breakdown?: InterceptorBreakdownEntryDTO[];
+  /** Host-owned system guidance retained for each authoritative Main attempt. */
+  deferredGuidance?: DeferredGuidanceDTO[];
+  /** Optional privileged response replacement. Requires the `final_response` permission. */
+  finalResponse?: FinalResponseDTO;
 }
 
+export type InterceptorDisposer = () => void;
+
+export type InterceptorHandler = (
+  messages: LlmMessageDTO[],
+  context: InterceptorContextDTO,
+) => Promise<LlmMessageDTO[] | InterceptorResultDTO>;
+
 export interface MacroDefinitionDTO {
   name: string;
   category: string;
@@ -261,6 +364,15 @@ export interface ToolSchemaDTO {
   parameters: Record<string, unknown>; // JSON Schema
 }
 
+export interface ToolDefinitionDTO {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  strict?: boolean;
+  inputExamples?: Array<Record<string, unknown>>;
+  cache_control?: Record<string, unknown>;
+}
+
 /** A single function call made by the LLM. */
 export interface ToolCallDTO {
   /** Tool name (as given in the schema). */
@@ -269,8 +381,35 @@ export interface ToolCallDTO {
   args: Record<string, unknown>;
   /** Provider call ID (e.g. Anthropic `id`, OpenAI `id`). Synthetic UUID for providers that don't supply one (e.g. Google). */
   call_id: string;
+  /** Opaque provider signature preserved for tool-call continuations. */
+  thought_signature?: string;
+}
+
+export interface GenerationUsageDTO {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+  provider_raw?: Record<string, unknown>;
+}
+
+export interface GenerationResponseDTO {
+  content: string;
+  reasoning?: string;
+  finish_reason: string;
+  tool_calls?: ToolCallDTO[];
+  thinking_blocks?: LlmThinkingBlockDTO[];
+  reasoning_details?: Record<string, unknown>[];
+  usage?: GenerationUsageDTO;
 }
 
+export type GenerationDispatchSourceDTO =
+  | { source: "main"; expectedConnectionDispatchRevision: string }
+  | {
+      source: "slot";
+      connectionId: string;
+      expectedConnectionDispatchRevision: string;
+    };
+
 export interface GenerationRequestDTO {
   type: "raw" | "quiet" | "batch";
   messages?: LlmMessageDTO[];
@@ -535,6 +674,16 @@ export interface ConnectionProfileDTO {
   updated_at: number;
 }
 
+export interface ConnectionDispatchDescriptorDTO {
+  connectionId: string;
+  connectionName: string;
+  provider: string;
+  model: string;
+  endpointOrigin: string;
+  dispatchKind: "concrete" | "roulette";
+  connectionDispatchRevision: string | null;
+}
+
 // ─── Image Generation DTOs ──────────────────────────────────────────────
 
 /**
@@ -1753,6 +1902,126 @@ export interface AssembleResultDTO {
   breakdown: AssemblyBreakdownEntryDTO[];
 }
 
+export interface BoundPrefillAttachmentDTO {
+  /**
+   * Opaque parent-prefill attestation. It may be presented only by the live
+   * worker invocation; it is not itself a reusable attachment capability,
+   * message index, or carrier content.
+   */
+  readonly id: string;
+  readonly state: "absent" | "available" | "invalid";
+}
+
+export interface BoundAssembleRequestDTO {
+  blocks: PromptBlockDTO[];
+  promptVariableValues?: PromptVariableValuesDTO;
+  dispatch: GenerationDispatchSourceDTO;
+  deadlineAt: number;
+  hookFailureMode?: "degrade" | "reject";
+  macroFailureMode?: "degrade" | "reject";
+  signal?: AbortSignal;
+}
+
+export interface BoundAssemblySuccessDTO {
+  messages: LlmMessageDTO[];
+  breakdown: AssemblyBreakdownEntryDTO[];
+  resolved: {
+    source: "main" | "slot";
+    connectionId: string | null;
+    connectionDispatchRevision: string;
+    dispatchKind: "concrete";
+  };
+}
+
+export type BoundAssemblyFailureDTO =
+  | {
+      kind: "hook";
+      code: "ASSEMBLY_HOOK_FAILED";
+      phase: "context" | "world_info" | "macro";
+      reason: "error" | "timeout";
+      message: string;
+    }
+  | {
+      kind: "macro";
+      code: "ASSEMBLY_MACRO_FAILED";
+      reason: "definition" | "parse" | "recursion" | "budget" | "evaluation";
+      message: string;
+    }
+  | {
+      kind: "retrieval_snapshot";
+      code: "ASSEMBLY_RETRIEVAL_SNAPSHOT_UNAVAILABLE";
+      reason: "missing" | "expired" | "unavailable" | "oversize";
+      message: string;
+    }
+  | {
+      kind: "abort";
+      code: "ASSEMBLY_ABORTED";
+      name: "AbortError";
+      message: string;
+    }
+  | {
+      kind: "precondition" | "security" | "internal";
+      code: string;
+      message: string;
+    };
+
+export type BoundAssemblyOutcomeDTO =
+  | { ok: true; result: BoundAssemblySuccessDTO }
+  | { ok: false; error: BoundAssemblyFailureDTO };
+
+export interface QuietTrackedRequestDTO {
+  messages: LlmMessageDTO[];
+  dispatch: GenerationDispatchSourceDTO;
+  /**
+   * When supplied, WorkerHost—not extension code—attaches the authenticated
+   * parent assistant carrier as the final continuation carrier for this dispatch.
+   */
+  continuation?: {
+    parentPrefill: BoundPrefillAttachmentDTO;
+    mode: "append-parent-carrier-last";
+  };
+  parameters?: Record<string, unknown>;
+  reasoning?: Record<string, unknown>;
+  tools?: ToolDefinitionDTO[];
+  deadlineAt: number;
+  signal?: AbortSignal;
+}
+
+export interface QuietDispatchReceiptDTO {
+  providerInvoked: boolean;
+  terminalResponse: boolean;
+  source: "main" | "slot";
+  connectionId: string | null;
+  connectionDispatchRevision: string;
+  usage?: GenerationUsageDTO;
+}
+
+export type QuietTrackedResultDTO =
+  | { ok: true; response: GenerationResponseDTO; receipt: QuietDispatchReceiptDTO }
+  | {
+      ok: false;
+      phase: "preflight";
+      providerInvoked: false;
+      receipt: null;
+      error: {
+        kind: "precondition" | "security";
+        code: string;
+        name: string;
+        message: string;
+      };
+    }
+  | {
+      ok: false;
+      phase: "resolved";
+      receipt: QuietDispatchReceiptDTO;
+      error: {
+        kind: "precondition" | "provider" | "abort" | "security" | "internal";
+        code: string;
+        name: string;
+        message: string;
+      };
+    };
+
 // ─── Chat Memory DTOs ──────────────────────────────────────────────────
 
 export interface ChatMemoryChunkDTO {
@@ -2641,13 +2910,22 @@ export type WorkerToHost =
   | { type: "register_macro"; definition: MacroDefinitionDTO }
   | { type: "unregister_macro"; name: string }
   | { type: "update_macro_value"; name: string; value: string }
-  | { type: "register_interceptor"; priority?: number }
+  | {
+      type: "register_interceptor";
+      registrationId: string;
+      priority?: number;
+      match?: InterceptorMatchDTO;
+    }
+  | { type: "unregister_interceptor"; registrationId: string }
   | {
       type: "intercept_result";
       requestId: string;
+      registrationId: string;
       messages: LlmMessageDTO[];
       parameters?: Record<string, unknown>;
       breakdown?: InterceptorBreakdownEntryDTO[];
+      deferredGuidance?: DeferredGuidanceDTO[];
+      finalResponse?: FinalResponseDTO;
     }
   | {
       type: "assemble_prompt";
@@ -2655,6 +2933,33 @@ export type WorkerToHost =
       input: Omit<AssembleRequestDTO, "signal">;
       userId?: string;
     }
+  /**
+   * Assemble through the active bound interceptor generation context. The
+   * worker-local signal is omitted from the structured-clone payload.
+   */
+  | {
+      type: "generate_assemble";
+      requestId: string;
+      input: Omit<BoundAssembleRequestDTO, "signal">;
+    }
+  /**
+   * Dispatch tracked quiet generation through the active bound context.
+   * The worker-local signal is omitted from the structured-clone payload.
+   */
+  | {
+      type: "generate_quiet_tracked";
+      requestId: string;
+      input: Omit<QuietTrackedRequestDTO, "signal">;
+    }
+  /**
+   * Inspect an owned concrete slot through the active bound interceptor
+   * context. The host derives user scope from the authenticated callback.
+   */
+  | {
+      type: "connections_resolve_dispatch";
+      requestId: string;
+      connectionId: string;
+    }
   | { type: "register_tool"; tool: ToolRegistrationDTO }
   | { type: "unregister_tool"; name: string }
   | { type: "request_generation"; requestId: string; input: GenerationRequestDTO }
@@ -3205,7 +3510,7 @@ export type WorkerToHost =
 // ─── Host → Worker messages ──────────────────────────────────────────────
 
 export type HostToWorker =
-  | { type: "init"; manifest: SpindleManifest; storagePath: string }
+  | { type: "init"; manifest: SpindleManifest; storagePath: string; host: SpindleHostDescriptorV1 }
   | { type: "event"; event: string; payload: unknown; userId?: string }
   | {
       type: "rpc_pool_request";
@@ -3218,8 +3523,15 @@ export type HostToWorker =
   | {
       type: "intercept_request";
       requestId: string;
+      registrationId: string;
       messages: LlmMessageDTO[];
-      context: unknown;
+      context: Omit<InterceptorContextDTO, "signal">;
+    }
+  | {
+      type: "intercept_abort";
+      requestId: string;
+      registrationId: string;
+      reason?: string;
     }
   | {
       type: "context_handler_request";

package/src/dom.ts

@@ -1,5 +1,6 @@
 import type { PromptBlockDTO, PromptVariableValuesDTO, RequestInitDTO } from "./api";
 import type { SpindleComponentsHelper } from "./components";
+import type { SpindleHostDescriptorV1, SpindleHostLocaleAPI } from "./host";
 
 /** A chat-message DOM element paired with its stable message id. */
 export interface SpindleMessageElement {
@@ -859,6 +860,10 @@ export interface SpindleDisplayResolverRegistry {
 
 /** Context object provided to frontend extension modules */
 export interface SpindleFrontendContext {
+  /** Immutable host compatibility descriptor for this extension runtime. */
+  readonly host: SpindleHostDescriptorV1;
+  /** Synchronous host locale access with removable live-change subscriptions. */
+  readonly locale: SpindleHostLocaleAPI;
   dom: SpindleDOMHelper;
   events: {
     on(event: string, handler: (payload: unknown) => void): () => void;
@@ -923,6 +928,8 @@ export interface SpindleFrontendContext {
     showConfirm(options: SpindleConfirmOptions): Promise<SpindleConfirmResult>;
     /** Request a tab move to a specific drawer location. */
     requestTabLocation(tabId: string, location: SpindleTabLocation): void;
+    /** Read the current drawer location for a built-in or extension tab. */
+    getTabLocation(tabId: string): SpindleTabLocation;
     /** Get the display title of a built-in drawer tab by its id. */
     getBuiltInTabTitle(tabId: string): string | undefined;
     /** Get the root HTMLElement of a built-in drawer tab by its id, or undefined if not mounted. */
@@ -1045,8 +1052,13 @@ export interface SpindleFrontendContext {
   manifest: import("./manifest").SpindleManifest;
 }
 
+/** Cleanup returned by a frontend extension setup hook. */
+export type SpindleFrontendTeardown = () => void | Promise<void>;
+
 /** What a frontend extension module must export */
 export interface SpindleFrontendModule {
-  setup(ctx: SpindleFrontendContext): void | (() => void);
-  teardown?(): void;
+  setup(
+    ctx: SpindleFrontendContext,
+  ): void | SpindleFrontendTeardown | Promise<void | SpindleFrontendTeardown>;
+  teardown?(): void | Promise<void>;
 }

package/src/host.ts

@@ -0,0 +1,32 @@
+export const SPINDLE_HOST_CAPABILITIES = Object.freeze({
+  "preset-extension-data-v1": 1,
+  "preset-editor-v1": 1,
+  "loom-block-editor-v1": 1,
+  "generation-assembly-v1": 1,
+  "interceptor-context-v1": 1,
+  "interceptor-final-response-v1": 1,
+}) as Readonly<Record<string, number>>;
+/** Structured error code returned when host compatibility validation fails. */
+export const SPINDLE_COMPATIBILITY_ERROR_CODE = "SPINDLE_COMPATIBILITY_ERROR" as const;
+
+/**
+ * Immutable host/runtime compatibility information exposed to extensions.
+ *
+ * Hosts may add capability keys over time. Extensions should only depend on
+ * the capability names they understand and the descriptor version they support.
+ */
+export interface SpindleHostDescriptorV1 {
+  readonly descriptorVersion: 1;
+  readonly lumiverseVersion: string;
+  readonly capabilities: Readonly<Record<string, number>>;
+  readonly extensionInstallationId: string;
+}
+
+/** Locale identifiers supplied by the host's active UI locale. */
+export type SpindleHostLocale = "en" | "zh" | "zh-TW" | "ja" | "fr" | "it";
+
+/** Synchronous host locale lookup with a removable live-change subscription. */
+export interface SpindleHostLocaleAPI {
+  get(): SpindleHostLocale;
+  subscribe(listener: (locale: SpindleHostLocale) => void): () => void;
+}

package/src/index.ts

@@ -8,6 +8,16 @@ export {
   validateIdentifier,
 } from "./manifest";
 
+export type {
+  SpindleHostDescriptorV1,
+  SpindleHostLocale,
+  SpindleHostLocaleAPI,
+} from "./host";
+export {
+  SPINDLE_HOST_CAPABILITIES,
+  SPINDLE_COMPATIBILITY_ERROR_CODE,
+} from "./host";
+
 export type { SpindlePermission as SpindlePermissionType } from "./permissions";
 export { ALL_PERMISSIONS, isValidPermission } from "./permissions";
 
@@ -18,8 +28,19 @@ export { SpindleEvent, CoreEventType } from "./events";
 
 export type {
   LlmMessageDTO,
+  LlmThinkingBlockDTO,
   SpindleUserRoleDTO,
+  InterceptorGenerationType,
+  InterceptorMatchScalar,
+  InterceptorMatchDTO,
+  InterceptorRegistrationMatchOptions,
+  InterceptorRegistrationOptions,
+  InterceptorContextDTO,
+  InterceptorDisposer,
+  InterceptorHandler,
+  DeferredGuidanceDTO,
   InterceptorBreakdownEntryDTO,
+  FinalResponseDTO,
   InterceptorResultDTO,
   MacroDefinitionDTO,
   MacroInvocationContextDTO,
@@ -28,6 +49,11 @@ export type {
   ToolRegistrationDTO,
   ToolSchemaDTO,
   ToolCallDTO,
+  ToolDefinitionDTO,
+  GenerationUsageDTO,
+  GenerationResponseDTO,
+  GenerationDispatchSourceDTO,
+  ConnectionDispatchDescriptorDTO,
   GenerationRequestDTO,
   GenerationReasoningOverrideDTO,
   ReasoningEffortDTO,
@@ -112,6 +138,14 @@ export type {
   DryRunResultDTO,
   AssembleRequestDTO,
   AssembleResultDTO,
+  BoundPrefillAttachmentDTO,
+  BoundAssembleRequestDTO,
+  BoundAssemblySuccessDTO,
+  BoundAssemblyFailureDTO,
+  BoundAssemblyOutcomeDTO,
+  QuietTrackedRequestDTO,
+  QuietDispatchReceiptDTO,
+  QuietTrackedResultDTO,
   AssemblyBreakdownEntryDTO,
   ActivationStatsDTO,
   MemoryStatsDTO,
@@ -216,6 +250,7 @@ export type {
     PermissionRequestOptions,
   SpindleFrontendContext,
   SpindleFrontendModule,
+  SpindleFrontendTeardown,
   SpindleDrawerTabOptions,
   SpindleDrawerTabHandle,
   SpindleCharacterEditorTabOptions,
@@ -381,6 +416,8 @@ export type {
 
 export type {
   SpindleAPI,
+  SpindleGenerateAPI,
+  SpindleConnectionsAPI,
   SpindlePromptRegex,
   FrontendProcessHandle,
   BackendProcessHandle,

package/src/permissions.ts

@@ -26,6 +26,8 @@
  *                            web search settings (never the API key).
  * - "unsafe_eval"          — opt a sandboxed widget frame into CSP 'unsafe-eval'
  *                            (eval / new Function) for runtime-compiling frameworks.
+ * - "final_response"        — replace the authoritative assistant response from
+ *                            an interceptor (privileged; never auto-granted)
  */
 export type SpindlePermission =
   | "generation"
@@ -54,7 +56,8 @@ export type SpindlePermission =
   | "generation_parameters"
   | "macro_interceptor"
   | "web_search"
-  | "unsafe_eval";
+  | "unsafe_eval"
+  | "final_response";
 
 export const ALL_PERMISSIONS: readonly SpindlePermission[] = [
   "generation",
@@ -84,6 +87,7 @@ export const ALL_PERMISSIONS: readonly SpindlePermission[] = [
   "macro_interceptor",
   "web_search",
   "unsafe_eval",
+  "final_response",
 ] as const;
 
 export function isValidPermission(p: string): p is SpindlePermission {

package/src/spindle-api.ts

@@ -1,11 +1,15 @@
 import type { SpindleManifest } from "./manifest";
+import type { SpindleHostDescriptorV1 } from "./host";
 import type {
   CouncilMemberContext,
   CouncilSettings,
 } from "./council";
 import type {
   LlmMessageDTO,
-  InterceptorResultDTO,
+  InterceptorDisposer,
+  InterceptorHandler,
+  InterceptorRegistrationMatchOptions,
+  InterceptorRegistrationOptions,
   MacroDefinitionDTO,
   MacroResolveOptionsDTO,
   MacroResolveResultDTO,
@@ -14,6 +18,7 @@ import type {
   ChatAppendMessageOptionsDTO,
   RequestInitDTO,
   ConnectionProfileDTO,
+  ConnectionDispatchDescriptorDTO,
   PermissionDeniedDetail,
   PermissionChangedDetail,
   CharacterDTO,
@@ -58,6 +63,10 @@ import type {
   DryRunResultDTO,
   AssembleRequestDTO,
   AssembleResultDTO,
+  BoundAssembleRequestDTO,
+  BoundAssemblyOutcomeDTO,
+  QuietTrackedRequestDTO,
+  QuietTrackedResultDTO,
   ChatMemoryResultDTO,
   ImageGenRequestDTO,
   ImageGenResultDTO,
@@ -235,8 +244,20 @@ export interface SpindlePromptRegex {
   setOwnedChats(chatIds: string[]): void;
 }
 
+export type SpindleGenerateAPI = SpindleAPI["generate"];
+
+export interface SpindleConnectionsAPI {
+  /**
+   * Resolve an owned concrete slot's current safe dispatch descriptor inside
+   * an active interceptor callback. Requires the `generation` permission.
+   */
+  resolveDispatch(connectionId: string): Promise<ConnectionDispatchDescriptorDTO | null>;
+}
+
 /** The global `spindle` object available in backend extension workers */
 export interface SpindleAPI {
+  /** Immutable host compatibility descriptor for this extension runtime. */
+  readonly host: SpindleHostDescriptorV1;
   /**
    * Subscribe to permission grant/revoke changes for this extension only.
    * This is delivered directly by the worker host and does not subscribe to
@@ -314,12 +335,14 @@ export interface SpindleAPI {
    * Without it, returned parameters are silently stripped.
    */
   registerInterceptor(
-    handler: (
-      messages: LlmMessageDTO[],
-      context: unknown
-    ) => Promise<LlmMessageDTO[] | InterceptorResultDTO>,
-    priority?: number
-  ): void;
+    handler: InterceptorHandler,
+    priority?: number,
+    options?: InterceptorRegistrationMatchOptions,
+  ): InterceptorDisposer;
+  registerInterceptor(
+    handler: InterceptorHandler,
+    options?: InterceptorRegistrationOptions,
+  ): InterceptorDisposer;
 
   /**
    * Assemble an arbitrary Loom block graph against a chat without calling an
@@ -378,6 +401,18 @@ export interface SpindleAPI {
    * ```
    */
   generate: {
+    /**
+     * Assemble against the active callback's frozen parent retrieval snapshot
+     * without provider work or fresh retrieval effects. Requires the
+     * `generation` permission and an active interceptor callback.
+     */
+    assemble(input: BoundAssembleRequestDTO): Promise<BoundAssemblyOutcomeDTO>;
+    /**
+     * Dispatch a receipt-bearing quiet call through the active callback's
+     * revision-bound Main or explicit-slot source. Requires the `generation`
+     * permission and an active interceptor callback.
+     */
+    quietTracked(input: QuietTrackedRequestDTO): Promise<QuietTrackedResultDTO>;
     raw(input: GenerationRequestDTO): Promise<unknown>;
     quiet(input: GenerationRequestDTO): Promise<unknown>;
     batch(input: GenerationRequestDTO): Promise<unknown>;
@@ -716,6 +751,11 @@ export interface SpindleAPI {
      * Returns null if the connection doesn't exist or isn't accessible.
      */
     get(connectionId: string, userId?: string): Promise<ConnectionProfileDTO | null>;
+    /**
+     * Resolve an owned concrete slot's safe current dispatch descriptor inside
+     * an active interceptor callback. Requires the `generation` permission.
+     */
+    resolveDispatch(connectionId: string): Promise<ConnectionDispatchDescriptorDTO | null>;
   };
 
   /** Server-side token counting helpers (free tier). */

package/test/bound-generation-consumer.ts

@@ -0,0 +1,254 @@
+import type {
+  BoundAssembleRequestDTO,
+  BoundAssemblyFailureDTO,
+  BoundAssemblyOutcomeDTO,
+  BoundAssemblySuccessDTO,
+  BoundPrefillAttachmentDTO,
+  ConnectionDispatchDescriptorDTO,
+  GenerationDispatchSourceDTO,
+  GenerationResponseDTO,
+  GenerationUsageDTO,
+  LlmMessageDTO,
+  QuietDispatchReceiptDTO,
+  QuietTrackedRequestDTO,
+  QuietTrackedResultDTO,
+  SpindleAPI,
+  SpindleConnectionsAPI,
+  SpindleGenerateAPI,
+  ToolDefinitionDTO,
+} from "lumiverse-spindle-types";
+
+const mainDispatch: GenerationDispatchSourceDTO = {
+  source: "main",
+  expectedConnectionDispatchRevision: "main-revision",
+};
+
+const slotDispatch: GenerationDispatchSourceDTO = {
+  source: "slot",
+  connectionId: "connection-id",
+  expectedConnectionDispatchRevision: "slot-revision",
+};
+
+const messages: LlmMessageDTO[] = [
+  {
+    role: "assistant",
+    content: [
+      {
+        type: "tool_use",
+        id: "call-1",
+        name: "lookup",
+        input: { query: "safe" },
+        thought_signature: "provider-signature",
+      },
+    ],
+    cache_control: { ttl: "request" },
+    reasoning_content: "reasoning carrier",
+    thinking_blocks: [
+      { type: "thinking", thinking: "private provider reasoning", signature: "opaque" },
+    ],
+    reasoning_details: [{ type: "summary_text", text: "provider detail" }],
+  },
+];
+
+const promptBlocks = [] as BoundAssembleRequestDTO["blocks"];
+const boundRequest: BoundAssembleRequestDTO = {
+  blocks: promptBlocks,
+  promptVariableValues: {},
+  dispatch: mainDispatch,
+  deadlineAt: Date.now() + 1_000,
+  hookFailureMode: "degrade",
+  macroFailureMode: "reject",
+};
+
+const boundSuccess: BoundAssemblySuccessDTO = {
+  messages,
+  breakdown: [],
+  resolved: {
+    source: "main",
+    connectionId: null,
+    connectionDispatchRevision: "main-revision",
+    dispatchKind: "concrete",
+  },
+};
+
+const boundFailures: BoundAssemblyFailureDTO[] = [
+  {
+    kind: "hook",
+    code: "ASSEMBLY_HOOK_FAILED",
+    phase: "context",
+    reason: "timeout",
+    message: "context hook timed out",
+  },
+  {
+    kind: "macro",
+    code: "ASSEMBLY_MACRO_FAILED",
+    reason: "evaluation",
+    message: "macro failed",
+  },
+  {
+    kind: "retrieval_snapshot",
+    code: "ASSEMBLY_RETRIEVAL_SNAPSHOT_UNAVAILABLE",
+    reason: "missing",
+    message: "snapshot unavailable",
+  },
+  { kind: "abort", code: "ASSEMBLY_ABORTED", name: "AbortError", message: "aborted" },
+  { kind: "precondition", code: "ASSEMBLY_PRECONDITION_FAILED", message: "stale dispatch" },
+  { kind: "security", code: "ASSEMBLY_SECURITY_FAILED", message: "invalid source" },
+  { kind: "internal", code: "ASSEMBLY_INTERNAL_FAILED", message: "host error" },
+];
+
+const boundOutcomes: BoundAssemblyOutcomeDTO[] = [
+  { ok: true, result: boundSuccess },
+  ...boundFailures.map((error) => ({ ok: false as const, error })),
+];
+
+function inspectBoundOutcome(outcome: BoundAssemblyOutcomeDTO): string {
+  if (outcome.ok) {
+    return outcome.result.resolved.connectionDispatchRevision;
+  }
+  switch (outcome.error.kind) {
+    case "hook":
+      return outcome.error.phase;
+    case "macro":
+      return outcome.error.reason;
+    case "retrieval_snapshot":
+      return outcome.error.reason;
+    case "abort":
+      return outcome.error.name;
+    case "precondition":
+    case "security":
+    case "internal":
+      return outcome.error.code;
+  }
+}
+
+const tool: ToolDefinitionDTO = {
+  name: "lookup",
+  description: "Look up a safe value",
+  parameters: { type: "object", properties: {} },
+  strict: true,
+  inputExamples: [{ query: "safe" }],
+  cache_control: { ttl: "request" },
+};
+
+const continuation: BoundPrefillAttachmentDTO = {
+  id: "parent-attestation",
+  state: "available",
+};
+
+const quietRequest: QuietTrackedRequestDTO = {
+  messages,
+  dispatch: slotDispatch,
+  continuation: {
+    parentPrefill: continuation,
+    mode: "append-parent-carrier-last",
+  },
+  parameters: { temperature: 0.2 },
+  reasoning: { effort: "low" },
+  tools: [tool],
+  deadlineAt: Date.now() + 1_000,
+};
+
+const usage: GenerationUsageDTO = {
+  prompt_tokens: 10,
+  completion_tokens: 5,
+  total_tokens: 15,
+  provider_raw: { cached: 2 },
+};
+
+const response: GenerationResponseDTO = {
+  content: "safe response",
+  reasoning: "safe reasoning carrier",
+  finish_reason: "stop",
+  tool_calls: [
+    { name: "lookup", args: { query: "safe" }, call_id: "call-1", thought_signature: "opaque" },
+  ],
+  thinking_blocks: [{ type: "redacted_thinking", data: "opaque" }],
+  reasoning_details: [{ type: "summary_text", text: "provider detail" }],
+  usage,
+};
+
+const receipt: QuietDispatchReceiptDTO = {
+  providerInvoked: true,
+  terminalResponse: true,
+  source: "slot",
+  connectionId: "connection-id",
+  connectionDispatchRevision: "slot-revision",
+  usage,
+};
+
+const quietResults: QuietTrackedResultDTO[] = [
+  { ok: true, response, receipt },
+  {
+    ok: false,
+    phase: "preflight",
+    providerInvoked: false,
+    receipt: null,
+    error: { kind: "precondition", code: "BOUND_INVOCATION_REQUIRED", name: "PreconditionError", message: "not bound" },
+  },
+  {
+    ok: false,
+    phase: "resolved",
+    receipt,
+    error: { kind: "provider", code: "PROVIDER_ACCESS_FAILED", name: "ProviderError", message: "provider unavailable" },
+  },
+];
+
+function inspectQuietResult(result: QuietTrackedResultDTO): string {
+  if (result.ok) return result.response.finish_reason;
+  if (result.phase === "preflight") return result.error.kind;
+  return `${result.error.kind}:${result.receipt.connectionDispatchRevision}`;
+}
+
+const descriptor: ConnectionDispatchDescriptorDTO = {
+  connectionId: "connection-id",
+  connectionName: "Safe connection",
+  provider: "provider",
+  model: "model",
+  endpointOrigin: "https://provider.example",
+  dispatchKind: "concrete",
+  connectionDispatchRevision: "slot-revision",
+};
+
+const generateApi = {
+  assemble: async () => ({ ok: true as const, result: boundSuccess }),
+  quietTracked: async () => ({ ok: true as const, response, receipt }),
+} satisfies Pick<SpindleGenerateAPI, "assemble" | "quietTracked">;
+
+const connectionsApi: SpindleConnectionsAPI = {
+  resolveDispatch: async () => descriptor,
+};
+
+declare const spindle: SpindleAPI;
+const generateSurface: SpindleGenerateAPI = spindle.generate;
+const connectionsSurface: SpindleConnectionsAPI = spindle.connections;
+
+// These accesses intentionally fail if private runtime protocol material leaks
+// into the public DTOs.
+// @ts-expect-error invocation tokens are host-private
+void ({} as BoundAssembleRequestDTO).invocationToken;
+// @ts-expect-error snapshots are host-private
+void ({} as QuietTrackedRequestDTO).parentGenerationSnapshot;
+// @ts-expect-error leases are host-private
+void ({} as QuietDispatchReceiptDTO).terminalFinalizationLease;
+// @ts-expect-error API keys are not safe dispatch descriptor fields
+void ({} as ConnectionDispatchDescriptorDTO).apiKey;
+const invalidMainDispatch: GenerationDispatchSourceDTO = {
+  source: "main",
+  expectedConnectionDispatchRevision: "revision",
+  // @ts-expect-error a main source cannot carry an explicit slot id
+  connectionId: "must-not-be-public-on-main",
+};
+// @ts-expect-error attachment attestations are immutable
+continuation.id = "mutated";
+
+void inspectBoundOutcome;
+void inspectQuietResult;
+void generateApi;
+void connectionsApi;
+void generateSurface;
+void connectionsSurface;
+void boundRequest;
+void quietRequest;
+void boundOutcomes;
+void quietResults;

package/test/final-response-and-host-compatibility.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test";
+import {
+  SPINDLE_COMPATIBILITY_ERROR_CODE,
+  SPINDLE_HOST_CAPABILITIES,
+} from "../src/host";
+import { ALL_PERMISSIONS, isValidPermission } from "../src/permissions";
+
+test("final-response permission is valid and publicly declared", () => {
+  expect(ALL_PERMISSIONS).toContain("final_response");
+  expect(isValidPermission("final_response")).toBe(true);
+});
+
+test("host compatibility constants are canonical and immutable", () => {
+  expect(SPINDLE_COMPATIBILITY_ERROR_CODE).toBe("SPINDLE_COMPATIBILITY_ERROR");
+  expect(SPINDLE_HOST_CAPABILITIES).toEqual({
+    "preset-extension-data-v1": 1,
+    "preset-editor-v1": 1,
+    "loom-block-editor-v1": 1,
+    "generation-assembly-v1": 1,
+    "interceptor-context-v1": 1,
+    "interceptor-final-response-v1": 1,
+  });
+  expect(Object.isFrozen(SPINDLE_HOST_CAPABILITIES)).toBe(true);
+});

package/test/host-runtime-contract-consumer.ts

@@ -0,0 +1,137 @@
+import type {
+  FinalResponseDTO,
+  HostToWorker,
+  InterceptorBreakdownEntryDTO,
+  InterceptorResultDTO,
+  SpindleAPI,
+  SpindleFrontendContext,
+  SpindleHostDescriptorV1,
+  SpindleHostLocale,
+  SpindleHostLocaleAPI,
+  SpindleManifest,
+  SpindlePermission,
+  SpindleTabLocation,
+  WorkerToHost,
+} from "lumiverse-spindle-types";
+import {
+  ALL_PERMISSIONS,
+  SPINDLE_COMPATIBILITY_ERROR_CODE,
+  SPINDLE_HOST_CAPABILITIES,
+  isValidPermission,
+} from "lumiverse-spindle-types";
+
+const host: SpindleHostDescriptorV1 = {
+  descriptorVersion: 1,
+  lumiverseVersion: "1.2.3",
+  capabilities: SPINDLE_HOST_CAPABILITIES,
+  extensionInstallationId: "550e8400-e29b-41d4-a716-446655440000",
+};
+
+const localeApi: SpindleHostLocaleAPI = {
+  get: () => "en",
+  subscribe: (listener) => {
+    listener("fr");
+    return () => undefined;
+  },
+};
+
+const locale: SpindleHostLocale = localeApi.get();
+const permission: SpindlePermission = "final_response";
+const allPermissions: readonly SpindlePermission[] = ALL_PERMISSIONS;
+if (!isValidPermission(permission) || !allPermissions.includes(permission)) {
+  throw new Error("final_response must be a valid public permission");
+}
+
+const finalResponse: FinalResponseDTO = {
+  content: "An extension-authored final answer",
+  reasoning: "The selected branch completed successfully.",
+  fallbackMessageIndex: 0,
+};
+const breakdown: InterceptorBreakdownEntryDTO = { messageIndex: 0, name: "Additional context" };
+
+const result: InterceptorResultDTO = {
+  messages: [{ role: "system", content: "Additional context" }],
+  breakdown: [breakdown],
+  finalResponse,
+};
+const wireResult: WorkerToHost = {
+  type: "intercept_result",
+  requestId: "request-id",
+  registrationId: "registration-id",
+  messages: result.messages,
+  breakdown: [breakdown],
+  finalResponse,
+};
+
+const init: HostToWorker = {
+  type: "init",
+  manifest: {
+    version: "1.0.0",
+    name: "Legacy extension",
+    identifier: "legacy_extension",
+    author: "Extension author",
+    github: "https://github.com/example/legacy-extension",
+    homepage: "https://example.com/legacy-extension",
+    permissions: [],
+  },
+  storagePath: "/extensions/legacy_extension",
+  host,
+};
+
+// The compatibility field is intentionally optional for legacy manifests.
+const legacyManifest: SpindleManifest = {
+  version: "1.0.0",
+  name: "Legacy extension",
+  identifier: "legacy_extension",
+  author: "Extension author",
+  github: "https://github.com/example/legacy-extension",
+  homepage: "https://example.com/legacy-extension",
+  permissions: [],
+};
+// @ts-expect-error host descriptor is required on the public init message
+const legacyInitWithoutHost: HostToWorker = {
+  type: "init",
+  manifest: legacyManifest,
+  storagePath: "/extensions/legacy_extension",
+};
+void locale;
+void result;
+void legacyManifest;
+
+declare const spindle: SpindleAPI;
+const backendHost: SpindleHostDescriptorV1 = spindle.host;
+// @ts-expect-error the host descriptor is exposed as a readonly API property
+spindle.host = host;
+// @ts-expect-error nested capability records are readonly
+spindle.host.capabilities["interceptor-final-response-v1"] = 2;
+// @ts-expect-error descriptor scalar fields are readonly
+spindle.host.lumiverseVersion = "2.0.0";
+void backendHost;
+
+declare const ctx: SpindleFrontendContext;
+const frontendHost: SpindleHostDescriptorV1 = ctx.host;
+const activeLocale: SpindleHostLocale = ctx.locale.get();
+const tabLocation: SpindleTabLocation = ctx.ui.getTabLocation("profile");
+const unsubscribe = ctx.locale.subscribe((nextLocale) => {
+  const checked: SpindleHostLocale = nextLocale;
+  void checked;
+});
+// @ts-expect-error the frontend host descriptor is exposed as a readonly API property
+ctx.host = host;
+// @ts-expect-error the frontend locale API is exposed as a readonly API property
+ctx.locale = localeApi;
+void frontendHost;
+void activeLocale;
+void unsubscribe;
+void tabLocation;
+const compatibilityCode: "SPINDLE_COMPATIBILITY_ERROR" = SPINDLE_COMPATIBILITY_ERROR_CODE;
+void compatibilityCode;
+
+const asyncFrontendModule = {
+  async setup(_ctx: SpindleFrontendContext) {
+    return async () => undefined;
+  },
+  async teardown() {},
+};
+const typedAsyncFrontendModule: import("lumiverse-spindle-types").SpindleFrontendModule = asyncFrontendModule;
+void typedAsyncFrontendModule;

package/test/interceptor-consumer.ts

@@ -0,0 +1,196 @@
+import type {
+  BoundAssembleRequestDTO,
+  BoundPrefillAttachmentDTO,
+  ConnectionDispatchDescriptorDTO,
+  DeferredGuidanceDTO,
+  HostToWorker,
+  InterceptorContextDTO,
+  InterceptorGenerationType,
+  InterceptorHandler,
+  InterceptorMatchDTO,
+  InterceptorRegistrationMatchOptions,
+  InterceptorRegistrationOptions,
+  InterceptorResultDTO,
+  InterceptorDisposer,
+  InterceptorBreakdownEntryDTO,
+  LlmMessageDTO,
+  QuietTrackedRequestDTO,
+  SpindleAPI,
+  WorkerToHost,
+} from "lumiverse-spindle-types";
+
+const generationType: InterceptorGenerationType = "continue";
+const match: InterceptorMatchDTO = {
+  generationTypes: ["normal", generationType],
+  isDryRun: false,
+  presetField: {
+    path: ["activeMode"],
+    exists: true,
+    notIn: ["single", 0, false, null],
+    oneOf: ["sequential", "parallel"],
+  },
+};
+const matchOptions: InterceptorRegistrationMatchOptions = { match };
+const options: InterceptorRegistrationOptions = { priority: 900, match };
+
+const descriptor: ConnectionDispatchDescriptorDTO = {
+  connectionId: "connection-id",
+  connectionName: "Main",
+  provider: "provider",
+  model: "model",
+  endpointOrigin: "https://provider.example",
+  dispatchKind: "concrete",
+  connectionDispatchRevision: "revision-1",
+};
+const prefillCarrier: BoundPrefillAttachmentDTO = {
+  id: "prefill-attestation",
+  state: "available",
+};
+const context: InterceptorContextDTO = {
+  userId: "user-id",
+  chatId: "chat-id",
+  generationId: "generation-id",
+  generationType,
+  isDryRun: false,
+  presetId: "preset-id",
+  presetMetadata: { activeMode: "parallel" },
+  personaId: null,
+  characterId: "character-id",
+  personaAddonStates: { example: true },
+  excludeMessageId: "message-id",
+  rejectedSwipe: "rejected-swipe",
+  regenFeedback: "try again",
+  regenFeedbackPosition: "user",
+  mainDispatch: {
+    source: "main",
+    descriptor,
+    connectionDispatchRevision: "revision-1",
+    dispatchKind: "concrete",
+  },
+  prefillCarrier,
+  interceptorDeadlineAt: Date.now() + 1_000,
+  boundWorkDeadlineAt: Date.now() + 900,
+  signal: new AbortController().signal,
+};
+
+const guidance: DeferredGuidanceDTO = {
+  id: "7c6d2b1a-5f44-4e90-8a31-2d7b9c4e6f80",
+  content: "Keep the response concise.",
+  role: "system",
+};
+const breakdown: InterceptorBreakdownEntryDTO = { messageIndex: 0, name: "injected" };
+const messages: LlmMessageDTO[] = [{ role: "user", content: "hello" }];
+
+const callback: InterceptorHandler = async (input, callbackContext) => {
+  const userId: string = callbackContext.userId;
+  const generationId: string = callbackContext.generationId;
+  const dispatchKind: "concrete" | "roulette" | null = callbackContext.mainDispatch.dispatchKind;
+  const signal: AbortSignal = callbackContext.signal;
+  const metadata: unknown = callbackContext.presetMetadata;
+  void userId;
+  void generationId;
+  void dispatchKind;
+  void signal;
+  void metadata;
+  const boundAssembly = await spindle.generate.assemble({
+    blocks: [],
+    dispatch: {
+      source: "main",
+      expectedConnectionDispatchRevision: "revision-1",
+    },
+    deadlineAt: Date.now() + 900,
+    signal,
+  });
+  const boundQuiet = await spindle.generate.quietTracked({
+    messages: input,
+    dispatch: {
+      source: "main",
+      expectedConnectionDispatchRevision: "revision-1",
+    },
+    deadlineAt: Date.now() + 900,
+    signal,
+  });
+  void boundAssembly;
+  void boundQuiet;
+  // @ts-expect-error callback context is readonly
+  callbackContext.userId = "must-not-compile";
+  // @ts-expect-error nested dispatch context is readonly
+  callbackContext.mainDispatch.dispatchKind = "roulette";
+  return {
+    messages: input,
+    breakdown: [breakdown],
+    deferredGuidance: [guidance],
+  } satisfies InterceptorResultDTO;
+};
+
+const legacyArrayCallback: InterceptorHandler = async (input) => input;
+const legacyResultCallback: InterceptorHandler = async (input) => ({ messages: input });
+
+declare const spindle: SpindleAPI;
+const priorityDisposer: InterceptorDisposer = spindle.registerInterceptor(callback, 900, matchOptions);
+const optionsDisposer: InterceptorDisposer = spindle.registerInterceptor(callback, options);
+const handlerOnlyDisposer: InterceptorDisposer = spindle.registerInterceptor(legacyArrayCallback);
+const legacyPriorityDisposer: InterceptorDisposer = spindle.registerInterceptor(legacyResultCallback, 100);
+priorityDisposer();
+optionsDisposer();
+handlerOnlyDisposer();
+legacyPriorityDisposer();
+
+const { signal: _signal, ...wireContext } = context;
+const wireIntercept: HostToWorker = {
+  type: "intercept_request",
+  requestId: "request-id",
+  registrationId: "registration-id",
+  messages,
+  context: wireContext,
+};
+const abortIntercept: HostToWorker = {
+  type: "intercept_abort",
+  requestId: "request-id",
+  registrationId: "registration-id",
+};
+const register: WorkerToHost = {
+  type: "register_interceptor",
+  registrationId: "registration-id",
+  priority: 900,
+  match,
+};
+const unregister: WorkerToHost = {
+  type: "unregister_interceptor",
+  registrationId: "registration-id",
+};
+const result: WorkerToHost = {
+  type: "intercept_result",
+  requestId: "request-id",
+  registrationId: "registration-id",
+  messages,
+  deferredGuidance: [guidance],
+};
+const assembleBound: WorkerToHost = {
+  type: "generate_assemble",
+  requestId: "assemble-id",
+  input: {
+    blocks: [] as BoundAssembleRequestDTO["blocks"],
+    dispatch: { source: "main", expectedConnectionDispatchRevision: "revision-1" },
+    deadlineAt: Date.now() + 500,
+  },
+};
+const quietTracked: WorkerToHost = {
+  type: "generate_quiet_tracked",
+  requestId: "quiet-id",
+  input: {
+    messages,
+    dispatch: { source: "main", expectedConnectionDispatchRevision: "revision-1" },
+    deadlineAt: Date.now() + 500,
+  } satisfies Omit<QuietTrackedRequestDTO, "signal">,
+};
+
+void abortIntercept;
+void assembleBound;
+void options;
+void priorityDisposer;
+void quietTracked;
+void register;
+void result;
+void unregister;
+void wireIntercept;

package/tsconfig.consumer.json

@@ -5,5 +5,5 @@
     "outDir": "./.consumer-dist",
     "declaration": false
   },
-  "include": ["test/loom-block-editor-consumer.ts"]
+  "include": ["test/loom-block-editor-consumer.ts", "test/bound-generation-consumer.ts", "test/interceptor-consumer.ts", "test/host-runtime-contract-consumer.ts"]
 }