@unbrained/pm-cli 2026.7.4 → 2026.7.5

package/dist/cli-bundle/chunks/chunk-3JZNEQBA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../sdk/compose.ts","../../../../../../../../sdk/testing.ts"],"sourcesContent":["/**\n * @module sdk/compose\n *\n * Declarative extension authoring — the capstone of the SDK authoring tripod\n * (`author → register → test`).\n *\n * The {@link ./define.js | `define*`} builders type each registration where it\n * is written, and the `assert*`/`run*` testing helpers verify and invoke it. But\n * the author still has to hand-wire every definition into an imperative\n * `activate(api)` body — calling the right `api.register*` method, in the right\n * order, without forgetting one — and then hand-sync `manifest.capabilities` to\n * match. Those are the two most common package-authoring footguns.\n *\n * {@link composeExtension} closes the loop: an author (or an agent) describes\n * *what* to register as a plain {@link ExtensionBlueprint} object, and the SDK\n * generates the `activate` that wires every surface for them.\n * {@link deriveExtensionCapabilities} computes the exact least-privilege\n * capability set that blueprint exercises, so `manifest.json` can be authored\n * with zero declared-but-unused / used-but-undeclared drift (the author-time\n * inverse of the runtime `reconcileExtensionCapabilityUsage` reconciliation).\n *\n * This module also owns {@link ExtensionModule} and {@link defineExtension} —\n * the in-module export shape every extension entry file produces and its\n * zero-cost identity helper — so both the imperative (`defineExtension`) and\n * declarative (`composeExtension`) authoring styles live together. Both are\n * re-exported from the SDK barrel, so the public API is unchanged.\n */\nimport type {\n  AfterCommandHook,\n  BeforeCommandHook,\n  CommandDefinition,\n  CommandOverride,\n  ExtensionApi,\n  ExtensionCapability,\n  ExtensionManifest,\n  ExtensionServiceName,\n  Exporter,\n  FlagDefinition,\n  ImportExportRegistrationOptions,\n  Importer,\n  OnIndexHook,\n  OnReadHook,\n  OnWriteHook,\n  OutputRendererFormat,\n  ParserOverride,\n  PreflightOverride,\n  RendererOverride,\n  SchemaFieldDefinition,\n  SchemaItemTypeDefinition,\n  SchemaMigrationDefinition,\n  SearchProviderDefinition,\n  ServiceOverride,\n  VectorStoreAdapterDefinition,\n} from \"../core/extensions/loader.js\";\nimport type { ExtensionActivationSummary } from \"../core/extensions/activation-summary.js\";\nimport type { ProjectProfileRegistrationInput } from \"../core/profile/profile-presets.js\";\nimport type { PmMaxVersionExceededMode } from \"../core/extensions/extension-types.js\";\nimport {\n  normalizeKnownExtensionCapability,\n  resolveLegacyExtensionCapabilityAlias,\n} from \"../core/extensions/extension-capability-aliases.js\";\nimport { normalizeCommandName } from \"../core/extensions/extension-runtime-helpers.js\";\nimport {\n  evaluatePmMaxVersionBound,\n  evaluatePmMinVersionBound,\n  type PmVersionBoundEvaluation,\n  type PmVersionBoundKind,\n} from \"../core/extensions/version-compat.js\";\n\n/**\n * Documents the extension module payload exchanged by command, SDK, and package integrations.\n *\n * This is the shape an extension entry file exports (as its default export and,\n * conventionally, as named `manifest`/`activate` exports). Produce it directly,\n * via {@link defineExtension} for the imperative style, or via\n * {@link composeExtension} for the declarative style.\n */\nexport interface ExtensionModule {\n  /**\n   * Optional in-module metadata mirror.\n   *\n   * The authoritative manifest remains on-disk `manifest.json`; this field is\n   * useful when authors want colocated metadata for tooling/tests. Type it with\n   * {@link defineExtensionManifest} for full contract checking at the definition\n   * site.\n   */\n  manifest?: ExtensionManifest;\n  activate(api: ExtensionApi): void | Promise<void>;\n  /**\n   * Optional teardown lifecycle hook (VS Code-style `deactivate`). Invoked by\n   * the host on shutdown/reload to release resources opened during `activate`.\n   */\n  deactivate?(): void | Promise<void>;\n}\n\n/**\n * Typed identity helper for extension module exports.\n *\n * Use as:\n * `export default defineExtension({ activate(api) { ... } })`\n *\n * Reach for {@link composeExtension} instead when you would rather declare the\n * registrations as data than wire them imperatively in `activate`.\n */\nexport function defineExtension<TModule extends ExtensionModule>(module: TModule): TModule {\n  return module;\n}\n\n/**\n * A single importer registration entry for an {@link ExtensionBlueprint}, mirroring\n * the positional arguments of `api.registerImporter(name, importer, options?)`.\n */\nexport interface ExtensionBlueprintImporter {\n  /** Registered importer name; the `<name> import` command path is derived from it. */\n  name: string;\n  /** The importer handler that bridges an external system into the pm context graph. */\n  importer: Importer;\n  /** Optional command metadata (description/flags/intent/examples) for the derived command. */\n  options?: ImportExportRegistrationOptions;\n}\n\n/**\n * A single exporter registration entry for an {@link ExtensionBlueprint}, mirroring\n * the positional arguments of `api.registerExporter(name, exporter, options?)`.\n */\nexport interface ExtensionBlueprintExporter {\n  /** Registered exporter name; the `<name> export` command path is derived from it. */\n  name: string;\n  /** The exporter handler that bridges the pm context graph out to an external system. */\n  exporter: Exporter;\n  /** Optional command metadata (description/flags/intent/examples) for the derived command. */\n  options?: ImportExportRegistrationOptions;\n}\n\n/**\n * The lifecycle hooks an {@link ExtensionBlueprint} can register, one array per\n * kind. Each entry is registered through the matching `api.hooks.*` method in\n * the canonical order `before_command → after_command → on_write → on_read →\n * on_index`.\n */\nexport interface ExtensionBlueprintHooks {\n  /** Hooks fired before a command runs (`api.hooks.beforeCommand`). */\n  beforeCommand?: BeforeCommandHook[];\n  /** Hooks fired after a command runs (`api.hooks.afterCommand`). */\n  afterCommand?: AfterCommandHook[];\n  /** Hooks fired when an item is persisted (`api.hooks.onWrite`). */\n  onWrite?: OnWriteHook[];\n  /** Hooks fired when an item is read (`api.hooks.onRead`). */\n  onRead?: OnReadHook[];\n  /** Hooks fired during index/search refresh (`api.hooks.onIndex`). */\n  onIndex?: OnIndexHook[];\n}\n\n/**\n * A declarative description of everything an extension registers at activation.\n *\n * Every field is optional: populate the surfaces your extension uses (ideally\n * with {@link ./define.js | `define*`}-authored definitions) and leave the rest\n * out. {@link composeExtension} turns the blueprint into an\n * {@link ExtensionModule} whose generated `activate` calls the matching\n * `api.register*` method for each surface, and {@link deriveExtensionCapabilities}\n * computes the capability set the blueprint requires.\n *\n * Record-keyed fields map a routing key (command name, output format, or service\n * name) to its handler, mirroring the two-argument `api.register*` overloads.\n */\nexport interface ExtensionBlueprint {\n  /** Optional in-module manifest mirror, copied onto the produced module verbatim. */\n  manifest?: ExtensionManifest;\n  /** Full command definitions registered via `api.registerCommand(definition)`. */\n  commands?: CommandDefinition[];\n  /** Command overrides keyed by command name, registered via `api.registerCommand(command, override)`. */\n  commandOverrides?: Record<string, CommandOverride>;\n  /** Additional flags keyed by target command name, registered via `api.registerFlags(command, flags)`. */\n  flags?: Record<string, FlagDefinition[]>;\n  /** Parser overrides keyed by command name, registered via `api.registerParser(command, override)`. */\n  parsers?: Record<string, ParserOverride>;\n  /** Output renderer overrides keyed by format, registered via `api.registerRenderer(format, renderer)`. */\n  renderers?: Partial<Record<OutputRendererFormat, RendererOverride>>;\n  /** Service overrides keyed by service name, registered via `api.registerService(service, override)`. */\n  services?: Partial<Record<ExtensionServiceName, ServiceOverride>>;\n  /** Preflight overrides registered via `api.registerPreflight(override)`. */\n  preflights?: PreflightOverride[];\n  /** Custom item types registered in a single `api.registerItemTypes(types)` call. */\n  itemTypes?: SchemaItemTypeDefinition[];\n  /** Custom front-matter fields registered in a single `api.registerItemFields(fields)` call. */\n  itemFields?: SchemaFieldDefinition[];\n  /** Schema migrations registered one at a time via `api.registerMigration(definition)`. */\n  migrations?: SchemaMigrationDefinition[];\n  /** Project profiles registered one at a time via `api.registerProfile(profile)`. */\n  profiles?: ProjectProfileRegistrationInput[];\n  /** Search providers registered via `api.registerSearchProvider(provider)`. */\n  searchProviders?: SearchProviderDefinition[];\n  /** Vector store adapters registered via `api.registerVectorStoreAdapter(adapter)`. */\n  vectorStoreAdapters?: VectorStoreAdapterDefinition[];\n  /** Importers registered via `api.registerImporter(name, importer, options?)`. */\n  importers?: ExtensionBlueprintImporter[];\n  /** Exporters registered via `api.registerExporter(name, exporter, options?)`. */\n  exporters?: ExtensionBlueprintExporter[];\n  /** Lifecycle hooks registered through `api.hooks.*`. */\n  hooks?: ExtensionBlueprintHooks;\n  /**\n   * Optional imperative escape hatch run *after* every declarative registration,\n   * for the rare wiring the blueprint cannot express. Receives the same `api`.\n   */\n  activate?: (api: ExtensionApi) => void | Promise<void>;\n  /** Optional teardown hook copied onto the produced module verbatim. */\n  deactivate?: () => void | Promise<void>;\n}\n\n/**\n * Typed identity helper for a (partial) {@link ExtensionBlueprint} authored as its\n * own module — the typed entry point of the modular declarative-authoring loop.\n *\n * It is the natural companion to {@link mergeExtensionBlueprints}: when an\n * extension's surface is split across files — a commands module, a search module,\n * a hooks module — wrap each fragment so it is contract-checked *at its definition\n * site* (with editor completion), exactly as {@link defineExtension} types a whole\n * module and {@link defineExtensionManifest} types a manifest. It returns its\n * argument unchanged, preserving the literal type\n * so the fragment composes into {@link mergeExtensionBlueprints},\n * {@link composeExtension}, or {@link composeExtensionPackage} with no loss of\n * inference.\n *\n * Use as:\n * `export const commandsModule = defineExtensionBlueprint({ commands: [...] })`\n */\nexport function defineExtensionBlueprint<TBlueprint extends ExtensionBlueprint>(blueprint: TBlueprint): TBlueprint {\n  return blueprint;\n}\n\n/**\n * Register a blueprint's command-layer surfaces — fresh command definitions,\n * command overrides, flag tables, and parser/renderer/service overrides — in the\n * deterministic order {@link composeExtension} documents.\n */\nfunction registerBlueprintCommandSurfaces(api: ExtensionApi, blueprint: ExtensionBlueprint): void {\n  for (const command of blueprint.commands ?? []) {\n    api.registerCommand(command);\n  }\n  for (const [command, override] of Object.entries(blueprint.commandOverrides ?? {})) {\n    api.registerCommand(command, override);\n  }\n  for (const [targetCommand, flags] of Object.entries(blueprint.flags ?? {})) {\n    api.registerFlags(targetCommand, flags);\n  }\n  for (const [command, override] of Object.entries(blueprint.parsers ?? {})) {\n    api.registerParser(command, override);\n  }\n  for (const [format, renderer] of Object.entries(blueprint.renderers ?? {}) as Array<\n    [OutputRendererFormat, RendererOverride]\n  >) {\n    api.registerRenderer(format, renderer);\n  }\n  for (const [service, override] of Object.entries(blueprint.services ?? {}) as Array<\n    [ExtensionServiceName, ServiceOverride]\n  >) {\n    api.registerService(service, override);\n  }\n}\n\n/**\n * Register a blueprint's schema-layer surfaces — preflight overrides, item types,\n * item fields, schema migrations, and project profiles — preserving the\n * batch-registration semantics of `registerItemTypes`/`registerItemFields`\n * (only invoked when at least one entry is present).\n */\nfunction registerBlueprintSchemaSurfaces(api: ExtensionApi, blueprint: ExtensionBlueprint): void {\n  for (const override of blueprint.preflights ?? []) {\n    api.registerPreflight(override);\n  }\n  const itemTypes = blueprint.itemTypes ?? [];\n  if (itemTypes.length > 0) {\n    api.registerItemTypes(itemTypes);\n  }\n  const itemFields = blueprint.itemFields ?? [];\n  if (itemFields.length > 0) {\n    api.registerItemFields(itemFields);\n  }\n  for (const migration of blueprint.migrations ?? []) {\n    api.registerMigration(migration);\n  }\n  for (const profile of blueprint.profiles ?? []) {\n    api.registerProfile(profile);\n  }\n}\n\n/**\n * Register a blueprint's retrieval and interchange surfaces — search providers,\n * vector store adapters, importers, and exporters — passing each importer's and\n * exporter's optional registration options through verbatim.\n */\nfunction registerBlueprintRetrievalSurfaces(api: ExtensionApi, blueprint: ExtensionBlueprint): void {\n  for (const provider of blueprint.searchProviders ?? []) {\n    api.registerSearchProvider(provider);\n  }\n  for (const adapter of blueprint.vectorStoreAdapters ?? []) {\n    api.registerVectorStoreAdapter(adapter);\n  }\n  for (const entry of blueprint.importers ?? []) {\n    api.registerImporter(entry.name, entry.importer, entry.options);\n  }\n  for (const entry of blueprint.exporters ?? []) {\n    api.registerExporter(entry.name, entry.exporter, entry.options);\n  }\n}\n\n/**\n * Register a blueprint's lifecycle hooks in canonical order\n * (beforeCommand → afterCommand → onWrite → onRead → onIndex).\n */\nfunction registerBlueprintHooks(api: ExtensionApi, hooks: ExtensionBlueprintHooks): void {\n  for (const hook of hooks.beforeCommand ?? []) {\n    api.hooks.beforeCommand(hook);\n  }\n  for (const hook of hooks.afterCommand ?? []) {\n    api.hooks.afterCommand(hook);\n  }\n  for (const hook of hooks.onWrite ?? []) {\n    api.hooks.onWrite(hook);\n  }\n  for (const hook of hooks.onRead ?? []) {\n    api.hooks.onRead(hook);\n  }\n  for (const hook of hooks.onIndex ?? []) {\n    api.hooks.onIndex(hook);\n  }\n}\n\n/**\n * Assemble an {@link ExtensionModule} from a declarative {@link ExtensionBlueprint}.\n *\n * The returned module's `activate` registers every populated surface through the\n * matching `api.register*` method in a deterministic order (commands → overrides\n * → flags → parsers → renderers → services → preflights → item types → item\n * fields → migrations → profiles → search providers → vector store adapters →\n * importers → exporters → hooks), then awaits the blueprint's optional imperative `activate`\n * so it can layer on anything the declarative form cannot express. `manifest`\n * and `deactivate` are copied onto the module verbatim.\n *\n * This is a pure assembler: it does not validate the definitions. Per-surface\n * contract enforcement stays in `api.register*` (and the loader), exactly as it\n * does for hand-written `activate` bodies, so a malformed definition surfaces\n * the same activation diagnostic either way.\n */\nexport function composeExtension(blueprint: ExtensionBlueprint): ExtensionModule {\n  const activate = async (api: ExtensionApi): Promise<void> => {\n    registerBlueprintCommandSurfaces(api, blueprint);\n    registerBlueprintSchemaSurfaces(api, blueprint);\n    registerBlueprintRetrievalSurfaces(api, blueprint);\n    // `?? {}` (rather than a `!== undefined` guard) so an explicit `hooks: null`\n    // crossing an untyped boundary (e.g. a blueprint hydrated from JSON) is\n    // treated the same as omitting it, instead of throwing on the first\n    // `hooks.beforeCommand` access.\n    registerBlueprintHooks(api, blueprint.hooks ?? {});\n    await blueprint.activate?.(api);\n  };\n\n  // Truthy checks (rather than `!== undefined`) so an explicit `null` mirror or\n  // teardown is treated as absent instead of copied onto the module.\n  const module: ExtensionModule = { activate };\n  if (blueprint.manifest) {\n    module.manifest = blueprint.manifest;\n  }\n  if (blueprint.deactivate) {\n    module.deactivate = blueprint.deactivate;\n  }\n  return module;\n}\n\n/**\n * Concatenate the populated entries of an array surface across blueprints,\n * preserving argument order. Returns `undefined` when no blueprint contributes\n * any entry, so {@link mergeExtensionBlueprints} omits the field instead of\n * emitting an empty array. `?? []` tolerates an explicit `null` field (e.g. from a\n * blueprint hydrated across an untyped boundary) exactly as {@link composeExtension} does.\n */\nfunction mergeArraySurface<TValue>(\n  surfaces: ReadonlyArray<readonly TValue[] | null | undefined>,\n): TValue[] | undefined {\n  const merged = surfaces.flatMap((surface) => surface ?? []);\n  return merged.length > 0 ? merged : undefined;\n}\n\n/**\n * Shallow-merge single-handler record surfaces (`commandOverrides`, `parsers`,\n * `renderers`, `services`) with last-defined-wins precedence on a key collision,\n * exactly like spreading the records in argument order. Returns `undefined` when\n * no blueprint contributes any key.\n */\nfunction mergeHandlerRecord<TRecord extends object>(\n  surfaces: ReadonlyArray<TRecord | null | undefined>,\n): TRecord | undefined {\n  const merged = Object.assign({}, ...surfaces.map((surface) => surface ?? {})) as TRecord;\n  return Object.keys(merged).length > 0 ? merged : undefined;\n}\n\n/**\n * Merge `flags` records by concatenating every blueprint's flag array for a shared\n * target command, mirroring the additive `api.registerFlags` semantics so each\n * module's flags reach the command. Returns `undefined` when no blueprint declares\n * any flags.\n */\nfunction mergeFlagRecord(\n  surfaces: ReadonlyArray<Record<string, FlagDefinition[]> | null | undefined>,\n): Record<string, FlagDefinition[]> | undefined {\n  const merged: Record<string, FlagDefinition[]> = {};\n  for (const surface of surfaces) {\n    for (const [command, flags] of Object.entries(surface ?? {})) {\n      // `flags` is the record's array value, never nullish in-type — `composeExtension`\n      // likewise passes it to `registerFlags` unguarded — so it is spread directly.\n      merged[command] = [...(merged[command] ?? []), ...flags];\n    }\n  }\n  return Object.keys(merged).length > 0 ? merged : undefined;\n}\n\nconst EXTENSION_BLUEPRINT_HOOK_KEYS = [\n  \"beforeCommand\",\n  \"afterCommand\",\n  \"onWrite\",\n  \"onRead\",\n  \"onIndex\",\n] as const satisfies ReadonlyArray<keyof ExtensionBlueprintHooks>;\n\ntype ExtensionBlueprintHookKey = (typeof EXTENSION_BLUEPRINT_HOOK_KEYS)[number];\ntype MissingExtensionBlueprintHookKeys = Exclude<keyof ExtensionBlueprintHooks, ExtensionBlueprintHookKey>;\ntype ExtraExtensionBlueprintHookKeys = Exclude<ExtensionBlueprintHookKey, keyof ExtensionBlueprintHooks>;\n\n// Compile-time exhaustiveness guard: adding a hook field must update the canonical\n// merge order above, and stale keys cannot remain in that list.\nconst EXTENSION_BLUEPRINT_HOOK_KEY_COVERAGE: Record<\n  MissingExtensionBlueprintHookKeys | ExtraExtensionBlueprintHookKeys,\n  never\n> = {};\nvoid EXTENSION_BLUEPRINT_HOOK_KEY_COVERAGE;\n\ntype ExtensionBlueprintHookArray<TKey extends keyof ExtensionBlueprintHooks> = NonNullable<ExtensionBlueprintHooks[TKey]>;\ntype ExtensionBlueprintHookValue<TKey extends keyof ExtensionBlueprintHooks> = ExtensionBlueprintHookArray<TKey>[number];\n\nfunction assignMergedHookSurface<TKey extends keyof ExtensionBlueprintHooks>(\n  merged: ExtensionBlueprintHooks,\n  surfaces: ReadonlyArray<ExtensionBlueprintHooks | null | undefined>,\n  key: TKey,\n): void {\n  const hookArrays = surfaces.map((hooks) => hooks?.[key]) as ReadonlyArray<\n    ExtensionBlueprintHookArray<TKey> | null | undefined\n  >;\n  const value = mergeArraySurface<ExtensionBlueprintHookValue<TKey>>(hookArrays);\n  if (value !== undefined) {\n    const typedMerged = merged as { [K in TKey]?: ExtensionBlueprintHookArray<K> };\n    typedMerged[key] = value as ExtensionBlueprintHookArray<TKey>;\n  }\n}\n\n/**\n * Merge the nested `hooks` surface by concatenating each lifecycle kind's array in\n * canonical order. Returns `undefined` when no blueprint registers any hook.\n */\nfunction mergeHookSurfaces(\n  surfaces: ReadonlyArray<ExtensionBlueprintHooks | null | undefined>,\n): ExtensionBlueprintHooks | undefined {\n  const merged: ExtensionBlueprintHooks = {};\n  for (const key of EXTENSION_BLUEPRINT_HOOK_KEYS) {\n    assignMergedHookSurface(merged, surfaces, key);\n  }\n  return Object.keys(merged).length > 0 ? merged : undefined;\n}\n\n/**\n * Merge several partial {@link ExtensionBlueprint}s into one, so an extension's\n * surface can be authored *modularly* — a commands module, a search module, a\n * hooks module — and combined into a single blueprint to feed\n * {@link composeExtension}, {@link composeExtensionPackage},\n * {@link synthesizeExtensionManifest}, {@link describeExtensionBlueprint}, or\n * {@link preflightExtension}.\n *\n * The merge is pure and deterministic and never mutates an input. Each surface\n * combines the way its underlying `api.register*` call composes:\n *\n * - **Array surfaces** — `commands`, `preflights`, `itemTypes`, `itemFields`,\n *   `migrations`, `profiles`, `searchProviders`, `vectorStoreAdapters`,\n *   `importers`, `exporters` — concatenate in argument order.\n * - **`flags`** concatenates the flag arrays of any shared target command,\n *   mirroring additive `api.registerFlags`: every module's flags reach the command.\n * - **Single-handler records** — `commandOverrides`, `parsers`, `renderers`,\n *   `services` — follow last-defined-wins precedence on a key collision, exactly\n *   like spreading the records in argument order; a later module deliberately\n *   overrides an earlier one's handler for that key.\n * - **`hooks`** concatenates each lifecycle kind's array in canonical order.\n * - The imperative **`activate`** escape hatches chain in argument order (each\n *   awaited), so every module's escape-hatch wiring still runs.\n * - The **`deactivate`** teardown hooks chain in *reverse* argument order (LIFO),\n *   releasing resources in the inverse of acquisition. Teardown is best-effort:\n *   a throwing hook does not strand later modules' cleanup — every hook runs and\n *   teardown failures are re-thrown afterwards (as the original error for one\n *   failure, or an `AggregateError` for several).\n * - The **`manifest`** mirror is last-defined-wins.\n *\n * Because `composeExtension` and the derive/lint/describe helpers are pure readers\n * of this data, a merged blueprint behaves exactly as a hand-written one: a command\n * two modules both define survives as a duplicate in the merged `commands` array\n * and {@link lintExtensionBlueprint} flags it, just as it would in one file. An\n * empty field is omitted rather than emitted empty, so merging zero blueprints\n * returns an empty blueprint (`{}`).\n */\nexport function mergeExtensionBlueprints(...blueprints: ExtensionBlueprint[]): ExtensionBlueprint {\n  const merged: ExtensionBlueprint = {};\n  const assign = <TKey extends keyof ExtensionBlueprint>(key: TKey, value: ExtensionBlueprint[TKey]): void => {\n    if (value !== undefined) {\n      merged[key] = value;\n    }\n  };\n  assign(\"commands\", mergeArraySurface(blueprints.map((blueprint) => blueprint.commands)));\n  assign(\"commandOverrides\", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.commandOverrides)));\n  assign(\"flags\", mergeFlagRecord(blueprints.map((blueprint) => blueprint.flags)));\n  assign(\"parsers\", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.parsers)));\n  assign(\"renderers\", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.renderers)));\n  assign(\"services\", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.services)));\n  assign(\"preflights\", mergeArraySurface(blueprints.map((blueprint) => blueprint.preflights)));\n  assign(\"itemTypes\", mergeArraySurface(blueprints.map((blueprint) => blueprint.itemTypes)));\n  assign(\"itemFields\", mergeArraySurface(blueprints.map((blueprint) => blueprint.itemFields)));\n  assign(\"migrations\", mergeArraySurface(blueprints.map((blueprint) => blueprint.migrations)));\n  assign(\"profiles\", mergeArraySurface(blueprints.map((blueprint) => blueprint.profiles)));\n  assign(\"searchProviders\", mergeArraySurface(blueprints.map((blueprint) => blueprint.searchProviders)));\n  assign(\"vectorStoreAdapters\", mergeArraySurface(blueprints.map((blueprint) => blueprint.vectorStoreAdapters)));\n  assign(\"importers\", mergeArraySurface(blueprints.map((blueprint) => blueprint.importers)));\n  assign(\"exporters\", mergeArraySurface(blueprints.map((blueprint) => blueprint.exporters)));\n  assign(\"hooks\", mergeHookSurfaces(blueprints.map((blueprint) => blueprint.hooks)));\n  // Last-defined-wins for the in-module manifest mirror: a later module's identity\n  // supersedes an earlier one's, matching the single-handler record precedence.\n  let manifest: ExtensionManifest | undefined;\n  for (const blueprint of blueprints) {\n    if (blueprint.manifest) {\n      manifest = blueprint.manifest;\n    }\n  }\n  assign(\"manifest\", manifest);\n  // Imperative escape hatches chain forward (acquisition order); teardown chains\n  // in reverse (LIFO), so resources release in the inverse of acquisition.\n  const hasActivates = blueprints.some((blueprint) => blueprint.activate);\n  assign(\n    \"activate\",\n    hasActivates\n      ? async (api: ExtensionApi): Promise<void> => {\n          for (const blueprint of blueprints) {\n            if (blueprint.activate) {\n              await blueprint.activate(api);\n            }\n          }\n        }\n      : undefined,\n  );\n  const hasDeactivates = blueprints.some((blueprint) => blueprint.deactivate);\n  assign(\n    \"deactivate\",\n    hasDeactivates\n      ? async (): Promise<void> => {\n          // Teardown is best-effort across modules: a throwing `deactivate` must\n          // not strand a later module's cleanup, so every hook runs (in reverse,\n          // LIFO) and failures are surfaced after cleanup completes.\n          const errors: unknown[] = [];\n          for (const blueprint of [...blueprints].reverse()) {\n            if (!blueprint.deactivate) {\n              continue;\n            }\n            try {\n              await blueprint.deactivate();\n            } catch (error) {\n              errors.push(error);\n            }\n          }\n          if (errors.length > 0) {\n            if (errors.length > 1) {\n              throw new AggregateError(errors, \"Multiple extension blueprint deactivate hooks failed.\");\n            }\n            throw errors[0];\n          }\n        }\n      : undefined,\n  );\n  return merged;\n}\n\n/**\n * Blueprint registration fields whose presence implies a capability, paired with\n * the capability each grants. Mirrors `EXTENSION_CAPABILITY_REGISTRATION_SURFACES`\n * so a blueprint's derived capabilities exactly match what the loader enforces\n * when {@link composeExtension}'s generated `activate` calls `api.register*`.\n *\n * `hooks` is handled separately (it is a nested object, not an array/record of\n * registrations) and so is intentionally absent from this table.\n */\nconst BLUEPRINT_FIELD_CAPABILITIES: ReadonlyArray<readonly [BlueprintRegistrationField, ExtensionCapability]> = [\n  [\"commands\", \"commands\"],\n  [\"commandOverrides\", \"commands\"],\n  [\"flags\", \"schema\"],\n  [\"itemTypes\", \"schema\"],\n  [\"itemFields\", \"schema\"],\n  [\"migrations\", \"schema\"],\n  [\"profiles\", \"schema\"],\n  [\"parsers\", \"parser\"],\n  [\"renderers\", \"renderers\"],\n  [\"services\", \"services\"],\n  [\"preflights\", \"preflight\"],\n  [\"searchProviders\", \"search\"],\n  [\"vectorStoreAdapters\", \"search\"],\n  [\"importers\", \"importers\"],\n  [\"exporters\", \"importers\"],\n];\n\ntype BlueprintRegistrationField =\n  | \"commands\"\n  | \"commandOverrides\"\n  | \"flags\"\n  | \"parsers\"\n  | \"renderers\"\n  | \"services\"\n  | \"preflights\"\n  | \"itemTypes\"\n  | \"itemFields\"\n  | \"migrations\"\n  | \"profiles\"\n  | \"searchProviders\"\n  | \"vectorStoreAdapters\"\n  | \"importers\"\n  | \"exporters\";\n\nfunction hasEntries(value: readonly unknown[] | Record<string, unknown> | null | undefined): boolean {\n  // `!value` treats both `null` and `undefined` as \"no entries\", so an untyped\n  // JavaScript author cannot crash capability derivation with an explicit null\n  // field — `Object.keys(null)` would otherwise throw.\n  if (!value) {\n    return false;\n  }\n  if (Array.isArray(value)) {\n    return value.length > 0;\n  }\n  return Object.keys(value).length > 0;\n}\n\n/**\n * Compute the minimal least-privilege capability set a {@link ExtensionBlueprint}\n * exercises, sorted and de-duplicated.\n *\n * Use it to author `manifest.json` `capabilities` exactly — declaring nothing the\n * extension does not use and nothing it does. It is the author-time inverse of\n * the runtime `reconcileExtensionCapabilityUsage` reconciliation: derive the set\n * here before activation rather than detecting drift after it. A blueprint with\n * no registration surfaces returns an empty array.\n */\nexport function deriveExtensionCapabilities(blueprint: ExtensionBlueprint): ExtensionCapability[] {\n  const capabilities = new Set<ExtensionCapability>();\n  for (const [field, capability] of BLUEPRINT_FIELD_CAPABILITIES) {\n    if (hasEntries(blueprint[field])) {\n      capabilities.add(capability);\n    }\n  }\n  // A command definition carrying its own inline `flags` registers them through\n  // `registerCommand`, which asserts the `schema` capability independently of the\n  // top-level `flags` record. Mirror that here so the derived set still matches\n  // what activation enforces when a command declares flags inline and the\n  // blueprint has no separate `flags` field. `!== undefined` (not a truthiness or\n  // length check) matches the loader's exact guard, including an empty inline array.\n  if ((blueprint.commands ?? []).filter(isPresent).some((command) => command.flags !== undefined)) {\n    capabilities.add(\"schema\");\n  }\n  // `registerImporter`/`registerExporter` with `options.flags` register flag\n  // metadata through the same surface as `registerFlags`, asserting the `schema`\n  // capability on top of `importers` (loader `applyImportExportCommandMetadata`).\n  // Mirror that guard so a flag-bearing importer/exporter derives `schema` too —\n  // otherwise a least-privilege manifest synthesized from the blueprint would\n  // under-grant `schema` and fail activation. `!== undefined` matches the loader's\n  // exact `options.flags` guard, including an empty flag array. `entry?.` keeps a\n  // malformed null array entry (from an untyped `.js`/JSON boundary) from crashing\n  // derivation, consistent with the null-field robustness above.\n  const importExportEntries = [...(blueprint.importers ?? []), ...(blueprint.exporters ?? [])].filter(isPresent);\n  if (importExportEntries.some((entry) => entry?.options?.flags !== undefined)) {\n    capabilities.add(\"schema\");\n  }\n  // Importers/exporters always synthesize command handlers (`<name> import` /\n  // `<name> export`), so runtime capability summaries attribute them to the\n  // commands surface as well as the importers surface. Keep the author-time\n  // capability preview aligned with describeExtensionActivation.\n  if (importExportEntries.some((entry) => typeof entry === \"object\")) {\n    capabilities.add(\"commands\");\n  }\n  // `?? {}` keeps an explicit `hooks: null` from throwing, mirroring composeExtension.\n  const hooks: ExtensionBlueprintHooks = blueprint.hooks ?? {};\n  if ([hooks.beforeCommand, hooks.afterCommand, hooks.onWrite, hooks.onRead, hooks.onIndex].some(hasEntries)) {\n    capabilities.add(\"hooks\");\n  }\n  return [...capabilities].sort((left, right) => left.localeCompare(right));\n}\n\n/**\n * Blueprint hook fields paired with the lifecycle kind each registers, ordered to\n * match `ExtensionActivationResult.hook_counts` (and the runtime\n * {@link ../core/extensions/activation-summary.js#describeExtensionActivation}'s\n * `hooks` ordering) so a blueprint summary's `hooks` list reads in the same\n * canonical order, not alphabetically.\n */\nconst BLUEPRINT_HOOK_FIELD_TO_KIND = [\n  [\"beforeCommand\", \"before_command\"],\n  [\"afterCommand\", \"after_command\"],\n  [\"onWrite\", \"on_write\"],\n  [\"onRead\", \"on_read\"],\n  [\"onIndex\", \"on_index\"],\n] as const satisfies ReadonlyArray<readonly [keyof ExtensionBlueprintHooks, string]>;\n\n/** De-duplicate and locale-sort a list of identifiers, mirroring the runtime summary. */\nfunction sortUnique<TValue extends string>(values: readonly TValue[]): TValue[] {\n  return [...new Set(values)].sort((left, right) => left.localeCompare(right));\n}\n\nfunction isPresent<TValue>(value: TValue | null | undefined): value is TValue {\n  return value !== null && value !== undefined;\n}\n\nfunction importerCommandPath(entry: ExtensionBlueprintImporter): string {\n  return normalizeCommandName(`${entry.name} import`);\n}\n\nfunction exporterCommandPath(entry: ExtensionBlueprintExporter): string {\n  return normalizeCommandName(`${entry.name} export`);\n}\n\nfunction collectBlueprintCommandPaths(\n  commands: CommandDefinition[],\n  importers: ExtensionBlueprintImporter[],\n  exporters: ExtensionBlueprintExporter[],\n): string[] {\n  return [\n    ...commands.map((command) => normalizeCommandName(command.name)),\n    ...importers.filter((entry) => entry.options !== undefined).map(importerCommandPath),\n    ...exporters.filter((entry) => entry.options !== undefined).map(exporterCommandPath),\n  ];\n}\n\nfunction collectBlueprintFlagCommands(\n  blueprint: ExtensionBlueprint,\n  commands: CommandDefinition[],\n  importers: ExtensionBlueprintImporter[],\n  exporters: ExtensionBlueprintExporter[],\n): string[] {\n  return [\n    ...Object.keys(blueprint.flags ?? {}).map((command) => normalizeCommandName(command)),\n    ...commands.filter((command) => command.flags !== undefined).map((command) => normalizeCommandName(command.name)),\n    ...importers.filter((entry) => entry.options?.flags !== undefined).map(importerCommandPath),\n    ...exporters.filter((entry) => entry.options?.flags !== undefined).map(exporterCommandPath),\n  ];\n}\n\nfunction collectBlueprintHookKinds(hooks: ExtensionBlueprintHooks): string[] {\n  return BLUEPRINT_HOOK_FIELD_TO_KIND.filter(([field]) => (hooks[field]?.length ?? 0) > 0).map(([, kind]) => kind);\n}\n\nfunction collectBlueprintSurfaceSummary(\n  blueprint: ExtensionBlueprint,\n  importers: ExtensionBlueprintImporter[],\n  exporters: ExtensionBlueprintExporter[],\n): Pick<\n  ExtensionActivationSummary,\n  | \"item_types\"\n  | \"item_fields\"\n  | \"migrations\"\n  | \"profiles\"\n  | \"importers\"\n  | \"exporters\"\n  | \"search_providers\"\n  | \"vector_store_adapters\"\n  | \"parser_overrides\"\n  | \"service_overrides\"\n  | \"renderer_overrides\"\n  | \"preflight_overrides\"\n> {\n  return {\n    item_types: sortUnique((blueprint.itemTypes ?? []).map((type) => type.name)),\n    item_fields: sortUnique((blueprint.itemFields ?? []).map((field) => field.name)),\n    // id-less migrations register but carry no identifier, so they are omitted —\n    // exactly as describeExtensionActivation drops them from its `migrations` list.\n    migrations: sortUnique(\n      (blueprint.migrations ?? []).flatMap((migration) => (typeof migration.id === \"string\" ? [migration.id] : [])),\n    ),\n    profiles: sortUnique((blueprint.profiles ?? []).map((profile) => profile.name)),\n    importers: sortUnique(importers.map((entry) => normalizeCommandName(entry.name))),\n    exporters: sortUnique(exporters.map((entry) => normalizeCommandName(entry.name))),\n    search_providers: sortUnique((blueprint.searchProviders ?? []).map((provider) => provider.name)),\n    vector_store_adapters: sortUnique((blueprint.vectorStoreAdapters ?? []).map((adapter) => adapter.name)),\n    parser_overrides: sortUnique(Object.keys(blueprint.parsers ?? {}).map((command) => normalizeCommandName(command))),\n    service_overrides: sortUnique(\n      Object.keys(blueprint.services ?? {}).map((service) => String(service).trim().toLowerCase() as ExtensionServiceName),\n    ),\n    renderer_overrides: sortUnique(\n      Object.keys(blueprint.renderers ?? {}).map((format) => String(format).trim().toLowerCase() as OutputRendererFormat),\n    ),\n    preflight_overrides: (blueprint.preflights ?? []).length,\n  };\n}\n\n/**\n * Compute, without activating, the exact {@link ExtensionActivationSummary} that\n * {@link composeExtension}'s generated `activate` would produce for a blueprint.\n *\n * This is the author-time inverse of the runtime\n * {@link ../core/extensions/activation-summary.js#describeExtensionActivation}:\n * the runtime verb walks an *activated* registry, while this one reads the\n * declarative {@link ExtensionBlueprint} data directly, so an author or agent can\n * preview the full named surface map (commands, overrides, handlers, hooks, item\n * types/fields, importers/exporters, search/vector adapters, parser/service/\n * renderer overrides, flag-target commands, and the preflight count) with no\n * loading, activation, or side effects. It is to the named surfaces what\n * {@link deriveExtensionCapabilities} is to the capability set.\n *\n * Fidelity is by construction: command paths are normalized with the same\n * `normalizeCommandName` the loader applies, and importer/exporter handler paths\n * are synthesized as `normalizeCommandName(\"<name> import|export\")`, exactly as\n * `registerImporter`/`registerExporter` do. A parity test pins this output equal\n * to `describeExtensionActivation` over the same composed-and-activated blueprint.\n *\n * The one surface it cannot reflect is the blueprint's optional imperative\n * `activate` escape hatch — arbitrary code a static reader cannot inspect. A\n * blueprint that registers everything through that hatch summarizes as empty.\n */\nexport function describeExtensionBlueprint(blueprint: ExtensionBlueprint): ExtensionActivationSummary {\n  const commands = (blueprint.commands ?? []).filter(isPresent);\n  const importers = (blueprint.importers ?? []).filter(isPresent);\n  const exporters = (blueprint.exporters ?? []).filter(isPresent);\n  const importerPaths = importers.map(importerCommandPath);\n  const exporterPaths = exporters.map(exporterCommandPath);\n  const commandPaths = collectBlueprintCommandPaths(commands, importers, exporters);\n  // A command definition with inline `flags` registers a flag target under its own\n  // path in addition to any top-level `flags` record. Import/export options with\n  // `flags` register through the same runtime metadata path, so union all sources.\n  const flagCommands = collectBlueprintFlagCommands(blueprint, commands, importers, exporters);\n  const hooks: ExtensionBlueprintHooks = blueprint.hooks ?? {};\n  const surfaces = collectBlueprintSurfaceSummary(blueprint, importers, exporters);\n\n  return {\n    capabilities: deriveExtensionCapabilities(blueprint),\n    commands: sortUnique(commandPaths),\n    command_overrides: sortUnique(Object.keys(blueprint.commandOverrides ?? {}).map((command) => normalizeCommandName(command))),\n    // command_handlers is a superset of commands that also carries the synthesized\n    // importer/exporter command paths, but never the override-only paths.\n    command_handlers: sortUnique([...commandPaths, ...importerPaths, ...exporterPaths]),\n    hooks: collectBlueprintHookKinds(hooks),\n    flag_commands: sortUnique(flagCommands),\n    ...surfaces,\n  };\n}\n\n/**\n * The blueprint registration fields a lint flags as a dead \"empty surface\" when\n * present but empty. Mirrors {@link BlueprintRegistrationField} so adding a new\n * registration surface forces a decision here too; `hooks` is handled separately\n * because it is a nested object rather than an array/record of registrations.\n */\nconst BLUEPRINT_LINTABLE_SURFACE_FIELDS = [\n  \"commands\",\n  \"commandOverrides\",\n  \"flags\",\n  \"parsers\",\n  \"renderers\",\n  \"services\",\n  \"preflights\",\n  \"itemTypes\",\n  \"itemFields\",\n  \"migrations\",\n  \"profiles\",\n  \"searchProviders\",\n  \"vectorStoreAdapters\",\n  \"importers\",\n  \"exporters\",\n] as const satisfies ReadonlyArray<BlueprintRegistrationField>;\n\n/** Severity of an {@link ExtensionBlueprintLintFinding}: a hard `error` (activation will fail) or an advisory `warning`. */\nexport type ExtensionBlueprintLintSeverity = \"error\" | \"warning\";\n\n/**\n * Machine-readable kind of an {@link ExtensionBlueprintLintFinding}.\n *\n * - `capability_undeclared` (error): a surface exercises a capability the declared\n *   set omits; the loader throws `extension_capability_missing` at activation.\n * - `capability_unused` (warning): a declared capability no surface exercises; the\n *   runtime equivalent is the `pm package doctor` `extension_capability_unused` note.\n * - `duplicate_command` (warning): the same normalized command path is declared\n *   more than once in `commands`; the later registration shadows the earlier.\n * - `command_override_conflict` (warning): a path is declared as both a fresh\n *   command definition and a command override.\n * - `empty_surface` (warning): a registration field is present but contributes\n *   nothing — a dead declaration.\n * - `manifest_capabilities_absent` (warning): the blueprint exercises capabilities\n *   but offers no declared set to reconcile against.\n */\nexport type ExtensionBlueprintLintCode =\n  | \"capability_undeclared\"\n  | \"capability_unused\"\n  | \"duplicate_command\"\n  | \"command_override_conflict\"\n  | \"empty_surface\"\n  | \"manifest_capabilities_absent\";\n\n/**\n * A single author-time issue {@link lintExtensionBlueprint} found in a blueprint.\n */\nexport interface ExtensionBlueprintLintFinding {\n  /** The machine-readable {@link ExtensionBlueprintLintCode} for programmatic handling. */\n  code: ExtensionBlueprintLintCode;\n  /** Whether the finding blocks activation (`error`) or is advisory (`warning`). */\n  severity: ExtensionBlueprintLintSeverity;\n  /** Human-readable explanation, including the suggested fix. */\n  message: string;\n  /** The capability involved, for capability-drift findings. */\n  capability?: ExtensionCapability;\n  /** The normalized command path involved, for command findings. */\n  command?: string;\n  /** The blueprint field involved, for `empty_surface` findings. */\n  field?: string;\n}\n\n/**\n * Options for {@link lintExtensionBlueprint} and {@link ../sdk/testing.js#assertExtensionBlueprint}.\n */\nexport interface LintExtensionBlueprintOptions {\n  /**\n   * The capabilities the package's `manifest.json` declares (or will), used to\n   * reconcile against the surfaces the blueprint exercises. Overrides\n   * `blueprint.manifest.capabilities` when both are present. Omit both to lint\n   * without a capability reconciliation (only the structural checks run).\n   */\n  declaredCapabilities?: readonly string[];\n}\n\n/**\n * The structured result of {@link lintExtensionBlueprint}.\n */\nexport interface ExtensionBlueprintLintResult {\n  /** `true` when no `error`-severity finding is present (warnings still allow activation). */\n  ok: boolean;\n  /** Every finding, in detection order (capability drift, duplicates, conflicts, empty surfaces). */\n  findings: ExtensionBlueprintLintFinding[];\n  /** The least-privilege capability set the blueprint exercises (from {@link deriveExtensionCapabilities}). */\n  used: ExtensionCapability[];\n  /** The normalized declared capability set reconciled against, or `null` when none was provided. */\n  declared: ExtensionCapability[] | null;\n}\n\n/** Normalize a raw declared-capability list to known capabilities only (legacy-alias aware, sorted, de-duplicated). */\nfunction normalizeDeclaredCapabilities(capabilities: readonly string[]): ExtensionCapability[] {\n  const known = new Set<ExtensionCapability>();\n  for (const capability of capabilities) {\n    // Resolve a legacy alias (e.g. migration/validation → schema) exactly as the\n    // loader does before reconciliation — the author's raw manifest input has not\n    // been loader-normalized yet, so failing to resolve it here would misreport an\n    // alias-satisfied capability as undeclared. Fall back to a canonical known\n    // name; unknown capabilities are a separate diagnostic and are dropped so a\n    // typo is not misreported as \"unused\".\n    const normalized = resolveLegacyExtensionCapabilityAlias(capability) ?? normalizeKnownExtensionCapability(capability);\n    if (normalized !== null) {\n      known.add(normalized);\n    }\n  }\n  return [...known].sort((left, right) => left.localeCompare(right));\n}\n\n/**\n * Reconcile a blueprint's exercised capabilities against its declared set: a\n * used-but-undeclared capability is an `error` (activation throws\n * `extension_capability_missing`), a declared-but-unused one a `warning`, and a\n * wholly absent declared set (`declared === null`) yields the single\n * `manifest_capabilities_absent` adoption hint.\n */\nfunction collectBlueprintCapabilityFindings(\n  used: ExtensionCapability[],\n  declared: ExtensionCapability[] | null,\n): ExtensionBlueprintLintFinding[] {\n  const findings: ExtensionBlueprintLintFinding[] = [];\n  if (declared === null) {\n    if (used.length > 0) {\n      findings.push({\n        code: \"manifest_capabilities_absent\",\n        severity: \"warning\",\n        message: `Blueprint exercises ${used.length === 1 ? \"capability\" : \"capabilities\"} [${used.join(\", \")}] but declares none; set capabilities to deriveExtensionCapabilities(blueprint) so the manifest grant matches.`,\n      });\n    }\n    return findings;\n  }\n  const declaredSet = new Set(declared);\n  const usedSet = new Set(used);\n  for (const capability of used) {\n    if (!declaredSet.has(capability)) {\n      findings.push({\n        code: \"capability_undeclared\",\n        severity: \"error\",\n        message: `Blueprint exercises capability \"${capability}\" but it is absent from the declared capabilities; activation throws extension_capability_missing — add \"${capability}\" to the manifest capabilities.`,\n        capability,\n      });\n    }\n  }\n  for (const capability of declared) {\n    if (!usedSet.has(capability)) {\n      findings.push({\n        code: \"capability_unused\",\n        severity: \"warning\",\n        message: `Capability \"${capability}\" is declared but no blueprint surface exercises it; drop it to keep the manifest least-privilege (pm package doctor reports this as extension_capability_unused).`,\n        capability,\n      });\n    }\n  }\n  return findings;\n}\n\n/**\n * Detect structural command footguns in a blueprint: a command path declared\n * more than once (`duplicate_command`, the later registration shadowing the\n * earlier at dispatch) and a path declared both as a fresh command definition\n * and as an override (`command_override_conflict`).\n */\nfunction collectBlueprintCommandFindings(blueprint: ExtensionBlueprint): ExtensionBlueprintLintFinding[] {\n  const findings: ExtensionBlueprintLintFinding[] = [];\n  const commandPathCounts = new Map<string, number>();\n  for (const command of blueprint.commands ?? []) {\n    const path = normalizeCommandName(command.name);\n    commandPathCounts.set(path, (commandPathCounts.get(path) ?? 0) + 1);\n  }\n  for (const [path, count] of commandPathCounts) {\n    if (count > 1) {\n      findings.push({\n        code: \"duplicate_command\",\n        severity: \"warning\",\n        message: `Command \"${path}\" is declared ${count} times in commands; the later registration shadows the earlier one at dispatch.`,\n        command: path,\n      });\n    }\n  }\n  const overridePaths = new Set(\n    Object.keys(blueprint.commandOverrides ?? {}).map((command) => normalizeCommandName(command)),\n  );\n  for (const path of commandPathCounts.keys()) {\n    if (overridePaths.has(path)) {\n      findings.push({\n        code: \"command_override_conflict\",\n        severity: \"warning\",\n        message: `Command \"${path}\" is declared both as a new command definition and as a command override; register one or the other.`,\n        command: path,\n      });\n    }\n  }\n  return findings;\n}\n\n/**\n * Flag blueprint registration fields that are present but contribute nothing —\n * an empty array/record surface, or a `hooks` object registering no lifecycle\n * hook — each reported as an `empty_surface` warning (fields first, then hooks).\n */\nfunction collectBlueprintEmptySurfaceFindings(blueprint: ExtensionBlueprint): ExtensionBlueprintLintFinding[] {\n  const findings: ExtensionBlueprintLintFinding[] = [];\n  for (const field of BLUEPRINT_LINTABLE_SURFACE_FIELDS) {\n    if (field in blueprint && !hasEntries(blueprint[field])) {\n      findings.push({\n        code: \"empty_surface\",\n        severity: \"warning\",\n        message: `Blueprint field \"${field}\" is present but empty; remove it or populate it.`,\n        field,\n      });\n    }\n  }\n  if (\"hooks\" in blueprint) {\n    const hooks: ExtensionBlueprintHooks = blueprint.hooks ?? {};\n    const registersHook = [hooks.beforeCommand, hooks.afterCommand, hooks.onWrite, hooks.onRead, hooks.onIndex].some(\n      hasEntries,\n    );\n    if (!registersHook) {\n      findings.push({\n        code: \"empty_surface\",\n        severity: \"warning\",\n        message: `Blueprint field \"hooks\" is present but registers no lifecycle hooks; remove it or populate it.`,\n        field: \"hooks\",\n      });\n    }\n  }\n  return findings;\n}\n\n/**\n * Preflight a declarative {@link ExtensionBlueprint} at author time, returning the\n * structured issues that would otherwise only surface at activation.\n *\n * It is the author-time inverse of the runtime extension guardrails — pure data\n * analysis with no loading, activation, or side effects:\n *\n * - capability drift in both directions: a capability a surface exercises but the\n *   declared set omits is an `error` (the loader throws `extension_capability_missing`\n *   at activation); a declared capability no surface exercises is a `warning` (the\n *   author-time form of the `pm package doctor` `extension_capability_unused` note,\n *   making this the static inverse of `reconcileExtensionCapabilityUsage`).\n * - structural footguns: a command path declared twice (`duplicate_command`), a\n *   path declared as both a command and an override (`command_override_conflict`),\n *   and a registration field present but empty (`empty_surface`).\n *\n * The declared set is taken from `options.declaredCapabilities` or, failing that,\n * `blueprint.manifest.capabilities`; with neither, capability reconciliation is\n * skipped and a single `manifest_capabilities_absent` warning suggests adopting\n * {@link deriveExtensionCapabilities}. Like {@link describeExtensionBlueprint},\n * the imperative `activate` escape hatch is invisible to this static check. The\n * findings are assembled from the per-dimension collectors\n * ({@link collectBlueprintCapabilityFindings}, {@link collectBlueprintCommandFindings},\n * {@link collectBlueprintEmptySurfaceFindings}) in that detection order.\n */\nexport function lintExtensionBlueprint(\n  blueprint: ExtensionBlueprint,\n  options: LintExtensionBlueprintOptions = {},\n): ExtensionBlueprintLintResult {\n  const used = deriveExtensionCapabilities(blueprint);\n\n  // A non-array declared source (an untyped `.js` author's malformed manifest, or\n  // a missing field) is treated as \"no declared set\" rather than \"declares nothing\".\n  const declaredSource = options.declaredCapabilities ?? blueprint.manifest?.capabilities;\n  const declared = Array.isArray(declaredSource) ? normalizeDeclaredCapabilities(declaredSource) : null;\n\n  // Findings accumulate in detection order: capability drift, then command\n  // duplicates/conflicts, then empty surfaces.\n  const findings: ExtensionBlueprintLintFinding[] = [\n    ...collectBlueprintCapabilityFindings(used, declared),\n    ...collectBlueprintCommandFindings(blueprint),\n    ...collectBlueprintEmptySurfaceFindings(blueprint),\n  ];\n\n  return {\n    ok: findings.every((finding) => finding.severity !== \"error\"),\n    findings,\n    used,\n    declared,\n  };\n}\n\n/**\n * The author-supplied identity fields {@link synthesizeExtensionManifest} cannot\n * derive from a blueprint: every {@link ExtensionManifest} field except the\n * generated `capabilities`.\n *\n * The blueprint determines `capabilities` (the surfaces it registers) and nothing\n * else, so `name`/`version`/`entry`/`priority` and any optional metadata\n * (engines, permissions, provenance, version floors/ceilings, sandbox profile,\n * manifest version, activation, legacy aliases) are the author's to supply here.\n */\nexport interface SynthesizeExtensionManifestIdentity extends Omit<ExtensionManifest, \"capabilities\"> {\n  /**\n   * Extra capabilities to grant beyond the blueprint's derived set, for surfaces\n   * registered through the blueprint's imperative `activate` escape hatch that\n   * static derivation cannot see (e.g. a renderer wired in `activate`). Each is\n   * legacy-alias resolved and normalized like a declared manifest capability;\n   * unknown names are dropped (the synthesized manifest is validated at load).\n   */\n  additionalCapabilities?: readonly string[];\n}\n\n/**\n * Generate a complete, least-privilege {@link ExtensionManifest} from a\n * declarative {@link ExtensionBlueprint} and the author's identity fields.\n *\n * This is the *generate* verb that completes the declarative authoring loop\n * (`compose → derive → describe/lint → synthesize`). Where\n * {@link defineExtensionManifest} only *types* a hand-written manifest and\n * {@link deriveExtensionCapabilities} computes only the capability set, this\n * function assembles the whole manifest: it copies every author-supplied identity\n * field verbatim and fills `capabilities` with `deriveExtensionCapabilities`\n * unioned with any {@link SynthesizeExtensionManifestIdentity.additionalCapabilities | additionalCapabilities},\n * sorted and de-duplicated. The author writes the blueprint once and never\n * hand-syncs `manifest.capabilities` — declaring nothing the extension does not\n * use and nothing it does.\n *\n * It is a pure assembler: it neither validates the blueprint definitions (that\n * stays in `api.register*` at activation) nor the identity fields (the loader\n * validates the on-disk manifest). Pair it with\n * {@link ../sdk/testing.js#assertExtensionManifestMatchesBlueprint} to guard a\n * hand-maintained `manifest.json` against drift in CI.\n */\nexport function synthesizeExtensionManifest(\n  blueprint: ExtensionBlueprint,\n  identity: SynthesizeExtensionManifestIdentity,\n): ExtensionManifest {\n  const { additionalCapabilities, ...manifestIdentity } = identity;\n  // `Array.isArray` keeps a non-array value (or an omitted field) crossing an\n  // untyped boundary from crashing the spread, mirroring the rest of the SDK.\n  const extra = Array.isArray(additionalCapabilities) ? normalizeDeclaredCapabilities(additionalCapabilities) : [];\n  const capabilities = [...new Set<ExtensionCapability>([...deriveExtensionCapabilities(blueprint), ...extra])].sort(\n    (left, right) => left.localeCompare(right),\n  );\n  return { ...manifestIdentity, capabilities };\n}\n\n/**\n * The two generated halves of a shippable extension package, returned by\n * {@link composeExtensionPackage}.\n */\nexport interface ExtensionPackage {\n  /**\n   * The runtime {@link ExtensionModule} to export as the package entry's default\n   * export. Its `manifest` mirror is set to the same {@link ExtensionPackage.manifest}\n   * object, so the in-module metadata and the on-disk manifest never diverge.\n   */\n  module: ExtensionModule;\n  /**\n   * The complete least-privilege {@link ExtensionManifest} to write as the\n   * package's `manifest.json`, with `capabilities` derived from the blueprint.\n   */\n  manifest: ExtensionManifest;\n}\n\n/**\n * Assemble both halves of a shippable extension package from one declarative\n * {@link ExtensionBlueprint} and the author's identity fields — the author-once\n * capstone of the declarative loop.\n *\n * Where {@link composeExtension} produces only the runtime module and\n * {@link synthesizeExtensionManifest} produces only the manifest, this unifies\n * them: it synthesizes the complete least-privilege manifest from the blueprint\n * and identity, then composes the module with that synthesized manifest set as its\n * authoritative in-module `manifest` mirror. Both halves are therefore generated\n * from a single source and cannot drift — the module's `manifest` is the very\n * object returned as `manifest`. Export `module` as the package entry's default\n * export and write `manifest` as `manifest.json`.\n *\n * It is a pure assembler with no validation, loading, or filesystem access,\n * exactly like the two functions it composes; pair it with\n * {@link preflightExtension} (or {@link ../sdk/testing.js#assertExtensionPreflight})\n * for the author-time verify step. Use {@link mergeExtensionBlueprints} first to\n * assemble the blueprint modularly, then this to ship it.\n */\nexport function composeExtensionPackage(\n  blueprint: ExtensionBlueprint,\n  identity: SynthesizeExtensionManifestIdentity,\n): ExtensionPackage {\n  const manifest = synthesizeExtensionManifest(blueprint, identity);\n  const module = composeExtension({ ...blueprint, manifest });\n  return { module, manifest };\n}\n\n/**\n * The target a {@link checkExtensionManifestCompatibility} call evaluates a\n * manifest's version bounds against.\n */\nexport interface ExtensionManifestCompatibilityTarget {\n  /**\n   * The pm CLI version to check the manifest against, e.g. the running CLI's\n   * `version` or a version floor a package commits to supporting. Plain\n   * dotted-numeric (`2026.6.23`) or `v`-prefixed values are compared; anything\n   * uninterpretable yields an `unchecked` finding rather than a false verdict.\n   */\n  pmVersion: string;\n  /**\n   * How a `pm_max_version` overrun is treated, mirroring the runtime\n   * `extensions.policy.pm_max_version_exceeded_mode`. `\"block\"` (the default)\n   * reports an exceeded upper bound as a blocking incompatibility; `\"warn\"`\n   * reports it as a non-blocking advisory, matching an operator who relaxed the\n   * gate during a CLI upgrade window.\n   */\n  pmMaxVersionExceededMode?: PmMaxVersionExceededMode;\n}\n\n/**\n * The manifest fields {@link checkExtensionManifestCompatibility} evaluates.\n *\n * Values are intentionally `unknown` rather than `string` so an author can\n * preflight the same malformed blank/non-string bounds (e.g. read from a JSON\n * manifest) the loader's manifest parser rejects as `extension_manifest_invalid`.\n */\nexport interface ExtensionManifestCompatibilityManifest {\n  /** Inclusive lower pm CLI version bound from `manifest.json`. */\n  pm_min_version?: unknown;\n  /** Inclusive upper pm CLI version bound from `manifest.json`. */\n  pm_max_version?: unknown;\n}\n\n/**\n * The machine-readable kind of an {@link ExtensionManifestCompatibilityFinding},\n * one per `<bound>_<outcome>` the loader can reach. Each mirrors a loader\n * `extension_pm_*_version_*` warning: `*_invalid`/`*_unmet`/`*_exceeded` block the\n * load, while `*_unchecked`/`*_exceeded_warn` are advisory (the extension still\n * loads).\n */\nexport type ExtensionManifestCompatibilityCode =\n  | \"pm_min_version_invalid\"\n  | \"pm_min_version_unchecked\"\n  | \"pm_min_version_unmet\"\n  | \"pm_max_version_invalid\"\n  | \"pm_max_version_unchecked\"\n  | \"pm_max_version_exceeded\"\n  | \"pm_max_version_exceeded_warn\";\n\n/**\n * A single version-bound issue {@link checkExtensionManifestCompatibility} found\n * when evaluating a manifest against a target pm version.\n */\nexport interface ExtensionManifestCompatibilityFinding {\n  /** The machine-readable {@link ExtensionManifestCompatibilityCode} for programmatic handling. */\n  code: ExtensionManifestCompatibilityCode;\n  /** `error` when the bound blocks the load against the target version, `warning` when it is advisory. */\n  severity: \"error\" | \"warning\";\n  /** Which manifest bound produced the finding. */\n  constraint: PmVersionBoundKind;\n  /** The declared bound value, verbatim. */\n  required: string;\n  /** The target pm version the bound was evaluated against. */\n  current: string;\n  /** Human-readable explanation of the outcome and its effect on loading. */\n  message: string;\n}\n\n/**\n * The structured result of {@link checkExtensionManifestCompatibility}.\n */\nexport interface ExtensionManifestCompatibilityResult {\n  /** `true` when no `error`-severity finding blocks the load against the target version. */\n  compatible: boolean;\n  /** Every bound finding, lower bound before upper bound; empty when both bounds are absent or satisfied. */\n  findings: ExtensionManifestCompatibilityFinding[];\n  /** The target pm version the manifest was checked against, echoed back for messaging. */\n  pmVersion: string;\n}\n\n/** Map a non-trivial bound evaluation to a compatibility finding, or `null` when the bound is absent or satisfied. */\nfunction toCompatibilityFinding(\n  evaluation: PmVersionBoundEvaluation,\n  pmVersion: string,\n): ExtensionManifestCompatibilityFinding | null {\n  if (evaluation.status === \"absent\" || evaluation.status === \"ok\") {\n    return null;\n  }\n  const code = `${evaluation.kind}_${evaluation.status}` as ExtensionManifestCompatibilityCode;\n  let message: string;\n  switch (code) {\n    case \"pm_min_version_invalid\":\n      message = `pm_min_version \"${evaluation.required}\" is not a valid version; the extension is treated as incompatible and the loader skips it.`;\n      break;\n    case \"pm_min_version_unchecked\":\n      message = `pm_min_version \"${evaluation.required}\" could not be compared against pm ${pmVersion}; compatibility is unverified.`;\n      break;\n    case \"pm_min_version_unmet\":\n      message = `Requires pm >= ${evaluation.required} but the target is pm ${pmVersion}; the loader skips the extension.`;\n      break;\n    case \"pm_max_version_invalid\":\n      message = `pm_max_version \"${evaluation.required}\" is not a valid inclusive upper bound (version ranges are not allowed); the extension is treated as incompatible and the loader skips it.`;\n      break;\n    case \"pm_max_version_unchecked\":\n      message = `pm_max_version \"${evaluation.required}\" could not be compared against pm ${pmVersion}; compatibility is unverified.`;\n      break;\n    case \"pm_max_version_exceeded\":\n      message = `Allows pm <= ${evaluation.required} but the target is pm ${pmVersion}; the loader skips the extension.`;\n      break;\n    case \"pm_max_version_exceeded_warn\":\n      message = `Target pm ${pmVersion} is newer than pm_max_version ${evaluation.required}, but the \"warn\" exceeded mode lets it load with a warning.`;\n      break;\n  }\n  return {\n    code,\n    severity: evaluation.allowed ? \"warning\" : \"error\",\n    constraint: evaluation.kind,\n    required: evaluation.required,\n    current: pmVersion,\n    message,\n  };\n}\n\n/**\n * Check, without loading anything, whether an extension manifest's declared\n * version bounds permit it to load on a given pm CLI version.\n *\n * This is the author-time inverse of the loader's runtime version gate: where the\n * loader resolves the *installed* CLI version (asynchronously, from `package.json`)\n * and emits `extension_pm_*_version_*` warnings, this pure synchronous function\n * takes the {@link ExtensionManifestCompatibilityTarget.pmVersion | target version}\n * the author supplies and returns structured findings. Both share the\n * {@link ../core/extensions/version-compat.js | version-compat core}, so the\n * author-time verdict and the runtime decision agree by construction — a package\n * author can pin a CI test to the pm version they support and catch a too-tight\n * `pm_min_version`, a malformed `pm_max_version`, or an upper bound a newer CLI\n * would exceed, long before publishing.\n *\n * `compatible` is `true` only when no bound blocks the load (`*_invalid`,\n * `*_unmet`, and a `block`-mode `*_exceeded`); `*_unchecked` (an uninterpretable\n * bound or target) and a `warn`-mode `*_exceeded_warn` are advisory `warning`\n * findings that still load. Pair it with\n * {@link ../sdk/testing.js#assertExtensionManifestCompatible} to fail CI on a\n * blocking incompatibility.\n */\nexport function checkExtensionManifestCompatibility(\n  manifest: ExtensionManifestCompatibilityManifest,\n  target: ExtensionManifestCompatibilityTarget,\n): ExtensionManifestCompatibilityResult {\n  const minEvaluation = evaluatePmMinVersionBound(manifest.pm_min_version, target.pmVersion);\n  const maxEvaluation = evaluatePmMaxVersionBound(\n    manifest.pm_max_version,\n    target.pmVersion,\n    target.pmMaxVersionExceededMode ?? \"block\",\n  );\n  const findings: ExtensionManifestCompatibilityFinding[] = [];\n  const minFinding = toCompatibilityFinding(minEvaluation, target.pmVersion);\n  if (minFinding !== null) {\n    findings.push(minFinding);\n  }\n  const maxFinding = toCompatibilityFinding(maxEvaluation, target.pmVersion);\n  if (maxFinding !== null) {\n    findings.push(maxFinding);\n  }\n  return {\n    compatible: minEvaluation.allowed && maxEvaluation.allowed,\n    findings,\n    pmVersion: target.pmVersion,\n  };\n}\n\n/**\n * The lint codes whose verdict depends on the *declared* capability set rather\n * than the blueprint's structure. {@link preflightExtension} drops these from its\n * consolidated view when it synthesizes the manifest from an `identity` without an\n * explicit declared set, because the synthesized manifest — not the blueprint's\n * stale in-module `manifest` mirror — is what the package ships, so a drift against\n * the mirror is a false positive. Structural codes (`duplicate_command`,\n * `command_override_conflict`, `empty_surface`) are never suppressed.\n */\nconst CAPABILITY_DRIFT_LINT_CODES = new Set<ExtensionBlueprintLintCode>([\n  \"capability_undeclared\",\n  \"capability_unused\",\n  \"manifest_capabilities_absent\",\n]);\n\n/**\n * Options for {@link preflightExtension} and\n * {@link ../sdk/testing.js#assertExtensionPreflight}. Every field is optional:\n * each one a check enables, so an author opts into exactly the stages whose\n * inputs they can supply.\n */\nexport interface PreflightExtensionOptions {\n  /**\n   * The author-supplied identity fields the blueprint cannot determine\n   * (`name`/`version`/`entry`/`priority`, version bounds, etc.). Provide them to\n   * have preflight {@link synthesizeExtensionManifest | synthesize} the complete\n   * least-privilege manifest and include it in the report; the synthesized\n   * version bounds then feed the {@link PreflightExtensionOptions.target | target}\n   * compatibility check. Omit to skip manifest synthesis.\n   */\n  identity?: SynthesizeExtensionManifestIdentity;\n  /**\n   * The pm CLI version (and optional max-version overrun mode) to evaluate the\n   * manifest's `pm_min_version`/`pm_max_version` bounds against. Provide it to run\n   * {@link checkExtensionManifestCompatibility} against the synthesized manifest\n   * (or, absent an `identity`, the blueprint's in-module `manifest` mirror). Omit\n   * to skip the version-compatibility check.\n   */\n  target?: ExtensionManifestCompatibilityTarget;\n  /**\n   * The capabilities the package's `manifest.json` declares, reconciled against\n   * the surfaces the blueprint exercises. Passed straight to\n   * {@link lintExtensionBlueprint}; when omitted it falls back to\n   * `blueprint.manifest.capabilities`, so the blueprint's in-module mirror is\n   * linted by default.\n   */\n  declaredCapabilities?: readonly string[];\n}\n\n/** Which preflight stage produced an {@link ExtensionPreflightFinding}. */\nexport type ExtensionPreflightFindingSource = \"blueprint\" | \"compatibility\";\n\n/**\n * A single finding in an {@link ExtensionPreflightReport}, flattened from one of\n * the underlying stages and tagged with its {@link ExtensionPreflightFindingSource}\n * so a consolidated report stays traceable to the check that raised it.\n */\nexport interface ExtensionPreflightFinding {\n  /** The stage that produced the finding: blueprint lint or version compatibility. */\n  source: ExtensionPreflightFindingSource;\n  /** Whether the finding blocks publish/activation (`error`) or is advisory (`warning`). */\n  severity: ExtensionBlueprintLintSeverity;\n  /** The underlying stage's machine-readable code, for programmatic handling. */\n  code: ExtensionBlueprintLintCode | ExtensionManifestCompatibilityCode;\n  /** The underlying stage's human-readable explanation, verbatim. */\n  message: string;\n}\n\n/**\n * The consolidated result of {@link preflightExtension}: every author-time stage's\n * structured output plus a flattened, source-tagged finding list.\n */\nexport interface ExtensionPreflightReport {\n  /** `true` when no `error`-severity finding appears across any stage (warnings still pass). */\n  ok: boolean;\n  /** The least-privilege capability set the blueprint exercises (from {@link deriveExtensionCapabilities}). */\n  capabilities: ExtensionCapability[];\n  /** The full {@link lintExtensionBlueprint} result (structural + capability-drift findings). */\n  blueprint: ExtensionBlueprintLintResult;\n  /** The manifest synthesized from `options.identity`, or `null` when no identity was supplied. */\n  manifest: ExtensionManifest | null;\n  /** The {@link checkExtensionManifestCompatibility} result, or `null` when no `options.target` was supplied. */\n  compatibility: ExtensionManifestCompatibilityResult | null;\n  /**\n   * Every finding from all stages, blueprint-lint findings before compatibility\n   * findings, each tagged by `source`. This is the consolidated, curated view: when\n   * `options.identity` synthesizes the manifest without an explicit\n   * `declaredCapabilities` set, capability-drift findings the lint raised against the\n   * blueprint's now-superseded in-module `manifest` mirror are omitted here (the raw\n   * `blueprint` result still carries them).\n   */\n  findings: ExtensionPreflightFinding[];\n}\n\n/**\n * Preflight a declarative {@link ExtensionBlueprint} through every author-time\n * check in one call, returning a single consolidated {@link ExtensionPreflightReport}.\n *\n * This is the author-time capstone — the static analog of\n * {@link ../sdk/testing.js#createExtensionTestHarness}, which unified the\n * runtime-test helpers. Instead of chaining {@link lintExtensionBlueprint},\n * {@link synthesizeExtensionManifest}, and {@link checkExtensionManifestCompatibility}\n * (and reconciling their separate results) before publishing a package, an author\n * runs `preflightExtension(blueprint, { identity, target })` and reads one report:\n *\n * - the blueprint is always linted (structural footguns + capability drift);\n * - when `options.identity` is given, the complete least-privilege manifest is\n *   synthesized and returned, so the author never hand-syncs `capabilities`;\n * - when `options.target` is given, the synthesized manifest's version bounds\n *   (or, absent an identity, the blueprint's in-module `manifest` mirror) are\n *   checked against that pm version.\n *\n * It is pure and side-effect-free — no loading, activation, or filesystem access,\n * exactly like the stages it composes — so it is safe in any author-time or CI\n * context. The per-stage structured results are exposed unmodified\n * (`report.blueprint`/`manifest`/`compatibility`) alongside the flattened,\n * source-tagged `report.findings`; `report.ok` is `false` if any stage produced an\n * `error`-severity finding. The flattened `findings` are curated for the author-once\n * flow: once an `identity` synthesizes the manifest (and no explicit\n * `declaredCapabilities` was pinned), the synthesized manifest — not the blueprint's\n * in-module `manifest` mirror — is what ships, so capability-drift findings the lint\n * raised against that mirror are false positives and are omitted from\n * `report.findings` (the raw `report.blueprint` result still reports them). Pair it\n * with {@link ../sdk/testing.js#assertExtensionPreflight} to fail CI in one line.\n */\nexport function preflightExtension(\n  blueprint: ExtensionBlueprint,\n  options: PreflightExtensionOptions = {},\n): ExtensionPreflightReport {\n  const blueprintResult = lintExtensionBlueprint(blueprint, { declaredCapabilities: options.declaredCapabilities });\n  const manifest = options.identity ? synthesizeExtensionManifest(blueprint, options.identity) : null;\n  // Compatibility evaluates the bounds the package will ship: the synthesized\n  // manifest when an identity drives generation, else the blueprint's in-module\n  // manifest mirror, else an empty manifest (no bounds → trivially compatible).\n  const compatibility = options.target\n    ? checkExtensionManifestCompatibility(manifest ?? blueprint.manifest ?? {}, options.target)\n    : null;\n  // When preflight synthesizes the manifest from an identity (and the caller did not\n  // pin an explicit declaredCapabilities set), the blueprint lint reconciled against\n  // the blueprint's in-module `manifest` mirror — which the synthesized manifest\n  // supersedes. Capability-drift findings against that stale mirror are false\n  // positives in the consolidated view (a missing capability would even flip `ok` to\n  // false though the synthesized manifest declares it), so drop them; structural\n  // findings are unaffected and the raw lint result on `report.blueprint` keeps all of\n  // them. An explicit declaredCapabilities set is a deliberate \"check exactly this\"\n  // request, so it is never suppressed.\n  const suppressCapabilityDrift = manifest !== null && options.declaredCapabilities === undefined;\n  const blueprintFindings = suppressCapabilityDrift\n    ? blueprintResult.findings.filter((finding) => !CAPABILITY_DRIFT_LINT_CODES.has(finding.code))\n    : blueprintResult.findings;\n  const findings: ExtensionPreflightFinding[] = [\n    ...blueprintFindings.map(\n      (finding): ExtensionPreflightFinding => ({\n        source: \"blueprint\",\n        severity: finding.severity,\n        code: finding.code,\n        message: finding.message,\n      }),\n    ),\n    ...(compatibility?.findings ?? []).map(\n      (finding): ExtensionPreflightFinding => ({\n        source: \"compatibility\",\n        severity: finding.severity,\n        code: finding.code,\n        message: finding.message,\n      }),\n    ),\n  ];\n  return {\n    ok: findings.every((finding) => finding.severity !== \"error\"),\n    capabilities: blueprintResult.used,\n    blueprint: blueprintResult,\n    manifest,\n    compatibility,\n    findings,\n  };\n}\n","/**\n * @module sdk/testing\n *\n * Defines public SDK APIs and package-author helpers for Testing.\n */\nimport type {\n  AfterCommandHookContext,\n  BeforeCommandHookContext,\n  CommandHandlerResult,\n  CommandOverrideContext,\n  CommandOverrideResult,\n  ExtensionActivationResult,\n  ExtensionCapability,\n  ExtensionCommandRegistry,\n  ExtensionDeactivationResult,\n  ExtensionGovernancePolicy,\n  ExtensionHookRegistry,\n  ExtensionLayer,\n  ExtensionLoadResult,\n  ExtensionManifest,\n  ExtensionParserRegistry,\n  ExtensionPreflightRegistry,\n  ExtensionRegistrationRegistry,\n  ExtensionRendererRegistry,\n  ExtensionServiceName,\n  ExtensionServiceRegistry,\n  FlagDefinition,\n  OnIndexHookContext,\n  OnReadHookContext,\n  OnWriteHookContext,\n  OutputRendererFormat,\n  ParserOverrideContext,\n  ParserOverrideResult,\n  PreflightOverrideContext,\n  PreflightOverrideResult,\n  RegisteredExtensionCommandDefinition,\n  RegisteredExtensionCommandOverride,\n  RegisteredExtensionExporter,\n  RegisteredExtensionFlagDefinitions,\n  RegisteredExtensionHook,\n  RegisteredExtensionImporter,\n  RegisteredExtensionParserOverride,\n  RegisteredExtensionPreflightOverride,\n  RegisteredExtensionProjectProfile,\n  RegisteredExtensionRendererOverride,\n  RegisteredExtensionSchemaFieldDefinitions,\n  RegisteredExtensionSchemaItemTypeDefinitions,\n  RegisteredExtensionSchemaMigrationDefinition,\n  RegisteredExtensionSearchProvider,\n  RegisteredExtensionServiceOverride,\n  RegisteredExtensionVectorStoreAdapter,\n  RendererOverrideContext,\n  RendererOverrideResult,\n  SchemaFieldDefinition,\n  SchemaItemTypeDefinition,\n  SchemaMigrationRunContext,\n  SearchProviderEmbedBatchContext,\n  SearchProviderEmbedContext,\n  SearchProviderQueryContext,\n  SearchProviderQueryExpansionContext,\n  SearchProviderQueryExpansionResult,\n  SearchProviderQueryResult,\n  SearchProviderRerankContext,\n  SearchProviderRerankResult,\n  ServiceOverrideContext,\n  ServiceOverrideResult,\n  VectorStoreDeleteContext,\n  VectorStoreQueryContext,\n  VectorStoreQueryHit,\n  VectorStoreUpsertContext,\n} from \"../core/extensions/loader.js\";\nimport {\n  activateExtensions,\n  deactivateExtensions,\n  runAfterCommandHooks,\n  runBeforeCommandHooks,\n  runCommandHandler,\n  runCommandOverride,\n  runOnIndexHooks,\n  runOnReadHooks,\n  runOnWriteHooks,\n  runParserOverride,\n  runPreflightOverride,\n  runRendererOverride,\n  runServiceOverride,\n} from \"../core/extensions/loader.js\";\nimport { createDefaultExtensionGovernancePolicy } from \"../core/extensions/extension-types.js\";\nimport {\n  getMigrationRuntimeDefinition,\n  resolveRegisteredSearchProvider,\n  resolveRegisteredVectorStoreAdapter,\n} from \"../core/extensions/runtime-registrations.js\";\nimport { collectUsedExtensionCapabilities } from \"../core/extensions/capability-usage.js\";\nimport { normalizeKnownExtensionCapability } from \"../core/extensions/extension-capability-aliases.js\";\nimport {\n  checkExtensionManifestCompatibility,\n  describeExtensionBlueprint,\n  lintExtensionBlueprint,\n  preflightExtension,\n} from \"./compose.js\";\nimport { describeExtensionActivation } from \"../core/extensions/activation-summary.js\";\nimport type {\n  DescribeExtensionActivationOptions,\n  ExtensionActivationSummary,\n} from \"../core/extensions/activation-summary.js\";\nimport type { ProjectProfileDefinition } from \"../core/profile/profile-presets.js\";\nimport { lintProjectProfile, type ProjectProfileLintReport } from \"../core/profile/profile-lint.js\";\nimport { renderExtensionSurfaceMarkdown } from \"../core/extensions/activation-summary-markdown.js\";\nimport type { ExtensionSurfaceMarkdownOptions } from \"../core/extensions/activation-summary-markdown.js\";\nimport type {\n  ExtensionBlueprint,\n  ExtensionBlueprintLintCode,\n  ExtensionBlueprintLintFinding,\n  ExtensionBlueprintLintResult,\n  ExtensionBlueprintLintSeverity,\n  ExtensionManifestCompatibilityManifest,\n  ExtensionManifestCompatibilityResult,\n  ExtensionManifestCompatibilityTarget,\n  ExtensionPreflightReport,\n  LintExtensionBlueprintOptions,\n  PreflightExtensionOptions,\n} from \"./compose.js\";\nimport type { GlobalOptions } from \"../core/shared/command-types.js\";\nimport type { PmPackageManifest, PmPackageResourceKind } from \"../core/packages/manifest.js\";\nimport { asPropertyRecord, resolveActivatablePropertyRecord } from \"../core/shared/primitives.js\";\n\n// `describeExtensionActivation` is the `describe` (enumerate-all) verb that\n// pairs with the `assert*` (verify-one) and `run*` (invoke-one) helpers below.\n// It lives in core (it walks the same registries the loader populates) and is\n// surfaced here so package authors get the whole testing surface from the\n// `@unbrained/pm-cli/sdk/testing` subpath.\nexport {\n  describeExtensionActivation,\n  renderExtensionSurfaceMarkdown,\n};\nexport type {\n  DescribeExtensionActivationOptions,\n  ExtensionActivationSummary,\n} from \"../core/extensions/activation-summary.js\";\nexport type { ExtensionSurfaceMarkdownOptions } from \"../core/extensions/activation-summary-markdown.js\";\n\n// `composeExtension`'s author-time companions: describe a blueprint's surface map\n// and preflight it for capability drift / duplicate / empty-surface footguns\n// without activating. Surfaced through the `@unbrained/pm-cli/sdk/testing` subpath\n// so a package author gets the full author → describe → preflight → test loop here,\n// alongside the assert*/run* helpers; `assertExtensionBlueprint` below is the\n// throwing assertion that pairs with the non-throwing `lintExtensionBlueprint`.\nexport { describeExtensionBlueprint, lintExtensionBlueprint };\nexport type {\n  ExtensionBlueprint,\n  ExtensionBlueprintLintCode,\n  ExtensionBlueprintLintFinding,\n  ExtensionBlueprintLintResult,\n  ExtensionBlueprintLintSeverity,\n  LintExtensionBlueprintOptions,\n};\n\n/**\n * Documents the activate extension for test options payload exchanged by command, SDK, and package integrations.\n */\nexport interface ActivateExtensionForTestOptions {\n  name?: string;\n  layer?: ExtensionLayer;\n  capabilities?: readonly ExtensionCapability[];\n  policy?: ExtensionGovernancePolicy;\n}\n\n/**\n * Documents the deactivate extension for test options payload exchanged by command, SDK, and package integrations.\n */\nexport interface DeactivateExtensionForTestOptions {\n  /** Overrides the in-memory extension name (defaults to `manifest.name` or `\"test-extension\"`). */\n  name?: string;\n  /** Overrides the layer recorded for the in-memory extension (defaults to `\"project\"`). */\n  layer?: ExtensionLayer;\n  /**\n   * Activation result returned by `activateExtensionForTest`. When provided, an\n   * extension whose `activate` failed is skipped — mirroring the host teardown\n   * contract that never deactivates a never-initialized extension. Pass the same\n   * `name`/`layer` to both helpers so the skip key matches.\n   */\n  activation?: Pick<ExtensionActivationResult, \"failed\">;\n  /**\n   * Per-hook teardown bound, forwarded as `deactivate_timeout_ms`. Use `0` (or\n   * `Infinity`) to wait indefinitely; omit to keep the host default.\n   */\n  deactivateTimeoutMs?: number;\n}\n\n/**\n * Options for {@link runRegisteredCommandForTest} — the inputs forwarded to a\n * registered extension command handler when exercising its behavior in a test.\n */\nexport interface RunRegisteredCommandForTestOptions {\n  /**\n   * Full registered command path to invoke, e.g. `\"hello\"` or `\"todos import\"`.\n   * Matched against `commands.handlers[].command` after normalization (trimmed,\n   * lower-cased, internal whitespace collapsed), mirroring runtime dispatch.\n   */\n  command: string;\n  /** Positional arguments forwarded as `context.args` (default: none). */\n  args?: readonly string[];\n  /** Parsed flags/options forwarded as `context.options` (default: none). */\n  options?: Record<string, unknown>;\n  /**\n   * Global option overrides merged onto the agent-safe test defaults\n   * (`{ json: true, quiet: true, noPager: true }`), forwarded as `context.global`.\n   */\n  global?: Partial<GlobalOptions>;\n  /**\n   * Resolved pm workspace root forwarded as `context.pm_root` (default: `\"\"`).\n   * Most pure handlers ignore it; set it when the handler reads workspace files.\n   */\n  pmRoot?: string;\n}\n\n/**\n * Options for {@link runRegisteredHookForTest} — the lifecycle `kind` to fire and\n * the synthetic context handed to every registered hook of that kind.\n *\n * The union keeps `context` type-safe per kind: `kind: \"on_write\"` requires an\n * {@link OnWriteHookContext}, `kind: \"after_command\"` an\n * {@link AfterCommandHookContext}, and so on — so authors cannot accidentally\n * pass an index context to a read hook.\n */\nexport type RunRegisteredHookForTestOptions =\n  | { kind: \"before_command\"; context: BeforeCommandHookContext }\n  | { kind: \"after_command\"; context: AfterCommandHookContext }\n  | { kind: \"on_read\"; context: OnReadHookContext }\n  | { kind: \"on_write\"; context: OnWriteHookContext }\n  | { kind: \"on_index\"; context: OnIndexHookContext };\n\n/**\n * Maps each invokable search-provider operation to the context type its function\n * receives, keeping {@link runRegisteredSearchProviderForTest} type-safe per\n * operation. Mirrors the operations the host dispatches to a registered provider:\n * semantic `query`, single/batch embedding (`embed`/`embedBatch`),\n * `queryExpansion`, and `rerank`.\n */\nexport interface SearchProviderOperationContexts {\n  query: SearchProviderQueryContext;\n  embed: SearchProviderEmbedContext;\n  embedBatch: SearchProviderEmbedBatchContext;\n  queryExpansion: SearchProviderQueryExpansionContext;\n  rerank: SearchProviderRerankContext;\n}\n\n/**\n * Maps each invokable search-provider operation to the result type its function\n * returns, so {@link runRegisteredSearchProviderForTest} resolves a precise return\n * type from the chosen `operation` instead of a union the caller must narrow.\n */\nexport interface SearchProviderOperationResults {\n  query: SearchProviderQueryResult;\n  embed: number[];\n  embedBatch: number[][];\n  queryExpansion: SearchProviderQueryExpansionResult;\n  rerank: SearchProviderRerankResult;\n}\n\n/**\n * Options for {@link runRegisteredSearchProviderForTest}: the registered\n * `provider` name to resolve, the `operation` to invoke, and the synthetic\n * `context` handed to that operation. The discriminated union keeps `context`\n * type-safe per operation — `operation: \"embed\"` requires a\n * {@link SearchProviderEmbedContext}, `operation: \"rerank\"` a\n * {@link SearchProviderRerankContext}, and so on.\n */\nexport type RunRegisteredSearchProviderForTestOptions = {\n  [Operation in keyof SearchProviderOperationContexts]: {\n    /** Registered provider name to resolve, matched case-insensitively as the host does. */\n    provider: string;\n    /** Provider operation to invoke. */\n    operation: Operation;\n    /** Synthetic context handed to the resolved operation function. */\n    context: SearchProviderOperationContexts[Operation];\n  };\n}[keyof SearchProviderOperationContexts];\n\n/**\n * Maps each invokable vector-store-adapter operation to the context type its\n * function receives, keeping {@link runRegisteredVectorStoreAdapterForTest}\n * type-safe per operation. Mirrors the operations the host dispatches to a\n * registered adapter: nearest-neighbour `query`, `upsert`, and `delete`.\n */\nexport interface VectorStoreAdapterOperationContexts {\n  query: VectorStoreQueryContext;\n  upsert: VectorStoreUpsertContext;\n  delete: VectorStoreDeleteContext;\n}\n\n/**\n * Maps each invokable vector-store-adapter operation to the result type its\n * function returns. Only `query` has a structured result\n * ({@link VectorStoreQueryHit}[]); `upsert`/`delete` report success by not\n * throwing, so their result is `unknown` and typically ignored.\n */\nexport interface VectorStoreAdapterOperationResults {\n  query: VectorStoreQueryHit[];\n  upsert: unknown;\n  delete: unknown;\n}\n\n/**\n * Options for {@link runRegisteredVectorStoreAdapterForTest}: the registered\n * `adapter` name to resolve, the `operation` to invoke, and the synthetic\n * `context` handed to that operation. The discriminated union keeps `context`\n * type-safe per operation — `operation: \"upsert\"` requires a\n * {@link VectorStoreUpsertContext}, `operation: \"delete\"` a\n * {@link VectorStoreDeleteContext}, and so on.\n */\nexport type RunRegisteredVectorStoreAdapterForTestOptions = {\n  [Operation in keyof VectorStoreAdapterOperationContexts]: {\n    /** Registered adapter name to resolve, matched case-insensitively as the host does. */\n    adapter: string;\n    /** Adapter operation to invoke. */\n    operation: Operation;\n    /** Synthetic context handed to the resolved operation function. */\n    context: VectorStoreAdapterOperationContexts[Operation];\n  };\n}[keyof VectorStoreAdapterOperationContexts];\n\n/**\n * Options for {@link runRegisteredMigrationForTest}: which registered migration\n * to invoke and the workspace root its run context reports.\n */\nexport interface RunRegisteredMigrationForTestOptions {\n  /** Registered migration id to resolve, matched case-insensitively against `definition.id`. */\n  migration: string;\n  /** Optional extension name to disambiguate when several extensions register the same id. */\n  extensionName?: string;\n  /** Resolved pm workspace root forwarded as `context.pm_root` (default `\"\"`). */\n  pmRoot?: string;\n}\n\n/**\n * Options for {@link runRegisteredImporterForTest} — the registered importer name\n * to invoke plus the synthetic invocation context forwarded to its handler.\n *\n * The `importer` name is the value passed to `api.registerImporter(name, ...)`,\n * resolved case-insensitively (and whitespace-collapsed) against\n * `registrations.importers`; the helper derives the `\"<name> import\"` command\n * path internally, so authors never hand-build it.\n */\nexport interface RunRegisteredImporterForTestOptions {\n  /** Registered importer name to resolve, e.g. `\"csv\"` for a `\"csv import\"` handler. */\n  importer: string;\n  /** Optional extension name to disambiguate when several extensions register the same importer. */\n  extensionName?: string;\n  /** Positional arguments forwarded as `context.args` (default: none). */\n  args?: readonly string[];\n  /** Parsed flags/options forwarded as `context.options` (default: none). */\n  options?: Record<string, unknown>;\n  /**\n   * Global option overrides merged onto the agent-safe test defaults\n   * (`{ json: true, quiet: true, noPager: true }`), forwarded as `context.global`.\n   */\n  global?: Partial<GlobalOptions>;\n  /** Resolved pm workspace root forwarded as `context.pm_root` (default: `\"\"`). */\n  pmRoot?: string;\n}\n\n/**\n * Options for {@link runRegisteredExporterForTest} — the registered exporter name\n * to invoke plus the synthetic invocation context forwarded to its handler.\n *\n * The `exporter` name is the value passed to `api.registerExporter(name, ...)`,\n * resolved case-insensitively (and whitespace-collapsed) against\n * `registrations.exporters`; the helper derives the `\"<name> export\"` command\n * path internally, so authors never hand-build it.\n */\nexport interface RunRegisteredExporterForTestOptions {\n  /** Registered exporter name to resolve, e.g. `\"csv\"` for a `\"csv export\"` handler. */\n  exporter: string;\n  /** Optional extension name to disambiguate when several extensions register the same exporter. */\n  extensionName?: string;\n  /** Positional arguments forwarded as `context.args` (default: none). */\n  args?: readonly string[];\n  /** Parsed flags/options forwarded as `context.options` (default: none). */\n  options?: Record<string, unknown>;\n  /**\n   * Global option overrides merged onto the agent-safe test defaults\n   * (`{ json: true, quiet: true, noPager: true }`), forwarded as `context.global`.\n   */\n  global?: Partial<GlobalOptions>;\n  /** Resolved pm workspace root forwarded as `context.pm_root` (default: `\"\"`). */\n  pmRoot?: string;\n}\n\n/**\n * Documents the extension deactivation expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface ExtensionDeactivationExpectation {\n  /** Expected count of extensions whose `deactivate` ran without throwing (default `1`). */\n  deactivated?: number;\n  /** Expected count of teardown failures (default `0`). */\n  failed?: number;\n}\n\n/**\n * Documents the registered command contract expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredCommandContractExpectation {\n  command: string;\n  action?: string;\n  extensionName?: string;\n  arguments?: string[];\n  flags?: string[];\n}\n\n/**\n * Documents the registered command contract assertion payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredCommandContractAssertion {\n  command: RegisteredExtensionCommandDefinition;\n  flags: FlagDefinition[];\n}\n\n/**\n * Documents the registered flags expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredFlagsExpectation {\n  targetCommand: string;\n  extensionName?: string;\n  flags?: string[];\n}\n\n/**\n * Public hook lifecycle kinds an extension can register through `api.hooks.*`.\n */\nexport type RegisteredHookKind = \"before_command\" | \"after_command\" | \"on_read\" | \"on_write\" | \"on_index\";\n\nconst HOOK_KIND_TO_REGISTRY_FIELD: Record<RegisteredHookKind, keyof ExtensionHookRegistry> = {\n  before_command: \"beforeCommand\",\n  after_command: \"afterCommand\",\n  on_read: \"onRead\",\n  on_write: \"onWrite\",\n  on_index: \"onIndex\",\n};\n\n/**\n * Documents the registered hook expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredHookExpectation {\n  kind: RegisteredHookKind;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered search provider expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredSearchProviderExpectation {\n  provider: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered vector store adapter expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredVectorStoreAdapterExpectation {\n  adapter: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered importer expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredImporterExpectation {\n  importer: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered exporter expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredExporterExpectation {\n  exporter: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered item field expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredItemFieldExpectation {\n  field: string;\n  extensionName?: string;\n  type?: SchemaFieldDefinition[\"type\"];\n}\n\n/**\n * Documents the registered item field assertion payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredItemFieldAssertion {\n  registration: RegisteredExtensionSchemaFieldDefinitions;\n  field: SchemaFieldDefinition;\n}\n\n/**\n * Documents the registered item type expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredItemTypeExpectation {\n  itemType: string;\n  extensionName?: string;\n  folder?: string;\n}\n\n/**\n * Documents the registered item type assertion payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredItemTypeAssertion {\n  registration: RegisteredExtensionSchemaItemTypeDefinitions;\n  itemType: SchemaItemTypeDefinition;\n}\n\n/**\n * Documents the registered command override expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredCommandOverrideExpectation {\n  command: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered parser override expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredParserOverrideExpectation {\n  command: string;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered preflight override expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredPreflightOverrideExpectation {\n  extensionName?: string;\n}\n\n/**\n * Documents the registered renderer override expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredRendererOverrideExpectation {\n  format: OutputRendererFormat;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered service override expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredServiceOverrideExpectation {\n  service: ExtensionServiceName;\n  extensionName?: string;\n}\n\n/**\n * Documents the registered migration expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredMigrationExpectation {\n  migration: string;\n  extensionName?: string;\n  mandatory?: boolean;\n}\n\n/**\n * Documents the registered project-profile expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredProfileExpectation {\n  /** Profile name to assert is registered (case-insensitive). */\n  profile: string;\n  /** Restrict the match to a single extension when several are active. */\n  extensionName?: string;\n}\n\n/**\n * Documents the registered project-profile assertion payload exchanged by command, SDK, and package integrations.\n */\nexport interface RegisteredProfileAssertion {\n  /** The matching registration entry. */\n  registration: RegisteredExtensionProjectProfile;\n  /** The registered profile definition. */\n  profile: ProjectProfileDefinition;\n}\n\n/**\n * Documents the extension capability usage expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface ExtensionCapabilityUsageExpectation {\n  /**\n   * Capabilities the manifest declares. Mirror `manifest.capabilities` here so\n   * the assertion fails when the manifest grants more than the code uses.\n   */\n  declared: readonly ExtensionCapability[];\n  /** Restrict reconciliation to a single extension when the activation has several. */\n  extensionName?: string;\n  /**\n   * Capabilities allowed to be declared without being exercised (e.g. ones a\n   * runtime registers only behind a config flag). These are excluded from the\n   * least-privilege failure.\n   */\n  allowUnused?: readonly ExtensionCapability[];\n}\n\n/**\n * Documents the extension capability usage assertion payload exchanged by command, SDK, and package integrations.\n */\nexport interface ExtensionCapabilityUsageAssertion {\n  /** Declared capabilities considered, sorted and de-duplicated. */\n  declared: ExtensionCapability[];\n  /** Capabilities the extension actually registered against, sorted. */\n  used: ExtensionCapability[];\n  /** Declared capabilities with no matching registration after the allowlist. */\n  unused: ExtensionCapability[];\n}\n\n/**\n * Restricts package manifest resource expectation values accepted by command, SDK, and storage contracts.\n */\nexport type PackageManifestResourceExpectation = Partial<Record<PmPackageResourceKind, readonly string[]>>;\n\n/**\n * Documents the package manifest expectation payload exchanged by command, SDK, and package integrations.\n */\nexport interface PackageManifestExpectation {\n  packageName?: string;\n  aliases?: readonly string[];\n  resources?: PackageManifestResourceExpectation;\n}\n\n/**\n * Options for {@link ExtensionTestHarness.renderMarkdown}.\n */\nexport interface RenderExtensionHarnessMarkdownOptions extends ExtensionSurfaceMarkdownOptions {\n  /**\n   * Restrict the rendered summary to one activated extension by name. Defaults\n   * to the full activation union, matching {@link ExtensionTestHarness.activationSummary}.\n   */\n  extensionName?: string;\n}\n\nfunction normalizeSdkIdentifier(value: string): string {\n  return value.trim().toLowerCase();\n}\n\n/**\n * Match key for profile-name assertions. Extends {@link normalizeSdkIdentifier}\n * with hyphen→underscore folding so the assertion mirrors the runtime profile\n * resolution (`pm profile`), which treats `my-flow` and `my_flow` as the same\n * archetype. Profiles are the one registration surface that resolves\n * hyphen-insensitively (item types resolve by alias, migrations by exact id), so\n * — unlike the other `assertRegistered*` helpers — this one folds the separator\n * to stay in lockstep with how a profile is actually looked up by name.\n */\nfunction normalizeSdkProfileMatchKey(value: string): string {\n  return normalizeSdkIdentifier(value).replaceAll(\"-\", \"_\");\n}\n\nfunction extensionNameSuffix(extensionName: string | undefined): string {\n  return extensionName ? ` from extension \"${extensionName}\"` : \"\";\n}\n\nfunction sortedUnique(values: readonly string[]): string[] {\n  return [...new Set(values)].sort((left, right) => left.localeCompare(right));\n}\n\nfunction normalizeSdkCommandName(command: string): string {\n  if (typeof command !== \"string\") {\n    // Positional misuse like runRegisteredCommandForTest(activation, \"name\", opts)\n    // reaches here with `undefined` at runtime; guide instead of crashing on .trim().\n    throw new Error(\n      'A command name string is required. Pass it via the options object, e.g. runRegisteredCommandForTest(activation, { command: \"my command\" }) — positional command arguments are not supported.',\n    );\n  }\n  return command\n    .trim()\n    .toLowerCase()\n    .split(/\\s+/)\n    .filter((part) => part.length > 0)\n    .join(\" \");\n}\n\nfunction formatAvailable(values: readonly string[]): string {\n  return values.length > 0 ? values.join(\", \") : \"(none)\";\n}\n\nfunction assertStringSetIncludes(\n  actual: readonly string[] | undefined,\n  expected: readonly string[],\n  label: string,\n): void {\n  const actualValues = new Set(actual ?? []);\n  const missing = sortedUnique(expected.filter((value) => !actualValues.has(value)));\n  if (missing.length > 0) {\n    throw new Error(\n      `Expected package manifest ${label} to include ${missing.join(\", \")}; available: ${formatAvailable(\n        sortedUnique(actual ?? []),\n      )}`,\n    );\n  }\n}\n\nfunction collectFlagLabels(flags: readonly FlagDefinition[]): Set<string> {\n  const labels = new Set<string>();\n  for (const flag of flags) {\n    if (typeof flag.long === \"string\" && flag.long.trim().length > 0) {\n      labels.add(flag.long.trim());\n    }\n    if (typeof flag.short === \"string\" && flag.short.trim().length > 0) {\n      labels.add(flag.short.trim());\n    }\n  }\n  return labels;\n}\n\nfunction readTestExtensionManifest(module: unknown): Partial<ExtensionManifest> {\n  const moduleRecord = asPropertyRecord(module);\n  if (!moduleRecord) {\n    return {};\n  }\n  const manifest = asPropertyRecord(moduleRecord.manifest);\n  if (manifest) {\n    return manifest as Partial<ExtensionManifest>;\n  }\n  const defaultExport = asPropertyRecord(moduleRecord.default);\n  const defaultManifest = asPropertyRecord(defaultExport?.manifest);\n  if (defaultManifest) {\n    return defaultManifest as Partial<ExtensionManifest>;\n  }\n  if (\n    defaultExport &&\n    typeof moduleRecord.default !== \"function\" &&\n    (\"name\" in defaultExport || \"capabilities\" in defaultExport)\n  ) {\n    return defaultExport as Partial<ExtensionManifest>;\n  }\n  if (typeof module !== \"function\" && (\"name\" in moduleRecord || \"capabilities\" in moduleRecord)) {\n    return moduleRecord as Partial<ExtensionManifest>;\n  }\n  return {};\n}\n\nfunction resolveTestExtensionName(manifest: Partial<ExtensionManifest>, explicitName: string | undefined): string {\n  return (\n    explicitName ??\n    (typeof manifest.name === \"string\" && manifest.name.trim().length > 0 ? manifest.name.trim() : \"test-extension\")\n  );\n}\n\nfunction readTestExtensionCapabilities(\n  manifest: Partial<ExtensionManifest>,\n  options: ActivateExtensionForTestOptions,\n): ExtensionCapability[] {\n  if (Array.isArray(options.capabilities)) {\n    return [...options.capabilities];\n  }\n  if (Array.isArray(manifest.capabilities)) {\n    return manifest.capabilities.filter((capability): capability is ExtensionCapability => typeof capability === \"string\");\n  }\n  return [];\n}\n\n/**\n * Build the synthetic single-extension {@link ExtensionLoadResult} shared by the\n * activate/deactivate test helpers, so both stay aligned with the loader's load\n * contract as it evolves. The `loaded` entry mirrors the real on-disk shape\n * (including `capabilities` and the compatibility fields) while leaving\n * filesystem paths empty, since the module is supplied in memory.\n */\nfunction buildSingleExtensionLoadResult(\n  module: unknown,\n  manifest: Partial<ExtensionManifest>,\n  identity: { name: string; layer: ExtensionLayer; capabilities: ExtensionCapability[]; policy: ExtensionGovernancePolicy },\n): ExtensionLoadResult {\n  return {\n    disabled_by_flag: false,\n    roots: { global: \"\", project: \"\" },\n    configured_enabled: [],\n    configured_disabled: [],\n    discovered: [],\n    effective: [],\n    warnings: [],\n    policy: identity.policy,\n    failed: [],\n    loaded: [\n      {\n        layer: identity.layer,\n        directory: \"\",\n        manifest_path: \"\",\n        name: identity.name,\n        version: typeof manifest.version === \"string\" ? manifest.version : \"0.0.0\",\n        entry: typeof manifest.entry === \"string\" ? manifest.entry : \"./index.js\",\n        priority: typeof manifest.priority === \"number\" ? manifest.priority : 0,\n        entry_path: \"\",\n        capabilities: identity.capabilities,\n        manifest_version: typeof manifest.manifest_version === \"number\" ? manifest.manifest_version : undefined,\n        pm_min_version: typeof manifest.pm_min_version === \"string\" ? manifest.pm_min_version : undefined,\n        pm_max_version: typeof manifest.pm_max_version === \"string\" ? manifest.pm_max_version : undefined,\n        engines: manifest.engines,\n        trusted: manifest.trusted,\n        provenance: manifest.provenance,\n        sandbox_profile: manifest.sandbox_profile,\n        permissions: manifest.permissions,\n        activation: manifest.activation,\n        module,\n      },\n    ],\n  };\n}\n\n/**\n * Activate one in-memory extension module for package tests.\n *\n * This uses pm's real registration validation and activation engine while\n * avoiding private loader imports, filesystem manifests, or workspace setup.\n */\nexport async function activateExtensionForTest(\n  module: unknown,\n  options: ActivateExtensionForTestOptions = {},\n): Promise<ExtensionActivationResult> {\n  const manifest = readTestExtensionManifest(module);\n  return activateExtensions(\n    buildSingleExtensionLoadResult(module, manifest, {\n      name: resolveTestExtensionName(manifest, options.name),\n      layer: options.layer ?? \"project\",\n      capabilities: readTestExtensionCapabilities(manifest, options),\n      policy: options.policy ?? createDefaultExtensionGovernancePolicy(),\n    }),\n  );\n}\n\n/**\n * Deactivate one in-memory extension module for package tests — the teardown\n * counterpart to {@link activateExtensionForTest}.\n *\n * Runs pm's real `deactivateExtensions` engine (including its bounded per-hook\n * timeout and best-effort failure capture) over a single synthetic load entry,\n * so authors can prove an extension's `deactivate` releases the resources its\n * `activate` opened — without importing private loader internals or staging a\n * workspace. Resolve `name`/`layer` the same way {@link activateExtensionForTest}\n * does so a forwarded `activation` result skips a failed extension correctly.\n */\nexport async function deactivateExtensionForTest(\n  module: unknown,\n  options: DeactivateExtensionForTestOptions = {},\n): Promise<ExtensionDeactivationResult> {\n  const manifest = readTestExtensionManifest(module);\n  return deactivateExtensions(\n    buildSingleExtensionLoadResult(module, manifest, {\n      name: resolveTestExtensionName(manifest, options.name),\n      layer: options.layer ?? \"project\",\n      capabilities: readTestExtensionCapabilities(manifest, {}),\n      policy: createDefaultExtensionGovernancePolicy(),\n    }),\n    options.activation,\n    options.deactivateTimeoutMs === undefined ? {} : { deactivate_timeout_ms: options.deactivateTimeoutMs },\n  );\n}\n\n/**\n * Invoke a registered extension command handler and return its real\n * {@link CommandHandlerResult} so package tests can assert on behavior — not\n * just that the command was registered.\n *\n * This is the \"invoke\" verb that completes the package-author testing loop:\n * `activateExtensionForTest` → `assertRegisteredCommandContract` → **run** →\n * `deactivateExtensionForTest`. It runs pm's real handler-dispatch engine\n * (`runCommandHandler`) over `activation.commands`, building the\n * `CommandHandlerContext` with agent-safe global defaults\n * (`{ json: true, quiet: true, noPager: true }`) that callers may override.\n *\n * Because `registerImporter`/`registerExporter` register their handlers under\n * the `\"<name> import\"` / `\"<name> export\"` command paths, this same helper\n * exercises importer and exporter handlers too.\n *\n * Throws a descriptive error (listing the available handler command paths) when\n * no handler is registered for `command`, since that is a wiring/typo bug in the\n * test rather than a behavior under test. When a handler is found, the result is\n * returned verbatim: a clean run yields `{ handled: true, result, warnings: [] }`,\n * while a handler that throws a non-exit error yields\n * `{ handled: false, warnings: [code], errorMessage }` so the failure can be\n * asserted. A handler that throws an error carrying a numeric `exitCode`\n * propagates the throw, matching runtime semantics.\n */\nexport async function runRegisteredCommandForTest(\n  commands: ExtensionCommandRegistry,\n  options: RunRegisteredCommandForTestOptions,\n): Promise<CommandHandlerResult> {\n  const command = normalizeSdkCommandName(options.command);\n  if (command.length === 0) {\n    throw new Error(\"Expected command name must be a non-empty string\");\n  }\n  const hasHandler = commands.handlers.some((entry) => entry.command === command);\n  if (!hasHandler) {\n    const available = sortedUnique(commands.handlers.map((entry) => entry.command));\n    throw new Error(\n      `Expected a registered command handler for \"${command}\" to invoke. Available command handlers: ${formatAvailable(\n        available,\n      )}`,\n    );\n  }\n  return runCommandHandler(commands, {\n    command,\n    args: options.args ? [...options.args] : [],\n    options: options.options ? { ...options.options } : {},\n    global: { json: true, quiet: true, noPager: true, ...options.global },\n    pm_root: options.pmRoot ?? \"\",\n  });\n}\n\n/**\n * Fire every registered lifecycle hook of a given `kind` through pm's real hook\n * runner and return the warnings array so package tests can assert on behavior —\n * not just that a hook was registered.\n *\n * This is the hook counterpart to {@link runRegisteredCommandForTest}, extending\n * the package-author \"invoke\" verb to the `api.hooks.*` surface. Pass the\n * `ExtensionHookRegistry` from `activateExtensionForTest(...).hooks` together with\n * the lifecycle `kind` and a synthetic context. Hooks observe their inputs via a\n * cloned context snapshot (mutations never leak back to the caller), so the\n * observable signal is twofold: any side effects the hook performs, and the\n * returned warnings. A clean run returns `[]`; a hook that throws contributes one\n * `extension_hook_failed:<layer>:<name>:<hookName>` warning, mirroring runtime\n * dispatch which isolates a failing hook without aborting the others.\n *\n * Throws a descriptive error (listing the hook kinds that do have registrations)\n * when no hook of `kind` is registered, since firing a hook the extension never\n * registered is a wiring/typo bug in the test rather than a behavior under test.\n */\nexport async function runRegisteredHookForTest(\n  hooks: ExtensionHookRegistry,\n  options: RunRegisteredHookForTestOptions,\n): Promise<string[]> {\n  if (hooks[HOOK_KIND_TO_REGISTRY_FIELD[options.kind]].length === 0) {\n    const populatedKinds = sortedUnique(\n      (Object.keys(HOOK_KIND_TO_REGISTRY_FIELD) as RegisteredHookKind[]).filter(\n        (kind) => hooks[HOOK_KIND_TO_REGISTRY_FIELD[kind]].length > 0,\n      ),\n    );\n    throw new Error(\n      `Expected a registered \"${options.kind}\" hook to invoke. Hook kinds with registrations: ${formatAvailable(\n        populatedKinds,\n      )}`,\n    );\n  }\n  switch (options.kind) {\n    case \"before_command\":\n      return runBeforeCommandHooks(hooks, options.context);\n    case \"after_command\":\n      return runAfterCommandHooks(hooks, options.context);\n    case \"on_read\":\n      return runOnReadHooks(hooks, options.context);\n    case \"on_write\":\n      return runOnWriteHooks(hooks, options.context);\n    case \"on_index\":\n      return runOnIndexHooks(hooks, options.context);\n  }\n}\n\n/**\n * Invoke a registered parser override through pm's real runner and return the\n * resolved {@link ParserOverrideResult}, so package tests can assert the rewritten\n * args/options/global an override produces for a command before dispatch.\n *\n * Guards that a parser override is registered for the (normalized) target command\n * before delegating: without a match `runParserOverride` would silently return\n * `overridden: false`, hiding a typo'd command name in the test. When a match\n * exists the result is returned verbatim — `overridden: true` with the rewritten\n * context on success, or `overridden: false` with an\n * `extension_parser_override_failed:*` warning when the override throws.\n */\nexport async function runRegisteredParserOverrideForTest(\n  parsers: ExtensionParserRegistry,\n  context: ParserOverrideContext,\n): Promise<ParserOverrideResult> {\n  const command = normalizeSdkCommandName(context.command);\n  if (!parsers.overrides.some((entry) => entry.command === command)) {\n    throw new Error(\n      `Expected a registered parser override for command \"${command}\" to invoke. Available parser override commands: ${formatAvailable(\n        sortedUnique(parsers.overrides.map((entry) => entry.command)),\n      )}`,\n    );\n  }\n  return runParserOverride(parsers, context);\n}\n\n/**\n * Invoke the active preflight override through pm's real runner and return the\n * resolved {@link PreflightOverrideResult}, so package tests can assert the\n * migration/format gate decision an override yields.\n *\n * Unlike command-scoped overrides, the runtime applies the **last** registered\n * preflight override regardless of command, so this helper guards only that at\n * least one preflight override is registered before delegating. The result is\n * returned verbatim — `overridden: true` with the adjusted decision on success,\n * or `overridden: false` with an `extension_preflight_override_failed:*` warning\n * when the override throws.\n */\nexport async function runRegisteredPreflightOverrideForTest(\n  preflight: ExtensionPreflightRegistry,\n  context: PreflightOverrideContext,\n): Promise<PreflightOverrideResult> {\n  if (preflight.overrides.length === 0) {\n    throw new Error(\n      \"Expected a registered preflight override to invoke, but none are registered.\",\n    );\n  }\n  return runPreflightOverride(preflight, context);\n}\n\n/**\n * Invoke a registered command-result override through pm's real runner and return\n * the resolved {@link CommandOverrideResult}, so package tests can assert how an\n * override transforms a command's result payload.\n *\n * Accepts the same `ExtensionCommandRegistry` exposed as\n * `activateExtensionForTest(...).commands` (it carries both handlers and\n * overrides). Guards that an override is registered for the (normalized) target\n * command before delegating, so a typo'd command name surfaces as a clear error\n * rather than a silent `overridden: false`. The result is returned verbatim —\n * including the `extension_command_override_async_unsupported:*` warning the\n * runtime emits when an override returns a Promise (command overrides are\n * synchronous), or an `extension_command_override_failed:*` warning on throw.\n */\nexport async function runRegisteredCommandOverrideForTest(\n  commands: ExtensionCommandRegistry,\n  context: CommandOverrideContext,\n): Promise<CommandOverrideResult> {\n  const command = normalizeSdkCommandName(context.command);\n  if (!commands.overrides.some((entry) => entry.command === command)) {\n    throw new Error(\n      `Expected a registered command override for command \"${command}\" to invoke. Available command override commands: ${formatAvailable(\n        sortedUnique(commands.overrides.map((entry) => entry.command)),\n      )}`,\n    );\n  }\n  return runCommandOverride(commands, context);\n}\n\n/**\n * Invoke a registered renderer override through pm's real runner and return the\n * resolved {@link RendererOverrideResult}, so package tests can assert the custom\n * string an override renders for a given output `format`.\n *\n * Guards that a renderer override is registered for `context.format` before\n * delegating, so a wrong format surfaces as a clear error rather than a silent\n * `overridden: false`. The result is returned verbatim — `overridden: true` with\n * the rendered string on success, or `overridden: false` (with an\n * `extension_renderer_invalid_result:*` / `extension_renderer_failed:*` warning\n * where applicable) when the override returns a non-string or throws.\n */\nexport async function runRegisteredRendererOverrideForTest(\n  renderers: ExtensionRendererRegistry,\n  context: RendererOverrideContext,\n): Promise<RendererOverrideResult> {\n  if (!renderers.overrides.some((entry) => entry.format === context.format)) {\n    throw new Error(\n      `Expected a registered renderer override for format \"${context.format}\" to invoke. Available renderer override formats: ${formatAvailable(\n        sortedUnique(renderers.overrides.map((entry) => entry.format)),\n      )}`,\n    );\n  }\n  return runRendererOverride(renderers, context);\n}\n\n/**\n * Invoke a registered service override through pm's real runner and return the\n * resolved {@link ServiceOverrideResult}, so package tests can assert how an\n * override handles an internal service payload (e.g. `output_format`).\n *\n * Guards that a service override is registered for `context.service` before\n * delegating, so a wrong service name surfaces as a clear error rather than a\n * silent `handled: false`. The result is returned verbatim — `handled: true` with\n * the override's result when it claims the payload, or `handled: false` with the\n * original payload (and any `extension_service_override_*` warnings) otherwise.\n */\nexport async function runRegisteredServiceOverrideForTest(\n  services: ExtensionServiceRegistry,\n  context: ServiceOverrideContext,\n): Promise<ServiceOverrideResult> {\n  if (!services.overrides.some((entry) => entry.service === context.service)) {\n    throw new Error(\n      `Expected a registered service override for service \"${context.service}\" to invoke. Available service override services: ${formatAvailable(\n        sortedUnique(services.overrides.map((entry) => entry.service)),\n      )}`,\n    );\n  }\n  return runServiceOverride(services, context);\n}\n\n/**\n * Maps each search-provider operation to the runtime-definition keys that may\n * hold its function, in priority order. The host accepts both camelCase and\n * snake_case spellings for the multi-word operations, so this helper mirrors that\n * by trying `embedBatch` before `embed_batch` and `queryExpansion` before\n * `query_expansion`.\n */\nconst SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS: Record<keyof SearchProviderOperationContexts, readonly string[]> = {\n  query: [\"query\"],\n  embed: [\"embed\"],\n  embedBatch: [\"embedBatch\", \"embed_batch\"],\n  queryExpansion: [\"queryExpansion\", \"query_expansion\"],\n  rerank: [\"rerank\"],\n};\n\n/**\n * Invoke an operation of a registered search provider through the same name\n * resolution the host uses and return the operation's result, so package tests\n * can assert a custom provider's runtime behavior — not just that it registered.\n *\n * This is the search-provider counterpart to {@link runRegisteredCommandForTest},\n * extending the package-author \"invoke\" verb to the `api.registerSearchProvider`\n * surface. Pass the `ExtensionRegistrationRegistry` from\n * `activateExtensionForTest(...).registrations`, the registered provider name, the\n * `operation` to exercise (`query`, `embed`, `embedBatch`, `queryExpansion`, or\n * `rerank`), and a synthetic context. The provider is resolved via\n * {@link resolveRegisteredSearchProvider} (case-insensitive, last registration\n * wins) and the operation is invoked on its `runtime_definition` — the clone that\n * preserves live functions, matching what the runtime dispatches.\n *\n * Throws a descriptive error listing the available providers when the name is not\n * registered, and a separate error when the resolved provider does not implement\n * the requested operation, since invoking an absent provider/operation is a\n * wiring bug in the test rather than a behavior under test.\n */\nexport async function runRegisteredSearchProviderForTest<Operation extends keyof SearchProviderOperationContexts>(\n  registrations: ExtensionRegistrationRegistry,\n  options: {\n    provider: string;\n    operation: Operation;\n    context: SearchProviderOperationContexts[Operation];\n  },\n): Promise<SearchProviderOperationResults[Operation]> {\n  const registration = resolveRegisteredSearchProvider(registrations, options.provider);\n  if (!registration) {\n    const available = sortedUnique(registrations.search_providers.map((entry) => entry.definition.name));\n    throw new Error(\n      `Expected a registered search provider \"${options.provider}\" to invoke. Available search providers: ${formatAvailable(\n        available,\n      )}`,\n    );\n  }\n  const runtimeDefinition = registration.runtime_definition;\n  const operationFn = SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS[options.operation]\n    .map((key) => runtimeDefinition[key])\n    .find((value) => typeof value === \"function\");\n  if (typeof operationFn !== \"function\") {\n    throw new Error(\n      `Registered search provider \"${options.provider}\" does not implement the \"${options.operation}\" operation.`,\n    );\n  }\n  return (await (operationFn as (context: SearchProviderOperationContexts[Operation]) => unknown)(\n    options.context,\n  )) as SearchProviderOperationResults[Operation];\n}\n\n/**\n * Invoke an operation of a registered vector store adapter through the same name\n * resolution the host uses and return the operation's result, so package tests\n * can assert a custom adapter's runtime behavior — not just that it registered.\n *\n * This is the vector-store counterpart to {@link runRegisteredSearchProviderForTest}.\n * Pass the `ExtensionRegistrationRegistry` from\n * `activateExtensionForTest(...).registrations`, the registered adapter name, the\n * `operation` to exercise (`query`, `upsert`, or `delete`), and a synthetic\n * context. The adapter is resolved via {@link resolveRegisteredVectorStoreAdapter}\n * (case-insensitive, last registration wins) and the operation is invoked on its\n * `runtime_definition` — the clone that preserves live functions, matching what\n * the runtime dispatches.\n *\n * Throws a descriptive error listing the available adapters when the name is not\n * registered, and a separate error when the resolved adapter does not implement\n * the requested operation.\n */\nexport async function runRegisteredVectorStoreAdapterForTest<\n  Operation extends keyof VectorStoreAdapterOperationContexts,\n>(\n  registrations: ExtensionRegistrationRegistry,\n  options: {\n    adapter: string;\n    operation: Operation;\n    context: VectorStoreAdapterOperationContexts[Operation];\n  },\n): Promise<VectorStoreAdapterOperationResults[Operation]> {\n  const registration = resolveRegisteredVectorStoreAdapter(registrations, options.adapter);\n  if (!registration) {\n    const available = sortedUnique(registrations.vector_store_adapters.map((entry) => entry.definition.name));\n    throw new Error(\n      `Expected a registered vector store adapter \"${options.adapter}\" to invoke. Available vector store adapters: ${formatAvailable(\n        available,\n      )}`,\n    );\n  }\n  const operationFn = registration.runtime_definition[options.operation];\n  if (typeof operationFn !== \"function\") {\n    throw new Error(\n      `Registered vector store adapter \"${options.adapter}\" does not implement the \"${options.operation}\" operation.`,\n    );\n  }\n  return (await (operationFn as (context: VectorStoreAdapterOperationContexts[Operation]) => unknown)(\n    options.context,\n  )) as VectorStoreAdapterOperationResults[Operation];\n}\n\n/**\n * Invoke a registered schema migration's `run` function through the same runtime\n * definition the host executes and return its result, so package tests can assert\n * a migration's behavior — not just that it registered.\n *\n * This completes the package-author \"invoke\" verb across every executable\n * registration surface. The migration is resolved by id via\n * {@link assertRegisteredMigration} (which throws a descriptive \"available\n * migrations\" error when absent), then `run` is invoked on its\n * `runtime_definition` with a context mirroring the one\n * `executeRegisteredRuntimeMigrations` builds at runtime: the resolved id,\n * `command: \"migration\"`, the registering extension's layer/name, the supplied\n * `pmRoot`, and the migration's normalized status. Unlike the runtime — which\n * skips already-applied migrations and folds a throw into a warning — this helper\n * always invokes `run` and lets a throw propagate, so authors can assert both the\n * success result and failure via rejection.\n *\n * Throws when the resolved migration declares no `run` function, since invoking a\n * runless migration is a wiring bug in the test rather than a behavior under test.\n */\nexport async function runRegisteredMigrationForTest(\n  registrations: ExtensionRegistrationRegistry,\n  options: RunRegisteredMigrationForTestOptions,\n): Promise<unknown> {\n  const migration = assertRegisteredMigration(registrations, {\n    migration: options.migration,\n    extensionName: options.extensionName,\n  });\n  const run = getMigrationRuntimeDefinition(migration).run;\n  if (typeof run !== \"function\") {\n    throw new Error(`Registered migration \"${options.migration}\" does not implement a run function to invoke.`);\n  }\n  const declaredStatus = migration.definition.status;\n  const context: SchemaMigrationRunContext = {\n    id: migration.definition.id as string,\n    command: \"migration\",\n    layer: migration.layer,\n    extension: migration.name,\n    pm_root: options.pmRoot ?? \"\",\n    status: (typeof declaredStatus === \"string\" ? declaredStatus.trim().toLowerCase() : \"\") || \"pending\",\n  };\n  return await (run as (context: SchemaMigrationRunContext) => unknown)(context);\n}\n\n/**\n * Invoke a registered extension importer through pm's real handler-dispatch\n * engine and return its {@link CommandHandlerResult}, so package tests can assert\n * an importer's behavior — not just that it registered.\n *\n * This is the importer counterpart to {@link runRegisteredCommandForTest},\n * extending the package-author \"invoke\" verb to the `api.registerImporter`\n * surface. Because `registerImporter(name, fn)` wraps `fn` into a command handler\n * at the `\"<name> import\"` path, invoking it through `runRegisteredCommandForTest`\n * requires the author to know that naming convention and to remember that an\n * importer is reachable as a command at all. This helper closes both gaps: it\n * accepts the registered importer name directly, validates via\n * {@link assertRegisteredImporter} that it is genuinely a registered importer\n * (not merely some command parked at that path), derives the command path, and\n * dispatches through the same engine.\n *\n * The full activation result is required because importer execution spans two\n * sub-registries: `registrations.importers` proves the importer exists, while\n * `commands` holds the wrapped handler. The result is returned verbatim from the\n * command engine: a clean run yields `{ handled: true, result, warnings: [] }`\n * (where `result` is the importer's return value), a non-exit throw yields\n * `{ handled: false, warnings: [code], errorMessage }`, and an error carrying a\n * numeric `exitCode` propagates — matching runtime import semantics.\n *\n * Throws a descriptive \"available importers\" error (via `assertRegisteredImporter`)\n * when no importer matches, since that is a wiring/typo bug in the test rather\n * than a behavior under test.\n */\nexport async function runRegisteredImporterForTest(\n  activation: ExtensionActivationResult,\n  options: RunRegisteredImporterForTestOptions,\n): Promise<CommandHandlerResult> {\n  const importer = assertRegisteredImporter(activation.registrations, {\n    importer: options.importer,\n    extensionName: options.extensionName,\n  });\n  return runRegisteredCommandForTest(activation.commands, {\n    command: `${importer.importer} import`,\n    args: options.args,\n    options: options.options,\n    global: options.global,\n    pmRoot: options.pmRoot,\n  });\n}\n\n/**\n * Invoke a registered extension exporter through pm's real handler-dispatch\n * engine and return its {@link CommandHandlerResult}, so package tests can assert\n * an exporter's behavior — not just that it registered.\n *\n * This is the exporter counterpart to {@link runRegisteredImporterForTest} and\n * the final surface in the package-author \"invoke\" verb. Because\n * `registerExporter(name, fn)` wraps `fn` into a command handler at the\n * `\"<name> export\"` path, this helper accepts the registered exporter name\n * directly, validates via {@link assertRegisteredExporter} that it is genuinely a\n * registered exporter, derives the command path, and dispatches through the same\n * engine. See {@link runRegisteredImporterForTest} for the full activation\n * rationale and return semantics (which apply identically here).\n *\n * Throws a descriptive \"available exporters\" error (via `assertRegisteredExporter`)\n * when no exporter matches, since that is a wiring/typo bug in the test rather\n * than a behavior under test.\n */\nexport async function runRegisteredExporterForTest(\n  activation: ExtensionActivationResult,\n  options: RunRegisteredExporterForTestOptions,\n): Promise<CommandHandlerResult> {\n  const exporter = assertRegisteredExporter(activation.registrations, {\n    exporter: options.exporter,\n    extensionName: options.extensionName,\n  });\n  return runRegisteredCommandForTest(activation.commands, {\n    command: `${exporter.exporter} export`,\n    args: options.args,\n    options: options.options,\n    global: options.global,\n    pmRoot: options.pmRoot,\n  });\n}\n\n/**\n * Assert that an {@link ExtensionDeactivationResult} reports the expected clean\n * teardown counts, throwing a descriptive error otherwise. Defaults assert the\n * single-extension happy path — exactly one extension deactivated and none\n * failed. Returns the result so assertions can chain.\n */\nexport function assertExtensionDeactivated(\n  result: ExtensionDeactivationResult,\n  expectation: ExtensionDeactivationExpectation = {},\n): ExtensionDeactivationResult {\n  const expectedDeactivated = expectation.deactivated ?? 1;\n  if (result.deactivated !== expectedDeactivated) {\n    throw new Error(\n      `Expected ${expectedDeactivated} extension${expectedDeactivated === 1 ? \"\" : \"s\"} to deactivate cleanly, ` +\n        `but ${result.deactivated} did.`,\n    );\n  }\n  const expectedFailed = expectation.failed ?? 0;\n  if (result.failed.length !== expectedFailed) {\n    const detail = result.failed.map((failure) => `${failure.layer}:${failure.name} (${failure.error})`).join(\", \");\n    throw new Error(\n      `Expected ${expectedFailed} teardown failure${expectedFailed === 1 ? \"\" : \"s\"}, ` +\n        `but observed ${result.failed.length}${detail.length > 0 ? `: ${detail}` : \"\"}.`,\n    );\n  }\n  return result;\n}\n\n/**\n * Assert that a normalized package manifest advertises expected package\n * resources. Pair with `readPmPackageManifest(packageRoot)` in package tests.\n */\nexport function assertPackageManifest(\n  manifest: PmPackageManifest,\n  expectation: PackageManifestExpectation,\n): PmPackageManifest {\n  if (expectation.packageName !== undefined && manifest.package_name !== expectation.packageName) {\n    throw new Error(\n      `Expected package manifest package_name to be \"${expectation.packageName}\"; received \"${\n        manifest.package_name ?? \"(none)\"\n      }\"`,\n    );\n  }\n  if (expectation.aliases !== undefined) {\n    assertStringSetIncludes(manifest.aliases, expectation.aliases, \"aliases\");\n  }\n  if (expectation.resources !== undefined) {\n    for (const [kind, expectedPaths] of Object.entries(expectation.resources) as Array<\n      [PmPackageResourceKind, readonly string[]]\n    >) {\n      assertStringSetIncludes(manifest.resources[kind], expectedPaths, `pm.${kind}`);\n    }\n  }\n  return manifest;\n}\n\n/**\n * Assert that an activated extension registration registry contains a command\n * contract with the expected public metadata.\n */\nexport function assertRegisteredCommandContract(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredCommandContractExpectation,\n): RegisteredCommandContractAssertion {\n  const expectedCommand = normalizeSdkCommandName(expectation.command);\n  if (expectedCommand.length === 0) {\n    throw new Error(\"Expected command name must be a non-empty string\");\n  }\n\n  const commandCandidates = registrations.commands.filter((entry) => entry.command === expectedCommand);\n  const command = expectation.extensionName\n    ? commandCandidates.find((entry) => entry.name === expectation.extensionName)\n    : commandCandidates[0];\n  if (!command) {\n    const available = registrations.commands.map((entry) => entry.command).sort((left, right) => left.localeCompare(right));\n    const extensionSuffix = expectation.extensionName ? ` from extension \"${expectation.extensionName}\"` : \"\";\n    throw new Error(\n      `Expected extension command \"${expectedCommand}\"${extensionSuffix} to be registered. Available commands: ${formatAvailable(\n        available,\n      )}`,\n    );\n  }\n\n  if (expectation.action !== undefined && command.action !== expectation.action) {\n    throw new Error(\n      `Expected extension command \"${expectedCommand}\" action \"${expectation.action}\", received \"${command.action}\"`,\n    );\n  }\n\n  if (expectation.arguments !== undefined) {\n    const actualArguments = (command.arguments ?? []).map((argument) => argument.name);\n    const missingArguments = expectation.arguments.filter((argument) => !actualArguments.includes(argument));\n    if (missingArguments.length > 0) {\n      throw new Error(\n        `Expected extension command \"${expectedCommand}\" arguments ${formatAvailable(\n          expectation.arguments,\n        )}; missing ${formatAvailable(missingArguments)}; available ${formatAvailable(actualArguments)}`,\n      );\n    }\n  }\n\n  const flags = registrations.flags\n    .filter(\n      (entry) =>\n        entry.target_command === expectedCommand &&\n        (expectation.extensionName === undefined || entry.name === expectation.extensionName),\n    )\n    .flatMap((entry) => entry.flags);\n\n  if (expectation.flags !== undefined) {\n    const actualFlagLabels = collectFlagLabels(flags);\n    const missingFlags = expectation.flags.filter((flag) => !actualFlagLabels.has(flag));\n    if (missingFlags.length > 0) {\n      throw new Error(\n        `Expected extension command \"${expectedCommand}\" flags ${formatAvailable(expectation.flags)}; missing ${formatAvailable(\n          missingFlags,\n        )}; available ${formatAvailable([...actualFlagLabels].sort((left, right) => left.localeCompare(right)))}`,\n      );\n    }\n  }\n\n  return { command, flags };\n}\n\n/**\n * Assert that an activated extension registration registry contains flags\n * injected into an existing command through `api.registerFlags(...)`.\n */\nexport function assertRegisteredFlags(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredFlagsExpectation,\n): RegisteredExtensionFlagDefinitions {\n  const expectedCommand = normalizeSdkCommandName(expectation.targetCommand);\n  if (expectedCommand.length === 0) {\n    throw new Error(\"Expected target command name must be a non-empty string\");\n  }\n\n  const candidates = registrations.flags.filter((entry) => entry.target_command === expectedCommand);\n  let registration: RegisteredExtensionFlagDefinitions | undefined;\n  if (expectation.extensionName) {\n    registration = candidates.find((entry) => entry.name === expectation.extensionName);\n  } else if (candidates.length === 1) {\n    registration = candidates[0];\n  } else if (candidates.length > 1) {\n    const availableExtensions = sortedUnique(candidates.map((entry) => entry.name));\n    throw new Error(\n      `Expected flags for target command \"${expectedCommand}\" matched multiple extensions: ${formatAvailable(\n        availableExtensions,\n      )}. Specify extensionName to choose one registration.`,\n    );\n  }\n  if (!registration) {\n    const available = sortedUnique(registrations.flags.map((entry) => entry.target_command));\n    const availableExtensions = sortedUnique(candidates.map((entry) => entry.name));\n    throw new Error(\n      `Expected flags for target command \"${expectedCommand}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available flag target commands: ${formatAvailable(available)}; matching extensions: ${formatAvailable(\n        availableExtensions,\n      )}`,\n    );\n  }\n\n  if (expectation.flags !== undefined) {\n    const actualFlagLabels = collectFlagLabels(registration.flags);\n    const missingFlags = expectation.flags.filter((flag) => !actualFlagLabels.has(flag));\n    if (missingFlags.length > 0) {\n      throw new Error(\n        `Expected flags for target command \"${expectedCommand}\" to include ${formatAvailable(\n          expectation.flags,\n        )}; missing ${formatAvailable(missingFlags)}; available ${formatAvailable(\n          [...actualFlagLabels].sort((left, right) => left.localeCompare(right)),\n        )}`,\n      );\n    }\n  }\n\n  return registration;\n}\n\n/**\n * Assert that an activated extension hook registry contains a hook of the\n * expected lifecycle kind (optionally scoped to a specific extension).\n *\n * Hooks are surfaced via `ExtensionActivationResult.hooks`, not the command\n * registration registry, so this helper accepts an `ExtensionHookRegistry`.\n */\nexport function assertRegisteredHook<TKind extends RegisteredHookKind>(\n  hooks: ExtensionHookRegistry,\n  expectation: RegisteredHookExpectation & { kind: TKind },\n): ExtensionHookRegistry[(typeof HOOK_KIND_TO_REGISTRY_FIELD)[TKind]][number] {\n  const field = HOOK_KIND_TO_REGISTRY_FIELD[expectation.kind];\n  const candidates = hooks[field] as ReadonlyArray<RegisteredExtensionHook<unknown>>;\n  const hook = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!hook) {\n    const available = sortedUnique(candidates.map((entry) => entry.name));\n    throw new Error(\n      `Expected a \"${expectation.kind}\" hook${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available \"${expectation.kind}\" hooks: ${formatAvailable(available)}`,\n    );\n  }\n\n  return hook as ExtensionHookRegistry[(typeof HOOK_KIND_TO_REGISTRY_FIELD)[TKind]][number];\n}\n\n/**\n * Assert that an activated extension registration registry contains a search\n * provider with the expected name (optionally scoped to a specific extension).\n */\nexport function assertRegisteredSearchProvider(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredSearchProviderExpectation,\n): RegisteredExtensionSearchProvider {\n  const expectedProvider = normalizeSdkIdentifier(expectation.provider);\n  if (expectedProvider.length === 0) {\n    throw new Error(\"Expected search provider name must be a non-empty string\");\n  }\n\n  const candidates = registrations.search_providers.filter(\n    (entry) => normalizeSdkIdentifier(entry.definition.name) === expectedProvider,\n  );\n  const provider = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!provider) {\n    const available = sortedUnique(registrations.search_providers.map((entry) => entry.definition.name));\n    throw new Error(\n      `Expected search provider \"${expectedProvider}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available search providers: ${formatAvailable(available)}`,\n    );\n  }\n\n  return provider;\n}\n\n/**\n * Assert that an activated extension registration registry contains a vector\n * store adapter with the expected name (optionally scoped to a specific\n * extension).\n */\nexport function assertRegisteredVectorStoreAdapter(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredVectorStoreAdapterExpectation,\n): RegisteredExtensionVectorStoreAdapter {\n  const expectedAdapter = normalizeSdkIdentifier(expectation.adapter);\n  if (expectedAdapter.length === 0) {\n    throw new Error(\"Expected vector store adapter name must be a non-empty string\");\n  }\n\n  const candidates = registrations.vector_store_adapters.filter(\n    (entry) => normalizeSdkIdentifier(entry.definition.name) === expectedAdapter,\n  );\n  const adapter = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!adapter) {\n    const available = sortedUnique(registrations.vector_store_adapters.map((entry) => entry.definition.name));\n    throw new Error(\n      `Expected vector store adapter \"${expectedAdapter}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available vector store adapters: ${formatAvailable(available)}`,\n    );\n  }\n\n  return adapter;\n}\n\n/**\n * Assert that an activated extension registration registry contains an importer\n * for the expected format/name (optionally scoped to a specific extension).\n */\nexport function assertRegisteredImporter(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredImporterExpectation,\n): RegisteredExtensionImporter {\n  const expectedImporter = normalizeSdkIdentifier(expectation.importer);\n  if (expectedImporter.length === 0) {\n    throw new Error(\"Expected importer name must be a non-empty string\");\n  }\n\n  const candidates = registrations.importers.filter(\n    (entry) => normalizeSdkIdentifier(entry.importer) === expectedImporter,\n  );\n  const importer = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!importer) {\n    const available = sortedUnique(registrations.importers.map((entry) => entry.importer));\n    throw new Error(\n      `Expected importer \"${expectedImporter}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available importers: ${formatAvailable(available)}`,\n    );\n  }\n\n  return importer;\n}\n\n/**\n * Assert that an activated extension registration registry contains an exporter\n * for the expected format/name (optionally scoped to a specific extension).\n */\nexport function assertRegisteredExporter(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredExporterExpectation,\n): RegisteredExtensionExporter {\n  const expectedExporter = normalizeSdkIdentifier(expectation.exporter);\n  if (expectedExporter.length === 0) {\n    throw new Error(\"Expected exporter name must be a non-empty string\");\n  }\n\n  const candidates = registrations.exporters.filter(\n    (entry) => normalizeSdkIdentifier(entry.exporter) === expectedExporter,\n  );\n  const exporter = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!exporter) {\n    const available = sortedUnique(registrations.exporters.map((entry) => entry.exporter));\n    throw new Error(\n      `Expected exporter \"${expectedExporter}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available exporters: ${formatAvailable(available)}`,\n    );\n  }\n\n  return exporter;\n}\n\n/**\n * Assert that an activated extension registration registry contains a custom\n * item field definition (optionally scoped to a specific extension).\n */\nexport function assertRegisteredItemField(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredItemFieldExpectation,\n): RegisteredItemFieldAssertion {\n  const expectedField = normalizeSdkIdentifier(expectation.field);\n  if (expectedField.length === 0) {\n    throw new Error(\"Expected item field name must be a non-empty string\");\n  }\n\n  const candidates = registrations.item_fields\n    .filter((entry) => expectation.extensionName === undefined || entry.name === expectation.extensionName)\n    .map((registration) => ({\n      registration,\n      field: registration.fields.find((field) => normalizeSdkIdentifier(field.name) === expectedField),\n    }))\n    .filter((entry): entry is RegisteredItemFieldAssertion => entry.field !== undefined);\n\n  const match = candidates.find((entry) => expectation.type === undefined || entry.field.type === expectation.type);\n  if (!match) {\n    const available = sortedUnique(\n      registrations.item_fields.flatMap((entry) => entry.fields.map((field) => `${field.name}:${field.type}`)),\n    );\n    throw new Error(\n      `Expected item field \"${expectedField}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available item fields: ${formatAvailable(available)}`,\n    );\n  }\n\n  return match;\n}\n\n/**\n * Assert that an activated extension registration registry contains a custom\n * item type definition (optionally scoped to a specific extension).\n */\nexport function assertRegisteredItemType(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredItemTypeExpectation,\n): RegisteredItemTypeAssertion {\n  const expectedType = normalizeSdkIdentifier(expectation.itemType);\n  if (expectedType.length === 0) {\n    throw new Error(\"Expected item type name must be a non-empty string\");\n  }\n\n  const candidates = registrations.item_types\n    .filter((entry) => expectation.extensionName === undefined || entry.name === expectation.extensionName)\n    .map((registration) => ({\n      registration,\n      itemType: registration.types.find((itemType) => normalizeSdkIdentifier(itemType.name) === expectedType),\n    }))\n    .filter((entry): entry is RegisteredItemTypeAssertion => entry.itemType !== undefined);\n\n  const match = candidates.find((entry) => expectation.folder === undefined || entry.itemType.folder === expectation.folder);\n  if (!match) {\n    const available = sortedUnique(\n      registrations.item_types.flatMap((entry) => entry.types.map((itemType) => `${itemType.name}:${itemType.folder}`)),\n    );\n    throw new Error(\n      `Expected item type \"${expectedType}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available item types: ${formatAvailable(available)}`,\n    );\n  }\n\n  return match;\n}\n\n/**\n * Assert that an activated extension registration registry contains a project\n * profile registered via `api.registerProfile(profile)` (optionally scoped to a\n * specific extension).\n *\n * This is the test-time counterpart to the declarative `defineProjectProfile`\n * authoring helper and the `pm profile list/show/apply` runtime surface: it\n * proves a package's archetype reached the registry so a downstream consumer can\n * resolve and apply it by name. Like the other declarative-surface assertions\n * (item types, item fields), a profile is verified by presence — it is staged,\n * not executed — so there is no `runRegisteredProfileForTest` counterpart.\n */\nexport function assertRegisteredProfile(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredProfileExpectation,\n): RegisteredProfileAssertion {\n  const expectedProfile = normalizeSdkProfileMatchKey(expectation.profile);\n  if (expectedProfile.length === 0) {\n    throw new Error(\"Expected profile name must be a non-empty string\");\n  }\n\n  const match = registrations.profiles\n    .filter((entry) => expectation.extensionName === undefined || entry.name === expectation.extensionName)\n    .find((entry) => normalizeSdkProfileMatchKey(entry.profile.name) === expectedProfile);\n  if (!match) {\n    const available = sortedUnique(registrations.profiles.map((entry) => entry.profile.name));\n    throw new Error(\n      `Expected profile \"${expectedProfile}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available profiles: ${formatAvailable(available)}`,\n    );\n  }\n\n  return { registration: match, profile: match.profile };\n}\n\n/**\n * Assert that an activated extension command registry contains a command\n * override registered via `api.registerCommand(command, override)` (optionally\n * scoped to a specific extension).\n *\n * Command overrides are surfaced via `ExtensionActivationResult.commands`, not\n * the command registration registry, so this helper accepts an\n * `ExtensionCommandRegistry`.\n */\nexport function assertRegisteredCommandOverride(\n  commands: ExtensionCommandRegistry,\n  expectation: RegisteredCommandOverrideExpectation,\n): RegisteredExtensionCommandOverride {\n  const expectedCommand = normalizeSdkCommandName(expectation.command);\n  if (expectedCommand.length === 0) {\n    throw new Error(\"Expected command name must be a non-empty string\");\n  }\n\n  const candidates = commands.overrides.filter((entry) => entry.command === expectedCommand);\n  const override = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!override) {\n    const available = sortedUnique(commands.overrides.map((entry) => entry.command));\n    throw new Error(\n      `Expected command override \"${expectedCommand}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available command overrides: ${formatAvailable(available)}`,\n    );\n  }\n\n  return override;\n}\n\n/**\n * Assert that an activated extension parser registry contains a parser override\n * registered via `api.registerParser(command, override)` (optionally scoped to\n * a specific extension).\n *\n * Parser overrides are surfaced via `ExtensionActivationResult.parsers`, not the\n * command registration registry, so this helper accepts an\n * `ExtensionParserRegistry`.\n */\nexport function assertRegisteredParserOverride(\n  parsers: ExtensionParserRegistry,\n  expectation: RegisteredParserOverrideExpectation,\n): RegisteredExtensionParserOverride {\n  const expectedCommand = normalizeSdkCommandName(expectation.command);\n  if (expectedCommand.length === 0) {\n    throw new Error(\"Expected command name must be a non-empty string\");\n  }\n\n  const candidates = parsers.overrides.filter((entry) => entry.command === expectedCommand);\n  const override = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!override) {\n    const available = sortedUnique(parsers.overrides.map((entry) => entry.command));\n    throw new Error(\n      `Expected parser override \"${expectedCommand}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available parser overrides: ${formatAvailable(available)}`,\n    );\n  }\n\n  return override;\n}\n\n/**\n * Assert that an activated extension preflight registry contains a preflight\n * override registered via `api.registerPreflight(override)` (optionally scoped\n * to a specific extension).\n *\n * Preflight overrides are global (they run for every command and carry no\n * `command` field), so the expectation only accepts an optional\n * `extensionName`. Preflight overrides are surfaced via\n * `ExtensionActivationResult.preflight`.\n */\nexport function assertRegisteredPreflightOverride(\n  preflight: ExtensionPreflightRegistry,\n  expectation: RegisteredPreflightOverrideExpectation = {},\n): RegisteredExtensionPreflightOverride {\n  const override = expectation.extensionName\n    ? preflight.overrides.find((entry) => entry.name === expectation.extensionName)\n    : preflight.overrides[0];\n  if (!override) {\n    const available = sortedUnique(preflight.overrides.map((entry) => entry.name));\n    throw new Error(\n      `Expected a preflight override${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available preflight overrides: ${formatAvailable(available)}`,\n    );\n  }\n\n  return override;\n}\n\n/**\n * Assert that an activated extension renderer registry contains a renderer\n * override registered via `api.registerRenderer(format, renderer)` for the\n * expected output format (optionally scoped to a specific extension).\n *\n * Renderer overrides are surfaced via `ExtensionActivationResult.renderers`.\n */\nexport function assertRegisteredRendererOverride(\n  renderers: ExtensionRendererRegistry,\n  expectation: RegisteredRendererOverrideExpectation,\n): RegisteredExtensionRendererOverride {\n  const expectedFormat = normalizeSdkIdentifier(expectation.format);\n  if (expectedFormat.length === 0) {\n    throw new Error(\"Expected renderer format must be a non-empty string\");\n  }\n\n  const candidates = renderers.overrides.filter((entry) => entry.format === expectedFormat);\n  const override = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!override) {\n    const available = sortedUnique(renderers.overrides.map((entry) => entry.format));\n    throw new Error(\n      `Expected renderer override \"${expectedFormat}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available renderer overrides: ${formatAvailable(available)}`,\n    );\n  }\n\n  return override;\n}\n\n/**\n * Assert that an activated extension service registry contains a service override\n * registered via `api.registerService(service, override)` for the expected\n * service name (optionally scoped to a specific extension).\n *\n * Service overrides are surfaced via `ExtensionActivationResult.services`, not the\n * command registration registry, so this helper accepts an\n * `ExtensionServiceRegistry`.\n */\nexport function assertRegisteredServiceOverride(\n  services: ExtensionServiceRegistry,\n  expectation: RegisteredServiceOverrideExpectation,\n): RegisteredExtensionServiceOverride {\n  const expectedService = normalizeSdkIdentifier(expectation.service);\n  if (expectedService.length === 0) {\n    throw new Error(\"Expected service name must be a non-empty string\");\n  }\n\n  const candidates = services.overrides.filter((entry) => normalizeSdkIdentifier(entry.service) === expectedService);\n  const override = expectation.extensionName\n    ? candidates.find((entry) => entry.name === expectation.extensionName)\n    : candidates[0];\n  if (!override) {\n    const available = sortedUnique(services.overrides.map((entry) => entry.service));\n    throw new Error(\n      `Expected service override \"${expectedService}\"${extensionNameSuffix(\n        expectation.extensionName,\n      )} to be registered. Available service overrides: ${formatAvailable(available)}`,\n    );\n  }\n\n  return override;\n}\n\n/**\n * Assert that an activated extension registration registry contains a schema\n * migration registered via `api.registerMigration(definition)` with the expected\n * id (optionally scoped to a specific extension and asserting the `mandatory`\n * governance flag, where an unset flag is treated as non-mandatory).\n *\n * Migrations are surfaced via `ExtensionActivationResult.registrations.migrations`.\n */\nexport function assertRegisteredMigration(\n  registrations: ExtensionRegistrationRegistry,\n  expectation: RegisteredMigrationExpectation,\n): RegisteredExtensionSchemaMigrationDefinition {\n  const expectedMigration = normalizeSdkIdentifier(expectation.migration);\n  if (expectedMigration.length === 0) {\n    throw new Error(\"Expected migration id must be a non-empty string\");\n  }\n\n  const candidates = registrations.migrations.filter(\n    (entry) =>\n      (expectation.extensionName === undefined || entry.name === expectation.extensionName) &&\n      typeof entry.definition.id === \"string\" &&\n      normalizeSdkIdentifier(entry.definition.id) === expectedMigration,\n  );\n  const match = candidates.find(\n    (entry) => expectation.mandatory === undefined || (entry.definition.mandatory ?? false) === expectation.mandatory,\n  );\n  if (match) {\n    return match;\n  }\n\n  // The id (and any extension scope) matched but the `mandatory` flag did not:\n  // report the mismatch directly rather than the misleading \"not registered\"\n  // listing. Reaching here with a candidate implies `expectation.mandatory` was\n  // set, since an unset flag matches any candidate above.\n  const idMatch = candidates[0];\n  if (idMatch !== undefined) {\n    throw new Error(\n      `Expected migration \"${expectedMigration}\"${extensionNameSuffix(expectation.extensionName)} to have ` +\n        `mandatory=${expectation.mandatory}, but it is mandatory=${idMatch.definition.mandatory ?? false}.`,\n    );\n  }\n\n  const available = sortedUnique(\n    registrations.migrations.map((entry) => {\n      const id =\n        typeof entry.definition.id === \"string\" && entry.definition.id.trim().length > 0\n          ? entry.definition.id.trim()\n          : \"(unnamed)\";\n      return `${id}:${entry.definition.mandatory === true}`;\n    }),\n  );\n  throw new Error(\n    `Expected migration \"${expectedMigration}\"${extensionNameSuffix(\n      expectation.extensionName,\n    )} to be registered. Available migrations: ${formatAvailable(available)}`,\n  );\n}\n\n/**\n * Assert that an activated extension declares no capability it never uses\n * (least privilege). Pass the same capabilities as `manifest.capabilities` via\n * `expectation.declared`; the helper computes what the extension actually\n * registered against and throws when any declared capability is unused.\n *\n * This is the package-test counterpart of the advisory\n * `extension_capability_unused` warning `pm package doctor` emits, letting an\n * author catch an over-broad manifest at `npm test` time. Returns the\n * declared/used/unused breakdown for further assertions.\n */\nexport function assertExtensionCapabilityUsage(\n  activation: ExtensionActivationResult,\n  expectation: ExtensionCapabilityUsageExpectation,\n): ExtensionCapabilityUsageAssertion {\n  const toKnownCapabilitySet = (capabilities: readonly string[], field: string): Set<ExtensionCapability> => {\n    const known = new Set<ExtensionCapability>();\n    for (const capability of capabilities) {\n      const normalized = normalizeKnownExtensionCapability(capability);\n      if (normalized === null) {\n        throw new Error(\n          `Expected ${field} capability \"${capability}\" to be a known extension capability. ` +\n            \"Use canonical capability names (see manifest.capabilities).\",\n        );\n      }\n      known.add(normalized);\n    }\n    return known;\n  };\n  const declared = [...toKnownCapabilitySet(expectation.declared, \"declared\")].sort((left, right) =>\n    left.localeCompare(right),\n  );\n  const allowUnused = toKnownCapabilitySet(expectation.allowUnused ?? [], \"allowUnused\");\n  const used = collectUsedExtensionCapabilities(activation, { extensionName: expectation.extensionName });\n  const usedSet = new Set(used);\n  const unused = declared.filter((capability) => !usedSet.has(capability) && !allowUnused.has(capability));\n  if (unused.length > 0) {\n    const scopeSuffix = extensionNameSuffix(expectation.extensionName);\n    throw new Error(\n      `Expected every declared capability${scopeSuffix} to be exercised, but [${unused.join(\n        \", \",\n      )}] ${unused.length === 1 ? \"is\" : \"are\"} declared yet never registered against. ` +\n        `Remove ${unused.length === 1 ? \"it\" : \"them\"} from manifest.capabilities for least privilege, ` +\n        \"or pass allowUnused for capabilities registered only behind a runtime flag.\",\n    );\n  }\n  return { declared, used, unused };\n}\n\n/**\n * Preflight a declarative {@link ExtensionBlueprint} in a test, throwing if it has\n * any `error`-severity issue (today: capability the blueprint exercises but the\n * declared set omits, which would fail activation with `extension_capability_missing`).\n *\n * The throwing counterpart to {@link lintExtensionBlueprint} and the `assert*`\n * family member for declarative authoring: drop `assertExtensionBlueprint(blueprint)`\n * into a package's `node:test`/Vitest suite to fail CI before the blueprint is\n * ever activated. The full {@link ExtensionBlueprintLintResult} is returned on\n * success so a test can still inspect advisory warnings (unused capability,\n * duplicate command, empty surface) without failing on them.\n */\nexport function assertExtensionBlueprint(\n  blueprint: ExtensionBlueprint,\n  options: LintExtensionBlueprintOptions = {},\n): ExtensionBlueprintLintResult {\n  const result = lintExtensionBlueprint(blueprint, options);\n  if (!result.ok) {\n    const errors = result.findings.filter((finding) => finding.severity === \"error\");\n    throw new Error(\n      `Extension blueprint failed preflight with ${errors.length} ${errors.length === 1 ? \"error\" : \"errors\"}:\\n` +\n        errors.map((finding) => `  - [${finding.code}] ${finding.message}`).join(\"\\n\"),\n    );\n  }\n  return result;\n}\n\n/** Options for {@link assertProjectProfile}. */\nexport interface AssertProjectProfileOptions {\n  /**\n   * Also throw when the profile produces `warning`-severity findings (e.g. a\n   * workflow transition referencing a status no profile or built-in defines).\n   * Off by default so warnings stay advisory; turn on for strict CI gates.\n   */\n  strict?: boolean;\n}\n\n/**\n * Assert a {@link ProjectProfileDefinition} is internally consistent in a test,\n * throwing on any `error`-severity finding (and on `warning`-severity findings\n * too when `strict` is set). The author-time counterpart to `defineProjectProfile`\n * and the project-profile analogue of {@link assertExtensionBlueprint}: drop\n * `assertProjectProfile(myProfile)` into a package's `node:test`/Vitest suite to\n * fail CI before the profile is ever registered via `api.registerProfile` or\n * applied via `pm profile apply`. The full {@link ProjectProfileLintReport} is\n * returned on success so a test can still inspect advisory warnings without\n * failing on them.\n */\nexport function assertProjectProfile(\n  profile: ProjectProfileDefinition,\n  options: AssertProjectProfileOptions = {},\n): ProjectProfileLintReport {\n  const report = lintProjectProfile(profile);\n  const blocking = report.findings.filter(\n    (finding) => finding.severity === \"error\" || (options.strict === true && finding.severity === \"warning\"),\n  );\n  if (blocking.length > 0) {\n    throw new Error(\n      `Project profile \"${report.profile}\" failed lint with ${blocking.length} ${blocking.length === 1 ? \"issue\" : \"issues\"}:\\n` +\n        blocking.map((finding) => `  - ${finding.severity} [${finding.code}] ${finding.message}`).join(\"\\n\"),\n    );\n  }\n  return report;\n}\n\n/**\n * The structured result of {@link assertExtensionManifestMatchesBlueprint}: the\n * reconciliation between a manifest's declared capabilities and the set the\n * blueprint actually exercises. Returned only when they match exactly (the\n * assertion throws otherwise).\n */\nexport interface ExtensionManifestBlueprintMatch {\n  /** The least-privilege capability set the blueprint exercises (from `deriveExtensionCapabilities`). */\n  used: ExtensionCapability[];\n  /** The manifest's declared capabilities, legacy-alias resolved and normalized. */\n  declared: ExtensionCapability[];\n  /** Capabilities the blueprint uses but the manifest omits — would crash activation. Empty on success. */\n  missing: ExtensionCapability[];\n  /** Capabilities the manifest declares but no surface exercises — violates least privilege. Empty on success. */\n  unused: ExtensionCapability[];\n  /** Every lint finding for the blueprint, so callers can inspect advisory warnings. */\n  findings: ExtensionBlueprintLintFinding[];\n}\n\n/**\n * Strictly assert a manifest's `capabilities` equal the least-privilege set a\n * declarative {@link ExtensionBlueprint} exercises, throwing on any drift in\n * either direction.\n *\n * This is the strict bookend to the lenient {@link assertExtensionBlueprint}:\n * where that helper fails only on an *undeclared* capability (the `error`-severity\n * `extension_capability_missing` activation crash) and merely *warns* on an unused\n * one, this assertion fails on **both** — an undeclared capability (`missing`) and\n * a declared-but-unused one (`unused`) — so a hand-maintained `manifest.json` stays\n * exactly the set the blueprint requires. Drop it into a package's\n * `node:test`/Vitest suite to guard against capability drift in CI, the natural\n * companion to {@link ../sdk/compose.js#synthesizeExtensionManifest} (assert what\n * you would otherwise generate). Only `capabilities` are reconciled because that is\n * the one manifest field a blueprint determines.\n *\n * The reconciliation is returned on success so a test can still inspect advisory\n * warnings (duplicate command, empty surface) without failing on them.\n */\nexport function assertExtensionManifestMatchesBlueprint(\n  manifest: Pick<ExtensionManifest, \"capabilities\">,\n  blueprint: ExtensionBlueprint,\n): ExtensionManifestBlueprintMatch {\n  // Coerce a malformed/absent capabilities field to an explicit empty declared set\n  // so an untyped `.js` caller gets a deterministic `missing` list rather than the\n  // lint silently falling back to the blueprint's in-module manifest mirror.\n  const declaredCapabilities = Array.isArray(manifest.capabilities) ? manifest.capabilities : [];\n  const result = lintExtensionBlueprint(blueprint, { declaredCapabilities });\n  // `declared` is guaranteed non-null here: we always hand lint an array, so it\n  // never takes its \"no declared set\" branch. The cast drops the unreachable null.\n  const declared = result.declared as ExtensionCapability[];\n  const declaredSet = new Set(declared);\n  const usedSet = new Set(result.used);\n  const missing = result.used.filter((capability) => !declaredSet.has(capability));\n  const unused = declared.filter((capability) => !usedSet.has(capability));\n  if (missing.length > 0 || unused.length > 0) {\n    const parts: string[] = [];\n    if (missing.length > 0) {\n      parts.push(`missing [${missing.join(\", \")}] (the blueprint registers ${missing.length === 1 ? \"a surface\" : \"surfaces\"} requiring ${missing.length === 1 ? \"it\" : \"them\"}; activation throws extension_capability_missing)`);\n    }\n    if (unused.length > 0) {\n      parts.push(`unused [${unused.join(\", \")}] (declared but no surface exercises ${unused.length === 1 ? \"it\" : \"them\"}; drop for least privilege)`);\n    }\n    throw new Error(\n      `Manifest capabilities do not match the blueprint: ${parts.join(\"; \")}. ` +\n        \"Set capabilities to synthesizeExtensionManifest(blueprint, identity).capabilities to stay in sync.\",\n    );\n  }\n  return { used: result.used, declared, missing, unused, findings: result.findings };\n}\n\n/**\n * Assert an extension manifest's declared version bounds permit it to load on a\n * target pm CLI version, throwing when a bound blocks the load.\n *\n * This is the throwing CI/test counterpart to\n * {@link ../sdk/compose.js#checkExtensionManifestCompatibility}: it runs the same\n * author-time version-bound analysis and fails on any blocking incompatibility — a\n * malformed bound (`*_invalid`), a `pm_min_version` the target is below\n * (`pm_min_version_unmet`), or a `block`-mode `pm_max_version` the target exceeds\n * (`pm_max_version_exceeded`). Advisory `warning` findings (`*_unchecked`, or a\n * `warn`-mode `pm_max_version_exceeded_warn`) never throw, because the loader\n * would still load the extension. Pin it to the pm version a package commits to\n * supporting so a too-tight or malformed bound fails the package's own suite, not\n * a user's install. The full compatibility result is returned on success so a test\n * can still inspect advisory warnings.\n */\nexport function assertExtensionManifestCompatible(\n  manifest: ExtensionManifestCompatibilityManifest,\n  target: ExtensionManifestCompatibilityTarget,\n): ExtensionManifestCompatibilityResult {\n  const result = checkExtensionManifestCompatibility(manifest, target);\n  const blocking = result.findings.filter((finding) => finding.severity === \"error\");\n  if (blocking.length > 0) {\n    throw new Error(\n      `Extension manifest is not compatible with pm ${result.pmVersion}: ${blocking\n        .map((finding) => finding.message)\n        .join(\"; \")}`,\n    );\n  }\n  return result;\n}\n\n/**\n * Preflight a declarative {@link ExtensionBlueprint} through every author-time\n * check in one test, throwing if any stage produced an `error`-severity finding.\n *\n * This is the throwing CI/test bookend over\n * {@link ../sdk/compose.js#preflightExtension} — the single guard that replaces\n * chaining {@link assertExtensionBlueprint}, {@link assertExtensionManifestMatchesBlueprint},\n * and {@link assertExtensionManifestCompatible} in a package's\n * `node:test`/Vitest suite. It runs the same consolidated analysis (always lints\n * the blueprint; synthesizes the manifest when `options.identity` is given; checks\n * version bounds when `options.target` is given) and throws one error listing every\n * blocking finding tagged by its `source:code`. Advisory `warning` findings (an\n * unused capability, a duplicate command, an `*_unchecked` bound) never throw,\n * matching the underlying stages. The full {@link ExtensionPreflightReport} is\n * returned on success so a test can still inspect those warnings, the synthesized\n * manifest, and the derived capability set without failing on them.\n */\nexport function assertExtensionPreflight(\n  blueprint: ExtensionBlueprint,\n  options: PreflightExtensionOptions = {},\n): ExtensionPreflightReport {\n  const report = preflightExtension(blueprint, options);\n  if (!report.ok) {\n    const errors = report.findings.filter((finding) => finding.severity === \"error\");\n    throw new Error(\n      `Extension failed preflight with ${errors.length} ${errors.length === 1 ? \"error\" : \"errors\"}:\\n` +\n        errors.map((finding) => `  - [${finding.source}:${finding.code}] ${finding.message}`).join(\"\\n\"),\n    );\n  }\n  return report;\n}\n\n/**\n * A fluent, single-extension test fixture returned by\n * {@link createExtensionTestHarness}.\n *\n * Every method binds one of the standalone SDK testing helpers to the correct\n * sub-registry of a single {@link ExtensionActivationResult}, so a package author\n * never threads `activation.registrations` vs `activation.commands` vs\n * `activation.hooks` (etc.) by hand — picking the wrong sub-registry is a common\n * footgun that surfaces as a confusing `available: (none)` error. Methods do not\n * use `this`; they close over the activation, so they remain safe to destructure\n * (`const { runCommand, assertCommandContract } = harness;`).\n *\n * The `assert*` methods verify registration wiring (returning the matched\n * registration); the `run*` methods invoke a registered surface through pm's real\n * dispatch engine (returning its runtime result); {@link deactivate} runs the real\n * teardown engine. The raw {@link activation} stays public as an escape hatch to\n * the standalone helpers for any surface not covered by a convenience method.\n */\nexport interface ExtensionTestHarness {\n  /** The in-memory extension module supplied to {@link createExtensionTestHarness}. */\n  readonly module: unknown;\n  /** Resolved extension name (manifest name, explicit override, or `\"test-extension\"`). */\n  readonly name: string;\n  /** Layer recorded for the in-memory extension (defaults to `\"project\"`). */\n  readonly layer: ExtensionLayer;\n  /** The underlying activation result; use it to reach standalone helpers directly. */\n  readonly activation: ExtensionActivationResult;\n\n  /** Bound {@link describeExtensionActivation} over the whole `activation`. */\n  activationSummary(options?: DescribeExtensionActivationOptions): ExtensionActivationSummary;\n  /**\n   * Bound {@link renderExtensionSurfaceMarkdown} over {@link activationSummary},\n   * so tests and README generators can produce deterministic surface docs from\n   * the same harness they use for assert/run coverage.\n   */\n  renderMarkdown(options?: RenderExtensionHarnessMarkdownOptions): string;\n\n  /** Bound {@link assertRegisteredCommandContract} over `activation.registrations`. */\n  assertCommandContract(expectation: RegisteredCommandContractExpectation): RegisteredCommandContractAssertion;\n  /** Bound {@link assertRegisteredFlags} over `activation.registrations`. */\n  assertFlags(expectation: RegisteredFlagsExpectation): RegisteredExtensionFlagDefinitions;\n  /** Bound {@link assertRegisteredItemField} over `activation.registrations`. */\n  assertItemField(expectation: RegisteredItemFieldExpectation): RegisteredItemFieldAssertion;\n  /** Bound {@link assertRegisteredItemType} over `activation.registrations`. */\n  assertItemType(expectation: RegisteredItemTypeExpectation): RegisteredItemTypeAssertion;\n  /** Bound {@link assertRegisteredProfile} over `activation.registrations`. */\n  assertProfile(expectation: RegisteredProfileExpectation): RegisteredProfileAssertion;\n  /** Bound {@link assertRegisteredHook} over `activation.hooks`. */\n  assertHook<TKind extends RegisteredHookKind>(\n    expectation: RegisteredHookExpectation & { kind: TKind },\n  ): ExtensionHookRegistry[(typeof HOOK_KIND_TO_REGISTRY_FIELD)[TKind]][number];\n  /** Bound {@link assertRegisteredCommandOverride} over `activation.commands`. */\n  assertCommandOverride(expectation: RegisteredCommandOverrideExpectation): RegisteredExtensionCommandOverride;\n  /** Bound {@link assertRegisteredParserOverride} over `activation.parsers`. */\n  assertParserOverride(expectation: RegisteredParserOverrideExpectation): RegisteredExtensionParserOverride;\n  /** Bound {@link assertRegisteredPreflightOverride} over `activation.preflight`. */\n  assertPreflightOverride(expectation?: RegisteredPreflightOverrideExpectation): RegisteredExtensionPreflightOverride;\n  /** Bound {@link assertRegisteredRendererOverride} over `activation.renderers`. */\n  assertRendererOverride(expectation: RegisteredRendererOverrideExpectation): RegisteredExtensionRendererOverride;\n  /** Bound {@link assertRegisteredServiceOverride} over `activation.services`. */\n  assertServiceOverride(expectation: RegisteredServiceOverrideExpectation): RegisteredExtensionServiceOverride;\n  /** Bound {@link assertRegisteredSearchProvider} over `activation.registrations`. */\n  assertSearchProvider(expectation: RegisteredSearchProviderExpectation): RegisteredExtensionSearchProvider;\n  /** Bound {@link assertRegisteredVectorStoreAdapter} over `activation.registrations`. */\n  assertVectorStoreAdapter(expectation: RegisteredVectorStoreAdapterExpectation): RegisteredExtensionVectorStoreAdapter;\n  /** Bound {@link assertRegisteredImporter} over `activation.registrations`. */\n  assertImporter(expectation: RegisteredImporterExpectation): RegisteredExtensionImporter;\n  /** Bound {@link assertRegisteredExporter} over `activation.registrations`. */\n  assertExporter(expectation: RegisteredExporterExpectation): RegisteredExtensionExporter;\n  /** Bound {@link assertRegisteredMigration} over `activation.registrations`. */\n  assertMigration(expectation: RegisteredMigrationExpectation): RegisteredExtensionSchemaMigrationDefinition;\n  /** Bound {@link assertExtensionCapabilityUsage} over the whole `activation`. */\n  assertCapabilityUsage(expectation: ExtensionCapabilityUsageExpectation): ExtensionCapabilityUsageAssertion;\n\n  /** Bound {@link runRegisteredCommandForTest} over `activation.commands`. */\n  runCommand(options: RunRegisteredCommandForTestOptions): Promise<CommandHandlerResult>;\n  /** Bound {@link runRegisteredHookForTest} over `activation.hooks`. */\n  runHook(options: RunRegisteredHookForTestOptions): Promise<string[]>;\n  /** Bound {@link runRegisteredCommandOverrideForTest} over `activation.commands`. */\n  runCommandOverride(context: CommandOverrideContext): Promise<CommandOverrideResult>;\n  /** Bound {@link runRegisteredParserOverrideForTest} over `activation.parsers`. */\n  runParserOverride(context: ParserOverrideContext): Promise<ParserOverrideResult>;\n  /** Bound {@link runRegisteredPreflightOverrideForTest} over `activation.preflight`. */\n  runPreflightOverride(context: PreflightOverrideContext): Promise<PreflightOverrideResult>;\n  /** Bound {@link runRegisteredRendererOverrideForTest} over `activation.renderers`. */\n  runRendererOverride(context: RendererOverrideContext): Promise<RendererOverrideResult>;\n  /** Bound {@link runRegisteredServiceOverrideForTest} over `activation.services`. */\n  runServiceOverride(context: ServiceOverrideContext): Promise<ServiceOverrideResult>;\n  /** Bound {@link runRegisteredSearchProviderForTest} over `activation.registrations`. */\n  runSearchProvider<Operation extends keyof SearchProviderOperationContexts>(options: {\n    provider: string;\n    operation: Operation;\n    context: SearchProviderOperationContexts[Operation];\n  }): Promise<SearchProviderOperationResults[Operation]>;\n  /** Bound {@link runRegisteredVectorStoreAdapterForTest} over `activation.registrations`. */\n  runVectorStoreAdapter<Operation extends keyof VectorStoreAdapterOperationContexts>(options: {\n    adapter: string;\n    operation: Operation;\n    context: VectorStoreAdapterOperationContexts[Operation];\n  }): Promise<VectorStoreAdapterOperationResults[Operation]>;\n  /** Bound {@link runRegisteredMigrationForTest} over `activation.registrations`. */\n  runMigration(options: RunRegisteredMigrationForTestOptions): Promise<unknown>;\n  /** Bound {@link runRegisteredImporterForTest} over the whole `activation`. */\n  runImporter(options: RunRegisteredImporterForTestOptions): Promise<CommandHandlerResult>;\n  /** Bound {@link runRegisteredExporterForTest} over the whole `activation`. */\n  runExporter(options: RunRegisteredExporterForTestOptions): Promise<CommandHandlerResult>;\n\n  /**\n   * Bound {@link deactivateExtensionForTest} — runs the real teardown engine for\n   * this harness's module, forwarding its resolved `name`/`layer`/`activation` so\n   * the skip-key matches and a never-initialized extension is not deactivated.\n   */\n  deactivate(options?: { deactivateTimeoutMs?: number }): Promise<ExtensionDeactivationResult>;\n}\n\n/**\n * Reject obviously wrong harness input (e.g. an options object passed as the\n * module) instead of silently producing an empty activation. Mirrors the\n * loader's activatable-extension shapes: an `activate` function on the module\n * or on its default export.\n */\nfunction assertTestModuleHasActivateExport(module: unknown): void {\n  if (resolveActivatablePropertyRecord(module)) {\n    return;\n  }\n  throw new Error(\n    \"createExtensionTestHarness received a module with no activate export. Pass the extension module (with an activate(api) function on the module or its default export) as the first argument, and options second.\",\n  );\n}\n\n/**\n * Activate one in-memory extension module and return a fluent\n * {@link ExtensionTestHarness} that binds every SDK testing helper to the right\n * sub-registry of the resulting activation.\n *\n * This is the ergonomic capstone over the standalone helpers: instead of\n * `activateExtensionForTest(module)` followed by repeatedly threading\n * `activation.registrations` / `activation.commands` / `activation.hooks` into\n * each `assertRegistered*` / `runRegistered*` call, an author writes\n * `const ext = await createExtensionTestHarness(module, { capabilities });` and\n * then `ext.assertCommandContract(...)`, `await ext.runCommand(...)`,\n * `await ext.deactivate()` — never needing to know pm's internal registry layout.\n *\n * `name` and `layer` are resolved exactly as {@link activateExtensionForTest}\n * resolves them, and captured so {@link ExtensionTestHarness.deactivate} forwards\n * a matching skip-key. Activation runs pm's real validation/activation engine, so\n * every bound helper exercises real wiring and dispatch — not mocks.\n *\n * Fails fast: if the module does not activate cleanly (e.g. a registration is\n * dropped because the manifest omits the required capability), this throws a\n * descriptive error listing each failure instead of returning a harness whose\n * registries are empty — which would otherwise surface later as the confusing\n * `available: (none)` assertion error this helper exists to prevent. Tests that\n * deliberately exercise a *failed* activation should call\n * {@link activateExtensionForTest} directly and inspect `activation.failed`.\n */\nexport async function createExtensionTestHarness(\n  module: unknown,\n  options: ActivateExtensionForTestOptions = {},\n): Promise<ExtensionTestHarness> {\n  assertTestModuleHasActivateExport(module);\n  const manifest = readTestExtensionManifest(module);\n  const name = resolveTestExtensionName(manifest, options.name);\n  const layer: ExtensionLayer = options.layer ?? \"project\";\n  const activation = await activateExtensionForTest(module, options);\n  if (activation.failed.length > 0) {\n    const detail = activation.failed\n      .map((failure) => {\n        const missingCapability = failure.trace?.missing_capability;\n        const reason = missingCapability ? `${failure.error}; missing capability \"${missingCapability}\"` : failure.error;\n        return `${failure.layer}:${failure.name} (${reason})`;\n      })\n      .join(\", \");\n    throw new Error(\n      `createExtensionTestHarness could not activate the extension cleanly: ${detail}. ` +\n        \"Declare the required capability in the manifest (or pass it via options.capabilities), \" +\n        \"or use activateExtensionForTest directly to inspect a failed activation.\",\n    );\n  }\n  return {\n    module,\n    name,\n    layer,\n    activation,\n    activationSummary(describeOptions) {\n      return describeExtensionActivation(activation, describeOptions);\n    },\n    renderMarkdown(markdownOptions = {}) {\n      const { extensionName, ...renderOptions } = markdownOptions ?? {};\n      return renderExtensionSurfaceMarkdown(describeExtensionActivation(activation, { extensionName }), renderOptions);\n    },\n    assertCommandContract(expectation) {\n      return assertRegisteredCommandContract(activation.registrations, expectation);\n    },\n    assertFlags(expectation) {\n      return assertRegisteredFlags(activation.registrations, expectation);\n    },\n    assertItemField(expectation) {\n      return assertRegisteredItemField(activation.registrations, expectation);\n    },\n    assertItemType(expectation) {\n      return assertRegisteredItemType(activation.registrations, expectation);\n    },\n    assertProfile(expectation) {\n      return assertRegisteredProfile(activation.registrations, expectation);\n    },\n    assertHook(expectation) {\n      return assertRegisteredHook(activation.hooks, expectation);\n    },\n    assertCommandOverride(expectation) {\n      return assertRegisteredCommandOverride(activation.commands, expectation);\n    },\n    assertParserOverride(expectation) {\n      return assertRegisteredParserOverride(activation.parsers, expectation);\n    },\n    assertPreflightOverride(expectation) {\n      return assertRegisteredPreflightOverride(activation.preflight, expectation);\n    },\n    assertRendererOverride(expectation) {\n      return assertRegisteredRendererOverride(activation.renderers, expectation);\n    },\n    assertServiceOverride(expectation) {\n      return assertRegisteredServiceOverride(activation.services, expectation);\n    },\n    assertSearchProvider(expectation) {\n      return assertRegisteredSearchProvider(activation.registrations, expectation);\n    },\n    assertVectorStoreAdapter(expectation) {\n      return assertRegisteredVectorStoreAdapter(activation.registrations, expectation);\n    },\n    assertImporter(expectation) {\n      return assertRegisteredImporter(activation.registrations, expectation);\n    },\n    assertExporter(expectation) {\n      return assertRegisteredExporter(activation.registrations, expectation);\n    },\n    assertMigration(expectation) {\n      return assertRegisteredMigration(activation.registrations, expectation);\n    },\n    assertCapabilityUsage(expectation) {\n      return assertExtensionCapabilityUsage(activation, expectation);\n    },\n    runCommand(runOptions) {\n      return runRegisteredCommandForTest(activation.commands, runOptions);\n    },\n    runHook(runOptions) {\n      return runRegisteredHookForTest(activation.hooks, runOptions);\n    },\n    runCommandOverride(context) {\n      return runRegisteredCommandOverrideForTest(activation.commands, context);\n    },\n    runParserOverride(context) {\n      return runRegisteredParserOverrideForTest(activation.parsers, context);\n    },\n    runPreflightOverride(context) {\n      return runRegisteredPreflightOverrideForTest(activation.preflight, context);\n    },\n    runRendererOverride(context) {\n      return runRegisteredRendererOverrideForTest(activation.renderers, context);\n    },\n    runServiceOverride(context) {\n      return runRegisteredServiceOverrideForTest(activation.services, context);\n    },\n    runSearchProvider(runOptions) {\n      return runRegisteredSearchProviderForTest(activation.registrations, runOptions);\n    },\n    runVectorStoreAdapter(runOptions) {\n      return runRegisteredVectorStoreAdapterForTest(activation.registrations, runOptions);\n    },\n    runMigration(runOptions) {\n      return runRegisteredMigrationForTest(activation.registrations, runOptions);\n    },\n    runImporter(runOptions) {\n      return runRegisteredImporterForTest(activation, runOptions);\n    },\n    runExporter(runOptions) {\n      return runRegisteredExporterForTest(activation, runOptions);\n    },\n    deactivate(deactivateOptions = {}) {\n      return deactivateExtensionForTest(module, {\n        name,\n        layer,\n        activation,\n        deactivateTimeoutMs: deactivateOptions.deactivateTimeoutMs,\n      });\n    },\n  };\n}\n"],"names":[],"mappings":"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","debugId":"30820bf7-18ff-502d-a376-4f04726e1bec"}