@agentxm/registry-protocol 0.31.1 → 0.33.0

package/README.md

@@ -1,21 +1,70 @@
 # @agentxm/registry-protocol
 
-The AgentXM Registry wire contracts that the AXM client and the Registry
-implementation must interpret identically: extension index and version entry
-schemas (`./unstable/registry/schema`), discovery responses
+The AXM client's typed representation of the public AgentXM Registry HTTP
+contract: extension index and version entry schemas
+(`./unstable/registry/schema`), discovery responses
 (`./unstable/registry/discover-schema`), publication-set preview and
 validation (`./unstable/registry/publication-set`), publish visibility
-(`./unstable/publish`), publish authorization
-(`./unstable/publish-authorization`), and the shared suggested-action and
+(`./unstable/publish`), and the shared suggested-action and
 human-handoff error vocabulary (`./unstable/suggested-action`,
 `./unstable/human-handoff`).
 
+## Batch resolution metadata
+
+`./unstable/registry/resolution-metadata` defines the versioned contract for a
+repeat-safe `POST /v1/resolutions/metadata` query. The Registry owns the HTTP
+route and authorization; AXM keeps version selection, release-age policy, and
+dependency graph decisions. A request groups up to 100 items in one trusted
+Registry and credential context. Each item has a unique caller key, extension
+identity, and a `select` or `restore-exact` purpose. Exact restoration supplies
+the accepted version and integrity. The caller may also supply an expected
+publisher binding, a known representation revision, or a continuation bound to
+the previous revision.
+
+The response has exactly one outcome per submitted key in request order:
+
+| Outcome            | Meaning                                                                                                                                                                                          |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `metadata`         | An authorized page of version descriptors, dependency and package compatibility data, lifecycle information, and an opaque revision. A `null` continuation means the candidate list is complete. |
+| `unchanged`        | Current authorization and lifecycle still admit a matching complete representation already held by the client. A client without that representation repeats the item without `knownRevision`.    |
+| `unavailable`      | The identity is absent or inaccessible; the response deliberately does not distinguish those cases.                                                                                              |
+| `binding-conflict` | An authorized identity no longer has the expected publisher binding.                                                                                                                             |
+| `exact-conflict`   | An authorized exact version or integrity no longer matches the accepted identity.                                                                                                                |
+| `restart-required` | A continued page crossed a representation revision; discard the earlier pages and restart.                                                                                                       |
+
+A metadata page contains at most 100 versions. Clients must follow every
+continuation and check the revision and result keys before selecting a version;
+truncated pages are never complete selection input. Continuation tokens are
+opaque and must be bound by the Registry to the request identity, credential
+context, and revision. A changed binding, hold, visibility, yank, archival or
+deprecation fact must invalidate an `unchanged` result. Backend failures are
+envelope errors, never invented per-item absence. The query is private and
+non-cacheable across commands; its POST method does not make publish mutations
+retryable.
+
+The schema exports the item, version-page, request-body, and response-body
+limits. A server checks encoded body size before decoding and returns the
+declared `request-too-large` error when exceeded. Request keys correlate results
+only; they confer no identity or access.
+
+The exported `./unstable/registry/resolution-metadata.vectors.json` records
+selection examples for ordinary and exact yanks, release age, direct and pack
+constraints, package compatibility, and publisher-binding changes. Producer and
+consumer tests can use the same cases without moving selection to the server.
+
+The byte-vendorable
+`./unstable/registry/publication-set.vectors.json` export pins digest
+conformance examples for independent implementations of the public protocol.
+Its metadata describes the canonicalization and optional-field rules; changing
+the digest algorithm requires a new contract identifier and vector format
+rather than editing the meaning of existing vectors.
+
 Content parsing, Knowledge inspection, the lint catalog, and archive and
 manifest validation live in `@agentxm/extension-content`; version selection
-and release-age policy live in `@agentxm/extension-resolution`.
+and release-age policy live in `@agentxm/workspace/resolution`.
 
-Every export lives under an explicit `./unstable/*` subpath: the surface is
-unsupported and may change in any release. Ordinary users should use the
-[`axm` CLI](https://axm.sh) instead.
+This package is bundled into `axm.sh`; it is not an independently published
+API. Its `./unstable/*` subpaths are workspace-internal boundaries. Ordinary
+users should use the [`axm` CLI](https://axm.sh) instead.
 
 FSL-1.1-MIT © 2025-2026 AgentXM, Inc.

package/dist/src/unstable/human-handoff.d.ts

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 /** Public references describe pending work; they never convey exchange authority. */
 export declare const HumanHandoffActionSchema: Schema.Struct<{
     readonly kind: Schema.Literal<"open-url">;
-    readonly purpose: Schema.Literals<readonly ["login", "step-up", "publish"]>;
+    readonly purpose: Schema.Literals<readonly ["login", "step-up"]>;
     readonly requestRef: Schema.String;
     readonly registryUrl: Schema.String;
     readonly url: Schema.String;

package/dist/src/unstable/human-handoff.js

@@ -2,7 +2,7 @@ import * as Schema from "effect/Schema";
 /** Public references describe pending work; they never convey exchange authority. */
 export const HumanHandoffActionSchema = Schema.Struct({
     kind: Schema.Literal("open-url"),
-    purpose: Schema.Literals(["login", "step-up", "publish"]),
+    purpose: Schema.Literals(["login", "step-up"]),
     requestRef: Schema.String,
     registryUrl: Schema.String,
     url: Schema.String,

package/dist/src/unstable/registry/discover-schema.d.ts

@@ -4,44 +4,289 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
-export declare const DiscoveryResolvedExtensionSchema: Schema.Struct<{
+/** A normalized recommendation submitted for package-side attestation. */
+export declare const DiscoveryDeclaredExtensionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly url: Schema.URLFromString;
+    }>;
+    readonly versionRange: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+}>, Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly url: Schema.URLFromString;
+        readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+}>, Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"path">;
+        readonly path: Schema.NonEmptyString;
+    }>;
+}>]>;
+export type DiscoveryDeclaredExtension = Schema.Schema.Type<typeof DiscoveryDeclaredExtensionSchema>;
+export declare const DiscoverPackageInputSchema: Schema.Struct<{
+    readonly purl: Schema.String;
+    readonly version: Schema.String;
+    readonly declaredExtensions: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly ref: Schema.String;
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"registry">;
+            readonly url: Schema.URLFromString;
+        }>;
+        readonly versionRange: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+    }>, Schema.Struct<{
+        readonly ref: Schema.String;
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"git">;
+            readonly url: Schema.URLFromString;
+            readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+        }>;
+    }>, Schema.Struct<{
+        readonly ref: Schema.String;
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"path">;
+            readonly path: Schema.NonEmptyString;
+        }>;
+    }>]>>;
+}>;
+export type DiscoverPackageInput = Schema.Schema.Type<typeof DiscoverPackageInputSchema>;
+export declare const DiscoverPackagesRequestSchema: Schema.Struct<{
+    readonly client: Schema.Struct<{
+        readonly axmVersion: Schema.String;
+    }>;
+    readonly packages: Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.String;
+        readonly version: Schema.String;
+        readonly declaredExtensions: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly ref: Schema.String;
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"registry">;
+                readonly url: Schema.URLFromString;
+            }>;
+            readonly versionRange: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+        }>, Schema.Struct<{
+            readonly ref: Schema.String;
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"git">;
+                readonly url: Schema.URLFromString;
+                readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+            }>;
+        }>, Schema.Struct<{
+            readonly ref: Schema.String;
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"path">;
+                readonly path: Schema.NonEmptyString;
+            }>;
+        }>]>>;
+    }>>;
+}>;
+export type DiscoverPackagesRequest = Schema.Schema.Type<typeof DiscoverPackagesRequestSchema>;
+export declare const DiscoveryRegistryResolutionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"registry">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+}>;
+export declare const DiscoveryGitResolutionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"git">;
+    readonly url: Schema.URLFromString;
+    readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+}>;
+export declare const DiscoveryPathResolutionSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"path">;
+    readonly path: Schema.NonEmptyString;
+}>;
+export declare const DiscoveryRegistryResolvedExtensionSchema: Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly version: Schema.brand<Schema.String, "Version">;
+    }>;
+}>;
+export declare const DiscoveryGitResolvedExtensionSchema: Schema.Struct<{
     readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
-    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "packs" | "skills" | "mcps" | "subagents" | "rules" | "hooks")[]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
     readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
-    readonly installVersion: Schema.brand<Schema.String, "Version">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly url: Schema.URLFromString;
+        readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
 }>;
+export declare const DiscoveryPathResolvedExtensionSchema: Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"path">;
+        readonly path: Schema.NonEmptyString;
+    }>;
+}>;
+export declare const DiscoveryResolvedExtensionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly version: Schema.brand<Schema.String, "Version">;
+    }>;
+}>, Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly url: Schema.URLFromString;
+        readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+}>, Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly resolution: Schema.Struct<{
+        readonly type: Schema.Literal<"path">;
+        readonly path: Schema.NonEmptyString;
+    }>;
+}>]>;
 export type DiscoveryResolvedExtension = Schema.Schema.Type<typeof DiscoveryResolvedExtensionSchema>;
-export declare const DiscoveryExtensionResultSchema: Schema.Struct<{
+export declare const DiscoveryExtensionResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"registry">;
+        readonly url: Schema.URLFromString;
+    }>;
+    readonly extension: Schema.optional<Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolution: Schema.Struct<{
+            readonly type: Schema.Literal<"registry">;
+            readonly version: Schema.brand<Schema.String, "Version">;
+        }>;
+    }>>;
+    readonly official: Schema.Boolean;
     readonly ref: Schema.String;
     readonly resolved: Schema.Boolean;
+    readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+    readonly packageVersionInRange: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"git">;
+        readonly url: Schema.URLFromString;
+        readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
     readonly extension: Schema.optional<Schema.Struct<{
         readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
-        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "packs" | "skills" | "mcps" | "subagents" | "rules" | "hooks")[]>;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
         readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
-        readonly installVersion: Schema.brand<Schema.String, "Version">;
+        readonly resolution: Schema.Struct<{
+            readonly type: Schema.Literal<"git">;
+            readonly url: Schema.URLFromString;
+            readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+        }>;
     }>>;
+    readonly official: Schema.Literal<false>;
+    readonly ref: Schema.String;
+    readonly resolved: Schema.Boolean;
     readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
-    readonly official: Schema.Boolean;
     readonly packageVersionInRange: Schema.Boolean;
-}>;
+}>, Schema.Struct<{
+    readonly source: Schema.Struct<{
+        readonly type: Schema.Literal<"path">;
+        readonly path: Schema.NonEmptyString;
+    }>;
+    readonly extension: Schema.optional<Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly resolution: Schema.Struct<{
+            readonly type: Schema.Literal<"path">;
+            readonly path: Schema.NonEmptyString;
+        }>;
+    }>>;
+    readonly official: Schema.Literal<false>;
+    readonly ref: Schema.String;
+    readonly resolved: Schema.Boolean;
+    readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+    readonly packageVersionInRange: Schema.Boolean;
+}>]>;
 export type DiscoveryExtensionResult = Schema.Schema.Type<typeof DiscoveryExtensionResultSchema>;
 export declare const DiscoveryPackageResultSchema: Schema.Struct<{
     readonly purl: Schema.String;
     readonly version: Schema.String;
     readonly status: Schema.Literals<readonly ["resolved", "invalid_purl"]>;
-    readonly extensions: Schema.$Array<Schema.Struct<{
+    readonly extensions: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"registry">;
+            readonly url: Schema.URLFromString;
+        }>;
+        readonly extension: Schema.optional<Schema.Struct<{
+            readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+            readonly resolution: Schema.Struct<{
+                readonly type: Schema.Literal<"registry">;
+                readonly version: Schema.brand<Schema.String, "Version">;
+            }>;
+        }>>;
+        readonly official: Schema.Boolean;
         readonly ref: Schema.String;
         readonly resolved: Schema.Boolean;
+        readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+        readonly packageVersionInRange: Schema.Boolean;
+    }>, Schema.Struct<{
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"git">;
+            readonly url: Schema.URLFromString;
+            readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+        }>;
         readonly extension: Schema.optional<Schema.Struct<{
             readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
-            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "packs" | "skills" | "mcps" | "subagents" | "rules" | "hooks")[]>;
+            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
             readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
-            readonly installVersion: Schema.brand<Schema.String, "Version">;
+            readonly resolution: Schema.Struct<{
+                readonly type: Schema.Literal<"git">;
+                readonly url: Schema.URLFromString;
+                readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+            }>;
         }>>;
+        readonly official: Schema.Literal<false>;
+        readonly ref: Schema.String;
+        readonly resolved: Schema.Boolean;
         readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
-        readonly official: Schema.Boolean;
         readonly packageVersionInRange: Schema.Boolean;
-    }>>;
+    }>, Schema.Struct<{
+        readonly source: Schema.Struct<{
+            readonly type: Schema.Literal<"path">;
+            readonly path: Schema.NonEmptyString;
+        }>;
+        readonly extension: Schema.optional<Schema.Struct<{
+            readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+            readonly resolution: Schema.Struct<{
+                readonly type: Schema.Literal<"path">;
+                readonly path: Schema.NonEmptyString;
+            }>;
+        }>>;
+        readonly official: Schema.Literal<false>;
+        readonly ref: Schema.String;
+        readonly resolved: Schema.Boolean;
+        readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+        readonly packageVersionInRange: Schema.Boolean;
+    }>]>>;
 }>;
 export type DiscoveryPackageResult = Schema.Schema.Type<typeof DiscoveryPackageResultSchema>;
 export declare const DiscoverPackagesResponseSchema: Schema.Struct<{
@@ -49,19 +294,68 @@ export declare const DiscoverPackagesResponseSchema: Schema.Struct<{
         readonly purl: Schema.String;
         readonly version: Schema.String;
         readonly status: Schema.Literals<readonly ["resolved", "invalid_purl"]>;
-        readonly extensions: Schema.$Array<Schema.Struct<{
+        readonly extensions: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"registry">;
+                readonly url: Schema.URLFromString;
+            }>;
+            readonly extension: Schema.optional<Schema.Struct<{
+                readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+                readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+                readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+                readonly resolution: Schema.Struct<{
+                    readonly type: Schema.Literal<"registry">;
+                    readonly version: Schema.brand<Schema.String, "Version">;
+                }>;
+            }>>;
+            readonly official: Schema.Boolean;
+            readonly ref: Schema.String;
+            readonly resolved: Schema.Boolean;
+            readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+            readonly packageVersionInRange: Schema.Boolean;
+        }>, Schema.Struct<{
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"git">;
+                readonly url: Schema.URLFromString;
+                readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+            }>;
+            readonly extension: Schema.optional<Schema.Struct<{
+                readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+                readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
+                readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+                readonly resolution: Schema.Struct<{
+                    readonly type: Schema.Literal<"git">;
+                    readonly url: Schema.URLFromString;
+                    readonly path: Schema.optionalKey<Schema.NonEmptyString>;
+                    readonly revision: Schema.optionalKey<Schema.NonEmptyString>;
+                }>;
+            }>>;
+            readonly official: Schema.Literal<false>;
             readonly ref: Schema.String;
             readonly resolved: Schema.Boolean;
+            readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+            readonly packageVersionInRange: Schema.Boolean;
+        }>, Schema.Struct<{
+            readonly source: Schema.Struct<{
+                readonly type: Schema.Literal<"path">;
+                readonly path: Schema.NonEmptyString;
+            }>;
             readonly extension: Schema.optional<Schema.Struct<{
                 readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
-                readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "packs" | "skills" | "mcps" | "subagents" | "rules" | "hooks")[]>;
+                readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "rules" | "hooks" | "packs")[]>;
                 readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
-                readonly installVersion: Schema.brand<Schema.String, "Version">;
+                readonly resolution: Schema.Struct<{
+                    readonly type: Schema.Literal<"path">;
+                    readonly path: Schema.NonEmptyString;
+                }>;
             }>>;
+            readonly official: Schema.Literal<false>;
+            readonly ref: Schema.String;
+            readonly resolved: Schema.Boolean;
             readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
-            readonly official: Schema.Boolean;
             readonly packageVersionInRange: Schema.Boolean;
-        }>>;
+        }>]>>;
     }>>;
 }>;
 export type DiscoverPackagesResponse = Schema.Schema.Type<typeof DiscoverPackagesResponseSchema>;

package/dist/src/unstable/registry/discover-schema.js

@@ -4,25 +4,89 @@
  * @experimental This API is unstable and may change without notice.
  */
 import * as Schema from "effect/Schema";
-import { ExtensionNameSchema, extensionTypePluralSegments, extensionTypes, } from "@agentxm/extension-model/unstable/extensions/common";
+import { ExtensionFqnSchema, ExtensionNameSchema, extensionTypePluralSegments, extensionTypes, } from "@agentxm/extension-model/unstable/extensions/common";
 import { HandleSchema, SlugSchema } from "@agentxm/extension-model/unstable/extensions/handle";
-import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
+import { AgentExtensionGitSourceSchema, AgentExtensionPathSourceSchema, AgentExtensionRegistrySourceSchema, } from "@agentxm/extension-model/unstable/recommendations/agent-extensions";
+import { VersionRangeSchema, VersionSchema, } from "@agentxm/extension-model/unstable/version-constraints";
 const discoveryExtensionWireTypes = [...extensionTypes, ...extensionTypePluralSegments];
 const DiscoveryExtensionWireTypeSchema = Schema.Literals(discoveryExtensionWireTypes);
-export const DiscoveryResolvedExtensionSchema = Schema.Struct({
+const DiscoveryRegistryDeclarationSchema = Schema.Struct({
+    ref: ExtensionFqnSchema,
+    source: AgentExtensionRegistrySourceSchema,
+    versionRange: Schema.optionalKey(VersionRangeSchema),
+});
+const DiscoveryGitDeclarationSchema = Schema.Struct({
+    ref: ExtensionFqnSchema,
+    source: AgentExtensionGitSourceSchema,
+});
+const DiscoveryPathDeclarationSchema = Schema.Struct({
+    ref: ExtensionFqnSchema,
+    source: AgentExtensionPathSourceSchema,
+});
+/** A normalized recommendation submitted for package-side attestation. */
+export const DiscoveryDeclaredExtensionSchema = Schema.Union([
+    DiscoveryRegistryDeclarationSchema,
+    DiscoveryGitDeclarationSchema,
+    DiscoveryPathDeclarationSchema,
+]);
+export const DiscoverPackageInputSchema = Schema.Struct({
+    purl: Schema.String,
+    version: Schema.String,
+    declaredExtensions: Schema.Array(DiscoveryDeclaredExtensionSchema),
+});
+export const DiscoverPackagesRequestSchema = Schema.Struct({
+    client: Schema.Struct({ axmVersion: Schema.String }),
+    packages: Schema.Array(DiscoverPackageInputSchema),
+});
+export const DiscoveryRegistryResolutionSchema = Schema.Struct({
+    type: Schema.Literal("registry"),
+    version: VersionSchema,
+});
+export const DiscoveryGitResolutionSchema = AgentExtensionGitSourceSchema;
+export const DiscoveryPathResolutionSchema = AgentExtensionPathSourceSchema;
+const makeResolvedExtensionSchema = (resolution) => Schema.Struct({
     owner: Schema.Union([HandleSchema, SlugSchema]),
     type: DiscoveryExtensionWireTypeSchema,
     name: ExtensionNameSchema,
-    installVersion: VersionSchema,
+    resolution,
 });
-export const DiscoveryExtensionResultSchema = Schema.Struct({
+export const DiscoveryRegistryResolvedExtensionSchema = makeResolvedExtensionSchema(DiscoveryRegistryResolutionSchema);
+export const DiscoveryGitResolvedExtensionSchema = makeResolvedExtensionSchema(DiscoveryGitResolutionSchema);
+export const DiscoveryPathResolvedExtensionSchema = makeResolvedExtensionSchema(DiscoveryPathResolutionSchema);
+export const DiscoveryResolvedExtensionSchema = Schema.Union([
+    DiscoveryRegistryResolvedExtensionSchema,
+    DiscoveryGitResolvedExtensionSchema,
+    DiscoveryPathResolvedExtensionSchema,
+]);
+const discoveryResultFields = {
     ref: Schema.String,
     resolved: Schema.Boolean,
-    extension: Schema.optional(DiscoveryResolvedExtensionSchema),
     attestedBy: Schema.Array(Schema.Literals(["package", "extension"])),
-    official: Schema.Boolean,
     packageVersionInRange: Schema.Boolean,
+};
+const DiscoveryRegistryExtensionResultSchema = Schema.Struct({
+    ...discoveryResultFields,
+    source: AgentExtensionRegistrySourceSchema,
+    extension: Schema.optional(DiscoveryRegistryResolvedExtensionSchema),
+    official: Schema.Boolean,
+});
+const DiscoveryGitExtensionResultSchema = Schema.Struct({
+    ...discoveryResultFields,
+    source: AgentExtensionGitSourceSchema,
+    extension: Schema.optional(DiscoveryGitResolvedExtensionSchema),
+    official: Schema.Literal(false),
+});
+const DiscoveryPathExtensionResultSchema = Schema.Struct({
+    ...discoveryResultFields,
+    source: AgentExtensionPathSourceSchema,
+    extension: Schema.optional(DiscoveryPathResolvedExtensionSchema),
+    official: Schema.Literal(false),
 });
+export const DiscoveryExtensionResultSchema = Schema.Union([
+    DiscoveryRegistryExtensionResultSchema,
+    DiscoveryGitExtensionResultSchema,
+    DiscoveryPathExtensionResultSchema,
+]);
 export const DiscoveryPackageResultSchema = Schema.Struct({
     purl: Schema.String,
     version: Schema.String,

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

@@ -3,7 +3,8 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-export { type DiscoverPackagesResponse, DiscoverPackagesResponseSchema, type DiscoveryExtensionResult, DiscoveryExtensionResultSchema, type DiscoveryPackageResult, DiscoveryPackageResultSchema, type DiscoveryResolvedExtension, DiscoveryResolvedExtensionSchema, } from "./discover-schema.js";
+export { type DiscoverPackageInput, DiscoverPackageInputSchema, type DiscoverPackagesRequest, DiscoverPackagesRequestSchema, type DiscoverPackagesResponse, DiscoverPackagesResponseSchema, type DiscoveryDeclaredExtension, DiscoveryDeclaredExtensionSchema, type DiscoveryExtensionResult, DiscoveryExtensionResultSchema, DiscoveryGitResolutionSchema, DiscoveryGitResolvedExtensionSchema, type DiscoveryPackageResult, DiscoveryPackageResultSchema, DiscoveryPathResolutionSchema, DiscoveryPathResolvedExtensionSchema, DiscoveryRegistryResolutionSchema, DiscoveryRegistryResolvedExtensionSchema, type DiscoveryResolvedExtension, DiscoveryResolvedExtensionSchema, } from "./discover-schema.js";
+export { MAX_RESOLUTION_METADATA_ITEMS, MAX_RESOLUTION_METADATA_REQUEST_BYTES, MAX_RESOLUTION_METADATA_RESPONSE_BYTES, MAX_RESOLUTION_METADATA_VERSIONS_PER_PAGE, RESOLUTION_METADATA_SCHEMA_VERSION, RESOLUTION_SELECTION_POLICY_VERSION, decodeResolutionMetadataRequestBody, type ResolutionMetadataError, ResolutionMetadataErrorSchema, ResolutionMetadataIdentitySchema, ResolutionMetadataItemSchema, type ResolutionMetadataOutcome, ResolutionMetadataOutcomeSchema, type ResolutionMetadataRequest, ResolutionMetadataRequestSchema, type ResolutionMetadataResponse, ResolutionMetadataResponseSchema, resolutionMetadataResponseMatchesRequest, } from "./resolution-metadata.js";
 export { MAX_PUBLICATION_SET_CANDIDATES, PUBLICATION_SET_CONTRACT, type PackDependencyDescriptor, type PackDependencyFinding, PackDependencyFindingSchema, type PreviewPublicationSetRequest, PreviewPublicationSetRequestSchema, type PreviewPublicationSetResponse, PreviewPublicationSetResponseSchema, type PublicationCandidateResult, type PublicationDescriptor, type PublicationPackResult, type PublicationTarget, type PublicationVisibilityInput, PublicationVisibilityInputSchema, type Sha256Hex, Sha256HexSchema, archiveSha256Hex, formatPackDependencyFinding, comparePublicationTargets, normalizePublicationDescriptor, normalizePublicationSet, publicationDescriptorDigest, publicationSetDigest, publicationTargetKey, validatePublicationDescriptors, validatePublicationSetResponse, } from "./publication-set.js";
-export { type DeprecationManagementView, DeprecationManagementViewSchema, type DeprecationReplacementIntent, DeprecationReplacementIntentSchema, DeprecationRevisionSchema, type DeprecationTransition, DeprecationTransitionSchema, type ExtensionIndex, ExtensionIndexSchema, type VersionEntry, VersionEntrySchema, packagesToPackageUrlParts, } from "./schema.js";
+export { type ArchivalManagementView, ArchivalManagementViewSchema, ArchivalRevisionSchema, type ArchivalTransition, ArchivalTransitionSchema, type DeprecationManagementView, DeprecationManagementViewSchema, type DeprecationReplacementIntent, DeprecationReplacementIntentSchema, DeprecationRevisionSchema, type DeprecationTransition, DeprecationTransitionSchema, type ExtensionIndex, ExtensionIndexSchema, type VersionEntry, VersionEntrySchema, packagesToPackageUrlParts, } from "./schema.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -3,7 +3,8 @@
  *
  * @experimental This API is unstable and may change without notice.
  */
-export { DiscoverPackagesResponseSchema, DiscoveryExtensionResultSchema, DiscoveryPackageResultSchema, DiscoveryResolvedExtensionSchema, } from "./discover-schema.js";
+export { DiscoverPackageInputSchema, DiscoverPackagesRequestSchema, DiscoverPackagesResponseSchema, DiscoveryDeclaredExtensionSchema, DiscoveryExtensionResultSchema, DiscoveryGitResolutionSchema, DiscoveryGitResolvedExtensionSchema, DiscoveryPackageResultSchema, DiscoveryPathResolutionSchema, DiscoveryPathResolvedExtensionSchema, DiscoveryRegistryResolutionSchema, DiscoveryRegistryResolvedExtensionSchema, DiscoveryResolvedExtensionSchema, } from "./discover-schema.js";
+export { MAX_RESOLUTION_METADATA_ITEMS, MAX_RESOLUTION_METADATA_REQUEST_BYTES, MAX_RESOLUTION_METADATA_RESPONSE_BYTES, MAX_RESOLUTION_METADATA_VERSIONS_PER_PAGE, RESOLUTION_METADATA_SCHEMA_VERSION, RESOLUTION_SELECTION_POLICY_VERSION, decodeResolutionMetadataRequestBody, ResolutionMetadataErrorSchema, ResolutionMetadataIdentitySchema, ResolutionMetadataItemSchema, ResolutionMetadataOutcomeSchema, ResolutionMetadataRequestSchema, ResolutionMetadataResponseSchema, resolutionMetadataResponseMatchesRequest, } from "./resolution-metadata.js";
 export { MAX_PUBLICATION_SET_CANDIDATES, PUBLICATION_SET_CONTRACT, PackDependencyFindingSchema, PreviewPublicationSetRequestSchema, PreviewPublicationSetResponseSchema, PublicationVisibilityInputSchema, Sha256HexSchema, archiveSha256Hex, formatPackDependencyFinding, comparePublicationTargets, normalizePublicationDescriptor, normalizePublicationSet, publicationDescriptorDigest, publicationSetDigest, publicationTargetKey, validatePublicationDescriptors, validatePublicationSetResponse, } from "./publication-set.js";
-export { DeprecationManagementViewSchema, DeprecationReplacementIntentSchema, DeprecationRevisionSchema, DeprecationTransitionSchema, ExtensionIndexSchema, VersionEntrySchema, packagesToPackageUrlParts, } from "./schema.js";
+export { ArchivalManagementViewSchema, ArchivalRevisionSchema, ArchivalTransitionSchema, DeprecationManagementViewSchema, DeprecationReplacementIntentSchema, DeprecationRevisionSchema, DeprecationTransitionSchema, ExtensionIndexSchema, VersionEntrySchema, packagesToPackageUrlParts, } from "./schema.js";
 //# sourceMappingURL=index.js.map