@unbrained/pm-cli 2026.3.9

package/dist/core/extensions/loader.js

@@ -0,0 +1,917 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { pathExists } from "../fs/fs-utils.js";
+import { resolveGlobalPmRoot } from "../store/paths.js";
+const DEFAULT_EXTENSION_PRIORITY = 100;
+const KNOWN_EXTENSION_CAPABILITIES = ["commands", "renderers", "hooks", "schema", "importers", "search"];
+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));
+}
+function parseManifest(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        return null;
+    }
+    const candidate = raw;
+    if (typeof candidate.name !== "string" || candidate.name.trim().length === 0) {
+        return null;
+    }
+    if (typeof candidate.version !== "string" || candidate.version.trim().length === 0) {
+        return null;
+    }
+    if (typeof candidate.entry !== "string" || candidate.entry.trim().length === 0) {
+        return null;
+    }
+    let priority = DEFAULT_EXTENSION_PRIORITY;
+    if ("priority" in candidate && candidate.priority !== undefined && candidate.priority !== null) {
+        if (typeof candidate.priority !== "number" || !Number.isInteger(candidate.priority)) {
+            return null;
+        }
+        priority = candidate.priority;
+    }
+    let capabilities = [];
+    if ("capabilities" in candidate && candidate.capabilities !== undefined && candidate.capabilities !== null) {
+        if (!Array.isArray(candidate.capabilities) || candidate.capabilities.some((value) => typeof value !== "string")) {
+            return null;
+        }
+        capabilities = normalizeNames(candidate.capabilities.map((value) => value.toLowerCase()));
+    }
+    return {
+        name: candidate.name.trim(),
+        version: candidate.version.trim(),
+        entry: candidate.entry.trim(),
+        priority,
+        capabilities,
+    };
+}
+function asRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    return value;
+}
+function shouldEnable(name, enabled, disabled) {
+    if (disabled.has(name)) {
+        return false;
+    }
+    if (enabled.size === 0) {
+        return true;
+    }
+    return enabled.has(name);
+}
+function isPathWithinDirectory(directory, targetPath) {
+    const relative = path.relative(directory, targetPath);
+    if (relative.length === 0) {
+        return true;
+    }
+    return !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+async function isCanonicalPathWithinDirectory(directory, targetPath) {
+    const [resolvedDirectory, resolvedTargetPath] = await Promise.all([fs.realpath(directory), fs.realpath(targetPath)]);
+    return isPathWithinDirectory(resolvedDirectory, resolvedTargetPath);
+}
+export function resolveExtensionRoots(pmRoot, cwd = process.cwd()) {
+    return {
+        global: path.join(resolveGlobalPmRoot(cwd), "extensions"),
+        project: path.join(pmRoot, "extensions"),
+    };
+}
+export function createEmptyExtensionHookRegistry() {
+    return {
+        beforeCommand: [],
+        afterCommand: [],
+        onWrite: [],
+        onRead: [],
+        onIndex: [],
+    };
+}
+export function createEmptyExtensionCommandRegistry() {
+    return {
+        overrides: [],
+        handlers: [],
+    };
+}
+export function createEmptyExtensionRendererRegistry() {
+    return {
+        overrides: [],
+    };
+}
+export function createEmptyExtensionRegistrationRegistry() {
+    return {
+        flags: [],
+        item_fields: [],
+        migrations: [],
+        importers: [],
+        exporters: [],
+        search_providers: [],
+        vector_store_adapters: [],
+    };
+}
+async function listExtensionDirectories(extensionsRoot) {
+    try {
+        const entries = await fs.readdir(extensionsRoot, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+function summarizeCandidate(candidate) {
+    return {
+        layer: candidate.layer,
+        directory: candidate.directory,
+        manifest_path: candidate.manifest_path,
+        name: candidate.manifest.name,
+        version: candidate.manifest.version,
+        entry: candidate.manifest.entry,
+        priority: candidate.manifest.priority,
+        entry_path: candidate.entry_path,
+        capabilities: [...candidate.manifest.capabilities],
+    };
+}
+function sortCandidates(candidates) {
+    return [...candidates].sort((left, right) => {
+        if (left.manifest.priority !== right.manifest.priority) {
+            return left.manifest.priority - right.manifest.priority;
+        }
+        const byName = left.manifest.name.localeCompare(right.manifest.name);
+        if (byName !== 0) {
+            return byName;
+        }
+        return left.directory.localeCompare(right.directory);
+    });
+}
+function buildEffectiveExtensions(globalCandidates, projectCandidates) {
+    const ordered = [...sortCandidates(globalCandidates), ...sortCandidates(projectCandidates)];
+    const effective = [];
+    for (const candidate of ordered) {
+        const existingIndex = effective.findIndex((entry) => entry.manifest.name === candidate.manifest.name);
+        if (existingIndex >= 0) {
+            effective.splice(existingIndex, 1);
+        }
+        effective.push(candidate);
+    }
+    return effective;
+}
+async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled) {
+    const diagnostics = [];
+    const warnings = [];
+    const candidates = [];
+    const directories = await listExtensionDirectories(extensionsRoot);
+    for (const directory of directories) {
+        const scanned = await scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled);
+        diagnostics.push(scanned.diagnostic);
+        warnings.push(...scanned.warnings);
+        if (scanned.candidate) {
+            candidates.push(scanned.candidate);
+        }
+    }
+    return { diagnostics, warnings, candidates };
+}
+async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled) {
+    const extensionDir = path.join(extensionsRoot, directory);
+    const manifestPath = path.join(extensionDir, "manifest.json");
+    if (!(await pathExists(manifestPath))) {
+        return {
+            diagnostic: {
+                layer,
+                directory,
+                manifest_path: manifestPath,
+                name: null,
+                version: null,
+                entry: null,
+                priority: null,
+                entry_path: null,
+                enabled: null,
+                status: "warn",
+            },
+            warnings: [`extension_manifest_missing:${layer}:${directory}`],
+            candidate: null,
+        };
+    }
+    let manifest = null;
+    try {
+        const parsed = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        manifest = parseManifest(parsed);
+    }
+    catch {
+        manifest = null;
+    }
+    if (!manifest) {
+        return {
+            diagnostic: {
+                layer,
+                directory,
+                manifest_path: manifestPath,
+                name: null,
+                version: null,
+                entry: null,
+                priority: null,
+                entry_path: null,
+                enabled: null,
+                status: "warn",
+            },
+            warnings: [`extension_manifest_invalid:${layer}:${directory}`],
+            candidate: null,
+        };
+    }
+    const entryPath = path.resolve(extensionDir, manifest.entry);
+    const entryWithinDirectoryByPath = isPathWithinDirectory(extensionDir, entryPath);
+    const entryExists = entryWithinDirectoryByPath ? await pathExists(entryPath) : false;
+    const entryWithinDirectory = entryWithinDirectoryByPath && entryExists
+        ? await isCanonicalPathWithinDirectory(extensionDir, entryPath)
+        : entryWithinDirectoryByPath;
+    const enabledForLoad = shouldEnable(manifest.name, enabled, disabled);
+    const extensionWarnings = [];
+    for (const capability of collectUnknownExtensionCapabilities(manifest.capabilities)) {
+        extensionWarnings.push(`extension_capability_unknown:${layer}:${manifest.name}:${capability}`);
+    }
+    if (!entryWithinDirectory) {
+        extensionWarnings.push(`extension_entry_outside_extension:${layer}:${manifest.name}`);
+    }
+    else if (!entryExists) {
+        extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`);
+    }
+    return {
+        diagnostic: {
+            layer,
+            directory,
+            manifest_path: manifestPath,
+            name: manifest.name,
+            version: manifest.version,
+            entry: manifest.entry,
+            priority: manifest.priority,
+            entry_path: entryPath,
+            enabled: enabledForLoad,
+            status: entryWithinDirectory && entryExists ? "ok" : "warn",
+        },
+        warnings: extensionWarnings,
+        candidate: entryWithinDirectory && entryExists && enabledForLoad
+            ? {
+                layer,
+                directory,
+                manifest_path: manifestPath,
+                entry_path: entryPath,
+                manifest,
+            }
+            : null,
+    };
+}
+export async function discoverExtensions(options) {
+    const roots = resolveExtensionRoots(options.pmRoot, options.cwd ?? process.cwd());
+    const configured_enabled = normalizeNames(options.settings.extensions.enabled);
+    const configured_disabled = normalizeNames(options.settings.extensions.disabled);
+    if (options.noExtensions) {
+        return {
+            disabled_by_flag: true,
+            roots,
+            configured_enabled,
+            configured_disabled,
+            discovered: [],
+            effective: [],
+            warnings: [],
+        };
+    }
+    const enabled = new Set(configured_enabled);
+    const disabled = new Set(configured_disabled);
+    const globalScan = await scanExtensionLayer("global", roots.global, enabled, disabled);
+    const projectScan = await scanExtensionLayer("project", roots.project, enabled, disabled);
+    const effective = buildEffectiveExtensions(globalScan.candidates, projectScan.candidates).map(summarizeCandidate);
+    return {
+        disabled_by_flag: false,
+        roots,
+        configured_enabled,
+        configured_disabled,
+        discovered: [...globalScan.diagnostics, ...projectScan.diagnostics],
+        effective,
+        warnings: [...globalScan.warnings, ...projectScan.warnings],
+    };
+}
+function formatUnknownError(error) {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return error.message;
+    }
+    return String(error);
+}
+export async function loadExtensions(options) {
+    const discovery = await discoverExtensions(options);
+    const loaded = [];
+    const failed = [];
+    const warnings = [...discovery.warnings];
+    if (discovery.disabled_by_flag) {
+        return {
+            ...discovery,
+            warnings,
+            loaded,
+            failed,
+        };
+    }
+    for (const extension of discovery.effective) {
+        try {
+            const module = await import(pathToFileURL(extension.entry_path).href);
+            loaded.push({
+                ...extension,
+                module,
+            });
+        }
+        catch (error) {
+            warnings.push(`extension_load_failed:${extension.layer}:${extension.name}`);
+            failed.push({
+                layer: extension.layer,
+                name: extension.name,
+                entry_path: extension.entry_path,
+                error: formatUnknownError(error),
+            });
+        }
+    }
+    return {
+        ...discovery,
+        warnings,
+        loaded,
+        failed,
+    };
+}
+function resolveActivatableExtension(module) {
+    const moduleRecord = asRecord(module);
+    if (!moduleRecord) {
+        return null;
+    }
+    if (typeof moduleRecord.activate === "function") {
+        return {
+            activate: moduleRecord.activate,
+        };
+    }
+    const defaultExport = asRecord(moduleRecord.default);
+    if (defaultExport && typeof defaultExport.activate === "function") {
+        return {
+            activate: defaultExport.activate,
+        };
+    }
+    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";
+}
+function assertHookHandler(hookName, hook) {
+    if (typeof hook !== "function") {
+        throw new TypeError(`api.hooks.${hookName} requires a function handler`);
+    }
+}
+function assertNonEmptyString(name, value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError(`${name} requires a non-empty string`);
+    }
+    return value.trim();
+}
+function assertFunctionHandler(name, value) {
+    if (typeof value !== "function") {
+        throw new TypeError(`${name} requires a function handler`);
+    }
+}
+function normalizeRegistrationName(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((part) => part.length > 0)
+        .join(" ");
+}
+function toRegistrationCommandPath(name, action) {
+    return normalizeCommandName(`${name} ${action}`);
+}
+function sanitizeRegistrationValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeRegistrationValue(entry));
+    }
+    if (typeof value === "function") {
+        return "[Function]";
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (typeof value === "symbol") {
+        return value.toString();
+    }
+    if (typeof value === "object") {
+        const record = value;
+        const normalized = {};
+        const keys = Object.keys(record).sort((left, right) => left.localeCompare(right));
+        for (const key of keys) {
+            normalized[key] = sanitizeRegistrationValue(record[key]);
+        }
+        return normalized;
+    }
+    return value;
+}
+function normalizeRegistrationRecord(name, value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${name} requires an object definition`);
+    }
+    return sanitizeRegistrationValue(value);
+}
+function normalizeRegistrationRecordList(name, value) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`${name} requires an array of object definitions`);
+    }
+    return value.map((entry) => normalizeRegistrationRecord(name, entry));
+}
+function getDeclaredExtensionCapabilities(extension) {
+    if (!Array.isArray(extension.capabilities)) {
+        return null;
+    }
+    const declared = new Set();
+    for (const capability of extension.capabilities) {
+        const normalized = capability.trim().toLowerCase();
+        if (isKnownExtensionCapability(normalized)) {
+            declared.add(normalized);
+        }
+    }
+    return declared;
+}
+function assertExtensionCapability(extension, capability, method) {
+    const declared = getDeclaredExtensionCapabilities(extension);
+    // Keep direct unit tests that construct LoadedExtension fixtures without
+    // capability metadata backwards-compatible while enforcing manifest-declared
+    // capabilities for runtime-loaded extensions.
+    if (declared === null) {
+        return;
+    }
+    if (!declared.has(capability)) {
+        throw new TypeError(`${method} requires capability '${capability}' in extension manifest capabilities`);
+    }
+}
+function createExtensionApi(extension, hooks, commands, renderers, registrations) {
+    const registerCommand = (commandOrDefinition, override) => {
+        assertExtensionCapability(extension, "commands", "registerCommand");
+        if (typeof commandOrDefinition === "string") {
+            const normalizedCommand = normalizeCommandName(commandOrDefinition);
+            if (normalizedCommand.length === 0) {
+                throw new TypeError("registerCommand requires a non-empty command name");
+            }
+            if (typeof override !== "function") {
+                throw new TypeError("registerCommand requires an override function when command name is provided");
+            }
+            commands.overrides.push({
+                layer: extension.layer,
+                name: extension.name,
+                command: normalizedCommand,
+                run: override,
+            });
+            return;
+        }
+        if (typeof commandOrDefinition !== "object" || commandOrDefinition === null) {
+            throw new TypeError("registerCommand requires a command definition object");
+        }
+        if (typeof commandOrDefinition.name !== "string") {
+            throw new TypeError("registerCommand requires a command definition name");
+        }
+        const normalizedCommand = normalizeCommandName(commandOrDefinition.name);
+        if (normalizedCommand.length === 0) {
+            throw new TypeError("registerCommand requires a non-empty command definition name");
+        }
+        if (typeof commandOrDefinition.run !== "function") {
+            throw new TypeError("registerCommand requires a command definition run handler");
+        }
+        commands.handlers.push({
+            layer: extension.layer,
+            name: extension.name,
+            command: normalizedCommand,
+            run: commandOrDefinition.run,
+        });
+    };
+    const registerRenderer = (format, renderer) => {
+        assertExtensionCapability(extension, "renderers", "registerRenderer");
+        if (typeof renderer !== "function") {
+            throw new TypeError("registerRenderer requires a renderer function");
+        }
+        const normalizedFormat = String(format).trim().toLowerCase();
+        if (!isOutputRendererFormat(normalizedFormat)) {
+            throw new Error(`registerRenderer format must be toon|json, received: ${String(format)}`);
+        }
+        renderers.overrides.push({
+            layer: extension.layer,
+            name: extension.name,
+            format: normalizedFormat,
+            run: renderer,
+        });
+    };
+    const registerFlags = (targetCommand, flags) => {
+        assertExtensionCapability(extension, "schema", "registerFlags");
+        const normalizedTargetCommand = normalizeCommandName(assertNonEmptyString("registerFlags targetCommand", targetCommand));
+        const normalizedFlags = normalizeRegistrationRecordList("registerFlags flags", flags);
+        if (normalizedFlags.length === 0) {
+            throw new TypeError("registerFlags requires at least one flag definition");
+        }
+        registrations.flags.push({
+            layer: extension.layer,
+            name: extension.name,
+            target_command: normalizedTargetCommand,
+            flags: normalizedFlags,
+        });
+    };
+    const registerItemFields = (fields) => {
+        assertExtensionCapability(extension, "schema", "registerItemFields");
+        const normalizedFields = normalizeRegistrationRecordList("registerItemFields fields", fields);
+        if (normalizedFields.length === 0) {
+            throw new TypeError("registerItemFields requires at least one field definition");
+        }
+        registrations.item_fields.push({
+            layer: extension.layer,
+            name: extension.name,
+            fields: normalizedFields,
+        });
+    };
+    const registerMigration = (definition) => {
+        assertExtensionCapability(extension, "schema", "registerMigration");
+        registrations.migrations.push({
+            layer: extension.layer,
+            name: extension.name,
+            definition: normalizeRegistrationRecord("registerMigration definition", definition),
+        });
+    };
+    const registerImporter = (name, importer) => {
+        assertExtensionCapability(extension, "importers", "registerImporter");
+        const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerImporter name", name));
+        assertFunctionHandler("registerImporter importer", importer);
+        const commandPath = toRegistrationCommandPath(normalizedName, "import");
+        registrations.importers.push({
+            layer: extension.layer,
+            name: extension.name,
+            importer: normalizedName,
+        });
+        commands.handlers.push({
+            layer: extension.layer,
+            name: extension.name,
+            command: commandPath,
+            run: async (context) => importer({
+                registration: normalizedName,
+                action: "import",
+                command: context.command,
+                args: cloneContextSnapshot(context.args),
+                options: cloneContextSnapshot(context.options),
+                global: cloneContextSnapshot(context.global),
+                pm_root: context.pm_root,
+            }),
+        });
+    };
+    const registerExporter = (name, exporter) => {
+        assertExtensionCapability(extension, "importers", "registerExporter");
+        const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerExporter name", name));
+        assertFunctionHandler("registerExporter exporter", exporter);
+        const commandPath = toRegistrationCommandPath(normalizedName, "export");
+        registrations.exporters.push({
+            layer: extension.layer,
+            name: extension.name,
+            exporter: normalizedName,
+        });
+        commands.handlers.push({
+            layer: extension.layer,
+            name: extension.name,
+            command: commandPath,
+            run: async (context) => exporter({
+                registration: normalizedName,
+                action: "export",
+                command: context.command,
+                args: cloneContextSnapshot(context.args),
+                options: cloneContextSnapshot(context.options),
+                global: cloneContextSnapshot(context.global),
+                pm_root: context.pm_root,
+            }),
+        });
+    };
+    const registerSearchProvider = (provider) => {
+        assertExtensionCapability(extension, "search", "registerSearchProvider");
+        registrations.search_providers.push({
+            layer: extension.layer,
+            name: extension.name,
+            definition: normalizeRegistrationRecord("registerSearchProvider provider", provider),
+        });
+    };
+    const registerVectorStoreAdapter = (adapter) => {
+        assertExtensionCapability(extension, "search", "registerVectorStoreAdapter");
+        registrations.vector_store_adapters.push({
+            layer: extension.layer,
+            name: extension.name,
+            definition: normalizeRegistrationRecord("registerVectorStoreAdapter adapter", adapter),
+        });
+    };
+    const registerBeforeCommand = (hook) => {
+        assertExtensionCapability(extension, "hooks", "api.hooks.beforeCommand");
+        assertHookHandler("beforeCommand", hook);
+        hooks.beforeCommand.push({
+            layer: extension.layer,
+            name: extension.name,
+            run: hook,
+        });
+    };
+    const registerAfterCommand = (hook) => {
+        assertExtensionCapability(extension, "hooks", "api.hooks.afterCommand");
+        assertHookHandler("afterCommand", hook);
+        hooks.afterCommand.push({
+            layer: extension.layer,
+            name: extension.name,
+            run: hook,
+        });
+    };
+    const registerOnWrite = (hook) => {
+        assertExtensionCapability(extension, "hooks", "api.hooks.onWrite");
+        assertHookHandler("onWrite", hook);
+        hooks.onWrite.push({
+            layer: extension.layer,
+            name: extension.name,
+            run: hook,
+        });
+    };
+    const registerOnRead = (hook) => {
+        assertExtensionCapability(extension, "hooks", "api.hooks.onRead");
+        assertHookHandler("onRead", hook);
+        hooks.onRead.push({
+            layer: extension.layer,
+            name: extension.name,
+            run: hook,
+        });
+    };
+    const registerOnIndex = (hook) => {
+        assertExtensionCapability(extension, "hooks", "api.hooks.onIndex");
+        assertHookHandler("onIndex", hook);
+        hooks.onIndex.push({
+            layer: extension.layer,
+            name: extension.name,
+            run: hook,
+        });
+    };
+    return {
+        registerCommand,
+        registerFlags,
+        registerItemFields,
+        registerMigration,
+        registerRenderer,
+        registerImporter,
+        registerExporter,
+        registerSearchProvider,
+        registerVectorStoreAdapter,
+        hooks: {
+            beforeCommand: registerBeforeCommand,
+            afterCommand: registerAfterCommand,
+            onWrite: registerOnWrite,
+            onRead: registerOnRead,
+            onIndex: registerOnIndex,
+        },
+    };
+}
+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 flagCount = registrations.flags.reduce((total, entry) => total + entry.flags.length, 0);
+    const itemFieldCount = registrations.item_fields.reduce((total, entry) => total + entry.fields.length, 0);
+    return {
+        flags: flagCount,
+        item_fields: itemFieldCount,
+        migrations: registrations.migrations.length,
+        importers: registrations.importers.length,
+        exporters: registrations.exporters.length,
+        search_providers: registrations.search_providers.length,
+        vector_store_adapters: registrations.vector_store_adapters.length,
+    };
+}
+export async function activateExtensions(loadResult) {
+    const hooks = createEmptyExtensionHookRegistry();
+    const commands = createEmptyExtensionCommandRegistry();
+    const renderers = createEmptyExtensionRendererRegistry();
+    const registrations = createEmptyExtensionRegistrationRegistry();
+    const failed = [];
+    const warnings = [];
+    for (const extension of loadResult.loaded) {
+        const activatable = resolveActivatableExtension(extension.module);
+        if (!activatable) {
+            continue;
+        }
+        try {
+            await activatable.activate(createExtensionApi(extension, hooks, commands, renderers, registrations));
+        }
+        catch (error) {
+            warnings.push(`extension_activate_failed:${extension.layer}:${extension.name}`);
+            failed.push({
+                layer: extension.layer,
+                name: extension.name,
+                entry_path: extension.entry_path,
+                error: formatUnknownError(error),
+            });
+        }
+    }
+    return {
+        hooks,
+        commands,
+        renderers,
+        registrations,
+        failed,
+        warnings,
+        hook_counts: {
+            before_command: hooks.beforeCommand.length,
+            after_command: hooks.afterCommand.length,
+            on_write: hooks.onWrite.length,
+            on_read: hooks.onRead.length,
+            on_index: hooks.onIndex.length,
+        },
+        command_override_count: commands.overrides.length,
+        command_handler_count: commands.handlers.length,
+        renderer_override_count: renderers.overrides.length,
+        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 {
+        return {
+            handled: false,
+            result: null,
+            warnings: [`extension_command_handler_failed:${matched.layer}:${matched.name}:${matched.command}`],
+        };
+    }
+}
+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