@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-P5TFTLWW.js

@@ -1,1423 +0,0 @@
-import {
-  lintProjectProfile
-} from "./chunk-DLQ4ZTCU.js";
-import {
-  getMigrationRuntimeDefinition,
-  resolveRegisteredSearchProvider,
-  resolveRegisteredVectorStoreAdapter
-} from "./chunk-B5KXLBSJ.js";
-import {
-  describeExtensionActivation,
-  renderExtensionSurfaceMarkdown
-} from "./chunk-C3PMDWGX.js";
-import {
-  activateExtensions,
-  asPropertyRecord,
-  collectUsedExtensionCapabilities,
-  createDefaultExtensionGovernancePolicy,
-  deactivateExtensions,
-  evaluatePmMaxVersionBound,
-  evaluatePmMinVersionBound,
-  normalizeCommandName,
-  normalizeKnownExtensionCapability,
-  resolveActivatablePropertyRecord,
-  resolveLegacyExtensionCapabilityAlias,
-  runAfterCommandHooks,
-  runBeforeCommandHooks,
-  runCommandHandler,
-  runCommandOverride,
-  runOnIndexHooks,
-  runOnReadHooks,
-  runOnWriteHooks,
-  runParserOverride,
-  runPreflightOverride,
-  runRendererOverride,
-  runServiceOverride
-} from "./chunk-5VVUKE3U.js";
-
-// dist/sdk/compose.js
-!(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] = "329d1e0e-99f4-5153-addd-3e8ae912dae1");
-  } catch (e2) {
-  }
-})();
-function defineExtension(module) {
-  return module;
-}
-function defineExtensionBlueprint(blueprint) {
-  return blueprint;
-}
-function registerBlueprintCommandSurfaces(api, blueprint) {
-  for (const command of blueprint.commands ?? []) {
-    api.registerCommand(command);
-  }
-  for (const [command, override] of Object.entries(blueprint.commandOverrides ?? {})) {
-    api.registerCommand(command, override);
-  }
-  for (const [targetCommand, flags] of Object.entries(blueprint.flags ?? {})) {
-    api.registerFlags(targetCommand, flags);
-  }
-  for (const [command, override] of Object.entries(blueprint.parsers ?? {})) {
-    api.registerParser(command, override);
-  }
-  for (const [format, renderer] of Object.entries(blueprint.renderers ?? {})) {
-    api.registerRenderer(format, renderer);
-  }
-  for (const [service, override] of Object.entries(blueprint.services ?? {})) {
-    api.registerService(service, override);
-  }
-}
-function registerBlueprintSchemaSurfaces(api, blueprint) {
-  for (const override of blueprint.preflights ?? []) {
-    api.registerPreflight(override);
-  }
-  const itemTypes = blueprint.itemTypes ?? [];
-  if (itemTypes.length > 0) {
-    api.registerItemTypes(itemTypes);
-  }
-  const itemFields = blueprint.itemFields ?? [];
-  if (itemFields.length > 0) {
-    api.registerItemFields(itemFields);
-  }
-  for (const migration of blueprint.migrations ?? []) {
-    api.registerMigration(migration);
-  }
-  for (const profile of blueprint.profiles ?? []) {
-    api.registerProfile(profile);
-  }
-}
-function registerBlueprintRetrievalSurfaces(api, blueprint) {
-  for (const provider of blueprint.searchProviders ?? []) {
-    api.registerSearchProvider(provider);
-  }
-  for (const adapter of blueprint.vectorStoreAdapters ?? []) {
-    api.registerVectorStoreAdapter(adapter);
-  }
-  for (const entry of blueprint.importers ?? []) {
-    api.registerImporter(entry.name, entry.importer, entry.options);
-  }
-  for (const entry of blueprint.exporters ?? []) {
-    api.registerExporter(entry.name, entry.exporter, entry.options);
-  }
-}
-function registerBlueprintHooks(api, hooks) {
-  for (const hook of hooks.beforeCommand ?? []) {
-    api.hooks.beforeCommand(hook);
-  }
-  for (const hook of hooks.afterCommand ?? []) {
-    api.hooks.afterCommand(hook);
-  }
-  for (const hook of hooks.onWrite ?? []) {
-    api.hooks.onWrite(hook);
-  }
-  for (const hook of hooks.onRead ?? []) {
-    api.hooks.onRead(hook);
-  }
-  for (const hook of hooks.onIndex ?? []) {
-    api.hooks.onIndex(hook);
-  }
-}
-function composeExtension(blueprint) {
-  const activate = async (api) => {
-    registerBlueprintCommandSurfaces(api, blueprint);
-    registerBlueprintSchemaSurfaces(api, blueprint);
-    registerBlueprintRetrievalSurfaces(api, blueprint);
-    registerBlueprintHooks(api, blueprint.hooks ?? {});
-    await blueprint.activate?.(api);
-  };
-  const module = { activate };
-  if (blueprint.manifest) {
-    module.manifest = blueprint.manifest;
-  }
-  if (blueprint.deactivate) {
-    module.deactivate = blueprint.deactivate;
-  }
-  return module;
-}
-function mergeArraySurface(surfaces) {
-  const merged = surfaces.flatMap((surface) => surface ?? []);
-  return merged.length > 0 ? merged : void 0;
-}
-function mergeHandlerRecord(surfaces) {
-  const merged = Object.assign({}, ...surfaces.map((surface) => surface ?? {}));
-  return Object.keys(merged).length > 0 ? merged : void 0;
-}
-function mergeFlagRecord(surfaces) {
-  const merged = {};
-  for (const surface of surfaces) {
-    for (const [command, flags] of Object.entries(surface ?? {})) {
-      merged[command] = [...merged[command] ?? [], ...flags];
-    }
-  }
-  return Object.keys(merged).length > 0 ? merged : void 0;
-}
-var EXTENSION_BLUEPRINT_HOOK_KEYS = [
-  "beforeCommand",
-  "afterCommand",
-  "onWrite",
-  "onRead",
-  "onIndex"
-];
-function assignMergedHookSurface(merged, surfaces, key) {
-  const hookArrays = surfaces.map((hooks) => hooks?.[key]);
-  const value = mergeArraySurface(hookArrays);
-  if (value !== void 0) {
-    const typedMerged = merged;
-    typedMerged[key] = value;
-  }
-}
-function mergeHookSurfaces(surfaces) {
-  const merged = {};
-  for (const key of EXTENSION_BLUEPRINT_HOOK_KEYS) {
-    assignMergedHookSurface(merged, surfaces, key);
-  }
-  return Object.keys(merged).length > 0 ? merged : void 0;
-}
-function mergeExtensionBlueprints(...blueprints) {
-  const merged = {};
-  const assign = (key, value) => {
-    if (value !== void 0) {
-      merged[key] = value;
-    }
-  };
-  assign("commands", mergeArraySurface(blueprints.map((blueprint) => blueprint.commands)));
-  assign("commandOverrides", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.commandOverrides)));
-  assign("flags", mergeFlagRecord(blueprints.map((blueprint) => blueprint.flags)));
-  assign("parsers", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.parsers)));
-  assign("renderers", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.renderers)));
-  assign("services", mergeHandlerRecord(blueprints.map((blueprint) => blueprint.services)));
-  assign("preflights", mergeArraySurface(blueprints.map((blueprint) => blueprint.preflights)));
-  assign("itemTypes", mergeArraySurface(blueprints.map((blueprint) => blueprint.itemTypes)));
-  assign("itemFields", mergeArraySurface(blueprints.map((blueprint) => blueprint.itemFields)));
-  assign("migrations", mergeArraySurface(blueprints.map((blueprint) => blueprint.migrations)));
-  assign("profiles", mergeArraySurface(blueprints.map((blueprint) => blueprint.profiles)));
-  assign("searchProviders", mergeArraySurface(blueprints.map((blueprint) => blueprint.searchProviders)));
-  assign("vectorStoreAdapters", mergeArraySurface(blueprints.map((blueprint) => blueprint.vectorStoreAdapters)));
-  assign("importers", mergeArraySurface(blueprints.map((blueprint) => blueprint.importers)));
-  assign("exporters", mergeArraySurface(blueprints.map((blueprint) => blueprint.exporters)));
-  assign("hooks", mergeHookSurfaces(blueprints.map((blueprint) => blueprint.hooks)));
-  let manifest;
-  for (const blueprint of blueprints) {
-    if (blueprint.manifest) {
-      manifest = blueprint.manifest;
-    }
-  }
-  assign("manifest", manifest);
-  const hasActivates = blueprints.some((blueprint) => blueprint.activate);
-  assign("activate", hasActivates ? async (api) => {
-    for (const blueprint of blueprints) {
-      if (blueprint.activate) {
-        await blueprint.activate(api);
-      }
-    }
-  } : void 0);
-  const hasDeactivates = blueprints.some((blueprint) => blueprint.deactivate);
-  assign("deactivate", hasDeactivates ? async () => {
-    const errors = [];
-    for (const blueprint of [...blueprints].reverse()) {
-      if (!blueprint.deactivate) {
-        continue;
-      }
-      try {
-        await blueprint.deactivate();
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length > 0) {
-      if (errors.length > 1) {
-        throw new AggregateError(errors, "Multiple extension blueprint deactivate hooks failed.");
-      }
-      throw errors[0];
-    }
-  } : void 0);
-  return merged;
-}
-var BLUEPRINT_FIELD_CAPABILITIES = [
-  ["commands", "commands"],
-  ["commandOverrides", "commands"],
-  ["flags", "schema"],
-  ["itemTypes", "schema"],
-  ["itemFields", "schema"],
-  ["migrations", "schema"],
-  ["profiles", "schema"],
-  ["parsers", "parser"],
-  ["renderers", "renderers"],
-  ["services", "services"],
-  ["preflights", "preflight"],
-  ["searchProviders", "search"],
-  ["vectorStoreAdapters", "search"],
-  ["importers", "importers"],
-  ["exporters", "importers"]
-];
-function hasEntries(value) {
-  if (!value) {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return value.length > 0;
-  }
-  return Object.keys(value).length > 0;
-}
-function deriveExtensionCapabilities(blueprint) {
-  const capabilities = /* @__PURE__ */ new Set();
-  for (const [field, capability] of BLUEPRINT_FIELD_CAPABILITIES) {
-    if (hasEntries(blueprint[field])) {
-      capabilities.add(capability);
-    }
-  }
-  if ((blueprint.commands ?? []).filter(isPresent).some((command) => command.flags !== void 0)) {
-    capabilities.add("schema");
-  }
-  const importExportEntries = [...blueprint.importers ?? [], ...blueprint.exporters ?? []].filter(isPresent);
-  if (importExportEntries.some((entry) => entry?.options?.flags !== void 0)) {
-    capabilities.add("schema");
-  }
-  if (importExportEntries.some((entry) => typeof entry === "object")) {
-    capabilities.add("commands");
-  }
-  const hooks = blueprint.hooks ?? {};
-  if ([hooks.beforeCommand, hooks.afterCommand, hooks.onWrite, hooks.onRead, hooks.onIndex].some(hasEntries)) {
-    capabilities.add("hooks");
-  }
-  return [...capabilities].sort((left, right) => left.localeCompare(right));
-}
-var BLUEPRINT_HOOK_FIELD_TO_KIND = [
-  ["beforeCommand", "before_command"],
-  ["afterCommand", "after_command"],
-  ["onWrite", "on_write"],
-  ["onRead", "on_read"],
-  ["onIndex", "on_index"]
-];
-function sortUnique(values) {
-  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function isPresent(value) {
-  return value !== null && value !== void 0;
-}
-function importerCommandPath(entry) {
-  return normalizeCommandName(`${entry.name} import`);
-}
-function exporterCommandPath(entry) {
-  return normalizeCommandName(`${entry.name} export`);
-}
-function collectBlueprintCommandPaths(commands, importers, exporters) {
-  return [
-    ...commands.map((command) => normalizeCommandName(command.name)),
-    ...importers.filter((entry) => entry.options !== void 0).map(importerCommandPath),
-    ...exporters.filter((entry) => entry.options !== void 0).map(exporterCommandPath)
-  ];
-}
-function collectBlueprintFlagCommands(blueprint, commands, importers, exporters) {
-  return [
-    ...Object.keys(blueprint.flags ?? {}).map((command) => normalizeCommandName(command)),
-    ...commands.filter((command) => command.flags !== void 0).map((command) => normalizeCommandName(command.name)),
-    ...importers.filter((entry) => entry.options?.flags !== void 0).map(importerCommandPath),
-    ...exporters.filter((entry) => entry.options?.flags !== void 0).map(exporterCommandPath)
-  ];
-}
-function collectBlueprintHookKinds(hooks) {
-  return BLUEPRINT_HOOK_FIELD_TO_KIND.filter(([field]) => (hooks[field]?.length ?? 0) > 0).map(([, kind]) => kind);
-}
-function collectBlueprintSurfaceSummary(blueprint, importers, exporters) {
-  return {
-    item_types: sortUnique((blueprint.itemTypes ?? []).map((type) => type.name)),
-    item_fields: sortUnique((blueprint.itemFields ?? []).map((field) => field.name)),
-    // id-less migrations register but carry no identifier, so they are omitted —
-    // exactly as describeExtensionActivation drops them from its `migrations` list.
-    migrations: sortUnique((blueprint.migrations ?? []).flatMap((migration) => typeof migration.id === "string" ? [migration.id] : [])),
-    profiles: sortUnique((blueprint.profiles ?? []).map((profile) => profile.name)),
-    importers: sortUnique(importers.map((entry) => normalizeCommandName(entry.name))),
-    exporters: sortUnique(exporters.map((entry) => normalizeCommandName(entry.name))),
-    search_providers: sortUnique((blueprint.searchProviders ?? []).map((provider) => provider.name)),
-    vector_store_adapters: sortUnique((blueprint.vectorStoreAdapters ?? []).map((adapter) => adapter.name)),
-    parser_overrides: sortUnique(Object.keys(blueprint.parsers ?? {}).map((command) => normalizeCommandName(command))),
-    service_overrides: sortUnique(Object.keys(blueprint.services ?? {}).map((service) => String(service).trim().toLowerCase())),
-    renderer_overrides: sortUnique(Object.keys(blueprint.renderers ?? {}).map((format) => String(format).trim().toLowerCase())),
-    preflight_overrides: (blueprint.preflights ?? []).length
-  };
-}
-function describeExtensionBlueprint(blueprint) {
-  const commands = (blueprint.commands ?? []).filter(isPresent);
-  const importers = (blueprint.importers ?? []).filter(isPresent);
-  const exporters = (blueprint.exporters ?? []).filter(isPresent);
-  const importerPaths = importers.map(importerCommandPath);
-  const exporterPaths = exporters.map(exporterCommandPath);
-  const commandPaths = collectBlueprintCommandPaths(commands, importers, exporters);
-  const flagCommands = collectBlueprintFlagCommands(blueprint, commands, importers, exporters);
-  const hooks = blueprint.hooks ?? {};
-  const surfaces = collectBlueprintSurfaceSummary(blueprint, importers, exporters);
-  return {
-    capabilities: deriveExtensionCapabilities(blueprint),
-    commands: sortUnique(commandPaths),
-    command_overrides: sortUnique(Object.keys(blueprint.commandOverrides ?? {}).map((command) => normalizeCommandName(command))),
-    // command_handlers is a superset of commands that also carries the synthesized
-    // importer/exporter command paths, but never the override-only paths.
-    command_handlers: sortUnique([...commandPaths, ...importerPaths, ...exporterPaths]),
-    hooks: collectBlueprintHookKinds(hooks),
-    flag_commands: sortUnique(flagCommands),
-    ...surfaces
-  };
-}
-var BLUEPRINT_LINTABLE_SURFACE_FIELDS = [
-  "commands",
-  "commandOverrides",
-  "flags",
-  "parsers",
-  "renderers",
-  "services",
-  "preflights",
-  "itemTypes",
-  "itemFields",
-  "migrations",
-  "profiles",
-  "searchProviders",
-  "vectorStoreAdapters",
-  "importers",
-  "exporters"
-];
-function normalizeDeclaredCapabilities(capabilities) {
-  const known = /* @__PURE__ */ new Set();
-  for (const capability of capabilities) {
-    const normalized = resolveLegacyExtensionCapabilityAlias(capability) ?? normalizeKnownExtensionCapability(capability);
-    if (normalized !== null) {
-      known.add(normalized);
-    }
-  }
-  return [...known].sort((left, right) => left.localeCompare(right));
-}
-function collectBlueprintCapabilityFindings(used, declared) {
-  const findings = [];
-  if (declared === null) {
-    if (used.length > 0) {
-      findings.push({
-        code: "manifest_capabilities_absent",
-        severity: "warning",
-        message: `Blueprint exercises ${used.length === 1 ? "capability" : "capabilities"} [${used.join(", ")}] but declares none; set capabilities to deriveExtensionCapabilities(blueprint) so the manifest grant matches.`
-      });
-    }
-    return findings;
-  }
-  const declaredSet = new Set(declared);
-  const usedSet = new Set(used);
-  for (const capability of used) {
-    if (!declaredSet.has(capability)) {
-      findings.push({
-        code: "capability_undeclared",
-        severity: "error",
-        message: `Blueprint exercises capability "${capability}" but it is absent from the declared capabilities; activation throws extension_capability_missing \u2014 add "${capability}" to the manifest capabilities.`,
-        capability
-      });
-    }
-  }
-  for (const capability of declared) {
-    if (!usedSet.has(capability)) {
-      findings.push({
-        code: "capability_unused",
-        severity: "warning",
-        message: `Capability "${capability}" is declared but no blueprint surface exercises it; drop it to keep the manifest least-privilege (pm package doctor reports this as extension_capability_unused).`,
-        capability
-      });
-    }
-  }
-  return findings;
-}
-function collectBlueprintCommandFindings(blueprint) {
-  const findings = [];
-  const commandPathCounts = /* @__PURE__ */ new Map();
-  for (const command of blueprint.commands ?? []) {
-    const path = normalizeCommandName(command.name);
-    commandPathCounts.set(path, (commandPathCounts.get(path) ?? 0) + 1);
-  }
-  for (const [path, count] of commandPathCounts) {
-    if (count > 1) {
-      findings.push({
-        code: "duplicate_command",
-        severity: "warning",
-        message: `Command "${path}" is declared ${count} times in commands; the later registration shadows the earlier one at dispatch.`,
-        command: path
-      });
-    }
-  }
-  const overridePaths = new Set(Object.keys(blueprint.commandOverrides ?? {}).map((command) => normalizeCommandName(command)));
-  for (const path of commandPathCounts.keys()) {
-    if (overridePaths.has(path)) {
-      findings.push({
-        code: "command_override_conflict",
-        severity: "warning",
-        message: `Command "${path}" is declared both as a new command definition and as a command override; register one or the other.`,
-        command: path
-      });
-    }
-  }
-  return findings;
-}
-function collectBlueprintEmptySurfaceFindings(blueprint) {
-  const findings = [];
-  for (const field of BLUEPRINT_LINTABLE_SURFACE_FIELDS) {
-    if (field in blueprint && !hasEntries(blueprint[field])) {
-      findings.push({
-        code: "empty_surface",
-        severity: "warning",
-        message: `Blueprint field "${field}" is present but empty; remove it or populate it.`,
-        field
-      });
-    }
-  }
-  if ("hooks" in blueprint) {
-    const hooks = blueprint.hooks ?? {};
-    const registersHook = [hooks.beforeCommand, hooks.afterCommand, hooks.onWrite, hooks.onRead, hooks.onIndex].some(hasEntries);
-    if (!registersHook) {
-      findings.push({
-        code: "empty_surface",
-        severity: "warning",
-        message: `Blueprint field "hooks" is present but registers no lifecycle hooks; remove it or populate it.`,
-        field: "hooks"
-      });
-    }
-  }
-  return findings;
-}
-function lintExtensionBlueprint(blueprint, options = {}) {
-  const used = deriveExtensionCapabilities(blueprint);
-  const declaredSource = options.declaredCapabilities ?? blueprint.manifest?.capabilities;
-  const declared = Array.isArray(declaredSource) ? normalizeDeclaredCapabilities(declaredSource) : null;
-  const findings = [
-    ...collectBlueprintCapabilityFindings(used, declared),
-    ...collectBlueprintCommandFindings(blueprint),
-    ...collectBlueprintEmptySurfaceFindings(blueprint)
-  ];
-  return {
-    ok: findings.every((finding) => finding.severity !== "error"),
-    findings,
-    used,
-    declared
-  };
-}
-function synthesizeExtensionManifest(blueprint, identity) {
-  const { additionalCapabilities, ...manifestIdentity } = identity;
-  const extra = Array.isArray(additionalCapabilities) ? normalizeDeclaredCapabilities(additionalCapabilities) : [];
-  const capabilities = [.../* @__PURE__ */ new Set([...deriveExtensionCapabilities(blueprint), ...extra])].sort((left, right) => left.localeCompare(right));
-  return { ...manifestIdentity, capabilities };
-}
-function composeExtensionPackage(blueprint, identity) {
-  const manifest = synthesizeExtensionManifest(blueprint, identity);
-  const module = composeExtension({ ...blueprint, manifest });
-  return { module, manifest };
-}
-function toCompatibilityFinding(evaluation, pmVersion) {
-  if (evaluation.status === "absent" || evaluation.status === "ok") {
-    return null;
-  }
-  const code = `${evaluation.kind}_${evaluation.status}`;
-  let message;
-  switch (code) {
-    case "pm_min_version_invalid":
-      message = `pm_min_version "${evaluation.required}" is not a valid version; the extension is treated as incompatible and the loader skips it.`;
-      break;
-    case "pm_min_version_unchecked":
-      message = `pm_min_version "${evaluation.required}" could not be compared against pm ${pmVersion}; compatibility is unverified.`;
-      break;
-    case "pm_min_version_unmet":
-      message = `Requires pm >= ${evaluation.required} but the target is pm ${pmVersion}; the loader skips the extension.`;
-      break;
-    case "pm_max_version_invalid":
-      message = `pm_max_version "${evaluation.required}" is not a valid inclusive upper bound (version ranges are not allowed); the extension is treated as incompatible and the loader skips it.`;
-      break;
-    case "pm_max_version_unchecked":
-      message = `pm_max_version "${evaluation.required}" could not be compared against pm ${pmVersion}; compatibility is unverified.`;
-      break;
-    case "pm_max_version_exceeded":
-      message = `Allows pm <= ${evaluation.required} but the target is pm ${pmVersion}; the loader skips the extension.`;
-      break;
-    case "pm_max_version_exceeded_warn":
-      message = `Target pm ${pmVersion} is newer than pm_max_version ${evaluation.required}, but the "warn" exceeded mode lets it load with a warning.`;
-      break;
-  }
-  return {
-    code,
-    severity: evaluation.allowed ? "warning" : "error",
-    constraint: evaluation.kind,
-    required: evaluation.required,
-    current: pmVersion,
-    message
-  };
-}
-function checkExtensionManifestCompatibility(manifest, target) {
-  const minEvaluation = evaluatePmMinVersionBound(manifest.pm_min_version, target.pmVersion);
-  const maxEvaluation = evaluatePmMaxVersionBound(manifest.pm_max_version, target.pmVersion, target.pmMaxVersionExceededMode ?? "block");
-  const findings = [];
-  const minFinding = toCompatibilityFinding(minEvaluation, target.pmVersion);
-  if (minFinding !== null) {
-    findings.push(minFinding);
-  }
-  const maxFinding = toCompatibilityFinding(maxEvaluation, target.pmVersion);
-  if (maxFinding !== null) {
-    findings.push(maxFinding);
-  }
-  return {
-    compatible: minEvaluation.allowed && maxEvaluation.allowed,
-    findings,
-    pmVersion: target.pmVersion
-  };
-}
-var CAPABILITY_DRIFT_LINT_CODES = /* @__PURE__ */ new Set([
-  "capability_undeclared",
-  "capability_unused",
-  "manifest_capabilities_absent"
-]);
-function preflightExtension(blueprint, options = {}) {
-  const blueprintResult = lintExtensionBlueprint(blueprint, { declaredCapabilities: options.declaredCapabilities });
-  const manifest = options.identity ? synthesizeExtensionManifest(blueprint, options.identity) : null;
-  const compatibility = options.target ? checkExtensionManifestCompatibility(manifest ?? blueprint.manifest ?? {}, options.target) : null;
-  const suppressCapabilityDrift = manifest !== null && options.declaredCapabilities === void 0;
-  const blueprintFindings = suppressCapabilityDrift ? blueprintResult.findings.filter((finding) => !CAPABILITY_DRIFT_LINT_CODES.has(finding.code)) : blueprintResult.findings;
-  const findings = [
-    ...blueprintFindings.map((finding) => ({
-      source: "blueprint",
-      severity: finding.severity,
-      code: finding.code,
-      message: finding.message
-    })),
-    ...(compatibility?.findings ?? []).map((finding) => ({
-      source: "compatibility",
-      severity: finding.severity,
-      code: finding.code,
-      message: finding.message
-    }))
-  ];
-  return {
-    ok: findings.every((finding) => finding.severity !== "error"),
-    capabilities: blueprintResult.used,
-    blueprint: blueprintResult,
-    manifest,
-    compatibility,
-    findings
-  };
-}
-
-// dist/sdk/testing.js
-!(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] = "fd785549-a72d-5b9c-8e0a-26513960d8dc");
-  } catch (e2) {
-  }
-})();
-var 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 = /* @__PURE__ */ 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)}`);
-  }
-  return runCommandHandler(commands, {
-    command,
-    args: options.args ? [...options.args] : [],
-    options: options.options ? { ...options.options } : {},
-    global: { json: true, quiet: true, noPager: true, ...options.global },
-    pm_root: options.pmRoot ?? ""
-  });
-}
-async function runRegisteredHookForTest(hooks, options) {
-  if (hooks[HOOK_KIND_TO_REGISTRY_FIELD[options.kind]].length === 0) {
-    const populatedKinds = sortedUnique(Object.keys(HOOK_KIND_TO_REGISTRY_FIELD).filter((kind) => hooks[HOOK_KIND_TO_REGISTRY_FIELD[kind]].length > 0));
-    throw new Error(`Expected a registered "${options.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);
-}
-var 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 = /* @__PURE__ */ 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);
-    },
-    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 {
-  defineExtension,
-  defineExtensionBlueprint,
-  composeExtension,
-  mergeExtensionBlueprints,
-  deriveExtensionCapabilities,
-  describeExtensionBlueprint,
-  lintExtensionBlueprint,
-  synthesizeExtensionManifest,
-  composeExtensionPackage,
-  checkExtensionManifestCompatibility,
-  preflightExtension,
-  activateExtensionForTest,
-  deactivateExtensionForTest,
-  runRegisteredCommandForTest,
-  runRegisteredHookForTest,
-  runRegisteredParserOverrideForTest,
-  runRegisteredPreflightOverrideForTest,
-  runRegisteredCommandOverrideForTest,
-  runRegisteredRendererOverrideForTest,
-  runRegisteredServiceOverrideForTest,
-  runRegisteredSearchProviderForTest,
-  runRegisteredVectorStoreAdapterForTest,
-  runRegisteredMigrationForTest,
-  runRegisteredImporterForTest,
-  runRegisteredExporterForTest,
-  assertExtensionDeactivated,
-  assertPackageManifest,
-  assertRegisteredCommandContract,
-  assertRegisteredFlags,
-  assertRegisteredHook,
-  assertRegisteredSearchProvider,
-  assertRegisteredVectorStoreAdapter,
-  assertRegisteredImporter,
-  assertRegisteredExporter,
-  assertRegisteredItemField,
-  assertRegisteredItemType,
-  assertRegisteredProfile,
-  assertRegisteredCommandOverride,
-  assertRegisteredParserOverride,
-  assertRegisteredPreflightOverride,
-  assertRegisteredRendererOverride,
-  assertRegisteredServiceOverride,
-  assertRegisteredMigration,
-  assertExtensionCapabilityUsage,
-  assertExtensionBlueprint,
-  assertProjectProfile,
-  assertExtensionManifestMatchesBlueprint,
-  assertExtensionManifestCompatible,
-  assertExtensionPreflight,
-  createExtensionTestHarness
-};
-//# sourceMappingURL=chunk-P5TFTLWW.js.map