@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -0,0 +1,1423 @@
+import {
+  lintProjectProfile
+} from "./chunk-24YG75HI.js";
+import {
+  getMigrationRuntimeDefinition,
+  resolveRegisteredSearchProvider,
+  resolveRegisteredVectorStoreAdapter
+} from "./chunk-B5KXLBSJ.js";
+import {
+  describeExtensionActivation,
+  renderExtensionSurfaceMarkdown
+} from "./chunk-EGY6JBQ3.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-LK6XLOGP.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-MWMVPCIE.js.map