@agentxm/registry-protocol 0.28.11 → 0.28.13

package/dist/src/unstable/publish/manifest-policy.js

@@ -1,196 +0,0 @@
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Result from "effect/Result";
-import * as Schema from "effect/Schema";
-import * as SchemaIssue from "effect/SchemaIssue";
-import { ExtensionNameSchema, ExtensionTypeSchema, } from "@agentxm/extension-model/unstable/extensions/common";
-import { HookManifestSchema, HOOK_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/hooks/manifest-schema";
-import { HandleSchema } from "@agentxm/extension-model/unstable/extensions/handle";
-import { KnowledgeManifestSchema, KNOWLEDGE_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/knowledge/manifest-schema";
-import { McpServerManifestSchema, MCP_SERVER_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/mcps/manifest-schema";
-import { PACK_MANIFEST_FILENAME, PackManifestSchema, } from "@agentxm/extension-model/unstable/packs/manifest-schema";
-import { RuleManifestSchema, RULE_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/rules/manifest-schema";
-import { SkillManifestSchema, MANIFEST_FILENAME as SKILL_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/skills/manifest-schema";
-import { SubagentManifestSchema, MANIFEST_FILENAME as SUBAGENT_MANIFEST_FILENAME, } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
-import { VersionSchema } from "@agentxm/extension-model/unstable/version-constraints";
-export class ManifestError extends Data.TaggedError("ManifestError") {
-}
-export const MANIFEST_FILENAME_BY_TYPE = {
-    skill: SKILL_MANIFEST_FILENAME,
-    "mcp-server": MCP_SERVER_MANIFEST_FILENAME,
-    subagent: SUBAGENT_MANIFEST_FILENAME,
-    pack: PACK_MANIFEST_FILENAME,
-    rule: RULE_MANIFEST_FILENAME,
-    hook: HOOK_MANIFEST_FILENAME,
-    knowledge: KNOWLEDGE_MANIFEST_FILENAME,
-};
-export const manifestFilenameForType = (type) => MANIFEST_FILENAME_BY_TYPE[type];
-export const ManifestIdentitySchema = Schema.Struct({
-    owner: HandleSchema.pipe(Schema.annotateKey({ messageMissingKey: "owner is required" })),
-    type: ExtensionTypeSchema.pipe(Schema.annotateKey({ messageMissingKey: "type is required" })),
-    name: ExtensionNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "name is required" })),
-    version: VersionSchema.pipe(Schema.annotateKey({ messageMissingKey: "version is required" })),
-}).annotate({
-    identifier: "ManifestIdentity",
-    title: "Manifest Identity",
-    description: "The key identity fields from a manifest: who owns it, what type, its name, and version.",
-});
-const MANIFEST_SCHEMA_BY_TYPE = {
-    skill: SkillManifestSchema,
-    "mcp-server": McpServerManifestSchema,
-    subagent: SubagentManifestSchema,
-    pack: PackManifestSchema,
-    rule: RuleManifestSchema,
-    hook: HookManifestSchema,
-    knowledge: KnowledgeManifestSchema,
-};
-export const manifestSchemaForType = (type) => MANIFEST_SCHEMA_BY_TYPE[type];
-const hasOwnField = (value, field) => typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    Object.hasOwn(value, field);
-const purlHasVersion = (value) => {
-    const queryStart = value.search(/[?#]/);
-    const comparable = queryStart === -1 ? value : value.slice(0, queryStart);
-    const lastSlash = comparable.lastIndexOf("/");
-    return lastSlash >= 0 && comparable.indexOf("@", lastSlash + 1) !== -1;
-};
-const purlType = (value) => {
-    const match = /^pkg:([^/]+)\//i.exec(value);
-    return match?.[1]?.toLowerCase();
-};
-const versScheme = (value) => {
-    const match = /^vers:([^/]+)\//i.exec(value);
-    return match?.[1]?.toLowerCase();
-};
-const classifyCompanionPackageManifestError = (raw) => {
-    if (typeof raw !== "object" || raw === null || !("packages" in raw)) {
-        return undefined;
-    }
-    const packages = Reflect.get(raw, "packages");
-    if (!Array.isArray(packages)) {
-        return {
-            code: "companion_package_invalid",
-            detail: "Manifest packages must be an array of companion package objects.",
-        };
-    }
-    for (const entry of packages) {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            return {
-                code: "companion_package_invalid",
-                detail: "Manifest packages entries must be objects with purl and optional versionRange fields.",
-            };
-        }
-        const purl = Reflect.get(entry, "purl");
-        if (typeof purl !== "string") {
-            return {
-                code: "companion_package_invalid",
-                detail: "Manifest packages entries must include a purl string.",
-            };
-        }
-        if (purlHasVersion(purl)) {
-            return {
-                code: "companion_package_purl_has_version",
-                detail: "Companion package purls are identities, not pins. Move versions into versionRange.",
-            };
-        }
-        const versionRange = Reflect.get(entry, "versionRange");
-        if (versionRange !== undefined && typeof versionRange !== "string") {
-            return {
-                code: "companion_package_invalid",
-                detail: "Manifest packages versionRange must be a VERS string.",
-            };
-        }
-        const packageType = purlType(purl);
-        const rangeScheme = typeof versionRange === "string" ? versScheme(versionRange) : undefined;
-        if (packageType !== undefined && rangeScheme !== undefined && packageType !== rangeScheme) {
-            return {
-                code: "companion_package_scheme_mismatch",
-                detail: "Companion package purl ecosystem must match the versionRange VERS scheme.",
-            };
-        }
-    }
-    // No concrete companion-package problem found: the schema decode failed for an
-    // unrelated reason, so let the caller fall back to a generic manifest error
-    // rather than misreporting it as companion_package_invalid.
-    return undefined;
-};
-export const validateManifestHasNoAgentsField = (fileName, raw) => {
-    if (!hasOwnField(raw, "agents"))
-        return Result.void;
-    return Result.fail(new ManifestError({
-        code: "manifest_schema_invalid",
-        detail: `Manifest file "${fileName}" must not include "agents"; express targeting in settings.agents.`,
-    }));
-};
-export const resolveManifest = (input) => Effect.gen(function* () {
-    const expectedFilename = manifestFilenameForType(input.type);
-    const [manifestEntry, ...rest] = input.entries.filter((entry) => {
-        const normalized = entry.fileName.replace(/\\/g, "/");
-        return (normalized === expectedFilename ||
-            normalized.toLowerCase() === expectedFilename.toLowerCase());
-    });
-    if (manifestEntry === undefined) {
-        return yield* new ManifestError({
-            code: "manifest_missing",
-            detail: `Expected manifest file "${expectedFilename}" not found in archive root.`,
-        });
-    }
-    if (rest.length > 0) {
-        const allCandidates = [manifestEntry, ...rest];
-        return yield* new ManifestError({
-            code: "manifest_multiple",
-            detail: `Multiple manifest candidates found for type "${input.type}": ${allCandidates.map((candidate) => candidate.fileName).join(", ")}.`,
-        });
-    }
-    const rawBytes = yield* input.readEntry(manifestEntry.fileName);
-    const text = new TextDecoder().decode(rawBytes);
-    const parsed = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(text).pipe(Effect.mapError(() => new ManifestError({
-        code: "manifest_invalid_json",
-        detail: `Manifest file "${manifestEntry.fileName}" contains invalid JSON.`,
-    })));
-    yield* Effect.fromResult(validateManifestHasNoAgentsField(manifestEntry.fileName, parsed));
-    const schema = manifestSchemaForType(input.type);
-    yield* Schema.decodeUnknownEffect(schema)(parsed).pipe(Effect.mapError((error) => {
-        const companionPackageError = classifyCompanionPackageManifestError(parsed);
-        return new ManifestError({
-            code: companionPackageError?.code ?? "manifest_schema_invalid",
-            detail: companionPackageError?.detail ??
-                `Manifest file "${manifestEntry.fileName}" does not conform to the ${input.type} manifest schema.`,
-            details: SchemaIssue.makeFormatterDefault()(error.issue),
-        });
-    }));
-    const identity = yield* Schema.decodeUnknownEffect(ManifestIdentitySchema)(parsed).pipe(Effect.mapError(() => new ManifestError({
-        code: "manifest_schema_invalid",
-        detail: `Manifest file "${manifestEntry.fileName}" is missing required identity fields (owner, type, name, version).`,
-    })));
-    return {
-        identity,
-        raw: parsed,
-        fileName: manifestEntry.fileName,
-    };
-});
-export const validateDeclaredManifestAlignment = (declaredIdentity, manifest) => {
-    const mismatches = [];
-    if (declaredIdentity.name !== manifest.name) {
-        mismatches.push(`name: declared="${declaredIdentity.name}" manifest="${manifest.name}"`);
-    }
-    if (declaredIdentity.owner !== manifest.owner) {
-        mismatches.push(`owner: declared="${declaredIdentity.owner}" manifest="${manifest.owner}"`);
-    }
-    if (declaredIdentity.type !== manifest.type) {
-        mismatches.push(`type: declared="${declaredIdentity.type}" manifest="${manifest.type}"`);
-    }
-    if (declaredIdentity.version !== manifest.version) {
-        mismatches.push(`version: declared="${declaredIdentity.version}" manifest="${manifest.version}"`);
-    }
-    if (mismatches.length > 0) {
-        return Result.fail(new ManifestError({
-            code: "declared_manifest_mismatch",
-            detail: `Declared publish identity and manifest identity disagree: ${mismatches.join(", ")}.`,
-            details: { declaredIdentity, manifest },
-        }));
-    }
-    return Result.void;
-};
-//# sourceMappingURL=manifest-policy.js.map

package/dist/src/unstable/publish/test-zip-helpers.d.ts

@@ -1,13 +0,0 @@
-interface ZipFileEntry {
-    fileName: string;
-    content: Uint8Array;
-    compressionMethod?: number;
-    externalAttributes?: number;
-}
-export declare const buildZip: (entries: ZipFileEntry[]) => Uint8Array;
-export declare const buildSymlinkZip: (symlinkName: string, targetPath: string) => Uint8Array;
-export declare const buildDecompressionBombZip: (uncompressedSize: number, compressedSize: number, entryName?: string) => Uint8Array;
-export declare const buildMalformedZip: () => Uint8Array;
-export declare const textContent: (text: string) => Uint8Array;
-export {};
-//# sourceMappingURL=test-zip-helpers.d.ts.map

package/dist/src/unstable/publish/test-zip-helpers.js

@@ -1,117 +0,0 @@
-import * as zlib from "node:zlib";
-const textEncoder = new TextEncoder();
-const LOCAL_FILE_HEADER_SIG = 0x04034b50;
-const CENTRAL_DIR_SIG = 0x02014b50;
-const EOCD_SIG = 0x06054b50;
-const writeUint32LE = (buf, offset, value) => buf.setUint32(offset, value, true);
-const writeUint16LE = (buf, offset, value) => buf.setUint16(offset, value, true);
-const concatBytes = (arrays) => {
-    const totalLength = arrays.reduce((sum, array) => sum + array.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const array of arrays) {
-        result.set(array, offset);
-        offset += array.length;
-    }
-    return result;
-};
-export const buildZip = (entries) => {
-    const centralDirs = [];
-    let currentOffset = 0;
-    const localParts = [];
-    for (const entry of entries) {
-        const fileNameBytes = textEncoder.encode(entry.fileName);
-        const compressionMethod = entry.compressionMethod ?? 0;
-        let compressedData;
-        if (compressionMethod === 8) {
-            const deflated = zlib.deflateRawSync(entry.content);
-            compressedData = new Uint8Array(deflated.buffer, deflated.byteOffset, deflated.byteLength);
-        }
-        else {
-            compressedData = entry.content;
-        }
-        const localBuf = new ArrayBuffer(30);
-        const localView = new DataView(localBuf);
-        writeUint32LE(localView, 0, LOCAL_FILE_HEADER_SIG);
-        writeUint16LE(localView, 4, 20);
-        writeUint16LE(localView, 6, 0);
-        writeUint16LE(localView, 8, compressionMethod);
-        writeUint16LE(localView, 10, 0);
-        writeUint16LE(localView, 12, 0);
-        writeUint32LE(localView, 14, 0);
-        writeUint32LE(localView, 18, compressedData.length);
-        writeUint32LE(localView, 22, entry.content.length);
-        writeUint16LE(localView, 26, fileNameBytes.length);
-        writeUint16LE(localView, 28, 0);
-        const localHeaderBytes = new Uint8Array(localBuf);
-        const localRecord = concatBytes([localHeaderBytes, fileNameBytes, compressedData]);
-        localParts.push(localRecord);
-        const cdirBuf = new ArrayBuffer(46);
-        const cdirView = new DataView(cdirBuf);
-        writeUint32LE(cdirView, 0, CENTRAL_DIR_SIG);
-        writeUint16LE(cdirView, 4, 20);
-        writeUint16LE(cdirView, 6, 20);
-        writeUint16LE(cdirView, 8, 0);
-        writeUint16LE(cdirView, 10, compressionMethod);
-        writeUint16LE(cdirView, 12, 0);
-        writeUint16LE(cdirView, 14, 0);
-        writeUint32LE(cdirView, 16, 0);
-        writeUint32LE(cdirView, 20, compressedData.length);
-        writeUint32LE(cdirView, 24, entry.content.length);
-        writeUint16LE(cdirView, 28, fileNameBytes.length);
-        writeUint16LE(cdirView, 30, 0);
-        writeUint16LE(cdirView, 32, 0);
-        writeUint16LE(cdirView, 34, 0);
-        writeUint16LE(cdirView, 36, 0);
-        writeUint32LE(cdirView, 38, entry.externalAttributes ?? 0);
-        writeUint32LE(cdirView, 42, currentOffset);
-        centralDirs.push(concatBytes([new Uint8Array(cdirBuf), fileNameBytes]));
-        currentOffset += localRecord.length;
-    }
-    const cdirStartOffset = currentOffset;
-    const allCdir = concatBytes(centralDirs);
-    const eocdBuf = new ArrayBuffer(22);
-    const eocdView = new DataView(eocdBuf);
-    writeUint32LE(eocdView, 0, EOCD_SIG);
-    writeUint16LE(eocdView, 4, 0);
-    writeUint16LE(eocdView, 6, 0);
-    writeUint16LE(eocdView, 8, entries.length);
-    writeUint16LE(eocdView, 10, entries.length);
-    writeUint32LE(eocdView, 12, allCdir.length);
-    writeUint32LE(eocdView, 16, cdirStartOffset);
-    writeUint16LE(eocdView, 20, 0);
-    return concatBytes([...localParts, allCdir, new Uint8Array(eocdBuf)]);
-};
-export const buildSymlinkZip = (symlinkName, targetPath) => {
-    const symlinkAttrs = (0xa000 | 0o777) << 16;
-    return buildZip([
-        {
-            fileName: symlinkName,
-            content: textEncoder.encode(targetPath),
-            externalAttributes: symlinkAttrs,
-        },
-    ]);
-};
-export const buildDecompressionBombZip = (uncompressedSize, compressedSize, entryName = "bomb.bin") => {
-    const content = new Uint8Array(compressedSize);
-    const zip = buildZip([
-        {
-            fileName: entryName,
-            content,
-            compressionMethod: 0,
-        },
-    ]);
-    const view = new DataView(zip.buffer, zip.byteOffset, zip.byteLength);
-    view.setUint32(22, uncompressedSize, true);
-    for (let i = zip.length - 22; i >= 0; i--) {
-        if (view.getUint32(i, true) === EOCD_SIG) {
-            const cdirOffset = view.getUint32(i + 16, true);
-            view.setUint32(cdirOffset + 24, uncompressedSize, true);
-            break;
-        }
-    }
-    return zip;
-};
-export const buildMalformedZip = () => new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]);
-export const textContent = (text) => textEncoder.encode(text);
-//# sourceMappingURL=test-zip-helpers.js.map

package/dist/src/unstable/registry/release-age-policy.d.ts

@@ -1,57 +0,0 @@
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import type { ExtensionFqnParts } from "@agentxm/extension-model/unstable/extensions/common";
-import type { ReleaseAgeEvaluation, ReleaseAgeEvidence, ReleaseAgeExemption } from "@agentxm/extension-model/unstable/extensions/release-age";
-import type { VersionEntry } from "./schema.js";
-export declare const releaseAgeExemptionForIdentity: (evaluation: ReleaseAgeEvaluation, identity: ExtensionFqnParts) => ReleaseAgeExemption | undefined;
-export interface ReleaseAgeRecordBase {
-    readonly reason: "minimum-release-age";
-    readonly target: string;
-    readonly dependencyPath: ReadonlyArray<string>;
-    readonly requestedRange?: string;
-    readonly currentVersion?: string;
-    readonly selectedVersion?: string;
-    readonly candidateVersion: string;
-    readonly publishedAt: string;
-    readonly eligibleAt: string;
-    readonly minimumReleaseAgeSeconds: number;
-}
-export type ReleaseAgeHoldbackRecord = ReleaseAgeRecordBase;
-export type ReleaseAgeBypassRecord = ReleaseAgeRecordBase & ({
-    readonly bypassCause: "exclude";
-    readonly exemptionScope: "project" | "user";
-} | {
-    readonly bypassCause: "ignore-flag";
-});
-export type ReleaseAgeRecord = ReleaseAgeHoldbackRecord | ReleaseAgeBypassRecord;
-export interface ReleaseAgeOperationEvidence {
-    readonly evaluatedAt: string;
-    readonly holdbacks: ReadonlyArray<ReleaseAgeHoldbackRecord>;
-    readonly bypasses: ReadonlyArray<ReleaseAgeBypassRecord>;
-}
-/** Deduplicate and order operation evidence independently from concurrent resolution order. */
-export declare const normalizeReleaseAgeRecords: <Record extends ReleaseAgeRecord>(records: ReadonlyArray<Record>) => ReadonlyArray<Record>;
-export declare const DEFAULT_MINIMUM_RELEASE_AGE = "24h";
-export declare const DEFAULT_MINIMUM_RELEASE_AGE_DURATION: Duration.Duration;
-export declare const parseMinimumReleaseAge: (value: string) => Option.Option<Duration.Duration>;
-/**
- * Render a release-age window in the compact grammar the setting accepts, so
- * output names the policy in the same units the reader would configure.
- *
- * Days are used only from two days up: the default window is written `24h`,
- * and reporting it as `1d` would not match the setting the reader would edit.
- * Falls back to whole seconds when the window is not a clean larger unit.
- */
-export declare const formatMinimumReleaseAgeSeconds: (seconds: number) => string;
-export declare const isVersionEntryMature: (entry: VersionEntry, minimumAge: Duration.Duration) => Effect.Effect<boolean>;
-export declare const isVersionEntryEligibleAt: (entry: VersionEntry, evaluation: ReleaseAgeEvaluation) => boolean;
-export declare const releaseAgeEvidence: (entry: VersionEntry, evaluation: ReleaseAgeEvaluation) => ReleaseAgeEvidence;
-export declare const filterMatureVersions: (versions: ReadonlyArray<VersionEntry>, minimumAge: Duration.Duration) => Effect.Effect<ReadonlyArray<VersionEntry>>;
-export declare const releaseAgeHoldbackWarning: (args: {
-    readonly fqn: string;
-    readonly selectedVersion: string;
-    readonly heldVersion: string;
-    readonly minimumReleaseAge: string;
-}) => string;
-//# sourceMappingURL=release-age-policy.d.ts.map

package/dist/src/unstable/registry/release-age-policy.js

@@ -1,117 +0,0 @@
-import * as DateTime from "effect/DateTime";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { matchesReleaseAgeExcludePattern } from "@agentxm/extension-model/unstable/extensions/fqn-pattern";
-export const releaseAgeExemptionForIdentity = (evaluation, identity) => {
-    if (evaluation.grantedExemption !== undefined)
-        return evaluation.grantedExemption;
-    const excluded = evaluation.exclude?.find(({ pattern }) => matchesReleaseAgeExcludePattern(pattern, identity));
-    if (excluded !== undefined) {
-        return { bypassCause: "exclude", exemptionScope: excluded.scope };
-    }
-    return evaluation.mode === "ignore" ? { bypassCause: "ignore-flag" } : undefined;
-};
-const releaseAgeRecordKey = (record) => [
-    record.target,
-    ...record.dependencyPath,
-    record.candidateVersion,
-    record.selectedVersion ?? "",
-    record.currentVersion ?? "",
-    record.requestedRange ?? "",
-    "bypassCause" in record ? record.bypassCause : "",
-    "exemptionScope" in record ? record.exemptionScope : "",
-].join("\u0000");
-/** Deduplicate and order operation evidence independently from concurrent resolution order. */
-export const normalizeReleaseAgeRecords = (records) => {
-    const byKey = new Map();
-    for (const record of records) {
-        byKey.set(releaseAgeRecordKey(record), record);
-    }
-    return [...byKey.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([, record]) => record);
-};
-export const DEFAULT_MINIMUM_RELEASE_AGE = "24h";
-export const DEFAULT_MINIMUM_RELEASE_AGE_DURATION = Duration.hours(24);
-/**
- * Documented exception: hand-rolled parser for the compact duration grammar
- * (`24h`, `30d`, `500ms`).
- *
- * Effect v4 has no `Duration.decode`; the closest constructors are
- * `Duration.fromInput` / `Duration.fromInputUnsafe`, and the `Duration.Input`
- * string form only accepts space-separated long-unit strings ("30 days"), so
- * the compact grammar is not expressible upstream. `durationPattern` and
- * `parseMinimumReleaseAge` therefore stay as a thin syntax adapter over the
- * `Duration` constructors (`Duration.millis` / `seconds` / `minutes` /
- * `hours` / `days`).
- *
- * Removal condition: upstream `Duration` accepting the compact unit grammar.
- */
-const durationPattern = /^(\d+)(ms|s|m|h|d)$/;
-export const parseMinimumReleaseAge = (value) => {
-    const trimmed = value.trim();
-    const match = durationPattern.exec(trimmed);
-    if (match === null)
-        return Option.none();
-    const amountText = match[1];
-    const unit = match[2];
-    if (amountText === undefined || unit === undefined)
-        return Option.none();
-    const amount = Number(amountText);
-    if (!Number.isSafeInteger(amount))
-        return Option.none();
-    switch (unit) {
-        case "ms":
-            return Option.some(Duration.millis(amount));
-        case "s":
-            return Option.some(Duration.seconds(amount));
-        case "m":
-            return Option.some(Duration.minutes(amount));
-        case "h":
-            return Option.some(Duration.hours(amount));
-        case "d":
-            return Option.some(Duration.days(amount));
-    }
-    // Unreachable at runtime, but `unit` is typed `string` (a regex capture),
-    // so the switch is not statically exhaustive and the compiler (TS2366)
-    // requires this ending return.
-    return Option.none();
-};
-/**
- * Render a release-age window in the compact grammar the setting accepts, so
- * output names the policy in the same units the reader would configure.
- *
- * Days are used only from two days up: the default window is written `24h`,
- * and reporting it as `1d` would not match the setting the reader would edit.
- * Falls back to whole seconds when the window is not a clean larger unit.
- */
-export const formatMinimumReleaseAgeSeconds = (seconds) => {
-    const whole = Math.max(0, Math.round(seconds));
-    if (whole === 0)
-        return "0s";
-    if (whole % 86_400 === 0 && whole >= 172_800)
-        return `${whole / 86_400}d`;
-    if (whole % 3_600 === 0)
-        return `${whole / 3_600}h`;
-    if (whole % 60 === 0)
-        return `${whole / 60}m`;
-    return `${whole}s`;
-};
-export const isVersionEntryMature = (entry, minimumAge) => Duration.isLessThanOrEqualTo(minimumAge, Duration.zero)
-    ? Effect.succeed(true)
-    : DateTime.now.pipe(Effect.map((now) => 
-    // Inclusive at the boundary: a release published exactly `minimumAge`
-    // ago is mature, matching the original `now - published >= minimumAge`.
-    DateTime.isLessThanOrEqualTo(DateTime.addDuration(entry.published, minimumAge), now)));
-export const isVersionEntryEligibleAt = (entry, evaluation) => Duration.isLessThanOrEqualTo(evaluation.minimumReleaseAge, Duration.zero) ||
-    DateTime.isLessThanOrEqualTo(DateTime.addDuration(entry.published, evaluation.minimumReleaseAge), evaluation.evaluatedAt);
-export const releaseAgeEvidence = (entry, evaluation) => ({
-    version: entry.version,
-    publishedAt: DateTime.formatIso(entry.published),
-    eligibleAt: DateTime.formatIso(DateTime.addDuration(entry.published, evaluation.minimumReleaseAge)),
-    minimumReleaseAgeSeconds: Math.max(0, Duration.toMillis(evaluation.minimumReleaseAge) / 1_000),
-});
-export const filterMatureVersions = (versions, minimumAge) => Effect.filter(versions, (entry) => isVersionEntryMature(entry, minimumAge));
-export const releaseAgeHoldbackWarning = (args) => `${args.fqn} held at ${args.selectedVersion} — ${args.heldVersion} has not reached the ${args.minimumReleaseAge} minimum release age`;
-//# sourceMappingURL=release-age-policy.js.map