@agentxm/registry-protocol 0.31.1 → 0.33.0

package/dist/src/unstable/registry/publication-set.d.ts

@@ -1,6 +1,6 @@
 import * as Schema from "effect/Schema";
 import type { PackDependencyPolicyFinding } from "@agentxm/extension-model/unstable/packs/dependency-policy";
-import { type ExtensionName, type ExtensionType } from "@agentxm/extension-model/unstable/extensions/common";
+import { type ExtensionName, type ExtensionType, type PackMemberRegistrySource } from "@agentxm/extension-model/unstable/extensions/common";
 import { type Handle } from "@agentxm/extension-model/unstable/extensions/handle";
 import { type Version, type VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
 export declare const PUBLICATION_SET_CONTRACT: "publication-set-v2";
@@ -18,6 +18,7 @@ export interface PackDependencyDescriptor {
     readonly type: Exclude<ExtensionType, "pack">;
     readonly name: ExtensionName;
     readonly range: VersionRange;
+    readonly source?: PackMemberRegistrySource | undefined;
 }
 export declare const PublicationVisibilityInputSchema: Schema.Struct<{
     readonly intent: Schema.NullOr<Schema.Struct<{
@@ -28,6 +29,36 @@ export declare const PublicationVisibilityInputSchema: Schema.Struct<{
     readonly request: Schema.NullOr<Schema.Literals<readonly ["public", "private"]>>;
 }>;
 export type PublicationVisibilityInput = typeof PublicationVisibilityInputSchema.Type;
+export declare const PublicationDescriptorSchema: Schema.Struct<{
+    readonly target: Schema.Struct<{
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly version: Schema.brand<Schema.String, "Version">;
+    }>;
+    readonly participation: Schema.Literals<readonly ["publish", "verified-existing"]>;
+    readonly archiveSha256Hex: Schema.optional<Schema.String>;
+    readonly visibility: Schema.Struct<{
+        readonly intent: Schema.NullOr<Schema.Struct<{
+            readonly value: Schema.Literals<readonly ["public", "private"]>;
+            readonly source: Schema.Literals<readonly ["manifest", "workspace"]>;
+            readonly fingerprint: Schema.String;
+        }>>;
+        readonly request: Schema.NullOr<Schema.Literals<readonly ["public", "private"]>>;
+    }>;
+    readonly pack: Schema.optional<Schema.Struct<{
+        readonly dependencies: Schema.$Array<Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "Handle">;
+            readonly type: Schema.Literals<readonly ["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+            readonly range: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+            readonly source: Schema.optional<Schema.Struct<{
+                readonly type: Schema.Literal<"registry">;
+                readonly url: Schema.URLFromString;
+            }>>;
+        }>>;
+    }>>;
+}>;
 export interface PublicationDescriptor {
     readonly target: PublicationTarget;
     readonly participation: "publish" | "verified-existing";
@@ -62,6 +93,10 @@ export declare const PreviewPublicationSetRequestSchema: Schema.Struct<{
                 readonly type: Schema.Literals<readonly ["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]>;
                 readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
                 readonly range: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+                readonly source: Schema.optional<Schema.Struct<{
+                    readonly type: Schema.Literal<"registry">;
+                    readonly url: Schema.URLFromString;
+                }>>;
             }>>;
         }>>;
     }>>;
@@ -80,6 +115,10 @@ export declare const PackDependencyFindingSchema: Schema.Struct<{
         readonly type: Schema.Literals<readonly ["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]>;
         readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
         readonly range: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+        readonly source: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"registry">;
+            readonly url: Schema.URLFromString;
+        }>>;
     }>;
     readonly effectiveVisibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
     readonly lifecycle: Schema.optional<Schema.Literals<readonly ["active", "unavailable"]>>;
@@ -200,6 +239,10 @@ export declare const PreviewPublicationSetResponseSchema: Schema.Struct<{
                 readonly type: Schema.Literals<readonly ["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]>;
                 readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
                 readonly range: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+                readonly source: Schema.optional<Schema.Struct<{
+                    readonly type: Schema.Literal<"registry">;
+                    readonly url: Schema.URLFromString;
+                }>>;
             }>;
             readonly effectiveVisibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
             readonly lifecycle: Schema.optional<Schema.Literals<readonly ["active", "unavailable"]>>;
@@ -241,6 +284,10 @@ export declare const PreviewPublicationSetResponseSchema: Schema.Struct<{
                 readonly type: Schema.Literals<readonly ["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]>;
                 readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
                 readonly range: Schema.brand<Schema.NonEmptyString, "VersionRange">;
+                readonly source: Schema.optional<Schema.Struct<{
+                    readonly type: Schema.Literal<"registry">;
+                    readonly url: Schema.URLFromString;
+                }>>;
             }>;
             readonly effectiveVersion: Schema.brand<Schema.String, "Version">;
         }>>;
@@ -250,10 +297,10 @@ export type PreviewPublicationSetResponse = typeof PreviewPublicationSetResponse
 export type PublicationCandidateResult = PreviewPublicationSetResponse["candidates"][number];
 export type PublicationPackResult = PreviewPublicationSetResponse["packs"][number];
 export declare const comparePublicationTargets: (left: PublicationTarget, right: PublicationTarget) => number;
-export declare const normalizePublicationDescriptor: (descriptor: PublicationDescriptor) => PublicationDescriptor;
-export declare const normalizePublicationSet: (descriptors: ReadonlyArray<PublicationDescriptor>) => ReadonlyArray<PublicationDescriptor>;
-export declare const publicationDescriptorDigest: (descriptor: PublicationDescriptor) => Sha256Hex;
-export declare const publicationSetDigest: (descriptors: ReadonlyArray<PublicationDescriptor>) => Sha256Hex;
+export declare const normalizePublicationDescriptor: (input: unknown) => PublicationDescriptor;
+export declare const normalizePublicationSet: (descriptors: ReadonlyArray<unknown>) => ReadonlyArray<PublicationDescriptor>;
+export declare const publicationDescriptorDigest: (descriptor: unknown) => Sha256Hex;
+export declare const publicationSetDigest: (descriptors: ReadonlyArray<unknown>) => Sha256Hex;
 export declare const archiveSha256Hex: (archive: Uint8Array) => Sha256Hex;
 export declare const publicationTargetKey: (target: PublicationTarget) => string;
 export declare const validatePublicationDescriptors: (descriptors: ReadonlyArray<PublicationDescriptor>) => ReadonlyArray<PublicationDescriptor>;

package/dist/src/unstable/registry/publication-set.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import * as Schema from "effect/Schema";
 import * as semver from "semver";
 import { SuggestedActionSchema } from "../suggested-action.js";
-import { ExtensionNameSchema, ExtensionTypeSchema, ExtensionVisibilitySchema, } from "@agentxm/extension-model/unstable/extensions/common";
+import { ExtensionNameSchema, ExtensionTypeSchema, ExtensionVisibilitySchema, PackMemberRegistrySourceSchema, } from "@agentxm/extension-model/unstable/extensions/common";
 import { formatFqn } from "@agentxm/extension-model/unstable/extensions/fqn";
 import { HandleSchema } from "@agentxm/extension-model/unstable/extensions/handle";
 import { VisibilityEvaluationSchema, VisibilityEvaluationUnavailableSchema, VisibilityIntentSchema, } from "../publish/visibility.js";
@@ -24,12 +24,13 @@ const PackDependencyDescriptorSchema = Schema.Struct({
     type: Schema.Literals(["hook", "knowledge", "mcp-server", "rule", "skill", "subagent"]),
     name: ExtensionNameSchema,
     range: VersionRangeSchema,
+    source: Schema.optional(PackMemberRegistrySourceSchema),
 }).annotate({ identifier: "PackDependencyDescriptor" });
 export const PublicationVisibilityInputSchema = Schema.Struct({
     intent: Schema.NullOr(VisibilityIntentSchema),
     request: Schema.NullOr(ExtensionVisibilitySchema),
 }).annotate({ identifier: "PublicationVisibilityInput" });
-const PublicationDescriptorSchema = Schema.Struct({
+export const PublicationDescriptorSchema = Schema.Struct({
     target: PublicationTargetSchema,
     participation: Schema.Literals(["publish", "verified-existing"]),
     archiveSha256Hex: Schema.optional(Sha256HexSchema),
@@ -38,6 +39,10 @@ const PublicationDescriptorSchema = Schema.Struct({
         dependencies: Schema.Array(PackDependencyDescriptorSchema),
     })),
 }).annotate({ identifier: "PublicationDescriptor" });
+const PublicationDescriptorInputSchema = Schema.Union([
+    PublicationDescriptorSchema,
+    Schema.toType(PublicationDescriptorSchema),
+]);
 export const PreviewPublicationSetRequestSchema = Schema.Struct({
     contract: Schema.Literal(PUBLICATION_SET_CONTRACT),
     candidates: Schema.Array(PublicationDescriptorSchema),
@@ -205,34 +210,90 @@ export const comparePublicationTargets = (left, right) => compareText(left.owner
 const compareDependencies = (left, right) => compareText(left.owner, right.owner) ||
     compareText(left.type, right.type) ||
     compareText(left.name, right.name) ||
-    compareText(left.range, right.range);
-export const normalizePublicationDescriptor = (descriptor) => ({
-    target: descriptor.target,
-    participation: descriptor.participation,
-    visibility: descriptor.visibility,
-    ...(descriptor.archiveSha256Hex === undefined
-        ? {}
-        : { archiveSha256Hex: descriptor.archiveSha256Hex }),
-    ...(descriptor.pack === undefined
-        ? {}
-        : {
-            pack: {
-                dependencies: [...descriptor.pack.dependencies].sort(compareDependencies),
-            },
-        }),
-});
+    compareText(left.range, right.range) ||
+    compareText(left.source?.url.href ?? "", right.source?.url.href ?? "");
+export const normalizePublicationDescriptor = (input) => {
+    const descriptor = Schema.decodeUnknownSync(PublicationDescriptorInputSchema)(input);
+    return {
+        target: {
+            owner: descriptor.target.owner,
+            type: descriptor.target.type,
+            name: descriptor.target.name,
+            version: descriptor.target.version,
+        },
+        participation: descriptor.participation,
+        visibility: {
+            intent: descriptor.visibility.intent === null
+                ? null
+                : {
+                    value: descriptor.visibility.intent.value,
+                    source: descriptor.visibility.intent.source,
+                    fingerprint: descriptor.visibility.intent.fingerprint,
+                },
+            request: descriptor.visibility.request,
+        },
+        ...(descriptor.archiveSha256Hex === undefined
+            ? {}
+            : { archiveSha256Hex: descriptor.archiveSha256Hex }),
+        ...(descriptor.pack === undefined
+            ? {}
+            : {
+                pack: {
+                    dependencies: descriptor.pack.dependencies
+                        .map((dependency) => ({
+                        owner: dependency.owner,
+                        type: dependency.type,
+                        name: dependency.name,
+                        range: dependency.range,
+                        ...(dependency.source === undefined
+                            ? {}
+                            : {
+                                source: {
+                                    type: dependency.source.type,
+                                    url: dependency.source.url,
+                                },
+                            }),
+                    }))
+                        .sort(compareDependencies),
+                },
+            }),
+    };
+};
 export const normalizePublicationSet = (descriptors) => descriptors
     .map(normalizePublicationDescriptor)
     .sort((left, right) => comparePublicationTargets(left.target, right.target));
 const canonicalBytes = (value) => new TextEncoder().encode(JSON.stringify(value));
+const canonicalPublicationDescriptor = (input) => {
+    const descriptor = normalizePublicationDescriptor(input);
+    return {
+        ...descriptor,
+        ...(descriptor.pack === undefined
+            ? {}
+            : {
+                pack: {
+                    dependencies: descriptor.pack.dependencies.map((dependency) => ({
+                        ...dependency,
+                        ...(dependency.source === undefined
+                            ? {}
+                            : {
+                                source: {
+                                    type: dependency.source.type,
+                                    url: dependency.source.url.href,
+                                },
+                            }),
+                    })),
+                },
+            }),
+    };
+};
 const sha256Hex = (bytes) => Schema.decodeUnknownSync(Sha256HexSchema)(createHash("sha256").update(bytes).digest("hex"));
 export const publicationDescriptorDigest = (descriptor) => sha256Hex(canonicalBytes({
     contract: PUBLICATION_SET_CONTRACT,
-    descriptor: normalizePublicationDescriptor(descriptor),
+    descriptor: canonicalPublicationDescriptor(descriptor),
 }));
 export const publicationSetDigest = (descriptors) => sha256Hex(canonicalBytes({
     contract: PUBLICATION_SET_CONTRACT,
-    candidates: normalizePublicationSet(descriptors),
+    candidates: normalizePublicationSet(descriptors).map(canonicalPublicationDescriptor),
 }));
 export const archiveSha256Hex = (archive) => sha256Hex(archive);
 export const publicationTargetKey = (target) => JSON.stringify([target.owner, target.type, target.name, target.version]);
@@ -241,12 +302,9 @@ export const validatePublicationDescriptors = (descriptors) => {
     if (descriptors.length > MAX_PUBLICATION_SET_CANDIDATES) {
         throw new RangeError(`Publication sets accept at most ${MAX_PUBLICATION_SET_CANDIDATES} candidates.`);
     }
-    Schema.decodeUnknownSync(PreviewPublicationSetRequestSchema)({
-        contract: PUBLICATION_SET_CONTRACT,
-        candidates: descriptors,
-    });
+    const normalized = normalizePublicationSet(descriptors);
     const identities = new Set();
-    for (const descriptor of descriptors) {
+    for (const descriptor of normalized) {
         const key = publicationIdentityKey(descriptor.target);
         if (identities.has(key)) {
             throw new TypeError(`Duplicate publication target ${key}.`);
@@ -259,7 +317,7 @@ export const validatePublicationDescriptors = (descriptors) => {
             throw new TypeError("Pack declarations are required exactly for pack candidates.");
         }
     }
-    return normalizePublicationSet(descriptors);
+    return normalized;
 };
 const dependencyIdentityKey = (dependency) => `${dependency.owner}\u0000${dependency.type}\u0000${dependency.name}`;
 export const validatePublicationSetResponse = (descriptors, response) => {

package/dist/src/unstable/registry/resolution-metadata.d.ts

@@ -0,0 +1,351 @@
+/**
+ * Repeat-safe Registry metadata query contract. Selection stays with the client;
+ * each response page is evidence for one authorized identity and revision.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import * as Result from "effect/Result";
+export declare const RESOLUTION_METADATA_SCHEMA_VERSION = 1;
+export declare const RESOLUTION_SELECTION_POLICY_VERSION = "1";
+export declare const MAX_RESOLUTION_METADATA_ITEMS = 100;
+export declare const MAX_RESOLUTION_METADATA_VERSIONS_PER_PAGE = 100;
+export declare const MAX_RESOLUTION_METADATA_REQUEST_BYTES: number;
+export declare const MAX_RESOLUTION_METADATA_RESPONSE_BYTES: number;
+export declare const ResolutionMetadataIdentitySchema: Schema.Struct<{
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+}>;
+export declare const ResolutionMetadataItemSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly purpose: Schema.Literal<"select">;
+    readonly key: Schema.NonEmptyString;
+    readonly identity: Schema.Struct<{
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    }>;
+    readonly expectedPublisherBinding: Schema.optional<Schema.NonEmptyString>;
+    readonly knownRevision: Schema.optional<Schema.NonEmptyString>;
+    readonly continuation: Schema.optional<Schema.Struct<{
+        readonly token: Schema.NonEmptyString;
+        readonly revision: Schema.NonEmptyString;
+    }>>;
+}>, Schema.Struct<{
+    readonly purpose: Schema.Literal<"restore-exact">;
+    readonly accepted: Schema.Struct<{
+        readonly version: Schema.brand<Schema.String, "Version">;
+        readonly integrity: Schema.NonEmptyString;
+    }>;
+    readonly key: Schema.NonEmptyString;
+    readonly identity: Schema.Struct<{
+        readonly owner: Schema.brand<Schema.String, "Handle">;
+        readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    }>;
+    readonly expectedPublisherBinding: Schema.optional<Schema.NonEmptyString>;
+    readonly knownRevision: Schema.optional<Schema.NonEmptyString>;
+    readonly continuation: Schema.optional<Schema.Struct<{
+        readonly token: Schema.NonEmptyString;
+        readonly revision: Schema.NonEmptyString;
+    }>>;
+}>]>;
+export declare const ResolutionMetadataRequestSchema: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly selectionPolicyVersion: Schema.Literal<"1">;
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly purpose: Schema.Literal<"select">;
+        readonly key: Schema.NonEmptyString;
+        readonly identity: Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "Handle">;
+            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        }>;
+        readonly expectedPublisherBinding: Schema.optional<Schema.NonEmptyString>;
+        readonly knownRevision: Schema.optional<Schema.NonEmptyString>;
+        readonly continuation: Schema.optional<Schema.Struct<{
+            readonly token: Schema.NonEmptyString;
+            readonly revision: Schema.NonEmptyString;
+        }>>;
+    }>, Schema.Struct<{
+        readonly purpose: Schema.Literal<"restore-exact">;
+        readonly accepted: Schema.Struct<{
+            readonly version: Schema.brand<Schema.String, "Version">;
+            readonly integrity: Schema.NonEmptyString;
+        }>;
+        readonly key: Schema.NonEmptyString;
+        readonly identity: Schema.Struct<{
+            readonly owner: Schema.brand<Schema.String, "Handle">;
+            readonly type: Schema.Literals<readonly ("skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack")[]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        }>;
+        readonly expectedPublisherBinding: Schema.optional<Schema.NonEmptyString>;
+        readonly knownRevision: Schema.optional<Schema.NonEmptyString>;
+        readonly continuation: Schema.optional<Schema.Struct<{
+            readonly token: Schema.NonEmptyString;
+            readonly revision: Schema.NonEmptyString;
+        }>>;
+    }>]>>;
+}>;
+export type ResolutionMetadataRequest = typeof ResolutionMetadataRequestSchema.Type;
+export declare const ResolutionMetadataOutcomeSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"metadata">;
+    readonly page: Schema.Struct<{
+        readonly versions: Schema.$Array<Schema.Struct<{
+            readonly version: Schema.brand<Schema.String, "Version">;
+            readonly published: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly dependencies: Schema.optional<Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>>;
+            readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+                readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+                    readonly raw: Schema.NonEmptyString;
+                    readonly scheme: Schema.NonEmptyString;
+                    readonly constraints: Schema.$Array<Schema.Struct<{
+                        readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                        readonly version: Schema.NonEmptyString;
+                    }>>;
+                }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+            }>>>;
+            readonly integrity: Schema.String;
+            readonly yankedAt: Schema.optional<Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>>;
+            readonly yankCategory: Schema.optional<Schema.String>;
+            readonly yankNotice: Schema.optional<Schema.String>;
+        }>>;
+        readonly continuation: Schema.NullOr<Schema.NonEmptyString>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly type: Schema.optional<Schema.NonEmptyString>;
+            readonly url: Schema.NonEmptyString;
+            readonly directory: Schema.optional<Schema.NonEmptyString>;
+        }>]>>;
+        readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly url: Schema.optional<Schema.NonEmptyString>;
+            readonly email: Schema.optional<Schema.NonEmptyString>;
+        }>]>>;
+        readonly license: Schema.optional<Schema.String>;
+        readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly email: Schema.optional<Schema.String>;
+            readonly url: Schema.optional<Schema.String>;
+        }>>>;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly visibility: Schema.Literals<readonly ["public", "private"]>;
+        readonly archival: Schema.NullOr<Schema.Struct<{
+            readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly reason: Schema.optional<Schema.String>;
+        }>>;
+        readonly deprecation: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+            readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly message: Schema.String;
+            readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"available">;
+                readonly fqn: Schema.String;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"unavailable">;
+                readonly fqn: Schema.optional<Schema.String>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly message: Schema.optional<Schema.String>;
+            readonly replacement: Schema.Union<readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"available">;
+                readonly fqn: Schema.String;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"unavailable">;
+                readonly fqn: Schema.optional<Schema.String>;
+            }>]>;
+        }>]>>;
+        readonly revision: Schema.NonEmptyString;
+        readonly observedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly validUntil: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+    }>;
+}>, Schema.Struct<{
+    readonly exactVersion: Schema.optional<Schema.brand<Schema.String, "Version">>;
+    readonly publisherBindingId: Schema.NonEmptyString;
+    readonly visibility: Schema.Literals<readonly ["public", "private"]>;
+    readonly archival: Schema.NullOr<Schema.Struct<{
+        readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly reason: Schema.optional<Schema.String>;
+    }>>;
+    readonly deprecation: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+        readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly message: Schema.String;
+        readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"available">;
+            readonly fqn: Schema.String;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"unavailable">;
+            readonly fqn: Schema.optional<Schema.String>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly message: Schema.optional<Schema.String>;
+        readonly replacement: Schema.Union<readonly [Schema.Struct<{
+            readonly status: Schema.Literal<"available">;
+            readonly fqn: Schema.String;
+        }>, Schema.Struct<{
+            readonly status: Schema.Literal<"unavailable">;
+            readonly fqn: Schema.optional<Schema.String>;
+        }>]>;
+    }>]>>;
+    readonly revision: Schema.NonEmptyString;
+    readonly observedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+    readonly validUntil: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"unchanged">;
+}>, Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"unavailable">;
+}>, Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"binding-conflict">;
+    readonly publisherBindingId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"exact-conflict">;
+    readonly reason: Schema.Literals<readonly ["version-unavailable", "integrity-mismatch"]>;
+}>, Schema.Struct<{
+    readonly key: Schema.NonEmptyString;
+    readonly outcome: Schema.Literal<"restart-required">;
+    readonly revision: Schema.NonEmptyString;
+}>]>;
+export type ResolutionMetadataOutcome = typeof ResolutionMetadataOutcomeSchema.Type;
+export declare const ResolutionMetadataResponseSchema: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly selectionPolicyVersion: Schema.Literal<"1">;
+    readonly observedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+    readonly results: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"metadata">;
+        readonly page: Schema.Struct<{
+            readonly versions: Schema.$Array<Schema.Struct<{
+                readonly version: Schema.brand<Schema.String, "Version">;
+                readonly published: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+                readonly dependencies: Schema.optional<Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>>;
+                readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+                    readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+                        readonly raw: Schema.NonEmptyString;
+                        readonly scheme: Schema.NonEmptyString;
+                        readonly constraints: Schema.$Array<Schema.Struct<{
+                            readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                            readonly version: Schema.NonEmptyString;
+                        }>>;
+                    }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+                }>>>;
+                readonly integrity: Schema.String;
+                readonly yankedAt: Schema.optional<Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>>;
+                readonly yankCategory: Schema.optional<Schema.String>;
+                readonly yankNotice: Schema.optional<Schema.String>;
+            }>>;
+            readonly continuation: Schema.NullOr<Schema.NonEmptyString>;
+            readonly description: Schema.optional<Schema.String>;
+            readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly type: Schema.optional<Schema.NonEmptyString>;
+                readonly url: Schema.NonEmptyString;
+                readonly directory: Schema.optional<Schema.NonEmptyString>;
+            }>]>>;
+            readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly url: Schema.optional<Schema.NonEmptyString>;
+                readonly email: Schema.optional<Schema.NonEmptyString>;
+            }>]>>;
+            readonly license: Schema.optional<Schema.String>;
+            readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly email: Schema.optional<Schema.String>;
+                readonly url: Schema.optional<Schema.String>;
+            }>>>;
+            readonly publisherBindingId: Schema.NonEmptyString;
+            readonly visibility: Schema.Literals<readonly ["public", "private"]>;
+            readonly archival: Schema.NullOr<Schema.Struct<{
+                readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+                readonly reason: Schema.optional<Schema.String>;
+            }>>;
+            readonly deprecation: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+                readonly message: Schema.String;
+                readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                    readonly status: Schema.Literal<"available">;
+                    readonly fqn: Schema.String;
+                }>, Schema.Struct<{
+                    readonly status: Schema.Literal<"unavailable">;
+                    readonly fqn: Schema.optional<Schema.String>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+                readonly message: Schema.optional<Schema.String>;
+                readonly replacement: Schema.Union<readonly [Schema.Struct<{
+                    readonly status: Schema.Literal<"available">;
+                    readonly fqn: Schema.String;
+                }>, Schema.Struct<{
+                    readonly status: Schema.Literal<"unavailable">;
+                    readonly fqn: Schema.optional<Schema.String>;
+                }>]>;
+            }>]>>;
+            readonly revision: Schema.NonEmptyString;
+            readonly observedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly validUntil: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly exactVersion: Schema.optional<Schema.brand<Schema.String, "Version">>;
+        readonly publisherBindingId: Schema.NonEmptyString;
+        readonly visibility: Schema.Literals<readonly ["public", "private"]>;
+        readonly archival: Schema.NullOr<Schema.Struct<{
+            readonly archivedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly reason: Schema.optional<Schema.String>;
+        }>>;
+        readonly deprecation: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+            readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly message: Schema.String;
+            readonly replacement: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"available">;
+                readonly fqn: Schema.String;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"unavailable">;
+                readonly fqn: Schema.optional<Schema.String>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly deprecatedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+            readonly message: Schema.optional<Schema.String>;
+            readonly replacement: Schema.Union<readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"available">;
+                readonly fqn: Schema.String;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"unavailable">;
+                readonly fqn: Schema.optional<Schema.String>;
+            }>]>;
+        }>]>>;
+        readonly revision: Schema.NonEmptyString;
+        readonly observedAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly validUntil: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"unchanged">;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"unavailable">;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"binding-conflict">;
+        readonly publisherBindingId: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"exact-conflict">;
+        readonly reason: Schema.Literals<readonly ["version-unavailable", "integrity-mismatch"]>;
+    }>, Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly outcome: Schema.Literal<"restart-required">;
+        readonly revision: Schema.NonEmptyString;
+    }>]>>;
+}>;
+export type ResolutionMetadataResponse = typeof ResolutionMetadataResponseSchema.Type;
+/** Validate the response against the submitted keys before consuming any page. */
+export declare const resolutionMetadataResponseMatchesRequest: (request: ResolutionMetadataRequest, response: ResolutionMetadataResponse) => boolean;
+export declare const ResolutionMetadataErrorSchema: Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["invalid-request", "unsupported-schema-version", "unsupported-selection-policy-version", "request-too-large", "response-too-large", "backend-unavailable"]>;
+    readonly detail: Schema.String;
+}>;
+export type ResolutionMetadataError = typeof ResolutionMetadataErrorSchema.Type;
+/** Apply the encoded body limit before parsing an untrusted request. */
+export declare const decodeResolutionMetadataRequestBody: (body: Uint8Array) => Result.Result<ResolutionMetadataRequest, ResolutionMetadataError>;
+//# sourceMappingURL=resolution-metadata.d.ts.map