niceeval 0.12.2-canary.31 → 0.13.0

package/dist/record/family/assertions.d.ts

@@ -0,0 +1,292 @@
+import { Schema } from "effect";
+import { type RecordBlobRef } from "../attachment/blob-ref.js";
+import { type RecordAttachmentIssue } from "../attachment/errors.js";
+import type { SourcesAttachment } from "./sources.js";
+/**
+ * A source site is a semantic join only. It names an item in the exact origin
+ * Run Sources payload and never gains that payload's blob capability.
+ */
+export declare const AssertionSourceSiteSchema: Schema.Struct<{
+    entryId: Schema.Schema<import("../../index.js").AssertionEntryId, string, never>;
+    sourceOrder: Schema.filter<typeof Schema.JsonNumber>;
+    role: Schema.Literal<["declaration", "threshold", "score", "gate", "optional", "stop"]>;
+    sourceItemId: Schema.Schema<import("../model/identifiers.js").SourceItemId, string, never>;
+    sha256: Schema.Schema<import("../model/identifiers.js").Sha256Digest, string, never>;
+    start: Schema.Struct<{
+        line: Schema.filter<typeof Schema.JsonNumber>;
+        column: Schema.filter<typeof Schema.JsonNumber>;
+    }>;
+    end: Schema.Struct<{
+        line: Schema.filter<typeof Schema.JsonNumber>;
+        column: Schema.filter<typeof Schema.JsonNumber>;
+    }>;
+}>;
+export type AssertionSourceSite = Schema.Schema.Type<typeof AssertionSourceSiteSchema>;
+/** Reuse the existing v1 entry schema inside the one direct attachment schema. */
+export declare const AssertionsEntriesSchema: Schema.filter<Schema.Array$<Schema.filter<Schema.Struct<{
+    entryId: Schema.Schema<import("../../index.js").AssertionEntryId, string, never>;
+    display: Schema.Schema<import("../../assertions/record/model.js").AssertionDisplay, import("../../assertions/record/model.js").AssertionDisplay, never>;
+    criterion: Schema.Schema<import("../../assertions/record/model.js").BoundedJsonObject, import("../../assertions/record/model.js").BoundedJsonObject, never>;
+    subject: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["snapshot"]>;
+        value: Schema.Schema<import("../../assertions/record/model.js").BoundedJsonValue, import("../../assertions/record/model.js").BoundedJsonValue, never>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["blob"]>;
+        ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+        encoding: Schema.Literal<["utf-8", "binary"]>;
+        byteLength: Schema.filter<typeof Schema.JsonNumber>;
+        sha256: Schema.Schema<import("../model/identifiers.js").Sha256Digest, string, never>;
+        preview: Schema.filter<typeof Schema.String>;
+    }>]>;
+    evidence: Schema.Array$<Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["snapshot"]>;
+        value: Schema.Schema<import("../../assertions/record/model.js").BoundedJsonValue, import("../../assertions/record/model.js").BoundedJsonValue, never>;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["blob"]>;
+        ref: Schema.Schema<RecordBlobRef, RecordBlobRef, never>;
+        encoding: Schema.Literal<["utf-8", "binary"]>;
+        byteLength: Schema.filter<typeof Schema.JsonNumber>;
+        sha256: Schema.Schema<import("../model/identifiers.js").Sha256Digest, string, never>;
+        preview: Schema.filter<typeof Schema.String>;
+    }>]>>;
+    coverage: Schema.Schema<import("../../assertions/record/model.js").AssertionCoverage, import("../../assertions/record/model.js").AssertionCoverage, never>;
+    limitations: Schema.Array$<Schema.Schema<import("../../assertions/record/model.js").AssertionLimitation, import("../../assertions/record/model.js").AssertionLimitation, never>>;
+    result: Schema.Schema<import("../../assertions/record/model.js").SealedAssertionResult, import("../../assertions/record/model.js").SealedAssertionResult, never>;
+}>>>>;
+export declare const AssertionSourceSitesSchema: Schema.Array$<Schema.Struct<{
+    entryId: Schema.Schema<import("../../index.js").AssertionEntryId, string, never>;
+    sourceOrder: Schema.filter<typeof Schema.JsonNumber>;
+    role: Schema.Literal<["declaration", "threshold", "score", "gate", "optional", "stop"]>;
+    sourceItemId: Schema.Schema<import("../model/identifiers.js").SourceItemId, string, never>;
+    sha256: Schema.Schema<import("../model/identifiers.js").Sha256Digest, string, never>;
+    start: Schema.Struct<{
+        line: Schema.filter<typeof Schema.JsonNumber>;
+        column: Schema.filter<typeof Schema.JsonNumber>;
+    }>;
+    end: Schema.Struct<{
+        line: Schema.filter<typeof Schema.JsonNumber>;
+        column: Schema.filter<typeof Schema.JsonNumber>;
+    }>;
+}>>;
+/**
+ * `sourceSites` is embedded in the fixed Assertions payload. The former
+ * `niceeval.assertion-source-sites/v1` family is not part of Record v1.
+ */
+/** One direct current schema: Type fields and durable keys share all v1 filters. */
+export declare const AssertionsAttachmentSchema: Schema.filter<Schema.filter<Schema.filter<Schema.filter<Schema.Struct<{
+    entries: Schema.PropertySignature<":", readonly {
+        readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
+        readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+        readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+        readonly subject: {
+            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+            readonly kind: "snapshot";
+        } | {
+            readonly kind: "blob";
+            readonly ref: RecordBlobRef;
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly encoding: "utf-8" | "binary";
+            readonly preview: string;
+            readonly byteLength: number;
+        };
+        readonly evidence: readonly ({
+            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+            readonly kind: "snapshot";
+        } | {
+            readonly kind: "blob";
+            readonly ref: RecordBlobRef;
+            readonly sha256: import("../model/identifiers.js").Sha256Digest;
+            readonly encoding: "utf-8" | "binary";
+            readonly preview: string;
+            readonly byteLength: number;
+        })[];
+        readonly display: import("../../assertions/record/model.js").AssertionDisplay;
+        readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+        readonly entryId: import("../../index.js").AssertionEntryId;
+    }[], "entries-data", ":", readonly {
+        readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
+        readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+        readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+        readonly subject: {
+            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+            readonly kind: "snapshot";
+        } | {
+            readonly kind: "blob";
+            readonly ref: RecordBlobRef;
+            readonly sha256: string;
+            readonly encoding: "utf-8" | "binary";
+            readonly preview: string;
+            readonly byteLength: number;
+        };
+        readonly evidence: readonly ({
+            readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+            readonly kind: "snapshot";
+        } | {
+            readonly kind: "blob";
+            readonly ref: RecordBlobRef;
+            readonly sha256: string;
+            readonly encoding: "utf-8" | "binary";
+            readonly preview: string;
+            readonly byteLength: number;
+        })[];
+        readonly display: import("../../assertions/record/model.js").AssertionDisplay;
+        readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+        readonly entryId: string;
+    }[], false, never>;
+    sourceSites: Schema.PropertySignature<":", readonly {
+        readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+        readonly sha256: import("../model/identifiers.js").Sha256Digest;
+        readonly start: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly end: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+        readonly sourceOrder: number;
+        readonly entryId: import("../../index.js").AssertionEntryId;
+    }[], "source-sites-data", ":", readonly {
+        readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+        readonly sha256: string;
+        readonly start: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly end: {
+            readonly line: number;
+            readonly column: number;
+        };
+        readonly sourceItemId: string;
+        readonly sourceOrder: number;
+        readonly entryId: string;
+    }[], false, never>;
+}>>>>>;
+export type AssertionsAttachment = Schema.Schema.Type<typeof AssertionsAttachmentSchema>;
+/** Complete closure projection for `niceeval.assertions`. */
+export declare function assertionsBlobRefs(payload: AssertionsAttachment): readonly RecordBlobRef[];
+/** Binds every Assertions blob declaration to its exact materialized bytes. */
+export declare function assertionsAttachmentIntegrityIssues(payload: AssertionsAttachment, blobs: readonly {
+    readonly ref: RecordBlobRef;
+    readonly bytes: Uint8Array;
+}[]): readonly RecordAttachmentIssue[];
+/**
+ * Host-only semantic join to the exact origin Sources manifest.  The row owns
+ * neither source bytes nor a blob capability, so this check deliberately
+ * compares only the explicit item identity, digest, and stored coordinates.
+ */
+export declare function assertionsSourceSiteIntegrityIssues(payload: AssertionsAttachment, sources: SourcesAttachment): readonly RecordAttachmentIssue[];
+/** The sole current declaration for the Attempt-owned Assertions family. */
+export declare const assertionsRecordAttachment: import("../definition/attachment.js").RecordAttachmentDefinition<"niceeval.assertions", {
+    readonly attempt: {
+        readonly schema: Schema.filter<Schema.filter<Schema.filter<Schema.filter<Schema.Struct<{
+            entries: Schema.PropertySignature<":", readonly {
+                readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
+                readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                readonly subject: {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly evidence: readonly ({
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+                readonly display: import("../../assertions/record/model.js").AssertionDisplay;
+                readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+                readonly entryId: import("../../index.js").AssertionEntryId;
+            }[], "entries-data", ":", readonly {
+                readonly result: import("../../assertions/record/model.js").SealedAssertionResult;
+                readonly coverage: import("../../assertions/record/model.js").AssertionCoverage;
+                readonly limitations: readonly import("../../assertions/record/model.js").AssertionLimitation[];
+                readonly subject: {
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: string;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                };
+                readonly evidence: readonly ({
+                    readonly value: import("../../assertions/record/model.js").BoundedJsonValue;
+                    readonly kind: "snapshot";
+                } | {
+                    readonly kind: "blob";
+                    readonly ref: RecordBlobRef;
+                    readonly sha256: string;
+                    readonly encoding: "utf-8" | "binary";
+                    readonly preview: string;
+                    readonly byteLength: number;
+                })[];
+                readonly display: import("../../assertions/record/model.js").AssertionDisplay;
+                readonly criterion: import("../../assertions/record/model.js").BoundedJsonObject;
+                readonly entryId: string;
+            }[], false, never>;
+            sourceSites: Schema.PropertySignature<":", readonly {
+                readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+                readonly sha256: import("../model/identifiers.js").Sha256Digest;
+                readonly start: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly end: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly sourceItemId: import("../model/identifiers.js").SourceItemId;
+                readonly sourceOrder: number;
+                readonly entryId: import("../../index.js").AssertionEntryId;
+            }[], "source-sites-data", ":", readonly {
+                readonly role: "gate" | "score" | "declaration" | "threshold" | "optional" | "stop";
+                readonly sha256: string;
+                readonly start: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly end: {
+                    readonly line: number;
+                    readonly column: number;
+                };
+                readonly sourceItemId: string;
+                readonly sourceOrder: number;
+                readonly entryId: string;
+            }[], false, never>;
+        }>>>>>;
+        readonly limits: Readonly<{
+            maximumJsonBytes: number;
+            maximumDepth: 32;
+            maximumNodes: 200000;
+            maximumObjectKeys: 50000;
+            maximumArrayItems: 100000;
+            maximumKeyUtf8Bytes: 256;
+            maximumStringUtf8Bytes: number;
+        }>;
+        readonly blobs: {
+            readonly refs: typeof assertionsBlobRefs;
+            readonly budget: Readonly<{
+                maximumBlobs: 20000;
+                maximumBlobBytes: number;
+                maximumTotalBytes: number;
+            }>;
+            readonly verify: typeof assertionsAttachmentIntegrityIssues;
+        };
+    };
+}>;

package/dist/record/family/assertions.js

@@ -0,0 +1,20 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./assertions.cjs");
+const __niceevalExport0 = __niceevalCanonical["AssertionSourceSiteSchema"];
+export { __niceevalExport0 as AssertionSourceSiteSchema };
+const __niceevalExport1 = __niceevalCanonical["AssertionSourceSitesSchema"];
+export { __niceevalExport1 as AssertionSourceSitesSchema };
+const __niceevalExport2 = __niceevalCanonical["AssertionsAttachmentSchema"];
+export { __niceevalExport2 as AssertionsAttachmentSchema };
+const __niceevalExport3 = __niceevalCanonical["AssertionsEntriesSchema"];
+export { __niceevalExport3 as AssertionsEntriesSchema };
+const __niceevalExport4 = __niceevalCanonical["assertionsAttachmentIntegrityIssues"];
+export { __niceevalExport4 as assertionsAttachmentIntegrityIssues };
+const __niceevalExport5 = __niceevalCanonical["assertionsBlobRefs"];
+export { __niceevalExport5 as assertionsBlobRefs };
+const __niceevalExport6 = __niceevalCanonical["assertionsRecordAttachment"];
+export { __niceevalExport6 as assertionsRecordAttachment };
+const __niceevalExport7 = __niceevalCanonical["assertionsSourceSiteIntegrityIssues"];
+export { __niceevalExport7 as assertionsSourceSiteIntegrityIssues };
+//# sourceMappingURL=assertions.js.map

package/dist/record/family/assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.js","sources":[],"names":[],"mappings":""}

package/dist/record/family/catalog.cjs

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedRecordAttachmentEnvelopeSchema = exports.NiceEvalRecordFamilyCatalog = exports.runArtifactsRecordFamily = exports.attemptArtifactsRecordFamily = exports.sourcesRecordFamily = exports.sourceNavigationRecordFamily = exports.fileChangesRecordFamily = exports.runObservabilityRecordFamily = exports.attemptObservabilityRecordFamily = exports.assertionsRecordFamily = exports.NiceEvalFamilySchema = exports.NICE_EVAL_FAMILIES = exports.NiceEvalRecordAttachments = void 0;
+exports.decodeFixedRecordAttachmentEnvelope = decodeFixedRecordAttachmentEnvelope;
+exports.encodeFixedRecordAttachmentEnvelope = encodeFixedRecordAttachmentEnvelope;
+const effect_1 = require("effect");
+const internal_ts_1 = require("../attachment/internal.cjs");
+const core_ts_1 = require("../codec/core.cjs");
+const assertions_ts_1 = require("./assertions.cjs");
+const artifacts_ts_1 = require("./artifacts.cjs");
+const file_changes_ts_1 = require("./file-changes.cjs");
+const observability_ts_1 = require("./observability.cjs");
+const source_navigation_ts_1 = require("./source-navigation.cjs");
+const sources_ts_1 = require("./sources.cjs");
+/** The catalog lists declarations only; family identities come from them. */
+exports.NiceEvalRecordAttachments = Object.freeze({
+    assertions: assertions_ts_1.assertionsRecordAttachment,
+    observability: observability_ts_1.observabilityRecordAttachment,
+    fileChanges: file_changes_ts_1.fileChangesRecordAttachment,
+    sourceNavigation: source_navigation_ts_1.sourceNavigationRecordAttachment,
+    sources: sources_ts_1.sourcesRecordAttachment,
+    artifacts: artifacts_ts_1.artifactsRecordAttachment,
+});
+exports.NICE_EVAL_FAMILIES = Object.freeze([
+    exports.NiceEvalRecordAttachments.assertions.family,
+    exports.NiceEvalRecordAttachments.observability.family,
+    exports.NiceEvalRecordAttachments.fileChanges.family,
+    exports.NiceEvalRecordAttachments.sourceNavigation.family,
+    exports.NiceEvalRecordAttachments.sources.family,
+    exports.NiceEvalRecordAttachments.artifacts.family,
+]);
+exports.NiceEvalFamilySchema = effect_1.Schema.Literal(...exports.NICE_EVAL_FAMILIES);
+function requireFixed(result, message) {
+    if (effect_1.Either.isLeft(result))
+        throw new Error(message);
+    return result.right;
+}
+function fixedFamily(declaration, owner) {
+    const ownerDefinition = declaration.current.owners[owner];
+    if (ownerDefinition === undefined) {
+        throw new Error(`Fixed Record family ${declaration.family} does not declare a ${owner} owner`);
+    }
+    const write = requireFixed((0, internal_ts_1.makeFixedAttachmentWriteSpec)(ownerDefinition), `Fixed Record family ${declaration.family} must have a valid compiled ${owner} owner`);
+    return Object.freeze({
+        family: declaration.family,
+        schemaVersion: declaration.current.schemaVersion,
+        owner,
+        write,
+        adjacentMigrationLinks: declaration.adjacentMigrationLinks,
+    });
+}
+exports.assertionsRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.assertions, "attempt");
+exports.attemptObservabilityRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.observability, "attempt");
+exports.runObservabilityRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.observability, "run");
+exports.fileChangesRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.fileChanges, "attempt");
+exports.sourceNavigationRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.sourceNavigation, "attempt");
+exports.sourcesRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.sources, "run");
+exports.attemptArtifactsRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.artifacts, "attempt");
+exports.runArtifactsRecordFamily = fixedFamily(exports.NiceEvalRecordAttachments.artifacts, "run");
+/** The static Record v1 catalog is closed; family protocol remains at each declaration. */
+exports.NiceEvalRecordFamilyCatalog = Object.freeze({
+    assertions: exports.assertionsRecordFamily,
+    observability: Object.freeze({
+        attempt: exports.attemptObservabilityRecordFamily,
+        run: exports.runObservabilityRecordFamily,
+    }),
+    fileChanges: exports.fileChangesRecordFamily,
+    sourceNavigation: exports.sourceNavigationRecordFamily,
+    sources: exports.sourcesRecordFamily,
+    artifacts: Object.freeze({
+        attempt: exports.attemptArtifactsRecordFamily,
+        run: exports.runArtifactsRecordFamily,
+    }),
+});
+exports.FixedRecordAttachmentEnvelopeSchema = effect_1.Schema.Struct({
+    family: exports.NiceEvalFamilySchema,
+    schemaVersion: effect_1.Schema.Int.pipe(effect_1.Schema.positive()),
+});
+function decodeFixedRecordAttachmentEnvelope(input) {
+    const decoded = effect_1.Schema.decodeUnknownEither(exports.FixedRecordAttachmentEnvelopeSchema, core_ts_1.RecordExactParseOptions)(input);
+    return effect_1.Either.isLeft(decoded)
+        ? effect_1.Either.left(Object.freeze({ code: "record-fixed-family-envelope-invalid" }))
+        : effect_1.Either.right(decoded.right);
+}
+function encodeFixedRecordAttachmentEnvelope(envelope) {
+    const encoded = effect_1.Schema.encodeUnknownEither(exports.FixedRecordAttachmentEnvelopeSchema, core_ts_1.RecordExactParseOptions)(envelope);
+    return effect_1.Either.isLeft(encoded)
+        ? effect_1.Either.left(Object.freeze({ code: "record-fixed-family-envelope-invalid" }))
+        : effect_1.Either.right(encoded.right);
+}
+//# sourceMappingURL=catalog.cjs.map

package/dist/record/family/catalog.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["catalog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Either, Schema } from \"effect\";\nimport { makeFixedAttachmentWriteSpec } from \"../attachment/internal.ts\";\nimport type { FixedAttachmentWriteSpec, RecordAttachmentWrite, } from \"../attachment/types.ts\";\nimport { RecordExactParseOptions } from \"../codec/core.ts\";\nimport type { RecordAttachmentAdjacentMigrationLink, RecordAttachmentDefinition, RecordAttachmentOwnerDefinition, RecordAttachmentOwnerInputs, } from \"../definition/index.ts\";\nimport { assertionsRecordAttachment } from \"./assertions.ts\";\nimport { artifactsRecordAttachment } from \"./artifacts.ts\";\nimport { type FixedRecordAttachmentOwner, } from \"./common.ts\";\nimport { fileChangesRecordAttachment } from \"./file-changes.ts\";\nimport { observabilityRecordAttachment } from \"./observability.ts\";\nimport { sourceNavigationRecordAttachment } from \"./source-navigation.ts\";\nimport { sourcesRecordAttachment } from \"./sources.ts\";\n/** The catalog lists declarations only; family identities come from them. */\nexport const NiceEvalRecordAttachments = Object.freeze({\n    assertions: assertionsRecordAttachment,\n    observability: observabilityRecordAttachment,\n    fileChanges: fileChangesRecordAttachment,\n    sourceNavigation: sourceNavigationRecordAttachment,\n    sources: sourcesRecordAttachment,\n    artifacts: artifactsRecordAttachment,\n});\nexport const NICE_EVAL_FAMILIES = Object.freeze([\n    NiceEvalRecordAttachments.assertions.family,\n    NiceEvalRecordAttachments.observability.family,\n    NiceEvalRecordAttachments.fileChanges.family,\n    NiceEvalRecordAttachments.sourceNavigation.family,\n    NiceEvalRecordAttachments.sources.family,\n    NiceEvalRecordAttachments.artifacts.family,\n] as const);\nexport type NiceEvalFamily = (typeof NICE_EVAL_FAMILIES)[number];\nexport const NiceEvalFamilySchema: Schema.Schema<NiceEvalFamily> = Schema.Literal(...NICE_EVAL_FAMILIES);\nfunction requireFixed<Result, Failure>(result: Either.Either<Result, Failure>, message: string): Result {\n    if (Either.isLeft(result))\n        throw new Error(message);\n    return result.right;\n}\n/** One closed catalog entry derived from one compiled fixed-family owner. */\nexport interface FixedRecordFamilyDescriptor<Family extends NiceEvalFamily, Owner extends FixedRecordAttachmentOwner, Payload> {\n    readonly family: Family;\n    readonly schemaVersion: number;\n    readonly owner: Owner;\n    /** The sole low-level closure/write primitive minted from this declaration owner. */\n    readonly write: FixedAttachmentWriteSpec<Owner, Payload>;\n    /** Declared adjacent upgrade graph; implementations remain lazy. */\n    readonly adjacentMigrationLinks: readonly RecordAttachmentAdjacentMigrationLink[];\n}\ntype FixedAttachmentDeclaration = RecordAttachmentDefinition<NiceEvalFamily, RecordAttachmentOwnerInputs>;\ntype DeclaredOwnerDefinition<Declaration extends FixedAttachmentDeclaration, Owner extends keyof Declaration[\"current\"][\"owners\"]> = Declaration extends {\n    readonly current: {\n        readonly owners: infer Owners;\n    };\n} ? Owner extends keyof Owners ? Exclude<Owners[Owner], undefined> : never : never;\ntype DeclaredOwnerPayload<Declaration extends FixedAttachmentDeclaration, Owner extends keyof Declaration[\"current\"][\"owners\"]> = DeclaredOwnerDefinition<Declaration, Owner> extends RecordAttachmentOwnerDefinition<Owner & FixedRecordAttachmentOwner, infer Payload, infer _SourceSchema> ? Payload : never;\nfunction fixedFamily<const Declaration extends FixedAttachmentDeclaration, const Owner extends Extract<keyof Declaration[\"current\"][\"owners\"], FixedRecordAttachmentOwner>>(declaration: Declaration, owner: Owner): FixedRecordFamilyDescriptor<Declaration[\"family\"], Owner, DeclaredOwnerPayload<Declaration, Owner>>;\nfunction fixedFamily(declaration: FixedAttachmentDeclaration, owner: FixedRecordAttachmentOwner) {\n    const ownerDefinition = declaration.current.owners[owner];\n    if (ownerDefinition === undefined) {\n        throw new Error(`Fixed Record family ${declaration.family} does not declare a ${owner} owner`);\n    }\n    const write = requireFixed(makeFixedAttachmentWriteSpec(ownerDefinition), `Fixed Record family ${declaration.family} must have a valid compiled ${owner} owner`);\n    return Object.freeze({\n        family: declaration.family,\n        schemaVersion: declaration.current.schemaVersion,\n        owner,\n        write,\n        adjacentMigrationLinks: declaration.adjacentMigrationLinks,\n    });\n}\nexport const assertionsRecordFamily = fixedFamily(NiceEvalRecordAttachments.assertions, \"attempt\");\nexport const attemptObservabilityRecordFamily = fixedFamily(NiceEvalRecordAttachments.observability, \"attempt\");\nexport const runObservabilityRecordFamily = fixedFamily(NiceEvalRecordAttachments.observability, \"run\");\nexport const fileChangesRecordFamily = fixedFamily(NiceEvalRecordAttachments.fileChanges, \"attempt\");\nexport const sourceNavigationRecordFamily = fixedFamily(NiceEvalRecordAttachments.sourceNavigation, \"attempt\");\nexport const sourcesRecordFamily = fixedFamily(NiceEvalRecordAttachments.sources, \"run\");\nexport const attemptArtifactsRecordFamily = fixedFamily(NiceEvalRecordAttachments.artifacts, \"attempt\");\nexport const runArtifactsRecordFamily = fixedFamily(NiceEvalRecordAttachments.artifacts, \"run\");\n/** The static Record v1 catalog is closed; family protocol remains at each declaration. */\nexport const NiceEvalRecordFamilyCatalog = Object.freeze({\n    assertions: assertionsRecordFamily,\n    observability: Object.freeze({\n        attempt: attemptObservabilityRecordFamily,\n        run: runObservabilityRecordFamily,\n    }),\n    fileChanges: fileChangesRecordFamily,\n    sourceNavigation: sourceNavigationRecordFamily,\n    sources: sourcesRecordFamily,\n    artifacts: Object.freeze({\n        attempt: attemptArtifactsRecordFamily,\n        run: runArtifactsRecordFamily,\n    }),\n});\nexport const FixedRecordAttachmentEnvelopeSchema: Schema.Schema<{\n    readonly family: NiceEvalFamily;\n    readonly schemaVersion: number;\n}> = Schema.Struct({\n    family: NiceEvalFamilySchema,\n    schemaVersion: Schema.Int.pipe(Schema.positive()),\n});\nexport function decodeFixedRecordAttachmentEnvelope(input: unknown): Either.Either<{\n    readonly family: NiceEvalFamily;\n    readonly schemaVersion: number;\n}, {\n    readonly code: \"record-fixed-family-envelope-invalid\";\n}> {\n    const decoded = Schema.decodeUnknownEither(FixedRecordAttachmentEnvelopeSchema, RecordExactParseOptions)(input);\n    return Either.isLeft(decoded)\n        ? Either.left(Object.freeze({ code: \"record-fixed-family-envelope-invalid\" as const }))\n        : Either.right(decoded.right);\n}\nexport function encodeFixedRecordAttachmentEnvelope(envelope: {\n    readonly family: NiceEvalFamily;\n    readonly schemaVersion: number;\n}): Either.Either<{\n    readonly family: NiceEvalFamily;\n    readonly schemaVersion: number;\n}, {\n    readonly code: \"record-fixed-family-envelope-invalid\";\n}> {\n    const encoded = Schema.encodeUnknownEither(FixedRecordAttachmentEnvelopeSchema, RecordExactParseOptions)(envelope);\n    return Either.isLeft(encoded)\n        ? Either.left(Object.freeze({ code: \"record-fixed-family-envelope-invalid\" as const }))\n        : Either.right(encoded.right);\n}\ntype DescriptorPayload<Descriptor> = Descriptor extends FixedRecordFamilyDescriptor<NiceEvalFamily, FixedRecordAttachmentOwner, infer Payload> ? Payload : never;\nexport type FixedRecordFamilyPayload = DescriptorPayload<typeof assertionsRecordFamily> | DescriptorPayload<typeof attemptObservabilityRecordFamily> | DescriptorPayload<typeof runObservabilityRecordFamily> | DescriptorPayload<typeof fileChangesRecordFamily> | DescriptorPayload<typeof sourceNavigationRecordFamily> | DescriptorPayload<typeof sourcesRecordFamily> | DescriptorPayload<typeof attemptArtifactsRecordFamily> | DescriptorPayload<typeof runArtifactsRecordFamily>;\nexport type FixedRecordFamilyWrite<Owner extends FixedRecordAttachmentOwner, Error = never, Requirements = never> = RecordAttachmentWrite<Owner, Error, Requirements>;\n"]}