@agentxm/extension-lifecycle 0.28.11 → 0.28.13

package/dist/src/configured-entry-resolution.js

@@ -1,731 +0,0 @@
-import * as DateTime from "effect/DateTime";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { parseRegistrySourceRef, parseSourceQualifiedRegistrySourcePatternParts, } from "@agentxm/extension-model/unstable/extensions";
-import { parseMinimumReleaseAge } from "@agentxm/registry-protocol/unstable/registry/release-age-policy";
-import { resolveSource, SourceHostProviders, WorkspaceCatalog } from "@agentxm/extension-sources";
-import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
-import { WorkspaceMutations } from "@agentxm/workspace-state";
-import { ExtensionLifecycleFailed } from "./errors.js";
-import { ReleaseAgePosture } from "./release-age-posture.js";
-import { LifecycleFailureAdapter } from "./failure-adapter.js";
-import { acceptedResolutionRef } from "@agentxm/workspace-state";
-import { resolveWorkspaceExtensionRef } from "@agentxm/workspace-state";
-export const makeConfiguredReleaseAgeEvaluation = () => Effect.gen(function* () {
-    const mode = yield* ReleaseAgePosture;
-    const ws = yield* WorkspaceMutations;
-    const configured = yield* ws.getMinimumReleaseAge();
-    const minimumReleaseAge = parseMinimumReleaseAge(configured);
-    if (Option.isNone(minimumReleaseAge)) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `Invalid minimumReleaseAge "${configured}"`,
-            recover: "Use a duration such as 24h, 1440m, or 0s.",
-        });
-    }
-    const evaluatedAt = yield* DateTime.now;
-    const exclude = yield* ws.getMinimumReleaseAgeExclude();
-    return {
-        minimumReleaseAge: minimumReleaseAge.value,
-        evaluatedAt,
-        mode,
-        exclude,
-    };
-});
-const releaseAgeRecord = (args) => ({
-    reason: "minimum-release-age",
-    target: args.target,
-    dependencyPath: [args.target],
-    ...(Option.isSome(args.versionRange) ? { requestedRange: args.versionRange.value } : {}),
-    ...(args.selectedVersion === undefined ? {} : { selectedVersion: args.selectedVersion }),
-    candidateVersion: args.evidence.version,
-    publishedAt: args.evidence.publishedAt,
-    eligibleAt: args.evidence.eligibleAt,
-    minimumReleaseAgeSeconds: args.evidence.minimumReleaseAgeSeconds,
-});
-const configuredRegistryResolution = (resolution) => Effect.gen(function* () {
-    if (resolution.kind === "not_found") {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured extension "${resolution.target}" could not be found in its source`,
-            suggestions: [{ description: "Verify the configured source or update axm.json." }],
-        });
-    }
-    if (resolution.kind === "version_unsatisfied") {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            title: "No compatible version",
-            detail: `${resolution.target} has no visible version satisfying ${resolution.requestedRange}`,
-        });
-    }
-    if (resolution.kind === "policy_held") {
-        return yield* new ExtensionLifecycleFailed({
-            category: "conflict",
-            title: "Release held by minimum release age",
-            detail: `${resolution.target}@${resolution.candidate.version} is held by the minimum release age until ${resolution.candidate.eligibleAt}`,
-            // Both routes are reachable from wherever the operator is standing:
-            // the exemption is declared once, the flag lasts one run.
-            recover: `Declare ${resolution.target} in minimumReleaseAgeExclude, or rerun this command with --ignore-release-age to take it for this run only.`,
-        });
-    }
-    const holdbacks = resolution.kind === "exempted" || resolution.newerHeld === undefined
-        ? []
-        : [
-            releaseAgeRecord({
-                target: resolution.target,
-                versionRange: resolution.versionRange,
-                evidence: resolution.newerHeld,
-                selectedVersion: resolution.ref.version,
-            }),
-        ];
-    const bypasses = resolution.kind === "selected"
-        ? []
-        : [
-            {
-                ...releaseAgeRecord({
-                    target: resolution.target,
-                    versionRange: resolution.versionRange,
-                    evidence: resolution.bypassed,
-                    selectedVersion: resolution.ref.version,
-                }),
-                ...resolution.exemption,
-            },
-        ];
-    return {
-        ref: resolution.ref,
-        versionRange: resolution.versionRange,
-        ...(holdbacks.length === 0 && bypasses.length === 0
-            ? {}
-            : { releaseAge: { holdbacks, bypasses } }),
-    };
-});
-const resolveConfiguredRegistryRef = (name, source, expectedType, releaseAgeEvaluation) => resolveConfiguredRegistryEntry(name, source, expectedType, releaseAgeEvaluation).pipe(Effect.flatMap(Option.match({
-    onNone: () => Effect.succeed(Option.none()),
-    onSome: (resolution) => configuredRegistryResolution(resolution).pipe(Effect.map(Option.some)),
-})));
-export const resolveConfiguredRegistryEntry = (name, source, expectedType, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source))
-        return Option.none();
-    const adapter = yield* LifecycleFailureAdapter;
-    const resolvedSource = yield* resolveSource(source, { expectedType }).pipe(Effect.mapError((failure) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid ${expectedType} source for ${name}: ${adapter.describeFailure(failure)}`,
-        cause: failure,
-    })));
-    if (resolvedSource.type !== "registry")
-        return Option.none();
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const pluralType = parsedPattern?.type;
-    const expectedPlural = expectedType === "mcp-server"
-        ? "mcps"
-        : expectedType === "knowledge"
-            ? "knowledge"
-            : `${expectedType}s`;
-    if (pluralType !== undefined && pluralType !== expectedPlural) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `Configured ${expectedType} "${name}" uses a ${pluralType} Registry source`,
-        });
-    }
-    if (expectedType !== "mcp-server" &&
-        parsedPattern?.name !== undefined &&
-        parsedPattern.name !== name) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `Configured ${expectedType} "${name}" points to Registry extension "${parsedPattern.name}"`,
-        });
-    }
-    const owner = parsedPattern?.owner ?? Option.getOrUndefined(resolvedSource.owner);
-    if (owner === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `Configured Registry source for ${expectedType} "${name}" must include an owner`,
-        });
-    }
-    const versionRange = Option.fromUndefinedOr(parsedPattern?.versionRange);
-    const registryName = expectedType === "mcp-server" ? (parsedPattern?.name ?? name) : name;
-    const workspace = yield* WorkspaceMutations;
-    const acceptedRef = yield* acceptedResolutionRef({
-        workspace,
-        type: expectedType,
-        name,
-    });
-    const accepted = Option.flatMap(acceptedRef, (ref) => ref.refType === "registry" && ref.owner === owner && ref.name === registryName
-        ? Option.some({
-            version: ref.version,
-            publisherBindingId: ref.publisherBindingId,
-        })
-        : Option.none());
-    const providers = yield* SourceHostProviders;
-    const resolution = yield* providers.resolveNamedRegistry(resolvedSource, {
-        name: registryName,
-        type: expectedType,
-        owner,
-        versionRange,
-        releaseAgeEvaluation,
-        ...(Option.isSome(accepted) ? { accepted: accepted.value } : {}),
-    });
-    const acceptedVersion = Option.isSome(accepted) &&
-        (resolution.kind === "selected" || resolution.kind === "exempted") &&
-        resolution.ref.version === accepted.value.version &&
-        resolution.ref.publisherBindingId === accepted.value.publisherBindingId
-        ? accepted.value.version
-        : undefined;
-    return Option.some({
-        ...resolution,
-        versionRange,
-        ...(acceptedVersion === undefined ? {} : { acceptedVersion }),
-    });
-});
-export const resolveConfiguredSkill = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "skill",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "skill") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace skill resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "skill", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "skill") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-skill",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const providers = yield* SourceHostProviders;
-    const resolvedSource = yield* resolveSource(source, { expectedType: "skill" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid skill source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const requestedOwner = parsedPattern?.type === "skills"
-        ? Option.some(parsedPattern.owner)
-        : resolvedSource.type === "registry"
-            ? resolvedSource.owner
-            : Option.none();
-    const versionRange = resolvedSource.type === "registry" && parsedPattern?.type === "skills"
-        ? Option.fromUndefinedOr(parsedPattern.versionRange)
-        : Option.none();
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "skill",
-        owner: requestedOwner,
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "skill")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured skill "${name}"`,
-        suggestions: [
-            {
-                description: `Verify the configured source is reachable and still contains the skill.`,
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.skill.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured skill "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: `Verify the configured source still contains the skill or update axm.json.`,
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange: ref.refType === "registry" ? versionRange : Option.none(),
-    };
-});
-export const resolveConfiguredSubagent = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "subagent",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "subagent") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace subagent resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "subagent", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "subagent") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-subagent",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const providers = yield* SourceHostProviders;
-    const resolvedSource = yield* resolveSource(source, { expectedType: "subagent" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid subagent source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const requestedOwner = parsedPattern?.type === "subagents"
-        ? Option.some(parsedPattern.owner)
-        : resolvedSource.type === "registry"
-            ? resolvedSource.owner
-            : Option.none();
-    const versionRange = resolvedSource.type === "registry" && parsedPattern?.type === "subagents"
-        ? Option.fromUndefinedOr(parsedPattern.versionRange)
-        : Option.none();
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "subagent",
-        owner: requestedOwner,
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "subagent")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured subagent "${name}"`,
-        suggestions: [
-            {
-                description: `Verify the configured source is reachable and still contains the subagent.`,
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.subagent.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured subagent "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: `Verify the configured source still contains the subagent or update axm.json.`,
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange: ref.refType === "registry" ? versionRange : Option.none(),
-    };
-});
-export const resolveConfiguredRule = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "rule",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "rule") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace rule resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "rule", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "rule") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-rule",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const providers = yield* SourceHostProviders;
-    const resolvedSource = yield* resolveSource(source, { expectedType: "rule" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid rule source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const requestedOwner = parsedPattern?.type === "rules"
-        ? Option.some(parsedPattern.owner)
-        : resolvedSource.type === "registry"
-            ? resolvedSource.owner
-            : Option.none();
-    const versionRange = resolvedSource.type === "registry" && parsedPattern?.type === "rules"
-        ? Option.fromUndefinedOr(parsedPattern.versionRange)
-        : Option.none();
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "rule",
-        owner: requestedOwner,
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "rule")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured rule "${name}"`,
-        suggestions: [
-            {
-                description: "Verify the configured source is reachable and still contains the rule.",
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.rule.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured rule "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: "Verify the configured source still contains the rule or update axm.json.",
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange: ref.refType === "registry" ? versionRange : Option.none(),
-    };
-});
-export const resolveConfiguredHook = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "hook",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "hook") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace hook resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "hook", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "hook") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-hook",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const providers = yield* SourceHostProviders;
-    const resolvedSource = yield* resolveSource(source, { expectedType: "hook" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid hook source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const requestedOwner = parsedPattern?.type === "hooks"
-        ? Option.some(parsedPattern.owner)
-        : resolvedSource.type === "registry"
-            ? resolvedSource.owner
-            : Option.none();
-    const versionRange = resolvedSource.type === "registry" && parsedPattern?.type === "hooks"
-        ? Option.fromUndefinedOr(parsedPattern.versionRange)
-        : Option.none();
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "hook",
-        owner: requestedOwner,
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "hook")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured hook "${name}"`,
-        suggestions: [
-            {
-                description: "Verify the configured source is reachable and still contains the hook.",
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.hook.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured hook "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: "Verify the configured source still contains the hook or update axm.json.",
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange: ref.refType === "registry" ? versionRange : Option.none(),
-    };
-});
-export const resolveConfiguredKnowledge = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "knowledge",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "knowledge") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace knowledge resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "knowledge", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "knowledge") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned non-knowledge content",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const providers = yield* SourceHostProviders;
-    const resolvedSource = yield* resolveSource(source, { expectedType: "knowledge" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid knowledge source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const parsedPattern = parseSourceQualifiedRegistrySourcePatternParts(source);
-    const requestedOwner = parsedPattern?.type === "knowledge"
-        ? Option.some(parsedPattern.owner)
-        : resolvedSource.type === "registry"
-            ? resolvedSource.owner
-            : Option.none();
-    const versionRange = resolvedSource.type === "registry" && parsedPattern?.type === "knowledge"
-        ? Option.fromUndefinedOr(parsedPattern.versionRange)
-        : Option.none();
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "knowledge",
-        owner: requestedOwner,
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "knowledge")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured knowledge bundle "${name}"`,
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.knowledge.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured knowledge bundle "${name}" could not be found in its source`,
-        });
-    }
-    return {
-        ref,
-        versionRange: ref.refType === "registry" ? versionRange : Option.none(),
-    };
-});
-export const resolveConfiguredMcpServer = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "mcp-server",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "mcp-server") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace MCP server resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "mcp-server", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "mcp-server") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-MCP-server",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const parsed = parseRegistrySourceRef(source);
-    if (parsed === undefined || parsed.type !== "mcps" || parsed.name !== name) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `The configured MCP server entry "${name}" is invalid.`,
-            suggestions: [{ description: `Use a name like "@owner/mcps/name".` }],
-        });
-    }
-    const providers = yield* SourceHostProviders;
-    const versionRange = Option.fromUndefinedOr(parsed.versionRange);
-    const resolvedSource = yield* resolveSource(source, { expectedType: "mcp-server" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid MCP server source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const refs = yield* providers
-        .find(resolvedSource, {
-        names: [name],
-        type: "mcp-server",
-        owner: Option.some(parsed.owner),
-        versionRange,
-    })
-        .pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "mcp-server")), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured MCP server "${name}"`,
-        suggestions: [
-            {
-                description: `Verify the configured registry source is reachable and still contains the MCP server.`,
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.server.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured MCP server "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: `Verify the configured source still contains the MCP server or update axm.json.`,
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange,
-    };
-});
-export const resolveConfiguredPack = (name, source, releaseAgeEvaluation) => Effect.gen(function* () {
-    if (isWorkspaceSourceLocator(source)) {
-        const ws = yield* WorkspaceMutations;
-        const ref = yield* resolveWorkspaceExtensionRef({
-            settingsName: name,
-            source,
-            expectedType: "pack",
-            layout: ws.layout,
-            scope: ws.scope,
-        });
-        if (ref.type !== "pack") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: `Workspace pack resolution returned ${ref.type}`,
-            });
-        }
-        return { ref, versionRange: Option.none() };
-    }
-    const registry = yield* resolveConfiguredRegistryRef(name, source, "pack", releaseAgeEvaluation);
-    if (Option.isSome(registry)) {
-        if (registry.value.ref.type !== "pack") {
-            return yield* new ExtensionLifecycleFailed({
-                category: "internal",
-                detail: "Registry returned a non-pack",
-            });
-        }
-        return { ...registry.value, ref: registry.value.ref };
-    }
-    const parsed = parseRegistrySourceRef(source);
-    if (parsed === undefined || parsed.type !== "packs" || parsed.name !== name) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "validation",
-            detail: `The configured pack entry "${name}" is invalid.`,
-            suggestions: [{ description: `Use a name like "@owner/packs/name".` }],
-        });
-    }
-    const providers = yield* SourceHostProviders;
-    const versionRange = Option.fromUndefinedOr(parsed.versionRange);
-    const resolvedSource = yield* resolveSource(source, { expectedType: "pack" }).pipe(Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "validation",
-        detail: `Invalid pack source for ${name}: ${cause.detail}`,
-        cause,
-    })));
-    const findWith = (candidate) => providers.find(candidate, {
-        names: [name],
-        type: "pack",
-        owner: Option.some(parsed.owner),
-        versionRange,
-    });
-    const refs = yield* findWith(resolvedSource).pipe(Effect.map((entries) => entries.filter((entry) => entry.type === "pack")), Effect.catch((error) => resolvedSource.type === "registry"
-        ? Effect.gen(function* () {
-            const ws = yield* WorkspaceMutations;
-            const registryHosts = yield* ws.getRegistrySourceHosts();
-            const fallbackSources = registryHosts
-                .filter((host) => host.location.protocol === "file:")
-                .map((host) => ({
-                type: "registry",
-                name: host.name,
-                location: host.location,
-                owner: Option.some(parsed.owner),
-            }));
-            for (const fallback of fallbackSources) {
-                if (fallback.location.href === resolvedSource.location.href) {
-                    continue;
-                }
-                const fallbackResult = yield* findWith(fallback).pipe(Effect.result);
-                if (fallbackResult._tag === "Success" && fallbackResult.success.length > 0) {
-                    return fallbackResult.success.filter((entry) => entry.type === "pack");
-                }
-            }
-            return yield* error;
-        })
-        : Effect.fail(error)), Effect.mapError((cause) => new ExtensionLifecycleFailed({
-        category: "internal",
-        detail: `Failed to resolve configured pack "${name}"`,
-        suggestions: [
-            {
-                description: "Verify the configured registry source is reachable and still contains the pack.",
-            },
-        ],
-        cause,
-    })));
-    const ref = refs.find((entry) => entry.pack.name === name);
-    if (ref === undefined) {
-        return yield* new ExtensionLifecycleFailed({
-            category: "not_found",
-            detail: `Configured pack "${name}" could not be found in its source`,
-            suggestions: [
-                {
-                    description: "Verify the configured source still contains the pack or update axm.json.",
-                },
-            ],
-        });
-    }
-    return {
-        ref,
-        versionRange,
-    };
-});
-//# sourceMappingURL=configured-entry-resolution.js.map