@unbrained/pm-cli 2026.9.6 → 2026.9.8

package/dist/sdk/testing.js

@@ -1,1392 +1,5 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a09f5e0d-fccc-5a22-a6f3-0a37cbeea3b0")}catch(e){}}();
-import { activateExtensions, deactivateExtensions, runAfterCommandHooks, runBeforeCommandHooks, runBeforeMutationHooks, runCommandHandler, runCommandOverride, runOnIndexHooks, runOnReadHooks, runOnWriteHooks, runParserOverride, runPreflightOverride, runRendererOverride, runServiceOverride, } from "../core/extensions/loader.js";
-import { createDefaultExtensionGovernancePolicy } from "../core/extensions/extension-types.js";
-import { getMigrationRuntimeDefinition, resolveRegisteredSearchProvider, resolveRegisteredVectorStoreAdapter, } from "../core/extensions/runtime-registrations.js";
-import { collectUsedExtensionCapabilities } from "../core/extensions/capability-usage.js";
-import { normalizeKnownExtensionCapability } from "../core/extensions/extension-capability-aliases.js";
-import { checkExtensionManifestCompatibility, describeExtensionBlueprint, lintExtensionBlueprint, preflightExtension, } from "./compose.js";
-import { describeExtensionActivation } from "../core/extensions/activation-summary.js";
-import { lintProjectProfile, } from "../core/profile/profile-lint.js";
-import { renderExtensionSurfaceMarkdown } from "../core/extensions/activation-summary-markdown.js";
-import { asPropertyRecord, resolveActivatablePropertyRecord, } from "../core/shared/primitives.js";
-import { createExtensionCommandSdk } from "./extension-command-context.js";
-import { PmClient } from "./runtime.js";
-// `describeExtensionActivation` is the `describe` (enumerate-all) verb that
-// pairs with the `assert*` (verify-one) and `run*` (invoke-one) helpers below.
-// It lives in core (it walks the same registries the loader populates) and is
-// surfaced here so package authors get the whole testing surface from the
-// `@unbrained/pm-cli/sdk/testing` subpath.
-export { describeExtensionActivation, renderExtensionSurfaceMarkdown };
-// `composeExtension`'s author-time companions: describe a blueprint's surface map
-// and preflight it for capability drift / duplicate / empty-surface footguns
-// without activating. Surfaced through the `@unbrained/pm-cli/sdk/testing` subpath
-// so a package author gets the full author → describe → preflight → test loop here,
-// alongside the assert*/run* helpers; `assertExtensionBlueprint` below is the
-// throwing assertion that pairs with the non-throwing `lintExtensionBlueprint`.
-export { describeExtensionBlueprint, lintExtensionBlueprint };
-function registeredExpectationName(expectation, legacyValue) {
-    return expectation.name ?? legacyValue ?? "";
-}
-const HOOK_KIND_TO_REGISTRY_FIELD = {
-    before_command: "beforeCommand",
-    before_mutation: "beforeMutation",
-    after_command: "afterCommand",
-    on_read: "onRead",
-    on_write: "onWrite",
-    on_index: "onIndex",
-};
-const RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD = {
-    before_command: "beforeCommand",
-    after_command: "afterCommand",
-    on_read: "onRead",
-    on_write: "onWrite",
-    on_index: "onIndex",
-};
-function normalizeSdkIdentifier(value) {
-    return value.trim().toLowerCase();
-}
-/**
- * Match key for profile-name assertions. Extends {@link normalizeSdkIdentifier}
- * with hyphen→underscore folding so the assertion mirrors the runtime profile
- * resolution (`pm profile`), which treats `my-flow` and `my_flow` as the same
- * archetype. Profiles are the one registration surface that resolves
- * hyphen-insensitively (item types resolve by alias, migrations by exact id), so
- * — unlike the other `assertRegistered*` helpers — this one folds the separator
- * to stay in lockstep with how a profile is actually looked up by name.
- */
-function normalizeSdkProfileMatchKey(value) {
-    return normalizeSdkIdentifier(value).replaceAll("-", "_");
-}
-function extensionNameSuffix(extensionName) {
-    return extensionName ? ` from extension "${extensionName}"` : "";
-}
-function sortedUnique(values) {
-    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function normalizeSdkCommandName(command) {
-    if (typeof command !== "string") {
-        // Positional misuse like runRegisteredCommandForTest(activation, "name", opts)
-        // reaches here with `undefined` at runtime; guide instead of crashing on .trim().
-        throw new Error('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.');
-    }
-    return command
-        .trim()
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((part) => part.length > 0)
-        .join(" ");
-}
-function formatAvailable(values) {
-    return values.length > 0 ? values.join(", ") : "(none)";
-}
-function assertStringSetIncludes(actual, expected, label) {
-    const actualValues = new Set(actual ?? []);
-    const missing = sortedUnique(expected.filter((value) => !actualValues.has(value)));
-    if (missing.length > 0) {
-        throw new Error(`Expected package manifest ${label} to include ${missing.join(", ")}; available: ${formatAvailable(sortedUnique(actual ?? []))}`);
-    }
-}
-function collectFlagLabels(flags) {
-    const labels = new Set();
-    for (const flag of flags) {
-        if (typeof flag.long === "string" && flag.long.trim().length > 0) {
-            labels.add(flag.long.trim());
-        }
-        if (typeof flag.short === "string" && flag.short.trim().length > 0) {
-            labels.add(flag.short.trim());
-        }
-    }
-    return labels;
-}
-function readTestExtensionManifest(module) {
-    const moduleRecord = asPropertyRecord(module);
-    if (!moduleRecord) {
-        return {};
-    }
-    const manifest = asPropertyRecord(moduleRecord.manifest);
-    if (manifest) {
-        return manifest;
-    }
-    const defaultExport = asPropertyRecord(moduleRecord.default);
-    const defaultManifest = asPropertyRecord(defaultExport?.manifest);
-    if (defaultManifest) {
-        return defaultManifest;
-    }
-    if (defaultExport &&
-        typeof moduleRecord.default !== "function" &&
-        ("name" in defaultExport || "capabilities" in defaultExport)) {
-        return defaultExport;
-    }
-    if (typeof module !== "function" &&
-        ("name" in moduleRecord || "capabilities" in moduleRecord)) {
-        return moduleRecord;
-    }
-    return {};
-}
-function resolveTestExtensionName(manifest, explicitName) {
-    return (explicitName ??
-        (typeof manifest.name === "string" && manifest.name.trim().length > 0
-            ? manifest.name.trim()
-            : "test-extension"));
-}
-function readTestExtensionCapabilities(manifest, options) {
-    if (Array.isArray(options.capabilities)) {
-        return [...options.capabilities];
-    }
-    if (Array.isArray(manifest.capabilities)) {
-        return manifest.capabilities.filter((capability) => typeof capability === "string");
-    }
-    return [];
-}
-/**
- * Build the synthetic single-extension {@link ExtensionLoadResult} shared by the
- * activate/deactivate test helpers, so both stay aligned with the loader's load
- * contract as it evolves. The `loaded` entry mirrors the real on-disk shape
- * (including `capabilities` and the compatibility fields) while leaving
- * filesystem paths empty, since the module is supplied in memory.
- */
-function buildSingleExtensionLoadResult(module, manifest, identity) {
-    return {
-        disabled_by_flag: false,
-        roots: { global: "", project: "" },
-        configured_enabled: [],
-        configured_disabled: [],
-        discovered: [],
-        effective: [],
-        warnings: [],
-        policy: identity.policy,
-        failed: [],
-        loaded: [
-            {
-                layer: identity.layer,
-                directory: "",
-                manifest_path: "",
-                name: identity.name,
-                version: typeof manifest.version === "string" ? manifest.version : "0.0.0",
-                entry: typeof manifest.entry === "string" ? manifest.entry : "./index.js",
-                priority: typeof manifest.priority === "number" ? manifest.priority : 0,
-                entry_path: "",
-                capabilities: identity.capabilities,
-                manifest_version: typeof manifest.manifest_version === "number"
-                    ? manifest.manifest_version
-                    : undefined,
-                pm_min_version: typeof manifest.pm_min_version === "string"
-                    ? manifest.pm_min_version
-                    : undefined,
-                pm_max_version: typeof manifest.pm_max_version === "string"
-                    ? manifest.pm_max_version
-                    : undefined,
-                engines: manifest.engines,
-                trusted: manifest.trusted,
-                provenance: manifest.provenance,
-                sandbox_profile: manifest.sandbox_profile,
-                permissions: manifest.permissions,
-                activation: manifest.activation,
-                module,
-            },
-        ],
-    };
-}
-/**
- * Activate one in-memory extension module for package tests.
- *
- * This uses pm's real registration validation and activation engine while
- * avoiding private loader imports, filesystem manifests, or workspace setup.
- */
-export async function activateExtensionForTest(module, options = {}) {
-    const manifest = readTestExtensionManifest(module);
-    return activateExtensions(buildSingleExtensionLoadResult(module, manifest, {
-        name: resolveTestExtensionName(manifest, options.name),
-        layer: options.layer ?? "project",
-        capabilities: readTestExtensionCapabilities(manifest, options),
-        policy: options.policy ?? createDefaultExtensionGovernancePolicy(),
-    }));
-}
-/**
- * Deactivate one in-memory extension module for package tests — the teardown
- * counterpart to {@link activateExtensionForTest}.
- *
- * Runs pm's real `deactivateExtensions` engine (including its bounded per-hook
- * timeout and best-effort failure capture) over a single synthetic load entry,
- * so authors can prove an extension's `deactivate` releases the resources its
- * `activate` opened — without importing private loader internals or staging a
- * workspace. Resolve `name`/`layer` the same way {@link activateExtensionForTest}
- * does so a forwarded `activation` result skips a failed extension correctly.
- */
-export async function deactivateExtensionForTest(module, options = {}) {
-    const manifest = readTestExtensionManifest(module);
-    return deactivateExtensions(buildSingleExtensionLoadResult(module, manifest, {
-        name: resolveTestExtensionName(manifest, options.name),
-        layer: options.layer ?? "project",
-        capabilities: readTestExtensionCapabilities(manifest, {}),
-        policy: createDefaultExtensionGovernancePolicy(),
-    }), options.activation, options.deactivateTimeoutMs === undefined
-        ? {}
-        : { deactivate_timeout_ms: options.deactivateTimeoutMs });
-}
-/**
- * Invoke a registered extension command handler and return its real
- * {@link CommandHandlerResult} so package tests can assert on behavior — not
- * just that the command was registered.
- *
- * This is the "invoke" verb that completes the package-author testing loop:
- * `activateExtensionForTest` → `assertRegisteredCommandContract` → **run** →
- * `deactivateExtensionForTest`. It runs pm's real handler-dispatch engine
- * (`runCommandHandler`) over `activation.commands`, building the
- * `CommandHandlerContext` with agent-safe global defaults
- * (`{ json: true, quiet: true, noPager: true }`) that callers may override.
- *
- * Because `registerImporter`/`registerExporter` register their handlers under
- * the `"<name> import"` / `"<name> export"` command paths, this same helper
- * exercises importer and exporter handlers too.
- *
- * Throws a descriptive error (listing the available handler command paths) when
- * no handler is registered for `command`, since that is a wiring/typo bug in the
- * test rather than a behavior under test. When a handler is found, the result is
- * returned verbatim: a clean run yields `{ handled: true, result, warnings: [] }`,
- * while a handler that throws a non-exit error yields
- * `{ handled: false, warnings: [code], errorMessage }` so the failure can be
- * asserted. A handler that throws an error carrying a numeric `exitCode`
- * propagates the throw, matching runtime semantics.
- */
-export async function runRegisteredCommandForTest(commands, options) {
-    const command = normalizeSdkCommandName(options.command);
-    if (command.length === 0) {
-        throw new Error("Expected command name must be a non-empty string");
-    }
-    const hasHandler = commands.handlers.some((entry) => entry.command === command);
-    if (!hasHandler) {
-        const available = sortedUnique(commands.handlers.map((entry) => entry.command));
-        throw new Error(`Expected a registered command handler for "${command}" to invoke. Available command handlers: ${formatAvailable(available)}`);
-    }
-    if (options.sdk !== undefined && options.sdkFactory !== undefined) {
-        throw new TypeError("runRegisteredCommandForTest accepts sdk or sdkFactory, not both");
-    }
-    const pmRoot = options.pmRoot ?? "";
-    const global = { json: true, quiet: true, noPager: true, ...options.global };
-    const sdk = options.sdk ??
-        options.sdkFactory?.({ pmRoot, global }) ??
-        (pmRoot.length > 0
-            ? createExtensionCommandSdk(pmRoot, new PmClient({ pmRoot }))
-            : undefined);
-    return runCommandHandler(commands, {
-        command,
-        args: options.args ? [...options.args] : [],
-        options: options.options ? { ...options.options } : {},
-        global,
-        pm_root: pmRoot,
-        ...(sdk === undefined ? {} : { sdk }),
-    });
-}
-/** Invoke registered transactional mutation guards through the same fail-closed runtime used by real writes. */
-export async function runRegisteredMutationGuardForTest(hooks, options) {
-    if ((hooks.beforeMutation?.length ?? 0) === 0) {
-        throw new Error("Expected a registered before_mutation hook to invoke");
-    }
-    await runBeforeMutationHooks(hooks, options.context);
-}
-/**
- * Fire every registered lifecycle hook of a given `kind` through pm's real hook
- * runner and return the warnings array so package tests can assert on behavior —
- * not just that a hook was registered.
- *
- * This is the hook counterpart to {@link runRegisteredCommandForTest}, extending
- * the package-author "invoke" verb to the `api.hooks.*` surface. Pass the
- * `ExtensionHookRegistry` from `activateExtensionForTest(...).hooks` together with
- * the lifecycle `kind` and a synthetic context. Hooks observe their inputs via a
- * cloned context snapshot (mutations never leak back to the caller), so the
- * observable signal is twofold: any side effects the hook performs, and the
- * returned warnings. A clean run returns `[]`; a hook that throws contributes one
- * `extension_hook_failed:<layer>:<name>:<hookName>` warning, mirroring runtime
- * dispatch which isolates a failing hook without aborting the others.
- *
- * Throws a descriptive error (listing the hook kinds that do have registrations)
- * when no hook of `kind` is registered, since firing a hook the extension never
- * registered is a wiring/typo bug in the test rather than a behavior under test.
- */
-export async function runRegisteredHookForTest(hooks, options) {
-    const kind = options.kind;
-    if (kind === "before_mutation") {
-        throw new Error("Invoke before_mutation hooks with runRegisteredMutationGuardForTest so denials and failures retain fail-closed semantics.");
-    }
-    if ((hooks[RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD[kind]]?.length ?? 0) === 0) {
-        const populatedKinds = sortedUnique(Object.keys(RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD).filter((candidateKind) => (hooks[RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD[candidateKind]]
-            ?.length ?? 0) > 0));
-        throw new Error(`Expected a registered "${kind}" hook to invoke. Hook kinds with registrations: ${formatAvailable(populatedKinds)}`);
-    }
-    switch (options.kind) {
-        case "before_command":
-            return runBeforeCommandHooks(hooks, options.context);
-        case "after_command":
-            return runAfterCommandHooks(hooks, options.context);
-        case "on_read":
-            return runOnReadHooks(hooks, options.context);
-        case "on_write":
-            return runOnWriteHooks(hooks, options.context);
-        case "on_index":
-            return runOnIndexHooks(hooks, options.context);
-    }
-}
-/**
- * Invoke a registered parser override through pm's real runner and return the
- * resolved {@link ParserOverrideResult}, so package tests can assert the rewritten
- * args/options/global an override produces for a command before dispatch.
- *
- * Guards that a parser override is registered for the (normalized) target command
- * before delegating: without a match `runParserOverride` would silently return
- * `overridden: false`, hiding a typo'd command name in the test. When a match
- * exists the result is returned verbatim — `overridden: true` with the rewritten
- * context on success, or `overridden: false` with an
- * `extension_parser_override_failed:*` warning when the override throws.
- */
-export async function runRegisteredParserOverrideForTest(parsers, context) {
-    const command = normalizeSdkCommandName(context.command);
-    if (!parsers.overrides.some((entry) => entry.command === command)) {
-        throw new Error(`Expected a registered parser override for command "${command}" to invoke. Available parser override commands: ${formatAvailable(sortedUnique(parsers.overrides.map((entry) => entry.command)))}`);
-    }
-    return runParserOverride(parsers, context);
-}
-/**
- * Invoke the active preflight override through pm's real runner and return the
- * resolved {@link PreflightOverrideResult}, so package tests can assert the
- * migration/format gate decision an override yields.
- *
- * Unlike command-scoped overrides, the runtime applies the **last** registered
- * preflight override regardless of command, so this helper guards only that at
- * least one preflight override is registered before delegating. The result is
- * returned verbatim — `overridden: true` with the adjusted decision on success,
- * or `overridden: false` with an `extension_preflight_override_failed:*` warning
- * when the override throws.
- */
-export async function runRegisteredPreflightOverrideForTest(preflight, context) {
-    if (preflight.overrides.length === 0) {
-        throw new Error("Expected a registered preflight override to invoke, but none are registered.");
-    }
-    return runPreflightOverride(preflight, context);
-}
-/**
- * Invoke a registered command-result override through pm's real runner and return
- * the resolved {@link CommandOverrideResult}, so package tests can assert how an
- * override transforms a command's result payload.
- *
- * Accepts the same `ExtensionCommandRegistry` exposed as
- * `activateExtensionForTest(...).commands` (it carries both handlers and
- * overrides). Guards that an override is registered for the (normalized) target
- * command before delegating, so a typo'd command name surfaces as a clear error
- * rather than a silent `overridden: false`. The result is returned verbatim —
- * including the `extension_command_override_async_unsupported:*` warning the
- * runtime emits when an override returns a Promise (command overrides are
- * synchronous), or an `extension_command_override_failed:*` warning on throw.
- */
-export async function runRegisteredCommandOverrideForTest(commands, context) {
-    const command = normalizeSdkCommandName(context.command);
-    if (!commands.overrides.some((entry) => entry.command === command)) {
-        throw new Error(`Expected a registered command override for command "${command}" to invoke. Available command override commands: ${formatAvailable(sortedUnique(commands.overrides.map((entry) => entry.command)))}`);
-    }
-    return runCommandOverride(commands, context);
-}
-/**
- * Invoke a registered renderer override through pm's real runner and return the
- * resolved {@link RendererOverrideResult}, so package tests can assert the custom
- * string an override renders for a given output `format`.
- *
- * Guards that a renderer override is registered for `context.format` before
- * delegating, so a wrong format surfaces as a clear error rather than a silent
- * `overridden: false`. The result is returned verbatim — `overridden: true` with
- * the rendered string on success, or `overridden: false` (with an
- * `extension_renderer_invalid_result:*` / `extension_renderer_failed:*` warning
- * where applicable) when the override returns a non-string or throws.
- */
-export async function runRegisteredRendererOverrideForTest(renderers, context) {
-    if (!renderers.overrides.some((entry) => entry.format === context.format)) {
-        throw new Error(`Expected a registered renderer override for format "${context.format}" to invoke. Available renderer override formats: ${formatAvailable(sortedUnique(renderers.overrides.map((entry) => entry.format)))}`);
-    }
-    return runRendererOverride(renderers, context);
-}
-/**
- * Invoke a registered service override through pm's real runner and return the
- * resolved {@link ServiceOverrideResult}, so package tests can assert how an
- * override handles an internal service payload (e.g. `output_format`).
- *
- * Guards that a service override is registered for `context.service` before
- * delegating, so a wrong service name surfaces as a clear error rather than a
- * silent `handled: false`. The result is returned verbatim — `handled: true` with
- * the override's result when it claims the payload, or `handled: false` with the
- * original payload (and any `extension_service_override_*` warnings) otherwise.
- */
-export async function runRegisteredServiceOverrideForTest(services, context) {
-    if (!services.overrides.some((entry) => entry.service === context.service)) {
-        throw new Error(`Expected a registered service override for service "${context.service}" to invoke. Available service override services: ${formatAvailable(sortedUnique(services.overrides.map((entry) => entry.service)))}`);
-    }
-    return runServiceOverride(services, context);
-}
-/** Maps each search-provider operation to the runtime-definition keys that may hold its function, in priority order. The host accepts both camelCase and snake_case spellings for the multi-word operations, so this helper mirrors that by trying `embedBatch` before `embed_batch` and `queryExpansion` before `query_expansion`. */
-const SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS = {
-    query: ["query"],
-    embed: ["embed"],
-    embedBatch: ["embedBatch", "embed_batch"],
-    queryExpansion: ["queryExpansion", "query_expansion"],
-    rerank: ["rerank"],
-};
-/**
- * Invoke an operation of a registered search provider through the same name
- * resolution the host uses and return the operation's result, so package tests
- * can assert a custom provider's runtime behavior — not just that it registered.
- *
- * This is the search-provider counterpart to {@link runRegisteredCommandForTest},
- * extending the package-author "invoke" verb to the `api.registerSearchProvider`
- * surface. Pass the `ExtensionRegistrationRegistry` from
- * `activateExtensionForTest(...).registrations`, the registered provider name, the
- * `operation` to exercise (`query`, `embed`, `embedBatch`, `queryExpansion`, or
- * `rerank`), and a synthetic context. The provider is resolved via
- * {@link resolveRegisteredSearchProvider} (case-insensitive, last registration
- * wins) and the operation is invoked on its `runtime_definition` — the clone that
- * preserves live functions, matching what the runtime dispatches.
- *
- * Throws a descriptive error listing the available providers when the name is not
- * registered, and a separate error when the resolved provider does not implement
- * the requested operation, since invoking an absent provider/operation is a
- * wiring bug in the test rather than a behavior under test.
- */
-export async function runRegisteredSearchProviderForTest(registrations, options) {
-    const registration = resolveRegisteredSearchProvider(registrations, options.provider);
-    if (!registration) {
-        const available = sortedUnique(registrations.search_providers.map((entry) => entry.definition.name));
-        throw new Error(`Expected a registered search provider "${options.provider}" to invoke. Available search providers: ${formatAvailable(available)}`);
-    }
-    const runtimeDefinition = registration.runtime_definition;
-    const operationFn = SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS[options.operation]
-        .map((key) => runtimeDefinition[key])
-        .find((value) => typeof value === "function");
-    if (typeof operationFn !== "function") {
-        throw new Error(`Registered search provider "${options.provider}" does not implement the "${options.operation}" operation.`);
-    }
-    return (await operationFn(options.context));
-}
-/**
- * Invoke an operation of a registered vector store adapter through the same name
- * resolution the host uses and return the operation's result, so package tests
- * can assert a custom adapter's runtime behavior — not just that it registered.
- *
- * This is the vector-store counterpart to {@link runRegisteredSearchProviderForTest}.
- * Pass the `ExtensionRegistrationRegistry` from
- * `activateExtensionForTest(...).registrations`, the registered adapter name, the
- * `operation` to exercise (`query`, `upsert`, or `delete`), and a synthetic
- * context. The adapter is resolved via {@link resolveRegisteredVectorStoreAdapter}
- * (case-insensitive, last registration wins) and the operation is invoked on its
- * `runtime_definition` — the clone that preserves live functions, matching what
- * the runtime dispatches.
- *
- * Throws a descriptive error listing the available adapters when the name is not
- * registered, and a separate error when the resolved adapter does not implement
- * the requested operation.
- */
-export async function runRegisteredVectorStoreAdapterForTest(registrations, options) {
-    const registration = resolveRegisteredVectorStoreAdapter(registrations, options.adapter);
-    if (!registration) {
-        const available = sortedUnique(registrations.vector_store_adapters.map((entry) => entry.definition.name));
-        throw new Error(`Expected a registered vector store adapter "${options.adapter}" to invoke. Available vector store adapters: ${formatAvailable(available)}`);
-    }
-    const operationFn = registration.runtime_definition[options.operation];
-    if (typeof operationFn !== "function") {
-        throw new Error(`Registered vector store adapter "${options.adapter}" does not implement the "${options.operation}" operation.`);
-    }
-    return (await operationFn(options.context));
-}
-/**
- * Invoke a registered schema migration's `run` function through the same runtime
- * definition the host executes and return its result, so package tests can assert
- * a migration's behavior — not just that it registered.
- *
- * This completes the package-author "invoke" verb across every executable
- * registration surface. The migration is resolved by id via
- * {@link assertRegisteredMigration} (which throws a descriptive "available
- * migrations" error when absent), then `run` is invoked on its
- * `runtime_definition` with a context mirroring the one
- * `executeRegisteredRuntimeMigrations` builds at runtime: the resolved id,
- * `command: "migration"`, the registering extension's layer/name, the supplied
- * `pmRoot`, and the migration's normalized status. Unlike the runtime — which
- * skips already-applied migrations and folds a throw into a warning — this helper
- * always invokes `run` and lets a throw propagate, so authors can assert both the
- * success result and failure via rejection.
- *
- * Throws when the resolved migration declares no `run` function, since invoking a
- * runless migration is a wiring bug in the test rather than a behavior under test.
- */
-export async function runRegisteredMigrationForTest(registrations, options) {
-    const migration = assertRegisteredMigration(registrations, {
-        migration: options.migration,
-        extensionName: options.extensionName,
-    });
-    const run = getMigrationRuntimeDefinition(migration).run;
-    if (typeof run !== "function") {
-        throw new Error(`Registered migration "${options.migration}" does not implement a run function to invoke.`);
-    }
-    const declaredStatus = migration.definition.status;
-    const context = {
-        id: migration.definition.id,
-        command: "migration",
-        layer: migration.layer,
-        extension: migration.name,
-        pm_root: options.pmRoot ?? "",
-        status: (typeof declaredStatus === "string"
-            ? declaredStatus.trim().toLowerCase()
-            : "") || "pending",
-    };
-    return await run(context);
-}
-/**
- * Invoke a registered extension importer through pm's real handler-dispatch
- * engine and return its {@link CommandHandlerResult}, so package tests can assert
- * an importer's behavior — not just that it registered.
- *
- * This is the importer counterpart to {@link runRegisteredCommandForTest},
- * extending the package-author "invoke" verb to the `api.registerImporter`
- * surface. Because `registerImporter(name, fn)` wraps `fn` into a command handler
- * at the `"<name> import"` path, invoking it through `runRegisteredCommandForTest`
- * requires the author to know that naming convention and to remember that an
- * importer is reachable as a command at all. This helper closes both gaps: it
- * accepts the registered importer name directly, validates via
- * {@link assertRegisteredImporter} that it is genuinely a registered importer
- * (not merely some command parked at that path), derives the command path, and
- * dispatches through the same engine.
- *
- * The full activation result is required because importer execution spans two
- * sub-registries: `registrations.importers` proves the importer exists, while
- * `commands` holds the wrapped handler. The result is returned verbatim from the
- * command engine: a clean run yields `{ handled: true, result, warnings: [] }`
- * (where `result` is the importer's return value), a non-exit throw yields
- * `{ handled: false, warnings: [code], errorMessage }`, and an error carrying a
- * numeric `exitCode` propagates — matching runtime import semantics.
- *
- * Throws a descriptive "available importers" error (via `assertRegisteredImporter`)
- * when no importer matches, since that is a wiring/typo bug in the test rather
- * than a behavior under test.
- */
-export async function runRegisteredImporterForTest(activation, options) {
-    const importer = assertRegisteredImporter(activation.registrations, {
-        importer: options.importer,
-        extensionName: options.extensionName,
-    });
-    return runRegisteredCommandForTest(activation.commands, {
-        command: `${importer.importer} import`,
-        args: options.args,
-        options: options.options,
-        global: options.global,
-        pmRoot: options.pmRoot,
-    });
-}
-/**
- * Invoke a registered extension exporter through pm's real handler-dispatch
- * engine and return its {@link CommandHandlerResult}, so package tests can assert
- * an exporter's behavior — not just that it registered.
- *
- * This is the exporter counterpart to {@link runRegisteredImporterForTest} and
- * the final surface in the package-author "invoke" verb. Because
- * `registerExporter(name, fn)` wraps `fn` into a command handler at the
- * `"<name> export"` path, this helper accepts the registered exporter name
- * directly, validates via {@link assertRegisteredExporter} that it is genuinely a
- * registered exporter, derives the command path, and dispatches through the same
- * engine. See {@link runRegisteredImporterForTest} for the full activation
- * rationale and return semantics (which apply identically here).
- *
- * Throws a descriptive "available exporters" error (via `assertRegisteredExporter`)
- * when no exporter matches, since that is a wiring/typo bug in the test rather
- * than a behavior under test.
- */
-export async function runRegisteredExporterForTest(activation, options) {
-    const exporter = assertRegisteredExporter(activation.registrations, {
-        exporter: options.exporter,
-        extensionName: options.extensionName,
-    });
-    return runRegisteredCommandForTest(activation.commands, {
-        command: `${exporter.exporter} export`,
-        args: options.args,
-        options: options.options,
-        global: options.global,
-        pmRoot: options.pmRoot,
-    });
-}
-/**
- * Assert that an {@link ExtensionDeactivationResult} reports the expected clean
- * teardown counts, throwing a descriptive error otherwise. Defaults assert the
- * single-extension happy path — exactly one extension deactivated and none
- * failed. Returns the result so assertions can chain.
- */
-export function assertExtensionDeactivated(result, expectation = {}) {
-    const expectedDeactivated = expectation.deactivated ?? 1;
-    if (result.deactivated !== expectedDeactivated) {
-        throw new Error(`Expected ${expectedDeactivated} extension${expectedDeactivated === 1 ? "" : "s"} to deactivate cleanly, ` +
-            `but ${result.deactivated} did.`);
-    }
-    const expectedFailed = expectation.failed ?? 0;
-    if (result.failed.length !== expectedFailed) {
-        const detail = result.failed
-            .map((failure) => `${failure.layer}:${failure.name} (${failure.error})`)
-            .join(", ");
-        throw new Error(`Expected ${expectedFailed} teardown failure${expectedFailed === 1 ? "" : "s"}, ` +
-            `but observed ${result.failed.length}${detail.length > 0 ? `: ${detail}` : ""}.`);
-    }
-    return result;
-}
-/** Assert that a normalized package manifest advertises expected package resources. Pair with `readPmPackageManifest(packageRoot)` in package tests. */
-export function assertPackageManifest(manifest, expectation) {
-    if (expectation.packageName !== undefined &&
-        manifest.package_name !== expectation.packageName) {
-        throw new Error(`Expected package manifest package_name to be "${expectation.packageName}"; received "${manifest.package_name ?? "(none)"}"`);
-    }
-    if (expectation.aliases !== undefined) {
-        assertStringSetIncludes(manifest.aliases, expectation.aliases, "aliases");
-    }
-    if (expectation.resources !== undefined) {
-        for (const [kind, expectedPaths] of Object.entries(expectation.resources)) {
-            assertStringSetIncludes(manifest.resources[kind], expectedPaths, `pm.${kind}`);
-        }
-    }
-    return manifest;
-}
-/** Assert that an activated extension registration registry contains a command contract with the expected public metadata. */
-export function assertRegisteredCommandContract(registrations, expectation) {
-    const expectedCommand = normalizeSdkCommandName(registeredExpectationName(expectation, expectation.command));
-    if (expectedCommand.length === 0) {
-        throw new Error("Expected command name must be a non-empty string");
-    }
-    const commandCandidates = registrations.commands.filter((entry) => entry.command === expectedCommand);
-    const command = expectation.extensionName
-        ? commandCandidates.find((entry) => entry.name === expectation.extensionName)
-        : commandCandidates[0];
-    if (!command) {
-        const available = registrations.commands
-            .map((entry) => entry.command)
-            .sort((left, right) => left.localeCompare(right));
-        const extensionSuffix = expectation.extensionName
-            ? ` from extension "${expectation.extensionName}"`
-            : "";
-        throw new Error(`Expected extension command "${expectedCommand}"${extensionSuffix} to be registered. Available commands: ${formatAvailable(available)}`);
-    }
-    if (expectation.action !== undefined &&
-        command.action !== expectation.action) {
-        throw new Error(`Expected extension command "${expectedCommand}" action "${expectation.action}", received "${command.action}"`);
-    }
-    if (expectation.arguments !== undefined) {
-        const actualArguments = (command.arguments ?? []).map((argument) => argument.name);
-        const missingArguments = expectation.arguments.filter((argument) => !actualArguments.includes(argument));
-        if (missingArguments.length > 0) {
-            throw new Error(`Expected extension command "${expectedCommand}" arguments ${formatAvailable(expectation.arguments)}; missing ${formatAvailable(missingArguments)}; available ${formatAvailable(actualArguments)}`);
-        }
-    }
-    const flags = registrations.flags
-        .filter((entry) => entry.target_command === expectedCommand &&
-        (expectation.extensionName === undefined ||
-            entry.name === expectation.extensionName))
-        .flatMap((entry) => entry.flags);
-    if (expectation.flags !== undefined) {
-        const actualFlagLabels = collectFlagLabels(flags);
-        const missingFlags = expectation.flags.filter((flag) => !actualFlagLabels.has(flag));
-        if (missingFlags.length > 0) {
-            throw new Error(`Expected extension command "${expectedCommand}" flags ${formatAvailable(expectation.flags)}; missing ${formatAvailable(missingFlags)}; available ${formatAvailable([...actualFlagLabels].sort((left, right) => left.localeCompare(right)))}`);
-        }
-    }
-    return { command, flags };
-}
-/** Assert that an activated extension registration registry contains flags injected into an existing command through `api.registerFlags(...)`. */
-export function assertRegisteredFlags(registrations, expectation) {
-    const expectedCommand = normalizeSdkCommandName(registeredExpectationName(expectation, expectation.targetCommand));
-    if (expectedCommand.length === 0) {
-        throw new Error("Expected target command name must be a non-empty string");
-    }
-    const candidates = registrations.flags.filter((entry) => entry.target_command === expectedCommand);
-    let registration;
-    if (expectation.extensionName) {
-        registration = candidates.find((entry) => entry.name === expectation.extensionName);
-    }
-    else if (candidates.length === 1) {
-        registration = candidates[0];
-    }
-    else if (candidates.length > 1) {
-        const availableExtensions = sortedUnique(candidates.map((entry) => entry.name));
-        throw new Error(`Expected flags for target command "${expectedCommand}" matched multiple extensions: ${formatAvailable(availableExtensions)}. Specify extensionName to choose one registration.`);
-    }
-    if (!registration) {
-        const available = sortedUnique(registrations.flags.map((entry) => entry.target_command));
-        const availableExtensions = sortedUnique(candidates.map((entry) => entry.name));
-        throw new Error(`Expected flags for target command "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available flag target commands: ${formatAvailable(available)}; matching extensions: ${formatAvailable(availableExtensions)}`);
-    }
-    if (expectation.flags !== undefined) {
-        const actualFlagLabels = collectFlagLabels(registration.flags);
-        const missingFlags = expectation.flags.filter((flag) => !actualFlagLabels.has(flag));
-        if (missingFlags.length > 0) {
-            throw new Error(`Expected flags for target command "${expectedCommand}" to include ${formatAvailable(expectation.flags)}; missing ${formatAvailable(missingFlags)}; available ${formatAvailable([...actualFlagLabels].sort((left, right) => left.localeCompare(right)))}`);
-        }
-    }
-    return registration;
-}
-/**
- * Assert that an activated extension hook registry contains a hook of the
- * expected lifecycle kind (optionally scoped to a specific extension).
- *
- * Hooks are surfaced via `ExtensionActivationResult.hooks`, not the command
- * registration registry, so this helper accepts an `ExtensionHookRegistry`.
- */
-export function assertRegisteredHook(hooks, expectation) {
-    const field = HOOK_KIND_TO_REGISTRY_FIELD[expectation.kind];
-    const candidates = (hooks[field] ?? []);
-    const hook = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!hook) {
-        const available = sortedUnique(candidates.map((entry) => entry.name));
-        throw new Error(`Expected a "${expectation.kind}" hook${extensionNameSuffix(expectation.extensionName)} to be registered. Available "${expectation.kind}" hooks: ${formatAvailable(available)}`);
-    }
-    return hook;
-}
-/** Assert that an activated extension registration registry contains a search provider with the expected name (optionally scoped to a specific extension). */
-export function assertRegisteredSearchProvider(registrations, expectation) {
-    const expectedProvider = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.provider));
-    if (expectedProvider.length === 0) {
-        throw new Error("Expected search provider name must be a non-empty string");
-    }
-    const candidates = registrations.search_providers.filter((entry) => normalizeSdkIdentifier(entry.definition.name) === expectedProvider);
-    const provider = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!provider) {
-        const available = sortedUnique(registrations.search_providers.map((entry) => entry.definition.name));
-        throw new Error(`Expected search provider "${expectedProvider}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available search providers: ${formatAvailable(available)}`);
-    }
-    return provider;
-}
-/** Assert that an activated extension registration registry contains a vector store adapter with the expected name (optionally scoped to a specific extension). */
-export function assertRegisteredVectorStoreAdapter(registrations, expectation) {
-    const expectedAdapter = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.adapter));
-    if (expectedAdapter.length === 0) {
-        throw new Error("Expected vector store adapter name must be a non-empty string");
-    }
-    const candidates = registrations.vector_store_adapters.filter((entry) => normalizeSdkIdentifier(entry.definition.name) === expectedAdapter);
-    const adapter = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!adapter) {
-        const available = sortedUnique(registrations.vector_store_adapters.map((entry) => entry.definition.name));
-        throw new Error(`Expected vector store adapter "${expectedAdapter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available vector store adapters: ${formatAvailable(available)}`);
-    }
-    return adapter;
-}
-/** Assert that an activated extension registration registry contains an importer for the expected format/name (optionally scoped to a specific extension). */
-export function assertRegisteredImporter(registrations, expectation) {
-    const expectedImporter = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.importer));
-    if (expectedImporter.length === 0) {
-        throw new Error("Expected importer name must be a non-empty string");
-    }
-    const candidates = registrations.importers.filter((entry) => normalizeSdkIdentifier(entry.importer) === expectedImporter);
-    const importer = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!importer) {
-        const available = sortedUnique(registrations.importers.map((entry) => entry.importer));
-        throw new Error(`Expected importer "${expectedImporter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available importers: ${formatAvailable(available)}`);
-    }
-    return importer;
-}
-/** Assert that an activated extension registration registry contains an exporter for the expected format/name (optionally scoped to a specific extension). */
-export function assertRegisteredExporter(registrations, expectation) {
-    const expectedExporter = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.exporter));
-    if (expectedExporter.length === 0) {
-        throw new Error("Expected exporter name must be a non-empty string");
-    }
-    const candidates = registrations.exporters.filter((entry) => normalizeSdkIdentifier(entry.exporter) === expectedExporter);
-    const exporter = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!exporter) {
-        const available = sortedUnique(registrations.exporters.map((entry) => entry.exporter));
-        throw new Error(`Expected exporter "${expectedExporter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available exporters: ${formatAvailable(available)}`);
-    }
-    return exporter;
-}
-/** Assert that an activated extension registration registry contains a custom item field definition (optionally scoped to a specific extension). */
-export function assertRegisteredItemField(registrations, expectation) {
-    const expectedField = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.field));
-    if (expectedField.length === 0) {
-        throw new Error("Expected item field name must be a non-empty string");
-    }
-    const candidates = registrations.item_fields
-        .filter((entry) => expectation.extensionName === undefined ||
-        entry.name === expectation.extensionName)
-        .map((registration) => ({
-        registration,
-        field: registration.fields.find((field) => normalizeSdkIdentifier(field.name) === expectedField),
-    }))
-        .filter((entry) => entry.field !== undefined);
-    const match = candidates.find((entry) => expectation.type === undefined || entry.field.type === expectation.type);
-    if (!match) {
-        const available = sortedUnique(registrations.item_fields.flatMap((entry) => entry.fields.map((field) => `${field.name}:${field.type}`)));
-        throw new Error(`Expected item field "${expectedField}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available item fields: ${formatAvailable(available)}`);
-    }
-    return match;
-}
-/** Assert that an activated extension registration registry contains a custom item type definition (optionally scoped to a specific extension). */
-export function assertRegisteredItemType(registrations, expectation) {
-    const expectedType = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.itemType));
-    if (expectedType.length === 0) {
-        throw new Error("Expected item type name must be a non-empty string");
-    }
-    const candidates = registrations.item_types
-        .filter((entry) => expectation.extensionName === undefined ||
-        entry.name === expectation.extensionName)
-        .map((registration) => ({
-        registration,
-        itemType: registration.types.find((itemType) => normalizeSdkIdentifier(itemType.name) === expectedType),
-    }))
-        .filter((entry) => entry.itemType !== undefined);
-    const match = candidates.find((entry) => expectation.folder === undefined ||
-        entry.itemType.folder === expectation.folder);
-    if (!match) {
-        const available = sortedUnique(registrations.item_types.flatMap((entry) => entry.types.map((itemType) => `${itemType.name}:${itemType.folder}`)));
-        throw new Error(`Expected item type "${expectedType}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available item types: ${formatAvailable(available)}`);
-    }
-    return match;
-}
-/**
- * Assert that an activated extension registration registry contains a project
- * profile registered via `api.registerProfile(profile)` (optionally scoped to a
- * specific extension).
- *
- * This is the test-time counterpart to the declarative `defineProjectProfile`
- * authoring helper and the `pm profile list/show/apply` runtime surface: it
- * proves a package's archetype reached the registry so a downstream consumer can
- * resolve and apply it by name. Like the other declarative-surface assertions
- * (item types, item fields), a profile is verified by presence — it is staged,
- * not executed — so there is no `runRegisteredProfileForTest` counterpart.
- */
-export function assertRegisteredProfile(registrations, expectation) {
-    const expectedProfile = normalizeSdkProfileMatchKey(registeredExpectationName(expectation, expectation.profile));
-    if (expectedProfile.length === 0) {
-        throw new Error("Expected profile name must be a non-empty string");
-    }
-    const match = registrations.profiles
-        .filter((entry) => expectation.extensionName === undefined ||
-        entry.name === expectation.extensionName)
-        .find((entry) => normalizeSdkProfileMatchKey(entry.profile.name) === expectedProfile);
-    if (!match) {
-        const available = sortedUnique(registrations.profiles.map((entry) => entry.profile.name));
-        throw new Error(`Expected profile "${expectedProfile}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available profiles: ${formatAvailable(available)}`);
-    }
-    return { registration: match, profile: match.profile };
-}
-/**
- * Assert that an activated extension command registry contains a command
- * override registered via `api.registerCommand(command, override)` (optionally
- * scoped to a specific extension).
- *
- * Command overrides are surfaced via `ExtensionActivationResult.commands`, not
- * the command registration registry, so this helper accepts an
- * `ExtensionCommandRegistry`.
- */
-export function assertRegisteredCommandOverride(commands, expectation) {
-    const expectedCommand = normalizeSdkCommandName(registeredExpectationName(expectation, expectation.command));
-    if (expectedCommand.length === 0) {
-        throw new Error("Expected command name must be a non-empty string");
-    }
-    const candidates = commands.overrides.filter((entry) => entry.command === expectedCommand);
-    const override = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!override) {
-        const available = sortedUnique(commands.overrides.map((entry) => entry.command));
-        throw new Error(`Expected command override "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available command overrides: ${formatAvailable(available)}`);
-    }
-    return override;
-}
-/**
- * Assert that an activated extension parser registry contains a parser override
- * registered via `api.registerParser(command, override)` (optionally scoped to
- * a specific extension).
- *
- * Parser overrides are surfaced via `ExtensionActivationResult.parsers`, not the
- * command registration registry, so this helper accepts an
- * `ExtensionParserRegistry`.
- */
-export function assertRegisteredParserOverride(parsers, expectation) {
-    const expectedCommand = normalizeSdkCommandName(registeredExpectationName(expectation, expectation.command));
-    if (expectedCommand.length === 0) {
-        throw new Error("Expected command name must be a non-empty string");
-    }
-    const candidates = parsers.overrides.filter((entry) => entry.command === expectedCommand);
-    const override = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!override) {
-        const available = sortedUnique(parsers.overrides.map((entry) => entry.command));
-        throw new Error(`Expected parser override "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available parser overrides: ${formatAvailable(available)}`);
-    }
-    return override;
-}
-/**
- * Assert that an activated extension preflight registry contains a preflight
- * override registered via `api.registerPreflight(override)` (optionally scoped
- * to a specific extension).
- *
- * Preflight overrides are global (they run for every command and carry no
- * `command` field), so the expectation only accepts an optional
- * `extensionName`. Preflight overrides are surfaced via
- * `ExtensionActivationResult.preflight`.
- */
-export function assertRegisteredPreflightOverride(preflight, expectation = {}) {
-    const override = expectation.extensionName
-        ? preflight.overrides.find((entry) => entry.name === expectation.extensionName)
-        : preflight.overrides[0];
-    if (!override) {
-        const available = sortedUnique(preflight.overrides.map((entry) => entry.name));
-        throw new Error(`Expected a preflight override${extensionNameSuffix(expectation.extensionName)} to be registered. Available preflight overrides: ${formatAvailable(available)}`);
-    }
-    return override;
-}
-/**
- * Assert that an activated extension renderer registry contains a renderer
- * override registered via `api.registerRenderer(format, renderer)` for the
- * expected output format (optionally scoped to a specific extension).
- *
- * Renderer overrides are surfaced via `ExtensionActivationResult.renderers`.
- */
-export function assertRegisteredRendererOverride(renderers, expectation) {
-    const expectedFormat = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.format));
-    if (expectedFormat.length === 0) {
-        throw new Error("Expected renderer format must be a non-empty string");
-    }
-    const candidates = renderers.overrides.filter((entry) => entry.format === expectedFormat);
-    const override = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!override) {
-        const available = sortedUnique(renderers.overrides.map((entry) => entry.format));
-        throw new Error(`Expected renderer override "${expectedFormat}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available renderer overrides: ${formatAvailable(available)}`);
-    }
-    return override;
-}
-/**
- * Assert that an activated extension service registry contains a service override
- * registered via `api.registerService(service, override)` for the expected
- * service name (optionally scoped to a specific extension).
- *
- * Service overrides are surfaced via `ExtensionActivationResult.services`, not the
- * command registration registry, so this helper accepts an
- * `ExtensionServiceRegistry`.
- */
-export function assertRegisteredServiceOverride(services, expectation) {
-    const expectedService = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.service));
-    if (expectedService.length === 0) {
-        throw new Error("Expected service name must be a non-empty string");
-    }
-    const candidates = services.overrides.filter((entry) => normalizeSdkIdentifier(entry.service) === expectedService);
-    const override = expectation.extensionName
-        ? candidates.find((entry) => entry.name === expectation.extensionName)
-        : candidates[0];
-    if (!override) {
-        const available = sortedUnique(services.overrides.map((entry) => entry.service));
-        throw new Error(`Expected service override "${expectedService}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available service overrides: ${formatAvailable(available)}`);
-    }
-    return override;
-}
-/**
- * Assert that an activated extension registration registry contains a schema
- * migration registered via `api.registerMigration(definition)` with the expected
- * id (optionally scoped to a specific extension and asserting the `mandatory`
- * governance flag, where an unset flag is treated as non-mandatory).
- *
- * Migrations are surfaced via `ExtensionActivationResult.registrations.migrations`.
- */
-export function assertRegisteredMigration(registrations, expectation) {
-    const expectedMigration = normalizeSdkIdentifier(registeredExpectationName(expectation, expectation.migration));
-    if (expectedMigration.length === 0) {
-        throw new Error("Expected migration id must be a non-empty string");
-    }
-    const candidates = registrations.migrations.filter((entry) => (expectation.extensionName === undefined ||
-        entry.name === expectation.extensionName) &&
-        typeof entry.definition.id === "string" &&
-        normalizeSdkIdentifier(entry.definition.id) === expectedMigration);
-    const match = candidates.find((entry) => expectation.mandatory === undefined ||
-        (entry.definition.mandatory ?? false) === expectation.mandatory);
-    if (match) {
-        return match;
-    }
-    // The id (and any extension scope) matched but the `mandatory` flag did not:
-    // report the mismatch directly rather than the misleading "not registered"
-    // listing. Reaching here with a candidate implies `expectation.mandatory` was
-    // set, since an unset flag matches any candidate above.
-    const idMatch = candidates[0];
-    if (idMatch !== undefined) {
-        throw new Error(`Expected migration "${expectedMigration}"${extensionNameSuffix(expectation.extensionName)} to have ` +
-            `mandatory=${expectation.mandatory}, but it is mandatory=${idMatch.definition.mandatory ?? false}.`);
-    }
-    const available = sortedUnique(registrations.migrations.map((entry) => {
-        const id = typeof entry.definition.id === "string" &&
-            entry.definition.id.trim().length > 0
-            ? entry.definition.id.trim()
-            : "(unnamed)";
-        return `${id}:${entry.definition.mandatory === true}`;
-    }));
-    throw new Error(`Expected migration "${expectedMigration}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available migrations: ${formatAvailable(available)}`);
-}
-/**
- * Assert that an activated extension declares no capability it never uses
- * (least privilege). Pass the same capabilities as `manifest.capabilities` via
- * `expectation.declared`; the helper computes what the extension actually
- * registered against and throws when any declared capability is unused.
- *
- * This is the package-test counterpart of the advisory
- * `extension_capability_unused` warning `pm package doctor` emits, letting an
- * author catch an over-broad manifest at `npm test` time. Returns the
- * declared/used/unused breakdown for further assertions.
- */
-export function assertExtensionCapabilityUsage(activation, expectation) {
-    const toKnownCapabilitySet = (capabilities, field) => {
-        const known = new Set();
-        for (const capability of capabilities) {
-            const normalized = normalizeKnownExtensionCapability(capability);
-            if (normalized === null) {
-                throw new Error(`Expected ${field} capability "${capability}" to be a known extension capability. ` +
-                    "Use canonical capability names (see manifest.capabilities).");
-            }
-            known.add(normalized);
-        }
-        return known;
-    };
-    const declared = [
-        ...toKnownCapabilitySet(expectation.declared, "declared"),
-    ].sort((left, right) => left.localeCompare(right));
-    const allowUnused = toKnownCapabilitySet(expectation.allowUnused ?? [], "allowUnused");
-    const used = collectUsedExtensionCapabilities(activation, {
-        extensionName: expectation.extensionName,
-    });
-    const usedSet = new Set(used);
-    const unused = declared.filter((capability) => !usedSet.has(capability) && !allowUnused.has(capability));
-    if (unused.length > 0) {
-        const scopeSuffix = extensionNameSuffix(expectation.extensionName);
-        throw new Error(`Expected every declared capability${scopeSuffix} to be exercised, but [${unused.join(", ")}] ${unused.length === 1 ? "is" : "are"} declared yet never registered against. ` +
-            `Remove ${unused.length === 1 ? "it" : "them"} from manifest.capabilities for least privilege, ` +
-            "or pass allowUnused for capabilities registered only behind a runtime flag.");
-    }
-    return { declared, used, unused };
-}
-/**
- * Preflight a declarative {@link ExtensionBlueprint} in a test, throwing if it has
- * any `error`-severity issue (today: capability the blueprint exercises but the
- * declared set omits, which would fail activation with `extension_capability_missing`).
- *
- * The throwing counterpart to {@link lintExtensionBlueprint} and the `assert*`
- * family member for declarative authoring: drop `assertExtensionBlueprint(blueprint)`
- * into a package's `node:test`/Vitest suite to fail CI before the blueprint is
- * ever activated. The full {@link ExtensionBlueprintLintResult} is returned on
- * success so a test can still inspect advisory warnings (unused capability,
- * duplicate command, empty surface) without failing on them.
- */
-export function assertExtensionBlueprint(blueprint, options = {}) {
-    const result = lintExtensionBlueprint(blueprint, options);
-    if (!result.ok) {
-        const errors = result.findings.filter((finding) => finding.severity === "error");
-        throw new Error(`Extension blueprint failed preflight with ${errors.length} ${errors.length === 1 ? "error" : "errors"}:\n` +
-            errors
-                .map((finding) => `  - [${finding.code}] ${finding.message}`)
-                .join("\n"));
-    }
-    return result;
-}
-/**
- * Assert a {@link ProjectProfileDefinition} is internally consistent in a test,
- * throwing on any `error`-severity finding (and on `warning`-severity findings
- * too when `strict` is set). The author-time counterpart to `defineProjectProfile`
- * and the project-profile analogue of {@link assertExtensionBlueprint}: drop
- * `assertProjectProfile(myProfile)` into a package's `node:test`/Vitest suite to
- * fail CI before the profile is ever registered via `api.registerProfile` or
- * applied via `pm profile apply`. The full {@link ProjectProfileLintReport} is
- * returned on success so a test can still inspect advisory warnings without
- * failing on them.
- */
-export function assertProjectProfile(profile, options = {}) {
-    const report = lintProjectProfile(profile);
-    const blocking = report.findings.filter((finding) => finding.severity === "error" ||
-        (options.strict === true && finding.severity === "warning"));
-    if (blocking.length > 0) {
-        throw new Error(`Project profile "${report.profile}" failed lint with ${blocking.length} ${blocking.length === 1 ? "issue" : "issues"}:\n` +
-            blocking
-                .map((finding) => `  - ${finding.severity} [${finding.code}] ${finding.message}`)
-                .join("\n"));
-    }
-    return report;
-}
-/**
- * Strictly assert a manifest's `capabilities` equal the least-privilege set a
- * declarative {@link ExtensionBlueprint} exercises, throwing on any drift in
- * either direction.
- *
- * This is the strict bookend to the lenient {@link assertExtensionBlueprint}:
- * where that helper fails only on an *undeclared* capability (the `error`-severity
- * `extension_capability_missing` activation crash) and merely *warns* on an unused
- * one, this assertion fails on **both** — an undeclared capability (`missing`) and
- * a declared-but-unused one (`unused`) — so a hand-maintained `manifest.json` stays
- * exactly the set the blueprint requires. Drop it into a package's
- * `node:test`/Vitest suite to guard against capability drift in CI, the natural
- * companion to {@link ../sdk/compose.js#synthesizeExtensionManifest} (assert what
- * you would otherwise generate). Only `capabilities` are reconciled because that is
- * the one manifest field a blueprint determines.
- *
- * The reconciliation is returned on success so a test can still inspect advisory
- * warnings (duplicate command, empty surface) without failing on them.
- */
-export function assertExtensionManifestMatchesBlueprint(manifest, blueprint) {
-    // Coerce a malformed/absent capabilities field to an explicit empty declared set
-    // so an untyped `.js` caller gets a deterministic `missing` list rather than the
-    // lint silently falling back to the blueprint's in-module manifest mirror.
-    const declaredCapabilities = Array.isArray(manifest.capabilities)
-        ? manifest.capabilities
-        : [];
-    const result = lintExtensionBlueprint(blueprint, { declaredCapabilities });
-    // `declared` is guaranteed non-null here: we always hand lint an array, so it
-    // never takes its "no declared set" branch. The cast drops the unreachable null.
-    const declared = result.declared;
-    const declaredSet = new Set(declared);
-    const usedSet = new Set(result.used);
-    const missing = result.used.filter((capability) => !declaredSet.has(capability));
-    const unused = declared.filter((capability) => !usedSet.has(capability));
-    if (missing.length > 0 || unused.length > 0) {
-        const parts = [];
-        if (missing.length > 0) {
-            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)`);
-        }
-        if (unused.length > 0) {
-            parts.push(`unused [${unused.join(", ")}] (declared but no surface exercises ${unused.length === 1 ? "it" : "them"}; drop for least privilege)`);
-        }
-        throw new Error(`Manifest capabilities do not match the blueprint: ${parts.join("; ")}. ` +
-            "Set capabilities to synthesizeExtensionManifest(blueprint, identity).capabilities to stay in sync.");
-    }
-    return {
-        used: result.used,
-        declared,
-        missing,
-        unused,
-        findings: result.findings,
-    };
-}
-/**
- * Assert an extension manifest's declared version bounds permit it to load on a
- * target pm CLI version, throwing when a bound blocks the load.
- *
- * This is the throwing CI/test counterpart to
- * {@link ../sdk/compose.js#checkExtensionManifestCompatibility}: it runs the same
- * author-time version-bound analysis and fails on any blocking incompatibility — a
- * malformed bound (`*_invalid`), a `pm_min_version` the target is below
- * (`pm_min_version_unmet`), or a `block`-mode `pm_max_version` the target exceeds
- * (`pm_max_version_exceeded`). Advisory `warning` findings (`*_unchecked`, or a
- * `warn`-mode `pm_max_version_exceeded_warn`) never throw, because the loader
- * would still load the extension. Pin it to the pm version a package commits to
- * supporting so a too-tight or malformed bound fails the package's own suite, not
- * a user's install. The full compatibility result is returned on success so a test
- * can still inspect advisory warnings.
- */
-export function assertExtensionManifestCompatible(manifest, target) {
-    const result = checkExtensionManifestCompatibility(manifest, target);
-    const blocking = result.findings.filter((finding) => finding.severity === "error");
-    if (blocking.length > 0) {
-        throw new Error(`Extension manifest is not compatible with pm ${result.pmVersion}: ${blocking
-            .map((finding) => finding.message)
-            .join("; ")}`);
-    }
-    return result;
-}
-/**
- * Preflight a declarative {@link ExtensionBlueprint} through every author-time
- * check in one test, throwing if any stage produced an `error`-severity finding.
- *
- * This is the throwing CI/test bookend over
- * {@link ../sdk/compose.js#preflightExtension} — the single guard that replaces
- * chaining {@link assertExtensionBlueprint}, {@link assertExtensionManifestMatchesBlueprint},
- * and {@link assertExtensionManifestCompatible} in a package's
- * `node:test`/Vitest suite. It runs the same consolidated analysis (always lints
- * the blueprint; synthesizes the manifest when `options.identity` is given; checks
- * version bounds when `options.target` is given) and throws one error listing every
- * blocking finding tagged by its `source:code`. Advisory `warning` findings (an
- * unused capability, a duplicate command, an `*_unchecked` bound) never throw,
- * matching the underlying stages. The full {@link ExtensionPreflightReport} is
- * returned on success so a test can still inspect those warnings, the synthesized
- * manifest, and the derived capability set without failing on them.
- */
-export function assertExtensionPreflight(blueprint, options = {}) {
-    const report = preflightExtension(blueprint, options);
-    if (!report.ok) {
-        const errors = report.findings.filter((finding) => finding.severity === "error");
-        throw new Error(`Extension failed preflight with ${errors.length} ${errors.length === 1 ? "error" : "errors"}:\n` +
-            errors
-                .map((finding) => `  - [${finding.source}:${finding.code}] ${finding.message}`)
-                .join("\n"));
-    }
-    return report;
-}
-/** Reject obviously wrong harness input (e.g. an options object passed as the module) instead of silently producing an empty activation. Mirrors the loader's activatable-extension shapes: an `activate` function on the module or on its default export. */
-function assertTestModuleHasActivateExport(module) {
-    if (resolveActivatablePropertyRecord(module)) {
-        return;
-    }
-    throw new Error("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.");
-}
-/**
- * Activate one in-memory extension module and return a fluent
- * {@link ExtensionTestHarness} that binds every SDK testing helper to the right
- * sub-registry of the resulting activation.
- *
- * This is the ergonomic capstone over the standalone helpers: instead of
- * `activateExtensionForTest(module)` followed by repeatedly threading
- * `activation.registrations` / `activation.commands` / `activation.hooks` into
- * each `assertRegistered*` / `runRegistered*` call, an author writes
- * `const ext = await createExtensionTestHarness(module, { capabilities });` and
- * then `ext.assertCommandContract(...)`, `await ext.runCommand(...)`,
- * `await ext.deactivate()` — never needing to know pm's internal registry layout.
- *
- * `name` and `layer` are resolved exactly as {@link activateExtensionForTest}
- * resolves them, and captured so {@link ExtensionTestHarness.deactivate} forwards
- * a matching skip-key. Activation runs pm's real validation/activation engine, so
- * every bound helper exercises real wiring and dispatch — not mocks.
- *
- * Fails fast: if the module does not activate cleanly (e.g. a registration is
- * dropped because the manifest omits the required capability), this throws a
- * descriptive error listing each failure instead of returning a harness whose
- * registries are empty — which would otherwise surface later as the confusing
- * `available: (none)` assertion error this helper exists to prevent. Tests that
- * deliberately exercise a *failed* activation should call
- * {@link activateExtensionForTest} directly and inspect `activation.failed`.
- */
-export async function createExtensionTestHarness(module, options = {}) {
-    assertTestModuleHasActivateExport(module);
-    const manifest = readTestExtensionManifest(module);
-    const name = resolveTestExtensionName(manifest, options.name);
-    const layer = options.layer ?? "project";
-    const activation = await activateExtensionForTest(module, options);
-    if (activation.failed.length > 0) {
-        const detail = activation.failed
-            .map((failure) => {
-            const missingCapability = failure.trace?.missing_capability;
-            const reason = missingCapability
-                ? `${failure.error}; missing capability "${missingCapability}"`
-                : failure.error;
-            return `${failure.layer}:${failure.name} (${reason})`;
-        })
-            .join(", ");
-        throw new Error(`createExtensionTestHarness could not activate the extension cleanly: ${detail}. ` +
-            "Declare the required capability in the manifest (or pass it via options.capabilities), " +
-            "or use activateExtensionForTest directly to inspect a failed activation.");
-    }
-    return {
-        module,
-        name,
-        layer,
-        activation,
-        activationSummary(describeOptions) {
-            return describeExtensionActivation(activation, describeOptions);
-        },
-        renderMarkdown(markdownOptions = {}) {
-            const { extensionName, ...renderOptions } = markdownOptions ?? {};
-            return renderExtensionSurfaceMarkdown(describeExtensionActivation(activation, { extensionName }), renderOptions);
-        },
-        assertCommandContract(expectation) {
-            return assertRegisteredCommandContract(activation.registrations, expectation);
-        },
-        assertFlags(expectation) {
-            return assertRegisteredFlags(activation.registrations, expectation);
-        },
-        assertItemField(expectation) {
-            return assertRegisteredItemField(activation.registrations, expectation);
-        },
-        assertItemType(expectation) {
-            return assertRegisteredItemType(activation.registrations, expectation);
-        },
-        assertProfile(expectation) {
-            return assertRegisteredProfile(activation.registrations, expectation);
-        },
-        assertHook(expectation) {
-            return assertRegisteredHook(activation.hooks, expectation);
-        },
-        assertCommandOverride(expectation) {
-            return assertRegisteredCommandOverride(activation.commands, expectation);
-        },
-        assertParserOverride(expectation) {
-            return assertRegisteredParserOverride(activation.parsers, expectation);
-        },
-        assertPreflightOverride(expectation) {
-            return assertRegisteredPreflightOverride(activation.preflight, expectation);
-        },
-        assertRendererOverride(expectation) {
-            return assertRegisteredRendererOverride(activation.renderers, expectation);
-        },
-        assertServiceOverride(expectation) {
-            return assertRegisteredServiceOverride(activation.services, expectation);
-        },
-        assertSearchProvider(expectation) {
-            return assertRegisteredSearchProvider(activation.registrations, expectation);
-        },
-        assertVectorStoreAdapter(expectation) {
-            return assertRegisteredVectorStoreAdapter(activation.registrations, expectation);
-        },
-        assertImporter(expectation) {
-            return assertRegisteredImporter(activation.registrations, expectation);
-        },
-        assertExporter(expectation) {
-            return assertRegisteredExporter(activation.registrations, expectation);
-        },
-        assertMigration(expectation) {
-            return assertRegisteredMigration(activation.registrations, expectation);
-        },
-        assertCapabilityUsage(expectation) {
-            return assertExtensionCapabilityUsage(activation, expectation);
-        },
-        runCommand(runOptions) {
-            return runRegisteredCommandForTest(activation.commands, runOptions);
-        },
-        runHook(runOptions) {
-            return runRegisteredHookForTest(activation.hooks, runOptions);
-        },
-        runMutationGuard(runOptions) {
-            return runRegisteredMutationGuardForTest(activation.hooks, runOptions);
-        },
-        runCommandOverride(context) {
-            return runRegisteredCommandOverrideForTest(activation.commands, context);
-        },
-        runParserOverride(context) {
-            return runRegisteredParserOverrideForTest(activation.parsers, context);
-        },
-        runPreflightOverride(context) {
-            return runRegisteredPreflightOverrideForTest(activation.preflight, context);
-        },
-        runRendererOverride(context) {
-            return runRegisteredRendererOverrideForTest(activation.renderers, context);
-        },
-        runServiceOverride(context) {
-            return runRegisteredServiceOverrideForTest(activation.services, context);
-        },
-        runSearchProvider(runOptions) {
-            return runRegisteredSearchProviderForTest(activation.registrations, runOptions);
-        },
-        runVectorStoreAdapter(runOptions) {
-            return runRegisteredVectorStoreAdapterForTest(activation.registrations, runOptions);
-        },
-        runMigration(runOptions) {
-            return runRegisteredMigrationForTest(activation.registrations, runOptions);
-        },
-        runImporter(runOptions) {
-            return runRegisteredImporterForTest(activation, runOptions);
-        },
-        runExporter(runOptions) {
-            return runRegisteredExporterForTest(activation, runOptions);
-        },
-        deactivate(deactivateOptions = {}) {
-            return deactivateExtensionForTest(module, {
-                name,
-                layer,
-                activation,
-                deactivateTimeoutMs: deactivateOptions.deactivateTimeoutMs,
-            });
-        },
-    };
-}
+!(function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fa9e95e5-7782-509d-96af-093a47daaed7")}catch(e2){}})();import{activateExtensions,deactivateExtensions,runAfterCommandHooks,runBeforeCommandHooks,runBeforeMutationHooks,runCommandHandler,runCommandOverride,runOnIndexHooks,runOnReadHooks,runOnWriteHooks,runParserOverride,runPreflightOverride,runRendererOverride,runServiceOverride}from"../core/extensions/loader.js";import{createDefaultExtensionGovernancePolicy}from"../core/extensions/extension-types.js";import{getMigrationRuntimeDefinition,resolveRegisteredSearchProvider,resolveRegisteredVectorStoreAdapter}from"../core/extensions/runtime-registrations.js";import{collectUsedExtensionCapabilities}from"../core/extensions/capability-usage.js";import{normalizeKnownExtensionCapability}from"../core/extensions/extension-capability-aliases.js";import{checkExtensionManifestCompatibility,describeExtensionBlueprint,lintExtensionBlueprint,preflightExtension}from"./compose.js";import{describeExtensionActivation}from"../core/extensions/activation-summary.js";import{lintProjectProfile}from"../core/profile/profile-lint.js";import{renderExtensionSurfaceMarkdown}from"../core/extensions/activation-summary-markdown.js";import{asPropertyRecord,resolveActivatablePropertyRecord}from"../core/shared/primitives.js";import{createExtensionCommandSdk}from"./extension-command-context.js";import{PmClient}from"./runtime.js";function registeredExpectationName(expectation,legacyValue){return expectation.name??legacyValue??""}const HOOK_KIND_TO_REGISTRY_FIELD={before_command:"beforeCommand",before_mutation:"beforeMutation",after_command:"afterCommand",on_read:"onRead",on_write:"onWrite",on_index:"onIndex"};const RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD={before_command:"beforeCommand",after_command:"afterCommand",on_read:"onRead",on_write:"onWrite",on_index:"onIndex"};function normalizeSdkIdentifier(value){return value.trim().toLowerCase()}function normalizeSdkProfileMatchKey(value){return normalizeSdkIdentifier(value).replaceAll("-","_")}function extensionNameSuffix(extensionName){return extensionName?` from extension "${extensionName}"`:""}function sortedUnique(values){return[...new Set(values)].sort((left,right)=>left.localeCompare(right))}function normalizeSdkCommandName(command){if(typeof command!=="string"){throw new Error('A command name string is required. Pass it via the options object, e.g. runRegisteredCommandForTest(activation, { command: "my command" }) \u2014 positional command arguments are not supported.')}return command.trim().toLowerCase().split(/\s+/).filter(part=>part.length>0).join(" ")}function formatAvailable(values){return values.length>0?values.join(", "):"(none)"}function assertStringSetIncludes(actual,expected,label){const actualValues=new Set(actual??[]);const missing=sortedUnique(expected.filter(value=>!actualValues.has(value)));if(missing.length>0){throw new Error(`Expected package manifest ${label} to include ${missing.join(", ")}; available: ${formatAvailable(sortedUnique(actual??[]))}`)}}function collectFlagLabels(flags){const labels=new Set;for(const flag of flags){if(typeof flag.long==="string"&&flag.long.trim().length>0){labels.add(flag.long.trim())}if(typeof flag.short==="string"&&flag.short.trim().length>0){labels.add(flag.short.trim())}}return labels}function readTestExtensionManifest(module){const moduleRecord=asPropertyRecord(module);if(!moduleRecord){return{}}const manifest=asPropertyRecord(moduleRecord.manifest);if(manifest){return manifest}const defaultExport=asPropertyRecord(moduleRecord.default);const defaultManifest=asPropertyRecord(defaultExport?.manifest);if(defaultManifest){return defaultManifest}if(defaultExport&&typeof moduleRecord.default!=="function"&&("name"in defaultExport||"capabilities"in defaultExport)){return defaultExport}if(typeof module!=="function"&&("name"in moduleRecord||"capabilities"in moduleRecord)){return moduleRecord}return{}}function resolveTestExtensionName(manifest,explicitName){return explicitName??(typeof manifest.name==="string"&&manifest.name.trim().length>0?manifest.name.trim():"test-extension")}function readTestExtensionCapabilities(manifest,options){if(Array.isArray(options.capabilities)){return[...options.capabilities]}if(Array.isArray(manifest.capabilities)){return manifest.capabilities.filter(capability=>typeof capability==="string")}return[]}function buildSingleExtensionLoadResult(module,manifest,identity){return{disabled_by_flag:false,roots:{global:"",project:""},configured_enabled:[],configured_disabled:[],discovered:[],effective:[],warnings:[],policy:identity.policy,failed:[],loaded:[{layer:identity.layer,directory:"",manifest_path:"",name:identity.name,version:typeof manifest.version==="string"?manifest.version:"0.0.0",entry:typeof manifest.entry==="string"?manifest.entry:"./index.js",priority:typeof manifest.priority==="number"?manifest.priority:0,entry_path:"",capabilities:identity.capabilities,manifest_version:typeof manifest.manifest_version==="number"?manifest.manifest_version:void 0,pm_min_version:typeof manifest.pm_min_version==="string"?manifest.pm_min_version:void 0,pm_max_version:typeof manifest.pm_max_version==="string"?manifest.pm_max_version:void 0,engines:manifest.engines,trusted:manifest.trusted,provenance:manifest.provenance,sandbox_profile:manifest.sandbox_profile,permissions:manifest.permissions,activation:manifest.activation,module}]}}async function activateExtensionForTest(module,options={}){const manifest=readTestExtensionManifest(module);return activateExtensions(buildSingleExtensionLoadResult(module,manifest,{name:resolveTestExtensionName(manifest,options.name),layer:options.layer??"project",capabilities:readTestExtensionCapabilities(manifest,options),policy:options.policy??createDefaultExtensionGovernancePolicy()}))}async function deactivateExtensionForTest(module,options={}){const manifest=readTestExtensionManifest(module);return deactivateExtensions(buildSingleExtensionLoadResult(module,manifest,{name:resolveTestExtensionName(manifest,options.name),layer:options.layer??"project",capabilities:readTestExtensionCapabilities(manifest,{}),policy:createDefaultExtensionGovernancePolicy()}),options.activation,options.deactivateTimeoutMs===void 0?{}:{deactivate_timeout_ms:options.deactivateTimeoutMs})}async function runRegisteredCommandForTest(commands,options){const command=normalizeSdkCommandName(options.command);if(command.length===0){throw new Error("Expected command name must be a non-empty string")}const hasHandler=commands.handlers.some(entry=>entry.command===command);if(!hasHandler){const available=sortedUnique(commands.handlers.map(entry=>entry.command));throw new Error(`Expected a registered command handler for "${command}" to invoke. Available command handlers: ${formatAvailable(available)}`)}if(options.sdk!==void 0&&options.sdkFactory!==void 0){throw new TypeError("runRegisteredCommandForTest accepts sdk or sdkFactory, not both")}const pmRoot=options.pmRoot??"";const global2={json:true,quiet:true,noPager:true,...options.global};const sdk=options.sdk??options.sdkFactory?.({pmRoot,global:global2})??(pmRoot.length>0?createExtensionCommandSdk(pmRoot,new PmClient({pmRoot})):void 0);return runCommandHandler(commands,{command,args:options.args?[...options.args]:[],options:options.options?{...options.options}:{},global:global2,pm_root:pmRoot,...sdk===void 0?{}:{sdk}})}async function runRegisteredMutationGuardForTest(hooks,options){if((hooks.beforeMutation?.length??0)===0){throw new Error("Expected a registered before_mutation hook to invoke")}await runBeforeMutationHooks(hooks,options.context)}async function runRegisteredHookForTest(hooks,options){const kind=options.kind;if(kind==="before_mutation"){throw new Error("Invoke before_mutation hooks with runRegisteredMutationGuardForTest so denials and failures retain fail-closed semantics.")}if((hooks[RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD[kind]]?.length??0)===0){const populatedKinds=sortedUnique(Object.keys(RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD).filter(candidateKind=>(hooks[RUNNABLE_HOOK_KIND_TO_REGISTRY_FIELD[candidateKind]]?.length??0)>0));throw new Error(`Expected a registered "${kind}" hook to invoke. Hook kinds with registrations: ${formatAvailable(populatedKinds)}`)}switch(options.kind){case"before_command":return runBeforeCommandHooks(hooks,options.context);case"after_command":return runAfterCommandHooks(hooks,options.context);case"on_read":return runOnReadHooks(hooks,options.context);case"on_write":return runOnWriteHooks(hooks,options.context);case"on_index":return runOnIndexHooks(hooks,options.context)}}async function runRegisteredParserOverrideForTest(parsers,context){const command=normalizeSdkCommandName(context.command);if(!parsers.overrides.some(entry=>entry.command===command)){throw new Error(`Expected a registered parser override for command "${command}" to invoke. Available parser override commands: ${formatAvailable(sortedUnique(parsers.overrides.map(entry=>entry.command)))}`)}return runParserOverride(parsers,context)}async function runRegisteredPreflightOverrideForTest(preflight,context){if(preflight.overrides.length===0){throw new Error("Expected a registered preflight override to invoke, but none are registered.")}return runPreflightOverride(preflight,context)}async function runRegisteredCommandOverrideForTest(commands,context){const command=normalizeSdkCommandName(context.command);if(!commands.overrides.some(entry=>entry.command===command)){throw new Error(`Expected a registered command override for command "${command}" to invoke. Available command override commands: ${formatAvailable(sortedUnique(commands.overrides.map(entry=>entry.command)))}`)}return runCommandOverride(commands,context)}async function runRegisteredRendererOverrideForTest(renderers,context){if(!renderers.overrides.some(entry=>entry.format===context.format)){throw new Error(`Expected a registered renderer override for format "${context.format}" to invoke. Available renderer override formats: ${formatAvailable(sortedUnique(renderers.overrides.map(entry=>entry.format)))}`)}return runRendererOverride(renderers,context)}async function runRegisteredServiceOverrideForTest(services,context){if(!services.overrides.some(entry=>entry.service===context.service)){throw new Error(`Expected a registered service override for service "${context.service}" to invoke. Available service override services: ${formatAvailable(sortedUnique(services.overrides.map(entry=>entry.service)))}`)}return runServiceOverride(services,context)}const SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS={query:["query"],embed:["embed"],embedBatch:["embedBatch","embed_batch"],queryExpansion:["queryExpansion","query_expansion"],rerank:["rerank"]};async function runRegisteredSearchProviderForTest(registrations,options){const registration=resolveRegisteredSearchProvider(registrations,options.provider);if(!registration){const available=sortedUnique(registrations.search_providers.map(entry=>entry.definition.name));throw new Error(`Expected a registered search provider "${options.provider}" to invoke. Available search providers: ${formatAvailable(available)}`)}const runtimeDefinition=registration.runtime_definition;const operationFn=SEARCH_PROVIDER_OPERATION_DEFINITION_KEYS[options.operation].map(key=>runtimeDefinition[key]).find(value=>typeof value==="function");if(typeof operationFn!=="function"){throw new Error(`Registered search provider "${options.provider}" does not implement the "${options.operation}" operation.`)}return await operationFn(options.context)}async function runRegisteredVectorStoreAdapterForTest(registrations,options){const registration=resolveRegisteredVectorStoreAdapter(registrations,options.adapter);if(!registration){const available=sortedUnique(registrations.vector_store_adapters.map(entry=>entry.definition.name));throw new Error(`Expected a registered vector store adapter "${options.adapter}" to invoke. Available vector store adapters: ${formatAvailable(available)}`)}const operationFn=registration.runtime_definition[options.operation];if(typeof operationFn!=="function"){throw new Error(`Registered vector store adapter "${options.adapter}" does not implement the "${options.operation}" operation.`)}return await operationFn(options.context)}async function runRegisteredMigrationForTest(registrations,options){const migration=assertRegisteredMigration(registrations,{migration:options.migration,extensionName:options.extensionName});const run=getMigrationRuntimeDefinition(migration).run;if(typeof run!=="function"){throw new Error(`Registered migration "${options.migration}" does not implement a run function to invoke.`)}const declaredStatus=migration.definition.status;const context={id:migration.definition.id,command:"migration",layer:migration.layer,extension:migration.name,pm_root:options.pmRoot??"",status:(typeof declaredStatus==="string"?declaredStatus.trim().toLowerCase():"")||"pending"};return await run(context)}async function runRegisteredImporterForTest(activation,options){const importer=assertRegisteredImporter(activation.registrations,{importer:options.importer,extensionName:options.extensionName});return runRegisteredCommandForTest(activation.commands,{command:`${importer.importer} import`,args:options.args,options:options.options,global:options.global,pmRoot:options.pmRoot})}async function runRegisteredExporterForTest(activation,options){const exporter=assertRegisteredExporter(activation.registrations,{exporter:options.exporter,extensionName:options.extensionName});return runRegisteredCommandForTest(activation.commands,{command:`${exporter.exporter} export`,args:options.args,options:options.options,global:options.global,pmRoot:options.pmRoot})}function assertExtensionDeactivated(result,expectation={}){const expectedDeactivated=expectation.deactivated??1;if(result.deactivated!==expectedDeactivated){throw new Error(`Expected ${expectedDeactivated} extension${expectedDeactivated===1?"":"s"} to deactivate cleanly, but ${result.deactivated} did.`)}const expectedFailed=expectation.failed??0;if(result.failed.length!==expectedFailed){const detail=result.failed.map(failure=>`${failure.layer}:${failure.name} (${failure.error})`).join(", ");throw new Error(`Expected ${expectedFailed} teardown failure${expectedFailed===1?"":"s"}, but observed ${result.failed.length}${detail.length>0?`: ${detail}`:""}.`)}return result}function assertPackageManifest(manifest,expectation){if(expectation.packageName!==void 0&&manifest.package_name!==expectation.packageName){throw new Error(`Expected package manifest package_name to be "${expectation.packageName}"; received "${manifest.package_name??"(none)"}"`)}if(expectation.aliases!==void 0){assertStringSetIncludes(manifest.aliases,expectation.aliases,"aliases")}if(expectation.resources!==void 0){for(const[kind,expectedPaths]of Object.entries(expectation.resources)){assertStringSetIncludes(manifest.resources[kind],expectedPaths,`pm.${kind}`)}}return manifest}function assertRegisteredCommandContract(registrations,expectation){const expectedCommand=normalizeSdkCommandName(registeredExpectationName(expectation,expectation.command));if(expectedCommand.length===0){throw new Error("Expected command name must be a non-empty string")}const commandCandidates=registrations.commands.filter(entry=>entry.command===expectedCommand);const command=expectation.extensionName?commandCandidates.find(entry=>entry.name===expectation.extensionName):commandCandidates[0];if(!command){const available=registrations.commands.map(entry=>entry.command).sort((left,right)=>left.localeCompare(right));const extensionSuffix=expectation.extensionName?` from extension "${expectation.extensionName}"`:"";throw new Error(`Expected extension command "${expectedCommand}"${extensionSuffix} to be registered. Available commands: ${formatAvailable(available)}`)}if(expectation.action!==void 0&&command.action!==expectation.action){throw new Error(`Expected extension command "${expectedCommand}" action "${expectation.action}", received "${command.action}"`)}if(expectation.arguments!==void 0){const actualArguments=(command.arguments??[]).map(argument=>argument.name);const missingArguments=expectation.arguments.filter(argument=>!actualArguments.includes(argument));if(missingArguments.length>0){throw new Error(`Expected extension command "${expectedCommand}" arguments ${formatAvailable(expectation.arguments)}; missing ${formatAvailable(missingArguments)}; available ${formatAvailable(actualArguments)}`)}}const flags=registrations.flags.filter(entry=>entry.target_command===expectedCommand&&(expectation.extensionName===void 0||entry.name===expectation.extensionName)).flatMap(entry=>entry.flags);if(expectation.flags!==void 0){const actualFlagLabels=collectFlagLabels(flags);const missingFlags=expectation.flags.filter(flag=>!actualFlagLabels.has(flag));if(missingFlags.length>0){throw new Error(`Expected extension command "${expectedCommand}" flags ${formatAvailable(expectation.flags)}; missing ${formatAvailable(missingFlags)}; available ${formatAvailable([...actualFlagLabels].sort((left,right)=>left.localeCompare(right)))}`)}}return{command,flags}}function assertRegisteredFlags(registrations,expectation){const expectedCommand=normalizeSdkCommandName(registeredExpectationName(expectation,expectation.targetCommand));if(expectedCommand.length===0){throw new Error("Expected target command name must be a non-empty string")}const candidates=registrations.flags.filter(entry=>entry.target_command===expectedCommand);let registration;if(expectation.extensionName){registration=candidates.find(entry=>entry.name===expectation.extensionName)}else if(candidates.length===1){registration=candidates[0]}else if(candidates.length>1){const availableExtensions=sortedUnique(candidates.map(entry=>entry.name));throw new Error(`Expected flags for target command "${expectedCommand}" matched multiple extensions: ${formatAvailable(availableExtensions)}. Specify extensionName to choose one registration.`)}if(!registration){const available=sortedUnique(registrations.flags.map(entry=>entry.target_command));const availableExtensions=sortedUnique(candidates.map(entry=>entry.name));throw new Error(`Expected flags for target command "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available flag target commands: ${formatAvailable(available)}; matching extensions: ${formatAvailable(availableExtensions)}`)}if(expectation.flags!==void 0){const actualFlagLabels=collectFlagLabels(registration.flags);const missingFlags=expectation.flags.filter(flag=>!actualFlagLabels.has(flag));if(missingFlags.length>0){throw new Error(`Expected flags for target command "${expectedCommand}" to include ${formatAvailable(expectation.flags)}; missing ${formatAvailable(missingFlags)}; available ${formatAvailable([...actualFlagLabels].sort((left,right)=>left.localeCompare(right)))}`)}}return registration}function assertRegisteredHook(hooks,expectation){const field=HOOK_KIND_TO_REGISTRY_FIELD[expectation.kind];const candidates=hooks[field]??[];const hook=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!hook){const available=sortedUnique(candidates.map(entry=>entry.name));throw new Error(`Expected a "${expectation.kind}" hook${extensionNameSuffix(expectation.extensionName)} to be registered. Available "${expectation.kind}" hooks: ${formatAvailable(available)}`)}return hook}function assertRegisteredSearchProvider(registrations,expectation){const expectedProvider=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.provider));if(expectedProvider.length===0){throw new Error("Expected search provider name must be a non-empty string")}const candidates=registrations.search_providers.filter(entry=>normalizeSdkIdentifier(entry.definition.name)===expectedProvider);const provider=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!provider){const available=sortedUnique(registrations.search_providers.map(entry=>entry.definition.name));throw new Error(`Expected search provider "${expectedProvider}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available search providers: ${formatAvailable(available)}`)}return provider}function assertRegisteredVectorStoreAdapter(registrations,expectation){const expectedAdapter=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.adapter));if(expectedAdapter.length===0){throw new Error("Expected vector store adapter name must be a non-empty string")}const candidates=registrations.vector_store_adapters.filter(entry=>normalizeSdkIdentifier(entry.definition.name)===expectedAdapter);const adapter=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!adapter){const available=sortedUnique(registrations.vector_store_adapters.map(entry=>entry.definition.name));throw new Error(`Expected vector store adapter "${expectedAdapter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available vector store adapters: ${formatAvailable(available)}`)}return adapter}function assertRegisteredImporter(registrations,expectation){const expectedImporter=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.importer));if(expectedImporter.length===0){throw new Error("Expected importer name must be a non-empty string")}const candidates=registrations.importers.filter(entry=>normalizeSdkIdentifier(entry.importer)===expectedImporter);const importer=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!importer){const available=sortedUnique(registrations.importers.map(entry=>entry.importer));throw new Error(`Expected importer "${expectedImporter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available importers: ${formatAvailable(available)}`)}return importer}function assertRegisteredExporter(registrations,expectation){const expectedExporter=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.exporter));if(expectedExporter.length===0){throw new Error("Expected exporter name must be a non-empty string")}const candidates=registrations.exporters.filter(entry=>normalizeSdkIdentifier(entry.exporter)===expectedExporter);const exporter=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!exporter){const available=sortedUnique(registrations.exporters.map(entry=>entry.exporter));throw new Error(`Expected exporter "${expectedExporter}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available exporters: ${formatAvailable(available)}`)}return exporter}function assertRegisteredItemField(registrations,expectation){const expectedField=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.field));if(expectedField.length===0){throw new Error("Expected item field name must be a non-empty string")}const candidates=registrations.item_fields.filter(entry=>expectation.extensionName===void 0||entry.name===expectation.extensionName).map(registration=>({registration,field:registration.fields.find(field=>normalizeSdkIdentifier(field.name)===expectedField)})).filter(entry=>entry.field!==void 0);const match=candidates.find(entry=>expectation.type===void 0||entry.field.type===expectation.type);if(!match){const available=sortedUnique(registrations.item_fields.flatMap(entry=>entry.fields.map(field=>`${field.name}:${field.type}`)));throw new Error(`Expected item field "${expectedField}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available item fields: ${formatAvailable(available)}`)}return match}function assertRegisteredItemType(registrations,expectation){const expectedType=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.itemType));if(expectedType.length===0){throw new Error("Expected item type name must be a non-empty string")}const candidates=registrations.item_types.filter(entry=>expectation.extensionName===void 0||entry.name===expectation.extensionName).map(registration=>({registration,itemType:registration.types.find(itemType=>normalizeSdkIdentifier(itemType.name)===expectedType)})).filter(entry=>entry.itemType!==void 0);const match=candidates.find(entry=>expectation.folder===void 0||entry.itemType.folder===expectation.folder);if(!match){const available=sortedUnique(registrations.item_types.flatMap(entry=>entry.types.map(itemType=>`${itemType.name}:${itemType.folder}`)));throw new Error(`Expected item type "${expectedType}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available item types: ${formatAvailable(available)}`)}return match}function assertRegisteredProfile(registrations,expectation){const expectedProfile=normalizeSdkProfileMatchKey(registeredExpectationName(expectation,expectation.profile));if(expectedProfile.length===0){throw new Error("Expected profile name must be a non-empty string")}const match=registrations.profiles.filter(entry=>expectation.extensionName===void 0||entry.name===expectation.extensionName).find(entry=>normalizeSdkProfileMatchKey(entry.profile.name)===expectedProfile);if(!match){const available=sortedUnique(registrations.profiles.map(entry=>entry.profile.name));throw new Error(`Expected profile "${expectedProfile}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available profiles: ${formatAvailable(available)}`)}return{registration:match,profile:match.profile}}function assertRegisteredCommandOverride(commands,expectation){const expectedCommand=normalizeSdkCommandName(registeredExpectationName(expectation,expectation.command));if(expectedCommand.length===0){throw new Error("Expected command name must be a non-empty string")}const candidates=commands.overrides.filter(entry=>entry.command===expectedCommand);const override=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!override){const available=sortedUnique(commands.overrides.map(entry=>entry.command));throw new Error(`Expected command override "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available command overrides: ${formatAvailable(available)}`)}return override}function assertRegisteredParserOverride(parsers,expectation){const expectedCommand=normalizeSdkCommandName(registeredExpectationName(expectation,expectation.command));if(expectedCommand.length===0){throw new Error("Expected command name must be a non-empty string")}const candidates=parsers.overrides.filter(entry=>entry.command===expectedCommand);const override=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!override){const available=sortedUnique(parsers.overrides.map(entry=>entry.command));throw new Error(`Expected parser override "${expectedCommand}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available parser overrides: ${formatAvailable(available)}`)}return override}function assertRegisteredPreflightOverride(preflight,expectation={}){const override=expectation.extensionName?preflight.overrides.find(entry=>entry.name===expectation.extensionName):preflight.overrides[0];if(!override){const available=sortedUnique(preflight.overrides.map(entry=>entry.name));throw new Error(`Expected a preflight override${extensionNameSuffix(expectation.extensionName)} to be registered. Available preflight overrides: ${formatAvailable(available)}`)}return override}function assertRegisteredRendererOverride(renderers,expectation){const expectedFormat=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.format));if(expectedFormat.length===0){throw new Error("Expected renderer format must be a non-empty string")}const candidates=renderers.overrides.filter(entry=>entry.format===expectedFormat);const override=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!override){const available=sortedUnique(renderers.overrides.map(entry=>entry.format));throw new Error(`Expected renderer override "${expectedFormat}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available renderer overrides: ${formatAvailable(available)}`)}return override}function assertRegisteredServiceOverride(services,expectation){const expectedService=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.service));if(expectedService.length===0){throw new Error("Expected service name must be a non-empty string")}const candidates=services.overrides.filter(entry=>normalizeSdkIdentifier(entry.service)===expectedService);const override=expectation.extensionName?candidates.find(entry=>entry.name===expectation.extensionName):candidates[0];if(!override){const available=sortedUnique(services.overrides.map(entry=>entry.service));throw new Error(`Expected service override "${expectedService}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available service overrides: ${formatAvailable(available)}`)}return override}function assertRegisteredMigration(registrations,expectation){const expectedMigration=normalizeSdkIdentifier(registeredExpectationName(expectation,expectation.migration));if(expectedMigration.length===0){throw new Error("Expected migration id must be a non-empty string")}const candidates=registrations.migrations.filter(entry=>(expectation.extensionName===void 0||entry.name===expectation.extensionName)&&typeof entry.definition.id==="string"&&normalizeSdkIdentifier(entry.definition.id)===expectedMigration);const match=candidates.find(entry=>expectation.mandatory===void 0||(entry.definition.mandatory??false)===expectation.mandatory);if(match){return match}const idMatch=candidates[0];if(idMatch!==void 0){throw new Error(`Expected migration "${expectedMigration}"${extensionNameSuffix(expectation.extensionName)} to have mandatory=${expectation.mandatory}, but it is mandatory=${idMatch.definition.mandatory??false}.`)}const available=sortedUnique(registrations.migrations.map(entry=>{const id=typeof entry.definition.id==="string"&&entry.definition.id.trim().length>0?entry.definition.id.trim():"(unnamed)";return`${id}:${entry.definition.mandatory===true}`}));throw new Error(`Expected migration "${expectedMigration}"${extensionNameSuffix(expectation.extensionName)} to be registered. Available migrations: ${formatAvailable(available)}`)}function assertExtensionCapabilityUsage(activation,expectation){const toKnownCapabilitySet=(capabilities,field)=>{const known=new Set;for(const capability of capabilities){const normalized=normalizeKnownExtensionCapability(capability);if(normalized===null){throw new Error(`Expected ${field} capability "${capability}" to be a known extension capability. Use canonical capability names (see manifest.capabilities).`)}known.add(normalized)}return known};const declared=[...toKnownCapabilitySet(expectation.declared,"declared")].sort((left,right)=>left.localeCompare(right));const allowUnused=toKnownCapabilitySet(expectation.allowUnused??[],"allowUnused");const used=collectUsedExtensionCapabilities(activation,{extensionName:expectation.extensionName});const usedSet=new Set(used);const unused=declared.filter(capability=>!usedSet.has(capability)&&!allowUnused.has(capability));if(unused.length>0){const scopeSuffix=extensionNameSuffix(expectation.extensionName);throw new Error(`Expected every declared capability${scopeSuffix} to be exercised, but [${unused.join(", ")}] ${unused.length===1?"is":"are"} declared yet never registered against. Remove ${unused.length===1?"it":"them"} from manifest.capabilities for least privilege, or pass allowUnused for capabilities registered only behind a runtime flag.`)}return{declared,used,unused}}function assertExtensionBlueprint(blueprint,options={}){const result=lintExtensionBlueprint(blueprint,options);if(!result.ok){const errors=result.findings.filter(finding=>finding.severity==="error");throw new Error(`Extension blueprint failed preflight with ${errors.length} ${errors.length===1?"error":"errors"}:
+`+errors.map(finding=>`  - [${finding.code}] ${finding.message}`).join("\n"))}return result}function assertProjectProfile(profile,options={}){const report=lintProjectProfile(profile);const blocking=report.findings.filter(finding=>finding.severity==="error"||options.strict===true&&finding.severity==="warning");if(blocking.length>0){throw new Error(`Project profile "${report.profile}" failed lint with ${blocking.length} ${blocking.length===1?"issue":"issues"}:
+`+blocking.map(finding=>`  - ${finding.severity} [${finding.code}] ${finding.message}`).join("\n"))}return report}function assertExtensionManifestMatchesBlueprint(manifest,blueprint){const declaredCapabilities=Array.isArray(manifest.capabilities)?manifest.capabilities:[];const result=lintExtensionBlueprint(blueprint,{declaredCapabilities});const declared=result.declared;const declaredSet=new Set(declared);const usedSet=new Set(result.used);const missing=result.used.filter(capability=>!declaredSet.has(capability));const unused=declared.filter(capability=>!usedSet.has(capability));if(missing.length>0||unused.length>0){const parts=[];if(missing.length>0){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)`)}if(unused.length>0){parts.push(`unused [${unused.join(", ")}] (declared but no surface exercises ${unused.length===1?"it":"them"}; drop for least privilege)`)}throw new Error(`Manifest capabilities do not match the blueprint: ${parts.join("; ")}. Set capabilities to synthesizeExtensionManifest(blueprint, identity).capabilities to stay in sync.`)}return{used:result.used,declared,missing,unused,findings:result.findings}}function assertExtensionManifestCompatible(manifest,target){const result=checkExtensionManifestCompatibility(manifest,target);const blocking=result.findings.filter(finding=>finding.severity==="error");if(blocking.length>0){throw new Error(`Extension manifest is not compatible with pm ${result.pmVersion}: ${blocking.map(finding=>finding.message).join("; ")}`)}return result}function assertExtensionPreflight(blueprint,options={}){const report=preflightExtension(blueprint,options);if(!report.ok){const errors=report.findings.filter(finding=>finding.severity==="error");throw new Error(`Extension failed preflight with ${errors.length} ${errors.length===1?"error":"errors"}:
+`+errors.map(finding=>`  - [${finding.source}:${finding.code}] ${finding.message}`).join("\n"))}return report}function assertTestModuleHasActivateExport(module){if(resolveActivatablePropertyRecord(module)){return}throw new Error("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.")}async function createExtensionTestHarness(module,options={}){assertTestModuleHasActivateExport(module);const manifest=readTestExtensionManifest(module);const name=resolveTestExtensionName(manifest,options.name);const layer=options.layer??"project";const activation=await activateExtensionForTest(module,options);if(activation.failed.length>0){const detail=activation.failed.map(failure=>{const missingCapability=failure.trace?.missing_capability;const reason=missingCapability?`${failure.error}; missing capability "${missingCapability}"`:failure.error;return`${failure.layer}:${failure.name} (${reason})`}).join(", ");throw new Error(`createExtensionTestHarness could not activate the extension cleanly: ${detail}. Declare the required capability in the manifest (or pass it via options.capabilities), or use activateExtensionForTest directly to inspect a failed activation.`)}return{module,name,layer,activation,activationSummary(describeOptions){return describeExtensionActivation(activation,describeOptions)},renderMarkdown(markdownOptions={}){const{extensionName,...renderOptions}=markdownOptions??{};return renderExtensionSurfaceMarkdown(describeExtensionActivation(activation,{extensionName}),renderOptions)},assertCommandContract(expectation){return assertRegisteredCommandContract(activation.registrations,expectation)},assertFlags(expectation){return assertRegisteredFlags(activation.registrations,expectation)},assertItemField(expectation){return assertRegisteredItemField(activation.registrations,expectation)},assertItemType(expectation){return assertRegisteredItemType(activation.registrations,expectation)},assertProfile(expectation){return assertRegisteredProfile(activation.registrations,expectation)},assertHook(expectation){return assertRegisteredHook(activation.hooks,expectation)},assertCommandOverride(expectation){return assertRegisteredCommandOverride(activation.commands,expectation)},assertParserOverride(expectation){return assertRegisteredParserOverride(activation.parsers,expectation)},assertPreflightOverride(expectation){return assertRegisteredPreflightOverride(activation.preflight,expectation)},assertRendererOverride(expectation){return assertRegisteredRendererOverride(activation.renderers,expectation)},assertServiceOverride(expectation){return assertRegisteredServiceOverride(activation.services,expectation)},assertSearchProvider(expectation){return assertRegisteredSearchProvider(activation.registrations,expectation)},assertVectorStoreAdapter(expectation){return assertRegisteredVectorStoreAdapter(activation.registrations,expectation)},assertImporter(expectation){return assertRegisteredImporter(activation.registrations,expectation)},assertExporter(expectation){return assertRegisteredExporter(activation.registrations,expectation)},assertMigration(expectation){return assertRegisteredMigration(activation.registrations,expectation)},assertCapabilityUsage(expectation){return assertExtensionCapabilityUsage(activation,expectation)},runCommand(runOptions){return runRegisteredCommandForTest(activation.commands,runOptions)},runHook(runOptions){return runRegisteredHookForTest(activation.hooks,runOptions)},runMutationGuard(runOptions){return runRegisteredMutationGuardForTest(activation.hooks,runOptions)},runCommandOverride(context){return runRegisteredCommandOverrideForTest(activation.commands,context)},runParserOverride(context){return runRegisteredParserOverrideForTest(activation.parsers,context)},runPreflightOverride(context){return runRegisteredPreflightOverrideForTest(activation.preflight,context)},runRendererOverride(context){return runRegisteredRendererOverrideForTest(activation.renderers,context)},runServiceOverride(context){return runRegisteredServiceOverrideForTest(activation.services,context)},runSearchProvider(runOptions){return runRegisteredSearchProviderForTest(activation.registrations,runOptions)},runVectorStoreAdapter(runOptions){return runRegisteredVectorStoreAdapterForTest(activation.registrations,runOptions)},runMigration(runOptions){return runRegisteredMigrationForTest(activation.registrations,runOptions)},runImporter(runOptions){return runRegisteredImporterForTest(activation,runOptions)},runExporter(runOptions){return runRegisteredExporterForTest(activation,runOptions)},deactivate(deactivateOptions={}){return deactivateExtensionForTest(module,{name,layer,activation,deactivateTimeoutMs:deactivateOptions.deactivateTimeoutMs})}}}export{activateExtensionForTest,assertExtensionBlueprint,assertExtensionCapabilityUsage,assertExtensionDeactivated,assertExtensionManifestCompatible,assertExtensionManifestMatchesBlueprint,assertExtensionPreflight,assertPackageManifest,assertProjectProfile,assertRegisteredCommandContract,assertRegisteredCommandOverride,assertRegisteredExporter,assertRegisteredFlags,assertRegisteredHook,assertRegisteredImporter,assertRegisteredItemField,assertRegisteredItemType,assertRegisteredMigration,assertRegisteredParserOverride,assertRegisteredPreflightOverride,assertRegisteredProfile,assertRegisteredRendererOverride,assertRegisteredSearchProvider,assertRegisteredServiceOverride,assertRegisteredVectorStoreAdapter,createExtensionTestHarness,deactivateExtensionForTest,describeExtensionActivation,describeExtensionBlueprint,lintExtensionBlueprint,renderExtensionSurfaceMarkdown,runRegisteredCommandForTest,runRegisteredCommandOverrideForTest,runRegisteredExporterForTest,runRegisteredHookForTest,runRegisteredImporterForTest,runRegisteredMigrationForTest,runRegisteredMutationGuardForTest,runRegisteredParserOverrideForTest,runRegisteredPreflightOverrideForTest,runRegisteredRendererOverrideForTest,runRegisteredSearchProviderForTest,runRegisteredServiceOverrideForTest,runRegisteredVectorStoreAdapterForTest};
 //# sourceMappingURL=testing.js.map
-//# debugId=a09f5e0d-fccc-5a22-a6f3-0a37cbeea3b0