@agentxm/registry-protocol 0.28.4-bootstrap.0

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

@@ -0,0 +1,68 @@
+/**
+ * Registry discovery schemas for package-submitted companion extension metadata.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+export declare const DiscoveryResolvedExtensionSchema: Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.String, "Handle">, Schema.brand<Schema.String, "Slug">]>;
+    readonly type: Schema.Literals<readonly ("rules" | "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "hooks" | "packs")[]>;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly installVersion: Schema.brand<Schema.String, "Version">;
+}>;
+export type DiscoveryResolvedExtension = Schema.Schema.Type<typeof DiscoveryResolvedExtensionSchema>;
+export declare const DiscoveryExtensionResultSchema: Schema.Struct<{
+    readonly ref: Schema.String;
+    readonly resolved: Schema.Boolean;
+    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 ("rules" | "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "hooks" | "packs")[]>;
+        readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+        readonly installVersion: Schema.brand<Schema.String, "Version">;
+    }>>;
+    readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+    readonly official: Schema.Boolean;
+    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 ref: Schema.String;
+        readonly resolved: Schema.Boolean;
+        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 ("rules" | "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "hooks" | "packs")[]>;
+            readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+            readonly installVersion: Schema.brand<Schema.String, "Version">;
+        }>>;
+        readonly attestedBy: Schema.$Array<Schema.Literals<readonly ["package", "extension"]>>;
+        readonly official: Schema.Boolean;
+        readonly packageVersionInRange: Schema.Boolean;
+    }>>;
+}>;
+export type DiscoveryPackageResult = Schema.Schema.Type<typeof DiscoveryPackageResultSchema>;
+export declare const DiscoverPackagesResponseSchema: Schema.Struct<{
+    readonly results: Schema.$Array<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 ref: Schema.String;
+            readonly resolved: Schema.Boolean;
+            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 ("rules" | "skill" | "mcp-server" | "subagent" | "rule" | "hook" | "knowledge" | "pack" | "skills" | "mcps" | "subagents" | "hooks" | "packs")[]>;
+                readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+                readonly installVersion: Schema.brand<Schema.String, "Version">;
+            }>>;
+            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>;
+//# sourceMappingURL=discover-schema.d.ts.map

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

@@ -0,0 +1,35 @@
+/**
+ * Registry discovery schemas for package-submitted companion extension metadata.
+ *
+ * @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 { HandleSchema, SlugSchema } from "@agentxm/extension-model/unstable/extensions/handle";
+import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
+const discoveryExtensionWireTypes = [...extensionTypes, ...extensionTypePluralSegments];
+const DiscoveryExtensionWireTypeSchema = Schema.Literals(discoveryExtensionWireTypes);
+export const DiscoveryResolvedExtensionSchema = Schema.Struct({
+    owner: Schema.Union([HandleSchema, SlugSchema]),
+    type: DiscoveryExtensionWireTypeSchema,
+    name: ExtensionNameSchema,
+    installVersion: VersionSchema,
+});
+export const DiscoveryExtensionResultSchema = Schema.Struct({
+    ref: Schema.String,
+    resolved: Schema.Boolean,
+    extension: Schema.optional(DiscoveryResolvedExtensionSchema),
+    attestedBy: Schema.Array(Schema.Literals(["package", "extension"])),
+    official: Schema.Boolean,
+    packageVersionInRange: Schema.Boolean,
+});
+export const DiscoveryPackageResultSchema = Schema.Struct({
+    purl: Schema.String,
+    version: Schema.String,
+    status: Schema.Literals(["resolved", "invalid_purl"]),
+    extensions: Schema.Array(DiscoveryExtensionResultSchema),
+});
+export const DiscoverPackagesResponseSchema = Schema.Struct({
+    results: Schema.Array(DiscoveryPackageResultSchema),
+});
+//# sourceMappingURL=discover-schema.js.map

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

@@ -0,0 +1,9 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @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 { MAX_PUBLICATION_SET_CANDIDATES, PUBLICATION_SET_CONTRACT, type PackDependencyDescriptor, type PackDependencyFinding, PackDependencyFindingSchema, type PreviewPublicationSetRequest, PreviewPublicationSetRequestSchema, type PreviewPublicationSetResponse, PreviewPublicationSetResponseSchema, type ProspectivePackDependencyState, type ProspectivePublicationCandidate, type PublicationCandidateResult, type PublicationDependencySnapshot, type PublicationDependencyVersionSnapshot, type PublicationDescriptor, type PublicationPackResult, type PublicationTarget, type PublicationVisibilityInput, PublicationVisibilityInputSchema, type Sha256Hex, Sha256HexSchema, archiveSha256Hex, comparePublicationTargets, evaluateProspectivePackDependencies, evaluateProspectivePackDependencyState, 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";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * Area barrel for the package public surface.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export { DiscoverPackagesResponseSchema, DiscoveryExtensionResultSchema, DiscoveryPackageResultSchema, DiscoveryResolvedExtensionSchema, } from "./discover-schema.js";
+export { MAX_PUBLICATION_SET_CANDIDATES, PUBLICATION_SET_CONTRACT, PackDependencyFindingSchema, PreviewPublicationSetRequestSchema, PreviewPublicationSetResponseSchema, PublicationVisibilityInputSchema, Sha256HexSchema, archiveSha256Hex, comparePublicationTargets, evaluateProspectivePackDependencies, evaluateProspectivePackDependencyState, normalizePublicationDescriptor, normalizePublicationSet, publicationDescriptorDigest, publicationSetDigest, publicationTargetKey, validatePublicationDescriptors, validatePublicationSetResponse, } from "./publication-set.js";
+export { DeprecationManagementViewSchema, DeprecationReplacementIntentSchema, DeprecationRevisionSchema, DeprecationTransitionSchema, ExtensionIndexSchema, VersionEntrySchema, packagesToPackageUrlParts, } from "./schema.js";
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,303 @@
+import * as Schema from "effect/Schema";
+import { type ExtensionName, type ExtensionType, type ExtensionVisibility } from "@agentxm/extension-model/unstable/extensions/common";
+import { type Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import { VisibilityEvaluationSchema, VisibilityEvaluationUnavailableSchema } from "../publish/visibility.js";
+import { type Version, type VersionRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { type DeprecationView } from "@agentxm/extension-model/unstable/extensions/deprecation";
+export declare const PUBLICATION_SET_CONTRACT: "publication-set-v2";
+export declare const MAX_PUBLICATION_SET_CANDIDATES = 100;
+export declare const Sha256HexSchema: Schema.String;
+export type Sha256Hex = typeof Sha256HexSchema.Type;
+export interface PublicationTarget {
+    readonly owner: Handle;
+    readonly type: ExtensionType;
+    readonly name: ExtensionName;
+    readonly version: Version;
+}
+export interface PackDependencyDescriptor {
+    readonly owner: Handle;
+    readonly type: Exclude<ExtensionType, "pack">;
+    readonly name: ExtensionName;
+    readonly range: VersionRange;
+}
+export declare const PublicationVisibilityInputSchema: 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"]>>;
+}>;
+export type PublicationVisibilityInput = typeof PublicationVisibilityInputSchema.Type;
+export interface PublicationDescriptor {
+    readonly target: PublicationTarget;
+    readonly participation: "publish" | "verified-existing";
+    readonly archiveSha256Hex?: Sha256Hex | undefined;
+    readonly visibility: PublicationVisibilityInput;
+    readonly pack?: {
+        readonly dependencies: ReadonlyArray<PackDependencyDescriptor>;
+    } | undefined;
+}
+export declare const PreviewPublicationSetRequestSchema: Schema.Struct<{
+    readonly contract: Schema.Literal<"publication-set-v2">;
+    readonly candidates: Schema.$Array<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">;
+            }>>;
+        }>>;
+    }>>;
+}>;
+export interface PreviewPublicationSetRequest {
+    readonly contract: typeof PUBLICATION_SET_CONTRACT;
+    readonly candidates: ReadonlyArray<PublicationDescriptor>;
+}
+export declare const PackDependencyFindingSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"advisory">;
+    readonly ruleId: Schema.Literals<readonly ["pack/dependency-version-resolvable", "pack/dependency-deprecated"]>;
+    readonly severity: Schema.Literals<readonly ["error", "warning"]>;
+    readonly reason: Schema.Literals<readonly ["selected-new-private", "selected-existing-private", "target-unavailable", "lifecycle-unavailable", "no-installable-version", "range-unsatisfied", "deprecated"]>;
+    readonly dependency: 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 effectiveVisibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+    readonly lifecycle: Schema.optional<Schema.Literals<readonly ["active", "unavailable"]>>;
+    readonly deprecation: Schema.optional<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 location: Schema.Struct<{
+        readonly file: Schema.Literal<"pack.json">;
+    }>;
+    readonly path: Schema.Literal<"./pack.json">;
+    readonly message: Schema.String;
+    readonly suggestions: Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly cmd: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export type PackDependencyFinding = typeof PackDependencyFindingSchema.Type;
+export declare const PreviewPublicationSetResponseSchema: Schema.Struct<{
+    readonly contract: Schema.Literal<"publication-set-v2">;
+    readonly publicationSetDigest: Schema.String;
+    readonly status: Schema.Literals<readonly ["admitted", "blocked"]>;
+    readonly candidates: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"resolved">;
+        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 descriptorDigest: Schema.String;
+        readonly visibility: Schema.Struct<{
+            readonly target: Schema.String;
+            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 resolved: Schema.NullOr<Schema.Union<readonly [Schema.Struct<{
+                readonly value: Schema.Literals<readonly ["public", "private"]>;
+                readonly disposition: Schema.Literal<"establish">;
+                readonly source: Schema.Literals<readonly ["manifest", "workspace", "explicit", "account", "platform"]>;
+            }>, Schema.Struct<{
+                readonly value: Schema.Literals<readonly ["public", "private"]>;
+                readonly disposition: Schema.Literal<"preserve">;
+                readonly source: Schema.Literal<"existing">;
+            }>]>>;
+            readonly actual: Schema.NullOr<Schema.Struct<{
+                readonly value: Schema.Literals<readonly ["public", "private"]>;
+                readonly revision: Schema.NonEmptyString;
+            }>>;
+            readonly comparison: Schema.Literals<readonly ["not-established", "unconfigured", "match", "drift"]>;
+            readonly findings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["visibility/intent-conflict", "visibility/drift", "visibility/unavailable", "visibility/intent-required", "visibility/not-established", "visibility/stale-source", "visibility/stale-revision", "visibility/confirmation-required", "visibility/authorization-denied", "visibility/impersonation-denied", "visibility/verification-required", "visibility/verification-expired", "visibility/verification-cancelled", "visibility/verification-replayed", "visibility/pack-blocked"]>;
+                readonly severity: Schema.Literals<readonly ["error", "warning"]>;
+                readonly message: Schema.String;
+            }>>;
+        }>;
+        readonly condition: Schema.optional<Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+        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 descriptorDigest: Schema.String;
+        readonly code: Schema.Literal<"publish/target-unavailable">;
+        readonly visibility: Schema.Struct<{
+            readonly target: Schema.String;
+            readonly unavailable: Schema.Literal<true>;
+            readonly findings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["visibility/intent-conflict", "visibility/drift", "visibility/unavailable", "visibility/intent-required", "visibility/not-established", "visibility/stale-source", "visibility/stale-revision", "visibility/confirmation-required", "visibility/authorization-denied", "visibility/impersonation-denied", "visibility/verification-required", "visibility/verification-expired", "visibility/verification-cancelled", "visibility/verification-replayed", "visibility/pack-blocked"]>;
+                readonly severity: Schema.Literals<readonly ["error", "warning"]>;
+                readonly message: Schema.String;
+            }>>;
+        }>;
+    }>]>>;
+    readonly packs: Schema.$Array<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 status: Schema.Literals<readonly ["admitted", "blocked"]>;
+        readonly findings: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literal<"advisory">;
+            readonly ruleId: Schema.Literals<readonly ["pack/dependency-version-resolvable", "pack/dependency-deprecated"]>;
+            readonly severity: Schema.Literals<readonly ["error", "warning"]>;
+            readonly reason: Schema.Literals<readonly ["selected-new-private", "selected-existing-private", "target-unavailable", "lifecycle-unavailable", "no-installable-version", "range-unsatisfied", "deprecated"]>;
+            readonly dependency: 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 effectiveVisibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+            readonly lifecycle: Schema.optional<Schema.Literals<readonly ["active", "unavailable"]>>;
+            readonly deprecation: Schema.optional<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 location: Schema.Struct<{
+                readonly file: Schema.Literal<"pack.json">;
+            }>;
+            readonly path: Schema.Literal<"./pack.json">;
+            readonly message: Schema.String;
+            readonly suggestions: Schema.$Array<Schema.Struct<{
+                readonly description: Schema.String;
+                readonly cmd: Schema.optional<Schema.String>;
+                readonly url: Schema.optional<Schema.String>;
+            }>>;
+        }>>;
+        readonly resolutions: Schema.$Array<Schema.Struct<{
+            readonly dependency: 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 effectiveVersion: Schema.brand<Schema.String, "Version">;
+        }>>;
+    }>>;
+}>;
+export type PreviewPublicationSetResponse = typeof PreviewPublicationSetResponseSchema.Type;
+export type PublicationCandidateResult = PreviewPublicationSetResponse["candidates"][number];
+export type PublicationPackResult = PreviewPublicationSetResponse["packs"][number];
+export interface PublicationDependencyVersionSnapshot {
+    readonly version: string;
+    readonly status: string;
+    readonly yanked: boolean;
+    readonly purged: boolean;
+}
+export interface PublicationDependencySnapshot {
+    readonly dependency: PackDependencyDescriptor;
+    readonly exists: boolean;
+    readonly visibility: string | null;
+    readonly lifecycleState: string | null;
+    readonly deprecation: DeprecationView | null;
+    readonly versions: ReadonlyArray<PublicationDependencyVersionSnapshot>;
+}
+export type ProspectivePublicationCandidate = {
+    readonly descriptor: PublicationDescriptor;
+    readonly kind: "resolved";
+    readonly visibility: typeof VisibilityEvaluationSchema.Type;
+} | {
+    readonly descriptor: PublicationDescriptor;
+    readonly kind: "unavailable";
+    readonly visibility: typeof VisibilityEvaluationUnavailableSchema.Type;
+};
+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 archiveSha256Hex: (archive: Uint8Array) => Sha256Hex;
+export declare const publicationTargetKey: (target: PublicationTarget) => string;
+export declare const validatePublicationDescriptors: (descriptors: ReadonlyArray<PublicationDescriptor>) => ReadonlyArray<PublicationDescriptor>;
+export declare const evaluateProspectivePackDependencies: (input: {
+    readonly packVisibility: ExtensionVisibility;
+    readonly dependencies: ReadonlyArray<PackDependencyDescriptor>;
+    readonly snapshots: ReadonlyArray<PublicationDependencySnapshot>;
+    readonly candidates: ReadonlyArray<ProspectivePublicationCandidate>;
+}) => ReadonlyArray<PackDependencyFinding>;
+export interface ProspectivePackDependencyState {
+    readonly findings: ReadonlyArray<PackDependencyFinding>;
+    readonly resolutions: PublicationPackResult["resolutions"];
+}
+/**
+ * Evaluate dependency admission and expose the exact version an ordinary
+ * Registry consumer would resolve from the same prospective snapshot.
+ */
+export declare const evaluateProspectivePackDependencyState: (input: {
+    readonly packVisibility: ExtensionVisibility;
+    readonly dependencies: ReadonlyArray<PackDependencyDescriptor>;
+    readonly snapshots: ReadonlyArray<PublicationDependencySnapshot>;
+    readonly candidates: ReadonlyArray<ProspectivePublicationCandidate>;
+}) => ProspectivePackDependencyState;
+export declare const validatePublicationSetResponse: (descriptors: ReadonlyArray<PublicationDescriptor>, response: PreviewPublicationSetResponse) => PreviewPublicationSetResponse;
+//# sourceMappingURL=publication-set.d.ts.map