@agentxm/extension-lifecycle 0.28.4-bootstrap.0

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

@@ -0,0 +1,723 @@
+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 { LifecycleFailureAdapter } from "./failure-adapter.js";
+import { acceptedResolutionRef } from "@agentxm/workspace-state";
+import { resolveWorkspaceExtensionRef } from "@agentxm/workspace-state";
+export const makeConfiguredReleaseAgeEvaluation = (mode) => Effect.gen(function* () {
+    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}`,
+        });
+    }
+    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 (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 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 === name
+        ? Option.some({
+            version: ref.version,
+            publisherBindingId: ref.publisherBindingId,
+        })
+        : Option.none());
+    const providers = yield* SourceHostProviders;
+    const resolution = yield* providers.resolveNamedRegistry(resolvedSource, {
+        name,
+        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