@nakafa/aksara-contracts 0.27.0

package/dist/tryout/placement.d.ts

@@ -0,0 +1,280 @@
+import { Schema } from "effect";
+/** Active placement before immutable artifact hashes are bound. */
+export declare const TryoutPlacementSourceSchema: Schema.Struct<{
+    answerArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    answerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    countryKey: Schema.String;
+    deliveryLanguage: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+    examKey: Schema.String;
+    languagePolicy: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"app-locale">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"fixed">;
+        readonly language: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+    }>]>;
+    questionArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    questionContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    questionOrder: Schema.Finite;
+    questionSourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    response: Schema.Union<readonly [Schema.Struct<{
+        readonly categories: Schema.$Array<Schema.Struct<{
+            readonly categoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+        }>>;
+        readonly kind: Schema.Literal<"category">;
+        readonly statements: Schema.$Array<Schema.Struct<{
+            readonly correctCategoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+            readonly statementKey: Schema.String;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multiple-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"single-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>]>;
+    scope: Schema.Literal<"server">;
+    sectionKey: Schema.String;
+    setKey: Schema.String;
+    sourceRevision: Schema.Trimmed;
+    stimulusKey: Schema.optionalKey<Schema.String>;
+    trackKey: Schema.String;
+}>;
+export type TryoutPlacementSource = typeof TryoutPlacementSourceSchema.Type;
+/** Artifact-bound placement retained by signed attempt state. */
+export declare const TryoutPlacementSchema: Schema.Struct<{
+    readonly answerArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly answerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly countryKey: Schema.String;
+    readonly deliveryLanguage: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+    readonly examKey: Schema.String;
+    readonly languagePolicy: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"app-locale">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"fixed">;
+        readonly language: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+    }>]>;
+    readonly questionArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly questionContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly questionOrder: Schema.Finite;
+    readonly questionSourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly response: Schema.Union<readonly [Schema.Struct<{
+        readonly categories: Schema.$Array<Schema.Struct<{
+            readonly categoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+        }>>;
+        readonly kind: Schema.Literal<"category">;
+        readonly statements: Schema.$Array<Schema.Struct<{
+            readonly correctCategoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+            readonly statementKey: Schema.String;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multiple-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"single-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>]>;
+    readonly scope: Schema.Literal<"server">;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly sourceRevision: Schema.Trimmed;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+    readonly trackKey: Schema.String;
+    readonly answerArtifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentHash: Schema.brand<Schema.String, "@NakafaAI/AksaraTryoutContentHash">;
+    readonly questionArtifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>;
+export type TryoutPlacement = typeof TryoutPlacementSchema.Type;
+/** Hashed immutable placement accepted by snapshot publication. */
+export declare const TryoutPlacementRecordSchema: Schema.Struct<{
+    readonly row: Schema.Struct<{
+        readonly answerArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly answerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+        readonly blueprint: Schema.optionalKey<Schema.Struct<{
+            readonly cognitiveLevel: Schema.String;
+            readonly contentDomain: Schema.String;
+            readonly topic: Schema.String;
+        }>>;
+        readonly countryKey: Schema.String;
+        readonly deliveryLanguage: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+        readonly examKey: Schema.String;
+        readonly languagePolicy: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"app-locale">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"fixed">;
+            readonly language: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraDeliveryLanguage">;
+        }>]>;
+        readonly questionArtifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly questionContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly questionOrder: Schema.Finite;
+        readonly questionSourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly response: Schema.Union<readonly [Schema.Struct<{
+            readonly categories: Schema.$Array<Schema.Struct<{
+                readonly categoryKey: Schema.String;
+                readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                    readonly kind: Schema.Literal<"math">;
+                    readonly math: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>]>>;
+                readonly order: Schema.Int;
+            }>>;
+            readonly kind: Schema.Literal<"category">;
+            readonly statements: Schema.$Array<Schema.Struct<{
+                readonly correctCategoryKey: Schema.String;
+                readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                    readonly kind: Schema.Literal<"math">;
+                    readonly math: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>]>>;
+                readonly order: Schema.Int;
+                readonly statementKey: Schema.String;
+            }>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"multiple-choice">;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly isCorrect: Schema.Boolean;
+                readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                    readonly kind: Schema.Literal<"math">;
+                    readonly math: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>]>>;
+                readonly optionKey: Schema.String;
+                readonly order: Schema.Int;
+            }>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"single-choice">;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly isCorrect: Schema.Boolean;
+                readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                    readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                    readonly kind: Schema.Literal<"math">;
+                    readonly math: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"text">;
+                    readonly text: Schema.String;
+                }>]>>;
+                readonly optionKey: Schema.String;
+                readonly order: Schema.Int;
+            }>>;
+        }>]>;
+        readonly scope: Schema.Literal<"server">;
+        readonly sectionKey: Schema.String;
+        readonly setKey: Schema.String;
+        readonly sourceRevision: Schema.Trimmed;
+        readonly stimulusKey: Schema.optionalKey<Schema.String>;
+        readonly trackKey: Schema.String;
+        readonly answerArtifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentHash: Schema.brand<Schema.String, "@NakafaAI/AksaraTryoutContentHash">;
+        readonly questionArtifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+    readonly rowHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>;
+export type TryoutPlacementRecord = typeof TryoutPlacementRecordSchema.Type;

package/dist/tryout/placement.js

@@ -0,0 +1,82 @@
+import { Schema } from "effect";
+import { ContentKeySchema, CorpusSourcePathSchema, Sha256HashSchema, } from "#contracts/ids";
+import { AppLocaleSchema, ArtifactLocaleSchema, DeliveryLanguageSchema, } from "#contracts/locale";
+import { QuestionKeySchema, questionKeyParts, } from "#contracts/question/identity";
+import { QuestionBlueprintSchema } from "#contracts/question/item";
+import { QuestionResponseSchema } from "#contracts/question/response";
+import { RendererDomainSchema } from "#contracts/renderer/domain";
+import { TryoutKeySchema } from "#contracts/tryout/key";
+import { AssessmentLanguagePolicySchema, deliveryLanguageForPolicy, } from "#contracts/tryout/language";
+import { TryoutContentHashSchema, TryoutSourceRevisionSchema, } from "#contracts/tryout/spec";
+const PositiveCountSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0)));
+const PlacementFields = {
+    answerArtifactLocale: ArtifactLocaleSchema,
+    answerContentKey: ContentKeySchema,
+    appLocale: AppLocaleSchema,
+    blueprint: Schema.optionalKey(QuestionBlueprintSchema),
+    countryKey: TryoutKeySchema,
+    deliveryLanguage: DeliveryLanguageSchema,
+    examKey: TryoutKeySchema,
+    languagePolicy: AssessmentLanguagePolicySchema,
+    questionArtifactLocale: ArtifactLocaleSchema,
+    questionContentKey: ContentKeySchema,
+    questionOrder: PositiveCountSchema,
+    questionSourcePath: CorpusSourcePathSchema,
+    rendererDomain: RendererDomainSchema,
+    response: QuestionResponseSchema,
+    scope: Schema.Literal("server"),
+    sectionKey: TryoutKeySchema,
+    setKey: TryoutKeySchema,
+    sourceRevision: TryoutSourceRevisionSchema,
+    stimulusKey: Schema.optionalKey(TryoutKeySchema),
+    trackKey: TryoutKeySchema,
+};
+/** Checks that content keys, source path, and authored order agree. */
+function hasCoherentPlacementKeys(input) {
+    const questionSuffix = "/question";
+    if (!input.questionContentKey.endsWith(questionSuffix)) {
+        return false;
+    }
+    const questionRoot = input.questionContentKey.slice(0, -questionSuffix.length);
+    if (!Schema.is(QuestionKeySchema)(questionRoot)) {
+        return false;
+    }
+    const parts = questionKeyParts(questionRoot);
+    return (input.answerContentKey === `${questionRoot}/answer` &&
+        parts.countryKey === input.countryKey &&
+        parts.examKey === input.examKey &&
+        parts.sectionKey === input.sectionKey &&
+        parts.setKey === input.setKey &&
+        parts.questionNumber === input.questionOrder &&
+        input.questionSourcePath === `packages/corpus/${questionRoot}` &&
+        input.questionContentKey === `${questionRoot}/question`);
+}
+/** Checks app, delivery, and artifact language identity for one placement. */
+function hasCoherentPlacementLanguages(input) {
+    const expectedDeliveryLanguage = deliveryLanguageForPolicy(input.languagePolicy, input.appLocale);
+    return (input.deliveryLanguage === expectedDeliveryLanguage &&
+        input.questionArtifactLocale === expectedDeliveryLanguage &&
+        input.answerArtifactLocale === input.appLocale);
+}
+/** Active placement before immutable artifact hashes are bound. */
+export const TryoutPlacementSourceSchema = Schema.Struct(PlacementFields).pipe(Schema.check(Schema.makeFilter(hasCoherentPlacementKeys, {
+    message: "Placement source, content keys, and authored order must agree.",
+})), Schema.check(Schema.makeFilter(hasCoherentPlacementLanguages, {
+    message: "Placement app, delivery, question, and answer languages must agree.",
+})));
+/** Artifact-bound placement retained by signed attempt state. */
+export const TryoutPlacementSchema = Schema.Struct({
+    ...PlacementFields,
+    answerArtifactHash: Sha256HashSchema,
+    contentHash: TryoutContentHashSchema,
+    questionArtifactHash: Sha256HashSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentPlacementKeys, {
+    message: "Placement source, content keys, and authored order must agree.",
+})), Schema.check(Schema.makeFilter(hasCoherentPlacementLanguages, {
+    message: "Placement app, delivery, question, and answer languages must agree.",
+})));
+/** Hashed immutable placement accepted by snapshot publication. */
+export const TryoutPlacementRecordSchema = Schema.Struct({
+    row: TryoutPlacementSchema,
+    rowHash: Sha256HashSchema,
+});

package/dist/tryout/row-hash.d.ts

@@ -0,0 +1,28 @@
+import { Effect, Schema, Stream } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+declare const TryoutDigestError_base: Schema.Class<TryoutDigestError, Schema.TaggedStruct<"TryoutDigestError", {
+    readonly code: Schema.Literals<readonly ["integrity", "order"]>;
+    readonly identity: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A snapshot stream is duplicated, unsorted, or tampered. */
+export declare class TryoutDigestError extends TryoutDigestError_base {
+}
+interface DigestRecord<Row> {
+    readonly row: Row;
+    readonly rowHash: typeof Sha256HashSchema.Type;
+}
+/** Digests one canonically ordered record stream with constant memory. */
+export declare const digestTryoutRecords: <E, R, Row>(input: {
+    /** Serializes one row into its exact digest bytes. */
+    readonly canonicalize: (row: Row) => string;
+    readonly domain: string;
+    /** Returns one stable ordering identity for a row. */
+    readonly identity: (row: Row) => string;
+    readonly records: Stream.Stream<DigestRecord<Row>, E, R>;
+    /** Recomputes the authenticated row hash for integrity checking. */
+    readonly rowHash: (row: Row) => typeof Sha256HashSchema.Type;
+}) => Effect.Effect<{
+    count: number;
+    digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, E | TryoutDigestError, R>;
+export {};

package/dist/tryout/row-hash.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema, Stream } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { compareCodeUnits } from "#contracts/text/order";
+/** A snapshot stream is duplicated, unsorted, or tampered. */
+export class TryoutDigestError extends Schema.TaggedError()("TryoutDigestError", {
+    code: Schema.Literals(["integrity", "order"]),
+    identity: Schema.String,
+}) {
+}
+/** Keeps one stream digest and previous identity private to its replay. */
+class TryoutDigestState {
+    #hash;
+    count = 0;
+    previous;
+    /** Creates one fresh domain-separated incremental digest. */
+    constructor(domain) {
+        this.#hash = createHash("sha256").update(domain).update("\n");
+    }
+    /** Adds one verified canonical record to the digest. */
+    update(canonical, identity) {
+        this.#hash.update(canonical).update("\n");
+        this.count += 1;
+        this.previous = identity;
+    }
+    /** Consumes the hash and returns its branded value. */
+    digest() {
+        return Sha256HashSchema.make(`sha256:${this.#hash.digest("hex")}`);
+    }
+}
+/** Verifies and adds one immutable record without retaining prior rows. */
+function updateDigest(state, record, identity, expectedHash, canonical) {
+    if (record.rowHash !== expectedHash) {
+        return Effect.fail(new TryoutDigestError({ code: "integrity", identity }));
+    }
+    if (state.previous !== undefined &&
+        compareCodeUnits(state.previous, identity) >= 0) {
+        return Effect.fail(new TryoutDigestError({ code: "order", identity }));
+    }
+    state.update(canonical, identity);
+    return Effect.succeed(state);
+}
+/** Digests one canonically ordered record stream with constant memory. */
+export const digestTryoutRecords = Effect.fn("AksaraContracts.digestTryoutRecords")(function* (input) {
+    const state = yield* input.records.pipe(Stream.runFoldEffect(() => new TryoutDigestState(input.domain), (current, record) => {
+        const canonical = input.canonicalize(record.row);
+        return updateDigest(current, record, input.identity(record.row), input.rowHash(record.row), `${canonical}\0${record.rowHash}`);
+    }));
+    return { count: state.count, digest: state.digest() };
+});

package/dist/tryout/runtime/canonical.d.ts

@@ -0,0 +1,8 @@
+import type { Sha256Hash } from "#contracts/ids";
+import type { TryoutRuntimeBundlePayload } from "#contracts/tryout/runtime/spec";
+/** Ed25519 domain separating runtime bundles from every other signed object. */
+export declare const TRYOUT_RUNTIME_BUNDLE_SIGNATURE_DOMAIN = "nakafa.aksara.tryout-runtime-bundle";
+/** Serializes one complete runtime payload with stable signed field order. */
+export declare function canonicalizeTryoutRuntimeBundlePayload(payload: TryoutRuntimeBundlePayload): string;
+/** Returns domain-separated canonical bytes covered by bundle Ed25519. */
+export declare function canonicalizeTryoutRuntimeBundleSigningInput(bundleHash: Sha256Hash, payload: TryoutRuntimeBundlePayload): string;

package/dist/tryout/runtime/canonical.js

@@ -0,0 +1,33 @@
+import { TRYOUT_RUNTIME_BUNDLE_FORMAT } from "#contracts/tryout/runtime/spec";
+/** Ed25519 domain separating runtime bundles from every other signed object. */
+export const TRYOUT_RUNTIME_BUNDLE_SIGNATURE_DOMAIN = "nakafa.aksara.tryout-runtime-bundle";
+/** Serializes one complete runtime payload with stable signed field order. */
+export function canonicalizeTryoutRuntimeBundlePayload(payload) {
+    return JSON.stringify({
+        format: TRYOUT_RUNTIME_BUNDLE_FORMAT,
+        rendererManifestHash: payload.rendererManifestHash,
+        snapshot: {
+            activeAppLocales: payload.snapshot.activeAppLocales,
+            catalogDigest: payload.snapshot.catalogDigest,
+            counts: {
+                country: payload.snapshot.counts.country,
+                exam: payload.snapshot.counts.exam,
+                section: payload.snapshot.counts.section,
+                set: payload.snapshot.counts.set,
+                track: payload.snapshot.counts.track,
+            },
+            format: payload.snapshot.format,
+            placementCount: payload.snapshot.placementCount,
+            placementDigest: payload.snapshot.placementDigest,
+            routeCount: payload.snapshot.routeCount,
+            snapshotId: payload.snapshot.snapshotId,
+        },
+        sourceGitSha: payload.sourceGitSha,
+        sourceManifestHash: payload.sourceManifestHash,
+        sourceReleaseId: payload.sourceReleaseId,
+    });
+}
+/** Returns domain-separated canonical bytes covered by bundle Ed25519. */
+export function canonicalizeTryoutRuntimeBundleSigningInput(bundleHash, payload) {
+    return `${TRYOUT_RUNTIME_BUNDLE_SIGNATURE_DOMAIN}\n${bundleHash}\n${canonicalizeTryoutRuntimeBundlePayload(payload)}`;
+}

package/dist/tryout/runtime/hash.d.ts

@@ -0,0 +1,32 @@
+import { Effect, Schema } from "effect";
+declare const TryoutRuntimeBundleHashComputationError_base: Schema.Class<TryoutRuntimeBundleHashComputationError, Schema.TaggedStruct<"TryoutRuntimeBundleHashComputationError", {
+    readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 computation failed before bundle authenticity was established. */
+export declare class TryoutRuntimeBundleHashComputationError extends TryoutRuntimeBundleHashComputationError_base {
+}
+/** Computes the immutable identity of one canonical runtime bundle payload. */
+export declare const hashTryoutRuntimeBundlePayload: (payload: {
+    readonly format: "signed-tryout-runtime-bundle";
+    readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly snapshot: {
+        readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+        readonly catalogDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly counts: {
+            readonly country: number;
+            readonly exam: number;
+            readonly section: number;
+            readonly set: number;
+            readonly track: number;
+        };
+        readonly placementCount: number;
+        readonly placementDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly routeCount: number;
+        readonly format: "localized-tryout-snapshot";
+        readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    };
+    readonly sourceGitSha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+    readonly sourceManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly sourceReleaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+}) => Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, TryoutRuntimeBundleHashComputationError, never>;
+export {};

package/dist/tryout/runtime/hash.js

@@ -0,0 +1,11 @@
+import { Effect, Schema } from "effect";
+import { hashText } from "#contracts/hash/text";
+import { ReleaseIdSchema } from "#contracts/ids";
+import { canonicalizeTryoutRuntimeBundlePayload } from "#contracts/tryout/runtime/canonical";
+/** SHA-256 computation failed before bundle authenticity was established. */
+export class TryoutRuntimeBundleHashComputationError extends Schema.TaggedError()("TryoutRuntimeBundleHashComputationError", { sourceReleaseId: ReleaseIdSchema }) {
+}
+/** Computes the immutable identity of one canonical runtime bundle payload. */
+export const hashTryoutRuntimeBundlePayload = Effect.fn("AksaraContracts.hashTryoutRuntimeBundlePayload")((payload) => hashText(canonicalizeTryoutRuntimeBundlePayload(payload)).pipe(Effect.mapError(() => new TryoutRuntimeBundleHashComputationError({
+    sourceReleaseId: payload.sourceReleaseId,
+}))));

package/dist/tryout/runtime/source.d.ts

@@ -0,0 +1,42 @@
+import { Effect, Schema } from "effect";
+import type { SignedContentRelease } from "#contracts/release/spec";
+import type { SignedTryoutRuntimeBundle } from "#contracts/tryout/runtime/spec";
+declare const TryoutRuntimeBundleSourceError_base: Schema.Class<TryoutRuntimeBundleSourceError, Schema.TaggedStruct<"TryoutRuntimeBundleSourceError", {
+    readonly reason: Schema.Literals<readonly ["release", "manifest", "revision", "renderer", "snapshot"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A runtime bundle does not describe a pair authenticated by its Git release. */
+export declare class TryoutRuntimeBundleSourceError extends TryoutRuntimeBundleSourceError_base {
+}
+/** Authenticates a runtime pair against its Git source or signed recovery link. */
+export declare const verifyTryoutRuntimeBundleSource: (input: {
+    readonly bundle: SignedTryoutRuntimeBundle;
+    readonly release: SignedContentRelease;
+}) => Effect.Effect<{
+    readonly bundleHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly keyId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSigningKeyId">;
+    readonly payload: {
+        readonly format: "signed-tryout-runtime-bundle";
+        readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly snapshot: {
+            readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+            readonly catalogDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly counts: {
+                readonly country: number;
+                readonly exam: number;
+                readonly section: number;
+                readonly set: number;
+                readonly track: number;
+            };
+            readonly placementCount: number;
+            readonly placementDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly routeCount: number;
+            readonly format: "localized-tryout-snapshot";
+            readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        };
+        readonly sourceGitSha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+        readonly sourceManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly sourceReleaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+    };
+    readonly signature: string & import("effect/Brand").Brand<"@NakafaAI/AksaraEd25519Signature">;
+}, TryoutRuntimeBundleSourceError, never>;
+export {};

package/dist/tryout/runtime/source.js

@@ -0,0 +1,47 @@
+import { Effect, Schema } from "effect";
+/** A runtime bundle does not describe a pair authenticated by its Git release. */
+export class TryoutRuntimeBundleSourceError extends Schema.TaggedError()("TryoutRuntimeBundleSourceError", {
+    reason: Schema.Literals([
+        "release",
+        "manifest",
+        "revision",
+        "renderer",
+        "snapshot",
+    ]),
+}) {
+}
+/** Authenticates a runtime pair against its Git source or signed recovery link. */
+export const verifyTryoutRuntimeBundleSource = Effect.fn("AksaraContracts.verifyTryoutRuntimeBundleSource")(function* (input) {
+    const { bundle, release } = input;
+    const { manifest } = release;
+    const sourceReleaseId = manifest.origin.kind === "git"
+        ? manifest.releaseId
+        : manifest.origin.releaseId;
+    if (sourceReleaseId !== bundle.payload.sourceReleaseId) {
+        return yield* new TryoutRuntimeBundleSourceError({ reason: "release" });
+    }
+    const sourceManifestHash = manifest.origin.kind === "git"
+        ? release.manifestHash
+        : manifest.baseManifestHash;
+    if (sourceManifestHash !== bundle.payload.sourceManifestHash) {
+        return yield* new TryoutRuntimeBundleSourceError({ reason: "manifest" });
+    }
+    if (manifest.origin.kind === "git" &&
+        manifest.origin.sha !== bundle.payload.sourceGitSha) {
+        return yield* new TryoutRuntimeBundleSourceError({ reason: "revision" });
+    }
+    if (manifest.rendererManifestHash !== bundle.payload.rendererManifestHash) {
+        return yield* new TryoutRuntimeBundleSourceError({ reason: "renderer" });
+    }
+    const { snapshotId } = bundle.payload.snapshot;
+    const transition = manifest.snapshots.tryout;
+    const isResult = snapshotId === transition.resultSnapshotId;
+    const isRetainedBase = manifest.origin.kind === "git" &&
+        transition.mode === "replace" &&
+        transition.baseSnapshotId !== null &&
+        snapshotId === transition.baseSnapshotId;
+    if (!(isResult || isRetainedBase)) {
+        return yield* new TryoutRuntimeBundleSourceError({ reason: "snapshot" });
+    }
+    return bundle;
+});