niceeval 0.12.1 → 0.12.2-canary.31

package/dist/eval/record/evaluation-record.d.cts

@@ -0,0 +1,168 @@
+import { Effect, Either } from "effect";
+import type { SealedAttemptAssertions } from "../../assertions/api.cjs";
+import type { AssertionsProducerErrorV1 } from "../../assertions/record/producer.cjs";
+import type { RecordAttachmentClosureInvalid, RecordAttachmentWrite } from "../../record/attachment/index.cjs";
+import type { SlotId, UtcMillis } from "../../record/model/identifiers.cjs";
+import type { FrozenRecordAttempt } from "../../record/reader/types.cjs";
+import type { RecordPublishReceipt, RecordAttemptDraft, RecordRunDraft, RecordWriteError, RecordWriteSession } from "../../record/writer/types.cjs";
+import { type EvaluationRecordCoherenceIssueV1 } from "./coherence.cjs";
+import { type EvaluationsPayloadBuildErrorV1, type EvaluationsPayloadV1 } from "./evaluation.cjs";
+import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.cjs";
+import { type ScorePayloadV1 } from "./score.cjs";
+import { type VerdictPayloadV1 } from "./verdict.cjs";
+/**
+ * A completed origin's producer facts. The Assertions write is intentionally
+ * separate from generic Attempt writes: it is the durable peer of `facts` and
+ * is verified as the built-in Assertions v1 Attachment before a plan exists.
+ */
+export interface EvaluationRecordOriginAttemptInputV1<Error = never, Requirements = never> {
+    readonly slotId: SlotId;
+    readonly facts: EvaluationAttemptFactsV1;
+    readonly assertions: RecordAttachmentWrite<"attempt", Error, Requirements>;
+    readonly verdict: VerdictPayloadV1;
+    readonly score?: ScorePayloadV1;
+    /** Domain-neutral Attempt Attachments already constructed by their owner. */
+    readonly writes?: readonly RecordAttachmentWrite<"attempt", Error, Requirements>[];
+}
+/**
+ * Runtime assertions reach durable storage only here. This adapter owns both
+ * entry-ID allocation and the v1 Attachment codecs; Runner keeps only the
+ * schema-independent sealed value.
+ */
+export type SealedAssertionsOriginEncodingError = {
+    readonly code: "assertions-attachment-invalid";
+    readonly issue: AssertionsProducerErrorV1;
+} | {
+    readonly code: "sealed-verdict-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "sealed-score-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "workspace-diff-attachment-invalid";
+    readonly message: string;
+};
+/**
+ * Encodes an already sealed runtime value at the Evaluation Record boundary.
+ * No author/runtime or Runner module receives an Attachment write or durable
+ * document while constructing the semantic attempt result.
+ */
+export declare function evaluationRecordOriginInputFromSealedAssertions(slotId: SlotId, sealed: SealedAttemptAssertions): Either.Either<EvaluationRecordOriginAttemptInputV1, SealedAssertionsOriginEncodingError>;
+/** A reference Member explicitly carries the exact frozen source capability. */
+export interface EvaluationRecordReferenceInputV1 {
+    readonly slotId: SlotId;
+    readonly attempt: FrozenRecordAttempt;
+}
+/**
+ * Input to the Evaluation producer's one-Run contract. Extra writes retain
+ * their owner-specific payload and closure authority. The generic writer
+ * consumes those already-constructed typed writes without learning their
+ * business names.
+ */
+export interface EvaluationRecordPlanInputV1<Error = never, Requirements = never> {
+    readonly startedAt: UtcMillis;
+    readonly completedAt: UtcMillis;
+    readonly expectedSlots: readonly SlotId[];
+    readonly evaluations: EvaluationsPayloadV1;
+    readonly originAttempts: readonly EvaluationRecordOriginAttemptInputV1<Error, Requirements>[];
+    readonly references?: readonly EvaluationRecordReferenceInputV1[];
+    /** Domain-neutral Run Attachments already constructed by their owner. */
+    readonly runWrites?: readonly RecordAttachmentWrite<"run", Error, Requirements>[];
+}
+export type EvaluationRecordContractIssueV1 = {
+    readonly code: "evaluation-record-evaluations-build-invalid";
+    readonly issue: EvaluationsPayloadBuildErrorV1;
+} | {
+    readonly code: "evaluation-record-attempt-facts-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-assertions-write-invalid";
+    readonly slotId: SlotId;
+    readonly reason: "closure-invalid" | "definition-invalid" | "facts-mismatch" | "record-attachment-reference-missing" | "record-attachment-coverage-incoherent";
+    readonly issue?: RecordAttachmentClosureInvalid;
+} | {
+    readonly code: "evaluation-record-verdict-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-score-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-coherence-invalid";
+    readonly issue: EvaluationRecordCoherenceIssueV1;
+} | {
+    readonly code: "evaluation-record-reference-slot-unexpected";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-member-slot-duplicate";
+    readonly slotId: SlotId;
+};
+/** All Evaluation-domain invalidity is settled before a generic draft exists. */
+export interface EvaluationRecordContractInvalidV1 {
+    readonly code: "evaluation-record-contract-invalid";
+    readonly issues: readonly EvaluationRecordContractIssueV1[];
+}
+/** A copied object cannot be used in place of a package-created plan. */
+export interface EvaluationRecordPlanInvalidV1 {
+    readonly code: "evaluation-record-plan-invalid";
+}
+/** A pre-created origin draft did not match the plan's exact Slot. */
+export interface EvaluationRecordOriginDraftMissingV1 {
+    readonly code: "evaluation-record-origin-draft-missing";
+    readonly slotId: SlotId;
+}
+declare const evaluationRecordPlanBrand: unique symbol;
+/**
+ * Opaque result of a successful EvaluationRecordContractV1 preflight. Its
+ * operational contents live in a private WeakMap, not on the public object.
+ */
+export interface EvaluationRecordPlanV1<Error = never, Requirements = never> {
+    readonly [evaluationRecordPlanBrand]: () => void;
+}
+/**
+ * Validates the Evaluation aggregate and captures generated domain writes plus
+ * already-constructed owner writes into an opaque plan. This is pure: it opens
+ * no writer and creates no Run directory.
+ */
+export declare function createEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Either.Either<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/** Effect form for callers that compose preflight directly into a producer flow. */
+export declare function prepareEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Effect.Effect<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/**
+ * Consumes a package-created plan through the generic Record writer. No domain
+ * fold or raw Attachment construction remains on this path, and interruption
+ * is deliberately left to the writer's normal incomplete-draft semantics.
+ */
+export declare function writeEvaluationRecordPlanV1<Error, Requirements>(session: RecordWriteSession, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Applies an already-validated Evaluation plan to a draft created before
+ * expensive execution begins. The Runner uses this to leave an incomplete
+ * directory behind on interruption while keeping the Evaluation contract as
+ * the only path that turns sealed facts into generic Record mutations.
+ */
+export declare function writeEvaluationRecordPlanToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes only the Run-owned portion of a validated Evaluation plan. This is
+ * intentionally narrow: a Runner can establish the denominator and linked
+ * Run attachments before dispatch without creating an Attempt for an
+ * unstarted Slot.
+ */
+export declare function writeEvaluationRecordPlanRunToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes sealed origin facts into Attempts that were allocated at dispatch.
+ * It never calls `createAttempt`: the caller must present the exact draft for
+ * each Slot, which keeps the AttemptId used during execution identical to the
+ * Member published later.
+ */
+export declare function writeEvaluationRecordPlanOriginsToAttemptsV1<Error, Requirements>(attempts: ReadonlyMap<SlotId, RecordAttemptDraft>, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/** Writes only exact reference Members already validated by the opaque plan. */
+export declare function writeEvaluationRecordPlanReferencesToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError, never>;
+/** The internal Evaluation-specific contract, not a generic Record abstraction. */
+export declare const EvaluationRecordContractV1: Readonly<{
+    createPlan: typeof createEvaluationRecordPlanV1;
+    preparePlan: typeof prepareEvaluationRecordPlanV1;
+    writePlan: typeof writeEvaluationRecordPlanV1;
+    writePlanToDraft: typeof writeEvaluationRecordPlanToDraftV1;
+    writePlanRunToDraft: typeof writeEvaluationRecordPlanRunToDraftV1;
+    writePlanOriginsToAttempts: typeof writeEvaluationRecordPlanOriginsToAttemptsV1;
+    writePlanReferencesToDraft: typeof writeEvaluationRecordPlanReferencesToDraftV1;
+}>;
+export {};

package/dist/eval/record/evaluation-record.d.mts

@@ -0,0 +1,168 @@
+import { Effect, Either } from "effect";
+import type { SealedAttemptAssertions } from "../../assertions/api.mjs";
+import type { AssertionsProducerErrorV1 } from "../../assertions/record/producer.mjs";
+import type { RecordAttachmentClosureInvalid, RecordAttachmentWrite } from "../../record/attachment/index.mjs";
+import type { SlotId, UtcMillis } from "../../record/model/identifiers.mjs";
+import type { FrozenRecordAttempt } from "../../record/reader/types.mjs";
+import type { RecordPublishReceipt, RecordAttemptDraft, RecordRunDraft, RecordWriteError, RecordWriteSession } from "../../record/writer/types.mjs";
+import { type EvaluationRecordCoherenceIssueV1 } from "./coherence.mjs";
+import { type EvaluationsPayloadBuildErrorV1, type EvaluationsPayloadV1 } from "./evaluation.mjs";
+import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.mjs";
+import { type ScorePayloadV1 } from "./score.mjs";
+import { type VerdictPayloadV1 } from "./verdict.mjs";
+/**
+ * A completed origin's producer facts. The Assertions write is intentionally
+ * separate from generic Attempt writes: it is the durable peer of `facts` and
+ * is verified as the built-in Assertions v1 Attachment before a plan exists.
+ */
+export interface EvaluationRecordOriginAttemptInputV1<Error = never, Requirements = never> {
+    readonly slotId: SlotId;
+    readonly facts: EvaluationAttemptFactsV1;
+    readonly assertions: RecordAttachmentWrite<"attempt", Error, Requirements>;
+    readonly verdict: VerdictPayloadV1;
+    readonly score?: ScorePayloadV1;
+    /** Domain-neutral Attempt Attachments already constructed by their owner. */
+    readonly writes?: readonly RecordAttachmentWrite<"attempt", Error, Requirements>[];
+}
+/**
+ * Runtime assertions reach durable storage only here. This adapter owns both
+ * entry-ID allocation and the v1 Attachment codecs; Runner keeps only the
+ * schema-independent sealed value.
+ */
+export type SealedAssertionsOriginEncodingError = {
+    readonly code: "assertions-attachment-invalid";
+    readonly issue: AssertionsProducerErrorV1;
+} | {
+    readonly code: "sealed-verdict-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "sealed-score-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "workspace-diff-attachment-invalid";
+    readonly message: string;
+};
+/**
+ * Encodes an already sealed runtime value at the Evaluation Record boundary.
+ * No author/runtime or Runner module receives an Attachment write or durable
+ * document while constructing the semantic attempt result.
+ */
+export declare function evaluationRecordOriginInputFromSealedAssertions(slotId: SlotId, sealed: SealedAttemptAssertions): Either.Either<EvaluationRecordOriginAttemptInputV1, SealedAssertionsOriginEncodingError>;
+/** A reference Member explicitly carries the exact frozen source capability. */
+export interface EvaluationRecordReferenceInputV1 {
+    readonly slotId: SlotId;
+    readonly attempt: FrozenRecordAttempt;
+}
+/**
+ * Input to the Evaluation producer's one-Run contract. Extra writes retain
+ * their owner-specific payload and closure authority. The generic writer
+ * consumes those already-constructed typed writes without learning their
+ * business names.
+ */
+export interface EvaluationRecordPlanInputV1<Error = never, Requirements = never> {
+    readonly startedAt: UtcMillis;
+    readonly completedAt: UtcMillis;
+    readonly expectedSlots: readonly SlotId[];
+    readonly evaluations: EvaluationsPayloadV1;
+    readonly originAttempts: readonly EvaluationRecordOriginAttemptInputV1<Error, Requirements>[];
+    readonly references?: readonly EvaluationRecordReferenceInputV1[];
+    /** Domain-neutral Run Attachments already constructed by their owner. */
+    readonly runWrites?: readonly RecordAttachmentWrite<"run", Error, Requirements>[];
+}
+export type EvaluationRecordContractIssueV1 = {
+    readonly code: "evaluation-record-evaluations-build-invalid";
+    readonly issue: EvaluationsPayloadBuildErrorV1;
+} | {
+    readonly code: "evaluation-record-attempt-facts-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-assertions-write-invalid";
+    readonly slotId: SlotId;
+    readonly reason: "closure-invalid" | "definition-invalid" | "facts-mismatch" | "record-attachment-reference-missing" | "record-attachment-coverage-incoherent";
+    readonly issue?: RecordAttachmentClosureInvalid;
+} | {
+    readonly code: "evaluation-record-verdict-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-score-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-coherence-invalid";
+    readonly issue: EvaluationRecordCoherenceIssueV1;
+} | {
+    readonly code: "evaluation-record-reference-slot-unexpected";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-member-slot-duplicate";
+    readonly slotId: SlotId;
+};
+/** All Evaluation-domain invalidity is settled before a generic draft exists. */
+export interface EvaluationRecordContractInvalidV1 {
+    readonly code: "evaluation-record-contract-invalid";
+    readonly issues: readonly EvaluationRecordContractIssueV1[];
+}
+/** A copied object cannot be used in place of a package-created plan. */
+export interface EvaluationRecordPlanInvalidV1 {
+    readonly code: "evaluation-record-plan-invalid";
+}
+/** A pre-created origin draft did not match the plan's exact Slot. */
+export interface EvaluationRecordOriginDraftMissingV1 {
+    readonly code: "evaluation-record-origin-draft-missing";
+    readonly slotId: SlotId;
+}
+declare const evaluationRecordPlanBrand: unique symbol;
+/**
+ * Opaque result of a successful EvaluationRecordContractV1 preflight. Its
+ * operational contents live in a private WeakMap, not on the public object.
+ */
+export interface EvaluationRecordPlanV1<Error = never, Requirements = never> {
+    readonly [evaluationRecordPlanBrand]: () => void;
+}
+/**
+ * Validates the Evaluation aggregate and captures generated domain writes plus
+ * already-constructed owner writes into an opaque plan. This is pure: it opens
+ * no writer and creates no Run directory.
+ */
+export declare function createEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Either.Either<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/** Effect form for callers that compose preflight directly into a producer flow. */
+export declare function prepareEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Effect.Effect<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/**
+ * Consumes a package-created plan through the generic Record writer. No domain
+ * fold or raw Attachment construction remains on this path, and interruption
+ * is deliberately left to the writer's normal incomplete-draft semantics.
+ */
+export declare function writeEvaluationRecordPlanV1<Error, Requirements>(session: RecordWriteSession, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Applies an already-validated Evaluation plan to a draft created before
+ * expensive execution begins. The Runner uses this to leave an incomplete
+ * directory behind on interruption while keeping the Evaluation contract as
+ * the only path that turns sealed facts into generic Record mutations.
+ */
+export declare function writeEvaluationRecordPlanToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes only the Run-owned portion of a validated Evaluation plan. This is
+ * intentionally narrow: a Runner can establish the denominator and linked
+ * Run attachments before dispatch without creating an Attempt for an
+ * unstarted Slot.
+ */
+export declare function writeEvaluationRecordPlanRunToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes sealed origin facts into Attempts that were allocated at dispatch.
+ * It never calls `createAttempt`: the caller must present the exact draft for
+ * each Slot, which keeps the AttemptId used during execution identical to the
+ * Member published later.
+ */
+export declare function writeEvaluationRecordPlanOriginsToAttemptsV1<Error, Requirements>(attempts: ReadonlyMap<SlotId, RecordAttemptDraft>, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/** Writes only exact reference Members already validated by the opaque plan. */
+export declare function writeEvaluationRecordPlanReferencesToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError, never>;
+/** The internal Evaluation-specific contract, not a generic Record abstraction. */
+export declare const EvaluationRecordContractV1: Readonly<{
+    createPlan: typeof createEvaluationRecordPlanV1;
+    preparePlan: typeof prepareEvaluationRecordPlanV1;
+    writePlan: typeof writeEvaluationRecordPlanV1;
+    writePlanToDraft: typeof writeEvaluationRecordPlanToDraftV1;
+    writePlanRunToDraft: typeof writeEvaluationRecordPlanRunToDraftV1;
+    writePlanOriginsToAttempts: typeof writeEvaluationRecordPlanOriginsToAttemptsV1;
+    writePlanReferencesToDraft: typeof writeEvaluationRecordPlanReferencesToDraftV1;
+}>;
+export {};

package/dist/eval/record/evaluation-record.d.ts

@@ -0,0 +1,168 @@
+import { Effect, Either } from "effect";
+import type { SealedAttemptAssertions } from "../../assertions/api.js";
+import type { AssertionsProducerErrorV1 } from "../../assertions/record/producer.js";
+import type { RecordAttachmentClosureInvalid, RecordAttachmentWrite } from "../../record/attachment/index.js";
+import type { SlotId, UtcMillis } from "../../record/model/identifiers.js";
+import type { FrozenRecordAttempt } from "../../record/reader/types.js";
+import type { RecordPublishReceipt, RecordAttemptDraft, RecordRunDraft, RecordWriteError, RecordWriteSession } from "../../record/writer/types.js";
+import { type EvaluationRecordCoherenceIssueV1 } from "./coherence.js";
+import { type EvaluationsPayloadBuildErrorV1, type EvaluationsPayloadV1 } from "./evaluation.js";
+import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.js";
+import { type ScorePayloadV1 } from "./score.js";
+import { type VerdictPayloadV1 } from "./verdict.js";
+/**
+ * A completed origin's producer facts. The Assertions write is intentionally
+ * separate from generic Attempt writes: it is the durable peer of `facts` and
+ * is verified as the built-in Assertions v1 Attachment before a plan exists.
+ */
+export interface EvaluationRecordOriginAttemptInputV1<Error = never, Requirements = never> {
+    readonly slotId: SlotId;
+    readonly facts: EvaluationAttemptFactsV1;
+    readonly assertions: RecordAttachmentWrite<"attempt", Error, Requirements>;
+    readonly verdict: VerdictPayloadV1;
+    readonly score?: ScorePayloadV1;
+    /** Domain-neutral Attempt Attachments already constructed by their owner. */
+    readonly writes?: readonly RecordAttachmentWrite<"attempt", Error, Requirements>[];
+}
+/**
+ * Runtime assertions reach durable storage only here. This adapter owns both
+ * entry-ID allocation and the v1 Attachment codecs; Runner keeps only the
+ * schema-independent sealed value.
+ */
+export type SealedAssertionsOriginEncodingError = {
+    readonly code: "assertions-attachment-invalid";
+    readonly issue: AssertionsProducerErrorV1;
+} | {
+    readonly code: "sealed-verdict-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "sealed-score-payload-invalid";
+    readonly message: string;
+} | {
+    readonly code: "workspace-diff-attachment-invalid";
+    readonly message: string;
+};
+/**
+ * Encodes an already sealed runtime value at the Evaluation Record boundary.
+ * No author/runtime or Runner module receives an Attachment write or durable
+ * document while constructing the semantic attempt result.
+ */
+export declare function evaluationRecordOriginInputFromSealedAssertions(slotId: SlotId, sealed: SealedAttemptAssertions): Either.Either<EvaluationRecordOriginAttemptInputV1, SealedAssertionsOriginEncodingError>;
+/** A reference Member explicitly carries the exact frozen source capability. */
+export interface EvaluationRecordReferenceInputV1 {
+    readonly slotId: SlotId;
+    readonly attempt: FrozenRecordAttempt;
+}
+/**
+ * Input to the Evaluation producer's one-Run contract. Extra writes retain
+ * their owner-specific payload and closure authority. The generic writer
+ * consumes those already-constructed typed writes without learning their
+ * business names.
+ */
+export interface EvaluationRecordPlanInputV1<Error = never, Requirements = never> {
+    readonly startedAt: UtcMillis;
+    readonly completedAt: UtcMillis;
+    readonly expectedSlots: readonly SlotId[];
+    readonly evaluations: EvaluationsPayloadV1;
+    readonly originAttempts: readonly EvaluationRecordOriginAttemptInputV1<Error, Requirements>[];
+    readonly references?: readonly EvaluationRecordReferenceInputV1[];
+    /** Domain-neutral Run Attachments already constructed by their owner. */
+    readonly runWrites?: readonly RecordAttachmentWrite<"run", Error, Requirements>[];
+}
+export type EvaluationRecordContractIssueV1 = {
+    readonly code: "evaluation-record-evaluations-build-invalid";
+    readonly issue: EvaluationsPayloadBuildErrorV1;
+} | {
+    readonly code: "evaluation-record-attempt-facts-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-assertions-write-invalid";
+    readonly slotId: SlotId;
+    readonly reason: "closure-invalid" | "definition-invalid" | "facts-mismatch" | "record-attachment-reference-missing" | "record-attachment-coverage-incoherent";
+    readonly issue?: RecordAttachmentClosureInvalid;
+} | {
+    readonly code: "evaluation-record-verdict-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-score-payload-invalid";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-coherence-invalid";
+    readonly issue: EvaluationRecordCoherenceIssueV1;
+} | {
+    readonly code: "evaluation-record-reference-slot-unexpected";
+    readonly slotId: SlotId;
+} | {
+    readonly code: "evaluation-record-member-slot-duplicate";
+    readonly slotId: SlotId;
+};
+/** All Evaluation-domain invalidity is settled before a generic draft exists. */
+export interface EvaluationRecordContractInvalidV1 {
+    readonly code: "evaluation-record-contract-invalid";
+    readonly issues: readonly EvaluationRecordContractIssueV1[];
+}
+/** A copied object cannot be used in place of a package-created plan. */
+export interface EvaluationRecordPlanInvalidV1 {
+    readonly code: "evaluation-record-plan-invalid";
+}
+/** A pre-created origin draft did not match the plan's exact Slot. */
+export interface EvaluationRecordOriginDraftMissingV1 {
+    readonly code: "evaluation-record-origin-draft-missing";
+    readonly slotId: SlotId;
+}
+declare const evaluationRecordPlanBrand: unique symbol;
+/**
+ * Opaque result of a successful EvaluationRecordContractV1 preflight. Its
+ * operational contents live in a private WeakMap, not on the public object.
+ */
+export interface EvaluationRecordPlanV1<Error = never, Requirements = never> {
+    readonly [evaluationRecordPlanBrand]: () => void;
+}
+/**
+ * Validates the Evaluation aggregate and captures generated domain writes plus
+ * already-constructed owner writes into an opaque plan. This is pure: it opens
+ * no writer and creates no Run directory.
+ */
+export declare function createEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Either.Either<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/** Effect form for callers that compose preflight directly into a producer flow. */
+export declare function prepareEvaluationRecordPlanV1<Error, Requirements>(input: EvaluationRecordPlanInputV1<Error, Requirements>): Effect.Effect<EvaluationRecordPlanV1<Error, Requirements>, EvaluationRecordContractInvalidV1>;
+/**
+ * Consumes a package-created plan through the generic Record writer. No domain
+ * fold or raw Attachment construction remains on this path, and interruption
+ * is deliberately left to the writer's normal incomplete-draft semantics.
+ */
+export declare function writeEvaluationRecordPlanV1<Error, Requirements>(session: RecordWriteSession, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Applies an already-validated Evaluation plan to a draft created before
+ * expensive execution begins. The Runner uses this to leave an incomplete
+ * directory behind on interruption while keeping the Evaluation contract as
+ * the only path that turns sealed facts into generic Record mutations.
+ */
+export declare function writeEvaluationRecordPlanToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<RecordPublishReceipt, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes only the Run-owned portion of a validated Evaluation plan. This is
+ * intentionally narrow: a Runner can establish the denominator and linked
+ * Run attachments before dispatch without creating an Attempt for an
+ * unstarted Slot.
+ */
+export declare function writeEvaluationRecordPlanRunToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError | Error, Requirements>;
+/**
+ * Writes sealed origin facts into Attempts that were allocated at dispatch.
+ * It never calls `createAttempt`: the caller must present the exact draft for
+ * each Slot, which keeps the AttemptId used during execution identical to the
+ * Member published later.
+ */
+export declare function writeEvaluationRecordPlanOriginsToAttemptsV1<Error, Requirements>(attempts: ReadonlyMap<SlotId, RecordAttemptDraft>, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | EvaluationRecordOriginDraftMissingV1 | RecordWriteError | Error, Requirements>;
+/** Writes only exact reference Members already validated by the opaque plan. */
+export declare function writeEvaluationRecordPlanReferencesToDraftV1<Error, Requirements>(draft: RecordRunDraft, plan: EvaluationRecordPlanV1<Error, Requirements>): Effect.Effect<void, EvaluationRecordPlanInvalidV1 | RecordWriteError, never>;
+/** The internal Evaluation-specific contract, not a generic Record abstraction. */
+export declare const EvaluationRecordContractV1: Readonly<{
+    createPlan: typeof createEvaluationRecordPlanV1;
+    preparePlan: typeof prepareEvaluationRecordPlanV1;
+    writePlan: typeof writeEvaluationRecordPlanV1;
+    writePlanToDraft: typeof writeEvaluationRecordPlanToDraftV1;
+    writePlanRunToDraft: typeof writeEvaluationRecordPlanRunToDraftV1;
+    writePlanOriginsToAttempts: typeof writeEvaluationRecordPlanOriginsToAttemptsV1;
+    writePlanReferencesToDraft: typeof writeEvaluationRecordPlanReferencesToDraftV1;
+}>;
+export {};

package/dist/eval/record/evaluation-record.js

@@ -0,0 +1,22 @@
+import { createRequire as __niceevalCreateRequire } from "node:module";
+const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
+const __niceevalCanonical = __niceevalRequire("./evaluation-record.cjs");
+const __niceevalExport0 = __niceevalCanonical["EvaluationRecordContractV1"];
+export { __niceevalExport0 as EvaluationRecordContractV1 };
+const __niceevalExport1 = __niceevalCanonical["createEvaluationRecordPlanV1"];
+export { __niceevalExport1 as createEvaluationRecordPlanV1 };
+const __niceevalExport2 = __niceevalCanonical["evaluationRecordOriginInputFromSealedAssertions"];
+export { __niceevalExport2 as evaluationRecordOriginInputFromSealedAssertions };
+const __niceevalExport3 = __niceevalCanonical["prepareEvaluationRecordPlanV1"];
+export { __niceevalExport3 as prepareEvaluationRecordPlanV1 };
+const __niceevalExport4 = __niceevalCanonical["writeEvaluationRecordPlanOriginsToAttemptsV1"];
+export { __niceevalExport4 as writeEvaluationRecordPlanOriginsToAttemptsV1 };
+const __niceevalExport5 = __niceevalCanonical["writeEvaluationRecordPlanReferencesToDraftV1"];
+export { __niceevalExport5 as writeEvaluationRecordPlanReferencesToDraftV1 };
+const __niceevalExport6 = __niceevalCanonical["writeEvaluationRecordPlanRunToDraftV1"];
+export { __niceevalExport6 as writeEvaluationRecordPlanRunToDraftV1 };
+const __niceevalExport7 = __niceevalCanonical["writeEvaluationRecordPlanToDraftV1"];
+export { __niceevalExport7 as writeEvaluationRecordPlanToDraftV1 };
+const __niceevalExport8 = __niceevalCanonical["writeEvaluationRecordPlanV1"];
+export { __niceevalExport8 as writeEvaluationRecordPlanV1 };
+//# sourceMappingURL=evaluation-record.js.map

package/dist/eval/record/evaluation-record.js.map

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