niceeval 0.12.2-canary.31 → 0.13.0

package/dist/eval/record/score.js

@@ -1,44 +1,26 @@
 import { createRequire as __niceevalCreateRequire } from "node:module";
 const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
 const __niceevalCanonical = __niceevalRequire("./score.cjs");
-const __niceevalExport0 = __niceevalCanonical["EarnedScoreV1Schema"];
-export { __niceevalExport0 as EarnedScoreV1Schema };
-const __niceevalExport1 = __niceevalCanonical["SCORE_ATTACHMENT_NAME_V1"];
-export { __niceevalExport1 as SCORE_ATTACHMENT_NAME_V1 };
-const __niceevalExport2 = __niceevalCanonical["SCORE_ATTACHMENT_SCHEMA_ID_V1"];
-export { __niceevalExport2 as SCORE_ATTACHMENT_SCHEMA_ID_V1 };
-const __niceevalExport3 = __niceevalCanonical["ScoreBuildInputV1Schema"];
-export { __niceevalExport3 as ScoreBuildInputV1Schema };
-const __niceevalExport4 = __niceevalCanonical["ScoreFoldInputV1Schema"];
-export { __niceevalExport4 as ScoreFoldInputV1Schema };
-const __niceevalExport5 = __niceevalCanonical["ScoreIncompleteReasonV1Schema"];
-export { __niceevalExport5 as ScoreIncompleteReasonV1Schema };
-const __niceevalExport6 = __niceevalCanonical["ScoreIncompleteReasonsV1Schema"];
-export { __niceevalExport6 as ScoreIncompleteReasonsV1Schema };
-const __niceevalExport7 = __niceevalCanonical["ScorePayloadV1Schema"];
-export { __niceevalExport7 as ScorePayloadV1Schema };
-const __niceevalExport8 = __niceevalCanonical["ScoreStateV1Schema"];
-export { __niceevalExport8 as ScoreStateV1Schema };
-const __niceevalExport9 = __niceevalCanonical["buildScoreAttachmentWriteV1"];
-export { __niceevalExport9 as buildScoreAttachmentWriteV1 };
-const __niceevalExport10 = __niceevalCanonical["buildScorePayloadV1"];
-export { __niceevalExport10 as buildScorePayloadV1 };
-const __niceevalExport11 = __niceevalCanonical["createScoreAttachmentWriteV1"];
-export { __niceevalExport11 as createScoreAttachmentWriteV1 };
-const __niceevalExport12 = __niceevalCanonical["decodeScorePayloadV1"];
-export { __niceevalExport12 as decodeScorePayloadV1 };
-const __niceevalExport13 = __niceevalCanonical["projectScoreAttachmentV1"];
-export { __niceevalExport13 as projectScoreAttachmentV1 };
-const __niceevalExport14 = __niceevalCanonical["projectScorePayloadV1"];
-export { __niceevalExport14 as projectScorePayloadV1 };
-const __niceevalExport15 = __niceevalCanonical["scoreAttachmentDefinitionV1"];
-export { __niceevalExport15 as scoreAttachmentDefinitionV1 };
-const __niceevalExport16 = __niceevalCanonical["scoreAttachmentFamilyV1"];
-export { __niceevalExport16 as scoreAttachmentFamilyV1 };
-const __niceevalExport17 = __niceevalCanonical["scoreProjector"];
-export { __niceevalExport17 as scoreProjector };
-const __niceevalExport18 = __niceevalCanonical["validateScoreCoherenceV1"];
-export { __niceevalExport18 as validateScoreCoherenceV1 };
-const __niceevalExport19 = __niceevalCanonical["validateScorePayloadV1"];
-export { __niceevalExport19 as validateScorePayloadV1 };
+const __niceevalExport0 = __niceevalCanonical["EarnedScoreSchema"];
+export { __niceevalExport0 as EarnedScoreSchema };
+const __niceevalExport1 = __niceevalCanonical["ScoreBuildInputSchema"];
+export { __niceevalExport1 as ScoreBuildInputSchema };
+const __niceevalExport2 = __niceevalCanonical["ScoreFoldInputSchema"];
+export { __niceevalExport2 as ScoreFoldInputSchema };
+const __niceevalExport3 = __niceevalCanonical["ScoreIncompleteReasonSchema"];
+export { __niceevalExport3 as ScoreIncompleteReasonSchema };
+const __niceevalExport4 = __niceevalCanonical["ScoreIncompleteReasonsSchema"];
+export { __niceevalExport4 as ScoreIncompleteReasonsSchema };
+const __niceevalExport5 = __niceevalCanonical["ScorePayloadSchema"];
+export { __niceevalExport5 as ScorePayloadSchema };
+const __niceevalExport6 = __niceevalCanonical["ScoreStateSchema"];
+export { __niceevalExport6 as ScoreStateSchema };
+const __niceevalExport7 = __niceevalCanonical["buildScorePayload"];
+export { __niceevalExport7 as buildScorePayload };
+const __niceevalExport8 = __niceevalCanonical["projectScorePayload"];
+export { __niceevalExport8 as projectScorePayload };
+const __niceevalExport9 = __niceevalCanonical["validateScoreCoherence"];
+export { __niceevalExport9 as validateScoreCoherence };
+const __niceevalExport10 = __niceevalCanonical["validateScorePayload"];
+export { __niceevalExport10 as validateScorePayload };
 //# sourceMappingURL=score.js.map

package/dist/eval/record/sealed-assertion.cjs

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvaluationAttemptFactsV1Schema = exports.SealedAssertionForEvaluationV1Schema = exports.SealedAssertionResultV1Schema = void 0;
-exports.isRequiredAssertionUnavailableOrErroredV1 = isRequiredAssertionUnavailableOrErroredV1;
-exports.isGateFailedV1 = isGateFailedV1;
+exports.EvaluationAttemptFactsSchema = exports.SealedAssertionForEvaluationSchema = exports.SealedAssertionResultSchema = void 0;
+exports.isRequiredAssertionUnavailableOrErrored = isRequiredAssertionUnavailableOrErrored;
+exports.isGateFailed = isGateFailed;
 const effect_1 = require("effect");
 const codec_ts_1 = require("../../assertions/record/codec.cjs");
-Object.defineProperty(exports, "SealedAssertionResultV1Schema", { enumerable: true, get: function () { return codec_ts_1.SealedAssertionResultV1Schema; } });
+Object.defineProperty(exports, "SealedAssertionResultSchema", { enumerable: true, get: function () { return codec_ts_1.SealedAssertionResultSchema; } });
 /**
  * `required` is producer policy, not a field added to the Assertions
  * Attachment. It determines whether an otherwise-local unavailable result
  * raises the Attempt Verdict to errored.
  */
-exports.SealedAssertionForEvaluationV1Schema = effect_1.Schema.Struct({
+exports.SealedAssertionForEvaluationSchema = effect_1.Schema.Struct({
     required: effect_1.Schema.Boolean,
-    result: codec_ts_1.SealedAssertionResultV1Schema,
+    result: codec_ts_1.SealedAssertionResultSchema,
 });
 /** All producer facts shared by the independent Verdict and Score folds. */
-exports.EvaluationAttemptFactsV1Schema = effect_1.Schema.Struct({
+exports.EvaluationAttemptFactsSchema = effect_1.Schema.Struct({
     execution: effect_1.Schema.Literal("completed", "errored"),
     explicitlySkipped: effect_1.Schema.Boolean,
-    assertions: effect_1.Schema.Array(exports.SealedAssertionForEvaluationV1Schema),
+    assertions: effect_1.Schema.Array(exports.SealedAssertionForEvaluationSchema),
 });
-function isRequiredAssertionUnavailableOrErroredV1(assertion) {
+function isRequiredAssertionUnavailableOrErrored(assertion) {
     return assertion.required && (assertion.result.state === "unavailable"
         || assertion.result.state === "errored");
 }
-function isGateFailedV1(assertion) {
+function isGateFailed(assertion) {
     return assertion.result.gate === "failed";
 }
 //# sourceMappingURL=sealed-assertion.cjs.map

package/dist/eval/record/sealed-assertion.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sealed-assertion.js","sourceRoot":"","sources":["sealed-assertion.ts"],"names":[],"mappings":";;;AA2BA,8FAGC;AACD,wCAEC;AAjCD,mCAAgC;AAChC,+DAA4H;AAOxE,8GAPV,wCAAuC,OAOA;AAEjF;;;;GAIG;AACU,QAAA,oCAAoC,GAAG,eAAM,CAAC,MAAM,CAAC;IAC9D,QAAQ,EAAE,eAAM,CAAC,OAAO;IACxB,MAAM,EAAE,wCAAuC;CAClD,CAAC,CAAC;AAEH,4EAA4E;AAC/D,QAAA,8BAA8B,GAAG,eAAM,CAAC,MAAM,CAAC;IACxD,SAAS,EAAE,eAAM,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC;IACjD,iBAAiB,EAAE,eAAM,CAAC,OAAO;IACjC,UAAU,EAAE,eAAM,CAAC,KAAK,CAAC,4CAAoC,CAAC;CACjE,CAAC,CAAC;AAEH,SAAgB,yCAAyC,CAAC,SAAyC;IAC/F,OAAO,SAAS,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,KAAK,aAAa;WAC/D,SAAS,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;AACjD,CAAC;AACD,SAAgB,cAAc,CAAC,SAAyC;IACpE,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC9C,CAAC","sourcesContent":["import { Schema } from \"effect\";\nimport { SealedAssertionResultV1Schema as AssertionsSealedAssertionResultV1Schema } from \"../../assertions/record/codec.ts\";\nimport type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1, } from \"../../assertions/record/model.ts\";\n/**\n * Eval folds consume the Assertions owner's sealed-result contract directly.\n * They deliberately do not re-own the Assertions Attachment or its blob\n * closure; `required` below is Eval producer policy only.\n */\nexport { AssertionsSealedAssertionResultV1Schema as SealedAssertionResultV1Schema, };\nexport type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1, };\n/**\n * `required` is producer policy, not a field added to the Assertions\n * Attachment. It determines whether an otherwise-local unavailable result\n * raises the Attempt Verdict to errored.\n */\nexport const SealedAssertionForEvaluationV1Schema = Schema.Struct({\n    required: Schema.Boolean,\n    result: AssertionsSealedAssertionResultV1Schema,\n});\nexport type SealedAssertionForEvaluationV1 = Schema.Schema.Type<typeof SealedAssertionForEvaluationV1Schema>;\n/** All producer facts shared by the independent Verdict and Score folds. */\nexport const EvaluationAttemptFactsV1Schema = Schema.Struct({\n    execution: Schema.Literal(\"completed\", \"errored\"),\n    explicitlySkipped: Schema.Boolean,\n    assertions: Schema.Array(SealedAssertionForEvaluationV1Schema),\n});\nexport type EvaluationAttemptFactsV1 = Schema.Schema.Type<typeof EvaluationAttemptFactsV1Schema>;\nexport function isRequiredAssertionUnavailableOrErroredV1(assertion: SealedAssertionForEvaluationV1): boolean {\n    return assertion.required && (assertion.result.state === \"unavailable\"\n        || assertion.result.state === \"errored\");\n}\nexport function isGateFailedV1(assertion: SealedAssertionForEvaluationV1): boolean {\n    return assertion.result.gate === \"failed\";\n}\n"]}
+{"version":3,"file":"sealed-assertion.js","sourceRoot":"","sources":["sealed-assertion.ts"],"names":[],"mappings":";;;AA2BA,0FAGC;AACD,oCAEC;AAjCD,mCAAgC;AAChC,+DAAwH;AAOtE,4GAPV,sCAAqC,OAOA;AAE7E;;;;GAIG;AACU,QAAA,kCAAkC,GAAG,eAAM,CAAC,MAAM,CAAC;IAC5D,QAAQ,EAAE,eAAM,CAAC,OAAO;IACxB,MAAM,EAAE,sCAAqC;CAChD,CAAC,CAAC;AAEH,4EAA4E;AAC/D,QAAA,4BAA4B,GAAG,eAAM,CAAC,MAAM,CAAC;IACtD,SAAS,EAAE,eAAM,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC;IACjD,iBAAiB,EAAE,eAAM,CAAC,OAAO;IACjC,UAAU,EAAE,eAAM,CAAC,KAAK,CAAC,0CAAkC,CAAC;CAC/D,CAAC,CAAC;AAEH,SAAgB,uCAAuC,CAAC,SAAuC;IAC3F,OAAO,SAAS,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,KAAK,aAAa;WAC/D,SAAS,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;AACjD,CAAC;AACD,SAAgB,YAAY,CAAC,SAAuC;IAChE,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC9C,CAAC","sourcesContent":["import { Schema } from \"effect\";\nimport { SealedAssertionResultSchema as AssertionsSealedAssertionResultSchema } from \"../../assertions/record/codec.ts\";\nimport type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution, } from \"../../assertions/record/model.ts\";\n/**\n * Eval folds consume the Assertions owner's sealed-result contract directly.\n * They deliberately do not re-own the Assertions Attachment or its blob\n * closure; `required` below is Eval producer policy only.\n */\nexport { AssertionsSealedAssertionResultSchema as SealedAssertionResultSchema, };\nexport type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution, };\n/**\n * `required` is producer policy, not a field added to the Assertions\n * Attachment. It determines whether an otherwise-local unavailable result\n * raises the Attempt Verdict to errored.\n */\nexport const SealedAssertionForEvaluationSchema = Schema.Struct({\n    required: Schema.Boolean,\n    result: AssertionsSealedAssertionResultSchema,\n});\nexport type SealedAssertionForEvaluation = Schema.Schema.Type<typeof SealedAssertionForEvaluationSchema>;\n/** All producer facts shared by the independent Verdict and Score folds. */\nexport const EvaluationAttemptFactsSchema = Schema.Struct({\n    execution: Schema.Literal(\"completed\", \"errored\"),\n    explicitlySkipped: Schema.Boolean,\n    assertions: Schema.Array(SealedAssertionForEvaluationSchema),\n});\nexport type EvaluationAttemptFacts = Schema.Schema.Type<typeof EvaluationAttemptFactsSchema>;\nexport function isRequiredAssertionUnavailableOrErrored(assertion: SealedAssertionForEvaluation): boolean {\n    return assertion.required && (assertion.result.state === \"unavailable\"\n        || assertion.result.state === \"errored\");\n}\nexport function isGateFailed(assertion: SealedAssertionForEvaluation): boolean {\n    return assertion.result.gate === \"failed\";\n}\n"]}

package/dist/eval/record/sealed-assertion.d.cts

@@ -1,32 +1,32 @@
 import { Schema } from "effect";
-import { SealedAssertionResultV1Schema as AssertionsSealedAssertionResultV1Schema } from "../../assertions/record/codec.cjs";
-import type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1 } from "../../assertions/record/model.cjs";
+import { SealedAssertionResultSchema as AssertionsSealedAssertionResultSchema } from "../../assertions/record/codec.cjs";
+import type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution } from "../../assertions/record/model.cjs";
 /**
  * Eval folds consume the Assertions owner's sealed-result contract directly.
  * They deliberately do not re-own the Assertions Attachment or its blob
  * closure; `required` below is Eval producer policy only.
  */
-export { AssertionsSealedAssertionResultV1Schema as SealedAssertionResultV1Schema, };
-export type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1, };
+export { AssertionsSealedAssertionResultSchema as SealedAssertionResultSchema, };
+export type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution, };
 /**
  * `required` is producer policy, not a field added to the Assertions
  * Attachment. It determines whether an otherwise-local unavailable result
  * raises the Attempt Verdict to errored.
  */
-export declare const SealedAssertionForEvaluationV1Schema: Schema.Struct<{
+export declare const SealedAssertionForEvaluationSchema: Schema.Struct<{
     required: typeof Schema.Boolean;
-    result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+    result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
 }>;
-export type SealedAssertionForEvaluationV1 = Schema.Schema.Type<typeof SealedAssertionForEvaluationV1Schema>;
+export type SealedAssertionForEvaluation = Schema.Schema.Type<typeof SealedAssertionForEvaluationSchema>;
 /** All producer facts shared by the independent Verdict and Score folds. */
-export declare const EvaluationAttemptFactsV1Schema: Schema.Struct<{
+export declare const EvaluationAttemptFactsSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+        result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
     }>>;
 }>;
-export type EvaluationAttemptFactsV1 = Schema.Schema.Type<typeof EvaluationAttemptFactsV1Schema>;
-export declare function isRequiredAssertionUnavailableOrErroredV1(assertion: SealedAssertionForEvaluationV1): boolean;
-export declare function isGateFailedV1(assertion: SealedAssertionForEvaluationV1): boolean;
+export type EvaluationAttemptFacts = Schema.Schema.Type<typeof EvaluationAttemptFactsSchema>;
+export declare function isRequiredAssertionUnavailableOrErrored(assertion: SealedAssertionForEvaluation): boolean;
+export declare function isGateFailed(assertion: SealedAssertionForEvaluation): boolean;

package/dist/eval/record/sealed-assertion.d.mts

@@ -1,32 +1,32 @@
 import { Schema } from "effect";
-import { SealedAssertionResultV1Schema as AssertionsSealedAssertionResultV1Schema } from "../../assertions/record/codec.mjs";
-import type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1 } from "../../assertions/record/model.mjs";
+import { SealedAssertionResultSchema as AssertionsSealedAssertionResultSchema } from "../../assertions/record/codec.mjs";
+import type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution } from "../../assertions/record/model.mjs";
 /**
  * Eval folds consume the Assertions owner's sealed-result contract directly.
  * They deliberately do not re-own the Assertions Attachment or its blob
  * closure; `required` below is Eval producer policy only.
  */
-export { AssertionsSealedAssertionResultV1Schema as SealedAssertionResultV1Schema, };
-export type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1, };
+export { AssertionsSealedAssertionResultSchema as SealedAssertionResultSchema, };
+export type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution, };
 /**
  * `required` is producer policy, not a field added to the Assertions
  * Attachment. It determines whether an otherwise-local unavailable result
  * raises the Attempt Verdict to errored.
  */
-export declare const SealedAssertionForEvaluationV1Schema: Schema.Struct<{
+export declare const SealedAssertionForEvaluationSchema: Schema.Struct<{
     required: typeof Schema.Boolean;
-    result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+    result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
 }>;
-export type SealedAssertionForEvaluationV1 = Schema.Schema.Type<typeof SealedAssertionForEvaluationV1Schema>;
+export type SealedAssertionForEvaluation = Schema.Schema.Type<typeof SealedAssertionForEvaluationSchema>;
 /** All producer facts shared by the independent Verdict and Score folds. */
-export declare const EvaluationAttemptFactsV1Schema: Schema.Struct<{
+export declare const EvaluationAttemptFactsSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+        result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
     }>>;
 }>;
-export type EvaluationAttemptFactsV1 = Schema.Schema.Type<typeof EvaluationAttemptFactsV1Schema>;
-export declare function isRequiredAssertionUnavailableOrErroredV1(assertion: SealedAssertionForEvaluationV1): boolean;
-export declare function isGateFailedV1(assertion: SealedAssertionForEvaluationV1): boolean;
+export type EvaluationAttemptFacts = Schema.Schema.Type<typeof EvaluationAttemptFactsSchema>;
+export declare function isRequiredAssertionUnavailableOrErrored(assertion: SealedAssertionForEvaluation): boolean;
+export declare function isGateFailed(assertion: SealedAssertionForEvaluation): boolean;

package/dist/eval/record/sealed-assertion.d.ts

@@ -1,32 +1,32 @@
 import { Schema } from "effect";
-import { SealedAssertionResultV1Schema as AssertionsSealedAssertionResultV1Schema } from "../../assertions/record/codec.js";
-import type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1 } from "../../assertions/record/model.js";
+import { SealedAssertionResultSchema as AssertionsSealedAssertionResultSchema } from "../../assertions/record/codec.js";
+import type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution } from "../../assertions/record/model.js";
 /**
  * Eval folds consume the Assertions owner's sealed-result contract directly.
  * They deliberately do not re-own the Assertions Attachment or its blob
  * closure; `required` below is Eval producer policy only.
  */
-export { AssertionsSealedAssertionResultV1Schema as SealedAssertionResultV1Schema, };
-export type { EarnedScoreContributionV1, GateDispositionV1, NoScoreContributionV1, ScoreContributionV1, SealedAssertionResultV1, UnavailableScoreContributionV1, };
+export { AssertionsSealedAssertionResultSchema as SealedAssertionResultSchema, };
+export type { EarnedScoreContribution, GateDisposition, NoScoreContribution, ScoreContribution, SealedAssertionResult, UnavailableScoreContribution, };
 /**
  * `required` is producer policy, not a field added to the Assertions
  * Attachment. It determines whether an otherwise-local unavailable result
  * raises the Attempt Verdict to errored.
  */
-export declare const SealedAssertionForEvaluationV1Schema: Schema.Struct<{
+export declare const SealedAssertionForEvaluationSchema: Schema.Struct<{
     required: typeof Schema.Boolean;
-    result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+    result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
 }>;
-export type SealedAssertionForEvaluationV1 = Schema.Schema.Type<typeof SealedAssertionForEvaluationV1Schema>;
+export type SealedAssertionForEvaluation = Schema.Schema.Type<typeof SealedAssertionForEvaluationSchema>;
 /** All producer facts shared by the independent Verdict and Score folds. */
-export declare const EvaluationAttemptFactsV1Schema: Schema.Struct<{
+export declare const EvaluationAttemptFactsSchema: Schema.Struct<{
     execution: Schema.Literal<["completed", "errored"]>;
     explicitlySkipped: typeof Schema.Boolean;
     assertions: Schema.Array$<Schema.Struct<{
         required: typeof Schema.Boolean;
-        result: Schema.Schema<SealedAssertionResultV1, SealedAssertionResultV1, never>;
+        result: Schema.Schema<SealedAssertionResult, SealedAssertionResult, never>;
     }>>;
 }>;
-export type EvaluationAttemptFactsV1 = Schema.Schema.Type<typeof EvaluationAttemptFactsV1Schema>;
-export declare function isRequiredAssertionUnavailableOrErroredV1(assertion: SealedAssertionForEvaluationV1): boolean;
-export declare function isGateFailedV1(assertion: SealedAssertionForEvaluationV1): boolean;
+export type EvaluationAttemptFacts = Schema.Schema.Type<typeof EvaluationAttemptFactsSchema>;
+export declare function isRequiredAssertionUnavailableOrErrored(assertion: SealedAssertionForEvaluation): boolean;
+export declare function isGateFailed(assertion: SealedAssertionForEvaluation): boolean;

package/dist/eval/record/sealed-assertion.js

@@ -1,14 +1,14 @@
 import { createRequire as __niceevalCreateRequire } from "node:module";
 const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
 const __niceevalCanonical = __niceevalRequire("./sealed-assertion.cjs");
-const __niceevalExport0 = __niceevalCanonical["EvaluationAttemptFactsV1Schema"];
-export { __niceevalExport0 as EvaluationAttemptFactsV1Schema };
-const __niceevalExport1 = __niceevalCanonical["SealedAssertionForEvaluationV1Schema"];
-export { __niceevalExport1 as SealedAssertionForEvaluationV1Schema };
-const __niceevalExport2 = __niceevalCanonical["SealedAssertionResultV1Schema"];
-export { __niceevalExport2 as SealedAssertionResultV1Schema };
-const __niceevalExport3 = __niceevalCanonical["isGateFailedV1"];
-export { __niceevalExport3 as isGateFailedV1 };
-const __niceevalExport4 = __niceevalCanonical["isRequiredAssertionUnavailableOrErroredV1"];
-export { __niceevalExport4 as isRequiredAssertionUnavailableOrErroredV1 };
+const __niceevalExport0 = __niceevalCanonical["EvaluationAttemptFactsSchema"];
+export { __niceevalExport0 as EvaluationAttemptFactsSchema };
+const __niceevalExport1 = __niceevalCanonical["SealedAssertionForEvaluationSchema"];
+export { __niceevalExport1 as SealedAssertionForEvaluationSchema };
+const __niceevalExport2 = __niceevalCanonical["SealedAssertionResultSchema"];
+export { __niceevalExport2 as SealedAssertionResultSchema };
+const __niceevalExport3 = __niceevalCanonical["isGateFailed"];
+export { __niceevalExport3 as isGateFailed };
+const __niceevalExport4 = __niceevalCanonical["isRequiredAssertionUnavailableOrErrored"];
+export { __niceevalExport4 as isRequiredAssertionUnavailableOrErrored };
 //# sourceMappingURL=sealed-assertion.js.map

package/dist/eval/record/verdict.cjs

@@ -1,69 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verdictProjector = exports.VerdictFoldInputV1Schema = exports.verdictAttachmentFamilyV1 = exports.verdictAttachmentDefinitionV1 = exports.VerdictPayloadV1Schema = exports.VerdictStateV1Schema = exports.VERDICT_ATTACHMENT_SCHEMA_ID_V1 = exports.VERDICT_ATTACHMENT_NAME_V1 = void 0;
-exports.decodeVerdictPayloadV1 = decodeVerdictPayloadV1;
-exports.foldVerdictV1 = foldVerdictV1;
-exports.buildVerdictPayloadV1 = buildVerdictPayloadV1;
-exports.createVerdictAttachmentWriteV1 = createVerdictAttachmentWriteV1;
-exports.buildVerdictAttachmentWriteV1 = buildVerdictAttachmentWriteV1;
-exports.validateVerdictCoherenceV1 = validateVerdictCoherenceV1;
-exports.projectVerdictPayloadV1 = projectVerdictPayloadV1;
-exports.projectVerdictAttachmentV1 = projectVerdictAttachmentV1;
+exports.VerdictFoldInputSchema = exports.VerdictPayloadSchema = exports.VerdictStateSchema = void 0;
+exports.foldVerdict = foldVerdict;
+exports.foldRecordedAttemptVerdict = foldRecordedAttemptVerdict;
+exports.buildVerdictPayload = buildVerdictPayload;
+exports.validateVerdictCoherence = validateVerdictCoherence;
+exports.projectVerdictPayload = projectVerdictPayload;
 const effect_1 = require("effect");
-const index_ts_1 = require("../../record/attachment/index.cjs");
-const internal_ts_1 = require("../../record/attachment/internal.cjs");
-const projector_ts_1 = require("../../projection/projector.cjs");
-const attachment_ts_1 = require("./attachment.cjs");
 const sealed_assertion_ts_1 = require("./sealed-assertion.cjs");
-exports.VERDICT_ATTACHMENT_NAME_V1 = "niceeval.verdict";
-exports.VERDICT_ATTACHMENT_SCHEMA_ID_V1 = "niceeval.verdict/v1";
-exports.VerdictStateV1Schema = effect_1.Schema.Literal("passed", "failed", "errored", "skipped");
-/** The durable Verdict fact deliberately contains no Assertions, diagnostics, or score. */
-exports.VerdictPayloadV1Schema = effect_1.Schema.Struct({
-    state: exports.VerdictStateV1Schema,
+/**
+ * A transient fold result. Verdict is derived from sealed Assertion facts and
+ * Attempt outcome; it is deliberately not a Record Attachment family.
+ */
+exports.VerdictStateSchema = effect_1.Schema.Literal("passed", "failed", "errored", "skipped");
+exports.VerdictPayloadSchema = effect_1.Schema.Struct({
+    state: exports.VerdictStateSchema,
 });
-/** The built-in Attempt Attachment definition owns exact decode and closure. */
-exports.verdictAttachmentDefinitionV1 = (0, attachment_ts_1.requireRecordAttachmentCapabilityV1)((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: exports.VERDICT_ATTACHMENT_NAME_V1,
-    schemaId: exports.VERDICT_ATTACHMENT_SCHEMA_ID_V1,
-    schema: exports.VerdictPayloadV1Schema,
-    blobRefs: attachment_ts_1.noRecordAttachmentBlobs,
-}), "Verdict v1 RecordAttachment definition must be valid");
-exports.verdictAttachmentFamilyV1 = (0, attachment_ts_1.requireRecordAttachmentCapabilityV1)((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.verdictAttachmentDefinitionV1,
-    migrations: [],
-}), "Verdict v1 RecordAttachment family must be valid");
-function decodeVerdictPayloadV1(input) {
-    return (0, index_ts_1.decodeJsonRecordAttachmentPayload)(exports.verdictAttachmentDefinitionV1, input);
-}
-exports.VerdictFoldInputV1Schema = sealed_assertion_ts_1.EvaluationAttemptFactsV1Schema;
-function foldVerdictV1(input) {
+exports.VerdictFoldInputSchema = sealed_assertion_ts_1.EvaluationAttemptFactsSchema;
+function foldVerdict(input) {
     if (input.execution === "errored"
-        || input.assertions.some(sealed_assertion_ts_1.isRequiredAssertionUnavailableOrErroredV1)) {
+        || input.assertions.some(sealed_assertion_ts_1.isRequiredAssertionUnavailableOrErrored)) {
         return "errored";
     }
-    if (input.assertions.some(sealed_assertion_ts_1.isGateFailedV1)) {
+    if (input.assertions.some(sealed_assertion_ts_1.isGateFailed))
         return "failed";
-    }
     return input.explicitlySkipped ? "skipped" : "passed";
 }
-function buildVerdictPayloadV1(input) {
-    return Object.freeze({ state: foldVerdictV1(input) });
-}
-/** Wraps an already validated durable Verdict payload in its Attempt Attachment. */
-function createVerdictAttachmentWriteV1(payload) {
-    return (0, attachment_ts_1.makeNoBlobRecordAttachmentWriteV1)(exports.verdictAttachmentFamilyV1, payload);
+/**
+ * Folds the public Verdict from the immutable Attempt outcome and verified
+ * Assertions payload.  This is the one adapter from Record's terminal Core
+ * state into the verdict fold; consumers must not reproduce these rules.
+ */
+function foldRecordedAttemptVerdict(input) {
+    return foldVerdict({
+        execution: input.outcome === "errored" || input.outcome === "interrupted"
+            ? "errored"
+            : "completed",
+        explicitlySkipped: input.outcome === "cancelled",
+        assertions: input.assertions.entries.map((entry) => Object.freeze({
+            // `unavailable` is a required gate's sealed representation. Entries
+            // marked `not-gate` stay optional and cannot invent an execution error.
+            required: entry.result.gate !== "not-gate",
+            result: entry.result,
+        })),
+    });
 }
-/** Builds the real Attempt-owned write without embedding Score or diagnostics. */
-function buildVerdictAttachmentWriteV1(input) {
-    return createVerdictAttachmentWriteV1(buildVerdictPayloadV1(input));
+function buildVerdictPayload(input) {
+    return Object.freeze({ state: foldVerdict(input) });
 }
-/** Confirms a producer persisted the Verdict demanded by sealed facts. */
-function validateVerdictCoherenceV1(input) {
-    const expected = foldVerdictV1(input.fold);
+function validateVerdictCoherence(input) {
+    const expected = foldVerdict(input.fold);
     return input.payload.state === expected
-        ? []
+        ? Object.freeze([])
         : Object.freeze([
             Object.freeze({
                 code: "verdict-fold-mismatch",
@@ -72,18 +60,8 @@ function validateVerdictCoherenceV1(input) {
             }),
         ]);
 }
-/** A projector needs only the already-decoded exact Verdict state. */
-function projectVerdictPayloadV1(payload) {
+/** Plain domain projection for callers that need NiceEval's public verdict. */
+function projectVerdictPayload(payload) {
     return payload.state;
 }
-/** Internal current-family interpretation used by the Evaluation producer. */
-function projectVerdictAttachmentV1(value) {
-    // Record has already exact-decoded and frozen every available payload.
-    return projectVerdictPayloadV1(value.payload);
-}
-/** The public four-state Verdict view for an Attempt-owned Attachment. */
-exports.verdictProjector = (0, projector_ts_1.defineRecordAttachmentProjector)({
-    attachment: exports.verdictAttachmentFamilyV1,
-    project: projectVerdictAttachmentV1,
-});
 //# sourceMappingURL=verdict.cjs.map

package/dist/eval/record/verdict.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"verdict.js","sourceRoot":"","sources":["verdict.ts"],"names":[],"mappings":";;;AA6BA,wDAEC;AAOD,sCASC;AACD,sDAEC;AAED,wEAEC;AAED,sEAEC;AAOD,gEAcC;AAED,0DAEC;AAED,gEAGC;AAxFD,mCAAgC;AAChC,+DAA4K;AAC5K,qEAAwF;AACxF,gEAAiH;AAEjH,mDAAmI;AACnI,+DAAkK;AACrJ,QAAA,0BAA0B,GAAG,kBAA2B,CAAC;AACzD,QAAA,+BAA+B,GAAG,qBAA8B,CAAC;AACjE,QAAA,oBAAoB,GAAG,eAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AAE7F,2FAA2F;AAC9E,QAAA,sBAAsB,GAAG,eAAM,CAAC,MAAM,CAAC;IAChD,KAAK,EAAE,4BAAoB;CAC9B,CAAC,CAAC;AAGH,gFAAgF;AACnE,QAAA,6BAA6B,GAAG,IAAA,mDAAmC,EAAC,IAAA,+CAAiC,EAAC;IAC/G,KAAK,EAAE,SAAS;IAChB,IAAI,EAAE,kCAA0B;IAChC,QAAQ,EAAE,uCAA+B;IACzC,MAAM,EAAE,8BAAsB;IAC9B,QAAQ,EAAE,uCAAuB;CACpC,CAAC,EAAE,sDAAsD,CAAC,CAAC;AAC/C,QAAA,yBAAyB,GAAG,IAAA,mDAAmC,EAAC,IAAA,uCAA4B,EAAC;IACtG,OAAO,EAAE,qCAA6B;IACtC,UAAU,EAAE,EAAE;CACjB,CAAC,EAAE,kDAAkD,CAAC,CAAC;AACxD,SAAgB,sBAAsB,CAAC,KAAc;IACjD,OAAO,IAAA,4CAAiC,EAAC,qCAA6B,EAAE,KAAK,CAAC,CAAC;AACnF,CAAC;AAMY,QAAA,wBAAwB,GAAG,oDAA8B,CAAC;AACvE,SAAgB,aAAa,CAAC,KAAyB;IACnD,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;WAC1B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,+DAAyC,CAAC,EAAE,CAAC;QACtE,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,oCAAc,CAAC,EAAE,CAAC;QACxC,OAAO,QAAQ,CAAC;IACpB,CAAC;IACD,OAAO,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC1D,CAAC;AACD,SAAgB,qBAAqB,CAAC,KAAyB;IAC3D,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AAC1D,CAAC;AACD,oFAAoF;AACpF,SAAgB,8BAA8B,CAAC,OAAyB;IACpE,OAAO,IAAA,iDAAiC,EAAC,iCAAyB,EAAE,OAAO,CAAC,CAAC;AACjF,CAAC;AACD,kFAAkF;AAClF,SAAgB,6BAA6B,CAAC,KAAyB;IACnE,OAAO,8BAA8B,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;AACxE,CAAC;AAMD,0EAA0E;AAC1E,SAAgB,0BAA0B,CAAC,KAG1C;IACG,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,KAAK,QAAQ;QACnC,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;YACZ,MAAM,CAAC,MAAM,CAAC;gBACV,IAAI,EAAE,uBAAgC;gBACtC,QAAQ;gBACR,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK;aAC9B,CAAC;SACL,CAAC,CAAC;AACX,CAAC;AACD,sEAAsE;AACtE,SAAgB,uBAAuB,CAAC,OAAyB;IAC7D,OAAO,OAAO,CAAC,KAAK,CAAC;AACzB,CAAC;AACD,8EAA8E;AAC9E,SAAgB,0BAA0B,CAAC,KAA8C;IACrF,uEAAuE;IACvE,OAAO,uBAAuB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;AAClD,CAAC;AACD,0EAA0E;AAC7D,QAAA,gBAAgB,GAAkD,IAAA,8CAA+B,EAAC;IAC3G,UAAU,EAAE,iCAAyB;IACrC,OAAO,EAAE,0BAA0B;CACtC,CAAC,CAAC","sourcesContent":["import { Schema } from \"effect\";\nimport { decodeJsonRecordAttachmentPayload, defineRecordAttachmentFamily, type RecordAttachmentValue, type RecordAttachmentWrite, } from \"../../record/attachment/index.ts\";\nimport { defineBuiltinJsonRecordAttachment } from \"../../record/attachment/internal.ts\";\nimport { defineRecordAttachmentProjector, type RecordAttachmentProjector, } from \"../../projection/projector.ts\";\nimport type { Verdict } from \"../../shared/types.ts\";\nimport { makeNoBlobRecordAttachmentWriteV1, noRecordAttachmentBlobs, requireRecordAttachmentCapabilityV1, } from \"./attachment.ts\";\nimport { EvaluationAttemptFactsV1Schema, isGateFailedV1, isRequiredAssertionUnavailableOrErroredV1, type EvaluationAttemptFactsV1, } from \"./sealed-assertion.ts\";\nexport const VERDICT_ATTACHMENT_NAME_V1 = \"niceeval.verdict\" as const;\nexport const VERDICT_ATTACHMENT_SCHEMA_ID_V1 = \"niceeval.verdict/v1\" as const;\nexport const VerdictStateV1Schema = Schema.Literal(\"passed\", \"failed\", \"errored\", \"skipped\");\nexport type VerdictStateV1 = Schema.Schema.Type<typeof VerdictStateV1Schema>;\n/** The durable Verdict fact deliberately contains no Assertions, diagnostics, or score. */\nexport const VerdictPayloadV1Schema = Schema.Struct({\n    state: VerdictStateV1Schema,\n});\nexport type VerdictPayloadV1 = Schema.Schema.Type<typeof VerdictPayloadV1Schema>;\nexport type VerdictPayloadV1Encoded = Schema.Schema.Encoded<typeof VerdictPayloadV1Schema>;\n/** The built-in Attempt Attachment definition owns exact decode and closure. */\nexport const verdictAttachmentDefinitionV1 = requireRecordAttachmentCapabilityV1(defineBuiltinJsonRecordAttachment({\n    owner: \"attempt\",\n    name: VERDICT_ATTACHMENT_NAME_V1,\n    schemaId: VERDICT_ATTACHMENT_SCHEMA_ID_V1,\n    schema: VerdictPayloadV1Schema,\n    blobRefs: noRecordAttachmentBlobs,\n}), \"Verdict v1 RecordAttachment definition must be valid\");\nexport const verdictAttachmentFamilyV1 = requireRecordAttachmentCapabilityV1(defineRecordAttachmentFamily({\n    current: verdictAttachmentDefinitionV1,\n    migrations: [],\n}), \"Verdict v1 RecordAttachment family must be valid\");\nexport function decodeVerdictPayloadV1(input: unknown) {\n    return decodeJsonRecordAttachmentPayload(verdictAttachmentDefinitionV1, input);\n}\n/**\n * The pure fold takes the shared sealed producer facts. It never receives a\n * Score payload, so score and Verdict cannot accidentally derive one another.\n */\nexport type VerdictFoldInputV1 = EvaluationAttemptFactsV1;\nexport const VerdictFoldInputV1Schema = EvaluationAttemptFactsV1Schema;\nexport function foldVerdictV1(input: VerdictFoldInputV1): VerdictStateV1 {\n    if (input.execution === \"errored\"\n        || input.assertions.some(isRequiredAssertionUnavailableOrErroredV1)) {\n        return \"errored\";\n    }\n    if (input.assertions.some(isGateFailedV1)) {\n        return \"failed\";\n    }\n    return input.explicitlySkipped ? \"skipped\" : \"passed\";\n}\nexport function buildVerdictPayloadV1(input: VerdictFoldInputV1): VerdictPayloadV1 {\n    return Object.freeze({ state: foldVerdictV1(input) });\n}\n/** Wraps an already validated durable Verdict payload in its Attempt Attachment. */\nexport function createVerdictAttachmentWriteV1(payload: VerdictPayloadV1): RecordAttachmentWrite<\"attempt\", never, never> {\n    return makeNoBlobRecordAttachmentWriteV1(verdictAttachmentFamilyV1, payload);\n}\n/** Builds the real Attempt-owned write without embedding Score or diagnostics. */\nexport function buildVerdictAttachmentWriteV1(input: VerdictFoldInputV1): RecordAttachmentWrite<\"attempt\", never, never> {\n    return createVerdictAttachmentWriteV1(buildVerdictPayloadV1(input));\n}\nexport type VerdictCoherenceIssueV1 = {\n    readonly code: \"verdict-fold-mismatch\";\n    readonly expected: VerdictStateV1;\n    readonly actual: VerdictStateV1;\n};\n/** Confirms a producer persisted the Verdict demanded by sealed facts. */\nexport function validateVerdictCoherenceV1(input: {\n    readonly payload: VerdictPayloadV1;\n    readonly fold: VerdictFoldInputV1;\n}): readonly VerdictCoherenceIssueV1[] {\n    const expected = foldVerdictV1(input.fold);\n    return input.payload.state === expected\n        ? []\n        : Object.freeze([\n            Object.freeze({\n                code: \"verdict-fold-mismatch\" as const,\n                expected,\n                actual: input.payload.state,\n            }),\n        ]);\n}\n/** A projector needs only the already-decoded exact Verdict state. */\nexport function projectVerdictPayloadV1(payload: VerdictPayloadV1): Verdict {\n    return payload.state;\n}\n/** Internal current-family interpretation used by the Evaluation producer. */\nexport function projectVerdictAttachmentV1(value: RecordAttachmentValue<VerdictPayloadV1>): Verdict {\n    // Record has already exact-decoded and frozen every available payload.\n    return projectVerdictPayloadV1(value.payload);\n}\n/** The public four-state Verdict view for an Attempt-owned Attachment. */\nexport const verdictProjector: RecordAttachmentProjector<\"attempt\", Verdict> = defineRecordAttachmentProjector({\n    attachment: verdictAttachmentFamilyV1,\n    project: projectVerdictAttachmentV1,\n});\n"]}
+{"version":3,"file":"verdict.js","sourceRoot":"","sources":["verdict.ts"],"names":[],"mappings":";;;AAkBA,kCAQC;AAMD,gEAgBC;AACD,kDAEC;AAMD,4DAcC;AAED,sDAEC;AA3ED,mCAAgC;AAIhC,+DAA0J;AAC1J;;;GAGG;AACU,QAAA,kBAAkB,GAAG,eAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AAE9E,QAAA,oBAAoB,GAAG,eAAM,CAAC,MAAM,CAAC;IAC9C,KAAK,EAAE,0BAAkB;CAC5B,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,kDAA4B,CAAC;AACnE,SAAgB,WAAW,CAAC,KAAuB;IAC/C,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;WAC1B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,6DAAuC,CAAC,EAAE,CAAC;QACpE,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,kCAAY,CAAC;QACnC,OAAO,QAAQ,CAAC;IACpB,OAAO,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC1D,CAAC;AACD;;;;GAIG;AACH,SAAgB,0BAA0B,CAAC,KAG1C;IACG,OAAO,WAAW,CAAC;QACf,SAAS,EAAE,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,KAAK,aAAa;YACrE,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,WAAW;QACjB,iBAAiB,EAAE,KAAK,CAAC,OAAO,KAAK,WAAW;QAChD,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;YAC9D,oEAAoE;YACpE,wEAAwE;YACxE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU;YAC1C,MAAM,EAAE,KAAK,CAAC,MAAM;SACvB,CAAC,CAAC;KACN,CAAC,CAAC;AACP,CAAC;AACD,SAAgB,mBAAmB,CAAC,KAAuB;IACvD,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;AACxD,CAAC;AAMD,SAAgB,wBAAwB,CAAC,KAGxC;IACG,MAAM,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACzC,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,KAAK,QAAQ;QACnC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACnB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;YACZ,MAAM,CAAC,MAAM,CAAC;gBACV,IAAI,EAAE,uBAAgC;gBACtC,QAAQ;gBACR,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK;aAC9B,CAAC;SACL,CAAC,CAAC;AACX,CAAC;AACD,+EAA+E;AAC/E,SAAgB,qBAAqB,CAAC,OAAuB;IACzD,OAAO,OAAO,CAAC,KAAK,CAAC;AACzB,CAAC","sourcesContent":["import { Schema } from \"effect\";\nimport type { AssertionsAttachment } from \"../../record/family/assertions.ts\";\nimport type { AttemptOutcome } from \"../../record/model/core.ts\";\nimport type { Verdict } from \"../../shared/types.ts\";\nimport { EvaluationAttemptFactsSchema, isGateFailed, isRequiredAssertionUnavailableOrErrored, type EvaluationAttemptFacts, } from \"./sealed-assertion.ts\";\n/**\n * A transient fold result. Verdict is derived from sealed Assertion facts and\n * Attempt outcome; it is deliberately not a Record Attachment family.\n */\nexport const VerdictStateSchema = Schema.Literal(\"passed\", \"failed\", \"errored\", \"skipped\");\nexport type VerdictState = Schema.Schema.Type<typeof VerdictStateSchema>;\nexport const VerdictPayloadSchema = Schema.Struct({\n    state: VerdictStateSchema,\n});\nexport type VerdictPayload = Schema.Schema.Type<typeof VerdictPayloadSchema>;\nexport type VerdictPayloadEncoded = Schema.Schema.Encoded<typeof VerdictPayloadSchema>;\nexport type VerdictFoldInput = EvaluationAttemptFacts;\nexport const VerdictFoldInputSchema = EvaluationAttemptFactsSchema;\nexport function foldVerdict(input: VerdictFoldInput): VerdictState {\n    if (input.execution === \"errored\"\n        || input.assertions.some(isRequiredAssertionUnavailableOrErrored)) {\n        return \"errored\";\n    }\n    if (input.assertions.some(isGateFailed))\n        return \"failed\";\n    return input.explicitlySkipped ? \"skipped\" : \"passed\";\n}\n/**\n * Folds the public Verdict from the immutable Attempt outcome and verified\n * Assertions payload.  This is the one adapter from Record's terminal Core\n * state into the verdict fold; consumers must not reproduce these rules.\n */\nexport function foldRecordedAttemptVerdict(input: {\n    readonly outcome: AttemptOutcome;\n    readonly assertions: AssertionsAttachment;\n}): VerdictState {\n    return foldVerdict({\n        execution: input.outcome === \"errored\" || input.outcome === \"interrupted\"\n            ? \"errored\"\n            : \"completed\",\n        explicitlySkipped: input.outcome === \"cancelled\",\n        assertions: input.assertions.entries.map((entry) => Object.freeze({\n            // `unavailable` is a required gate's sealed representation. Entries\n            // marked `not-gate` stay optional and cannot invent an execution error.\n            required: entry.result.gate !== \"not-gate\",\n            result: entry.result,\n        })),\n    });\n}\nexport function buildVerdictPayload(input: VerdictFoldInput): VerdictPayload {\n    return Object.freeze({ state: foldVerdict(input) });\n}\nexport type VerdictCoherenceIssue = {\n    readonly code: \"verdict-fold-mismatch\";\n    readonly expected: VerdictState;\n    readonly actual: VerdictState;\n};\nexport function validateVerdictCoherence(input: {\n    readonly payload: VerdictPayload;\n    readonly fold: VerdictFoldInput;\n}): readonly VerdictCoherenceIssue[] {\n    const expected = foldVerdict(input.fold);\n    return input.payload.state === expected\n        ? Object.freeze([])\n        : Object.freeze([\n            Object.freeze({\n                code: \"verdict-fold-mismatch\" as const,\n                expected,\n                actual: input.payload.state,\n            }),\n        ]);\n}\n/** Plain domain projection for callers that need NiceEval's public verdict. */\nexport function projectVerdictPayload(payload: VerdictPayload): Verdict {\n    return payload.state;\n}\n"]}

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

@@ -1,60 +1,47 @@
 import { Schema } from "effect";
-import { type RecordAttachmentValue, type RecordAttachmentWrite } from "../../record/attachment/index.cjs";
-import { type RecordAttachmentProjector } from "../../projection/projector.cjs";
+import type { AssertionsAttachment } from "../../record/family/assertions.cjs";
+import type { AttemptOutcome } from "../../record/model/core.cjs";
 import type { Verdict } from "../../shared/types.cjs";
-import { type EvaluationAttemptFactsV1 } from "./sealed-assertion.cjs";
-export declare const VERDICT_ATTACHMENT_NAME_V1: "niceeval.verdict";
-export declare const VERDICT_ATTACHMENT_SCHEMA_ID_V1: "niceeval.verdict/v1";
-export declare const VerdictStateV1Schema: Schema.Literal<["passed", "failed", "errored", "skipped"]>;
-export type VerdictStateV1 = Schema.Schema.Type<typeof VerdictStateV1Schema>;
-/** The durable Verdict fact deliberately contains no Assertions, diagnostics, or score. */
-export declare const VerdictPayloadV1Schema: Schema.Struct<{
-    state: Schema.Literal<["passed", "failed", "errored", "skipped"]>;
-}>;
-export type VerdictPayloadV1 = Schema.Schema.Type<typeof VerdictPayloadV1Schema>;
-export type VerdictPayloadV1Encoded = Schema.Schema.Encoded<typeof VerdictPayloadV1Schema>;
-/** The built-in Attempt Attachment definition owns exact decode and closure. */
-export declare const verdictAttachmentDefinitionV1: import("../../record/attachment/types.cjs").JsonRecordAttachmentDefinition<"attempt", {
-    readonly state: "skipped" | "failed" | "errored" | "passed";
-}>;
-export declare const verdictAttachmentFamilyV1: import("../../record/attachment/types.cjs").RecordAttachmentFamily<"attempt", {
-    readonly state: "skipped" | "failed" | "errored" | "passed";
-}>;
-export declare function decodeVerdictPayloadV1(input: unknown): import("effect/Either").Either<{
-    readonly state: "skipped" | "failed" | "errored" | "passed";
-}, import("../../record/attachment/errors.cjs").RecordAttachmentPayloadInvalid>;
+import { type EvaluationAttemptFacts } from "./sealed-assertion.cjs";
 /**
- * The pure fold takes the shared sealed producer facts. It never receives a
- * Score payload, so score and Verdict cannot accidentally derive one another.
+ * A transient fold result. Verdict is derived from sealed Assertion facts and
+ * Attempt outcome; it is deliberately not a Record Attachment family.
  */
-export type VerdictFoldInputV1 = EvaluationAttemptFactsV1;
-export declare const VerdictFoldInputV1Schema: Schema.Struct<{
+export declare const VerdictStateSchema: Schema.Literal<["passed", "failed", "errored", "skipped"]>;
+export type VerdictState = Schema.Schema.Type<typeof VerdictStateSchema>;
+export declare const VerdictPayloadSchema: Schema.Struct<{
+    state: Schema.Literal<["passed", "failed", "errored", "skipped"]>;
+}>;
+export type VerdictPayload = Schema.Schema.Type<typeof VerdictPayloadSchema>;
+export type VerdictPayloadEncoded = Schema.Schema.Encoded<typeof VerdictPayloadSchema>;
+export type VerdictFoldInput = EvaluationAttemptFacts;
+export declare const VerdictFoldInputSchema: 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 declare function foldVerdictV1(input: VerdictFoldInputV1): VerdictStateV1;
-export declare function buildVerdictPayloadV1(input: VerdictFoldInputV1): VerdictPayloadV1;
-/** Wraps an already validated durable Verdict payload in its Attempt Attachment. */
-export declare function createVerdictAttachmentWriteV1(payload: VerdictPayloadV1): RecordAttachmentWrite<"attempt", never, never>;
-/** Builds the real Attempt-owned write without embedding Score or diagnostics. */
-export declare function buildVerdictAttachmentWriteV1(input: VerdictFoldInputV1): RecordAttachmentWrite<"attempt", never, never>;
-export type VerdictCoherenceIssueV1 = {
+export declare function foldVerdict(input: VerdictFoldInput): VerdictState;
+/**
+ * Folds the public Verdict from the immutable Attempt outcome and verified
+ * Assertions payload.  This is the one adapter from Record's terminal Core
+ * state into the verdict fold; consumers must not reproduce these rules.
+ */
+export declare function foldRecordedAttemptVerdict(input: {
+    readonly outcome: AttemptOutcome;
+    readonly assertions: AssertionsAttachment;
+}): VerdictState;
+export declare function buildVerdictPayload(input: VerdictFoldInput): VerdictPayload;
+export type VerdictCoherenceIssue = {
     readonly code: "verdict-fold-mismatch";
-    readonly expected: VerdictStateV1;
-    readonly actual: VerdictStateV1;
+    readonly expected: VerdictState;
+    readonly actual: VerdictState;
 };
-/** Confirms a producer persisted the Verdict demanded by sealed facts. */
-export declare function validateVerdictCoherenceV1(input: {
-    readonly payload: VerdictPayloadV1;
-    readonly fold: VerdictFoldInputV1;
-}): readonly VerdictCoherenceIssueV1[];
-/** A projector needs only the already-decoded exact Verdict state. */
-export declare function projectVerdictPayloadV1(payload: VerdictPayloadV1): Verdict;
-/** Internal current-family interpretation used by the Evaluation producer. */
-export declare function projectVerdictAttachmentV1(value: RecordAttachmentValue<VerdictPayloadV1>): Verdict;
-/** The public four-state Verdict view for an Attempt-owned Attachment. */
-export declare const verdictProjector: RecordAttachmentProjector<"attempt", Verdict>;
+export declare function validateVerdictCoherence(input: {
+    readonly payload: VerdictPayload;
+    readonly fold: VerdictFoldInput;
+}): readonly VerdictCoherenceIssue[];
+/** Plain domain projection for callers that need NiceEval's public verdict. */
+export declare function projectVerdictPayload(payload: VerdictPayload): Verdict;