niceeval 0.12.2-canary.31 → 0.13.0

package/dist/eval/record/score.d.cts

@@ -1,21 +1,16 @@
 import { Either, Schema } from "effect";
-import { type RecordAttachmentPayloadSnapshot, type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.cjs";
-import { type RecordAttachmentProjector } from "../../projection/projector.cjs";
-import { type FiniteNonNegativeNumberV1 } from "./attachment.cjs";
-import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.cjs";
-export declare const SCORE_ATTACHMENT_NAME_V1: "niceeval.score";
-export declare const SCORE_ATTACHMENT_SCHEMA_ID_V1: "niceeval.score/v1";
-export declare const ScoreStateV1Schema: Schema.Literal<["complete", "partial", "unavailable"]>;
-export type ScoreStateV1 = Schema.Schema.Type<typeof ScoreStateV1Schema>;
-/** These are the only reasons that can make a sealed score source incomplete. */
-export declare const ScoreIncompleteReasonV1Schema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
-export type ScoreIncompleteReasonV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonV1Schema>;
-export declare const ScoreIncompleteReasonsV1Schema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
-export type ScoreIncompleteReasonsV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonsV1Schema>;
-/** A formal earned score: finite, non-negative, and never a percentage/max. */
-export declare const EarnedScoreV1Schema: Schema.filter<Schema.filter<typeof Schema.Number>>;
-export type EarnedScoreV1 = FiniteNonNegativeNumberV1;
-declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
+import { type FiniteNonNegativeNumber } from "./attachment.cjs";
+import { type EvaluationAttemptFacts } from "./sealed-assertion.cjs";
+/** Score is an Analysis calculation, not an independently persisted family. */
+export declare const ScoreStateSchema: Schema.Literal<["complete", "partial", "unavailable"]>;
+export type ScoreState = Schema.Schema.Type<typeof ScoreStateSchema>;
+export declare const ScoreIncompleteReasonSchema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
+export type ScoreIncompleteReason = Schema.Schema.Type<typeof ScoreIncompleteReasonSchema>;
+export declare const ScoreIncompleteReasonsSchema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
+export type ScoreIncompleteReasons = Schema.Schema.Type<typeof ScoreIncompleteReasonsSchema>;
+export declare const EarnedScoreSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export type EarnedScore = FiniteNonNegativeNumber;
+declare const ScorePayloadStructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -26,20 +21,18 @@ declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>;
-export type ScorePayloadV1 = Schema.Schema.Type<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadV1Encoded = Schema.Schema.Encoded<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadIssueV1 = {
+export type ScorePayload = Schema.Schema.Type<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadEncoded = Schema.Schema.Encoded<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadIssue = {
     readonly code: "score-incomplete-reason-duplicate";
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 } | {
     readonly code: "score-incomplete-reason-order-invalid";
     readonly index: number;
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 };
-/** Ensures reason arrays preserve all causes exactly once in a stable order. */
-export declare function validateScorePayloadV1(payload: ScorePayloadV1): readonly ScorePayloadIssueV1[];
-/** Exact JSON schema for `niceeval.score/v1`. */
-export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.Struct<{
+export declare function validateScorePayload(payload: ScorePayload): readonly ScorePayloadIssue[];
+export declare const ScorePayloadSchema: Schema.filter<Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -50,97 +43,41 @@ export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.St
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>>;
-/** The built-in Attempt Attachment definition owns exact decode and closure. */
-export declare const scoreAttachmentDefinitionV1: import("../../record/attachment/types.cjs").JsonRecordAttachmentDefinition<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare const scoreAttachmentFamilyV1: import("../../record/attachment/types.cjs").RecordAttachmentFamily<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare function decodeScorePayloadV1(input: unknown): Either.Either<{
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}, import("../../record/attachment/errors.cjs").RecordAttachmentPayloadInvalid>;
-/**
- * Score reads the same sealed producer facts as Verdict but intentionally uses
- * only `result.score` plus execution status. Gate and skip do not rewrite an
- * earned contribution.
- */
-export type ScoreFoldInputV1 = EvaluationAttemptFactsV1;
-export declare const ScoreFoldInputV1Schema: Schema.Struct<{
+export type ScoreFoldInput = EvaluationAttemptFacts;
+export declare const ScoreFoldInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.cjs").SealedAssertionResultV1, import("./sealed-assertion.cjs").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.cjs").SealedAssertionResult, import("./sealed-assertion.cjs").SealedAssertionResult, never>;
     }>>;
 }>;
-/** Backward-neutral name for callers that construct the Attachment before writing. */
-export type ScoreBuildInputV1 = ScoreFoldInputV1;
-export declare const ScoreBuildInputV1Schema: Schema.Struct<{
+export type ScoreBuildInput = ScoreFoldInput;
+export declare const ScoreBuildInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.cjs").SealedAssertionResultV1, import("./sealed-assertion.cjs").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.cjs").SealedAssertionResult, import("./sealed-assertion.cjs").SealedAssertionResult, never>;
     }>>;
 }>;
-export type ScorePayloadBuildErrorV1 = {
+export type ScorePayloadBuildError = {
     readonly code: "score-fold-input-invalid";
 } | {
     readonly code: "score-earned-overflow";
 };
-/**
- * Produces Score state from sealed Score contributions. A gate failure is
- * absent by design; a non-score required Assertion can therefore make Verdict
- * errored while an already-complete Score stays complete.
- */
-export declare function buildScorePayloadV1(input: ScoreFoldInputV1): Either.Either<ScorePayloadV1, ScorePayloadBuildErrorV1>;
-/** Wraps an already validated durable Score payload in its Attempt Attachment. */
-export declare function createScoreAttachmentWriteV1(payload: ScorePayloadV1): RecordAttachmentWrite<"attempt", never, never>;
-/** Builds the real Attempt-owned Score write from sealed score contributions. */
-export declare function buildScoreAttachmentWriteV1(input: ScoreFoldInputV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, ScorePayloadBuildErrorV1>;
-export type ScoreCoherenceIssueV1 = {
+/** Folds sealed Assertion facts without producing a durable Record write. */
+export declare function buildScorePayload(input: ScoreFoldInput): Either.Either<ScorePayload, ScorePayloadBuildError>;
+export type ScoreCoherenceIssue = {
     readonly code: "score-fold-input-invalid";
-    readonly reason: ScorePayloadBuildErrorV1["code"];
+    readonly reason: ScorePayloadBuildError["code"];
 } | {
     readonly code: "score-payload-mismatch";
 };
-/** Confirms persisted score is exactly what the shared sealed facts produce. */
-export declare function validateScoreCoherenceV1(input: {
-    readonly payload: ScorePayloadV1;
-    readonly fold: ScoreFoldInputV1;
-}): readonly ScoreCoherenceIssueV1[];
-/** A semantic reason why a Score is not a complete ranking value. */
-export type ScoreIncompleteReason = "execution-errored" | "source-unavailable" | "evaluation-errored" | "not-applicable";
-export type ScoreIncompleteReasons = readonly [
-    ScoreIncompleteReason,
-    ...ScoreIncompleteReason[]
-];
-/** Score keeps partial and unavailable as ordinary, non-ranking values. */
+export declare function validateScoreCoherence(input: {
+    readonly payload: ScorePayload;
+    readonly fold: ScoreFoldInput;
+}): readonly ScoreCoherenceIssue[];
 export type Score = {
     readonly state: "complete";
     readonly earned: number;
@@ -155,11 +92,6 @@ export type Score = {
     readonly reasons: ScoreIncompleteReasons;
     readonly comparable: false;
 };
-/** @internal The historical name remains for existing producer-only consumers. */
-export type ScoreProjectionV1 = Score;
-export declare function projectScorePayloadV1(payload: RecordAttachmentPayloadSnapshot<ScorePayloadV1>): Score;
-/** A typed, synchronous projection over an available Score Attachment. */
-export declare function projectScoreAttachmentV1(value: RecordAttachmentValue<ScorePayloadV1>): Score;
-/** The public Score view for an Attempt-owned Attachment. */
-export declare const scoreProjector: RecordAttachmentProjector<"attempt", Score>;
+export type ScoreProjection = Score;
+export declare function projectScorePayload(payload: ScorePayload): Score;
 export {};

package/dist/eval/record/score.d.mts

@@ -1,21 +1,16 @@
 import { Either, Schema } from "effect";
-import { type RecordAttachmentPayloadSnapshot, type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.mjs";
-import { type RecordAttachmentProjector } from "../../projection/projector.mjs";
-import { type FiniteNonNegativeNumberV1 } from "./attachment.mjs";
-import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.mjs";
-export declare const SCORE_ATTACHMENT_NAME_V1: "niceeval.score";
-export declare const SCORE_ATTACHMENT_SCHEMA_ID_V1: "niceeval.score/v1";
-export declare const ScoreStateV1Schema: Schema.Literal<["complete", "partial", "unavailable"]>;
-export type ScoreStateV1 = Schema.Schema.Type<typeof ScoreStateV1Schema>;
-/** These are the only reasons that can make a sealed score source incomplete. */
-export declare const ScoreIncompleteReasonV1Schema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
-export type ScoreIncompleteReasonV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonV1Schema>;
-export declare const ScoreIncompleteReasonsV1Schema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
-export type ScoreIncompleteReasonsV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonsV1Schema>;
-/** A formal earned score: finite, non-negative, and never a percentage/max. */
-export declare const EarnedScoreV1Schema: Schema.filter<Schema.filter<typeof Schema.Number>>;
-export type EarnedScoreV1 = FiniteNonNegativeNumberV1;
-declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
+import { type FiniteNonNegativeNumber } from "./attachment.mjs";
+import { type EvaluationAttemptFacts } from "./sealed-assertion.mjs";
+/** Score is an Analysis calculation, not an independently persisted family. */
+export declare const ScoreStateSchema: Schema.Literal<["complete", "partial", "unavailable"]>;
+export type ScoreState = Schema.Schema.Type<typeof ScoreStateSchema>;
+export declare const ScoreIncompleteReasonSchema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
+export type ScoreIncompleteReason = Schema.Schema.Type<typeof ScoreIncompleteReasonSchema>;
+export declare const ScoreIncompleteReasonsSchema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
+export type ScoreIncompleteReasons = Schema.Schema.Type<typeof ScoreIncompleteReasonsSchema>;
+export declare const EarnedScoreSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export type EarnedScore = FiniteNonNegativeNumber;
+declare const ScorePayloadStructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -26,20 +21,18 @@ declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>;
-export type ScorePayloadV1 = Schema.Schema.Type<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadV1Encoded = Schema.Schema.Encoded<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadIssueV1 = {
+export type ScorePayload = Schema.Schema.Type<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadEncoded = Schema.Schema.Encoded<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadIssue = {
     readonly code: "score-incomplete-reason-duplicate";
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 } | {
     readonly code: "score-incomplete-reason-order-invalid";
     readonly index: number;
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 };
-/** Ensures reason arrays preserve all causes exactly once in a stable order. */
-export declare function validateScorePayloadV1(payload: ScorePayloadV1): readonly ScorePayloadIssueV1[];
-/** Exact JSON schema for `niceeval.score/v1`. */
-export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.Struct<{
+export declare function validateScorePayload(payload: ScorePayload): readonly ScorePayloadIssue[];
+export declare const ScorePayloadSchema: Schema.filter<Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -50,97 +43,41 @@ export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.St
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>>;
-/** The built-in Attempt Attachment definition owns exact decode and closure. */
-export declare const scoreAttachmentDefinitionV1: import("../../record/attachment/types.mjs").JsonRecordAttachmentDefinition<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare const scoreAttachmentFamilyV1: import("../../record/attachment/types.mjs").RecordAttachmentFamily<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare function decodeScorePayloadV1(input: unknown): Either.Either<{
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}, import("../../record/attachment/errors.mjs").RecordAttachmentPayloadInvalid>;
-/**
- * Score reads the same sealed producer facts as Verdict but intentionally uses
- * only `result.score` plus execution status. Gate and skip do not rewrite an
- * earned contribution.
- */
-export type ScoreFoldInputV1 = EvaluationAttemptFactsV1;
-export declare const ScoreFoldInputV1Schema: Schema.Struct<{
+export type ScoreFoldInput = EvaluationAttemptFacts;
+export declare const ScoreFoldInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.mjs").SealedAssertionResultV1, import("./sealed-assertion.mjs").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.mjs").SealedAssertionResult, import("./sealed-assertion.mjs").SealedAssertionResult, never>;
     }>>;
 }>;
-/** Backward-neutral name for callers that construct the Attachment before writing. */
-export type ScoreBuildInputV1 = ScoreFoldInputV1;
-export declare const ScoreBuildInputV1Schema: Schema.Struct<{
+export type ScoreBuildInput = ScoreFoldInput;
+export declare const ScoreBuildInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.mjs").SealedAssertionResultV1, import("./sealed-assertion.mjs").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.mjs").SealedAssertionResult, import("./sealed-assertion.mjs").SealedAssertionResult, never>;
     }>>;
 }>;
-export type ScorePayloadBuildErrorV1 = {
+export type ScorePayloadBuildError = {
     readonly code: "score-fold-input-invalid";
 } | {
     readonly code: "score-earned-overflow";
 };
-/**
- * Produces Score state from sealed Score contributions. A gate failure is
- * absent by design; a non-score required Assertion can therefore make Verdict
- * errored while an already-complete Score stays complete.
- */
-export declare function buildScorePayloadV1(input: ScoreFoldInputV1): Either.Either<ScorePayloadV1, ScorePayloadBuildErrorV1>;
-/** Wraps an already validated durable Score payload in its Attempt Attachment. */
-export declare function createScoreAttachmentWriteV1(payload: ScorePayloadV1): RecordAttachmentWrite<"attempt", never, never>;
-/** Builds the real Attempt-owned Score write from sealed score contributions. */
-export declare function buildScoreAttachmentWriteV1(input: ScoreFoldInputV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, ScorePayloadBuildErrorV1>;
-export type ScoreCoherenceIssueV1 = {
+/** Folds sealed Assertion facts without producing a durable Record write. */
+export declare function buildScorePayload(input: ScoreFoldInput): Either.Either<ScorePayload, ScorePayloadBuildError>;
+export type ScoreCoherenceIssue = {
     readonly code: "score-fold-input-invalid";
-    readonly reason: ScorePayloadBuildErrorV1["code"];
+    readonly reason: ScorePayloadBuildError["code"];
 } | {
     readonly code: "score-payload-mismatch";
 };
-/** Confirms persisted score is exactly what the shared sealed facts produce. */
-export declare function validateScoreCoherenceV1(input: {
-    readonly payload: ScorePayloadV1;
-    readonly fold: ScoreFoldInputV1;
-}): readonly ScoreCoherenceIssueV1[];
-/** A semantic reason why a Score is not a complete ranking value. */
-export type ScoreIncompleteReason = "execution-errored" | "source-unavailable" | "evaluation-errored" | "not-applicable";
-export type ScoreIncompleteReasons = readonly [
-    ScoreIncompleteReason,
-    ...ScoreIncompleteReason[]
-];
-/** Score keeps partial and unavailable as ordinary, non-ranking values. */
+export declare function validateScoreCoherence(input: {
+    readonly payload: ScorePayload;
+    readonly fold: ScoreFoldInput;
+}): readonly ScoreCoherenceIssue[];
 export type Score = {
     readonly state: "complete";
     readonly earned: number;
@@ -155,11 +92,6 @@ export type Score = {
     readonly reasons: ScoreIncompleteReasons;
     readonly comparable: false;
 };
-/** @internal The historical name remains for existing producer-only consumers. */
-export type ScoreProjectionV1 = Score;
-export declare function projectScorePayloadV1(payload: RecordAttachmentPayloadSnapshot<ScorePayloadV1>): Score;
-/** A typed, synchronous projection over an available Score Attachment. */
-export declare function projectScoreAttachmentV1(value: RecordAttachmentValue<ScorePayloadV1>): Score;
-/** The public Score view for an Attempt-owned Attachment. */
-export declare const scoreProjector: RecordAttachmentProjector<"attempt", Score>;
+export type ScoreProjection = Score;
+export declare function projectScorePayload(payload: ScorePayload): Score;
 export {};

package/dist/eval/record/score.d.ts

@@ -1,21 +1,16 @@
 import { Either, Schema } from "effect";
-import { type RecordAttachmentPayloadSnapshot, type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.js";
-import { type RecordAttachmentProjector } from "../../projection/projector.js";
-import { type FiniteNonNegativeNumberV1 } from "./attachment.js";
-import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.js";
-export declare const SCORE_ATTACHMENT_NAME_V1: "niceeval.score";
-export declare const SCORE_ATTACHMENT_SCHEMA_ID_V1: "niceeval.score/v1";
-export declare const ScoreStateV1Schema: Schema.Literal<["complete", "partial", "unavailable"]>;
-export type ScoreStateV1 = Schema.Schema.Type<typeof ScoreStateV1Schema>;
-/** These are the only reasons that can make a sealed score source incomplete. */
-export declare const ScoreIncompleteReasonV1Schema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
-export type ScoreIncompleteReasonV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonV1Schema>;
-export declare const ScoreIncompleteReasonsV1Schema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
-export type ScoreIncompleteReasonsV1 = Schema.Schema.Type<typeof ScoreIncompleteReasonsV1Schema>;
-/** A formal earned score: finite, non-negative, and never a percentage/max. */
-export declare const EarnedScoreV1Schema: Schema.filter<Schema.filter<typeof Schema.Number>>;
-export type EarnedScoreV1 = FiniteNonNegativeNumberV1;
-declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
+import { type FiniteNonNegativeNumber } from "./attachment.js";
+import { type EvaluationAttemptFacts } from "./sealed-assertion.js";
+/** Score is an Analysis calculation, not an independently persisted family. */
+export declare const ScoreStateSchema: Schema.Literal<["complete", "partial", "unavailable"]>;
+export type ScoreState = Schema.Schema.Type<typeof ScoreStateSchema>;
+export declare const ScoreIncompleteReasonSchema: Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>;
+export type ScoreIncompleteReason = Schema.Schema.Type<typeof ScoreIncompleteReasonSchema>;
+export declare const ScoreIncompleteReasonsSchema: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
+export type ScoreIncompleteReasons = Schema.Schema.Type<typeof ScoreIncompleteReasonsSchema>;
+export declare const EarnedScoreSchema: Schema.filter<Schema.filter<typeof Schema.Number>>;
+export type EarnedScore = FiniteNonNegativeNumber;
+declare const ScorePayloadStructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -26,20 +21,18 @@ declare const ScorePayloadV1StructuralSchema: Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>;
-export type ScorePayloadV1 = Schema.Schema.Type<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadV1Encoded = Schema.Schema.Encoded<typeof ScorePayloadV1StructuralSchema>;
-export type ScorePayloadIssueV1 = {
+export type ScorePayload = Schema.Schema.Type<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadEncoded = Schema.Schema.Encoded<typeof ScorePayloadStructuralSchema>;
+export type ScorePayloadIssue = {
     readonly code: "score-incomplete-reason-duplicate";
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 } | {
     readonly code: "score-incomplete-reason-order-invalid";
     readonly index: number;
-    readonly reason: ScoreIncompleteReasonV1;
+    readonly reason: ScoreIncompleteReason;
 };
-/** Ensures reason arrays preserve all causes exactly once in a stable order. */
-export declare function validateScorePayloadV1(payload: ScorePayloadV1): readonly ScorePayloadIssueV1[];
-/** Exact JSON schema for `niceeval.score/v1`. */
-export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.Struct<{
+export declare function validateScorePayload(payload: ScorePayload): readonly ScorePayloadIssue[];
+export declare const ScorePayloadSchema: Schema.filter<Schema.Union<[Schema.Struct<{
     state: Schema.Literal<["complete"]>;
     earned: Schema.filter<Schema.filter<typeof Schema.Number>>;
 }>, Schema.Struct<{
@@ -50,97 +43,41 @@ export declare const ScorePayloadV1Schema: Schema.filter<Schema.Union<[Schema.St
     state: Schema.Literal<["unavailable"]>;
     reasons: Schema.NonEmptyArray<Schema.Literal<["execution-errored", "source-unavailable", "evaluation-errored", "not-applicable"]>>;
 }>]>>;
-/** The built-in Attempt Attachment definition owns exact decode and closure. */
-export declare const scoreAttachmentDefinitionV1: import("../../record/attachment/types.js").JsonRecordAttachmentDefinition<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare const scoreAttachmentFamilyV1: import("../../record/attachment/types.js").RecordAttachmentFamily<"attempt", {
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}>;
-export declare function decodeScorePayloadV1(input: unknown): Either.Either<{
-    readonly state: "complete";
-    readonly earned: number;
-} | {
-    readonly state: "partial";
-    readonly earned: number;
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-} | {
-    readonly state: "unavailable";
-    readonly reasons: readonly ["source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored", ...("source-unavailable" | "not-applicable" | "evaluation-errored" | "execution-errored")[]];
-}, import("../../record/attachment/errors.js").RecordAttachmentPayloadInvalid>;
-/**
- * Score reads the same sealed producer facts as Verdict but intentionally uses
- * only `result.score` plus execution status. Gate and skip do not rewrite an
- * earned contribution.
- */
-export type ScoreFoldInputV1 = EvaluationAttemptFactsV1;
-export declare const ScoreFoldInputV1Schema: Schema.Struct<{
+export type ScoreFoldInput = EvaluationAttemptFacts;
+export declare const ScoreFoldInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.js").SealedAssertionResultV1, import("./sealed-assertion.js").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.js").SealedAssertionResult, import("./sealed-assertion.js").SealedAssertionResult, never>;
     }>>;
 }>;
-/** Backward-neutral name for callers that construct the Attachment before writing. */
-export type ScoreBuildInputV1 = ScoreFoldInputV1;
-export declare const ScoreBuildInputV1Schema: Schema.Struct<{
+export type ScoreBuildInput = ScoreFoldInput;
+export declare const ScoreBuildInputSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<import("./sealed-assertion.js").SealedAssertionResultV1, import("./sealed-assertion.js").SealedAssertionResultV1, never>;
+        result: Schema.Schema<import("./sealed-assertion.js").SealedAssertionResult, import("./sealed-assertion.js").SealedAssertionResult, never>;
     }>>;
 }>;
-export type ScorePayloadBuildErrorV1 = {
+export type ScorePayloadBuildError = {
     readonly code: "score-fold-input-invalid";
 } | {
     readonly code: "score-earned-overflow";
 };
-/**
- * Produces Score state from sealed Score contributions. A gate failure is
- * absent by design; a non-score required Assertion can therefore make Verdict
- * errored while an already-complete Score stays complete.
- */
-export declare function buildScorePayloadV1(input: ScoreFoldInputV1): Either.Either<ScorePayloadV1, ScorePayloadBuildErrorV1>;
-/** Wraps an already validated durable Score payload in its Attempt Attachment. */
-export declare function createScoreAttachmentWriteV1(payload: ScorePayloadV1): RecordAttachmentWrite<"attempt", never, never>;
-/** Builds the real Attempt-owned Score write from sealed score contributions. */
-export declare function buildScoreAttachmentWriteV1(input: ScoreFoldInputV1): Either.Either<RecordAttachmentWrite<"attempt", never, never>, ScorePayloadBuildErrorV1>;
-export type ScoreCoherenceIssueV1 = {
+/** Folds sealed Assertion facts without producing a durable Record write. */
+export declare function buildScorePayload(input: ScoreFoldInput): Either.Either<ScorePayload, ScorePayloadBuildError>;
+export type ScoreCoherenceIssue = {
     readonly code: "score-fold-input-invalid";
-    readonly reason: ScorePayloadBuildErrorV1["code"];
+    readonly reason: ScorePayloadBuildError["code"];
 } | {
     readonly code: "score-payload-mismatch";
 };
-/** Confirms persisted score is exactly what the shared sealed facts produce. */
-export declare function validateScoreCoherenceV1(input: {
-    readonly payload: ScorePayloadV1;
-    readonly fold: ScoreFoldInputV1;
-}): readonly ScoreCoherenceIssueV1[];
-/** A semantic reason why a Score is not a complete ranking value. */
-export type ScoreIncompleteReason = "execution-errored" | "source-unavailable" | "evaluation-errored" | "not-applicable";
-export type ScoreIncompleteReasons = readonly [
-    ScoreIncompleteReason,
-    ...ScoreIncompleteReason[]
-];
-/** Score keeps partial and unavailable as ordinary, non-ranking values. */
+export declare function validateScoreCoherence(input: {
+    readonly payload: ScorePayload;
+    readonly fold: ScoreFoldInput;
+}): readonly ScoreCoherenceIssue[];
 export type Score = {
     readonly state: "complete";
     readonly earned: number;
@@ -155,11 +92,6 @@ export type Score = {
     readonly reasons: ScoreIncompleteReasons;
     readonly comparable: false;
 };
-/** @internal The historical name remains for existing producer-only consumers. */
-export type ScoreProjectionV1 = Score;
-export declare function projectScorePayloadV1(payload: RecordAttachmentPayloadSnapshot<ScorePayloadV1>): Score;
-/** A typed, synchronous projection over an available Score Attachment. */
-export declare function projectScoreAttachmentV1(value: RecordAttachmentValue<ScorePayloadV1>): Score;
-/** The public Score view for an Attempt-owned Attachment. */
-export declare const scoreProjector: RecordAttachmentProjector<"attempt", Score>;
+export type ScoreProjection = Score;
+export declare function projectScorePayload(payload: ScorePayload): Score;
 export {};