@agentxm/registry-client 0.28.4-bootstrap.0

package/dist/src/error-mapping.js

@@ -0,0 +1,186 @@
+/**
+ * Shared error mapping helpers for registry and auth client implementations.
+ *
+ * Provides reusable predicates and mappers for converting generated client
+ * errors (RegistryClientError, HttpClientError, SchemaError) to the typed
+ * registry failure vocabulary.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as Predicate from "effect/Predicate";
+import { isLoopbackAddress } from "./network.js";
+import { RegistryRequestFailed } from "./errors.js";
+import { registryClientErrorToProblem } from "./translate.js";
+// -----------------------------------------------------------------------------
+// Safe Field Access
+// -----------------------------------------------------------------------------
+/**
+ * Safely read a string field from an unknown object.
+ */
+export const getString = (obj, field) => {
+    if (obj === null || obj === undefined || typeof obj !== "object")
+        return undefined;
+    const value = Reflect.get(obj, field);
+    return typeof value === "string" ? value : undefined;
+};
+// -----------------------------------------------------------------------------
+// RegistryClientError Predicate
+// -----------------------------------------------------------------------------
+/**
+ * Create a type predicate that matches a specific RegistryClientError tag.
+ *
+ * Usage:
+ * ```ts
+ * Effect.catchIf(isRegistryClientError("ExtensionsGet404"), ...)
+ * ```
+ */
+export const isRegistryClientError = (tag) => (e) => Predicate.isTagged(e, tag);
+// -----------------------------------------------------------------------------
+// HttpClientError Predicate
+// -----------------------------------------------------------------------------
+/**
+ * Type predicate for HttpClientError.
+ */
+export const isHttpClientError = (e) => HttpClientError.isHttpClientError(e);
+/**
+ * Type predicate matching HttpClientErrors that are reasonable to retry:
+ * transport-level failures (ECONNREFUSED, DNS, etc.) and 5xx status codes.
+ * Deterministic failures — encode errors, invalid URLs, decode errors,
+ * 4xx statuses — are excluded so they fail fast.
+ */
+export const isTransientHttpClientError = (e) => {
+    if (!HttpClientError.isHttpClientError(e))
+        return false;
+    const reason = e.reason;
+    if (reason._tag === "TransportError")
+        return true;
+    if (reason._tag === "StatusCodeError" && reason.response.status >= 500)
+        return true;
+    return false;
+};
+/**
+ * Type predicate for SchemaError from effect/Schema.
+ */
+export const isSchemaError = (e) => e !== null && e !== undefined && typeof e === "object" && "_tag" in e && e._tag === "SchemaError";
+// -----------------------------------------------------------------------------
+// Network Diagnostics
+// -----------------------------------------------------------------------------
+/**
+ * Build user-facing suggestions for network errors.
+ * Detects localhost+HTTPS mismatches and provides targeted guidance.
+ */
+export const buildNetworkSuggestions = (baseUrl) => {
+    const fallback = "Check registry URL/network connectivity and retry.";
+    try {
+        const parsed = new URL(baseUrl);
+        const isLocalAddr = isLoopbackAddress(parsed.hostname);
+        if (isLocalAddr && parsed.protocol === "https:") {
+            return [
+                {
+                    description: "Ensure local registry is running with TLS, or switch the source URL to http://localhost:<port>.",
+                },
+            ];
+        }
+        if (isLocalAddr) {
+            return [
+                {
+                    description: "Ensure local registry is running and reachable at the configured host/port.",
+                },
+            ];
+        }
+        return [{ description: fallback }];
+    }
+    catch {
+        return [{ description: fallback }];
+    }
+};
+/**
+ * Build diagnostic details array for network errors.
+ * Detects localhost+HTTPS protocol mismatch.
+ */
+export const buildNetworkDiagnosis = (baseUrl) => {
+    try {
+        const parsed = new URL(baseUrl);
+        const isLocalAddr = isLoopbackAddress(parsed.hostname);
+        if (isLocalAddr && parsed.protocol === "https:") {
+            return ["Diagnosis: Local registry appears HTTP-only while source uses HTTPS."];
+        }
+        return [];
+    }
+    catch {
+        return [];
+    }
+};
+// -----------------------------------------------------------------------------
+// Tag Utilities
+// -----------------------------------------------------------------------------
+/**
+ * Safely read the _tag from an unknown value.
+ */
+export const getTag = (e) => getString(e, "_tag");
+/**
+ * Check if an unknown value is a RegistryClientError (has _tag, request, response fields).
+ */
+export const isAnyRegistryClientError = (e) => e !== null &&
+    e !== undefined &&
+    typeof e === "object" &&
+    !HttpClientError.isHttpClientError(e) &&
+    "_tag" in e &&
+    "response" in e &&
+    "request" in e;
+/**
+ * Check if an unknown value has a _tag ending with the given suffix.
+ */
+export const hasTagSuffix = (e, suffix) => {
+    const tag = getTag(e);
+    return tag !== undefined && tag.endsWith(suffix);
+};
+// -----------------------------------------------------------------------------
+// Network Error Mapping
+// -----------------------------------------------------------------------------
+/**
+ * Map an HttpClientError to a typed registry failure with the network category.
+ */
+export const mapNetworkError = (error, message, baseUrl) => new RegistryRequestFailed({
+    category: "network",
+    detail: message,
+    metadata: {
+        request: {
+            service: "registry",
+            method: error.request.method,
+            url: error.request.url,
+        },
+    },
+    suggestions: buildNetworkSuggestions(baseUrl),
+    cause: error,
+});
+// -----------------------------------------------------------------------------
+// Schema Error Mapping
+// -----------------------------------------------------------------------------
+/**
+ * Map an input Schema encode error to a typed registry failure.
+ */
+export const mapInputSchemaError = (error, message) => new RegistryRequestFailed({
+    category: "validation",
+    detail: message,
+    cause: error,
+});
+/**
+ * Map a response Schema decode error to a typed registry failure.
+ */
+export const mapResponseSchemaError = (error, message) => new RegistryRequestFailed({
+    category: "internal",
+    detail: message,
+    cause: error,
+});
+export const mapSchemaError = mapResponseSchemaError;
+// -----------------------------------------------------------------------------
+// Generic Error Mapping
+// -----------------------------------------------------------------------------
+/**
+ * Map a RegistryClientError to a typed registry failure for unexpected status codes.
+ */
+export const mapUnexpectedStatusError = (error, _message) => registryClientErrorToProblem(error);
+//# sourceMappingURL=error-mapping.js.map

package/dist/src/errors.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Failure vocabulary for the registry-client layer.
+ *
+ * The three families carry registry-born facts — the problem-details
+ * document, the transport evidence, and the request-policy verdict — as
+ * typed fields. The category vocabulary uses the same strings as the
+ * application error codes so the boundary conversion is a field copy; the
+ * application asserts the parity at compile time. Suggestions carried here
+ * are external display data (registry-supplied problem guidance, retry
+ * hints, network diagnosis) in the shared `SuggestedAction` contract shape.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+/** Every category a registry failure can carry. Identical strings to the CLI error codes. */
+export declare const REGISTRY_ERROR_CATEGORIES: readonly ["auth", "conflict", "forbidden", "internal", "network", "not_found", "quota", "rate_limit", "timeout", "unavailable", "validation"];
+export type RegistryErrorCategory = (typeof REGISTRY_ERROR_CATEGORIES)[number];
+export interface RegistryRequestMetadata {
+    readonly service: "registry";
+    readonly method?: string;
+    readonly url: string;
+}
+export interface RegistryResponseMetadata {
+    readonly status: number;
+    readonly requestId?: string;
+    readonly problemCode?: string;
+    readonly body?: unknown;
+}
+export interface RegistryRequestPolicyMetadata {
+    readonly retryable: boolean;
+    readonly attemptCount: number;
+    readonly maxAttempts: number;
+    readonly exhausted: boolean;
+    readonly stoppedBy?: "attempt-limit" | "deadline" | "replay-unsafe";
+    readonly replaySafety: "safe" | "mutation" | "idempotency-keyed";
+}
+export interface RegistryErrorMetadata {
+    readonly request?: RegistryRequestMetadata;
+    readonly response?: RegistryResponseMetadata;
+    readonly requestPolicy?: RegistryRequestPolicyMetadata;
+}
+declare const RegistryProblem_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RegistryProblem";
+} & Readonly<A>;
+/**
+ * The registry answered with a problem-details document. `title` and
+ * `detail` are the registry-supplied display strings (absent when the
+ * document had none — the application boundary supplies its per-category
+ * defaults); `metadata` retains the request and response evidence.
+ */
+export declare class RegistryProblem extends RegistryProblem_base<{
+    readonly category: RegistryErrorCategory;
+    readonly title?: string;
+    readonly detail?: string;
+    readonly metadata: RegistryErrorMetadata;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+    readonly cause: unknown;
+}> {
+}
+declare const RegistryRequestFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RegistryRequestFailed";
+} & Readonly<A>;
+/**
+ * A registry request failed without a decodable problem document: network
+ * transport, an incompatible response shape, request construction, a
+ * deadline timeout, or an unexpected failure.
+ */
+export declare class RegistryRequestFailed extends RegistryRequestFailed_base<{
+    readonly category: RegistryErrorCategory;
+    readonly detail: string;
+    readonly metadata?: RegistryErrorMetadata;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+    readonly cause?: unknown;
+}> {
+}
+declare const RegistryOperationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RegistryOperationFailed";
+} & Readonly<A>;
+/**
+ * A registry operation failed outside request transport: the local
+ * filesystem registry, the archive cache, version selection, or archive
+ * extraction.
+ */
+export declare class RegistryOperationFailed extends RegistryOperationFailed_base<{
+    readonly category: RegistryErrorCategory;
+    readonly detail: string;
+    readonly metadata?: RegistryErrorMetadata;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+    readonly cause?: unknown;
+}> {
+}
+/** Every typed failure the registry-client modules construct. */
+export type RegistryClientFailure = RegistryProblem | RegistryRequestFailed | RegistryOperationFailed;
+export declare const isRegistryClientFailure: (error: unknown) => error is RegistryClientFailure;
+/**
+ * Change endpoint semantics while preserving failure evidence and recovery:
+ * the given category/title/detail/suggestions replace the carried values,
+ * metadata and cause travel unchanged.
+ */
+export declare const withRegistrySemantics: (error: RegistryClientFailure, semantics: {
+    readonly category?: RegistryErrorCategory;
+    readonly title?: string;
+    readonly detail?: string;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+}) => RegistryClientFailure;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/errors.js

@@ -0,0 +1,98 @@
+/**
+ * Failure vocabulary for the registry-client layer.
+ *
+ * The three families carry registry-born facts — the problem-details
+ * document, the transport evidence, and the request-policy verdict — as
+ * typed fields. The category vocabulary uses the same strings as the
+ * application error codes so the boundary conversion is a field copy; the
+ * application asserts the parity at compile time. Suggestions carried here
+ * are external display data (registry-supplied problem guidance, retry
+ * hints, network diagnosis) in the shared `SuggestedAction` contract shape.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Data from "effect/Data";
+/** Every category a registry failure can carry. Identical strings to the CLI error codes. */
+export const REGISTRY_ERROR_CATEGORIES = [
+    "auth",
+    "conflict",
+    "forbidden",
+    "internal",
+    "network",
+    "not_found",
+    "quota",
+    "rate_limit",
+    "timeout",
+    "unavailable",
+    "validation",
+];
+/**
+ * The registry answered with a problem-details document. `title` and
+ * `detail` are the registry-supplied display strings (absent when the
+ * document had none — the application boundary supplies its per-category
+ * defaults); `metadata` retains the request and response evidence.
+ */
+export class RegistryProblem extends Data.TaggedError("RegistryProblem") {
+}
+/**
+ * A registry request failed without a decodable problem document: network
+ * transport, an incompatible response shape, request construction, a
+ * deadline timeout, or an unexpected failure.
+ */
+export class RegistryRequestFailed extends Data.TaggedError("RegistryRequestFailed") {
+}
+/**
+ * A registry operation failed outside request transport: the local
+ * filesystem registry, the archive cache, version selection, or archive
+ * extraction.
+ */
+export class RegistryOperationFailed extends Data.TaggedError("RegistryOperationFailed") {
+}
+export const isRegistryClientFailure = (error) => error instanceof RegistryProblem ||
+    error instanceof RegistryRequestFailed ||
+    error instanceof RegistryOperationFailed;
+/**
+ * Change endpoint semantics while preserving failure evidence and recovery:
+ * the given category/title/detail/suggestions replace the carried values,
+ * metadata and cause travel unchanged.
+ */
+export const withRegistrySemantics = (error, semantics) => {
+    switch (error._tag) {
+        case "RegistryProblem":
+            return new RegistryProblem({
+                category: semantics.category ?? error.category,
+                ...((semantics.title ?? error.title) === undefined
+                    ? {}
+                    : { title: semantics.title ?? error.title }),
+                ...((semantics.detail ?? error.detail) === undefined
+                    ? {}
+                    : { detail: semantics.detail ?? error.detail }),
+                metadata: error.metadata,
+                ...((semantics.suggestions ?? error.suggestions) === undefined
+                    ? {}
+                    : { suggestions: semantics.suggestions ?? error.suggestions }),
+                cause: error.cause,
+            });
+        case "RegistryRequestFailed":
+            return new RegistryRequestFailed({
+                category: semantics.category ?? error.category,
+                detail: semantics.detail ?? error.detail,
+                ...(error.metadata === undefined ? {} : { metadata: error.metadata }),
+                ...((semantics.suggestions ?? error.suggestions) === undefined
+                    ? {}
+                    : { suggestions: semantics.suggestions ?? error.suggestions }),
+                ...(error.cause === undefined ? {} : { cause: error.cause }),
+            });
+        case "RegistryOperationFailed":
+            return new RegistryOperationFailed({
+                category: semantics.category ?? error.category,
+                detail: semantics.detail ?? error.detail,
+                ...(error.metadata === undefined ? {} : { metadata: error.metadata }),
+                ...((semantics.suggestions ?? error.suggestions) === undefined
+                    ? {}
+                    : { suggestions: semantics.suggestions ?? error.suggestions }),
+                ...(error.cause === undefined ? {} : { cause: error.cause }),
+            });
+    }
+};
+//# sourceMappingURL=errors.js.map

package/dist/src/failure-mapping.d.ts

@@ -0,0 +1,14 @@
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+import { type RegistryClientFailure } from "./errors.js";
+export { captureRegistryErrorResponseBodies } from "./response-body.js";
+export interface RegistryFailureContext {
+    readonly baseUrl: string;
+    readonly networkDetail: string;
+    readonly incompatibleDetail: string;
+    readonly requestConstructionDetail: string;
+    readonly fallbackDetail: string;
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+}
+/** Translate one Registry boundary failure without discarding HTTP evidence. */
+export declare const mapRegistryFailure: (error: unknown, context: RegistryFailureContext) => RegistryClientFailure;
+//# sourceMappingURL=failure-mapping.d.ts.map

package/dist/src/failure-mapping.js

@@ -0,0 +1,100 @@
+import { isAnyRegistryClientError, isHttpClientError, isSchemaError, mapNetworkError, } from "./error-mapping.js";
+import { RegistryRequestFailed, isRegistryClientFailure, } from "./errors.js";
+import { recoverRegistryResponseBodyText, retainedRegistryResponseBody } from "./response-body.js";
+import { registryClientErrorToProblem, registryErrorToProblem } from "./translate.js";
+export { captureRegistryErrorResponseBodies } from "./response-body.js";
+const incompatibleResponse = (error, context) => {
+    if (!isHttpClientError(error)) {
+        return new RegistryRequestFailed({
+            category: "internal",
+            detail: context.incompatibleDetail,
+            ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+            cause: error,
+        });
+    }
+    const response = error.response;
+    return new RegistryRequestFailed({
+        category: "internal",
+        detail: context.incompatibleDetail,
+        metadata: {
+            request: {
+                service: "registry",
+                method: error.request.method,
+                url: error.request.url,
+            },
+            ...(response === undefined
+                ? {}
+                : {
+                    response: {
+                        status: response.status,
+                        body: retainedRegistryResponseBody(response, ""),
+                    },
+                }),
+        },
+        ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+        cause: error,
+    });
+};
+const requestConstructionError = (error, context) => {
+    if (!isHttpClientError(error)) {
+        return new RegistryRequestFailed({
+            category: "internal",
+            detail: context.requestConstructionDetail,
+            cause: error,
+        });
+    }
+    return new RegistryRequestFailed({
+        category: "internal",
+        detail: context.requestConstructionDetail,
+        metadata: {
+            request: {
+                service: "registry",
+                method: error.request.method,
+                url: error.request.url,
+            },
+        },
+        cause: error,
+    });
+};
+/** Translate one Registry boundary failure without discarding HTTP evidence. */
+export const mapRegistryFailure = (error, context) => {
+    if (isRegistryClientFailure(error))
+        return error;
+    if (isAnyRegistryClientError(error)) {
+        return registryClientErrorToProblem(error, {
+            ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+        });
+    }
+    if (isHttpClientError(error)) {
+        switch (error.reason._tag) {
+            case "StatusCodeError":
+                return registryErrorToProblem(retainedRegistryResponseBody(error.reason.response, recoverRegistryResponseBodyText(error.reason.description ?? "")), error.reason.response, {
+                    ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+                    cause: error,
+                });
+            case "DecodeError":
+            case "EmptyBodyError":
+                return incompatibleResponse(error, context);
+            case "TransportError":
+                return mapNetworkError(error, context.networkDetail, context.baseUrl);
+            case "EncodeError":
+            case "InvalidUrlError":
+                return requestConstructionError(error, context);
+        }
+    }
+    if (isSchemaError(error)) {
+        return new RegistryRequestFailed({
+            category: "internal",
+            detail: context.incompatibleDetail,
+            ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+            cause: error,
+        });
+    }
+    return new RegistryRequestFailed({
+        category: "internal",
+        detail: context.fallbackDetail,
+        ...(context.suggestions === undefined ? {} : { suggestions: context.suggestions }),
+        cause: error,
+    });
+};
+//# sourceMappingURL=failure-mapping.js.map

package/dist/src/fs-helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Pure filesystem path helpers.
+ *
+ * Deliberately duplicated from the CLI-destined fs-helpers module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+/** Convert a file URL to the current platform's native path representation. */
+export declare const stripFileProtocol: (location: string) => string;
+//# sourceMappingURL=fs-helpers.d.ts.map

package/dist/src/fs-helpers.js

@@ -0,0 +1,13 @@
+/**
+ * Pure filesystem path helpers.
+ *
+ * Deliberately duplicated from the CLI-destined fs-helpers module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import { fileURLToPath } from "node:url";
+/** Convert a file URL to the current platform's native path representation. */
+export const stripFileProtocol = (location) => location.startsWith("file:") ? fileURLToPath(location) : location;
+//# sourceMappingURL=fs-helpers.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @agentxm/registry-client public API.
+ *
+ * The registry integration: local and remote registry clients over the
+ * generated OpenAPI transport, request policy and retry, the typed registry
+ * failure vocabulary with problem-details translation, the content-addressed
+ * archive cache, lifecycle administration, and package metadata schemas.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export type { RegistryClient, RegistryExtensionManifest, DiscoverPackageInput, DiscoverPackagesArgs, GetExtensionsByOwnerArgs, GetExtensionsByOwnerResponse, GetExtensionIndexArgs, GetExactExtensionVersionArgs, ExactExtensionVersion, GetExtensionVisibilityArgs, GetExtensionPackageArgs, GetExtensionPackageResponse, PublishExtensionArgs, PublishExtensionResponse, RegistryPublishWarning, PreviewExtensionPublishesArgs, PublishPreviewResult, PublishPreviewTarget, OwnerExistsResponse, ExtensionExistsArgs, ExtensionExistsResponse, ExtensionVisibility, UpdateExtensionVisibilityArgs, } from "./client.js";
+export { createRegistryClient } from "./client.js";
+export { createLocalRegistryClient } from "./local-client.js";
+export { createRemoteRegistryClient } from "./remote-client.js";
+export { DEFAULT_REGISTRY_REQUEST_POLICY, PUBLISH_REGISTRY_REQUEST_POLICY, executeRegistryRequest, type RegistryRequestPolicy, type RegistryRequestReplaySafety, } from "./request-policy.js";
+export type { ArchiveCache, ArchiveCacheOptions, ArchiveCachePruneResult, ArchiveCacheStatus, ArchiveCacheVerifyResult, } from "./archive-cache.js";
+export { resolveAxmCacheRoot, resolveAxmCacheRootPure, type AxmCacheEnvironment, } from "./cache-root.js";
+export { ARCHIVE_CACHE_MAX_AGE, ARCHIVE_CACHE_MAX_BYTES, makeArchiveCache, makeUserArchiveCache, } from "./archive-cache.js";
+export type { RegistryExtensionReference, RegistryExtensionVersionReference, RegistryLifecycleCallOptions, PutExtensionDeprecationInput, YankCategory, } from "./admin-client.js";
+export { yankExtensionVersion, yankAvailableExtensionVersions, unyankExtensionVersion, deprecateExtension, getExtensionDeprecation, undeprecateExtension, } from "./admin-client.js";
+export { REGISTRY_ERROR_CATEGORIES, RegistryOperationFailed, RegistryProblem, RegistryRequestFailed, isRegistryClientFailure, withRegistrySemantics, type RegistryClientFailure, type RegistryErrorCategory, type RegistryErrorMetadata, type RegistryRequestMetadata, type RegistryRequestPolicyMetadata, type RegistryResponseMetadata, } from "./errors.js";
+export { httpStatusToCategory, registryClientErrorToProblem, registryErrorToProblem, type ProblemDetails, } from "./translate.js";
+export { captureRegistryErrorResponseBodies, mapRegistryFailure, type RegistryFailureContext, } from "./failure-mapping.js";
+export { buildNetworkSuggestions, buildNetworkDiagnosis, getString, isRegistryClientError, isHttpClientError, isSchemaError, isTransientHttpClientError, mapNetworkError, mapSchemaError, mapUnexpectedStatusError, } from "./error-mapping.js";
+export { extensionDir, extensionLifecycleWarnings, extractZip, pluralizeType, resolveVersionEntry, resolveVersionEntryForReleaseAge, resolveVersionEntryWithReleaseAge, selectVersion, } from "./utils.js";
+export { formatDeprecationWarning } from "./deprecation-warning.js";
+export type { ReleaseAgeVersionResolution } from "./utils.js";
+export { RegistryUrl } from "./registry-url.js";
+export { AxmPackageMetaSchema, PackageExtensionDeclarationSchema, type AxmPackageMeta, type PackageExtensionDeclaration, } from "./axm-package-meta.js";
+export { purlIdentityMatch, purlMatch } from "./purl-match.js";
+export * as GeneratedRegistryClient from "./__generated__/registry-client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,37 @@
+/**
+ * @agentxm/registry-client public API.
+ *
+ * The registry integration: local and remote registry clients over the
+ * generated OpenAPI transport, request policy and retry, the typed registry
+ * failure vocabulary with problem-details translation, the content-addressed
+ * archive cache, lifecycle administration, and package metadata schemas.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export { createRegistryClient } from "./client.js";
+// Local client
+export { createLocalRegistryClient } from "./local-client.js";
+// Remote client
+export { createRemoteRegistryClient } from "./remote-client.js";
+export { DEFAULT_REGISTRY_REQUEST_POLICY, PUBLISH_REGISTRY_REQUEST_POLICY, executeRegistryRequest, } from "./request-policy.js";
+export { resolveAxmCacheRoot, resolveAxmCacheRootPure, } from "./cache-root.js";
+export { ARCHIVE_CACHE_MAX_AGE, ARCHIVE_CACHE_MAX_BYTES, makeArchiveCache, makeUserArchiveCache, } from "./archive-cache.js";
+export { yankExtensionVersion, yankAvailableExtensionVersions, unyankExtensionVersion, deprecateExtension, getExtensionDeprecation, undeprecateExtension, } from "./admin-client.js";
+// Failure vocabulary
+export { REGISTRY_ERROR_CATEGORIES, RegistryOperationFailed, RegistryProblem, RegistryRequestFailed, isRegistryClientFailure, withRegistrySemantics, } from "./errors.js";
+// Failure translation
+export { httpStatusToCategory, registryClientErrorToProblem, registryErrorToProblem, } from "./translate.js";
+export { captureRegistryErrorResponseBodies, mapRegistryFailure, } from "./failure-mapping.js";
+// Error mapping helpers
+export { buildNetworkSuggestions, buildNetworkDiagnosis, getString, isRegistryClientError, isHttpClientError, isSchemaError, isTransientHttpClientError, mapNetworkError, mapSchemaError, mapUnexpectedStatusError, } from "./error-mapping.js";
+// Utilities
+export { extensionDir, extensionLifecycleWarnings, extractZip, pluralizeType, resolveVersionEntry, resolveVersionEntryForReleaseAge, resolveVersionEntryWithReleaseAge, selectVersion, } from "./utils.js";
+export { formatDeprecationWarning } from "./deprecation-warning.js";
+export { RegistryUrl } from "./registry-url.js";
+// Package metadata schemas
+export { AxmPackageMetaSchema, PackageExtensionDeclarationSchema, } from "./axm-package-meta.js";
+export { purlIdentityMatch, purlMatch } from "./purl-match.js";
+// Generated OpenAPI transport (consumed by the registry-auth feature)
+export * as GeneratedRegistryClient from "./__generated__/registry-client.js";
+//# sourceMappingURL=index.js.map

package/dist/src/integrity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SHA-512 integrity utility.
+ *
+ * Deliberately duplicated from the CLI-destined integrity module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+/** Compute SHA-512 integrity in `sha512-<base64>` SRI format. */
+export declare const computeIntegrity: (data: Uint8Array) => Effect.Effect<string>;
+//# sourceMappingURL=integrity.d.ts.map

package/dist/src/integrity.js

@@ -0,0 +1,17 @@
+/**
+ * SHA-512 integrity utility.
+ *
+ * Deliberately duplicated from the CLI-destined integrity module: the
+ * integration may not depend on application utilities, and this helper is
+ * within the sanctioned duplication budget for small pure functions.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import { createHash } from "node:crypto";
+/** Compute SHA-512 integrity in `sha512-<base64>` SRI format. */
+export const computeIntegrity = (data) => Effect.sync(() => {
+    const base64 = createHash("sha512").update(data).digest("base64");
+    return `sha512-${base64}`;
+});
+//# sourceMappingURL=integrity.js.map

package/dist/src/local-client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Local filesystem-backed registry client.
+ *
+ * All operations read/write files relative to a registry root using the
+ * layout: `<root>/extensions/@<owner>/<type>/<name>/`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as FileSystem from "effect/FileSystem";
+import type * as Path from "effect/Path";
+import type { RegistryClient } from "./client.js";
+/**
+ * Creates a local filesystem-backed registry client.
+ *
+ * All operations read/write files relative to `registryRoot` using the
+ * registry layout: `<root>/extensions/@<owner>/<type>/<name>/`.
+ *
+ * @param registryRoot - Absolute path to the registry root directory
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const createLocalRegistryClient: (registryRoot: string, fs: FileSystem.FileSystem, path: Path.Path) => RegistryClient;
+//# sourceMappingURL=local-client.d.ts.map