@nakafa/aksara-contracts 0.27.0

package/dist/tryout/content-hash.js

@@ -0,0 +1,72 @@
+import { createHash } from "node:crypto";
+import { Schema } from "effect";
+import { withPublicationDates } from "#contracts/date";
+import { AppLocaleSchema, ArtifactLocaleSchema, DeliveryLanguageSchema, } from "#contracts/locale";
+import { QuestionKeySchema } from "#contracts/question/identity";
+import { canonicalQuestionBlueprint, QuestionBlueprintSchema, } from "#contracts/question/item";
+import { canonicalQuestionResponse, QuestionResponseSchema, } from "#contracts/question/response";
+import { TryoutKeySchema } from "#contracts/tryout/key";
+import { AssessmentLanguagePolicySchema, canonicalAssessmentLanguagePolicy, } from "#contracts/tryout/language";
+import { TryoutContentHashSchema, TryoutSourceRevisionSchema, } from "#contracts/tryout/spec";
+const MULTIPLE_NEWLINES = /\n{3,}/gu;
+/** Exact authored facts that define one app and delivery-language question. */
+export const TryoutContentInputSchema = withPublicationDates({
+    answerArtifactLocale: ArtifactLocaleSchema,
+    answerBody: Schema.String,
+    appLocale: AppLocaleSchema,
+    blueprint: Schema.optionalKey(QuestionBlueprintSchema),
+    deliveryLanguage: DeliveryLanguageSchema,
+    languagePolicy: AssessmentLanguagePolicySchema,
+    questionArtifactLocale: ArtifactLocaleSchema,
+    questionBody: Schema.String,
+    response: QuestionResponseSchema,
+    sourcePath: QuestionKeySchema,
+    sourceRevision: TryoutSourceRevisionSchema,
+    stimulusKey: Schema.optionalKey(TryoutKeySchema),
+}).pipe(Schema.check(Schema.makeFilter(({ answerArtifactLocale, appLocale, deliveryLanguage, questionArtifactLocale, }) => String(answerArtifactLocale) === String(appLocale) &&
+    String(questionArtifactLocale) === String(deliveryLanguage), {
+    message: "Expected answer locale to match app locale and question locale to match delivery language.",
+})));
+/** Normalizes authored body spacing without changing MDX markup. */
+function normalizeBody(body) {
+    return body.replace(MULTIPLE_NEWLINES, "\n\n").trim();
+}
+/** Converts one validated date-only value to its UTC midnight epoch. */
+function dateEpoch(date) {
+    const year = Number.parseInt(date.slice(0, 4), 10);
+    const month = Number.parseInt(date.slice(5, 7), 10);
+    const day = Number.parseInt(date.slice(8, 10), 10);
+    return Date.UTC(year, month - 1, day);
+}
+/** Serializes every current question-pair identity field in stable order. */
+export function canonicalizeTryoutContent(input) {
+    return JSON.stringify({
+        answerArtifactLocale: input.answerArtifactLocale,
+        answerBody: normalizeBody(input.answerBody),
+        appLocale: input.appLocale,
+        ...(input.blueprint === undefined
+            ? {}
+            : { blueprint: canonicalQuestionBlueprint(input.blueprint) }),
+        ...(input.dateModified === undefined
+            ? {}
+            : { dateModified: dateEpoch(input.dateModified) }),
+        datePublished: dateEpoch(input.datePublished),
+        deliveryLanguage: input.deliveryLanguage,
+        languagePolicy: canonicalAssessmentLanguagePolicy(input.languagePolicy),
+        questionArtifactLocale: input.questionArtifactLocale,
+        questionBody: normalizeBody(input.questionBody),
+        response: canonicalQuestionResponse(input.response),
+        sourcePath: input.sourcePath,
+        sourceRevision: input.sourceRevision,
+        ...(input.stimulusKey === undefined
+            ? {}
+            : { stimulusKey: input.stimulusKey }),
+    });
+}
+/** Hashes one complete current question pair through its canonical identity. */
+export function hashTryoutContent(input) {
+    const digest = createHash("sha256")
+        .update(canonicalizeTryoutContent(input), "utf8")
+        .digest("hex");
+    return TryoutContentHashSchema.make(digest);
+}

package/dist/tryout/identity.d.ts

@@ -0,0 +1,12 @@
+import type { TryoutCatalogNodeIdentity, TryoutCatalogRow } from "#contracts/tryout/catalog";
+import type { TryoutPlacementSource } from "#contracts/tryout/placement";
+/** Builds one deterministic current node identity before its row is loaded. */
+export declare function tryoutCatalogNodeIdentity(input: TryoutCatalogNodeIdentity): string;
+/** Builds one deterministic current hierarchy identity from its signed row. */
+export declare function tryoutCatalogIdentity(row: TryoutCatalogRow): string;
+/** Builds the deterministic placement identity across application locales. */
+export declare function tryoutPlacementIdentity(row: TryoutPlacementSource): string;
+/** Builds one locale-neutral placement identity for closure checks. */
+export declare function tryoutPlacementLogicalIdentity(row: TryoutPlacementSource): string;
+/** Compares placements in the order used by question-head binding. */
+export declare function compareTryoutPlacements(left: TryoutPlacementSource, right: TryoutPlacementSource): -1 | 0 | 1;

package/dist/tryout/identity.js

@@ -0,0 +1,46 @@
+import { compareCodeUnits } from "#contracts/text/order";
+/** Builds one deterministic current node identity before its row is loaded. */
+export function tryoutCatalogNodeIdentity(input) {
+    return [
+        input.appLocale,
+        input.kind,
+        input.countryKey,
+        "examKey" in input ? input.examKey : "",
+        "trackKey" in input ? input.trackKey : "",
+        "setKey" in input ? input.setKey : "",
+        "sectionKey" in input ? input.sectionKey : "",
+    ].join("\0");
+}
+/** Builds one deterministic current hierarchy identity from its signed row. */
+export function tryoutCatalogIdentity(row) {
+    return tryoutCatalogNodeIdentity(row);
+}
+/** Builds the deterministic placement identity across application locales. */
+export function tryoutPlacementIdentity(row) {
+    return [
+        row.countryKey,
+        row.examKey,
+        row.trackKey,
+        row.setKey,
+        row.sectionKey,
+        row.questionOrder,
+        row.questionContentKey,
+        row.appLocale,
+    ].join("\0");
+}
+/** Builds one locale-neutral placement identity for closure checks. */
+export function tryoutPlacementLogicalIdentity(row) {
+    return [
+        row.countryKey,
+        row.examKey,
+        row.trackKey,
+        row.setKey,
+        row.sectionKey,
+        row.questionOrder,
+        row.questionContentKey,
+    ].join("\0");
+}
+/** Compares placements in the order used by question-head binding. */
+export function compareTryoutPlacements(left, right) {
+    return compareCodeUnits(tryoutPlacementIdentity(left), tryoutPlacementIdentity(right));
+}

package/dist/tryout/key.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+/** Stable lowercase identity for one try-out hierarchy node. */
+export declare const TryoutKeySchema: Schema.String;
+export type TryoutKey = typeof TryoutKeySchema.Type;

package/dist/tryout/key.js

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+import { isLowerKebab } from "#contracts/text/syntax";
+/** Stable lowercase identity for one try-out hierarchy node. */
+export const TryoutKeySchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab, {
+    description: "Lowercase kebab-case try-out source key.",
+    identifier: "TryoutKey",
+    message: "Invalid try-out key.",
+})), Schema.check(Schema.isMaxLength(128)));

package/dist/tryout/language.d.ts

@@ -0,0 +1,24 @@
+import { Schema } from "effect";
+import { type AppLocale, type ArtifactLocale, type DeliveryLanguage } from "#contracts/locale";
+/** Source-owned policy for the language presented by one assessment section. */
+export declare const AssessmentLanguagePolicySchema: 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">;
+}>]>;
+export type AssessmentLanguagePolicy = typeof AssessmentLanguagePolicySchema.Type;
+/** Resolves one section's delivered language without inspecting its name. */
+export declare function deliveryLanguageForPolicy(policy: AssessmentLanguagePolicy, appLocale: AppLocale): DeliveryLanguage;
+/** Resolves the exact immutable question artifact locale for one app locale. */
+export declare function questionArtifactLocaleForPolicy(policy: AssessmentLanguagePolicy, appLocale: AppLocale): ArtifactLocale;
+/** Lists unique prompt and response locales required by one section policy. */
+export declare function questionArtifactLocalesForPolicy(policy: AssessmentLanguagePolicy): readonly (("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">)[];
+/** Returns policy facts in stable field order for signed canonicalizers. */
+export declare function canonicalAssessmentLanguagePolicy(policy: AssessmentLanguagePolicy): {
+    kind: "fixed";
+    language: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraDeliveryLanguage">;
+} | {
+    language?: never;
+    kind: "app-locale";
+};

package/dist/tryout/language.js

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+import { ACTIVE_APP_LOCALES, ArtifactLocaleSchema, DeliveryLanguageSchema, } from "#contracts/locale";
+/** Source-owned policy for the language presented by one assessment section. */
+export const AssessmentLanguagePolicySchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("app-locale") }),
+    Schema.Struct({
+        kind: Schema.Literal("fixed"),
+        language: DeliveryLanguageSchema,
+    }),
+]);
+/** Resolves one section's delivered language without inspecting its name. */
+export function deliveryLanguageForPolicy(policy, appLocale) {
+    return policy.kind === "fixed"
+        ? policy.language
+        : DeliveryLanguageSchema.make(appLocale);
+}
+/** Resolves the exact immutable question artifact locale for one app locale. */
+export function questionArtifactLocaleForPolicy(policy, appLocale) {
+    return ArtifactLocaleSchema.make(deliveryLanguageForPolicy(policy, appLocale));
+}
+/** Lists unique prompt and response locales required by one section policy. */
+export function questionArtifactLocalesForPolicy(policy) {
+    return Object.freeze([
+        ...new Set(ACTIVE_APP_LOCALES.map((appLocale) => questionArtifactLocaleForPolicy(policy, appLocale))),
+    ]);
+}
+/** Returns policy facts in stable field order for signed canonicalizers. */
+export function canonicalAssessmentLanguagePolicy(policy) {
+    return policy.kind === "fixed"
+        ? { kind: policy.kind, language: policy.language }
+        : { kind: policy.kind };
+}

package/dist/tryout/locale-closure.d.ts

@@ -0,0 +1,20 @@
+import { Effect, Schema, Stream } from "effect";
+import type { ActiveAppLocaleList } from "#contracts/locale";
+import type { TryoutCatalogRecord } from "#contracts/tryout/catalog";
+import type { TryoutPlacementRecord } from "#contracts/tryout/placement";
+declare const TryoutClosureError_base: Schema.Class<TryoutClosureError, Schema.TaggedStruct<"TryoutClosureError", {
+    readonly actual: Schema.String;
+    readonly code: Schema.Literals<readonly ["assessed-language", "duplicate-locale", "fact-mismatch", "inactive-locale", "missing-locale", "missing-section", "question-count"]>;
+    readonly expected: Schema.String;
+    readonly identity: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A try-out snapshot is incomplete or inconsistent across app locales. */
+export declare class TryoutClosureError extends TryoutClosureError_base {
+}
+/** Verifies catalog facts, language policy, and inventory across app locales. */
+export declare const verifyTryoutLocaleClosure: <CatalogError, CatalogContext, PlacementError, PlacementContext>(input: {
+    readonly activeAppLocales: ActiveAppLocaleList;
+    readonly catalog: Stream.Stream<TryoutCatalogRecord, CatalogError, CatalogContext>;
+    readonly placements: Stream.Stream<TryoutPlacementRecord, PlacementError, PlacementContext>;
+}) => Effect.Effect<void, CatalogError | PlacementError | TryoutClosureError, CatalogContext | PlacementContext>;
+export {};

package/dist/tryout/locale-closure.js

@@ -0,0 +1,164 @@
+import { Effect, Schema, Stream } from "effect";
+import { canonicalizeTryoutCatalogFacts, tryoutCatalogLogicalIdentity, tryoutSectionLogicalIdentity, } from "#contracts/tryout/catalog-hash";
+import { tryoutPlacementLogicalIdentity } from "#contracts/tryout/identity";
+import { canonicalizeAssessedLanguagePlacementFacts, canonicalizeLocaleNeutralPlacementFacts, } from "#contracts/tryout/placement-closure";
+/** A try-out snapshot is incomplete or inconsistent across app locales. */
+export class TryoutClosureError extends Schema.TaggedError()("TryoutClosureError", {
+    actual: Schema.String,
+    code: Schema.Literals([
+        "assessed-language",
+        "duplicate-locale",
+        "fact-mismatch",
+        "inactive-locale",
+        "missing-locale",
+        "missing-section",
+        "question-count",
+    ]),
+    expected: Schema.String,
+    identity: Schema.String,
+}) {
+}
+/** Serializes locale sets through the active list's signed canonical order. */
+function localeSetIdentity(locales, activeAppLocales) {
+    return JSON.stringify(activeAppLocales.filter((locale) => locales.has(locale)));
+}
+/** Adds one active locale to a logical identity without duplicates. */
+function addLocale(localesByIdentity, activeAppLocales, identity, appLocale) {
+    if (!activeAppLocales.includes(appLocale)) {
+        return Effect.fail(new TryoutClosureError({
+            actual: appLocale,
+            code: "inactive-locale",
+            expected: JSON.stringify(activeAppLocales),
+            identity,
+        }));
+    }
+    const locales = localesByIdentity.get(identity) ?? new Set();
+    if (locales.has(appLocale)) {
+        return Effect.fail(new TryoutClosureError({
+            actual: appLocale,
+            code: "duplicate-locale",
+            expected: "one row per active app locale",
+            identity,
+        }));
+    }
+    locales.add(appLocale);
+    localesByIdentity.set(identity, locales);
+    return Effect.void;
+}
+/** Confirms every logical row closes over the exact active locale list. */
+function validateLocales(localesByIdentity, activeAppLocales) {
+    if (localesByIdentity.size === 0) {
+        return Effect.fail(new TryoutClosureError({
+            actual: "[]",
+            code: "missing-locale",
+            expected: JSON.stringify(activeAppLocales),
+            identity: "empty",
+        }));
+    }
+    return Effect.forEach(localesByIdentity, ([identity, locales]) => {
+        const actual = localeSetIdentity(locales, activeAppLocales);
+        const expected = JSON.stringify(activeAppLocales);
+        if (actual === expected) {
+            return Effect.void;
+        }
+        return Effect.fail(new TryoutClosureError({
+            actual,
+            code: "missing-locale",
+            expected,
+            identity,
+        }));
+    }, { discard: true });
+}
+/** Adds one catalog row and compares its locale-neutral facts. */
+function addCatalogRow(state, activeAppLocales, row) {
+    const identity = tryoutCatalogLogicalIdentity(row);
+    const facts = canonicalizeTryoutCatalogFacts(row);
+    const expectedFacts = state.factsByIdentity.get(identity);
+    if (expectedFacts !== undefined && expectedFacts !== facts) {
+        return Effect.fail(new TryoutClosureError({
+            actual: facts,
+            code: "fact-mismatch",
+            expected: expectedFacts,
+            identity,
+        }));
+    }
+    state.factsByIdentity.set(identity, facts);
+    if (row.kind === "section") {
+        state.sections.set(identity, row.questionCount);
+    }
+    return addLocale(state.localesByIdentity, activeAppLocales, identity, row.appLocale).pipe(Effect.as(state));
+}
+/** Adds one placement after binding it to a real catalog section. */
+function addPlacement(state, catalog, activeAppLocales, row) {
+    const identity = tryoutPlacementLogicalIdentity(row);
+    const sectionIdentity = tryoutSectionLogicalIdentity(row);
+    if (!catalog.sections.has(sectionIdentity)) {
+        return Effect.fail(new TryoutClosureError({
+            actual: "missing",
+            code: "missing-section",
+            expected: "catalog section",
+            identity: sectionIdentity,
+        }));
+    }
+    const facts = canonicalizeLocaleNeutralPlacementFacts(row);
+    const expectedFacts = state.factsByIdentity.get(identity);
+    if (expectedFacts !== undefined && expectedFacts !== facts) {
+        return Effect.fail(new TryoutClosureError({
+            actual: facts,
+            code: "fact-mismatch",
+            expected: expectedFacts,
+            identity,
+        }));
+    }
+    state.factsByIdentity.set(identity, facts);
+    if (row.languagePolicy.kind === "fixed") {
+        const assessedFacts = canonicalizeAssessedLanguagePlacementFacts(row);
+        const expectedAssessedFacts = state.assessedFacts.get(identity);
+        if (expectedAssessedFacts !== undefined &&
+            expectedAssessedFacts !== assessedFacts) {
+            return Effect.fail(new TryoutClosureError({
+                actual: assessedFacts,
+                code: "assessed-language",
+                expected: expectedAssessedFacts,
+                identity,
+            }));
+        }
+        state.assessedFacts.set(identity, assessedFacts);
+    }
+    const sectionLocaleIdentity = `${sectionIdentity}\0${row.appLocale}`;
+    state.countsBySectionLocale.set(sectionLocaleIdentity, (state.countsBySectionLocale.get(sectionLocaleIdentity) ?? 0) + 1);
+    return addLocale(state.localesByIdentity, activeAppLocales, identity, row.appLocale).pipe(Effect.as(state));
+}
+/** Confirms each localized section owns its declared question inventory. */
+function validateQuestionCounts(catalog, placements, activeAppLocales) {
+    return Effect.forEach(catalog.sections, ([identity, questionCount]) => Effect.forEach(activeAppLocales, (appLocale) => {
+        const actual = placements.countsBySectionLocale.get(`${identity}\0${appLocale}`) ??
+            0;
+        if (actual === questionCount) {
+            return Effect.void;
+        }
+        return Effect.fail(new TryoutClosureError({
+            actual: String(actual),
+            code: "question-count",
+            expected: String(questionCount),
+            identity: `${identity}\0${appLocale}`,
+        }));
+    }, { discard: true }), { discard: true });
+}
+/** Verifies catalog facts, language policy, and inventory across app locales. */
+export const verifyTryoutLocaleClosure = Effect.fn("AksaraContracts.verifyTryoutLocaleClosure")(function* (input) {
+    const catalog = yield* input.catalog.pipe(Stream.runFoldEffect(() => ({
+        factsByIdentity: new Map(),
+        localesByIdentity: new Map(),
+        sections: new Map(),
+    }), (state, record) => addCatalogRow(state, input.activeAppLocales, record.row)));
+    yield* validateLocales(catalog.localesByIdentity, input.activeAppLocales);
+    const placements = yield* input.placements.pipe(Stream.runFoldEffect(() => ({
+        assessedFacts: new Map(),
+        countsBySectionLocale: new Map(),
+        factsByIdentity: new Map(),
+        localesByIdentity: new Map(),
+    }), (state, record) => addPlacement(state, catalog, input.activeAppLocales, record.row)));
+    yield* validateLocales(placements.localesByIdentity, input.activeAppLocales);
+    yield* validateQuestionCounts(catalog, placements, input.activeAppLocales);
+});

package/dist/tryout/placement-closure.d.ts

@@ -0,0 +1,5 @@
+import type { TryoutPlacement } from "#contracts/tryout/placement";
+/** Serializes assessed prompt facts reused across application locales. */
+export declare function canonicalizeAssessedLanguagePlacementFacts(row: TryoutPlacement): string;
+/** Serializes placement facts that cannot vary with application locale. */
+export declare function canonicalizeLocaleNeutralPlacementFacts(row: TryoutPlacement): string;

package/dist/tryout/placement-closure.js

@@ -0,0 +1,30 @@
+import { canonicalQuestionBlueprint } from "#contracts/question/item";
+import { canonicalQuestionResponse, canonicalQuestionResponseStructure, } from "#contracts/question/response";
+import { canonicalAssessmentLanguagePolicy } from "#contracts/tryout/language";
+/** Serializes assessed prompt facts reused across application locales. */
+export function canonicalizeAssessedLanguagePlacementFacts(row) {
+    return JSON.stringify({
+        deliveryLanguage: row.deliveryLanguage,
+        questionArtifactHash: row.questionArtifactHash,
+        questionArtifactLocale: row.questionArtifactLocale,
+        questionContentKey: row.questionContentKey,
+        response: canonicalQuestionResponse(row.response),
+    });
+}
+/** Serializes placement facts that cannot vary with application locale. */
+export function canonicalizeLocaleNeutralPlacementFacts(row) {
+    return JSON.stringify({
+        answerContentKey: row.answerContentKey,
+        ...(row.blueprint === undefined
+            ? {}
+            : { blueprint: canonicalQuestionBlueprint(row.blueprint) }),
+        languagePolicy: canonicalAssessmentLanguagePolicy(row.languagePolicy),
+        questionContentKey: row.questionContentKey,
+        questionSourcePath: row.questionSourcePath,
+        rendererDomain: row.rendererDomain,
+        response: canonicalQuestionResponseStructure(row.response),
+        scope: row.scope,
+        sourceRevision: row.sourceRevision,
+        ...(row.stimulusKey === undefined ? {} : { stimulusKey: row.stimulusKey }),
+    });
+}

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

@@ -0,0 +1,11 @@
+import type { Stream } from "effect";
+import { type TryoutPlacement, type TryoutPlacementRecord } from "#contracts/tryout/placement";
+/** Serializes one artifact-bound placement with stable field order. */
+export declare function canonicalizeTryoutPlacement(row: TryoutPlacement): string;
+/** Creates one immutable authenticated placement record. */
+export declare function makeTryoutPlacementRecord(row: TryoutPlacement): TryoutPlacementRecord;
+/** Digests canonically ordered placements in constant space. */
+export declare function digestTryoutPlacements<E, R>(records: Stream.Stream<TryoutPlacementRecord, E, R>): import("effect/Effect").Effect<{
+    count: number;
+    digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, E | import("#contracts/tryout/row-hash").TryoutDigestError, R>;

package/dist/tryout/placement-hash.js

@@ -0,0 +1,55 @@
+import { canonicalQuestionBlueprint } from "#contracts/question/item";
+import { canonicalQuestionResponse } from "#contracts/question/response";
+import { hashTryoutCanonical } from "#contracts/tryout/canonical";
+import { tryoutPlacementIdentity } from "#contracts/tryout/identity";
+import { canonicalAssessmentLanguagePolicy } from "#contracts/tryout/language";
+import { TryoutPlacementRecordSchema, } from "#contracts/tryout/placement";
+import { digestTryoutRecords } from "#contracts/tryout/row-hash";
+const PLACEMENT_DOMAIN = "nakafa.aksara.tryout-placements";
+/** Serializes one artifact-bound placement with stable field order. */
+export function canonicalizeTryoutPlacement(row) {
+    return JSON.stringify({
+        answerArtifactHash: row.answerArtifactHash,
+        answerArtifactLocale: row.answerArtifactLocale,
+        answerContentKey: row.answerContentKey,
+        appLocale: row.appLocale,
+        ...(row.blueprint === undefined
+            ? {}
+            : { blueprint: canonicalQuestionBlueprint(row.blueprint) }),
+        contentHash: row.contentHash,
+        countryKey: row.countryKey,
+        deliveryLanguage: row.deliveryLanguage,
+        examKey: row.examKey,
+        languagePolicy: canonicalAssessmentLanguagePolicy(row.languagePolicy),
+        questionArtifactHash: row.questionArtifactHash,
+        questionArtifactLocale: row.questionArtifactLocale,
+        questionContentKey: row.questionContentKey,
+        questionOrder: row.questionOrder,
+        questionSourcePath: row.questionSourcePath,
+        rendererDomain: row.rendererDomain,
+        response: canonicalQuestionResponse(row.response),
+        scope: row.scope,
+        sectionKey: row.sectionKey,
+        setKey: row.setKey,
+        sourceRevision: row.sourceRevision,
+        ...(row.stimulusKey === undefined ? {} : { stimulusKey: row.stimulusKey }),
+        trackKey: row.trackKey,
+    });
+}
+/** Creates one immutable authenticated placement record. */
+export function makeTryoutPlacementRecord(row) {
+    return TryoutPlacementRecordSchema.make({
+        row,
+        rowHash: hashTryoutCanonical(PLACEMENT_DOMAIN, canonicalizeTryoutPlacement(row)),
+    });
+}
+/** Digests canonically ordered placements in constant space. */
+export function digestTryoutPlacements(records) {
+    return digestTryoutRecords({
+        canonicalize: canonicalizeTryoutPlacement,
+        domain: PLACEMENT_DOMAIN,
+        identity: tryoutPlacementIdentity,
+        records,
+        rowHash: (row) => makeTryoutPlacementRecord(row).rowHash,
+    });
+}