@agentxm/extension-lifecycle 0.28.11 → 0.28.13

package/dist/src/install/install-extensions.js

@@ -0,0 +1,282 @@
+/**
+ * Installing extensions.
+ *
+ * One use case behind seventeen command spellings. `axm install` with a
+ * registry FQN, `axm <type> install <source>`, `axm install <locator>`, and
+ * either form with no source at all are the same decision with different
+ * amounts already known: which type, which source, which versions, and which
+ * of a source's contents the person wants.
+ *
+ * `prepare` settles all of that and writes nothing. The locator form is the
+ * reason it must: a locator can carry skills, rules, hooks, knowledge bundles
+ * and subagents at once, and each is an independent closure inside one
+ * prepared candidate — so the preview shows the whole set, one type failing
+ * leaves the others committed, and the operation reports every outcome.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { operationPresentation, prepareExecutionCandidate, resolveExecutionCandidate, } from "@agentxm/workspace-operations";
+import { withPublisherTrust } from "../publisher-binding.js";
+import { planHookInstall } from "../hooks/install/plan.js";
+import { discoverHookRefs, finalizeHookInstallIntent, parseHookInstallRequest, } from "../hooks/install/plan.js";
+import { discoverKnowledgeRefs, finalizeKnowledgeInstallIntent, parseKnowledgeInstallRequest, planKnowledgeInstall, } from "../knowledge/install/plan.js";
+import { discoverMcpServerRefs, finalizeMcpServerInstallIntent, parseMcpServerInstallRequest, planMcpServerInstall, resolveMcpServerSourceRequest, } from "../mcps/install/plan.js";
+import { discoverPackRef, finalizePackInstallIntent, packDiscoveryDiagnostics, parsePackInstallRequest, planPackInstall, resolvePackSourceRequest, } from "../packs/install/plan.js";
+import { discoverRuleRefs, finalizeRuleInstallIntent, parseRuleInstallRequest, planRuleInstall, } from "../rules/install/plan.js";
+import { discoverSkillRefs, finalizeSkillInstallIntent, parseSkillInstallRequest, planSkillInstall, buildCompanionPackagesSection, } from "../skills/install/plan.js";
+import { discoverSubagentRefs, finalizeSubagentInstallIntent, parseSubagentInstallRequest, planSubagentInstall, } from "../subagents/install/plan.js";
+import { BundledAxmSkillAsset, planBundledAxmSkillInstall } from "../skills/install/bundled.js";
+import { buildConfiguredInstallPlan } from "./configured.js";
+import { formatRegistryProbe } from "./registry-source-resolution.js";
+import { resolveRootInstallIntent } from "./root-intent.js";
+import { ExtensionSelectionInteraction } from "./selection-interaction.js";
+import { installRefused, } from "./vocabulary.js";
+const EMPTY_DIAGNOSTICS = { resolutionLines: [], companionPackages: [] };
+const emptyPlan = (request) => ({
+    _tag: "Plan",
+    name: request.planName,
+    description: request.planDescription,
+    presentation: operationPresentation({ imperative: "install", past: "Installed", gerund: "Installing" }, Option.getOrUndefined(request.type)),
+    jobs: [{ concurrency: 1, steps: [] }],
+});
+const planForType = (type, source, request) => {
+    switch (type) {
+        case "skill":
+            return Effect.gen(function* () {
+                const parsed = yield* parseSkillInstallRequest({
+                    source,
+                    skills: request.names,
+                    all: request.all,
+                    force: request.reinstall,
+                    nonInteractive: request.nonInteractive,
+                }).pipe(Effect.mapError((cause) => cause._tag === "ExtensionLifecycleFailed"
+                    ? cause
+                    : installRefused({
+                        category: "validation",
+                        detail: `Skill source "${source}" could not be resolved`,
+                        cause,
+                    })));
+                const discovered = yield* discoverSkillRefs(parsed);
+                const intent = yield* finalizeSkillInstallIntent(parsed, discovered);
+                const plan = yield* planSkillInstall(intent);
+                const companions = buildCompanionPackagesSection(intent.skillsToInstall.map((entry) => entry.ref));
+                return {
+                    plan,
+                    diagnostics: {
+                        resolutionLines: [
+                            ...(parsed.resolutionProbes.length > 0
+                                ? [`Resolution: ${parsed.resolutionProbes.map(formatRegistryProbe).join("; ")}`]
+                                : []),
+                            `Found ${discovered.length} skill${discovered.length === 1 ? "" : "s"}`,
+                        ],
+                        companionPackages: companions === undefined ? [] : companions.items,
+                    },
+                };
+            });
+        case "subagent":
+            return Effect.gen(function* () {
+                const parsed = yield* parseSubagentInstallRequest({
+                    source,
+                    subagents: request.names,
+                    all: request.all,
+                    nonInteractive: request.nonInteractive,
+                }).pipe(Effect.mapError((cause) => cause._tag === "ExtensionLifecycleFailed"
+                    ? cause
+                    : installRefused({
+                        category: "validation",
+                        detail: `Subagent source "${source}" could not be resolved`,
+                        cause,
+                    })));
+                const discovered = yield* discoverSubagentRefs(parsed);
+                const intent = yield* finalizeSubagentInstallIntent(parsed, discovered);
+                return {
+                    plan: yield* planSubagentInstall(intent),
+                    diagnostics: {
+                        resolutionLines: [
+                            ...(parsed.resolutionProbes.length > 0
+                                ? [`Resolution: ${parsed.resolutionProbes.map(formatRegistryProbe).join("; ")}`]
+                                : []),
+                            `Found ${discovered.length} subagent${discovered.length === 1 ? "" : "s"}`,
+                        ],
+                        companionPackages: [],
+                    },
+                };
+            });
+        case "rule":
+            return Effect.gen(function* () {
+                const parsed = yield* parseRuleInstallRequest(source);
+                const intent = yield* finalizeRuleInstallIntent(parsed, yield* discoverRuleRefs(parsed));
+                return { plan: yield* planRuleInstall(intent), diagnostics: EMPTY_DIAGNOSTICS };
+            });
+        case "hook":
+            return Effect.gen(function* () {
+                const parsed = yield* parseHookInstallRequest(source);
+                const intent = yield* finalizeHookInstallIntent(parsed, yield* discoverHookRefs(parsed));
+                return { plan: yield* planHookInstall(intent), diagnostics: EMPTY_DIAGNOSTICS };
+            });
+        case "knowledge":
+            return Effect.gen(function* () {
+                const parsed = yield* parseKnowledgeInstallRequest(source);
+                const intent = yield* finalizeKnowledgeInstallIntent(parsed, yield* discoverKnowledgeRefs(parsed));
+                return { plan: yield* planKnowledgeInstall(intent), diagnostics: EMPTY_DIAGNOSTICS };
+            });
+        case "mcp-server":
+            return Effect.gen(function* () {
+                const parsed = yield* parseMcpServerInstallRequest({
+                    source,
+                    localName: request.localName,
+                    env: request.env,
+                    force: request.reinstall,
+                    nonInteractive: request.nonInteractive,
+                });
+                const sourceRequest = yield* resolveMcpServerSourceRequest(parsed);
+                const intent = yield* finalizeMcpServerInstallIntent(parsed, yield* discoverMcpServerRefs(sourceRequest));
+                return { plan: yield* planMcpServerInstall(intent), diagnostics: EMPTY_DIAGNOSTICS };
+            });
+        case "pack":
+            return Effect.gen(function* () {
+                const parsed = yield* parsePackInstallRequest({
+                    source,
+                    nonInteractive: request.nonInteractive,
+                });
+                const sourceRequest = yield* resolvePackSourceRequest(parsed);
+                const discovery = yield* discoverPackRef(sourceRequest);
+                const intent = finalizePackInstallIntent(parsed, discovery);
+                return {
+                    plan: yield* planPackInstall(intent),
+                    diagnostics: {
+                        resolutionLines: packDiscoveryDiagnostics(sourceRequest, discovery),
+                        companionPackages: [],
+                    },
+                };
+            });
+    }
+};
+/** The types a locator can carry, in the order a locator install reports them. */
+const LOCATOR_TYPES = ["skill", "rule", "hook", "knowledge", "subagent"];
+const isNoMatch = (failure) => failure._tag === "ExtensionLifecycleFailed" &&
+    (failure.category === "not_found" || failure.category === "usage");
+/**
+ * A locator names a place, not a type. Each installable type is offered the
+ * source and the ones that find nothing there simply do not contribute; if no
+ * type matches, the locator held nothing AXM can install.
+ */
+const planLocatorInstall = (source, request) => Effect.gen(function* () {
+    const attempts = yield* Effect.forEach(LOCATOR_TYPES, (type) => planForType(type, source, request).pipe(Effect.map((planned) => Option.some({ type, ...planned })), Effect.catch((failure) => isNoMatch(failure)
+        ? Effect.succeed(Option.none())
+        : Effect.fail(failure))), { concurrency: 1 });
+    const matched = attempts.flatMap((attempt) => (Option.isSome(attempt) ? [attempt.value] : []));
+    if (matched.length === 0) {
+        return yield* installRefused({
+            category: "not_found",
+            detail: "No locator-discoverable extensions found in source (supported: skills, rules, hooks, knowledge, and subagents)",
+        });
+    }
+    // Every matched type is one independent closure inside a single
+    // candidate: the preview shows all of them, and each settles on its own.
+    const steps = matched.flatMap(({ plan }) => plan.jobs.flatMap((job) => job.steps));
+    return {
+        types: matched.map(({ type }) => type),
+        plan: {
+            _tag: "Plan",
+            name: request.planName,
+            description: request.planDescription,
+            presentation: operationPresentation({
+                imperative: "install",
+                past: "Installed",
+                gerund: "Installing",
+            }),
+            jobs: [{ concurrency: 1, steps, executionPolicy: "best-effort" }],
+        },
+        diagnostics: {
+            resolutionLines: matched.flatMap(({ diagnostics }) => diagnostics.resolutionLines),
+            companionPackages: [
+                ...new Set(matched.flatMap(({ diagnostics }) => diagnostics.companionPackages)),
+            ],
+        },
+        configuredAgentOperations: [],
+        emptyMessage: Option.none(),
+    };
+});
+const planRequest = (request) => Effect.gen(function* () {
+    if (request.subject.kind === "bundled") {
+        return {
+            types: ["skill"],
+            plan: yield* planBundledAxmSkillInstall,
+            diagnostics: EMPTY_DIAGNOSTICS,
+            configuredAgentOperations: [],
+            emptyMessage: Option.none(),
+        };
+    }
+    if (request.subject.kind === "configured") {
+        const result = yield* buildConfiguredInstallPlan({
+            type: request.type,
+            planName: request.planName,
+            planDescription: request.planDescription,
+            nonInteractive: request.nonInteractive,
+        });
+        if (result._tag === "NoConfiguredExtensions") {
+            return {
+                types: Option.toArray(request.type),
+                plan: emptyPlan(request),
+                diagnostics: EMPTY_DIAGNOSTICS,
+                configuredAgentOperations: [],
+                emptyMessage: Option.some(result.message),
+            };
+        }
+        return {
+            types: Option.toArray(request.type),
+            plan: result.plan,
+            diagnostics: EMPTY_DIAGNOSTICS,
+            configuredAgentOperations: result.configuredAgentOperations,
+            emptyMessage: Option.none(),
+        };
+    }
+    const source = request.subject.source;
+    const type = yield* Option.match(request.type, {
+        onSome: (value) => Effect.succeed(value),
+        onNone: () => resolveRootInstallIntent(source).pipe(Effect.map((intent) => intent.type)),
+    });
+    if (type === "locator")
+        return yield* planLocatorInstall(source, request);
+    const { plan, diagnostics } = yield* planForType(type, source, request);
+    return {
+        types: [type],
+        plan: { ...plan, name: plan.name },
+        diagnostics,
+        configuredAgentOperations: [],
+        emptyMessage: Option.none(),
+    };
+});
+// -----------------------------------------------------------------------------
+// prepare
+// -----------------------------------------------------------------------------
+/** Settle an install without writing anything. */
+export const prepareInstallExtensions = Effect.fn("InstallExtensions.prepare")(function* (request) {
+    const planned = yield* planRequest(request);
+    // Every acceptance a plan proposes is classified against the accepted
+    // resolution here, so the root, per-type, locator, and configured routes
+    // share one publisher-trust rule instead of restating it five times.
+    const trusted = yield* withPublisherTrust(planned.plan);
+    const execution = yield* prepareExecutionCandidate(trusted, {
+        configuredAgentOperations: planned.configuredAgentOperations,
+    });
+    return {
+        types: planned.types,
+        empty: Option.isSome(planned.emptyMessage),
+        emptyMessage: planned.emptyMessage,
+        diagnostics: planned.diagnostics,
+        planName: trusted.name,
+        execution,
+    };
+});
+/** Preview or apply a settled install, resolving to one operation outcome. */
+export const previewOrApplyInstallExtensions = (candidate, execution) => resolveExecutionCandidate(candidate.execution, execution);
+/** The install use case: settle a request, then preview or apply it. */
+export const InstallExtensions = {
+    prepare: prepareInstallExtensions,
+    previewOrApply: previewOrApplyInstallExtensions,
+};
+//# sourceMappingURL=install-extensions.js.map

package/dist/src/install/per-type-install.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Per-type install command guidance.
+ *
+ * Every extension type group registers an `install` subcommand, so the segment
+ * list and the command spelling both come straight from the type table.
+ */
+import { type ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+/** Plural type segments whose command group exposes an `install` subcommand. */
+export declare const perTypeInstallPluralSegments: ReadonlyArray<string>;
+/** The install command that resolves for `type`, given an FQN or source. */
+export declare const installCommandFor: (type: ExtensionType, source: string) => string;
+//# sourceMappingURL=per-type-install.d.ts.map

package/dist/src/install/per-type-install.js

@@ -0,0 +1,12 @@
+/**
+ * Per-type install command guidance.
+ *
+ * Every extension type group registers an `install` subcommand, so the segment
+ * list and the command spelling both come straight from the type table.
+ */
+import { extensionTypePluralSegments, extensionTypeToPlural, } from "@agentxm/extension-model/unstable/extensions";
+/** Plural type segments whose command group exposes an `install` subcommand. */
+export const perTypeInstallPluralSegments = extensionTypePluralSegments;
+/** The install command that resolves for `type`, given an FQN or source. */
+export const installCommandFor = (type, source) => `axm ${extensionTypeToPlural[type]} install ${source}`;
+//# sourceMappingURL=per-type-install.js.map

package/dist/src/install/registry-install-target.d.ts

@@ -0,0 +1,35 @@
+import * as Result from "effect/Result";
+import { type ExtensionName, type ExtensionType, type Handle } from "@agentxm/extension-model/unstable/extensions";
+import { type VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+export interface BareRegistryInstallTarget {
+    readonly kind: "bare-name";
+    readonly name: ExtensionName;
+    readonly versionRange?: VersionRange | undefined;
+}
+export interface QualifiedRegistryInstallTarget {
+    readonly kind: "registry";
+    readonly owner: Handle;
+    readonly type: ExtensionType;
+    readonly name: ExtensionName;
+    readonly versionRange?: VersionRange | undefined;
+}
+export type RegistryInstallTarget = BareRegistryInstallTarget | QualifiedRegistryInstallTarget;
+export type RegistryInstallTargetParseError = {
+    readonly kind: "missing-name";
+} | {
+    readonly kind: "wrong-type";
+    readonly actualType?: ExtensionType | undefined;
+} | {
+    readonly kind: "invalid-bare-name";
+} | {
+    readonly kind: "invalid-version-constraint";
+} | {
+    readonly kind: "not-registry";
+};
+export interface ParseRegistryInstallTargetOptions {
+    readonly expectedType: ExtensionType;
+    readonly allowBareName: boolean;
+    readonly allowBareVersionRange?: boolean | undefined;
+}
+export declare const parseRegistryInstallTarget: (input: string, options: ParseRegistryInstallTargetOptions) => Result.Result<RegistryInstallTarget, RegistryInstallTargetParseError>;
+//# sourceMappingURL=registry-install-target.d.ts.map

package/dist/src/install/registry-install-target.js

@@ -0,0 +1,66 @@
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { ExtensionNameSchema, parseSourceQualifiedRegistrySourcePatternParts, toExtensionType, } from "@agentxm/extension-model/unstable/extensions";
+import { VersionRangeSchema, } from "@agentxm/extension-model/unstable/version-constraints";
+const decodeExtensionName = Schema.decodeUnknownResult(ExtensionNameSchema);
+const decodeVersionRange = Schema.decodeUnknownResult(VersionRangeSchema);
+const parseBareName = (input, options) => {
+    if (input.startsWith("@")) {
+        return Result.fail({ kind: "not-registry" });
+    }
+    const atIndex = input.indexOf("@");
+    const rawName = atIndex === -1 ? input : input.slice(0, atIndex);
+    const rawConstraint = atIndex === -1 ? undefined : input.slice(atIndex + 1);
+    if (rawConstraint !== undefined && !options.allowBareVersionRange) {
+        return Result.fail({ kind: "not-registry" });
+    }
+    const decodedName = decodeExtensionName(rawName);
+    if (Result.isFailure(decodedName)) {
+        return Result.fail({ kind: "invalid-bare-name" });
+    }
+    if (rawConstraint === undefined) {
+        return Result.succeed({
+            kind: "bare-name",
+            name: decodedName.success,
+        });
+    }
+    if (rawConstraint.length === 0) {
+        return Result.fail({ kind: "invalid-version-constraint" });
+    }
+    const decodedConstraint = decodeVersionRange(rawConstraint);
+    if (Result.isFailure(decodedConstraint)) {
+        return Result.fail({ kind: "invalid-version-constraint" });
+    }
+    return Result.succeed({
+        kind: "bare-name",
+        name: decodedName.success,
+        versionRange: decodedConstraint.success,
+    });
+};
+export const parseRegistryInstallTarget = (input, options) => {
+    const parsedRegistry = parseSourceQualifiedRegistrySourcePatternParts(input);
+    if (parsedRegistry !== undefined) {
+        const parsedSingularType = parsedRegistry.type !== undefined ? toExtensionType(parsedRegistry.type) : undefined;
+        if (parsedSingularType === undefined || parsedSingularType !== options.expectedType) {
+            return Result.fail({
+                kind: "wrong-type",
+                actualType: parsedSingularType,
+            });
+        }
+        if (parsedRegistry.name === undefined) {
+            return Result.fail({ kind: "missing-name" });
+        }
+        return Result.succeed({
+            kind: "registry",
+            owner: parsedRegistry.owner,
+            type: parsedSingularType,
+            name: parsedRegistry.name,
+            versionRange: parsedRegistry.versionRange,
+        });
+    }
+    if (!options.allowBareName) {
+        return Result.fail({ kind: "not-registry" });
+    }
+    return parseBareName(input, options);
+};
+//# sourceMappingURL=registry-install-target.js.map

package/dist/src/install/registry-login-suggestion.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The offline login hint an install refusal carries.
+ *
+ * When a registry lookup finds nothing, the extension may simply be private
+ * to an account this invocation is not signed in to. Whether every consulted
+ * origin already has a credential is the `registry-auth` capability's
+ * decision; the wording of the hint is this feature's.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+/**
+ * Suggest signing in when any consulted registry origin has no credential.
+ *
+ * The credential store and the default registry are optional: an invocation
+ * composed without them (a workspace with no registry configured) offers no
+ * hint rather than failing.
+ */
+export declare const registryLoginSuggestions: (locations: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<SuggestedAction>>;
+//# sourceMappingURL=registry-login-suggestion.d.ts.map

package/dist/src/install/registry-login-suggestion.js

@@ -0,0 +1,34 @@
+/**
+ * The offline login hint an install refusal carries.
+ *
+ * When a registry lookup finds nothing, the extension may simply be private
+ * to an account this invocation is not signed in to. Whether every consulted
+ * origin already has a credential is the `registry-auth` capability's
+ * decision; the wording of the hint is this feature's.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { CredentialStore, hasCredentialsForAll } from "@agentxm/registry-auth";
+import { RegistryUrl } from "@agentxm/registry-client";
+const LOGIN_SUGGESTION = {
+    description: "Sign in to check whether the extension is private.",
+    cmd: "axm login",
+};
+/**
+ * Suggest signing in when any consulted registry origin has no credential.
+ *
+ * The credential store and the default registry are optional: an invocation
+ * composed without them (a workspace with no registry configured) offers no
+ * hint rather than failing.
+ */
+export const registryLoginSuggestions = (locations) => Effect.gen(function* () {
+    const store = yield* Effect.serviceOption(CredentialStore);
+    const defaultRegistry = yield* Effect.serviceOption(RegistryUrl);
+    if (Option.isNone(store) || Option.isNone(defaultRegistry))
+        return [];
+    const present = yield* hasCredentialsForAll(locations, defaultRegistry.value).pipe(Effect.provideService(CredentialStore, store.value));
+    return present ? [] : [LOGIN_SUGGESTION];
+});
+//# sourceMappingURL=registry-login-suggestion.js.map

package/dist/src/install/registry-source-resolution.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Which configured registry supplies a skill or subagent named without one.
+ *
+ * A bare name or an unqualified `@owner/name` says nothing about which
+ * registry hosts it, so every configured host is probed in order and the
+ * first that answers wins. Each probe is recorded so the application can
+ * show, verbatim, which registries were consulted and what each one said.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { ExtensionName, ExtensionType, Handle } from "@agentxm/extension-model/unstable/extensions";
+import type { RegistrySource } from "@agentxm/extension-model/unstable/sources/types";
+import { type SourceResolutionFailure } from "@agentxm/extension-sources";
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+import type { ExtensionLifecycleFailed } from "../errors.js";
+import { type ResolveInstallRequirements } from "./vocabulary.js";
+/** How to declare a registry when none is configured for the requested owner. */
+export declare const ADD_REGISTRY_SOURCE: SuggestedAction;
+/** The two types whose bare names are resolved against configured registries. */
+export type InstallableRegistryType = Extract<ExtensionType, "skill" | "subagent">;
+/** What one configured registry host answered when it was consulted. */
+export interface RegistryLookupProbe {
+    readonly location: string;
+    readonly outcome: "matched" | "not-found" | "error";
+    readonly reason: Option.Option<string>;
+}
+export interface RegistryResolutionOptions {
+    readonly onRegistryProbe: (probe: RegistryLookupProbe) => void;
+}
+/** The sentence a source-resolution failure carries, for probe evidence. */
+export declare const sourceFailureDetail: (error: SourceResolutionFailure) => string;
+/** Render one probe as the line the application prints under `--verbose`. */
+export declare const formatRegistryProbe: (probe: RegistryLookupProbe) => string;
+/** Which configured registry to probe, for which extension. */
+export interface ConfiguredRegistryLookup {
+    readonly sourceName: string;
+    readonly owner: Handle;
+    readonly extensionType: InstallableRegistryType;
+    readonly extensionName: Option.Option<ExtensionName>;
+    readonly options: Option.Option<RegistryResolutionOptions>;
+}
+/** Probe every host configured under `sourceName` for the named extension. */
+export declare const resolveConfiguredRegistrySource: (args: ConfiguredRegistryLookup) => Effect.Effect<RegistrySource, ExtensionLifecycleFailed, ResolveInstallRequirements>;
+/** Which bare name to resolve against the default registry. */
+export interface DefaultRegistryLookup {
+    readonly name: string;
+    readonly extensionType: InstallableRegistryType;
+    readonly options: Option.Option<RegistryResolutionOptions>;
+}
+/** Resolve a bare name against the default `agentxm` registry and configured owner. */
+export declare const resolveDefaultRegistrySourceByName: (args: DefaultRegistryLookup) => Effect.Effect<RegistrySource, ExtensionLifecycleFailed, ResolveInstallRequirements>;
+//# sourceMappingURL=registry-source-resolution.d.ts.map