@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli-bundle/chunks/{chunk-57NWPFF2.js → chunk-MFLLULHU.js}

@@ -1,6 +1,6 @@
 // dist/core/fs/fs-utils.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]="8d328154-8bfe-548c-a5f0-21073bde97b1")}catch(e){}}();
+!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]="e9729333-6db5-59ee-8259-e1cba10d635f")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -3277,6 +3277,9 @@ async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMa
   }
   return { diagnostics, warnings, candidates };
 }
+function emptyExtensionLayerScan() {
+  return { diagnostics: [], warnings: [], candidates: [] };
+}
 function buildUnavailableExtensionScan(layer, directory, manifestPath, warning) {
   return {
     diagnostic: {
@@ -3386,7 +3389,7 @@ async function discoverExtensions(options) {
   }
   const enabled = new Set(configured_enabled);
   const disabled = new Set(configured_disabled);
-  const globalScan = await scanExtensionLayer("global", roots.global, enabled, disabled, policy.pmMaxVersionExceededMode.global);
+  const globalScan = options.ignoreGlobalExtensions === true ? emptyExtensionLayerScan() : await scanExtensionLayer("global", roots.global, enabled, disabled, policy.pmMaxVersionExceededMode.global);
   const projectScan = await scanExtensionLayer("project", roots.project, enabled, disabled, policy.pmMaxVersionExceededMode.project);
   const policyWarnings = [...policy.warnings];
   const effectiveCandidates = buildEffectiveExtensions(globalScan.candidates, projectScan.candidates);
@@ -4109,8 +4112,8 @@ function assertExtensionCapability(extension, capability, method) {
     });
   }
 }
-function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
-  const selfIdentity = Object.freeze({
+function buildExtensionSelfIdentity(extension) {
+  return Object.freeze({
     name: extension.name,
     layer: extension.layer,
     version: extension.version,
@@ -4119,7 +4122,9 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     pm_max_version: extension.pm_max_version,
     source_package: extension.source_package
   });
-  const extensionRef = {
+}
+function buildPolicyExtensionRef(extension) {
+  return {
     layer: extension.layer,
     name: extension.name,
     trusted: extension.trusted === true,
@@ -4134,65 +4139,114 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       process_spawn: extension.permissions.process_spawn
     } : void 0
   };
-  const pushPolicyWarning = (warning) => {
-    if (warning) {
-      activationWarnings.push(warning);
+}
+var ExtensionApiRegistrar = class {
+  extension;
+  hooks;
+  #loadedExtension;
+  #extensionRef;
+  #hookRegistry;
+  #commandRegistry;
+  #parserRegistry;
+  #preflightRegistry;
+  #serviceRegistry;
+  #rendererRegistry;
+  #registrationRegistry;
+  #activationWarnings;
+  #policy;
+  constructor(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
+    this.#loadedExtension = extension;
+    this.extension = buildExtensionSelfIdentity(extension);
+    this.#extensionRef = buildPolicyExtensionRef(extension);
+    this.#hookRegistry = hooks;
+    this.#commandRegistry = commands;
+    this.#parserRegistry = parsers;
+    this.#preflightRegistry = preflight;
+    this.#serviceRegistry = services;
+    this.#rendererRegistry = renderers;
+    this.#registrationRegistry = registrations;
+    this.#activationWarnings = activationWarnings;
+    this.#policy = policy;
+    this.registerCommand = this.registerCommand.bind(this);
+    this.registerParser = this.registerParser.bind(this);
+    this.registerPreflight = this.registerPreflight.bind(this);
+    this.registerService = this.registerService.bind(this);
+    this.registerFlags = this.registerFlags.bind(this);
+    this.registerItemFields = this.registerItemFields.bind(this);
+    this.registerItemTypes = this.registerItemTypes.bind(this);
+    this.registerMigration = this.registerMigration.bind(this);
+    this.registerProfile = this.registerProfile.bind(this);
+    this.registerRenderer = this.registerRenderer.bind(this);
+    this.registerImporter = this.registerImporter.bind(this);
+    this.registerExporter = this.registerExporter.bind(this);
+    this.registerSearchProvider = this.registerSearchProvider.bind(this);
+    this.registerVectorStoreAdapter = this.registerVectorStoreAdapter.bind(this);
+    this.hooks = {
+      beforeCommand: (hook) => this.registerBeforeCommand(hook),
+      afterCommand: (hook) => this.registerAfterCommand(hook),
+      onWrite: (hook) => this.registerOnWrite(hook),
+      onRead: (hook) => this.registerOnRead(hook),
+      onIndex: (hook) => this.registerOnIndex(hook)
+    };
+  }
+  allowRegistration(surface, method, capability, details) {
+    const decision = evaluateExtensionPolicyForRegistration(this.#policy, this.#extensionRef, surface, method, capability, details);
+    if (decision.warning) {
+      this.#activationWarnings.push(decision.warning);
     }
-  };
-  const allowRegistration = (surface, method, capability, details) => {
-    const decision = evaluateExtensionPolicyForRegistration(policy, extensionRef, surface, method, capability, details);
-    pushPolicyWarning(decision.warning);
     return decision.allowed;
-  };
-  const registerCommandTrace = (mode, command, expectedSchema, received, hint) => ({
-    method: "registerCommand",
-    registration_index: mode === "override" ? commands.overrides.length : commands.handlers.length,
-    command,
-    expected_schema: expectedSchema,
-    received: sanitizeRegistrationValue(received),
-    hint
-  });
-  const registerCommandOverride = (command, override) => {
+  }
+  registerCommandTrace(mode, command, expectedSchema, received, hint) {
+    return {
+      method: "registerCommand",
+      registration_index: mode === "override" ? this.#commandRegistry.overrides.length : this.#commandRegistry.handlers.length,
+      command,
+      expected_schema: expectedSchema,
+      received: sanitizeRegistrationValue(received),
+      hint
+    };
+  }
+  registerCommandOverride(command, override) {
     const normalizedCommand = normalizeCommandName(command);
     if (normalizedCommand.length === 0) {
-      throw createRegistrationValidationError("registerCommand requires a non-empty command name", registerCommandTrace("override", command, 'registerCommand("<command>", (context) => unknown)', command, "Provide a non-empty command path as the first argument."));
+      throw createRegistrationValidationError("registerCommand requires a non-empty command name", this.registerCommandTrace("override", command, 'registerCommand("<command>", (context) => unknown)', command, "Provide a non-empty command path as the first argument."));
     }
     if (typeof override !== "function") {
-      const trace = registerCommandTrace("override", normalizedCommand, 'registerCommand("<command>", (context) => unknown)', { command, override }, "Provide a function as the second registerCommand argument.");
+      const trace = this.registerCommandTrace("override", normalizedCommand, 'registerCommand("<command>", (context) => unknown)', override, "Provide a function as the second registerCommand argument.");
       throw createRegistrationValidationError(`registerCommand requires an override function when command name is provided (command="${normalizedCommand}", registration_index=${trace.registration_index})`, trace);
     }
-    if (!allowRegistration("commands.override", "registerCommand", "commands", { command: normalizedCommand })) {
+    if (!this.allowRegistration("commands.override", "registerCommand", "commands", { command: normalizedCommand })) {
       return;
     }
-    commands.overrides.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#commandRegistry.overrides.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       command: normalizedCommand,
       run: override
     });
-  };
-  const resolveCommandDefinitionRunHandler = (definition, normalizedCommand) => {
+  }
+  resolveCommandDefinitionRunHandler(definition, normalizedCommand) {
     const runHandler = typeof definition.run === "function" ? definition.run : void 0;
     const legacyHandler = typeof definition.handler === "function" ? definition.handler : void 0;
     if (!runHandler && legacyHandler) {
-      activationWarnings.push(`extension_command_definition_legacy_handler_alias:${extension.layer}:${extension.name}:${normalizedCommand}`);
+      this.#activationWarnings.push(`extension_command_definition_legacy_handler_alias:${this.#loadedExtension.layer}:${this.#loadedExtension.name}:${normalizedCommand}`);
     }
     return runHandler ?? legacyHandler;
-  };
-  const registerCommandDefinition = (definition) => {
+  }
+  registerCommandDefinition(definition) {
     if (typeof definition !== "object" || definition === null) {
-      throw createRegistrationValidationError("registerCommand requires a command definition object", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, 'Use registerCommand({ name: "command path", run: (context) => ... }).'));
+      throw createRegistrationValidationError("registerCommand requires a command definition object", this.registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, 'Use registerCommand({ name: "command path", run: (context) => ... }).'));
     }
     if (typeof definition.name !== "string") {
-      throw createRegistrationValidationError("registerCommand requires a command definition name", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, "Set command definition.name to a non-empty string command path."));
+      throw createRegistrationValidationError("registerCommand requires a command definition name", this.registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, "Set command definition.name to a non-empty string command path."));
     }
     const normalizedCommand = normalizeCommandName(definition.name);
     if (normalizedCommand.length === 0) {
-      throw createRegistrationValidationError("registerCommand requires a non-empty command definition name", registerCommandTrace("definition", definition.name, "{ name: string; run: (context) => unknown; }", definition, "Ensure command definition.name contains a non-empty command path."));
+      throw createRegistrationValidationError("registerCommand requires a non-empty command definition name", this.registerCommandTrace("definition", definition.name, "{ name: string; run: (context) => unknown; }", definition, "Ensure command definition.name contains a non-empty command path."));
     }
-    const resolvedHandler = resolveCommandDefinitionRunHandler(definition, normalizedCommand);
+    const resolvedHandler = this.resolveCommandDefinitionRunHandler(definition, normalizedCommand);
     if (typeof resolvedHandler !== "function") {
-      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; }", definition, "Define command definition.run as a function.");
+      const trace = this.registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; }", resolvedHandler, "Define command definition.run as a function.");
       throw createRegistrationValidationError(`registerCommand requires a command definition run handler (command="${normalizedCommand}", registration_index=${trace.registration_index})`, trace);
     }
     try {
@@ -4200,7 +4254,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       assertOptionalStringField("registerCommand definition.description", definition.description);
       assertOptionalStringField("registerCommand definition.intent", definition.intent);
       const action = resolveCommandDefinitionAction(normalizedCommand, definition.action);
-      if (!allowRegistration("commands.handler", "registerCommand", "commands", { command: normalizedCommand, action })) {
+      if (!this.allowRegistration("commands.handler", "registerCommand", "commands", { command: normalizedCommand, action })) {
         return;
       }
       const description = definition.description?.trim();
@@ -4209,19 +4263,21 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       const failureHints = normalizeOptionalStringArrayField("registerCommand definition.failure_hints", definition.failure_hints);
       const argumentsDefinition = normalizeCommandDefinitionArguments(definition.arguments);
       if (definition.flags !== void 0) {
-        assertExtensionCapability(extension, "schema", "registerCommand flags");
-        validateFlagDefinitions(definition.flags);
-        registrations.flags.push({
-          layer: extension.layer,
-          name: extension.name,
-          target_command: normalizedCommand,
-          flags: normalizeRegistrationRecordList("registerCommand definition.flags", definition.flags)
-        });
+        assertExtensionCapability(this.#loadedExtension, "schema", "registerCommand flags");
+        if (this.allowRegistration("schema.flags", "registerCommand flags", "schema")) {
+          validateFlagDefinitions(definition.flags);
+          this.#registrationRegistry.flags.push({
+            layer: this.#loadedExtension.layer,
+            name: this.#loadedExtension.name,
+            target_command: normalizedCommand,
+            flags: normalizeRegistrationRecordList("registerCommand definition.flags", definition.flags)
+          });
+        }
       }
       const registration = {
-        layer: extension.layer,
-        name: extension.name,
-        source_package: extension.source_package,
+        layer: this.#loadedExtension.layer,
+        name: this.#loadedExtension.name,
+        source_package: this.#loadedExtension.source_package,
         command: normalizedCommand,
         action,
         examples,
@@ -4234,73 +4290,73 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       if (intent) {
         registration.intent = intent;
       }
-      registrations.commands.push(registration);
+      this.#registrationRegistry.commands.push(registration);
     } catch (error) {
       const reason = formatUnknownError(error);
-      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }", definition, "Use schema-style metadata (action/arguments/flags/examples/intent) with valid values.");
+      const trace = this.registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }", definition, reason);
       throw createRegistrationValidationError(`registerCommand definition metadata invalid (command="${normalizedCommand}", registration_index=${trace.registration_index}): ${reason}`, trace);
     }
-    commands.handlers.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#commandRegistry.handlers.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       command: normalizedCommand,
       run: resolvedHandler
     });
-  };
-  const registerCommand = (commandOrDefinition, override) => {
-    assertExtensionCapability(extension, "commands", "registerCommand");
+  }
+  registerCommand(commandOrDefinition, override) {
+    assertExtensionCapability(this.#loadedExtension, "commands", "registerCommand");
     if (typeof commandOrDefinition === "string") {
-      registerCommandOverride(commandOrDefinition, override);
+      this.registerCommandOverride(commandOrDefinition, override);
       return;
     }
-    registerCommandDefinition(commandOrDefinition);
-  };
-  const registerParser = (command, override) => {
-    assertExtensionCapability(extension, "parser", "registerParser");
-    if (!allowRegistration("parser.override", "registerParser", "parser")) {
+    this.registerCommandDefinition(commandOrDefinition);
+  }
+  registerParser(command, override) {
+    assertExtensionCapability(this.#loadedExtension, "parser", "registerParser");
+    if (!this.allowRegistration("parser.override", "registerParser", "parser")) {
       return;
     }
     const normalizedCommand = normalizeCommandName(assertNonEmptyString("registerParser command", command));
     assertFunctionHandler("registerParser override", override);
-    parsers.overrides.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#parserRegistry.overrides.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       command: normalizedCommand,
       run: override
     });
-  };
-  const registerPreflight = (override) => {
-    assertExtensionCapability(extension, "preflight", "registerPreflight");
-    if (!allowRegistration("preflight.override", "registerPreflight", "preflight")) {
+  }
+  registerPreflight(override) {
+    assertExtensionCapability(this.#loadedExtension, "preflight", "registerPreflight");
+    if (!this.allowRegistration("preflight.override", "registerPreflight", "preflight")) {
       return;
     }
     assertFunctionHandler("registerPreflight override", override);
-    preflight.overrides.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#preflightRegistry.overrides.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: override
     });
-  };
-  const registerService = (service, override) => {
-    assertExtensionCapability(extension, "services", "registerService");
+  }
+  registerService(service, override) {
+    assertExtensionCapability(this.#loadedExtension, "services", "registerService");
     const normalizedService = String(service).trim().toLowerCase();
     if (!isExtensionServiceName(normalizedService)) {
       throw new TypeError(`registerService service must be one of: ${KNOWN_EXTENSION_SERVICE_NAMES.join(", ")}`);
     }
-    if (!allowRegistration("services.override", "registerService", "services", { service: normalizedService })) {
+    if (!this.allowRegistration("services.override", "registerService", "services", { service: normalizedService })) {
       return;
     }
     assertFunctionHandler("registerService override", override);
-    services.overrides.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#serviceRegistry.overrides.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       service: normalizedService,
       run: override
     });
-  };
-  const registerRenderer = (format, renderer) => {
-    assertExtensionCapability(extension, "renderers", "registerRenderer");
-    if (!allowRegistration("renderers.override", "registerRenderer", "renderers")) {
+  }
+  registerRenderer(format, renderer) {
+    assertExtensionCapability(this.#loadedExtension, "renderers", "registerRenderer");
+    if (!this.allowRegistration("renderers.override", "registerRenderer", "renderers")) {
       return;
     }
     if (typeof renderer !== "function") {
@@ -4310,16 +4366,16 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     if (!isOutputRendererFormat(normalizedFormat)) {
       throw new Error(`registerRenderer format must be toon|json, received: ${String(format)}`);
     }
-    renderers.overrides.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#rendererRegistry.overrides.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       format: normalizedFormat,
       run: renderer
     });
-  };
-  const registerFlags = (targetCommand, flags) => {
-    assertExtensionCapability(extension, "schema", "registerFlags");
-    if (!allowRegistration("schema.flags", "registerFlags", "schema")) {
+  }
+  registerFlags(targetCommand, flags) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerFlags");
+    if (!this.allowRegistration("schema.flags", "registerFlags", "schema")) {
       return;
     }
     const normalizedTargetCommand = normalizeCommandName(assertNonEmptyString("registerFlags targetCommand", targetCommand));
@@ -4328,16 +4384,16 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     if (normalizedFlags.length === 0) {
       throw new TypeError("registerFlags requires at least one flag definition");
     }
-    registrations.flags.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.flags.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       target_command: normalizedTargetCommand,
       flags: normalizedFlags
     });
-  };
-  const registerItemFields = (fields) => {
-    assertExtensionCapability(extension, "schema", "registerItemFields");
-    if (!allowRegistration("schema.itemfields", "registerItemFields", "schema")) {
+  }
+  registerItemFields(fields) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerItemFields");
+    if (!this.allowRegistration("schema.itemfields", "registerItemFields", "schema")) {
       return;
     }
     validateItemFieldDefinitions(fields);
@@ -4345,15 +4401,15 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     if (normalizedFields.length === 0) {
       throw new TypeError("registerItemFields requires at least one field definition");
     }
-    registrations.item_fields.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.item_fields.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       fields: normalizedFields
     });
-  };
-  const registerItemTypes = (types) => {
-    assertExtensionCapability(extension, "schema", "registerItemTypes");
-    if (!allowRegistration("schema.itemtypes", "registerItemTypes", "schema")) {
+  }
+  registerItemTypes(types) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerItemTypes");
+    if (!this.allowRegistration("schema.itemtypes", "registerItemTypes", "schema")) {
       return;
     }
     validateItemTypeDefinitions(types);
@@ -4361,39 +4417,39 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     if (normalizedTypes.length === 0) {
       throw new TypeError("registerItemTypes requires at least one type definition");
     }
-    registrations.item_types.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.item_types.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       types: normalizedTypes
     });
-  };
-  const registerMigration = (definition) => {
-    assertExtensionCapability(extension, "schema", "registerMigration");
-    if (!allowRegistration("schema.migrations", "registerMigration", "schema")) {
+  }
+  registerMigration(definition) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerMigration");
+    if (!this.allowRegistration("schema.migrations", "registerMigration", "schema")) {
       return;
     }
     validateMigrationDefinition(definition);
     const runtimeDefinition = normalizeRuntimeRegistrationRecord("registerMigration definition", definition);
-    registrations.migrations.push(attachRuntimeDefinition({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.migrations.push(attachRuntimeDefinition({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       definition: normalizeRegistrationRecord("registerMigration definition", definition)
     }, runtimeDefinition));
-  };
-  const registerProfile = (profile) => {
-    assertExtensionCapability(extension, "schema", "registerProfile");
-    if (!allowRegistration("schema.profiles", "registerProfile", "schema")) {
+  }
+  registerProfile(profile) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerProfile");
+    if (!this.allowRegistration("schema.profiles", "registerProfile", "schema")) {
       return;
     }
     const snapshot = cloneRuntimeRegistrationValue(profile);
     validateProjectProfileDefinition(snapshot);
-    registrations.profiles.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.profiles.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       profile: applyProjectProfileDefaults(snapshot)
     });
-  };
-  const applyImportExportCommandMetadata = (method, commandPath, options) => {
+  }
+  applyImportExportCommandMetadata(method, commandPath, options) {
     if (options === void 0) {
       return;
     }
@@ -4408,21 +4464,21 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     const failureHints = normalizeOptionalStringArrayField(`${method} options.failure_hints`, options.failure_hints);
     const argumentsDefinition = normalizeCommandDefinitionArguments(options.arguments);
     if (options.flags !== void 0) {
-      assertExtensionCapability(extension, "schema", `${method} options.flags`);
-      if (allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
+      assertExtensionCapability(this.#loadedExtension, "schema", `${method} options.flags`);
+      if (this.allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
         validateFlagDefinitions(options.flags);
-        registrations.flags.push({
-          layer: extension.layer,
-          name: extension.name,
+        this.#registrationRegistry.flags.push({
+          layer: this.#loadedExtension.layer,
+          name: this.#loadedExtension.name,
           target_command: commandPath,
           flags: normalizeRegistrationRecordList(`${method} options.flags`, options.flags)
         });
       }
     }
     const registration = {
-      layer: extension.layer,
-      name: extension.name,
-      source_package: extension.source_package,
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
+      source_package: this.#loadedExtension.source_package,
       command: commandPath,
       action,
       examples,
@@ -4437,25 +4493,25 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     if (intent) {
       registration.intent = intent;
     }
-    registrations.commands.push(registration);
-  };
-  const registerImporter = (name, importer, options) => {
-    assertExtensionCapability(extension, "importers", "registerImporter");
-    if (!allowRegistration("importers.importer", "registerImporter", "importers")) {
+    this.#registrationRegistry.commands.push(registration);
+  }
+  registerImporter(name, importer, options) {
+    assertExtensionCapability(this.#loadedExtension, "importers", "registerImporter");
+    if (!this.allowRegistration("importers.importer", "registerImporter", "importers")) {
       return;
     }
     const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerImporter name", name));
     assertFunctionHandler("registerImporter importer", importer);
     const commandPath = toRegistrationCommandPath(normalizedName, "import");
-    applyImportExportCommandMetadata("registerImporter", commandPath, options);
-    registrations.importers.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.applyImportExportCommandMetadata("registerImporter", commandPath, options);
+    this.#registrationRegistry.importers.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       importer: normalizedName
     });
-    commands.handlers.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#commandRegistry.handlers.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       command: commandPath,
       run: async (context) => importer({
         registration: normalizedName,
@@ -4467,24 +4523,24 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         pm_root: context.pm_root
       })
     });
-  };
-  const registerExporter = (name, exporter, options) => {
-    assertExtensionCapability(extension, "importers", "registerExporter");
-    if (!allowRegistration("importers.exporter", "registerExporter", "importers")) {
+  }
+  registerExporter(name, exporter, options) {
+    assertExtensionCapability(this.#loadedExtension, "importers", "registerExporter");
+    if (!this.allowRegistration("importers.exporter", "registerExporter", "importers")) {
       return;
     }
     const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerExporter name", name));
     assertFunctionHandler("registerExporter exporter", exporter);
     const commandPath = toRegistrationCommandPath(normalizedName, "export");
-    applyImportExportCommandMetadata("registerExporter", commandPath, options);
-    registrations.exporters.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.applyImportExportCommandMetadata("registerExporter", commandPath, options);
+    this.#registrationRegistry.exporters.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       exporter: normalizedName
     });
-    commands.handlers.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#commandRegistry.handlers.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       command: commandPath,
       run: async (context) => exporter({
         registration: normalizedName,
@@ -4496,115 +4552,94 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         pm_root: context.pm_root
       })
     });
-  };
-  const registerSearchProvider = (provider) => {
-    assertExtensionCapability(extension, "search", "registerSearchProvider");
-    if (!allowRegistration("search.provider", "registerSearchProvider", "search")) {
+  }
+  registerSearchProvider(provider) {
+    assertExtensionCapability(this.#loadedExtension, "search", "registerSearchProvider");
+    if (!this.allowRegistration("search.provider", "registerSearchProvider", "search")) {
       return;
     }
     const runtimeDefinition = normalizeRuntimeRegistrationRecord("registerSearchProvider provider", provider);
-    registrations.search_providers.push(attachRuntimeDefinition({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.search_providers.push(attachRuntimeDefinition({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       definition: normalizeRegistrationRecord("registerSearchProvider provider", provider)
     }, runtimeDefinition));
-  };
-  const registerVectorStoreAdapter = (adapter) => {
-    assertExtensionCapability(extension, "search", "registerVectorStoreAdapter");
-    if (!allowRegistration("search.vectorstore", "registerVectorStoreAdapter", "search")) {
+  }
+  registerVectorStoreAdapter(adapter) {
+    assertExtensionCapability(this.#loadedExtension, "search", "registerVectorStoreAdapter");
+    if (!this.allowRegistration("search.vectorstore", "registerVectorStoreAdapter", "search")) {
       return;
     }
     const runtimeDefinition = normalizeRuntimeRegistrationRecord("registerVectorStoreAdapter adapter", adapter);
-    registrations.vector_store_adapters.push(attachRuntimeDefinition({
-      layer: extension.layer,
-      name: extension.name,
+    this.#registrationRegistry.vector_store_adapters.push(attachRuntimeDefinition({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       definition: normalizeRegistrationRecord("registerVectorStoreAdapter adapter", adapter)
     }, runtimeDefinition));
-  };
-  const registerBeforeCommand = (hook) => {
-    assertExtensionCapability(extension, "hooks", "api.hooks.beforeCommand");
-    if (!allowRegistration("hooks.beforecommand", "api.hooks.beforeCommand", "hooks")) {
+  }
+  registerBeforeCommand(hook) {
+    assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.beforeCommand");
+    if (!this.allowRegistration("hooks.beforecommand", "api.hooks.beforeCommand", "hooks")) {
       return;
     }
     assertHookHandler("beforeCommand", hook);
-    hooks.beforeCommand.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#hookRegistry.beforeCommand.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: hook
     });
-  };
-  const registerAfterCommand = (hook) => {
-    assertExtensionCapability(extension, "hooks", "api.hooks.afterCommand");
-    if (!allowRegistration("hooks.aftercommand", "api.hooks.afterCommand", "hooks")) {
+  }
+  registerAfterCommand(hook) {
+    assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.afterCommand");
+    if (!this.allowRegistration("hooks.aftercommand", "api.hooks.afterCommand", "hooks")) {
       return;
     }
     assertHookHandler("afterCommand", hook);
-    hooks.afterCommand.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#hookRegistry.afterCommand.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: hook
     });
-  };
-  const registerOnWrite = (hook) => {
-    assertExtensionCapability(extension, "hooks", "api.hooks.onWrite");
-    if (!allowRegistration("hooks.onwrite", "api.hooks.onWrite", "hooks")) {
+  }
+  registerOnWrite(hook) {
+    assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.onWrite");
+    if (!this.allowRegistration("hooks.onwrite", "api.hooks.onWrite", "hooks")) {
       return;
     }
     assertHookHandler("onWrite", hook);
-    hooks.onWrite.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#hookRegistry.onWrite.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: hook
     });
-  };
-  const registerOnRead = (hook) => {
-    assertExtensionCapability(extension, "hooks", "api.hooks.onRead");
-    if (!allowRegistration("hooks.onread", "api.hooks.onRead", "hooks")) {
+  }
+  registerOnRead(hook) {
+    assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.onRead");
+    if (!this.allowRegistration("hooks.onread", "api.hooks.onRead", "hooks")) {
       return;
     }
     assertHookHandler("onRead", hook);
-    hooks.onRead.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#hookRegistry.onRead.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: hook
     });
-  };
-  const registerOnIndex = (hook) => {
-    assertExtensionCapability(extension, "hooks", "api.hooks.onIndex");
-    if (!allowRegistration("hooks.onindex", "api.hooks.onIndex", "hooks")) {
+  }
+  registerOnIndex(hook) {
+    assertExtensionCapability(this.#loadedExtension, "hooks", "api.hooks.onIndex");
+    if (!this.allowRegistration("hooks.onindex", "api.hooks.onIndex", "hooks")) {
       return;
     }
     assertHookHandler("onIndex", hook);
-    hooks.onIndex.push({
-      layer: extension.layer,
-      name: extension.name,
+    this.#hookRegistry.onIndex.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
       run: hook
     });
-  };
-  return {
-    extension: selfIdentity,
-    registerCommand,
-    registerParser,
-    registerPreflight,
-    registerService,
-    registerFlags,
-    registerItemFields,
-    registerItemTypes,
-    registerMigration,
-    registerProfile,
-    registerRenderer,
-    registerImporter,
-    registerExporter,
-    registerSearchProvider,
-    registerVectorStoreAdapter,
-    hooks: {
-      beforeCommand: registerBeforeCommand,
-      afterCommand: registerAfterCommand,
-      onWrite: registerOnWrite,
-      onRead: registerOnRead,
-      onIndex: registerOnIndex
-    }
-  };
+  }
+};
+function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
+  return new ExtensionApiRegistrar(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy);
 }
 function getRegistrationCounts(registrations) {
   const commandCount = registrations.commands.length;
@@ -5484,6 +5519,18 @@ function statusIsTerminal(status, registry) {
   return registry.terminal_statuses.has(normalized);
 }
 
+// dist/core/shared/memo.js
+function evictOldestMemoEntries(memo) {
+  let remaining = Math.ceil(memo.size / 2);
+  for (const key of memo.keys()) {
+    if (remaining === 0) {
+      return;
+    }
+    memo.delete(key);
+    remaining -= 1;
+  }
+}
+
 export {
   ensureDir,
   pathExists,
@@ -5633,8 +5680,9 @@ export {
   normalizeStatusInputWithRegistry,
   resolveRuntimeFieldRegistry,
   runtimeFieldOptionTarget,
-  statusIsTerminal
+  statusIsTerminal,
+  evictOldestMemoEntries
 };
-//# sourceMappingURL=chunk-57NWPFF2.js.map
+//# sourceMappingURL=chunk-MFLLULHU.js.map
 
-//# debugId=8d328154-8bfe-548c-a5f0-21073bde97b1
+//# debugId=e9729333-6db5-59ee-8259-e1cba10d635f