@agentxm/registry-client 0.28.4-bootstrap.0

package/dist/src/request-policy.d.ts

@@ -0,0 +1,29 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { type RegistryClientFailure, type RegistryRequestMetadata } from "./errors.js";
+export interface RegistryRequestPolicy {
+    readonly requestTimeout: Duration.Input;
+    readonly totalDeadline: Duration.Input;
+    readonly maxAttempts: number;
+    readonly initialBackoff: Duration.Input;
+    readonly maxBackoff: Duration.Input;
+}
+export declare const DEFAULT_REGISTRY_REQUEST_POLICY: RegistryRequestPolicy;
+/** A publish may legitimately spend longer validating and persisting an archive. */
+export declare const PUBLISH_REGISTRY_REQUEST_POLICY: RegistryRequestPolicy;
+export type RegistryRequestReplaySafety = {
+    readonly kind: "safe";
+} | {
+    readonly kind: "mutation";
+} | {
+    readonly kind: "idempotency-keyed";
+    readonly idempotencyKey: string;
+};
+export declare const executeRegistryRequest: <A, E, R>(effect: Effect.Effect<A, E, R>, args: {
+    readonly operation: string;
+    readonly request: RegistryRequestMetadata;
+    readonly replaySafety: RegistryRequestReplaySafety;
+    readonly mapError: (error: E) => RegistryClientFailure;
+    readonly policy?: RegistryRequestPolicy;
+}) => Effect.Effect<A, RegistryClientFailure, R>;
+//# sourceMappingURL=request-policy.d.ts.map

package/dist/src/request-policy.js

@@ -0,0 +1,190 @@
+import * as Cause from "effect/Cause";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
+import { isAnyRegistryClientError, isHttpClientError } from "./error-mapping.js";
+import { RegistryOperationFailed, RegistryProblem, RegistryRequestFailed, } from "./errors.js";
+import { registryRetryAfterSeconds } from "./retry-after.js";
+export const DEFAULT_REGISTRY_REQUEST_POLICY = {
+    requestTimeout: "10 seconds",
+    totalDeadline: "30 seconds",
+    maxAttempts: 3,
+    initialBackoff: "200 millis",
+    maxBackoff: "2 seconds",
+};
+/** A publish may legitimately spend longer validating and persisting an archive. */
+export const PUBLISH_REGISTRY_REQUEST_POLICY = {
+    requestTimeout: "5 minutes",
+    totalDeadline: "5 minutes",
+    maxAttempts: 1,
+    initialBackoff: "200 millis",
+    maxBackoff: "2 seconds",
+};
+const retryEvidence = (error) => {
+    if (isHttpClientError(error) && error.reason._tag === "StatusCodeError") {
+        return { response: error.reason.response, body: undefined };
+    }
+    if (isHttpClientError(error))
+        return undefined;
+    if (isAnyRegistryClientError(error)) {
+        return { response: error.response, body: error.cause };
+    }
+    return undefined;
+};
+const isRetryableRegistryError = (error) => {
+    if (Cause.isTimeoutError(error))
+        return true;
+    if (isHttpClientError(error)) {
+        if (error.reason._tag === "TransportError")
+            return true;
+        if (error.reason._tag !== "StatusCodeError")
+            return false;
+    }
+    const evidence = retryEvidence(error);
+    if (evidence === undefined)
+        return false;
+    return [408, 429, 500, 502, 503, 504].includes(evidence.response.status);
+};
+const getStringField = (value, field) => {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const fieldValue = Reflect.get(value, field);
+    return typeof fieldValue === "string" ? fieldValue : undefined;
+};
+const requestIdFromError = (error) => {
+    const body = retryEvidence(error)?.body;
+    return getStringField(body, "requestId") ?? getStringField(body, "request_id");
+};
+const retryAfter = (error) => Effect.gen(function* () {
+    const evidence = retryEvidence(error);
+    if (evidence === undefined)
+        return undefined;
+    const nowMillis = yield* Clock.currentTimeMillis;
+    return registryRetryAfterSeconds({
+        status: evidence.response.status,
+        body: evidence.body,
+        response: evidence.response,
+        nowMillis,
+    });
+});
+const retrySchedule = (policy, operation) => {
+    const totalDeadlineMillis = Duration.toMillis(Duration.fromInputUnsafe(policy.totalDeadline));
+    const maxBackoffMillis = Duration.toMillis(Duration.fromInputUnsafe(policy.maxBackoff));
+    return Schedule.exponential(policy.initialBackoff).pipe(Schedule.setInputType(), Schedule.jittered, Schedule.modifyDelay(({ duration, input }) => Effect.map(retryAfter(input), (serverSeconds) => {
+        const cappedBackoff = Math.min(Duration.toMillis(duration), maxBackoffMillis);
+        return Duration.millis(serverSeconds === undefined
+            ? cappedBackoff
+            : Math.max(cappedBackoff, serverSeconds * 1_000));
+    })), Schedule.while(({ input, elapsed, duration }) => isRetryableRegistryError(input) &&
+        elapsed + Duration.toMillis(duration) <= totalDeadlineMillis), Schedule.upTo({ times: Math.max(0, policy.maxAttempts - 1) }), Schedule.tap(({ attempt, duration, input }) => Effect.logDebug("Retrying Registry request", {
+        service: "registry",
+        operation,
+        nextAttempt: attempt + 1,
+        delayMillis: Duration.toMillis(duration),
+        ...(requestIdFromError(input) === undefined
+            ? {}
+            : { requestId: requestIdFromError(input) }),
+    })));
+};
+const isReplaySafe = (safety) => safety.kind === "safe" ||
+    (safety.kind === "idempotency-keyed" && safety.idempotencyKey.length > 0);
+const retryStopReason = (args) => {
+    if (!args.retryable)
+        return undefined;
+    if (!args.replaySafe)
+        return "replay-unsafe";
+    if (args.deadlineExpired || args.attemptCount < args.maxAttempts)
+        return "deadline";
+    return "attempt-limit";
+};
+const withRequestPolicyMetadata = (error, args) => {
+    const replaySafe = isReplaySafe(args.replaySafety);
+    const stoppedBy = retryStopReason({
+        retryable: args.retryable,
+        replaySafe,
+        attemptCount: args.attemptCount,
+        maxAttempts: args.maxAttempts,
+        deadlineExpired: args.deadlineExpired,
+    });
+    const metadata = {
+        ...error.metadata,
+        request: error.metadata?.request ?? args.request,
+        requestPolicy: {
+            retryable: args.retryable,
+            attemptCount: args.attemptCount,
+            maxAttempts: replaySafe ? args.maxAttempts : 1,
+            exhausted: args.retryable,
+            ...(stoppedBy === undefined ? {} : { stoppedBy }),
+            replaySafety: args.replaySafety.kind,
+        },
+    };
+    switch (error._tag) {
+        case "RegistryProblem":
+            return new RegistryProblem({
+                category: error.category,
+                ...(error.title === undefined ? {} : { title: error.title }),
+                ...(error.detail === undefined ? {} : { detail: error.detail }),
+                metadata,
+                ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                cause: error.cause,
+            });
+        case "RegistryRequestFailed":
+            return new RegistryRequestFailed({
+                category: error.category,
+                detail: error.detail,
+                metadata,
+                ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                ...(error.cause === undefined ? {} : { cause: error.cause }),
+            });
+        case "RegistryOperationFailed":
+            return new RegistryOperationFailed({
+                category: error.category,
+                detail: error.detail,
+                metadata,
+                ...(error.suggestions === undefined ? {} : { suggestions: error.suggestions }),
+                ...(error.cause === undefined ? {} : { cause: error.cause }),
+            });
+    }
+};
+export const executeRegistryRequest = (effect, args) => {
+    const policy = args.policy ?? DEFAULT_REGISTRY_REQUEST_POLICY;
+    const maxAttempts = Math.max(1, policy.maxAttempts);
+    const attempt = effect.pipe(Effect.timeout(policy.requestTimeout));
+    return Effect.gen(function* () {
+        const attempts = yield* Ref.make(0);
+        const countedAttempt = Ref.update(attempts, (count) => count + 1).pipe(Effect.andThen(attempt));
+        const executed = isReplaySafe(args.replaySafety)
+            ? countedAttempt.pipe(Effect.retry(retrySchedule(policy, args.operation)))
+            : countedAttempt;
+        return yield* executed.pipe(Effect.timeout(policy.totalDeadline), Effect.catch((error) => Ref.get(attempts).pipe(Effect.tap((attemptCount) => Effect.logDebug("Registry request finished with an error", {
+            service: "registry",
+            operation: args.operation,
+            attemptCount,
+            replaySafety: args.replaySafety.kind,
+            ...(requestIdFromError(error) === undefined
+                ? {}
+                : { requestId: requestIdFromError(error) }),
+        })), Effect.flatMap((attemptCount) => {
+            const deadlineExpired = Cause.isTimeoutError(error);
+            const mapped = deadlineExpired
+                ? new RegistryRequestFailed({
+                    category: "timeout",
+                    detail: "Registry request did not complete within the configured deadline.",
+                    metadata: { request: args.request },
+                    cause: error,
+                })
+                : args.mapError(error);
+            return Effect.fail(withRequestPolicyMetadata(mapped, {
+                request: args.request,
+                replaySafety: args.replaySafety,
+                attemptCount,
+                maxAttempts,
+                retryable: deadlineExpired || isRetryableRegistryError(error),
+                deadlineExpired,
+            }));
+        }))));
+    });
+};
+//# sourceMappingURL=request-policy.js.map

package/dist/src/response-body.d.ts

@@ -0,0 +1,11 @@
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+/**
+ * Capture non-success Registry response bodies before a generated or raw
+ * endpoint adapter decodes them. HttpClientResponse caches the consumed bytes,
+ * so the endpoint decoder still observes the same response.
+ */
+export declare const captureRegistryErrorResponseBodies: (client: HttpClient.HttpClient) => HttpClient.HttpClient;
+export declare const retainedRegistryResponseBody: (response: HttpClientResponse.HttpClientResponse, fallback: unknown) => unknown;
+export declare const recoverRegistryResponseBodyText: (text: string) => unknown;
+//# sourceMappingURL=response-body.d.ts.map

package/dist/src/response-body.js

@@ -0,0 +1,32 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+const decodeUnknownJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+const recoverBodyText = (text) => {
+    const decoded = decodeUnknownJson(text);
+    return Option.isSome(decoded) ? decoded.value : text;
+};
+const retainedResponseBodyKey = Symbol("@agentxm/registry/retained-response-body");
+const retainResponseBody = (response) => response.text.pipe(Effect.flatMap((text) => Effect.sync(() => {
+    Object.defineProperty(response, retainedResponseBodyKey, {
+        configurable: false,
+        enumerable: false,
+        value: recoverBodyText(text),
+        writable: false,
+    });
+    return response;
+})), Effect.catch(() => Effect.succeed(response)));
+/**
+ * Capture non-success Registry response bodies before a generated or raw
+ * endpoint adapter decodes them. HttpClientResponse caches the consumed bytes,
+ * so the endpoint decoder still observes the same response.
+ */
+export const captureRegistryErrorResponseBodies = (client) => client.pipe(HttpClient.transformResponse(Effect.flatMap((response) => response.status < 200 || response.status >= 300
+    ? retainResponseBody(response)
+    : Effect.succeed(response))));
+export const retainedRegistryResponseBody = (response, fallback) => Object.hasOwn(response, retainedResponseBodyKey)
+    ? Reflect.get(response, retainedResponseBodyKey)
+    : fallback;
+export const recoverRegistryResponseBodyText = (text) => recoverBodyText(text);
+//# sourceMappingURL=response-body.js.map

package/dist/src/retry-after.d.ts

@@ -0,0 +1,9 @@
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+export declare const parseRetryAfterHeader: (value: string | undefined, nowMillis: number) => number | undefined;
+export declare const registryRetryAfterSeconds: (args: {
+    readonly status: number;
+    readonly body: unknown;
+    readonly response: HttpClientResponse.HttpClientResponse;
+    readonly nowMillis: number;
+}) => number | undefined;
+//# sourceMappingURL=retry-after.d.ts.map

package/dist/src/retry-after.js

@@ -0,0 +1,28 @@
+import * as DateTime from "effect/DateTime";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { ProblemDetails as RegistryProblemDetailsSchema } from "./__generated__/registry-client.js";
+const decodeRegistryProblemDetails = Schema.decodeUnknownSync(RegistryProblemDetailsSchema);
+const retryAfterFromBody = (status, body) => {
+    if (status !== 429 && status !== 503)
+        return undefined;
+    try {
+        return decodeRegistryProblemDetails(body).details?.retryAfterSeconds;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const parseRetryAfterHeader = (value, nowMillis) => {
+    if (value === undefined)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.ceil(seconds);
+    const retryAt = DateTime.make(value);
+    if (Option.isNone(retryAt))
+        return undefined;
+    return Math.max(0, Math.ceil((DateTime.toEpochMillis(retryAt.value) - nowMillis) / 1_000));
+};
+export const registryRetryAfterSeconds = (args) => parseRetryAfterHeader(args.response.headers["retry-after"] ?? args.response.headers["Retry-After"], args.nowMillis) ?? retryAfterFromBody(args.status, args.body);
+//# sourceMappingURL=retry-after.js.map

package/dist/src/translate.d.ts

@@ -0,0 +1,20 @@
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
+import { type RegistryClientError } from "./__generated__/registry-client.js";
+import { RegistryProblem, type RegistryErrorCategory } from "./errors.js";
+export interface ProblemDetails {
+    readonly [key: string]: unknown;
+    readonly title?: string;
+    readonly status?: number;
+    readonly detail?: string;
+    readonly code?: string;
+}
+export declare const httpStatusToCategory: (status: number, code?: string) => RegistryErrorCategory;
+export declare const registryErrorToProblem: (body: unknown, response: HttpClientResponse.HttpClientResponse, ctx?: {
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+    readonly cause?: unknown;
+}) => RegistryProblem;
+export declare const registryClientErrorToProblem: (error: RegistryClientError<string, unknown>, ctx?: {
+    readonly suggestions?: ReadonlyArray<SuggestedAction>;
+}) => RegistryProblem;
+//# sourceMappingURL=translate.d.ts.map

package/dist/src/translate.js

@@ -0,0 +1,170 @@
+import * as DateTime from "effect/DateTime";
+import * as Schema from "effect/Schema";
+import { ExtensionIdentityMismatchErrorEncoded, ExtensionLintFailedErrorEncoded, ForbiddenErrorEncoded, } from "./__generated__/registry-client.js";
+import { RegistryProblem } from "./errors.js";
+import { registryRetryAfterSeconds } from "./retry-after.js";
+import { retainedRegistryResponseBody } from "./response-body.js";
+const EmptyProblem = {};
+const isProblemDetails = (value) => typeof value === "object" && value !== null;
+const decodeForbiddenError = Schema.decodeUnknownSync(ForbiddenErrorEncoded);
+const decodeExtensionLintFailedError = Schema.decodeUnknownSync(ExtensionLintFailedErrorEncoded);
+const decodeExtensionIdentityMismatchError = Schema.decodeUnknownSync(ExtensionIdentityMismatchErrorEncoded);
+const tryDecode = (decode, input) => {
+    try {
+        return decode(input);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const httpStatusToCategory = (status, code) => {
+    switch (status) {
+        case 400:
+            return "validation";
+        case 401:
+            return "auth";
+        case 403:
+            return code === "quota_exceeded" || code === "publish/quota-exceeded" ? "quota" : "forbidden";
+        case 404:
+        case 410:
+            return "not_found";
+        case 409:
+        case 412:
+            return "conflict";
+        case 413:
+        case 415:
+        case 422:
+            return "validation";
+        case 429:
+            return "rate_limit";
+        case 500:
+        case 501:
+        case 502:
+            return "internal";
+        case 503:
+            return "unavailable";
+        default:
+            return status >= 500 ? "internal" : "internal";
+    }
+};
+const retryAfterSuggestedAction = (status, body, response) => {
+    const retryAfterSeconds = registryRetryAfterSeconds({
+        status,
+        body,
+        response,
+        nowMillis: DateTime.toEpochMillis(DateTime.nowUnsafe()),
+    });
+    return retryAfterSeconds === undefined
+        ? undefined
+        : { description: `Retry after ${String(retryAfterSeconds)}s.` };
+};
+const scopeDeniedSuggestedAction = (body) => {
+    const decoded = tryDecode(decodeForbiddenError, body);
+    const requiredScope = decoded?.details !== undefined && "requiredScope" in decoded.details
+        ? decoded.details.requiredScope
+        : undefined;
+    return requiredScope === undefined
+        ? undefined
+        : {
+            description: "Sign in with the required registry scope.",
+            cmd: `axm login --scope ${requiredScope}`,
+        };
+};
+const lintFailedSuggestions = (body) => {
+    const decoded = tryDecode(decodeExtensionLintFailedError, body);
+    if (decoded === undefined)
+        return [];
+    const findingCount = decoded.findings.length;
+    const findingLabel = findingCount === 1 ? "finding" : "findings";
+    const summary = {
+        description: `Publish lint failed with ${String(findingCount)} ${findingLabel}.`,
+    };
+    const findings = decoded.findings.slice(0, 5).map((finding) => ({
+        description: `${finding.severity}: ${finding.ruleId} - ${finding.message} (${finding.path})`,
+    }));
+    const suppressedCount = findingCount - findings.length;
+    const suppressed = suppressedCount === 0
+        ? []
+        : [
+            {
+                description: `${String(suppressedCount)} additional ${suppressedCount === 1 ? "finding was" : "findings were"} suppressed.`,
+            },
+        ];
+    return [summary, ...findings, ...suppressed];
+};
+const identityMismatchSuggestions = (body) => {
+    const decoded = tryDecode(decodeExtensionIdentityMismatchError, body);
+    if (decoded === undefined)
+        return [];
+    const summary = {
+        description: `Publish identity mismatch on ${String(decoded.mismatches.length)} field${decoded.mismatches.length === 1 ? "" : "s"}.`,
+    };
+    const mismatches = decoded.mismatches.map((mismatch) => ({
+        description: `${mismatch.field}: URL has ${mismatch.urlPath ?? "<missing>"}, archive has ${mismatch.content ?? "<missing>"}.`,
+    }));
+    return [summary, ...mismatches];
+};
+const serverErrorSuggestedAction = (status) => status >= 500
+    ? {
+        description: "The registry returned a server error. Retry shortly; if it persists, report it with the request ID.",
+    }
+    : undefined;
+const getStringField = (value, field) => {
+    if (value === null || value === undefined || typeof value !== "object") {
+        return undefined;
+    }
+    const fieldValue = Reflect.get(value, field);
+    return typeof fieldValue === "string" ? fieldValue : undefined;
+};
+const problemSuggestions = (status, problem, response) => {
+    const body = problem;
+    const retry = retryAfterSuggestedAction(status, body, response);
+    const scope = status === 403 ? scopeDeniedSuggestedAction(body) : undefined;
+    const serverError = serverErrorSuggestedAction(status);
+    return [
+        ...(retry === undefined ? [] : [retry]),
+        ...(scope === undefined ? [] : [scope]),
+        ...(serverError === undefined ? [] : [serverError]),
+        ...(status === 422 && problem.code === "extension_lint_failed"
+            ? lintFailedSuggestions(body)
+            : []),
+        ...(status === 422 && problem.code === "extension_identity_mismatch"
+            ? identityMismatchSuggestions(body)
+            : []),
+    ];
+};
+export const registryErrorToProblem = (body, response, ctx) => {
+    const problem = isProblemDetails(body) ? body : EmptyProblem;
+    const status = response.status;
+    const category = httpStatusToCategory(status, problem.code);
+    const suggestions = [
+        ...problemSuggestions(status, problem, response),
+        ...(ctx?.suggestions ?? []),
+    ];
+    const requestId = getStringField(problem, "requestId") ?? getStringField(problem, "request_id");
+    return new RegistryProblem({
+        category,
+        ...(problem.title === undefined ? {} : { title: problem.title }),
+        ...(problem.detail === undefined ? {} : { detail: problem.detail }),
+        metadata: {
+            request: {
+                service: "registry",
+                method: response.request.method,
+                url: response.request.url,
+            },
+            response: {
+                status,
+                ...(requestId === undefined ? {} : { requestId }),
+                ...(problem.code === undefined ? {} : { problemCode: problem.code }),
+                body,
+            },
+        },
+        ...(suggestions.length > 0 ? { suggestions } : {}),
+        cause: ctx?.cause ?? body,
+    });
+};
+export const registryClientErrorToProblem = (error, ctx) => registryErrorToProblem(retainedRegistryResponseBody(error.response, error.cause), error.response, {
+    ...(ctx?.suggestions === undefined ? {} : { suggestions: ctx.suggestions }),
+    cause: error,
+});
+//# sourceMappingURL=translate.js.map

package/dist/src/utils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Registry utility functions extracted from sources/providers/registry.ts.
+ *
+ * Shared helpers for registry operations: version selection, integrity
+ * computation, zip extraction, type pluralization, and path building.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { RegistryOperationFailed } from "./errors.js";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+import { type ExtensionType } from "@agentxm/extension-model/unstable/extensions";
+import type { ExtensionIndex, VersionEntry } from "@agentxm/registry-protocol/unstable/registry/schema";
+import { type ReleaseAgeEvaluation, type ReleaseAgeEvidence, type ReleaseAgeExemption } from "@agentxm/extension-model/unstable/extensions/release-age";
+/**
+ * Select the best matching version from a list of versions.
+ *
+ * Returns the maximum non-yanked version, independent of input order.
+ */
+export declare const selectVersion: (versions: ReadonlyArray<VersionEntry>) => Option.Option<VersionEntry>;
+export declare const resolveVersionEntry: (versions: ReadonlyArray<VersionEntry>, versionRange: Option.Option<string>) => Option.Option<VersionEntry>;
+export declare const extensionLifecycleWarnings: (index: ExtensionIndex, version: VersionEntry) => ReadonlyArray<string>;
+export declare const resolveVersionEntryWithReleaseAge: (versions: ReadonlyArray<VersionEntry>, versionRange: Option.Option<string>, minimumReleaseAge: Option.Option<Duration.Duration>) => Effect.Effect<Option.Option<VersionEntry>>;
+export type ReleaseAgeVersionResolution = {
+    readonly kind: "selected";
+    readonly version: VersionEntry;
+    readonly newerHeld?: ReleaseAgeEvidence;
+} | {
+    readonly kind: "exempted";
+    readonly version: VersionEntry;
+    readonly bypassed: ReleaseAgeEvidence;
+    readonly exemption: ReleaseAgeExemption;
+} | {
+    readonly kind: "version_unsatisfied";
+} | {
+    readonly kind: "policy_held";
+    readonly candidate: ReleaseAgeEvidence;
+};
+/**
+ * Resolve one visible Registry index under one caller-supplied release-age
+ * evaluation. The supplied timestamp makes a complete operation deterministic.
+ * An accepted version that satisfies the requested range is a lower bound for
+ * unattended selection, even while that version is itself under age.
+ */
+export declare const resolveVersionEntryForReleaseAge: (versions: ReadonlyArray<VersionEntry>, versionRange: Option.Option<string>, evaluation: ReleaseAgeEvaluation, exemption?: ReleaseAgeExemption, acceptedVersion?: string) => ReleaseAgeVersionResolution;
+/** Pluralize extension type for directory segments. */
+export declare const pluralizeType: (type: ExtensionType) => string;
+/** Build the path to an extension's directory within a registry. */
+export declare const extensionDir: (registryRoot: string, owner: Handle, type: ExtensionType, name: string, join: (...parts: readonly string[]) => string) => string;
+/**
+ * Extract a zip archive to a target directory.
+ * Uses fflate for in-memory decompression (portable across platforms).
+ */
+export declare const extractZip: (archive: Uint8Array, targetDir: string) => Effect.Effect<void, RegistryOperationFailed, FileSystem.FileSystem | Path.Path>;
+//# sourceMappingURL=utils.d.ts.map