@agentxm/extension-sources 0.28.4-bootstrap.0

package/dist/src/resolve-identifier.d.ts

@@ -0,0 +1,73 @@
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import { SourceNotResolvable, type SourceResolutionFailure } from "./errors.js";
+import { type CatalogExtensionType } from "@agentxm/extension-model/unstable/extension-types/schema";
+import { type ExtensionName, type Handle } from "@agentxm/extension-model/unstable/extensions";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+/**
+ * Every non-pack extension type an installed identifier can name. Packs are
+ * excluded because they are containers: a pack has no per-type lock map of its
+ * own to resolve a bare name against.
+ */
+export type IdentifierResourceType = CatalogExtensionType;
+export type IdentifierResolutionScope = "installed" | "registry" | "both";
+export interface ResolvedIdentifier {
+    readonly input: string;
+    readonly owner: Option.Option<Handle>;
+    readonly type: IdentifierResourceType;
+    readonly name: ExtensionName;
+    readonly fqn: string;
+    readonly installedName: Option.Option<string>;
+    readonly registryLocation: Option.Option<URL>;
+    readonly registrySourceName: Option.Option<string>;
+    readonly source: "installed" | "registry" | "passthrough";
+}
+export interface ResolveIdentifierArgs {
+    readonly input: string;
+    readonly resourceType: IdentifierResourceType;
+    readonly scope: IdentifierResolutionScope;
+    readonly registrySourceName: string;
+}
+export declare const resolveIdentifier: (args: ResolveIdentifierArgs) => Effect.Effect<{
+    input: string;
+    owner: Option.Option<string & import("effect/Brand").Brand<"Handle">>;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge";
+    name: string & import("effect/Brand").Brand<"ExtensionName">;
+    fqn: string;
+    installedName: Option.Option<string>;
+    registryLocation: Option.Option<URL>;
+    registrySourceName: Option.Option<string>;
+    source: "registry" | "installed";
+} | {
+    input: string;
+    owner: Option.Option<string & import("effect/Brand").Brand<"Handle">>;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge";
+    name: string & import("effect/Brand").Brand<"ExtensionName">;
+    fqn: string;
+    installedName: Option.Option<string & import("effect/Brand").Brand<"ExtensionName">>;
+    registryLocation: Option.Option<URL>;
+    registrySourceName: Option.Option<string>;
+    source: "passthrough";
+}, SourceResolutionFailure, FileSystem.FileSystem | Path.Path | WorkspaceCatalog | HttpClient.HttpClient>;
+export declare const resolveInstalledIdentifier: (args: {
+    readonly input: string;
+    readonly resourceType: IdentifierResourceType;
+}) => Effect.Effect<{
+    input: string;
+    owner: Option.Option<string & import("effect/Brand").Brand<"Handle">>;
+    type: "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge";
+    name: string & import("effect/Brand").Brand<"ExtensionName">;
+    fqn: string;
+    installedName: Option.Option<string>;
+    registryLocation: Option.Option<URL>;
+    registrySourceName: Option.Option<string>;
+    source: "registry" | "installed";
+}, SourceResolutionFailure, WorkspaceCatalog>;
+export declare const resolveInstalledIdentifierNameOrInput: (args: {
+    readonly input: string;
+    readonly resourceType: IdentifierResourceType;
+}) => Effect.Effect<string, import("./axm-skill-gate.ts").AxmSkillGateUnavailable | import("./workspace-catalog.js").WorkspaceCatalogUnavailable | import("./errors.js").SourceSyntaxInvalid | import("./errors.js").SourceHostNotConfigured | SourceNotResolvable | import("./errors.js").SourceNetworkFailure | import("./errors.js").GitOperationFailed | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed, WorkspaceCatalog>;
+//# sourceMappingURL=resolve-identifier.d.ts.map

package/dist/src/resolve-identifier.js

@@ -0,0 +1,273 @@
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { SourceNotResolvable, sourceResolutionFailureCategory, } from "./errors.js";
+import { isCatalogExtensionType, } from "@agentxm/extension-model/unstable/extension-types/schema";
+import { decodeExtensionNameSync, extensionTypePluralSentenceLabels, formatFqn, parseExtensionFqnParts, parseSourceQualifiedRegistrySourcePatternParts, toExtensionTypePlural, } from "@agentxm/extension-model/unstable/extensions";
+import { createRegistryClient } from "@agentxm/registry-client";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+const isIdentifierResourceType = (type) => isCatalogExtensionType(type);
+const decodeName = (input) => Effect.try({
+    try: () => decodeExtensionNameSync(input),
+    catch: () => new SourceNotResolvable({
+        category: "not_found",
+        detail: `No ${input} identifier could be resolved`,
+        suggestions: [
+            {
+                description: "Use a valid bare name, or use a fully-qualified name like @owner/skills/name.",
+            },
+        ],
+    }),
+});
+const makeCandidate = (parts, installedName, source) => ({
+    owner: Option.some(parts.owner),
+    type: parts.type,
+    name: parts.name,
+    fqn: formatFqn(parts),
+    installedName,
+    registryLocation: Option.none(),
+    registrySourceName: Option.none(),
+    source,
+});
+const configuredSourceParts = (resourceType, source) => {
+    const parsed = parseSourceQualifiedRegistrySourcePatternParts(source);
+    if (parsed === undefined || parsed.name === undefined)
+        return Option.none();
+    if (parsed.type !== undefined && parsed.type !== toExtensionTypePlural(resourceType)) {
+        return Option.none();
+    }
+    return Option.some({
+        owner: parsed.owner,
+        type: resourceType,
+        name: parsed.name,
+    });
+};
+const matchesInput = (input, candidate) => candidate.fqn === input ||
+    candidate.name === input ||
+    (Option.isSome(candidate.installedName) && candidate.installedName.value === input);
+const dedupeCandidates = (candidates) => {
+    const deduped = [];
+    const chooseCandidate = (existing, next) => {
+        if (Option.isNone(existing.owner) && Option.isSome(next.owner))
+            return next;
+        return existing;
+    };
+    for (const candidate of candidates) {
+        if (Option.isSome(candidate.installedName)) {
+            const candidateInstalledName = candidate.installedName.value;
+            const existingIndex = deduped.findIndex((entry) => Option.isSome(entry.installedName) &&
+                entry.installedName.value === candidateInstalledName);
+            const existing = deduped[existingIndex];
+            if (existing !== undefined) {
+                deduped[existingIndex] = chooseCandidate(existing, candidate);
+                continue;
+            }
+        }
+        const existingFqnIndex = deduped.findIndex((entry) => entry.fqn === candidate.fqn);
+        const existingFqn = deduped[existingFqnIndex];
+        if (existingFqn !== undefined) {
+            deduped[existingFqnIndex] = chooseCandidate(existingFqn, candidate);
+            continue;
+        }
+        deduped.push(candidate);
+    }
+    return deduped;
+};
+const installedCandidates = (input, resourceType) => Effect.gen(function* () {
+    const catalog = yield* WorkspaceCatalog;
+    const candidates = [];
+    const graph = yield* catalog.desiredExtensionGraph;
+    if (!graph.complete) {
+        return yield* new SourceNotResolvable({
+            category: "conflict",
+            detail: "The desired extension graph is incomplete, so installed identifiers cannot be resolved safely.",
+            suggestions: [
+                {
+                    description: "Repair or reinstall the configured packs, then retry.",
+                    cmd: "axm sync",
+                },
+            ],
+        });
+    }
+    for (const node of graph.nodes) {
+        if (node.type !== resourceType)
+            continue;
+        if (node.source === undefined)
+            continue;
+        const graphIdentity = node.identity.startsWith("workspace:")
+            ? node.identity.slice("workspace:".length)
+            : node.identity;
+        const parsedIdentity = parseExtensionFqnParts(graphIdentity);
+        const parts = parsedIdentity !== undefined && parsedIdentity.type === resourceType
+            ? Option.some({
+                owner: parsedIdentity.owner,
+                type: resourceType,
+                name: parsedIdentity.name,
+            })
+            : configuredSourceParts(resourceType, node.source);
+        if (Option.isSome(parts)) {
+            candidates.push(makeCandidate(parts.value, Option.some(node.name), "installed"));
+        }
+        else if (node.name === input) {
+            const decodedName = yield* decodeName(node.name);
+            candidates.push({
+                owner: Option.none(),
+                type: resourceType,
+                name: decodedName,
+                fqn: node.name,
+                installedName: Option.some(node.name),
+                registryLocation: Option.none(),
+                registrySourceName: Option.none(),
+                source: "installed",
+            });
+        }
+    }
+    return dedupeCandidates(candidates).filter((candidate) => matchesInput(input, candidate));
+});
+const registryCandidates = (input, resourceType, registrySourceName) => Effect.gen(function* () {
+    const name = yield* decodeName(input);
+    const catalog = yield* WorkspaceCatalog;
+    const registrySources = (yield* catalog.registrySourceHosts).filter((source) => source.name === registrySourceName);
+    const results = yield* Effect.forEach(registrySources, (sourceConfig) => Effect.gen(function* () {
+        const location = sourceConfig.location.protocol === "file:"
+            ? sourceConfig.location.pathname
+            : sourceConfig.location.href;
+        const client = yield* createRegistryClient(location);
+        const result = yield* client.getExtensionsByScope({
+            owner: "*",
+            names: [name],
+            types: [resourceType],
+            limit: Option.none(),
+            offset: 0,
+        });
+        return result.extensions.map((entry) => ({
+            ...makeCandidate({
+                owner: entry.owner,
+                type: resourceType,
+                name: entry.name,
+            }, Option.none(), "registry"),
+            registryLocation: Option.some(sourceConfig.location),
+            registrySourceName: Option.some(sourceConfig.name),
+        }));
+    }).pipe(Effect.result), { concurrency: "unbounded" });
+    return dedupeCandidates(Array.flatten(Array.getSuccesses(results).map((result) => result.filter((candidate) => candidate.name === name))));
+});
+const notFound = (input, resourceType, scope) => new SourceNotResolvable({
+    category: "not_found",
+    detail: `"${input}" did not match any ${extensionTypePluralSentenceLabels[toExtensionTypePlural(resourceType)]} in ${scope} scope`,
+    suggestions: [{ description: "Check the name, or re-run with a fully-qualified name." }],
+});
+const ambiguous = (input, resourceType, scope, candidates) => new SourceNotResolvable({
+    category: "internal",
+    detail: `"${input}" matches more than one ${scope} ${extensionTypePluralSentenceLabels[toExtensionTypePlural(resourceType)]}: ${candidates.map((candidate) => candidate.fqn).join(", ")}`,
+    suggestions: [{ description: "Re-run with the fully-qualified name." }],
+});
+const resolveFromCandidates = (input, resourceType, scope, candidates) => Effect.gen(function* () {
+    if (candidates.length === 0) {
+        return yield* notFound(input, resourceType, scope);
+    }
+    if (candidates.length > 1) {
+        return yield* ambiguous(input, resourceType, scope, candidates);
+    }
+    const [candidate] = candidates;
+    if (candidate === undefined) {
+        return yield* notFound(input, resourceType, scope);
+    }
+    return {
+        input,
+        owner: candidate.owner,
+        type: candidate.type,
+        name: candidate.name,
+        fqn: candidate.fqn,
+        installedName: candidate.installedName,
+        registryLocation: candidate.registryLocation,
+        registrySourceName: candidate.registrySourceName,
+        source: candidate.source,
+    };
+});
+export const resolveIdentifier = (args) => Effect.gen(function* () {
+    const trimmed = args.input.trim();
+    const parsed = parseExtensionFqnParts(trimmed);
+    if (parsed !== undefined) {
+        if (!isIdentifierResourceType(parsed.type) || parsed.type !== args.resourceType) {
+            return yield* new SourceNotResolvable({
+                category: "not_found",
+                detail: `"${trimmed}" is not a ${args.resourceType} identifier`,
+                suggestions: [
+                    {
+                        description: `Use a ${args.resourceType} identifier like @owner/${toExtensionTypePlural(args.resourceType)}/name.`,
+                    },
+                ],
+            });
+        }
+        if (args.scope === "installed" || args.scope === "both") {
+            const installed = yield* installedCandidates(trimmed, args.resourceType);
+            if (installed.length > 0) {
+                return yield* resolveFromCandidates(trimmed, args.resourceType, "installed", installed);
+            }
+            if (args.scope === "installed") {
+                return yield* notFound(trimmed, args.resourceType, args.scope);
+            }
+        }
+        return {
+            input: trimmed,
+            owner: Option.some(parsed.owner),
+            type: args.resourceType,
+            name: parsed.name,
+            fqn: formatFqn(parsed),
+            installedName: Option.some(parsed.name),
+            registryLocation: Option.none(),
+            registrySourceName: Option.some(args.registrySourceName),
+            source: "passthrough",
+        };
+    }
+    switch (args.scope) {
+        case "installed": {
+            const candidates = yield* installedCandidates(trimmed, args.resourceType);
+            return yield* resolveFromCandidates(trimmed, args.resourceType, args.scope, candidates);
+        }
+        case "registry": {
+            const candidates = yield* registryCandidates(trimmed, args.resourceType, args.registrySourceName);
+            return yield* resolveFromCandidates(trimmed, args.resourceType, args.scope, candidates);
+        }
+        case "both": {
+            const installed = yield* installedCandidates(trimmed, args.resourceType);
+            if (installed.length > 0) {
+                return yield* resolveFromCandidates(trimmed, args.resourceType, "installed", installed);
+            }
+            const registry = yield* registryCandidates(trimmed, args.resourceType, args.registrySourceName);
+            return yield* resolveFromCandidates(trimmed, args.resourceType, "registry", registry);
+        }
+    }
+});
+export const resolveInstalledIdentifier = (args) => Effect.gen(function* () {
+    const trimmed = args.input.trim();
+    const parsed = parseExtensionFqnParts(trimmed);
+    if (parsed !== undefined) {
+        if (!isIdentifierResourceType(parsed.type) || parsed.type !== args.resourceType) {
+            return yield* new SourceNotResolvable({
+                category: "not_found",
+                detail: `"${trimmed}" is not a ${args.resourceType} identifier`,
+                suggestions: [
+                    {
+                        description: `Use a ${args.resourceType} identifier like @owner/${toExtensionTypePlural(args.resourceType)}/name.`,
+                    },
+                ],
+            });
+        }
+    }
+    const candidates = yield* installedCandidates(trimmed, args.resourceType);
+    return yield* resolveFromCandidates(trimmed, args.resourceType, "installed", candidates);
+});
+export const resolveInstalledIdentifierNameOrInput = (args) => Effect.gen(function* () {
+    const trimmed = args.input.trim();
+    const result = yield* Effect.result(resolveInstalledIdentifier(args));
+    if (Result.isFailure(result)) {
+        if (sourceResolutionFailureCategory(result.failure) === "not_found")
+            return trimmed;
+        return yield* result.failure;
+    }
+    return Option.getOrElse(result.success.installedName, () => result.success.name);
+});
+//# sourceMappingURL=resolve-identifier.js.map

package/dist/src/resolve-source-pattern.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Multi-source pattern resolution: handles both single sources and glob patterns.
+ *
+ * Wraps `resolveSource` for single inputs and expands globs against all known
+ * skills (locked, configured, and on-disk) to resolve multiple sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import { type SourceResolutionFailure } from "./errors.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+import type { Source } from "@agentxm/extension-model/unstable/sources/types";
+/**
+ * Resolve a source pattern into one or more `Source` values.
+ *
+ * - Single input (name, path, URL, etc.) → delegates to `resolveSource`, returns single-element array
+ * - Glob pattern (e.g. `effect-*`) → expands against locked, configured, and on-disk skills
+ *
+ * For single name inputs, includes fallbacks to configured skills and on-disk discovery
+ * when the skill is not in the lockfile.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const resolveSourcePattern: (input: string) => Effect.Effect<ReadonlyArray<Source>, SourceResolutionFailure, WorkspaceCatalog | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+//# sourceMappingURL=resolve-source-pattern.d.ts.map

package/dist/src/resolve-source-pattern.js

@@ -0,0 +1,77 @@
+/**
+ * Multi-source pattern resolution: handles both single sources and glob patterns.
+ *
+ * Wraps `resolveSource` for single inputs and expands globs against all known
+ * skills (locked, configured, and on-disk) to resolve multiple sources.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import { SourceNotResolvable, sourceResolutionFailureCategory, } from "./errors.js";
+import { expandGlobs, isGlobPattern } from "./glob.js";
+import { resolveSource } from "./resolve-source.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+const sortNames = (names) => [...names].sort((a, b) => a.localeCompare(b));
+/** Resolve a single skill name with fallbacks: resolveSource → configured source → on-disk path. */
+const resolveNameWithFallback = (name, configuredSkills, onDiskByName) => resolveSource(name).pipe(Effect.catch((error) => {
+    if (sourceResolutionFailureCategory(error) !== "validation") {
+        return Effect.fail(error);
+    }
+    const configuredEntry = configuredSkills[name];
+    if (configuredEntry?.source !== undefined) {
+        return resolveSource(configuredEntry.source);
+    }
+    const diskPath = onDiskByName.get(name);
+    if (diskPath !== undefined) {
+        return Effect.succeed({ type: "local", path: diskPath });
+    }
+    return Effect.fail(error);
+}));
+// -----------------------------------------------------------------------------
+// Main
+// -----------------------------------------------------------------------------
+/**
+ * Resolve a source pattern into one or more `Source` values.
+ *
+ * - Single input (name, path, URL, etc.) → delegates to `resolveSource`, returns single-element array
+ * - Glob pattern (e.g. `effect-*`) → expands against locked, configured, and on-disk skills
+ *
+ * For single name inputs, includes fallbacks to configured skills and on-disk discovery
+ * when the skill is not in the lockfile.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const resolveSourcePattern = (input) => isGlobPattern(input)
+    ? Effect.gen(function* () {
+        const catalog = yield* WorkspaceCatalog;
+        const candidates = yield* catalog.skillCandidates;
+        const matchedNames = expandGlobs([input], candidates.names);
+        if (matchedNames.length === 0) {
+            return yield* new SourceNotResolvable({
+                category: "not_found",
+                detail: "No skills matched the given pattern",
+                suggestions: [
+                    {
+                        description: "Inspect installed skills.",
+                        cmd: "axm skills list",
+                    },
+                ],
+            });
+        }
+        return yield* Effect.forEach(sortNames(matchedNames), (name) => resolveNameWithFallback(name, candidates.configuredSkills, candidates.onDiskByName), { concurrency: "unbounded" });
+    })
+    : resolveSource(input).pipe(Effect.catch((error) => {
+        if (sourceResolutionFailureCategory(error) !== "validation") {
+            return Effect.fail(error);
+        }
+        return Effect.gen(function* () {
+            const catalog = yield* WorkspaceCatalog;
+            const candidates = yield* catalog.skillCandidates;
+            return yield* resolveNameWithFallback(input, candidates.configuredSkills, candidates.onDiskByName);
+        });
+    }), Effect.map((source) => [source]));
+//# sourceMappingURL=resolve-source-pattern.js.map

package/dist/src/resolve-source.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Source resolution: classifies input via parseInputPattern, then routes
+ * each pattern type to the appropriate resolution logic.
+ *
+ * For URL and SCP patterns, resolution iterates configured sources and
+ * matches by hostname + provider parse. For other patterns, resolution
+ * handles them directly.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { InputParseResult, ShorthandInput } from "@agentxm/extension-model/unstable/sources/parser";
+import type { Source } from "@agentxm/extension-model/unstable/sources/types";
+import { type Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import type { ExtensionName, ExtensionType, ExtensionTypePlural } from "@agentxm/extension-model/unstable/extensions";
+import { SourceHostNotConfigured, SourceNotResolvable, SourceSyntaxInvalid, type SourceResolutionFailure } from "./errors.js";
+import { WorkspaceCatalog } from "./workspace-catalog.js";
+/**
+ * Route a URL input by iterating configured sources and matching by
+ * hostname + provider parse. First successful match wins.
+ */
+export declare const routeUrlInput: (url: URL, input: string) => Effect.Effect<Source, SourceSyntaxInvalid | SourceHostNotConfigured | SourceNotResolvable, WorkspaceCatalog>;
+/**
+ * Route an SCP address by iterating configured sources and matching by
+ * hostname + provider parse. First successful match wins.
+ */
+export declare const routeScpInput: (scp: {
+    readonly user: string;
+    readonly host: string;
+    readonly path: string;
+}, input: string) => Effect.Effect<Source, SourceHostNotConfigured | SourceNotResolvable, WorkspaceCatalog>;
+/**
+ * Route shorthand input (github:owner/repo, ghe:owner/repo, etc.).
+ *
+ * Known source-type prefixes dispatch directly to the provider's shorthand
+ * parser. Config-name prefixes look up the config and parse using its source
+ * type's shorthand parser.
+ */
+export declare const resolveShorthandInputSource: (parseResult: InputParseResult<ShorthandInput>) => Effect.Effect<Source, SourceSyntaxInvalid | SourceHostNotConfigured | SourceNotResolvable, WorkspaceCatalog>;
+/** Route NameInput through the complete desired extension graph. */
+export declare const routeNameInput: (name: string, _input: string, expectedType?: ExtensionType) => Effect.Effect<Source, SourceResolutionFailure, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceCatalog>;
+/** Route RegistryPatternInput: find matching registry config and intersect with params. */
+export declare const routeRegistryInput: (pattern: {
+    readonly sourceName: string;
+    readonly type: Option.Option<ExtensionTypePlural>;
+    readonly owner: Handle;
+    readonly name: Option.Option<ExtensionName>;
+}, _input: string) => Effect.Effect<{
+    type: "registry";
+    name: string;
+    location: URL;
+    owner: Option.Option<string & import("effect/Brand").Brand<"Handle">>;
+}, SourceHostNotConfigured | SourceNotResolvable, WorkspaceCatalog>;
+export declare const resolveSlashInputSource: (pattern: {
+    readonly first: string;
+    readonly second: string;
+    readonly third: Option.Option<string>;
+}, input: string) => Effect.Effect<Source, SourceSyntaxInvalid | SourceHostNotConfigured | SourceNotResolvable, FileSystem.FileSystem | Path.Path | WorkspaceCatalog | HttpClient.HttpClient>;
+/**
+ * Resolve a source string into a fully resolved `Source`.
+ *
+ * Classifies the input via `parseInputPattern`, then routes each pattern
+ * type to the appropriate resolution logic. For URL and SCP patterns,
+ * resolution iterates configured sources and matches by hostname + provider
+ * parse. For other patterns, resolution handles them directly.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @param input - The source string to resolve
+ * @returns Effect containing a resolved `Source` or a typed resolution failure
+ */
+export declare const resolveSource: (input: string, options?: {
+    readonly expectedType?: ExtensionType;
+}) => Effect.Effect<Source, SourceResolutionFailure, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceCatalog>;
+//# sourceMappingURL=resolve-source.d.ts.map