@nakafa/aksara-contracts 0.27.0

package/dist/program/snapshot/digest.d.ts

@@ -0,0 +1,26 @@
+import { Effect, Schema, Stream } from "effect";
+import type { ActiveAppLocaleList } from "#contracts/locale";
+import { type ProgramSnapshotRow } from "#contracts/program/snapshot/row";
+import { ProgramRowHashError } from "#contracts/program/snapshot/row-hash";
+import type { ProgramCounts } from "#contracts/program/snapshot/spec";
+declare const ProgramDigestError_base: Schema.Class<ProgramDigestError, Schema.TaggedStruct<"ProgramDigestError", {
+    readonly code: Schema.Literals<readonly ["count", "integrity", "key", "order", "parent", "program", "route", "root", "slug"]>;
+    readonly identity: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** An aggregate program stream is incomplete, duplicated, or tampered. */
+export declare class ProgramDigestError extends ProgramDigestError_base {
+}
+/** Digests a complete current program snapshot under its active locale set. */
+export declare const digestProgramRows: <E, R>(input: {
+    readonly activeAppLocales: ActiveAppLocaleList;
+    readonly expected?: ProgramCounts;
+    readonly rows: Stream.Stream<ProgramSnapshotRow, E, R>;
+}) => Effect.Effect<{
+    curriculumRowCount: number;
+    programRowCount: number;
+    rowCount: number;
+    sitemapCount: number;
+    slugCount: number;
+    rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, E | ProgramDigestError | ProgramRowHashError, R>;
+export {};

package/dist/program/snapshot/digest.js

@@ -0,0 +1,220 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema, Stream } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { curriculumNamespace, } from "#contracts/program/curriculum";
+import { canonicalizeProgramSnapshotRow, } from "#contracts/program/snapshot/row";
+import { ProgramRowHashError, verifyProgramSnapshotRowHash, } from "#contracts/program/snapshot/row-hash";
+import { compareCodeUnits } from "#contracts/text/order";
+const DIGEST_DOMAIN = "nakafa.aksara.program-rows";
+/** An aggregate program stream is incomplete, duplicated, or tampered. */
+export class ProgramDigestError extends Schema.TaggedError()("ProgramDigestError", {
+    code: Schema.Literals([
+        "count",
+        "integrity",
+        "key",
+        "order",
+        "parent",
+        "program",
+        "route",
+        "root",
+        "slug",
+    ]),
+    identity: Schema.String,
+}) {
+}
+/** Serializes source-derived counts for exact replay comparison. */
+function countIdentity(counts) {
+    return [
+        counts.curriculumRowCount,
+        counts.programRowCount,
+        counts.rowCount,
+        counts.sitemapCount,
+        counts.slugCount,
+    ].join(":");
+}
+/** Resolves one required localized program identity. */
+function translationFor(program, appLocale) {
+    return program.translations.find((translation) => translation.appLocale === appLocale);
+}
+/** Checks that one root is the exact localized route owned by its program. */
+function isExactProgramRoot(row, program) {
+    const translation = translationFor(program, row.appLocale);
+    return (translation !== undefined &&
+        row.iconKey === program.iconKey &&
+        row.order === program.displayOrder &&
+        row.publicPath ===
+            `${curriculumNamespace(row.appLocale)}/${translation.publicSlug}` &&
+        row.title === translation.title);
+}
+/** Keeps current locale closure, identity, and digest state in one replay. */
+class ProgramDigestState {
+    #activeAppLocales;
+    #hash = createHash("sha256").update(`${DIGEST_DOMAIN}\n`);
+    #nodes = new Set();
+    #paths = new Set();
+    #programs = new Map();
+    #routes = new Set();
+    #roots = new Set();
+    #slugs = new Set();
+    #lastCurriculumKey;
+    #lastProgramOrder = 0;
+    curriculumRowCount = 0;
+    programRowCount = 0;
+    sitemapCount = 0;
+    /** Initializes one isolated replay under the signed active locale set. */
+    constructor(activeAppLocales) {
+        this.#activeAppLocales = activeAppLocales;
+    }
+    /** Returns source-independent count evidence collected from accepted rows. */
+    counts() {
+        return {
+            curriculumRowCount: this.curriculumRowCount,
+            programRowCount: this.programRowCount,
+            rowCount: this.curriculumRowCount + this.programRowCount,
+            sitemapCount: this.sitemapCount,
+            slugCount: this.#slugs.size,
+        };
+    }
+    /** Adds one verified current row after checking ownership and order. */
+    add(record) {
+        return record.kind === "program"
+            ? this.#addProgram(record)
+            : this.#addCurriculum(record);
+    }
+    /** Finalizes complete catalog, root, locale, and count evidence. */
+    validateComplete(expected) {
+        const expectedRoots = new Set();
+        for (const program of this.#programs.values()) {
+            if (program.navigation.model !== "curriculum-tree") {
+                continue;
+            }
+            for (const locale of this.#activeAppLocales) {
+                expectedRoots.add(`${program.key}\0${locale}`);
+            }
+        }
+        const counts = this.counts();
+        const expectedCounts = expected ?? counts;
+        if (this.programRowCount > 0 &&
+            this.#slugs.size ===
+                this.programRowCount * this.#activeAppLocales.length &&
+            expectedRoots.size === this.#roots.size &&
+            [...expectedRoots].every((root) => this.#roots.has(root)) &&
+            countIdentity(counts) === countIdentity(expectedCounts)) {
+            return Effect.void;
+        }
+        return Effect.fail(new ProgramDigestError({
+            code: "count",
+            identity: JSON.stringify({
+                actual: counts,
+                expected,
+                rootCount: this.#roots.size,
+            }),
+        }));
+    }
+    /** Consumes the complete canonical stream digest. */
+    digest() {
+        return Effect.try({
+            catch: () => new ProgramRowHashError({ scope: "digest" }),
+            try: () => Sha256HashSchema.make(`sha256:${this.#hash.digest("hex")}`),
+        });
+    }
+    /** Adds one catalog row before any current curriculum records. */
+    #addProgram(record) {
+        const { row } = record;
+        const translationLocales = row.translations.map((translation) => translation.appLocale);
+        if (this.curriculumRowCount > 0 ||
+            row.displayOrder <= this.#lastProgramOrder) {
+            return Effect.fail(new ProgramDigestError({ code: "order", identity: row.key }));
+        }
+        if (this.#programs.has(row.key) ||
+            JSON.stringify(translationLocales) !==
+                JSON.stringify(this.#activeAppLocales)) {
+            return Effect.fail(new ProgramDigestError({ code: "key", identity: row.key }));
+        }
+        for (const translation of row.translations) {
+            const slug = `${translation.appLocale}\0${translation.publicSlug}`;
+            if (this.#slugs.has(slug)) {
+                return Effect.fail(new ProgramDigestError({ code: "slug", identity: slug }));
+            }
+            this.#slugs.add(slug);
+        }
+        this.#programs.set(row.key, row);
+        this.#lastProgramOrder = row.displayOrder;
+        this.programRowCount += 1;
+        return this.#updateDigest(record);
+    }
+    /** Adds one localized route after validating identity and ancestry. */
+    #addCurriculum(record) {
+        const { row } = record;
+        const program = this.#programs.get(row.programKey);
+        if (!this.#activeAppLocales.includes(row.appLocale) ||
+            program?.navigation.model !== "curriculum-tree") {
+            return Effect.fail(new ProgramDigestError({ code: "program", identity: row.programKey }));
+        }
+        const orderKey = `${row.programKey}\0${row.appLocale}\0${row.publicPath}`;
+        if (this.#lastCurriculumKey !== undefined &&
+            compareCodeUnits(this.#lastCurriculumKey, orderKey) >= 0) {
+            return Effect.fail(new ProgramDigestError({ code: "order", identity: orderKey }));
+        }
+        const pathIdentity = `${row.programKey}\0${row.appLocale}\0${row.publicPath}`;
+        const routeIdentity = `${row.appLocale}\0${row.publicPath}`;
+        const nodeIdentity = `${row.programKey}\0${row.appLocale}\0${row.nodeKey}`;
+        if (this.#nodes.has(nodeIdentity) ||
+            this.#paths.has(pathIdentity) ||
+            this.#routes.has(routeIdentity)) {
+            return Effect.fail(new ProgramDigestError({ code: "route", identity: routeIdentity }));
+        }
+        if (row.parentPath === undefined) {
+            const rootIdentity = `${row.programKey}\0${row.appLocale}`;
+            if (!isExactProgramRoot(row, program)) {
+                return Effect.fail(new ProgramDigestError({ code: "root", identity: rootIdentity }));
+            }
+            this.#roots.add(rootIdentity);
+        }
+        else if (!this.#paths.has(`${row.programKey}\0${row.appLocale}\0${row.parentPath}`)) {
+            return Effect.fail(new ProgramDigestError({ code: "parent", identity: nodeIdentity }));
+        }
+        this.#lastCurriculumKey = orderKey;
+        this.#nodes.add(nodeIdentity);
+        this.#paths.add(pathIdentity);
+        this.#routes.add(routeIdentity);
+        this.curriculumRowCount += 1;
+        this.sitemapCount += row.sitemap ? 1 : 0;
+        return this.#updateDigest(record);
+    }
+    /** Adds canonical current record bytes and their authenticated row hash. */
+    #updateDigest(record) {
+        return Effect.try({
+            catch: () => new ProgramRowHashError({ scope: "digest" }),
+            try: () => {
+                this.#hash
+                    .update(canonicalizeProgramSnapshotRow(record))
+                    .update("\0")
+                    .update(record.rowHash)
+                    .update("\n");
+            },
+        });
+    }
+}
+/** Verifies one current row hash before advancing aggregate state. */
+const updateProgramDigest = Effect.fn("AksaraContracts.updateProgramDigest")(function* (state, record) {
+    const expected = yield* verifyProgramSnapshotRowHash(record);
+    if (expected !== record.rowHash) {
+        return yield* new ProgramDigestError({
+            code: "integrity",
+            identity: record.kind === "program" ? record.row.key : record.row.publicPath,
+        });
+    }
+    yield* state.add(record);
+});
+/** Digests a complete current program snapshot under its active locale set. */
+export const digestProgramRows = Effect.fn("AksaraContracts.digestProgramRows")(function* (input) {
+    const state = yield* Effect.try({
+        catch: () => new ProgramRowHashError({ scope: "digest" }),
+        try: () => new ProgramDigestState(input.activeAppLocales),
+    });
+    yield* input.rows.pipe(Stream.runForEach((record) => updateProgramDigest(state, record)));
+    yield* state.validateComplete(input.expected);
+    const rowDigest = yield* state.digest();
+    return { ...state.counts(), rowDigest };
+});

package/dist/program/snapshot/hash.d.ts

@@ -0,0 +1,31 @@
+import { Effect, Schema } from "effect";
+import { type ProgramSnapshot, type ProgramSnapshotFacts } from "#contracts/program/snapshot/spec";
+declare const ProgramSnapshotHashError_base: Schema.Class<ProgramSnapshotHashError, Schema.TaggedStruct<"ProgramSnapshotHashError", {}>, import("effect/Cause").YieldableError>;
+/** Node could not compute a deterministic program snapshot identity. */
+export declare class ProgramSnapshotHashError extends ProgramSnapshotHashError_base {
+}
+/** Serializes current program facts in stable signed field order. */
+export declare function canonicalizeProgramSnapshot(input: ProgramSnapshotFacts): string;
+/** Creates the content-addressed identity of one complete program snapshot. */
+export declare const makeProgramSnapshot: (input: {
+    readonly curriculumRowCount: number;
+    readonly programRowCount: number;
+    readonly rowCount: number;
+    readonly sitemapCount: number;
+    readonly slugCount: number;
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}) => Effect.Effect<{
+    readonly curriculumRowCount: number;
+    readonly programRowCount: number;
+    readonly rowCount: number;
+    readonly sitemapCount: number;
+    readonly slugCount: number;
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly format: "localized-program-snapshot";
+    readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, ProgramSnapshotHashError, never>;
+/** Recomputes the content identity of one stored current snapshot. */
+export declare function verifyProgramSnapshotHash(snapshot: ProgramSnapshot): Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, ProgramSnapshotHashError, never>;
+export {};

package/dist/program/snapshot/hash.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { PROGRAM_SNAPSHOT_FORMAT, ProgramSnapshotSchema, } from "#contracts/program/snapshot/spec";
+const SNAPSHOT_DOMAIN = "nakafa.aksara.localized-program-snapshot";
+/** Node could not compute a deterministic program snapshot identity. */
+export class ProgramSnapshotHashError extends Schema.TaggedError()("ProgramSnapshotHashError", {}) {
+}
+/** Serializes current program facts in stable signed field order. */
+export function canonicalizeProgramSnapshot(input) {
+    return JSON.stringify({
+        activeAppLocales: input.activeAppLocales,
+        curriculumRowCount: input.curriculumRowCount,
+        format: PROGRAM_SNAPSHOT_FORMAT,
+        programRowCount: input.programRowCount,
+        rowCount: input.rowCount,
+        rowDigest: input.rowDigest,
+        sitemapCount: input.sitemapCount,
+        slugCount: input.slugCount,
+    });
+}
+/** Creates the content-addressed identity of one complete program snapshot. */
+export const makeProgramSnapshot = Effect.fn("AksaraContracts.makeProgramSnapshot")((input) => Effect.try({
+    catch: () => new ProgramSnapshotHashError(),
+    try: () => {
+        const snapshotId = Sha256HashSchema.make(`sha256:${createHash("sha256")
+            .update(`${SNAPSHOT_DOMAIN}\n${canonicalizeProgramSnapshot(input)}`)
+            .digest("hex")}`);
+        return ProgramSnapshotSchema.make({
+            ...input,
+            format: PROGRAM_SNAPSHOT_FORMAT,
+            snapshotId,
+        });
+    },
+}));
+/** Recomputes the content identity of one stored current snapshot. */
+export function verifyProgramSnapshotHash(snapshot) {
+    const { format: _format, snapshotId: _snapshotId, ...facts } = snapshot;
+    return makeProgramSnapshot(facts).pipe(Effect.map((value) => value.snapshotId));
+}

package/dist/program/snapshot/row-hash.d.ts

@@ -0,0 +1,155 @@
+import { Effect, Schema } from "effect";
+import { type ProgramSnapshotRow } from "#contracts/program/snapshot/row";
+declare const ProgramRowHashError_base: Schema.Class<ProgramRowHashError, Schema.TaggedStruct<"ProgramRowHashError", {
+    readonly scope: Schema.Literals<readonly ["digest", "row"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Node could not compute one deterministic program row identity. */
+export declare class ProgramRowHashError extends ProgramRowHashError_base {
+}
+/** Creates one authenticated current program record. */
+export declare const makeProgramSnapshotRow: (row: {
+    readonly defaultCoverageStatus: "archived" | "available" | "hidden" | "partial" | "planned";
+    readonly displayOrder: number;
+    readonly iconKey: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state";
+    readonly key: string & import("effect/Brand").Brand<"@NakafaAI/AksaraLearningProgramKey">;
+    readonly kind: "admission-exam" | "assessment" | "custom-program" | "institution-program" | "school-curriculum";
+    readonly navigation: {
+        readonly levels: readonly ["class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit", ...("class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit")[]];
+        readonly model: "course-unit-lesson" | "curriculum-tree" | "exam-domain-set" | "track-topic";
+    };
+    readonly provider: {
+        readonly homeCountry?: string | undefined;
+        readonly kind: "institution" | "learner" | "nakafa" | "official";
+        readonly name: string;
+    };
+    readonly recommendedCountry?: string | undefined;
+    readonly sources: readonly [{
+        readonly label: string;
+        readonly retrievedAt: string;
+        readonly reviewAfter?: string | undefined;
+        readonly type: "institution-document" | "nakafa-editorial" | "official-blueprint" | "official-policy" | "official-portal";
+        readonly url: string;
+    }, ...{
+        readonly label: string;
+        readonly retrievedAt: string;
+        readonly reviewAfter?: string | undefined;
+        readonly type: "institution-document" | "nakafa-editorial" | "official-blueprint" | "official-policy" | "official-portal";
+        readonly url: string;
+    }[]];
+    readonly translations: readonly [{
+        readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+        readonly publicSlug: string;
+        readonly title: string;
+    }, ...{
+        readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+        readonly publicSlug: string;
+        readonly title: string;
+    }[]];
+    readonly version: {
+        readonly endsAt?: string | undefined;
+        readonly label: string;
+        readonly startsAt?: string | undefined;
+    };
+}) => Effect.Effect<{
+    readonly kind: "program";
+    readonly row: {
+        readonly defaultCoverageStatus: "archived" | "available" | "hidden" | "partial" | "planned";
+        readonly displayOrder: number;
+        readonly iconKey: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state";
+        readonly key: string & import("effect/Brand").Brand<"@NakafaAI/AksaraLearningProgramKey">;
+        readonly kind: "admission-exam" | "assessment" | "custom-program" | "institution-program" | "school-curriculum";
+        readonly navigation: {
+            readonly levels: readonly ["class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit", ...("class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit")[]];
+            readonly model: "course-unit-lesson" | "curriculum-tree" | "exam-domain-set" | "track-topic";
+        };
+        readonly provider: {
+            readonly homeCountry?: string | undefined;
+            readonly kind: "institution" | "learner" | "nakafa" | "official";
+            readonly name: string;
+        };
+        readonly recommendedCountry?: string | undefined;
+        readonly sources: readonly [{
+            readonly label: string;
+            readonly retrievedAt: string;
+            readonly reviewAfter?: string | undefined;
+            readonly type: "institution-document" | "nakafa-editorial" | "official-blueprint" | "official-policy" | "official-portal";
+            readonly url: string;
+        }, ...{
+            readonly label: string;
+            readonly retrievedAt: string;
+            readonly reviewAfter?: string | undefined;
+            readonly type: "institution-document" | "nakafa-editorial" | "official-blueprint" | "official-policy" | "official-portal";
+            readonly url: string;
+        }[]];
+        readonly translations: readonly [{
+            readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+            readonly publicSlug: string;
+            readonly title: string;
+        }, ...{
+            readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+            readonly publicSlug: string;
+            readonly title: string;
+        }[]];
+        readonly version: {
+            readonly endsAt?: string | undefined;
+            readonly label: string;
+            readonly startsAt?: string | undefined;
+        };
+    };
+    readonly rowHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, ProgramRowHashError, never>;
+/** Creates one authenticated current curriculum record. */
+export declare const makeCurriculumSnapshotRow: (row: {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly canonicalPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+    readonly displayGroupIconKey?: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state" | undefined;
+    readonly displayGroupTitle?: string | undefined;
+    readonly iconKey: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state";
+    readonly kind: "curriculum-context";
+    readonly level: "class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit";
+    readonly materialCardDescription?: string | undefined;
+    readonly materialCardTitle?: string | undefined;
+    readonly materialContextNodeKey?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraCurriculumNodeKey">) | undefined;
+    readonly materialContextParentPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+    readonly materialContextPublicPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+    readonly materialDomain?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialDomain">) | undefined;
+    readonly materialKey?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialKey">) | undefined;
+    readonly nodeKey: string;
+    readonly order: number;
+    readonly parentPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+    readonly programKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraLearningProgramKey">;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly sitemap: boolean;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+    readonly title: string;
+}) => Effect.Effect<{
+    readonly kind: "curriculum";
+    readonly row: {
+        readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+        readonly canonicalPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+        readonly displayGroupIconKey?: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state" | undefined;
+        readonly displayGroupTitle?: string | undefined;
+        readonly iconKey: "advanced" | "assessment" | "certificate" | "course" | "diploma" | "early-years" | "global-education" | "grade-1" | "grade-10" | "grade-11" | "grade-12" | "grade-2" | "grade-3" | "grade-4" | "grade-5" | "grade-6" | "grade-7" | "grade-8" | "grade-9" | "high-school" | "mathematics" | "middle-school" | "primary-school" | "school" | "science" | "standards" | "state";
+        readonly kind: "curriculum-context";
+        readonly level: "class" | "course" | "domain" | "lesson" | "phase" | "section" | "set" | "stage" | "subject" | "topic" | "track" | "unit";
+        readonly materialCardDescription?: string | undefined;
+        readonly materialCardTitle?: string | undefined;
+        readonly materialContextNodeKey?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraCurriculumNodeKey">) | undefined;
+        readonly materialContextParentPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+        readonly materialContextPublicPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+        readonly materialDomain?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialDomain">) | undefined;
+        readonly materialKey?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialKey">) | undefined;
+        readonly nodeKey: string;
+        readonly order: number;
+        readonly parentPath?: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">) | undefined;
+        readonly programKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraLearningProgramKey">;
+        readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+        readonly sitemap: boolean;
+        readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+        readonly title: string;
+    };
+    readonly rowHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, ProgramRowHashError, never>;
+/** Recomputes one current row identity for streamed integrity checks. */
+export declare function verifyProgramSnapshotRowHash(record: ProgramSnapshotRow): Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, ProgramRowHashError, never>;
+export {};

package/dist/program/snapshot/row-hash.js

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { CurriculumRouteRecordSchema, canonicalizeProgramSnapshotRow, LearningProgramRecordSchema, } from "#contracts/program/snapshot/row";
+const ROW_DOMAIN = "nakafa.aksara.program-row";
+/** Node could not compute one deterministic program row identity. */
+export class ProgramRowHashError extends Schema.TaggedError()("ProgramRowHashError", { scope: Schema.Literals(["digest", "row"]) }) {
+}
+/** Hashes one current program or curriculum row. */
+function hashProgramRow(record) {
+    return Effect.try({
+        catch: () => new ProgramRowHashError({ scope: "row" }),
+        try: () => Sha256HashSchema.make(`sha256:${createHash("sha256")
+            .update(`${ROW_DOMAIN}\n${canonicalizeProgramSnapshotRow(record)}`)
+            .digest("hex")}`),
+    });
+}
+/** Creates one authenticated current program record. */
+export const makeProgramSnapshotRow = Effect.fn("AksaraContracts.makeProgramSnapshotRow")(function* (row) {
+    const input = { kind: "program", row };
+    const rowHash = yield* hashProgramRow(input);
+    return LearningProgramRecordSchema.make({ ...input, rowHash });
+});
+/** Creates one authenticated current curriculum record. */
+export const makeCurriculumSnapshotRow = Effect.fn("AksaraContracts.makeCurriculumSnapshotRow")(function* (row) {
+    const input = { kind: "curriculum", row };
+    const rowHash = yield* hashProgramRow(input);
+    return CurriculumRouteRecordSchema.make({ ...input, rowHash });
+});
+/** Recomputes one current row identity for streamed integrity checks. */
+export function verifyProgramSnapshotRowHash(record) {
+    const { rowHash: _rowHash, ...input } = record;
+    return hashProgramRow(input);
+}