@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/core/extensions/loader.js

@@ -4,7 +4,7 @@
  * Implements extension runtime contracts and governance for Loader.
  */
 
-!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]="07458218-1762-56b2-932e-adfacc4fa916")}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]="b7735a57-30b2-58a3-9d53-6805e011fd12")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -448,6 +448,9 @@ async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMa
     }
     return { diagnostics, warnings, candidates };
 }
+function emptyExtensionLayerScan() {
+    return { diagnostics: [], warnings: [], candidates: [] };
+}
 /**
  * Build the `warn`-status scan result for a directory whose manifest is missing
  * or unparseable, carrying the supplied diagnostic warning and no candidate.
@@ -579,7 +582,9 @@ export 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);
@@ -1390,8 +1395,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,
@@ -1400,7 +1405,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,
@@ -1417,65 +1424,114 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
             }
             : undefined,
     };
-    const pushPolicyWarning = (warning) => {
-        if (warning) {
-            activationWarnings.push(warning);
+}
+class ExtensionApiRegistrar {
+    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 : undefined;
         const legacyHandler = typeof definition.handler === "function" ? definition.handler : undefined;
         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", undefined, "{ name: string; run: (context) => unknown; }", definition, "Use registerCommand({ name: \"command path\", run: (context) => ... })."));
+            throw createRegistrationValidationError("registerCommand requires a command definition object", this.registerCommandTrace("definition", undefined, "{ 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", undefined, "{ 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", undefined, "{ 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 {
@@ -1483,7 +1539,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();
@@ -1492,19 +1548,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 !== undefined) {
-                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,
@@ -1517,74 +1575,74 @@ 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") {
@@ -1594,16 +1652,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));
@@ -1612,16 +1670,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);
@@ -1629,15 +1687,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);
@@ -1645,28 +1703,28 @@ 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;
         }
         // Snapshot first, then validate and default the snapshot: cloning resolves
@@ -1676,13 +1734,13 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         // only after validation, so an invalid type is rejected, not silently coerced.
         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 === undefined) {
             return;
         }
@@ -1697,23 +1755,23 @@ 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 !== undefined) {
-            assertExtensionCapability(extension, "schema", `${method} options.flags`);
+            assertExtensionCapability(this.#loadedExtension, "schema", `${method} options.flags`);
             // Route metadata flags through the same surface-policy gate as registerFlags so
             // enforce-mode policies blocking schema.flags are honored even when importers are allowed.
-            if (allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
+            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,
@@ -1728,11 +1786,11 @@ 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));
@@ -1740,15 +1798,15 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         const commandPath = toRegistrationCommandPath(normalizedName, "import");
         // Validate and register optional command metadata before mutating the registry
         // so an invalid options object leaves no partial importer registration.
-        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,
@@ -1760,10 +1818,10 @@ 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));
@@ -1771,15 +1829,15 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         const commandPath = toRegistrationCommandPath(normalizedName, "export");
         // Validate and register optional command metadata before mutating the registry
         // so an invalid options object leaves no partial exporter registration.
-        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,
@@ -1791,115 +1849,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;
@@ -2133,4 +2170,4 @@ export const _testOnlyLoader = {
     },
 };
 //# sourceMappingURL=loader.js.map
-//# debugId=07458218-1762-56b2-932e-adfacc4fa916
+//# debugId=b7735a57-30b2-58a3-9d53-6805e011fd12