@agentxm/extension-model 0.35.0 → 0.36.0

package/dist/src/unstable/agent-capabilities/derive.js

@@ -5,7 +5,7 @@
  */
 import { PER_AGENT_EXTENSION_TYPES } from "../extensions/common.js";
 import { AGENTS } from "./catalog.js";
-import { CONFIGURABLE_AGENT_IDS } from "./identity.js";
+import { isConfigurableAgentId } from "./identity.js";
 import { LEAF_EXTENSION_TYPES } from "../extension-types/schema.js";
 import { SUPPORTED_AXM_SUPPORT, } from "./schema.js";
 import {} from "../extensions/common.js";
@@ -43,8 +43,6 @@ const capabilityForType = (agent, type) => {
         return agent.capabilities[type];
     return undefined;
 };
-const configurableAgentIds = new Set(CONFIGURABLE_AGENT_IDS);
-const isConfigurableAgentId = (id) => configurableAgentIds.has(id);
 const deriveAgentId = (agent) => {
     if (isConfigurableAgentId(agent.id))
         return agent.id;

package/dist/src/unstable/agent-capabilities/identity.d.ts

@@ -5,6 +5,8 @@ export declare const CONFIGURABLE_AGENT_IDS: readonly ["adal", "aider-desk", "am
 /** @experimental This API is unstable and may change without notice. */
 export type ConfigurableAgentId = (typeof CONFIGURABLE_AGENT_IDS)[number];
 /** @experimental This API is unstable and may change without notice. */
+export declare const isConfigurableAgentId: (id: string) => id is ConfigurableAgentId;
+/** @experimental This API is unstable and may change without notice. */
 export declare const HOSTED_AGENT_IDS: readonly ["chatgpt", "claude-ai", "cowork", "gemini-app"];
 /** @experimental This API is unstable and may change without notice. */
 export type HostedAgentId = (typeof HOSTED_AGENT_IDS)[number];

package/dist/src/unstable/agent-capabilities/identity.js

@@ -65,6 +65,9 @@ export const CONFIGURABLE_AGENT_IDS = [
     "zed",
     "zenflow",
 ];
+const configurableAgentIdSet = new Set(CONFIGURABLE_AGENT_IDS);
+/** @experimental This API is unstable and may change without notice. */
+export const isConfigurableAgentId = (id) => configurableAgentIdSet.has(id);
 /** @experimental This API is unstable and may change without notice. */
 export const HOSTED_AGENT_IDS = ["chatgpt", "claude-ai", "cowork", "gemini-app"];
 /** @experimental This API is unstable and may change without notice. */

package/dist/src/unstable/agent-capabilities/index.d.ts

@@ -11,6 +11,6 @@ export { STANDARDS } from "../extension-types/standards.js";
 export { CAPABILITY_VERIFICATION_BUDGET_DAYS, capabilityVerificationAgeReport, type AgentCapabilitySlot, type CapabilityVerificationAge, } from "./verification.js";
 export { agentCapabilityStatus, agentSupportsType, axmIntegrationStatus, canonicalCoverage, deriveAgentDescriptor, deriveSkillConvention, deriveHookPortability, getSupportedAgentsForExtension, getSupportedAgentsForExtensionType, getSupportedAgentsForExtensionTypes, getSupportedExtensionTypesForAgent, isCapabilitySupported, isLeafExtensionType, listCapabilities, installable, toNativeAgent, type AgentCapabilityStatus, type AxmIntegrationStatus, type CapabilityListing, type ExtensionCompatibilityInput, type HookDecisionKind, type HookDecisionRequirement, type HookInstallabilityVerdict, type HookInstallBinding, type HookPortabilityRequirement, type HookPortabilityVerdict, type NativeAgent, type NativeAgentCapabilities, } from "./derive.js";
 export { AGENTS, AGENTS_BY_ID, CONFIGURABLE_AGENTS_BY_ID, HOSTED_AGENTS_BY_ID } from "./catalog.js";
-export { AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENT_IDS, HOSTED_AGENT_IDS, type AgentId, type ConfigurableAgentId, type HostedAgentId, } from "./identity.js";
+export { AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENT_IDS, HOSTED_AGENT_IDS, isConfigurableAgentId, type AgentId, type ConfigurableAgentId, type HostedAgentId, } from "./identity.js";
 export { agentById } from "./lookup.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/agent-capabilities/index.js

@@ -11,6 +11,6 @@ export { STANDARDS } from "../extension-types/standards.js";
 export { CAPABILITY_VERIFICATION_BUDGET_DAYS, capabilityVerificationAgeReport, } from "./verification.js";
 export { agentCapabilityStatus, agentSupportsType, axmIntegrationStatus, canonicalCoverage, deriveAgentDescriptor, deriveSkillConvention, deriveHookPortability, getSupportedAgentsForExtension, getSupportedAgentsForExtensionType, getSupportedAgentsForExtensionTypes, getSupportedExtensionTypesForAgent, isCapabilitySupported, isLeafExtensionType, listCapabilities, installable, toNativeAgent, } from "./derive.js";
 export { AGENTS, AGENTS_BY_ID, CONFIGURABLE_AGENTS_BY_ID, HOSTED_AGENTS_BY_ID } from "./catalog.js";
-export { AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENT_IDS, HOSTED_AGENT_IDS, } from "./identity.js";
+export { AGENT_IDS, AgentIdSchema, CONFIGURABLE_AGENT_IDS, HOSTED_AGENT_IDS, isConfigurableAgentId, } from "./identity.js";
 export { agentById } from "./lookup.js";
 //# sourceMappingURL=index.js.map

package/dist/src/unstable/agents/registry.d.ts

@@ -6,28 +6,14 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-import { type AgentId, type AgentRegistry } from "./types.js";
+import type { AgentRegistry } from "./types.js";
 /**
- * Complete registry of all known AI coding agents.
+ * Derived descriptors for all known AI coding agents, including the synthetic universal target.
  *
  * Keys are agent IDs, values are full descriptor objects.
  * Paths are pre-expanded at module initialization.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export declare const AGENTS: AgentRegistry;
-/**
- * Get all registered agent IDs.
- *
- * @returns Array of all agent identifiers
- *
- * @example
- * ```typescript
- * const ids = getAgentIds();
- * // ["adal", "amp", "antigravity", "augment", "claude-code", ...]
- * ```
- *
- * @experimental This API is unstable and may change without notice.
- */
-export declare const getAgentIds: () => ReadonlyArray<AgentId>;
+export declare const AGENT_DESCRIPTORS: AgentRegistry;
 //# sourceMappingURL=registry.d.ts.map

package/dist/src/unstable/agents/registry.js

@@ -10,7 +10,6 @@ import * as Record from "effect/Record";
 import { CONFIGURABLE_AGENTS_BY_ID } from "../agent-capabilities/catalog.js";
 import { deriveAgentDescriptor } from "../agent-capabilities/derive.js";
 import { UNIVERSAL_SKILLS_DIR } from "../extensions/universal-skills-dir.js";
-import { AGENT_IDS } from "./types.js";
 const UNIVERSAL_AGENT_DESCRIPTOR = {
     id: "universal",
     name: "Universal",
@@ -22,29 +21,15 @@ const UNIVERSAL_AGENT_DESCRIPTOR = {
     detection: { project: { markers: [] }, user: { markers: [] } },
 };
 /**
- * Complete registry of all known AI coding agents.
+ * Derived descriptors for all known AI coding agents, including the synthetic universal target.
  *
  * Keys are agent IDs, values are full descriptor objects.
  * Paths are pre-expanded at module initialization.
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const AGENTS = {
+export const AGENT_DESCRIPTORS = {
     ...Record.map(CONFIGURABLE_AGENTS_BY_ID, deriveAgentDescriptor),
     universal: UNIVERSAL_AGENT_DESCRIPTOR,
 };
-/**
- * Get all registered agent IDs.
- *
- * @returns Array of all agent identifiers
- *
- * @example
- * ```typescript
- * const ids = getAgentIds();
- * // ["adal", "amp", "antigravity", "augment", "claude-code", ...]
- * ```
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const getAgentIds = () => AGENT_IDS;
 //# sourceMappingURL=registry.js.map

package/dist/src/unstable/agents/types.d.ts

@@ -74,12 +74,10 @@ export interface AgentDetectionDescriptor {
 }
 /** @experimental This API is unstable and may change without notice. */
 export { CONFIGURABLE_AGENT_IDS, type ConfigurableAgentId };
+/** Configurable agents plus the synthetic universal materialization target. @experimental */
+export declare const MATERIALIZATION_TARGET_IDS: readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow", "universal"];
 /** @experimental This API is unstable and may change without notice. */
-export declare const AGENT_IDS: readonly ["adal", "aider-desk", "amp", "antigravity", "antigravity-cli", "augment", "claude-code", "cline", "codearts-agent", "codebuddy", "codemaker", "codestudio", "codex", "command-code", "continue", "cortex", "crush", "cursor", "deepagents", "devin", "dexto", "droid", "firebender", "forgecode", "gemini-cli", "github-copilot-cli", "goose", "grok-cli", "hermes", "ibm-bob", "iflow-cli", "junie", "lingma", "kilo", "kimi-cli", "kiro-cli", "kode", "mcpjam", "minimax-code", "mistral-vibe", "mux", "neovate", "openclaw", "opencode", "openhands", "ona", "pi", "pochi", "qoder", "qoder-cn", "qwen-code", "replit", "roo", "rovodev", "tabnine-cli", "trae-cn", "trae", "warp", "windsurf", "zencoder", "zed", "zenflow", "universal"];
-/** @experimental This API is unstable and may change without notice. */
-export type AgentId = (typeof AGENT_IDS)[number];
-/** @experimental This API is unstable and may change without notice. */
-export declare const isConfigurableAgentId: (id: AgentId) => id is ConfigurableAgentId;
+export type MaterializationTargetId = (typeof MATERIALIZATION_TARGET_IDS)[number];
 /**
  * Configuration for an AI coding agent.
  *
@@ -87,7 +85,7 @@ export declare const isConfigurableAgentId: (id: AgentId) => id is ConfigurableA
  */
 export interface AgentDescriptor {
     /** Unique identifier (e.g., "claude-code") */
-    readonly id: AgentId;
+    readonly id: MaterializationTargetId;
     /** Human-readable display name (e.g., "Claude Code") */
     readonly name: string;
     /**
@@ -122,5 +120,5 @@ export interface AgentDescriptor {
  *
  * @experimental This API is unstable and may change without notice.
  */
-export type AgentRegistry = Record.ReadonlyRecord<AgentId, AgentDescriptor>;
+export type AgentRegistry = Record.ReadonlyRecord<MaterializationTargetId, AgentDescriptor>;
 //# sourceMappingURL=types.d.ts.map

package/dist/src/unstable/agents/types.js

@@ -10,8 +10,6 @@ import { CONFIGURABLE_AGENT_IDS, } from "../agent-capabilities/identity.js";
 // -----------------------------------------------------------------------------
 /** @experimental This API is unstable and may change without notice. */
 export { CONFIGURABLE_AGENT_IDS };
-/** @experimental This API is unstable and may change without notice. */
-export const AGENT_IDS = [...CONFIGURABLE_AGENT_IDS, "universal"];
-/** @experimental This API is unstable and may change without notice. */
-export const isConfigurableAgentId = (id) => id !== "universal";
+/** Configurable agents plus the synthetic universal materialization target. @experimental */
+export const MATERIALIZATION_TARGET_IDS = [...CONFIGURABLE_AGENT_IDS, "universal"];
 //# sourceMappingURL=types.js.map

package/dist/src/unstable/extensions/name-patterns.d.ts

@@ -7,15 +7,17 @@
  * @experimental This API is unstable and may change without notice.
  */
 /**
- * Expand a glob pattern against a list of names.
+ * Match one extension name against a pattern.
  *
  * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
  * are treated as literals. Matching is case-sensitive.
  *
  * @param pattern - The pattern to match (may contain `*`)
- * @param names - Available names to match against
- * @returns Matching names in their original order
+ * @param name - The name to check
+ * @returns Whether the complete name matches
  */
+export declare const matchesPattern: (pattern: string, name: string) => boolean;
+/** Expand a glob pattern against names, preserving their original order. */
 export declare const expandGlob: (pattern: string, names: ReadonlyArray<string>) => ReadonlyArray<string>;
 /**
  * Expand multiple glob patterns against a list of extension names.

package/dist/src/unstable/extensions/name-patterns.js

@@ -7,48 +7,47 @@
  * @experimental This API is unstable and may change without notice.
  */
 /**
- * Expand a glob pattern against a list of names.
+ * Match one extension name against a pattern.
  *
  * Only `*` wildcards are supported. All other characters (including `?`, `[`, `]`)
  * are treated as literals. Matching is case-sensitive.
  *
  * @param pattern - The pattern to match (may contain `*`)
- * @param names - Available names to match against
- * @returns Matching names in their original order
+ * @param name - The name to check
+ * @returns Whether the complete name matches
  */
-export const expandGlob = (pattern, names) => {
-    const matches = (name) => {
-        let patternIndex = 0;
-        let nameIndex = 0;
-        let wildcardIndex = -1;
-        let wildcardNameIndex = 0;
-        while (nameIndex < name.length) {
-            const token = pattern[patternIndex];
-            if (token !== undefined && token !== "*" && token === name[nameIndex]) {
-                patternIndex += 1;
-                nameIndex += 1;
-            }
-            else if (token === "*") {
-                wildcardIndex = patternIndex;
-                wildcardNameIndex = nameIndex;
-                patternIndex += 1;
-            }
-            else if (wildcardIndex >= 0) {
-                patternIndex = wildcardIndex + 1;
-                wildcardNameIndex += 1;
-                nameIndex = wildcardNameIndex;
-            }
-            else {
-                return false;
-            }
+export const matchesPattern = (pattern, name) => {
+    let patternIndex = 0;
+    let nameIndex = 0;
+    let wildcardIndex = -1;
+    let wildcardNameIndex = 0;
+    while (nameIndex < name.length) {
+        const token = pattern[patternIndex];
+        if (token !== undefined && token !== "*" && token === name[nameIndex]) {
+            patternIndex += 1;
+            nameIndex += 1;
         }
-        while (pattern[patternIndex] === "*") {
+        else if (token === "*") {
+            wildcardIndex = patternIndex;
+            wildcardNameIndex = nameIndex;
             patternIndex += 1;
         }
-        return patternIndex === pattern.length;
-    };
-    return names.filter(matches);
+        else if (wildcardIndex >= 0) {
+            patternIndex = wildcardIndex + 1;
+            wildcardNameIndex += 1;
+            nameIndex = wildcardNameIndex;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[patternIndex] === "*") {
+        patternIndex += 1;
+    }
+    return patternIndex === pattern.length;
 };
+/** Expand a glob pattern against names, preserving their original order. */
+export const expandGlob = (pattern, names) => names.filter((name) => matchesPattern(pattern, name));
 /**
  * Expand multiple glob patterns against a list of extension names.
  *

package/dist/src/unstable/path-types.d.ts

@@ -26,4 +26,10 @@ export declare const makeWorkspaceRelativeSourcePath: (path: Path.Path, workspac
  * prefix is not mistaken for a child.
  */
 export declare const isPathSafe: (path: Path.Path, base: string, target: string) => boolean;
+/** Resolve a child against its base and reject paths that escape it. */
+export declare const safeChildPath: (path: Path.Path, base: string, target: string) => Option.Option<AbsolutePath>;
+/** Relative-path containment, including the parent itself. */
+export declare const isWithinOrEqual: (path: Path.Path, parent: string, child: string) => boolean;
+/** Relative-path containment that excludes the parent itself. */
+export declare const isStrictlyWithin: (path: Path.Path, parent: string, child: string) => boolean;
 //# sourceMappingURL=path-types.d.ts.map

package/dist/src/unstable/path-types.js

@@ -56,4 +56,24 @@ export const isPathSafe = (path, base, target) => {
     const resolvedTarget = path.resolve(target);
     return resolvedTarget === resolvedBase || resolvedTarget.startsWith(resolvedBase + path.sep);
 };
+/** Resolve a child against its base and reject paths that escape it. */
+export const safeChildPath = (path, base, target) => {
+    const resolvedBase = path.resolve(base);
+    const resolvedTarget = path.isAbsolute(target)
+        ? path.resolve(target)
+        : path.resolve(resolvedBase, target);
+    return isPathSafe(path, resolvedBase, resolvedTarget)
+        ? Option.some(makeAbsolutePath(path, resolvedTarget))
+        : Option.none();
+};
+/** Relative-path containment, including the parent itself. */
+export const isWithinOrEqual = (path, parent, child) => {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+};
+/** Relative-path containment that excludes the parent itself. */
+export const isStrictlyWithin = (path, parent, child) => {
+    const relative = path.relative(path.resolve(parent), path.resolve(child));
+    return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+};
 //# sourceMappingURL=path-types.js.map

package/dist/src/unstable/sources/forge-grammar.d.ts

@@ -1,22 +1,58 @@
 /**
- * Pure per-forge source shorthand printing grammar.
+ * Forge coordinate, clone URL, and browser URL grammar.
  *
- * Each printer formats source params as the forge's canonical shorthand
- * string. Probing and acquisition stay with the source-resolution providers;
- * only the string grammar lives here.
+ * Probing and acquisition stay with source resolution; the model owns the
+ * strings and URLs that identify each forge repository.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-import type { AzureReposSourceParams, BitbucketSourceParams, GitHubSourceParams, GitLabSourceParams, LocalSourceParams } from "./types.js";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
 /** @experimental */
-export declare const printGitHubSource: (source: GitHubSourceParams, sourceName?: string) => string;
+export declare const FORGE_PREFIXES: readonly ["github", "gitlab", "bitbucket", "azurerepos"];
 /** @experimental */
-export declare const printGitLabSource: (source: GitLabSourceParams, sourceName?: string) => string;
+export type ForgePrefix = (typeof FORGE_PREFIXES)[number];
 /** @experimental */
-export declare const printBitbucketSource: (source: BitbucketSourceParams, sourceName?: string) => string;
+export declare const isForgePrefix: (value: string) => value is ForgePrefix;
 /** @experimental */
-export declare const printAzureReposSource: (source: AzureReposSourceParams, sourceName?: string) => string;
+export interface ForgeCoordinate {
+    readonly forge: ForgePrefix;
+    readonly repository: string;
+    readonly ref: Option.Option<string>;
+    readonly subPath: Option.Option<string>;
+}
+interface BrowserPath {
+    readonly repository: string;
+    readonly ref?: string;
+    readonly subPath?: string;
+}
 /** @experimental */
-export declare const printLocalSource: (source: LocalSourceParams) => string;
+export interface Forge {
+    readonly prefix: ForgePrefix;
+    readonly hostname: string;
+    readonly repositorySegments: (count: number) => boolean;
+    readonly cloneUrl: (repository: string) => URL;
+    readonly repositoryFromCloneUrl: (pathname: string) => string | undefined;
+    readonly parseBrowserPath: (pathname: string) => BrowserPath | undefined;
+}
+/** @experimental */
+export declare const FORGES: Record<ForgePrefix, Forge>;
+/** @experimental */
+export declare const forgeForHostname: (hostname: string) => Forge | undefined;
+/** @experimental */
+export declare const parseForgeCoordinate: (forge: ForgePrefix, body: string) => Result.Result<ForgeCoordinate, {
+    readonly reason: string;
+}>;
+/** @experimental */
+export declare const printForgeCoordinateBody: (coordinate: ForgeCoordinate) => string;
+/** @experimental */
+export declare const printForgeCoordinate: (coordinate: ForgeCoordinate) => string;
+/** @experimental */
+export declare const forgeCloneUrl: (coordinate: ForgeCoordinate) => URL;
+/** @experimental */
+export declare const forgeCoordinateFromGitUrl: (url: URL, ref: Option.Option<string>, subPath: Option.Option<string>) => Option.Option<ForgeCoordinate>;
+/** @experimental */
+export declare const parseForgeBrowserUrl: (url: URL) => Option.Option<ForgeCoordinate>;
+export {};
 //# sourceMappingURL=forge-grammar.d.ts.map

package/dist/src/unstable/sources/forge-grammar.js

@@ -1,50 +1,170 @@
 /**
- * Pure per-forge source shorthand printing grammar.
+ * Forge coordinate, clone URL, and browser URL grammar.
  *
- * Each printer formats source params as the forge's canonical shorthand
- * string. Probing and acquisition stay with the source-resolution providers;
- * only the string grammar lives here.
+ * Probing and acquisition stay with source resolution; the model owns the
+ * strings and URLs that identify each forge repository.
  *
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
+import { SourceNamespaceSchema, SourceRefSchema, SourceSubPathSchema } from "./types.js";
 /** @experimental */
-export const printGitHubSource = (source, sourceName = source.sourceName ?? "github") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const FORGE_PREFIXES = ["github", "gitlab", "bitbucket", "azurerepos"];
+/** @experimental */
+export const isForgePrefix = (value) => FORGE_PREFIXES.some((prefix) => prefix === value);
+const segments = (pathname) => pathname.split("/").filter((segment) => segment.length > 0);
+const withoutGit = (name) => (name.endsWith(".git") ? name.slice(0, -4) : name);
+const hostedRepositoryFromCloneUrl = (pathname) => {
+    const parts = segments(pathname);
+    const last = parts.at(-1);
+    return last === undefined || parts.length < 2
+        ? undefined
+        : [...parts.slice(0, -1), withoutGit(last)].join("/");
+};
+const hostedBrowserPath = (pathname, marker) => {
+    const pattern = marker === "tree"
+        ? /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/tree\/([^/]+)(?:\/(.+))?)?$/u
+        : /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/src\/([^/]+)(?:\/(.+))?)?$/u;
+    const match = pattern.exec(pathname);
+    if (match?.[1] === undefined || match[2] === undefined)
+        return undefined;
+    return {
+        repository: `${match[1]}/${match[2]}`,
+        ...(match[3] === undefined ? {} : { ref: match[3] }),
+        ...(match[4] === undefined ? {} : { subPath: match[4] }),
+    };
+};
+const gitlabBrowserPath = (pathname) => {
+    const marker = "/-/tree/";
+    const markerIndex = pathname.indexOf(marker);
+    const repositoryParts = segments(markerIndex < 0 ? pathname : pathname.slice(0, markerIndex));
+    const last = repositoryParts.at(-1);
+    if (last === undefined || repositoryParts.length < 2)
+        return undefined;
+    const treePath = markerIndex < 0 ? [] : pathname.slice(markerIndex + marker.length).split("/");
+    const subPath = treePath.slice(1).join("/");
+    return {
+        repository: [...repositoryParts.slice(0, -1), withoutGit(last)].join("/"),
+        ...(treePath[0] === undefined ? {} : { ref: treePath[0] }),
+        ...(subPath.length === 0 ? {} : { subPath }),
+    };
+};
+const azureRepositoryFromCloneUrl = (pathname) => {
+    const parts = segments(pathname);
+    return parts.length === 4 && parts[2] === "_git"
+        ? `${parts[0]}/${parts[1]}/${withoutGit(parts[3] ?? "")}`
+        : undefined;
+};
+const azureBrowserPath = (pathname) => {
+    const match = /^\/([^/]+)\/([^/]+)\/_git\/([^/]+?)(?:\.git)?$/u.exec(pathname);
+    return match?.[1] === undefined || match[2] === undefined || match[3] === undefined
+        ? undefined
+        : { repository: `${match[1]}/${match[2]}/${match[3]}` };
+};
+const hostedForge = (prefix, hostname, parseBrowserPath) => ({
+    prefix,
+    hostname,
+    repositorySegments: (count) => count >= 2,
+    cloneUrl: (repository) => new URL(`https://${hostname}/${repository}.git`),
+    repositoryFromCloneUrl: hostedRepositoryFromCloneUrl,
+    parseBrowserPath,
+});
+/** @experimental */
+export const FORGES = {
+    github: hostedForge("github", "github.com", (pathname) => hostedBrowserPath(pathname, "tree")),
+    gitlab: hostedForge("gitlab", "gitlab.com", gitlabBrowserPath),
+    bitbucket: hostedForge("bitbucket", "bitbucket.org", (pathname) => hostedBrowserPath(pathname, "src")),
+    azurerepos: {
+        prefix: "azurerepos",
+        hostname: "dev.azure.com",
+        repositorySegments: (count) => count === 3,
+        cloneUrl: (repository) => {
+            const [organization, project, repo] = repository.split("/");
+            return new URL(`https://dev.azure.com/${organization}/${project}/_git/${repo}`);
+        },
+        repositoryFromCloneUrl: azureRepositoryFromCloneUrl,
+        parseBrowserPath: azureBrowserPath,
+    },
+};
+/** @experimental */
+export const forgeForHostname = (hostname) => Object.values(FORGES).find((forge) => forge.hostname === hostname);
+const decodeNamespace = Schema.decodeUnknownResult(SourceNamespaceSchema);
+const decodeSubPath = Schema.decodeUnknownResult(SourceSubPathSchema);
+const decodeRef = Schema.decodeUnknownResult(SourceRefSchema);
+const validCoordinate = (coordinate) => FORGES[coordinate.forge].repositorySegments(coordinate.repository.split("/").length) &&
+    Result.isSuccess(decodeNamespace(coordinate.repository)) &&
+    (Option.isNone(coordinate.subPath) ||
+        Result.isSuccess(decodeSubPath(coordinate.subPath.value))) &&
+    (Option.isNone(coordinate.ref) || Result.isSuccess(decodeRef(coordinate.ref.value)));
+const splitRef = (input) => {
+    const refIndex = input.lastIndexOf("@");
+    if (refIndex <= 0)
+        return { coordinate: input };
+    const ref = input.slice(refIndex + 1);
+    const subPathMarker = input.indexOf("//");
+    const isAtPathSegment = subPathMarker !== -1 &&
+        refIndex > subPathMarker + 1 &&
+        input[refIndex - 1] === "/" &&
+        ref.includes("/");
+    return isAtPathSegment ? { coordinate: input } : { coordinate: input.slice(0, refIndex), ref };
 };
 /** @experimental */
-export const printGitLabSource = (source, sourceName = source.sourceName ?? "gitlab") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const parseForgeCoordinate = (forge, body) => {
+    const { coordinate, ref } = splitRef(body);
+    const marker = coordinate.indexOf("//");
+    const repository = marker < 0 ? coordinate : coordinate.slice(0, marker);
+    const subPath = marker < 0 ? undefined : coordinate.slice(marker + 2);
+    const parsed = {
+        forge,
+        repository,
+        ref: Option.fromUndefinedOr(ref),
+        subPath: Option.fromUndefinedOr(subPath),
+    };
+    return validCoordinate(parsed)
+        ? Result.succeed(parsed)
+        : Result.fail({ reason: `Expected valid ${forge} repository[//subpath][@ref]` });
 };
 /** @experimental */
-export const printBitbucketSource = (source, sourceName = source.sourceName ?? "bitbucket") => {
-    let s = `${sourceName}:${source.owner}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const printForgeCoordinateBody = (coordinate) => {
+    let body = coordinate.repository;
+    if (Option.isSome(coordinate.subPath))
+        body += `//${coordinate.subPath.value}`;
+    if (Option.isSome(coordinate.ref))
+        body += `@${coordinate.ref.value}`;
+    return body;
 };
 /** @experimental */
-export const printAzureReposSource = (source, sourceName = source.sourceName ?? "azurerepos") => {
-    let s = `${sourceName}:${source.organization}/${source.project}/${source.repo}`;
-    if (Option.isSome(source.subPath))
-        s += `//${source.subPath.value}`;
-    if (Option.isSome(source.ref))
-        s += `@${source.ref.value}`;
-    return s;
+export const printForgeCoordinate = (coordinate) => `${coordinate.forge}:${printForgeCoordinateBody(coordinate)}`;
+/** @experimental */
+export const forgeCloneUrl = (coordinate) => FORGES[coordinate.forge].cloneUrl(coordinate.repository);
+/** @experimental */
+export const forgeCoordinateFromGitUrl = (url, ref, subPath) => {
+    const forge = forgeForHostname(url.hostname);
+    if (forge === undefined)
+        return Option.none();
+    const repository = forge.repositoryFromCloneUrl(url.pathname);
+    if (repository === undefined)
+        return Option.none();
+    const coordinate = { forge: forge.prefix, repository, ref, subPath };
+    return validCoordinate(coordinate) ? Option.some(coordinate) : Option.none();
 };
 /** @experimental */
-export const printLocalSource = (source) => source.path.startsWith("/") || source.path.startsWith(".") ? source.path : `./${source.path}`;
+export const parseForgeBrowserUrl = (url) => {
+    const forge = forgeForHostname(url.hostname);
+    if (forge === undefined)
+        return Option.none();
+    const parsed = forge.parseBrowserPath(url.pathname);
+    if (parsed === undefined)
+        return Option.none();
+    const coordinate = {
+        forge: forge.prefix,
+        repository: parsed.repository,
+        ref: Option.fromUndefinedOr(parsed.ref),
+        subPath: Option.fromUndefinedOr(parsed.subPath),
+    };
+    return validCoordinate(coordinate) ? Option.some(coordinate) : Option.none();
+};
 //# sourceMappingURL=forge-grammar.js.map

package/dist/src/unstable/sources/parser.d.ts

@@ -9,6 +9,7 @@
  * @packageDocumentation
  */
 import * as Option from "effect/Option";
+import { type ForgeCoordinate, type ForgePrefix } from "./forge-grammar.js";
 import type { VersionRange } from "../version-constraints/version-constraints.js";
 import type { ExtensionName, ExtensionType, ExtensionTypePlural } from "../extensions/common.js";
 import type { Handle } from "../extensions/handle.js";
@@ -45,10 +46,7 @@ type GitScpAddress = {
 /** An `owner/repo[//path][@ref]` style pattern containing `/` (not a URL or file path). */
 type SlashPattern = {
     readonly pattern: "slash-pattern";
-    readonly first: string;
-    readonly second: string;
-    readonly third: Option.Option<string>;
-    readonly ref: Option.Option<string>;
+    readonly coordinate: ForgeCoordinate;
 };
 /** A local filesystem path matching `LOCAL_PATH_PATTERN`. */
 type FilePathPattern = {
@@ -58,7 +56,7 @@ type FilePathPattern = {
 /** A shorthand prefixed input: `<prefix>:...` where prefix is a known source provider. */
 export type ShorthandInput = {
     readonly pattern: "shorthand-input";
-    readonly prefix: string;
+    readonly prefix: ForgePrefix;
     readonly remainingInput: string;
 };
 /** A glob pattern containing `*` wildcards (e.g. `effect-*`). */

package/dist/src/unstable/sources/parser.js

@@ -10,14 +10,13 @@
  */
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
+import { isForgePrefix, parseForgeCoordinate, } from "./forge-grammar.js";
 import { parseFqn } from "../extensions/fqn.js";
 import { parseSourceQualifiedRegistrySourcePatternParts } from "../extensions/registry-source.js";
 /** Matches: ./path, ../path, /path, ~/path, ~\path, or Windows paths like C:\path */
 const LOCAL_PATH_PATTERN = /^(?:\.\.?\/|\/|~\/|~\\|[A-Za-z]:[\\/])/;
 /** SCP-style: `user@host:path` — no `://` scheme. */
 const SCP_PATTERN = /^([^@]+)@([^:]+):(.+)$/;
-/** Known shorthand prefixes. */
-const SHORTHAND_PREFIXES = new Set(["github", "gitlab", "bitbucket", "azurerepos"]);
 /** Simple name: alphanumeric with hyphens, no leading/trailing hyphen. */
 const NAME_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
 /**
@@ -66,10 +65,11 @@ export const parseInputPattern = (input) => {
     }
     // 4. Shorthand prefix (github:..., gitlab:..., etc.) — must check before URL
     const colonIndex = input.indexOf(":");
-    if (colonIndex > 0 && SHORTHAND_PREFIXES.has(input.slice(0, colonIndex))) {
+    const prefix = input.slice(0, colonIndex);
+    if (colonIndex > 0 && isForgePrefix(prefix)) {
         return Option.some(wrap({
             pattern: "shorthand-input",
-            prefix: input.slice(0, colonIndex),
+            prefix,
             remainingInput: input.slice(colonIndex + 1),
         }));
     }
@@ -90,34 +90,17 @@ export const parseInputPattern = (input) => {
     }
     // 7. Slash pattern (`owner/repo[//path][@ref]`)
     if (input.includes("/")) {
-        const refIndex = input.lastIndexOf("@");
-        const hasRef = refIndex > 0 && refIndex < input.length - 1;
-        const coordinate = hasRef ? input.slice(0, refIndex) : input;
-        const ref = hasRef ? input.slice(refIndex + 1) : undefined;
-        const subPathIndex = coordinate.indexOf("//");
-        const repositoryCoordinate = subPathIndex < 0 ? coordinate : coordinate.slice(0, subPathIndex);
-        const subPath = subPathIndex < 0 ? undefined : coordinate.slice(subPathIndex + 2);
-        const segments = repositoryCoordinate.split("/");
-        const first = segments.at(0);
-        const second = segments.at(1);
-        if (first !== undefined &&
-            second !== undefined &&
-            segments.length === 2 &&
-            NAME_PATTERN.test(first) &&
-            NAME_PATTERN.test(second) &&
-            (ref === undefined || (ref.length > 0 && !ref.includes("/"))) &&
-            (subPath === undefined ||
-                (subPath.length > 0 &&
-                    subPath.split("/").every((segment) => segment.length > 0 && segment !== "..")))) {
-            return Option.some(wrap({
-                pattern: "slash-pattern",
-                first,
-                second,
-                third: Option.fromUndefinedOr(subPath),
-                ref: Option.fromUndefinedOr(ref),
-            }));
+        const parsed = parseForgeCoordinate("github", input);
+        if (Result.isFailure(parsed))
+            return Option.none();
+        const coordinate = parsed.success;
+        const segments = coordinate.repository.split("/");
+        if (segments.length !== 2 ||
+            !segments.every((segment) => NAME_PATTERN.test(segment)) ||
+            Option.exists(coordinate.ref, (ref) => ref.includes("/"))) {
+            return Option.none();
         }
-        return Option.none();
+        return Option.some(wrap({ pattern: "slash-pattern", coordinate }));
     }
     // 8. Glob pattern (contains `*` wildcard)
     if (input.includes("*")) {

package/dist/src/unstable/sources/printer.js

@@ -6,7 +6,8 @@
  */
 import * as Option from "effect/Option";
 import { formatFqn } from "../extensions/fqn.js";
-import { printLocalSource } from "./forge-grammar.js";
+import { forgeCoordinateFromGitUrl, printForgeCoordinate } from "./forge-grammar.js";
+const printLocalSource = (source) => source.path.startsWith("/") || source.path.startsWith(".") ? source.path : `./${source.path}`;
 /**
  * Print source params as their canonical shorthand string.
  *
@@ -17,40 +18,14 @@ export const printSourceParams = (source) => {
         case "local":
             return printLocalSource(source);
         case "git": {
-            const repositorySegments = source.url.pathname
-                .split("/")
-                .filter((segment) => segment.length > 0);
-            if (source.url.hostname === "dev.azure.com" &&
-                repositorySegments.length === 4 &&
-                repositorySegments[2] === "_git") {
-                let shorthand = `azurerepos:${repositorySegments[0]}/${repositorySegments[1]}/${repositorySegments[3]}`;
-                if (Option.isSome(source.subPath))
-                    shorthand += `//${source.subPath.value}`;
-                if (Option.isSome(source.ref))
-                    shorthand += `@${source.ref.value}`;
-                return shorthand;
-            }
-            const lastSegment = repositorySegments.at(-1);
-            const repo = lastSegment?.endsWith(".git") ? lastSegment.slice(0, -4) : lastSegment;
-            const sourcePrefix = source.url.hostname === "github.com"
-                ? "github"
-                : source.url.hostname === "gitlab.com"
-                    ? "gitlab"
-                    : source.url.hostname === "bitbucket.org"
-                        ? "bitbucket"
-                        : undefined;
-            if (sourcePrefix !== undefined && repo !== undefined && repositorySegments.length >= 2) {
-                const owner = repositorySegments.slice(0, -1).join("/");
-                let shorthand = `${sourcePrefix}:${owner}/${repo}`;
-                if (Option.isSome(source.subPath))
-                    shorthand += `//${source.subPath.value}`;
-                if (Option.isSome(source.ref))
-                    shorthand += `@${source.ref.value}`;
-                return shorthand;
-            }
-            const url = new URL(source.url.href);
-            url.hash = Option.getOrElse(source.ref, () => "");
-            return url.href;
+            return Option.match(forgeCoordinateFromGitUrl(source.url, source.ref, source.subPath), {
+                onSome: printForgeCoordinate,
+                onNone: () => {
+                    const url = new URL(source.url.href);
+                    url.hash = Option.getOrElse(source.ref, () => "");
+                    return url.href;
+                },
+            });
         }
         case "registry": {
             return source.sourceName ?? ("name" in source ? String(source.name) : "agentxm");

package/dist/src/unstable/sources/types.d.ts

@@ -29,7 +29,7 @@ export type SourceType = Schema.Schema.Type<typeof SourceTypeSchema>;
 /**
  * Ref type discriminator for extension ref hosting categories.
  *
- * - `"git-hosted"` - Git-based sources (GitHub, GitLab, Bitbucket, AzureRepos, Git)
+ * - `"git-hosted"` - Git-based sources, including the built-in forges
  * - `"registry"` - Package registry source
  * - `"local"` - Local filesystem path source
  * - `"workspace"` - Intrinsic managed workspace package
@@ -43,60 +43,9 @@ export declare const RefTypeSchema: Schema.Literals<readonly ["git-hosted", "reg
  * @experimental This API is unstable and may change without notice.
  */
 export type RefType = Schema.Schema.Type<typeof RefTypeSchema>;
-export declare const SourceSegmentSchema: Schema.NonEmptyString;
 export declare const SourceRefSchema: Schema.NonEmptyString;
 export declare const SourceNamespaceSchema: Schema.NonEmptyString;
 export declare const SourceSubPathSchema: Schema.NonEmptyString;
-export declare const GitHostedSourceParamPartsSchema: Schema.Struct<{
-    sourceName: Schema.optional<Schema.String>;
-    owner: Schema.NonEmptyString;
-    repo: Schema.NonEmptyString;
-    ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-}>;
-export type GitHostedSourceParamParts = Schema.Schema.Type<typeof GitHostedSourceParamPartsSchema>;
-export declare const AzureReposSourceParamPartsSchema: Schema.Struct<{
-    sourceName: Schema.optional<Schema.String>;
-    organization: Schema.NonEmptyString;
-    project: Schema.NonEmptyString;
-    repo: Schema.NonEmptyString;
-    ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-}>;
-export type AzureReposSourceParamParts = Schema.Schema.Type<typeof AzureReposSourceParamPartsSchema>;
-export declare const GitHubSourceParamsSchema: Schema.Struct<{
-    readonly sourceName: Schema.optional<Schema.String>;
-    readonly owner: Schema.NonEmptyString;
-    readonly repo: Schema.NonEmptyString;
-    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly type: Schema.Literal<"github">;
-}>;
-export declare const GitLabSourceParamsSchema: Schema.Struct<{
-    readonly sourceName: Schema.optional<Schema.String>;
-    readonly owner: Schema.NonEmptyString;
-    readonly repo: Schema.NonEmptyString;
-    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly type: Schema.Literal<"gitlab">;
-}>;
-export declare const BitbucketSourceParamsSchema: Schema.Struct<{
-    readonly sourceName: Schema.optional<Schema.String>;
-    readonly owner: Schema.NonEmptyString;
-    readonly repo: Schema.NonEmptyString;
-    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly type: Schema.Literal<"bitbucket">;
-}>;
-export declare const AzureReposSourceParamsSchema: Schema.Struct<{
-    readonly sourceName: Schema.optional<Schema.String>;
-    readonly organization: Schema.NonEmptyString;
-    readonly project: Schema.NonEmptyString;
-    readonly repo: Schema.NonEmptyString;
-    readonly ref: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly subPath: Schema.OptionFromOptionalKey<Schema.NonEmptyString>;
-    readonly type: Schema.Literal<"azurerepos">;
-}>;
 /** @experimental */
 /** Self-describing — the git URL lives in SourceParams. @experimental */
 export interface GitSourceHost {
@@ -126,47 +75,6 @@ export interface WorkspaceSourceHost {
 /** @experimental */
 export type SourceHost = GitSourceHost | RegistrySourceHost | LocalSourceHost | InlineSourceHost | WorkspaceSourceHost;
 /** @experimental */
-export interface GitHubSourceParams {
-    readonly type: "github";
-    readonly sourceName?: string | undefined;
-    readonly owner: string;
-    readonly repo: string;
-    readonly ref: Option.Option<string>;
-    readonly subPath: Option.Option<string>;
-    readonly cloneUrl?: Option.Option<string>;
-}
-/** @experimental */
-export interface GitLabSourceParams {
-    readonly type: "gitlab";
-    readonly sourceName?: string | undefined;
-    readonly owner: string;
-    readonly repo: string;
-    readonly ref: Option.Option<string>;
-    readonly subPath: Option.Option<string>;
-    readonly cloneUrl?: Option.Option<string>;
-}
-/** @experimental */
-export interface BitbucketSourceParams {
-    readonly type: "bitbucket";
-    readonly sourceName?: string | undefined;
-    readonly owner: string;
-    readonly repo: string;
-    readonly ref: Option.Option<string>;
-    readonly subPath: Option.Option<string>;
-    readonly cloneUrl?: Option.Option<string>;
-}
-/** @experimental */
-export interface AzureReposSourceParams {
-    readonly type: "azurerepos";
-    readonly sourceName?: string | undefined;
-    readonly organization: string;
-    readonly project: string;
-    readonly repo: string;
-    readonly ref: Option.Option<string>;
-    readonly subPath: Option.Option<string>;
-    readonly cloneUrl?: Option.Option<string>;
-}
-/** @experimental */
 export interface GitSourceParams {
     readonly type: "git";
     readonly url: URL;

package/dist/src/unstable/sources/types.js

@@ -36,7 +36,7 @@ export const SourceTypeSchema = Schema.Literals([
 /**
  * Ref type discriminator for extension ref hosting categories.
  *
- * - `"git-hosted"` - Git-based sources (GitHub, GitLab, Bitbucket, AzureRepos, Git)
+ * - `"git-hosted"` - Git-based sources, including the built-in forges
  * - `"registry"` - Package registry source
  * - `"local"` - Local filesystem path source
  * - `"workspace"` - Intrinsic managed workspace package
@@ -53,13 +53,7 @@ export const RefTypeSchema = Schema.Literals([
     title: "Ref Type",
     description: "Ref type category: git-hosted, registry, local, or workspace.",
 });
-const noSlashSegmentMessage = "Expected non-empty segment without '/' characters";
 const noTraversalSegmentMessage = "Expected subpath without '..' traversal segments";
-export const SourceSegmentSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => (value.includes("/") ? noSlashSegmentMessage : undefined)))).annotate({
-    identifier: "SourceSegment",
-    title: "Source Segment",
-    description: "A non-empty path segment without slash characters, used for owner/repo identifiers.",
-});
 export const SourceRefSchema = Schema.NonEmptyString;
 export const SourceNamespaceSchema = Schema.NonEmptyString.pipe(Schema.check(Schema.makeFilter((value) => value.split("/").some((segment) => segment.length === 0 || segment === "..")
     ? "Expected non-empty namespace path segments without '..' traversal"
@@ -75,45 +69,4 @@ export const SourceSubPathSchema = Schema.NonEmptyString.pipe(Schema.check(Schem
     title: "Source Subpath",
     description: "A non-empty repository subpath without empty or '..' traversal segments.",
 });
-const GitHostedSourceParamFields = {
-    sourceName: Schema.optional(Schema.String),
-    owner: SourceNamespaceSchema,
-    repo: SourceSegmentSchema,
-    ref: Schema.OptionFromOptionalKey(SourceRefSchema),
-    subPath: Schema.OptionFromOptionalKey(SourceSubPathSchema),
-};
-export const GitHostedSourceParamPartsSchema = Schema.Struct(GitHostedSourceParamFields).annotate({
-    identifier: "GitHostedSourceParamParts",
-    title: "Git Hosted Source Params",
-    description: "Parameters for a git-hosted source: owner, repo, optional ref and sub-path.",
-});
-const AzureReposSourceParamFields = {
-    sourceName: Schema.optional(Schema.String),
-    organization: SourceSegmentSchema,
-    project: SourceSegmentSchema,
-    repo: SourceSegmentSchema,
-    ref: Schema.OptionFromOptionalKey(SourceRefSchema),
-    subPath: Schema.OptionFromOptionalKey(SourceSubPathSchema),
-};
-export const AzureReposSourceParamPartsSchema = Schema.Struct(AzureReposSourceParamFields).annotate({
-    identifier: "AzureReposSourceParamParts",
-    title: "Azure Repos Source Params",
-    description: "Parameters for an Azure Repos source: organization, project, repo, optional ref and sub-path.",
-});
-export const GitHubSourceParamsSchema = Schema.Struct({
-    type: Schema.Literal("github"),
-    ...GitHostedSourceParamFields,
-});
-export const GitLabSourceParamsSchema = Schema.Struct({
-    type: Schema.Literal("gitlab"),
-    ...GitHostedSourceParamFields,
-});
-export const BitbucketSourceParamsSchema = Schema.Struct({
-    type: Schema.Literal("bitbucket"),
-    ...GitHostedSourceParamFields,
-});
-export const AzureReposSourceParamsSchema = Schema.Struct({
-    type: Schema.Literal("azurerepos"),
-    ...AzureReposSourceParamFields,
-});
 //# sourceMappingURL=types.js.map

package/package.json

@@ -11,7 +11,7 @@
   },
   "description": "Shared AgentXM extension model: identities, manifests, version constraints, and agent capabilities. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
-    "@agentxm/specification-metadata": "0.35.0",
+    "@agentxm/specification-metadata": "0.36.0",
     "@effect/vitest": "4.0.0-rc.117",
     "@fast-check/vitest": "^0.5.0",
     "@types/semver": "^7.7.1",
@@ -305,5 +305,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.35.0"
+  "version": "0.36.0"
 }