@unbrained/pm-cli 2026.5.24 → 2026.5.28

package/dist/core/extensions/loader.js

@@ -1,680 +1,33 @@
 
-!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]="1692aa42-b0fb-5c2d-bb14-f00bad3a8efe")}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]="4fba8687-0797-5479-afc8-12f1a2e5a954")}catch(e){}}();
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { pathExists } from "../fs/fs-utils.js";
 import { isPathWithinDirectory } from "../fs/path-utils.js";
 import { resolveGlobalPmRoot } from "../store/paths.js";
-import { KNOWN_EXTENSION_CAPABILITIES, KNOWN_EXTENSION_POLICY_MODES, KNOWN_EXTENSION_POLICY_SURFACES, KNOWN_EXTENSION_SANDBOX_PROFILES, KNOWN_EXTENSION_TRUST_MODES, EXTENSION_CAPABILITY_CONTRACT_VERSION, EXTENSION_CAPABILITY_LEGACY_ALIASES, } from "./extension-types.js";
+import { asRecordLoose } from "../shared/primitives.js";
+// Cohesive helper groups now live in sibling modules. They are imported for the
+// discovery/activation code that stays here and re-exported below so existing
+// import sites (sdk/index.ts, commands/extension.ts, health.ts, tests, …) keep
+// importing everything from "./loader.js" unchanged.
+import { normalizeNames, isKnownExtensionCapability, collectUnknownExtensionCapabilities, normalizeManifestCapabilities, formatUnknownExtensionCapabilityWarning, formatLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
+import { normalizeExtensionPolicy, serializeExtensionPolicy, hydrateExtensionPolicy, normalizePolicySandboxProfile, evaluateExtensionPolicyForExtension, evaluateExtensionPolicyForCapability, evaluateExtensionPolicyForRegistration, } from "./extension-policy.js";
+import { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
+import { normalizeCommandName, cloneContextSnapshot, } from "./extension-runtime-helpers.js";
+export { parseUnknownExtensionCapabilityWarning, parseLegacyExtensionCapabilityAliasWarning, } from "./extension-capability-aliases.js";
+export { createEmptyExtensionHookRegistry, createEmptyExtensionCommandRegistry, createEmptyExtensionParserRegistry, createEmptyExtensionPreflightRegistry, createEmptyExtensionServiceRegistry, createEmptyExtensionRendererRegistry, createEmptyExtensionRegistrationRegistry, } from "./extension-registries.js";
+export { runBeforeCommandHooks, runAfterCommandHooks, runOnWriteHooks, runOnReadHooks, runOnIndexHooks, runCommandHandler, runParserOverride, runPreflightOverride, runServiceOverrideSync, runServiceOverride, runCommandOverride, runRendererOverride, } from "./extension-hook-runtime.js";
+import { KNOWN_EXTENSION_SERVICE_NAMES, createDefaultExtensionGovernancePolicy, } from "./extension-types.js";
 export * from "./extension-types.js";
 const DEFAULT_EXTENSION_PRIORITY = 100;
 /* Types now in extension-types.ts - re-exported via `export * from "./extension-types.js"` above */
-function normalizeNames(values) {
-    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((a, b) => a.localeCompare(b));
-}
-function isKnownExtensionCapability(value) {
-    return KNOWN_EXTENSION_CAPABILITIES.includes(value);
-}
-function collectUnknownExtensionCapabilities(capabilities) {
-    return capabilities.filter((capability) => !isKnownExtensionCapability(capability));
-}
-const DEFAULT_EXTENSION_POLICY = Object.freeze({
-    mode: "off",
-    trust_mode: "off",
-    require_provenance: false,
-    trusted_extensions: [],
-    default_sandbox_profile: "none",
-    allowed_extensions: [],
-    blocked_extensions: [],
-    allowed_capabilities: [],
-    blocked_capabilities: [],
-    allowed_surfaces: [],
-    blocked_surfaces: [],
-    allowed_commands: [],
-    blocked_commands: [],
-    allowed_actions: [],
-    blocked_actions: [],
-    allowed_services: [],
-    blocked_services: [],
-    extension_overrides: [],
-});
+const DEFAULT_EXTENSION_POLICY = Object.freeze(createDefaultExtensionGovernancePolicy());
 let extensionReloadEpoch = 0;
 export function nextExtensionReloadToken(seed = Date.now()) {
     extensionReloadEpoch += 1;
     return `${extensionReloadEpoch}-${seed}`;
 }
-function normalizePolicyName(value) {
-    if (typeof value !== "string") {
-        return "";
-    }
-    return value.trim().toLowerCase();
-}
-function normalizePolicyStringSet(values) {
-    return new Set((values ?? [])
-        .map((value) => value.trim().toLowerCase())
-        .filter((value) => value.length > 0));
-}
-function normalizePolicySurfaceToken(value) {
-    const normalized = value.trim().toLowerCase();
-    if (normalized.length === 0) {
-        return "";
-    }
-    const segments = normalized
-        .split(/[.:/]/)
-        .map((segment) => segment.replace(/[\s_-]+/g, ""))
-        .filter((segment) => segment.length > 0);
-    if (segments.length === 0) {
-        return "";
-    }
-    if (segments.length === 1) {
-        return segments[0];
-    }
-    return `${segments[0]}.${segments.slice(1).join("")}`;
-}
-function normalizePolicySurfaceSet(values) {
-    return new Set((values ?? [])
-        .map((value) => normalizePolicySurfaceToken(value))
-        .filter((value) => value.length > 0));
-}
-function normalizePolicyMode(value) {
-    const normalized = normalizePolicyName(value);
-    if (KNOWN_EXTENSION_POLICY_MODES.includes(normalized)) {
-        return normalized;
-    }
-    return "off";
-}
-function normalizePolicyTrustMode(value) {
-    const normalized = normalizePolicyName(value);
-    if (KNOWN_EXTENSION_TRUST_MODES.includes(normalized)) {
-        return normalized;
-    }
-    return "off";
-}
-function normalizePolicySandboxProfile(value) {
-    const normalized = normalizePolicyName(value);
-    if (KNOWN_EXTENSION_SANDBOX_PROFILES.includes(normalized)) {
-        return normalized;
-    }
-    return "none";
-}
-function toSortedList(values) {
-    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function normalizeExtensionPolicy(settings) {
-    const policy = settings.extensions.policy;
-    const mode = normalizePolicyMode(policy?.mode);
-    const trustMode = normalizePolicyTrustMode(policy?.trust_mode);
-    const requireProvenance = policy?.require_provenance === true;
-    const trustedExtensions = normalizePolicyStringSet(policy?.trusted_extensions);
-    const defaultSandboxProfile = normalizePolicySandboxProfile(policy?.default_sandbox_profile);
-    const allowedExtensions = normalizePolicyStringSet(policy?.allowed_extensions);
-    const blockedExtensions = normalizePolicyStringSet(policy?.blocked_extensions);
-    const allowedCapabilities = normalizePolicyStringSet(policy?.allowed_capabilities);
-    const blockedCapabilities = normalizePolicyStringSet(policy?.blocked_capabilities);
-    const allowedSurfaces = normalizePolicySurfaceSet(policy?.allowed_surfaces);
-    const blockedSurfaces = normalizePolicySurfaceSet(policy?.blocked_surfaces);
-    const allowedCommands = normalizePolicyStringSet(policy?.allowed_commands);
-    const blockedCommands = normalizePolicyStringSet(policy?.blocked_commands);
-    const allowedActions = normalizePolicyStringSet(policy?.allowed_actions);
-    const blockedActions = normalizePolicyStringSet(policy?.blocked_actions);
-    const allowedServices = normalizePolicyStringSet(policy?.allowed_services);
-    const blockedServices = normalizePolicyStringSet(policy?.blocked_services);
-    const overridesByName = new Map();
-    for (const rawOverride of policy?.extension_overrides ?? []) {
-        const name = normalizePolicyName(rawOverride.name);
-        if (name.length === 0) {
-            continue;
-        }
-        overridesByName.set(name, {
-            name,
-            disabled: rawOverride.disabled === true,
-            requireTrusted: rawOverride.require_trusted === true,
-            requireProvenance: rawOverride.require_provenance === true,
-            sandboxProfile: rawOverride.sandbox_profile !== undefined
-                ? normalizePolicySandboxProfile(rawOverride.sandbox_profile)
-                : undefined,
-            allowedCapabilities: normalizePolicyStringSet(rawOverride.allowed_capabilities),
-            blockedCapabilities: normalizePolicyStringSet(rawOverride.blocked_capabilities),
-            allowedSurfaces: normalizePolicySurfaceSet(rawOverride.allowed_surfaces),
-            blockedSurfaces: normalizePolicySurfaceSet(rawOverride.blocked_surfaces),
-            allowedCommands: normalizePolicyStringSet(rawOverride.allowed_commands),
-            blockedCommands: normalizePolicyStringSet(rawOverride.blocked_commands),
-            allowedActions: normalizePolicyStringSet(rawOverride.allowed_actions),
-            blockedActions: normalizePolicyStringSet(rawOverride.blocked_actions),
-            allowedServices: normalizePolicyStringSet(rawOverride.allowed_services),
-            blockedServices: normalizePolicyStringSet(rawOverride.blocked_services),
-        });
-    }
-    const warnings = [];
-    for (const capability of toSortedList([...allowedCapabilities, ...blockedCapabilities])) {
-        if (!isKnownExtensionCapability(capability)) {
-            warnings.push(`extension_policy_unknown_capability:${capability}`);
-        }
-    }
-    for (const override of [...overridesByName.values()].sort((left, right) => left.name.localeCompare(right.name))) {
-        for (const capability of toSortedList([...override.allowedCapabilities, ...override.blockedCapabilities])) {
-            if (!isKnownExtensionCapability(capability)) {
-                warnings.push(`extension_policy_unknown_capability:${override.name}:${capability}`);
-            }
-        }
-    }
-    const knownSurfaces = new Set(KNOWN_EXTENSION_POLICY_SURFACES);
-    for (const surface of toSortedList([...allowedSurfaces, ...blockedSurfaces])) {
-        if (!knownSurfaces.has(surface)) {
-            warnings.push(`extension_policy_unknown_surface:${surface}`);
-        }
-    }
-    for (const override of [...overridesByName.values()].sort((left, right) => left.name.localeCompare(right.name))) {
-        for (const surface of toSortedList([...override.allowedSurfaces, ...override.blockedSurfaces])) {
-            if (!knownSurfaces.has(surface)) {
-                warnings.push(`extension_policy_unknown_surface:${override.name}:${surface}`);
-            }
-        }
-    }
-    return {
-        mode,
-        trustMode,
-        requireProvenance,
-        trustedExtensions,
-        defaultSandboxProfile,
-        allowedExtensions,
-        blockedExtensions,
-        allowedCapabilities,
-        blockedCapabilities,
-        allowedSurfaces,
-        blockedSurfaces,
-        allowedCommands,
-        blockedCommands,
-        allowedActions,
-        blockedActions,
-        allowedServices,
-        blockedServices,
-        overridesByName,
-        warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
-    };
-}
-function serializeExtensionPolicy(policy) {
-    const overrides = [...policy.overridesByName.values()]
-        .sort((left, right) => left.name.localeCompare(right.name))
-        .map((override) => ({
-        name: override.name,
-        ...(override.disabled ? { disabled: true } : {}),
-        ...(override.requireTrusted ? { require_trusted: true } : {}),
-        ...(override.requireProvenance ? { require_provenance: true } : {}),
-        ...(override.sandboxProfile ? { sandbox_profile: override.sandboxProfile } : {}),
-        ...(override.allowedCapabilities.size > 0 ? { allowed_capabilities: toSortedList(override.allowedCapabilities) } : {}),
-        ...(override.blockedCapabilities.size > 0 ? { blocked_capabilities: toSortedList(override.blockedCapabilities) } : {}),
-        ...(override.allowedSurfaces.size > 0 ? { allowed_surfaces: toSortedList(override.allowedSurfaces) } : {}),
-        ...(override.blockedSurfaces.size > 0 ? { blocked_surfaces: toSortedList(override.blockedSurfaces) } : {}),
-        ...(override.allowedCommands.size > 0 ? { allowed_commands: toSortedList(override.allowedCommands) } : {}),
-        ...(override.blockedCommands.size > 0 ? { blocked_commands: toSortedList(override.blockedCommands) } : {}),
-        ...(override.allowedActions.size > 0 ? { allowed_actions: toSortedList(override.allowedActions) } : {}),
-        ...(override.blockedActions.size > 0 ? { blocked_actions: toSortedList(override.blockedActions) } : {}),
-        ...(override.allowedServices.size > 0 ? { allowed_services: toSortedList(override.allowedServices) } : {}),
-        ...(override.blockedServices.size > 0 ? { blocked_services: toSortedList(override.blockedServices) } : {}),
-    }));
-    return {
-        mode: policy.mode,
-        trust_mode: policy.trustMode,
-        require_provenance: policy.requireProvenance,
-        trusted_extensions: toSortedList(policy.trustedExtensions),
-        default_sandbox_profile: policy.defaultSandboxProfile,
-        allowed_extensions: toSortedList(policy.allowedExtensions),
-        blocked_extensions: toSortedList(policy.blockedExtensions),
-        allowed_capabilities: toSortedList(policy.allowedCapabilities),
-        blocked_capabilities: toSortedList(policy.blockedCapabilities),
-        allowed_surfaces: toSortedList(policy.allowedSurfaces),
-        blocked_surfaces: toSortedList(policy.blockedSurfaces),
-        allowed_commands: toSortedList(policy.allowedCommands),
-        blocked_commands: toSortedList(policy.blockedCommands),
-        allowed_actions: toSortedList(policy.allowedActions),
-        blocked_actions: toSortedList(policy.blockedActions),
-        allowed_services: toSortedList(policy.allowedServices),
-        blocked_services: toSortedList(policy.blockedServices),
-        extension_overrides: overrides,
-    };
-}
-function hydrateExtensionPolicy(policy) {
-    const overridesByName = new Map();
-    for (const rawOverride of policy.extension_overrides ?? []) {
-        const name = normalizePolicyName(rawOverride.name);
-        if (name.length === 0) {
-            continue;
-        }
-        overridesByName.set(name, {
-            name,
-            disabled: rawOverride.disabled === true,
-            requireTrusted: rawOverride.require_trusted === true,
-            requireProvenance: rawOverride.require_provenance === true,
-            sandboxProfile: rawOverride.sandbox_profile !== undefined
-                ? normalizePolicySandboxProfile(rawOverride.sandbox_profile)
-                : undefined,
-            allowedCapabilities: normalizePolicyStringSet(rawOverride.allowed_capabilities),
-            blockedCapabilities: normalizePolicyStringSet(rawOverride.blocked_capabilities),
-            allowedSurfaces: normalizePolicySurfaceSet(rawOverride.allowed_surfaces),
-            blockedSurfaces: normalizePolicySurfaceSet(rawOverride.blocked_surfaces),
-            allowedCommands: normalizePolicyStringSet(rawOverride.allowed_commands),
-            blockedCommands: normalizePolicyStringSet(rawOverride.blocked_commands),
-            allowedActions: normalizePolicyStringSet(rawOverride.allowed_actions),
-            blockedActions: normalizePolicyStringSet(rawOverride.blocked_actions),
-            allowedServices: normalizePolicyStringSet(rawOverride.allowed_services),
-            blockedServices: normalizePolicyStringSet(rawOverride.blocked_services),
-        });
-    }
-    return {
-        mode: normalizePolicyMode(policy.mode),
-        trustMode: normalizePolicyTrustMode(policy.trust_mode),
-        requireProvenance: policy.require_provenance === true,
-        trustedExtensions: normalizePolicyStringSet(policy.trusted_extensions),
-        defaultSandboxProfile: normalizePolicySandboxProfile(policy.default_sandbox_profile),
-        allowedExtensions: normalizePolicyStringSet(policy.allowed_extensions),
-        blockedExtensions: normalizePolicyStringSet(policy.blocked_extensions),
-        allowedCapabilities: normalizePolicyStringSet(policy.allowed_capabilities),
-        blockedCapabilities: normalizePolicyStringSet(policy.blocked_capabilities),
-        allowedSurfaces: normalizePolicySurfaceSet(policy.allowed_surfaces),
-        blockedSurfaces: normalizePolicySurfaceSet(policy.blocked_surfaces),
-        allowedCommands: normalizePolicyStringSet(policy.allowed_commands),
-        blockedCommands: normalizePolicyStringSet(policy.blocked_commands),
-        allowedActions: normalizePolicyStringSet(policy.allowed_actions),
-        blockedActions: normalizePolicyStringSet(policy.blocked_actions),
-        allowedServices: normalizePolicyStringSet(policy.allowed_services),
-        blockedServices: normalizePolicyStringSet(policy.blocked_services),
-        overridesByName,
-        warnings: [],
-    };
-}
-function resolvePolicyOverride(policy, extensionName) {
-    return policy.overridesByName.get(normalizePolicyName(extensionName)) ?? null;
-}
-function evaluatePolicySet(allowed, blocked, value, notAllowlistedReason, blockedReason) {
-    if (blocked.has(value)) {
-        return blockedReason;
-    }
-    if (allowed.size > 0 && !allowed.has(value)) {
-        return notAllowlistedReason;
-    }
-    return null;
-}
-function resolvePolicyCapabilityReason(policy, extension, capability) {
-    const normalizedCapability = capability.trim().toLowerCase();
-    const override = resolvePolicyOverride(policy, extension.name);
-    const allowed = override && override.allowedCapabilities.size > 0 ? override.allowedCapabilities : policy.allowedCapabilities;
-    const blocked = new Set([
-        ...policy.blockedCapabilities,
-        ...(override ? override.blockedCapabilities : []),
-    ]);
-    return evaluatePolicySet(allowed, blocked, normalizedCapability, "capability_not_allowlisted", "capability_blocked");
-}
-function resolvePolicySurfaceReason(policy, extension, surface) {
-    const override = resolvePolicyOverride(policy, extension.name);
-    const allowed = override && override.allowedSurfaces.size > 0 ? override.allowedSurfaces : policy.allowedSurfaces;
-    const blocked = new Set([
-        ...policy.blockedSurfaces,
-        ...(override ? override.blockedSurfaces : []),
-    ]);
-    return evaluatePolicySet(allowed, blocked, surface, "surface_not_allowlisted", "surface_blocked");
-}
-function resolvePolicyCommandReason(policy, extension, command) {
-    const normalizedCommand = normalizeCommandName(command);
-    if (normalizedCommand.length === 0) {
-        return null;
-    }
-    const override = resolvePolicyOverride(policy, extension.name);
-    const allowed = override && override.allowedCommands.size > 0 ? override.allowedCommands : policy.allowedCommands;
-    const blocked = new Set([
-        ...policy.blockedCommands,
-        ...(override ? override.blockedCommands : []),
-    ]);
-    return evaluatePolicySet(allowed, blocked, normalizedCommand, "command_not_allowlisted", "command_blocked");
-}
-function resolvePolicyActionReason(policy, extension, action) {
-    const normalizedAction = normalizePolicyName(action).replace(/\s+/g, "-");
-    if (normalizedAction.length === 0) {
-        return null;
-    }
-    const override = resolvePolicyOverride(policy, extension.name);
-    const allowed = override && override.allowedActions.size > 0 ? override.allowedActions : policy.allowedActions;
-    const blocked = new Set([
-        ...policy.blockedActions,
-        ...(override ? override.blockedActions : []),
-    ]);
-    return evaluatePolicySet(allowed, blocked, normalizedAction, "action_not_allowlisted", "action_blocked");
-}
-function resolvePolicyServiceReason(policy, extension, service) {
-    const normalizedService = normalizePolicyName(service);
-    if (normalizedService.length === 0) {
-        return null;
-    }
-    const override = resolvePolicyOverride(policy, extension.name);
-    const allowed = override && override.allowedServices.size > 0 ? override.allowedServices : policy.allowedServices;
-    const blocked = new Set([
-        ...policy.blockedServices,
-        ...(override ? override.blockedServices : []),
-    ]);
-    return evaluatePolicySet(allowed, blocked, normalizedService, "service_not_allowlisted", "service_blocked");
-}
-function resolvePolicyExtensionReason(policy, extension) {
-    const name = normalizePolicyName(extension.name);
-    const override = resolvePolicyOverride(policy, extension.name);
-    if (override?.disabled === true) {
-        return "extension_override_disabled";
-    }
-    return evaluatePolicySet(policy.allowedExtensions, policy.blockedExtensions, name, "extension_not_allowlisted", "extension_blocked");
-}
-function resolvePolicyTrustReason(policy, extension) {
-    if (policy.trustMode === "off") {
-        return null;
-    }
-    const override = resolvePolicyOverride(policy, extension.name);
-    const name = normalizePolicyName(extension.name);
-    const trusted = extension.trusted === true;
-    const provenanceVerified = extension.provenanceVerified === true;
-    if (policy.trustedExtensions.size > 0 && !policy.trustedExtensions.has(name)) {
-        return "extension_not_trusted";
-    }
-    if ((override?.requireTrusted === true || policy.trustMode === "warn" || policy.trustMode === "enforce") && !trusted) {
-        return "extension_untrusted";
-    }
-    if ((policy.requireProvenance || override?.requireProvenance === true) && !provenanceVerified) {
-        return "provenance_missing_or_unverified";
-    }
-    return null;
-}
-function resolvePolicySandboxReason(policy, extension) {
-    if (policy.mode === "off") {
-        return null;
-    }
-    const override = resolvePolicyOverride(policy, extension.name);
-    const profile = override?.sandboxProfile ?? extension.sandboxProfile ?? policy.defaultSandboxProfile;
-    if (profile === "none") {
-        return null;
-    }
-    const permissions = extension.permissions;
-    if (!permissions) {
-        return "sandbox_permissions_missing";
-    }
-    const hasPermission = (name) => permissions[name] === true;
-    if (profile === "restricted") {
-        if (hasPermission("process_spawn")) {
-            return "sandbox_restricted_disallows_process_spawn";
-        }
-        if (hasPermission("env_write")) {
-            return "sandbox_restricted_disallows_env_write";
-        }
-        return null;
-    }
-    if (profile === "strict") {
-        if (hasPermission("process_spawn")) {
-            return "sandbox_strict_disallows_process_spawn";
-        }
-        if (hasPermission("network")) {
-            return "sandbox_strict_disallows_network";
-        }
-        if (hasPermission("fs_write")) {
-            return "sandbox_strict_disallows_fs_write";
-        }
-        if (hasPermission("env_write")) {
-            return "sandbox_strict_disallows_env_write";
-        }
-    }
-    return null;
-}
-function buildPolicyWarning(mode, scope, extension, reason, details = {}) {
-    const tokens = Object.entries(details)
-        .sort((left, right) => left[0].localeCompare(right[0]))
-        .map(([key, value]) => `${key}=${value}`)
-        .join(":");
-    const suffix = tokens.length > 0 ? `:${tokens}` : "";
-    return `extension_policy_${mode}_${scope}:${extension.layer}:${extension.name}:reason=${reason}${suffix}`;
-}
-function evaluateExtensionPolicyForExtension(policy, extension) {
-    if (policy.mode === "off" && policy.trustMode === "off") {
-        return { allowed: true, warning: null };
-    }
-    const reason = resolvePolicyExtensionReason(policy, extension);
-    const trustReason = resolvePolicyTrustReason(policy, extension);
-    const sandboxReason = resolvePolicySandboxReason(policy, extension);
-    const extensionEnforced = reason && policy.mode === "enforce";
-    const trustEnforced = trustReason && policy.trustMode === "enforce";
-    const sandboxEnforced = sandboxReason && policy.mode === "enforce";
-    if (!reason && !trustReason && !sandboxReason) {
-        return { allowed: true, warning: null };
-    }
-    if (extensionEnforced) {
-        return {
-            allowed: false,
-            warning: buildPolicyWarning("blocked", "extension", extension, reason),
-        };
-    }
-    if (trustEnforced) {
-        return {
-            allowed: false,
-            warning: buildPolicyWarning("blocked", "trust", extension, trustReason),
-        };
-    }
-    if (sandboxEnforced) {
-        return {
-            allowed: false,
-            warning: buildPolicyWarning("blocked", "extension", extension, sandboxReason),
-        };
-    }
-    if (reason && policy.mode === "warn") {
-        return {
-            allowed: true,
-            warning: buildPolicyWarning("violation", "extension", extension, reason),
-        };
-    }
-    if (trustReason && policy.trustMode === "warn") {
-        return {
-            allowed: true,
-            warning: buildPolicyWarning("violation", "trust", extension, trustReason),
-        };
-    }
-    if (sandboxReason && policy.mode === "warn") {
-        return {
-            allowed: true,
-            warning: buildPolicyWarning("violation", "extension", extension, sandboxReason),
-        };
-    }
-    return {
-        allowed: true,
-        warning: null,
-    };
-}
-function evaluateExtensionPolicyForCapability(policy, extension, capability) {
-    if (policy.mode === "off") {
-        return { allowed: true, warning: null };
-    }
-    const reason = resolvePolicyCapabilityReason(policy, extension, capability);
-    if (!reason) {
-        return { allowed: true, warning: null };
-    }
-    return {
-        allowed: policy.mode === "warn",
-        warning: buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "capability", extension, reason, { capability: capability.trim().toLowerCase() }),
-    };
-}
-function evaluateExtensionPolicyForRegistration(policy, extension, surface, method, capability, details) {
-    if (policy.mode === "off") {
-        return { allowed: true, warning: null };
-    }
-    const capabilityReason = typeof capability === "string" ? resolvePolicyCapabilityReason(policy, extension, capability) : null;
-    const surfaceReason = resolvePolicySurfaceReason(policy, extension, surface);
-    const commandReason = details?.command ? resolvePolicyCommandReason(policy, extension, details.command) : null;
-    const actionReason = details?.action ? resolvePolicyActionReason(policy, extension, details.action) : null;
-    const serviceReason = details?.service ? resolvePolicyServiceReason(policy, extension, details.service) : null;
-    const reason = capabilityReason ?? surfaceReason ?? commandReason ?? actionReason ?? serviceReason;
-    if (!reason) {
-        return { allowed: true, warning: null };
-    }
-    const warningDetails = {
-        method: normalizePolicyName(method).replace(/\s+/g, "_"),
-        surface,
-    };
-    if (capability) {
-        warningDetails.capability = capability;
-    }
-    if (details?.command) {
-        warningDetails.command = normalizeCommandName(details.command);
-    }
-    if (details?.action) {
-        warningDetails.action = normalizePolicyName(details.action).replace(/\s+/g, "-");
-    }
-    if (details?.service) {
-        warningDetails.service = normalizePolicyName(details.service);
-    }
-    const warning = buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "registration", extension, reason, warningDetails);
-    return {
-        allowed: policy.mode === "warn",
-        warning,
-    };
-}
-function resolveLegacyExtensionCapabilityAlias(capability) {
-    const normalized = capability.trim().toLowerCase();
-    if (normalized.length === 0) {
-        return null;
-    }
-    return EXTENSION_CAPABILITY_LEGACY_ALIASES[normalized] ?? null;
-}
-function normalizeManifestCapabilities(rawCapabilities) {
-    const normalizedCapabilities = normalizeNames([...rawCapabilities].map((value) => value.toLowerCase()));
-    const remappedCapabilities = [];
-    const legacyAliases = [];
-    for (const capability of normalizedCapabilities) {
-        const legacyAliasTarget = resolveLegacyExtensionCapabilityAlias(capability);
-        if (legacyAliasTarget) {
-            remappedCapabilities.push(legacyAliasTarget);
-            legacyAliases.push({
-                alias: capability,
-                target: legacyAliasTarget,
-            });
-            continue;
-        }
-        remappedCapabilities.push(capability);
-    }
-    const dedupedLegacyAliases = [...new Map(legacyAliases.map((entry) => [`${entry.alias}>${entry.target}`, entry])).values()].sort((left, right) => left.alias.localeCompare(right.alias));
-    return {
-        capabilities: normalizeNames(remappedCapabilities),
-        legacy_aliases: dedupedLegacyAliases,
-    };
-}
-function levenshteinDistance(left, right) {
-    if (left === right) {
-        return 0;
-    }
-    if (left.length === 0) {
-        return right.length;
-    }
-    if (right.length === 0) {
-        return left.length;
-    }
-    const previous = new Array(right.length + 1);
-    const current = new Array(right.length + 1);
-    for (let j = 0; j <= right.length; j += 1) {
-        previous[j] = j;
-    }
-    for (let i = 1; i <= left.length; i += 1) {
-        current[0] = i;
-        for (let j = 1; j <= right.length; j += 1) {
-            const substitutionCost = left[i - 1] === right[j - 1] ? 0 : 1;
-            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + substitutionCost);
-        }
-        for (let j = 0; j <= right.length; j += 1) {
-            previous[j] = current[j];
-        }
-    }
-    return previous[right.length] ?? left.length;
-}
-function suggestKnownExtensionCapability(capability) {
-    const normalized = capability.trim().toLowerCase();
-    if (normalized.length === 0) {
-        return null;
-    }
-    const legacyAlias = resolveLegacyExtensionCapabilityAlias(normalized);
-    if (legacyAlias) {
-        return legacyAlias;
-    }
-    let bestMatch = null;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (const candidate of KNOWN_EXTENSION_CAPABILITIES) {
-        const distance = levenshteinDistance(normalized, candidate);
-        if (distance < bestDistance) {
-            bestDistance = distance;
-            bestMatch = candidate;
-        }
-    }
-    const maxDistance = Math.max(1, Math.floor(normalized.length * 0.34));
-    return bestMatch !== null && bestDistance <= maxDistance ? bestMatch : null;
-}
-function formatUnknownExtensionCapabilityWarning(layer, name, capability) {
-    const allowed = KNOWN_EXTENSION_CAPABILITIES.join(",");
-    const suggested = suggestKnownExtensionCapability(capability) ?? "none";
-    return `extension_capability_unknown:${layer}:${name}:${capability}:allowed=${allowed}:suggested=${suggested}`;
-}
-function formatLegacyExtensionCapabilityAliasWarning(layer, name, aliases) {
-    const aliasesToken = aliases.map((entry) => `${entry.alias}>${entry.target}`).join(",");
-    return `extension_capability_legacy_alias:${layer}:${name}:aliases=${aliasesToken}`;
-}
-export function parseUnknownExtensionCapabilityWarning(warning) {
-    const match = /^extension_capability_unknown:(global|project):([^:]+):([^:]+):allowed=([^:]+):suggested=([^:]+)$/.exec(warning.trim());
-    if (!match) {
-        return null;
-    }
-    const [, layerRaw, name, capability, allowedRaw, suggestedRaw] = match;
-    const layer = layerRaw;
-    const allowed_capabilities = allowedRaw
-        .split(",")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
-    const legacyAlias = resolveLegacyExtensionCapabilityAlias(capability);
-    const suggestedFromWarning = suggestedRaw === "none" ? undefined : suggestedRaw;
-    const suggested_capability = suggestedFromWarning ?? legacyAlias ?? undefined;
-    const suggestion_source = suggested_capability
-        ? legacyAlias === suggested_capability
-            ? "legacy_alias"
-            : "nearest_match"
-        : undefined;
-    return {
-        layer,
-        name,
-        capability,
-        allowed_capabilities,
-        capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
-        suggested_capability,
-        suggestion_source,
-        legacy_alias_target: legacyAlias ?? undefined,
-    };
-}
-export function parseLegacyExtensionCapabilityAliasWarning(warning) {
-    const match = /^extension_capability_legacy_alias:(global|project):([^:]+):aliases=(.+)$/.exec(warning.trim());
-    if (!match) {
-        return [];
-    }
-    const [, layerRaw, name, aliasesRaw] = match;
-    const layer = layerRaw;
-    const allowedCapabilities = [...KNOWN_EXTENSION_CAPABILITIES];
-    const parsed = [];
-    for (const token of aliasesRaw.split(",")) {
-        const [rawAlias, rawTarget] = token.split(">");
-        const alias = rawAlias?.trim();
-        const target = rawTarget?.trim().toLowerCase();
-        if (!alias || !target || !isKnownExtensionCapability(target)) {
-            continue;
-        }
-        parsed.push({
-            layer,
-            name,
-            capability: alias,
-            allowed_capabilities: allowedCapabilities,
-            capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
-            suggested_capability: target,
-            suggestion_source: "legacy_alias",
-            legacy_alias_target: target,
-        });
-    }
-    return parsed;
-}
 function parseManifest(raw) {
     if (typeof raw !== "object" || raw === null) {
         return null;
@@ -723,7 +76,7 @@ function parseManifest(raw) {
     }
     let provenance;
     if ("provenance" in candidate && candidate.provenance !== undefined && candidate.provenance !== null) {
-        const provenanceRecord = asRecord(candidate.provenance);
+        const provenanceRecord = asRecordLoose(candidate.provenance);
         if (!provenanceRecord) {
             return null;
         }
@@ -753,7 +106,7 @@ function parseManifest(raw) {
     }
     let permissions;
     if ("permissions" in candidate && candidate.permissions !== undefined && candidate.permissions !== null) {
-        const permissionsRecord = asRecord(candidate.permissions);
+        const permissionsRecord = asRecordLoose(candidate.permissions);
         if (!permissionsRecord) {
             return null;
         }
@@ -808,12 +161,6 @@ function parseManifest(raw) {
         legacy_capability_aliases: legacyCapabilityAliases.length > 0 ? legacyCapabilityAliases : undefined,
     };
 }
-function asRecord(value) {
-    if (typeof value !== "object" || value === null) {
-        return null;
-    }
-    return value;
-}
 function shouldEnable(name, enabled, disabled) {
     if (disabled.has(name)) {
         return false;
@@ -833,54 +180,6 @@ export function resolveExtensionRoots(pmRoot, cwd = process.cwd()) {
         project: path.join(pmRoot, "extensions"),
     };
 }
-export function createEmptyExtensionHookRegistry() {
-    return {
-        beforeCommand: [],
-        afterCommand: [],
-        onWrite: [],
-        onRead: [],
-        onIndex: [],
-    };
-}
-export function createEmptyExtensionCommandRegistry() {
-    return {
-        overrides: [],
-        handlers: [],
-    };
-}
-export function createEmptyExtensionParserRegistry() {
-    return {
-        overrides: [],
-    };
-}
-export function createEmptyExtensionPreflightRegistry() {
-    return {
-        overrides: [],
-    };
-}
-export function createEmptyExtensionServiceRegistry() {
-    return {
-        overrides: [],
-    };
-}
-export function createEmptyExtensionRendererRegistry() {
-    return {
-        overrides: [],
-    };
-}
-export function createEmptyExtensionRegistrationRegistry() {
-    return {
-        commands: [],
-        flags: [],
-        item_fields: [],
-        item_types: [],
-        migrations: [],
-        importers: [],
-        exporters: [],
-        search_providers: [],
-        vector_store_adapters: [],
-    };
-}
 async function listExtensionDirectories(extensionsRoot) {
     try {
         const entries = await fs.readdir(extensionsRoot, { withFileTypes: true });
@@ -1182,7 +481,7 @@ export async function loadExtensions(options) {
     };
 }
 function resolveActivatableExtension(module) {
-    const moduleRecord = asRecord(module);
+    const moduleRecord = asRecordLoose(module);
     if (!moduleRecord) {
         return null;
     }
@@ -1191,7 +490,7 @@ function resolveActivatableExtension(module) {
             activate: moduleRecord.activate,
         };
     }
-    const defaultExport = asRecord(moduleRecord.default);
+    const defaultExport = asRecordLoose(moduleRecord.default);
     if (defaultExport && typeof defaultExport.activate === "function") {
         return {
             activate: defaultExport.activate,
@@ -1199,46 +498,11 @@ function resolveActivatableExtension(module) {
     }
     return null;
 }
-function normalizeCommandName(command) {
-    return command
-        .trim()
-        .toLowerCase()
-        .split(/\s+/)
-        .filter((part) => part.length > 0)
-        .join(" ");
-}
-function defaultGlobalOptions() {
-    return {
-        json: false,
-        quiet: false,
-        noExtensions: false,
-        profile: false,
-    };
-}
-function cloneCommandOptionsSnapshot(options) {
-    return options ? cloneContextSnapshot(options) : {};
-}
-function cloneGlobalOptionsSnapshot(options) {
-    return options ? cloneContextSnapshot(options) : defaultGlobalOptions();
-}
-function cloneContextSnapshot(value) {
-    return structuredClone(value);
-}
 function isOutputRendererFormat(value) {
     return value === "toon" || value === "json";
 }
-const EXTENSION_SERVICE_NAMES = [
-    "output_format",
-    "error_format",
-    "help_format",
-    "lock_acquire",
-    "lock_release",
-    "history_append",
-    "item_store_write",
-    "item_store_delete",
-];
 function isExtensionServiceName(value) {
-    return EXTENSION_SERVICE_NAMES.includes(value);
+    return KNOWN_EXTENSION_SERVICE_NAMES.includes(value);
 }
 function assertHookHandler(hookName, hook) {
     if (typeof hook !== "function") {
@@ -1742,7 +1006,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         assertExtensionCapability(extension, "services", "registerService");
         const normalizedService = String(service).trim().toLowerCase();
         if (!isExtensionServiceName(normalizedService)) {
-            throw new TypeError(`registerService service must be one of: ${EXTENSION_SERVICE_NAMES.join(", ")}`);
+            throw new TypeError(`registerService service must be one of: ${KNOWN_EXTENSION_SERVICE_NAMES.join(", ")}`);
         }
         if (!allowRegistration("services.override", "registerService", "services", { service: normalizedService })) {
             return;
@@ -2000,18 +1264,6 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
         },
     };
 }
-async function executeRegisteredHooks(entries, hookName, context) {
-    const warnings = [];
-    for (const entry of entries) {
-        try {
-            await entry.run(cloneContextSnapshot(context));
-        }
-        catch {
-            warnings.push(`extension_hook_failed:${entry.layer}:${entry.name}:${hookName}`);
-        }
-    }
-    return warnings;
-}
 function getRegistrationCounts(registrations) {
     const commandCount = registrations.commands.length;
     const flagCount = registrations.flags.reduce((total, entry) => total + entry.flags.length, 0);
@@ -2200,374 +1452,5 @@ export async function activateExtensions(loadResult) {
         registration_counts: getRegistrationCounts(registrations),
     };
 }
-export async function runBeforeCommandHooks(hooks, context) {
-    return executeRegisteredHooks(hooks.beforeCommand, "beforeCommand", context);
-}
-export async function runAfterCommandHooks(hooks, context) {
-    return executeRegisteredHooks(hooks.afterCommand, "afterCommand", context);
-}
-export async function runOnWriteHooks(hooks, context) {
-    return executeRegisteredHooks(hooks.onWrite, "onWrite", context);
-}
-export async function runOnReadHooks(hooks, context) {
-    return executeRegisteredHooks(hooks.onRead, "onRead", context);
-}
-export async function runOnIndexHooks(hooks, context) {
-    return executeRegisteredHooks(hooks.onIndex, "onIndex", context);
-}
-export async function runCommandHandler(commands, context) {
-    const command = normalizeCommandName(context.command);
-    if (command.length === 0) {
-        return {
-            handled: false,
-            result: null,
-            warnings: [],
-        };
-    }
-    const matched = [...commands.handlers].reverse().find((entry) => entry.command === command);
-    if (!matched) {
-        return {
-            handled: false,
-            result: null,
-            warnings: [],
-        };
-    }
-    try {
-        const result = await matched.run({
-            command,
-            args: cloneContextSnapshot(context.args),
-            options: cloneContextSnapshot(context.options),
-            global: cloneContextSnapshot(context.global),
-            pm_root: context.pm_root,
-        });
-        return {
-            handled: true,
-            result,
-            warnings: [],
-        };
-    }
-    catch (error) {
-        const exitCode = typeof error === "object" && error !== null && "exitCode" in error
-            ? error.exitCode
-            : undefined;
-        if (typeof exitCode === "number" && Number.isFinite(exitCode)) {
-            throw error;
-        }
-        return {
-            handled: false,
-            result: null,
-            warnings: [`extension_command_handler_failed:${matched.layer}:${matched.name}:${matched.command}`],
-        };
-    }
-}
-export async function runParserOverride(parsers, context) {
-    const command = normalizeCommandName(context.command);
-    if (command.length === 0) {
-        return {
-            overridden: false,
-            context: {
-                command,
-                args: cloneContextSnapshot(context.args),
-                options: cloneCommandOptionsSnapshot(context.options),
-                global: cloneGlobalOptionsSnapshot(context.global),
-                pm_root: context.pm_root,
-            },
-            warnings: [],
-        };
-    }
-    const matched = [...parsers.overrides].reverse().find((entry) => entry.command === command);
-    if (!matched) {
-        return {
-            overridden: false,
-            context: {
-                command,
-                args: cloneContextSnapshot(context.args),
-                options: cloneCommandOptionsSnapshot(context.options),
-                global: cloneGlobalOptionsSnapshot(context.global),
-                pm_root: context.pm_root,
-            },
-            warnings: [],
-        };
-    }
-    try {
-        const delta = (await Promise.resolve(matched.run({
-            command,
-            args: cloneContextSnapshot(context.args),
-            options: cloneCommandOptionsSnapshot(context.options),
-            global: cloneGlobalOptionsSnapshot(context.global),
-            pm_root: context.pm_root,
-        }))) ?? {};
-        const nextArgs = Array.isArray(delta.args) ? cloneContextSnapshot(delta.args) : cloneContextSnapshot(context.args);
-        const nextOptions = delta.options ? cloneCommandOptionsSnapshot(delta.options) : cloneCommandOptionsSnapshot(context.options);
-        const nextGlobal = delta.global ? cloneGlobalOptionsSnapshot(delta.global) : cloneGlobalOptionsSnapshot(context.global);
-        return {
-            overridden: true,
-            context: {
-                command,
-                args: nextArgs,
-                options: nextOptions,
-                global: nextGlobal,
-                pm_root: context.pm_root,
-            },
-            warnings: [],
-        };
-    }
-    catch {
-        return {
-            overridden: false,
-            context: {
-                command,
-                args: cloneContextSnapshot(context.args),
-                options: cloneCommandOptionsSnapshot(context.options),
-                global: cloneGlobalOptionsSnapshot(context.global),
-                pm_root: context.pm_root,
-            },
-            warnings: [`extension_parser_override_failed:${matched.layer}:${matched.name}:${matched.command}`],
-        };
-    }
-}
-export async function runPreflightOverride(preflight, context) {
-    const matched = [...preflight.overrides].reverse()[0];
-    const baseContext = {
-        command: normalizeCommandName(context.command),
-        args: cloneContextSnapshot(context.args),
-        options: cloneCommandOptionsSnapshot(context.options),
-        global: cloneGlobalOptionsSnapshot(context.global),
-        pm_root: context.pm_root,
-    };
-    const baseDecision = cloneContextSnapshot(context.decision);
-    if (!matched) {
-        return {
-            overridden: false,
-            context: baseContext,
-            decision: baseDecision,
-            warnings: [],
-        };
-    }
-    try {
-        const delta = (await Promise.resolve(matched.run({
-            command: baseContext.command,
-            args: cloneContextSnapshot(baseContext.args),
-            options: cloneCommandOptionsSnapshot(baseContext.options),
-            global: cloneGlobalOptionsSnapshot(baseContext.global),
-            pm_root: baseContext.pm_root,
-            decision: cloneContextSnapshot(baseDecision),
-        }))) ?? {};
-        const nextContext = {
-            command: baseContext.command,
-            args: Array.isArray(delta.args) ? cloneContextSnapshot(delta.args) : baseContext.args,
-            options: delta.options ? cloneCommandOptionsSnapshot(delta.options) : baseContext.options,
-            global: delta.global ? cloneGlobalOptionsSnapshot(delta.global) : baseContext.global,
-            pm_root: baseContext.pm_root,
-        };
-        const nextDecision = {
-            enforce_item_format_gate: typeof delta.enforce_item_format_gate === "boolean"
-                ? delta.enforce_item_format_gate
-                : baseDecision.enforce_item_format_gate,
-            run_preflight_item_format_sync: typeof delta.run_preflight_item_format_sync === "boolean"
-                ? delta.run_preflight_item_format_sync
-                : baseDecision.run_preflight_item_format_sync,
-            run_extension_migrations: typeof delta.run_extension_migrations === "boolean"
-                ? delta.run_extension_migrations
-                : baseDecision.run_extension_migrations,
-            enforce_mandatory_migration_gate: typeof delta.enforce_mandatory_migration_gate === "boolean"
-                ? delta.enforce_mandatory_migration_gate
-                : baseDecision.enforce_mandatory_migration_gate,
-        };
-        return {
-            overridden: true,
-            context: nextContext,
-            decision: nextDecision,
-            warnings: [],
-        };
-    }
-    catch {
-        return {
-            overridden: false,
-            context: baseContext,
-            decision: baseDecision,
-            warnings: [`extension_preflight_override_failed:${matched.layer}:${matched.name}`],
-        };
-    }
-}
-function resolveDefaultServiceResult(context) {
-    return {
-        handled: false,
-        result: context.payload,
-        warnings: [],
-    };
-}
-export function runServiceOverrideSync(services, context) {
-    const matches = [...services.overrides].reverse().filter((entry) => entry.service === context.service);
-    if (matches.length === 0) {
-        return resolveDefaultServiceResult(context);
-    }
-    const warnings = [];
-    for (const matched of matches) {
-        try {
-            const serviceContext = {
-                service: context.service,
-                command: context.command ? normalizeCommandName(context.command) : undefined,
-                args: context.args ? cloneContextSnapshot(context.args) : undefined,
-                options: context.options ? cloneCommandOptionsSnapshot(context.options) : undefined,
-                global: context.global ? cloneGlobalOptionsSnapshot(context.global) : undefined,
-                pm_root: context.pm_root,
-                payload: cloneContextSnapshot(context.payload),
-            };
-            const result = matched.run(serviceContext);
-            if (result instanceof Promise) {
-                warnings.push(`extension_service_override_async_unsupported:${matched.layer}:${matched.name}:${matched.service}`);
-                continue;
-            }
-            if (context.service === "output_format" && (result === null || result === undefined || result === serviceContext.payload)) {
-                continue;
-            }
-            return {
-                handled: true,
-                result,
-                warnings,
-            };
-        }
-        catch {
-            warnings.push(`extension_service_override_failed:${matched.layer}:${matched.name}:${matched.service}`);
-        }
-    }
-    return {
-        handled: false,
-        result: context.payload,
-        warnings,
-    };
-}
-export async function runServiceOverride(services, context) {
-    const matches = [...services.overrides].reverse().filter((entry) => entry.service === context.service);
-    if (matches.length === 0) {
-        return resolveDefaultServiceResult(context);
-    }
-    const warnings = [];
-    for (const matched of matches) {
-        try {
-            const serviceContext = {
-                service: context.service,
-                command: context.command ? normalizeCommandName(context.command) : undefined,
-                args: context.args ? cloneContextSnapshot(context.args) : undefined,
-                options: context.options ? cloneCommandOptionsSnapshot(context.options) : undefined,
-                global: context.global ? cloneGlobalOptionsSnapshot(context.global) : undefined,
-                pm_root: context.pm_root,
-                payload: cloneContextSnapshot(context.payload),
-            };
-            const result = await Promise.resolve(matched.run(serviceContext));
-            if (context.service === "output_format" && (result === null || result === undefined || result === serviceContext.payload)) {
-                continue;
-            }
-            return {
-                handled: true,
-                result,
-                warnings,
-            };
-        }
-        catch {
-            warnings.push(`extension_service_override_failed:${matched.layer}:${matched.name}:${matched.service}`);
-        }
-    }
-    return {
-        handled: false,
-        result: context.payload,
-        warnings,
-    };
-}
-export function runCommandOverride(commands, context) {
-    const command = normalizeCommandName(context.command);
-    if (command.length === 0) {
-        return {
-            overridden: false,
-            result: context.result,
-            warnings: [],
-        };
-    }
-    const matched = [...commands.overrides].reverse().find((entry) => entry.command === command);
-    if (!matched) {
-        return {
-            overridden: false,
-            result: context.result,
-            warnings: [],
-        };
-    }
-    try {
-        const overrideOptions = cloneCommandOptionsSnapshot(context.options);
-        const overrideGlobal = cloneGlobalOptionsSnapshot(context.global);
-        const overrideResult = matched.run({
-            command,
-            args: cloneContextSnapshot(context.args),
-            options: overrideOptions,
-            global: overrideGlobal,
-            pm_root: context.pm_root,
-            result: cloneContextSnapshot(context.result),
-        });
-        if (overrideResult instanceof Promise) {
-            return {
-                overridden: false,
-                result: context.result,
-                warnings: [`extension_command_override_async_unsupported:${matched.layer}:${matched.name}:${matched.command}`],
-            };
-        }
-        return {
-            overridden: true,
-            result: overrideResult,
-            warnings: [],
-        };
-    }
-    catch {
-        return {
-            overridden: false,
-            result: context.result,
-            warnings: [`extension_command_override_failed:${matched.layer}:${matched.name}:${matched.command}`],
-        };
-    }
-}
-export function runRendererOverride(renderers, context) {
-    const matched = [...renderers.overrides].reverse().find((entry) => entry.format === context.format);
-    if (!matched) {
-        return {
-            overridden: false,
-            rendered: null,
-            warnings: [],
-        };
-    }
-    try {
-        const rendererCommand = typeof context.command === "string" ? normalizeCommandName(context.command) : "";
-        const rendererArgs = Array.isArray(context.args) ? cloneContextSnapshot(context.args) : [];
-        const rendererOptions = cloneCommandOptionsSnapshot(context.options);
-        const rendererGlobal = cloneGlobalOptionsSnapshot(context.global);
-        const rendererPmRoot = typeof context.pm_root === "string" ? context.pm_root : "";
-        const rendered = matched.run({
-            format: context.format,
-            command: rendererCommand,
-            args: rendererArgs,
-            options: rendererOptions,
-            global: rendererGlobal,
-            pm_root: rendererPmRoot,
-            result: cloneContextSnapshot(context.result),
-        });
-        if (typeof rendered !== "string") {
-            return {
-                overridden: false,
-                rendered: null,
-                warnings: [`extension_renderer_invalid_result:${matched.layer}:${matched.name}:${matched.format}`],
-            };
-        }
-        return {
-            overridden: true,
-            rendered,
-            warnings: [],
-        };
-    }
-    catch {
-        return {
-            overridden: false,
-            rendered: null,
-            warnings: [`extension_renderer_failed:${matched.layer}:${matched.name}:${matched.format}`],
-        };
-    }
-}
 //# sourceMappingURL=loader.js.map
-//# debugId=1692aa42-b0fb-5c2d-bb14-f00bad3a8efe
+//# debugId=4fba8687-0797-5479-afc8-12f1a2e5a954