@nakafa/aksara-contracts 0.27.0

package/dist/quran/provenance.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { ActiveAppLocaleListSchema, AppLocaleSchema, ENGLISH_APP_LOCALE_CODE, GERMAN_APP_LOCALE_CODE, INDONESIAN_APP_LOCALE_CODE, } from "#contracts/locale";
+import { canonicalizeQuranAttribution } from "#contracts/quran/attribution";
+import { QuranNameProvenanceScopeSchema, QuranTranslationProvenanceScopeSchema, quranNameProvenanceScope, quranNameSourceForScope, quranTafsirSourceId, quranTranslationProvenanceScope, quranTranslationSourceForScope, } from "#contracts/quran/identity";
+import { QuranProvenanceStatusSchema } from "#contracts/quran/snapshot/spec";
+import { hasCompleteQuranSourceCopy, QuranSourceAttributionSchema, } from "#contracts/quran/source";
+/** Quran source fields that require independent provenance decisions. */
+const QuranStaticProvenanceScopeSchema = Schema.Literals([
+    "arabic-text",
+    "metadata",
+]);
+const QuranExternalTafsirProvenanceScopeSchema = Schema.Literals([
+    "en-tafsir-access",
+    "de-tafsir-access",
+]);
+const QuranNonTranslationProvenanceScopeSchema = Schema.Union([
+    QuranStaticProvenanceScopeSchema,
+    QuranExternalTafsirProvenanceScopeSchema,
+    Schema.Literal("id-tafsir"),
+]);
+/** Complete source-field vocabulary supported by current Quran publication. */
+export const QuranProvenanceScopeSchema = Schema.Union([
+    QuranNonTranslationProvenanceScopeSchema,
+    QuranNameProvenanceScopeSchema,
+    QuranTranslationProvenanceScopeSchema,
+]);
+/** Derives the exact provenance scope order for one active locale set. */
+export function quranProvenanceScopes(activeAppLocales) {
+    const scopes = ["arabic-text"];
+    for (const appLocale of activeAppLocales) {
+        scopes.push(quranNameProvenanceScope(appLocale));
+        scopes.push(quranTranslationProvenanceScope(appLocale));
+        if (appLocale === AppLocaleSchema.make("en")) {
+            scopes.push("en-tafsir-access");
+        }
+        else if (appLocale === AppLocaleSchema.make("id")) {
+            scopes.push("id-tafsir");
+        }
+        else {
+            scopes.push("de-tafsir-access");
+        }
+    }
+    scopes.push("metadata");
+    return scopes;
+}
+const QURAN_STATIC_PROVENANCE_SOURCE = {
+    "arabic-text": "tanzil-text",
+    "de-tafsir-access": quranTafsirSourceId(GERMAN_APP_LOCALE_CODE),
+    "en-tafsir-access": quranTafsirSourceId(ENGLISH_APP_LOCALE_CODE),
+    "id-tafsir": quranTafsirSourceId(INDONESIAN_APP_LOCALE_CODE),
+    metadata: "tanzil-metadata",
+};
+/** Resolves the only official source allowed to prove one provenance scope. */
+export function quranSourceForProvenanceScope(scope) {
+    if (Schema.is(QuranTranslationProvenanceScopeSchema)(scope)) {
+        return quranTranslationSourceForScope(scope);
+    }
+    if (Schema.is(QuranNameProvenanceScopeSchema)(scope)) {
+        return quranNameSourceForScope(scope);
+    }
+    return QURAN_STATIC_PROVENANCE_SOURCE[scope];
+}
+/** One reviewed official artifact and its field-level permission decision. */
+export const QuranProvenanceRecordSchema = Schema.Struct({
+    attribution: QuranSourceAttributionSchema,
+    evidence: Schema.Trimmed.check(Schema.isNonEmpty()),
+    scope: QuranProvenanceScopeSchema,
+    status: QuranProvenanceStatusSchema,
+}).pipe(Schema.check(Schema.makeFilter(({ attribution, scope }) => attribution.id === quranSourceForProvenanceScope(scope), { message: "Expected each Quran scope to bind its official source." })));
+/** Checks exact active-locale coverage and canonical scope order. */
+function hasCanonicalSourceCoverage(input) {
+    const expected = quranProvenanceScopes(input.activeAppLocales);
+    return (input.records.length === expected.length &&
+        input.records.every((record, index) => record.scope === expected[index] &&
+            record.attribution.id === quranSourceForProvenanceScope(record.scope) &&
+            hasCompleteQuranSourceCopy(record.attribution, input.activeAppLocales)));
+}
+/** Checks that the declared gate status matches every reviewed record. */
+function hasCoherentProvenanceStatus(input) {
+    const expected = input.records.some((record) => record.status === "blocked")
+        ? "blocked"
+        : "approved";
+    return input.status === expected;
+}
+/** Complete ordered evidence set that gates Quran production publication. */
+export const QuranProvenanceManifestSchema = Schema.Struct({
+    activeAppLocales: ActiveAppLocaleListSchema,
+    digest: Sha256HashSchema,
+    records: Schema.NonEmptyArray(QuranProvenanceRecordSchema),
+    status: QuranProvenanceStatusSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCanonicalSourceCoverage, {
+    message: "Expected exact active-locale Quran provenance scope coverage.",
+})), Schema.check(Schema.makeFilter(hasCoherentProvenanceStatus, {
+    message: "Expected Quran provenance status to match its complete evidence.",
+})));
+/** Quran provenance omitted or misordered an active-locale scope. */
+export class QuranProvenanceCoverageError extends Schema.TaggedError()("QuranProvenanceCoverageError", {
+    actualScopes: Schema.Array(QuranProvenanceScopeSchema),
+}) {
+}
+/** Node could not compute the deterministic provenance digest. */
+export class QuranProvenanceHashError extends Schema.TaggedError()("QuranProvenanceHashError", {}) {
+}
+const PROVENANCE_DOMAIN = "nakafa.aksara.quran-provenance";
+/** Produces stable JSON for one reviewed Quran provenance record. */
+export function canonicalizeQuranProvenance(record) {
+    return JSON.stringify({
+        attribution: canonicalizeQuranAttribution(record.attribution),
+        evidence: record.evidence,
+        scope: record.scope,
+        status: record.status,
+    });
+}
+/** Digests exact ordered provenance records under their active locale set. */
+export const hashQuranProvenance = Effect.fn("AksaraContracts.hashQuranProvenance")((input) => Effect.try({
+    catch: () => new QuranProvenanceHashError(),
+    try: () => {
+        const hash = createHash("sha256")
+            .update(`${PROVENANCE_DOMAIN}\n`)
+            .update(JSON.stringify(input.activeAppLocales))
+            .update("\n");
+        for (const record of input.records) {
+            hash.update(canonicalizeQuranProvenance(record));
+            hash.update("\n");
+        }
+        return Sha256HashSchema.make(`sha256:${hash.digest("hex")}`);
+    },
+}));
+/** Builds a snapshot provenance gate from exact reviewed source records. */
+export const makeQuranProvenanceManifest = Effect.fn("AksaraContracts.makeQuranProvenanceManifest")(function* (input) {
+    const decoded = yield* Schema.decodeUnknownEffect(Schema.Struct({
+        activeAppLocales: ActiveAppLocaleListSchema,
+        records: Schema.NonEmptyArray(QuranProvenanceRecordSchema),
+    }).pipe(Schema.check(Schema.makeFilter(hasCanonicalSourceCoverage))))(input).pipe(Effect.mapError(() => new QuranProvenanceCoverageError({
+        actualScopes: input.records.map(({ scope }) => scope),
+    })));
+    const digest = yield* hashQuranProvenance(decoded);
+    const status = decoded.records.some((record) => record.status === "blocked")
+        ? "blocked"
+        : "approved";
+    return QuranProvenanceManifestSchema.make({ ...decoded, digest, status });
+});

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

@@ -0,0 +1,33 @@
+import { Effect, Schema, Stream } from "effect";
+import type { ActiveAppLocaleList } from "#contracts/locale";
+import type { QuranSnapshotRow } from "#contracts/quran/snapshot/row";
+import { QuranRowHashError } from "#contracts/quran/snapshot/row/hash";
+declare const QuranRowIntegrityError_base: Schema.Class<QuranRowIntegrityError, Schema.TaggedStruct<"QuranRowIntegrityError", {
+    readonly actual: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expected: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** A current row hash does not authenticate its structured payload. */
+export declare class QuranRowIntegrityError extends QuranRowIntegrityError_base {
+}
+declare const QuranRowOrderError_base: Schema.Class<QuranRowOrderError, Schema.TaggedStruct<"QuranRowOrderError", {
+    readonly actual: Schema.String;
+    readonly expected: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A current row does not match the next deterministic snapshot identity. */
+export declare class QuranRowOrderError extends QuranRowOrderError_base {
+}
+/** Digests authenticated current rows under one active locale set. */
+export declare const digestQuranRows: <E, R>(input: {
+    readonly activeAppLocales: ActiveAppLocaleList;
+    readonly rows: Stream.Stream<Pick<QuranSnapshotRow, "payload" | "rowHash">, E, R>;
+}) => Effect.Effect<{
+    attributionCount: number;
+    chunkCount: number;
+    projectionCount: number;
+    projectionDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    runtimeCount: number;
+    runtimeDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    searchCount: number;
+    searchDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, E | QuranRowHashError | QuranRowIntegrityError | QuranRowOrderError, R>;
+export {};

package/dist/quran/snapshot/digest.js

@@ -0,0 +1,232 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema, Stream } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { AppLocaleSchema } from "#contracts/locale";
+import { hashQuranRow, QuranRowHashError, } from "#contracts/quran/snapshot/row/hash";
+import { quranSourceIds } from "#contracts/quran/source";
+import { QURAN_ATTRIBUTION_COUNT, QURAN_CHUNK_SIZE, QURAN_SURAH_COUNT, QURAN_VERSE_COUNT, } from "#contracts/quran/spec";
+const RUNTIME_DOMAIN = "nakafa.aksara.quran-runtime";
+const SEARCH_DOMAIN = "nakafa.aksara.quran-search";
+const PROJECTION_DOMAIN = "nakafa.aksara.quran-projection";
+/** A current row hash does not authenticate its structured payload. */
+export class QuranRowIntegrityError extends Schema.TaggedError()("QuranRowIntegrityError", {
+    actual: Sha256HashSchema,
+    expected: Sha256HashSchema,
+}) {
+}
+/** A current row does not match the next deterministic snapshot identity. */
+export class QuranRowOrderError extends Schema.TaggedError()("QuranRowOrderError", {
+    actual: Schema.String,
+    expected: Schema.String,
+}) {
+}
+/** Resolves one complete stable current row identity. */
+function rowIdentity(payload) {
+    if (payload.kind === "quran-attribution") {
+        return `quran-attribution:${payload.activeAppLocales.join(",")}:${payload.sources.map(({ id }) => id).join(":")}`;
+    }
+    if (payload.kind === "quran-surah") {
+        return `quran-surah:${payload.number}`;
+    }
+    if (payload.kind === "quran-chunk") {
+        return [
+            "quran-chunk",
+            payload.surahNumber,
+            payload.firstVerse,
+            payload.lastVerse,
+            payload.firstQuranNumber,
+        ].join(":");
+    }
+    return [
+        "quran-search",
+        payload.surahNumber,
+        payload.appLocale,
+        payload.route,
+        payload.graph.alignmentId,
+        payload.graph.assetId,
+        payload.graph.conceptId,
+        payload.graph.learningObjectId,
+        payload.graph.lensId,
+    ].join(":");
+}
+/** Keeps current locale closure and digest state private to one replay. */
+class QuranDigestState {
+    #activeAppLocales;
+    #runtime = createHash("sha256").update(`${RUNTIME_DOMAIN}\n`);
+    #search = createHash("sha256").update(`${SEARCH_DOMAIN}\n`);
+    #projection = createHash("sha256").update(`${PROJECTION_DOMAIN}\n`);
+    #nextQuranNumber = 1;
+    #nextSearchLocale;
+    #nextSearchSurah = 1;
+    #nextSurah = 1;
+    #nextSurahVerse = 0;
+    #surahVerseCount = 0;
+    attributionCount = 0;
+    chunkCount = 0;
+    projectionCount = 0;
+    runtimeCount = 0;
+    searchCount = 0;
+    /** Initializes one isolated replay under the signed active locale set. */
+    constructor(activeAppLocales) {
+        this.#activeAppLocales = activeAppLocales;
+        this.#nextSearchLocale = activeAppLocales[0];
+    }
+    /** Returns the only row identity valid at the current stream position. */
+    expectedIdentity() {
+        if (this.attributionCount === 0) {
+            return `quran-attribution:${this.#activeAppLocales.join(",")}:${quranSourceIds(this.#activeAppLocales).join(":")}`;
+        }
+        if (this.#nextSurah <= QURAN_SURAH_COUNT) {
+            if (this.#nextSurahVerse === 0) {
+                return `quran-surah:${this.#nextSurah}`;
+            }
+            const lastVerse = Math.min(this.#nextSurahVerse + QURAN_CHUNK_SIZE - 1, this.#surahVerseCount);
+            return [
+                "quran-chunk",
+                this.#nextSurah,
+                this.#nextSurahVerse,
+                lastVerse,
+                this.#nextQuranNumber,
+            ].join(":");
+        }
+        if (this.#nextSearchSurah <= QURAN_SURAH_COUNT) {
+            return [
+                "quran-search",
+                this.#nextSearchSurah,
+                this.#nextSearchLocale,
+                `quran/${this.#nextSearchSurah}`,
+                `alignment:quran:quran-surah:${this.#nextSearchSurah}`,
+                `asset:${this.#nextSearchLocale}:quran:quran-surah:${this.#nextSearchSurah}`,
+                `concept:quran:surah:${this.#nextSearchSurah}`,
+                `lo:quran-surah:${this.#nextSearchSurah}`,
+                "lens:quran",
+            ].join(":");
+        }
+        return "end";
+    }
+    /** Checks translation and Tafsir entries against active locale policy. */
+    validateVerseLocales(payload) {
+        if (payload.kind !== "quran-chunk") {
+            return true;
+        }
+        const expectedTafsir = this.#activeAppLocales.includes(AppLocaleSchema.make("id"))
+            ? ["id"]
+            : [];
+        return payload.verses.every((verse) => JSON.stringify(verse.translations.map((translation) => translation.appLocale)) === JSON.stringify(this.#activeAppLocales) &&
+            JSON.stringify(verse.tafsir.map((tafsir) => tafsir.appLocale)) ===
+                JSON.stringify(expectedTafsir));
+    }
+    /** Advances deterministic identity state after one accepted row. */
+    advance(payload) {
+        if (payload.kind === "quran-attribution") {
+            return;
+        }
+        if (payload.kind === "quran-surah") {
+            this.#surahVerseCount = payload.numberOfVerses;
+            this.#nextSurahVerse = 1;
+            return;
+        }
+        if (payload.kind === "quran-chunk") {
+            this.#nextQuranNumber = payload.firstQuranNumber + payload.verses.length;
+            if (payload.lastVerse === this.#surahVerseCount) {
+                this.#nextSurah += 1;
+                this.#nextSurahVerse = 0;
+                return;
+            }
+            this.#nextSurahVerse = payload.lastVerse + 1;
+            return;
+        }
+        const localeIndex = this.#activeAppLocales.indexOf(this.#nextSearchLocale);
+        const nextLocale = this.#activeAppLocales[localeIndex + 1];
+        if (nextLocale !== undefined) {
+            this.#nextSearchLocale = nextLocale;
+            return;
+        }
+        this.#nextSearchLocale = this.#activeAppLocales[0];
+        this.#nextSearchSurah += 1;
+    }
+    /** Adds one authenticated and correctly ordered row to all digests. */
+    update(row) {
+        const expected = this.expectedIdentity();
+        const actual = rowIdentity(row.payload);
+        if (actual !== expected || !this.validateVerseLocales(row.payload)) {
+            return Effect.fail(new QuranRowOrderError({ actual, expected }));
+        }
+        this.advance(row.payload);
+        const canonical = `${row.payload.kind}\n${row.rowHash}\n`;
+        return Effect.try({
+            catch: () => new QuranRowHashError({ scope: "row" }),
+            try: () => {
+                this.#projection.update(canonical);
+                this.projectionCount += 1;
+                if (row.payload.kind === "quran-search") {
+                    this.#search.update(canonical);
+                    this.searchCount += 1;
+                    return;
+                }
+                this.#runtime.update(canonical);
+                this.runtimeCount += 1;
+                if (row.payload.kind === "quran-attribution") {
+                    this.attributionCount += 1;
+                }
+                if (row.payload.kind === "quran-chunk") {
+                    this.chunkCount += 1;
+                }
+            },
+        });
+    }
+    /** Rejects an incomplete stream before consuming digest state. */
+    validateComplete() {
+        const expectedSearchCount = QURAN_SURAH_COUNT * this.#activeAppLocales.length;
+        if (this.expectedIdentity() === "end" &&
+            this.#nextQuranNumber === QURAN_VERSE_COUNT + 1 &&
+            this.attributionCount === QURAN_ATTRIBUTION_COUNT &&
+            this.runtimeCount ===
+                QURAN_ATTRIBUTION_COUNT + QURAN_SURAH_COUNT + this.chunkCount &&
+            this.searchCount === expectedSearchCount &&
+            this.projectionCount === this.runtimeCount + this.searchCount) {
+            return Effect.void;
+        }
+        return Effect.fail(new QuranRowOrderError({
+            actual: this.expectedIdentity(),
+            expected: "end",
+        }));
+    }
+    /** Finalizes all ordered current Quran digest domains. */
+    digest() {
+        return {
+            attributionCount: this.attributionCount,
+            chunkCount: this.chunkCount,
+            projectionCount: this.projectionCount,
+            projectionDigest: Sha256HashSchema.make(`sha256:${this.#projection.digest("hex")}`),
+            runtimeCount: this.runtimeCount,
+            runtimeDigest: Sha256HashSchema.make(`sha256:${this.#runtime.digest("hex")}`),
+            searchCount: this.searchCount,
+            searchDigest: Sha256HashSchema.make(`sha256:${this.#search.digest("hex")}`),
+        };
+    }
+}
+/** Authenticates one current row before advancing ordered state. */
+const updateQuranDigest = Effect.fn("AksaraContracts.updateQuranDigest")(function* (state, row) {
+    const expected = yield* hashQuranRow(row.payload);
+    if (expected !== row.rowHash) {
+        return yield* new QuranRowIntegrityError({
+            actual: row.rowHash,
+            expected,
+        });
+    }
+    yield* state.update(row);
+});
+/** Digests authenticated current rows under one active locale set. */
+export const digestQuranRows = Effect.fn("AksaraContracts.digestQuranRows")(function* (input) {
+    const state = yield* Effect.try({
+        catch: () => new QuranRowHashError({ scope: "row" }),
+        try: () => new QuranDigestState(input.activeAppLocales),
+    });
+    yield* input.rows.pipe(Stream.runForEach((row) => updateQuranDigest(state, row)));
+    yield* state.validateComplete();
+    return yield* Effect.try({
+        catch: () => new QuranRowHashError({ scope: "row" }),
+        try: () => state.digest(),
+    });
+});

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

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect";
+import { type QuranSnapshot, type QuranSnapshotFacts } from "#contracts/quran/snapshot/spec";
+declare const QuranSnapshotHashError_base: Schema.Class<QuranSnapshotHashError, Schema.TaggedStruct<"QuranSnapshotHashError", {}>, import("effect/Cause").YieldableError>;
+/** Node could not compute a deterministic Quran snapshot identity. */
+export declare class QuranSnapshotHashError extends QuranSnapshotHashError_base {
+}
+/** Serializes Quran snapshot facts in stable signed field order. */
+export declare function canonicalizeQuranSnapshot(input: QuranSnapshotFacts): string;
+/** Creates the content-addressed identity of one complete Quran snapshot. */
+export declare const makeQuranSnapshot: (input: {
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly attributionCount: number;
+    readonly chunkCount: number;
+    readonly projectionCount: number;
+    readonly projectionDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly provenanceDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly provenanceStatus: "approved" | "blocked";
+    readonly runtimeCount: number;
+    readonly runtimeDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly searchCount: number;
+    readonly searchDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly sourceBytes: number;
+    readonly sourceDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly sourceFileCount: number;
+    readonly surahCount: number;
+    readonly tafsirLocales: readonly "id"[];
+    readonly verseCount: number;
+}) => Effect.Effect<{
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly attributionCount: number;
+    readonly chunkCount: number;
+    readonly projectionCount: number;
+    readonly projectionDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly provenanceDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly provenanceStatus: "approved" | "blocked";
+    readonly runtimeCount: number;
+    readonly runtimeDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly searchCount: number;
+    readonly searchDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly sourceBytes: number;
+    readonly sourceDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly sourceFileCount: number;
+    readonly surahCount: number;
+    readonly tafsirLocales: readonly "id"[];
+    readonly verseCount: number;
+    readonly format: "localized-quran-snapshot";
+    readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, QuranSnapshotHashError, never>;
+/** Recomputes the content identity of one stored current snapshot. */
+export declare function verifyQuranSnapshotHash(snapshot: QuranSnapshot): Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, QuranSnapshotHashError, never>;
+export {};

package/dist/quran/snapshot/hash.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { QURAN_SNAPSHOT_FORMAT, QuranSnapshotSchema, } from "#contracts/quran/snapshot/spec";
+const SNAPSHOT_DOMAIN = "nakafa.aksara.localized-quran-snapshot";
+/** Node could not compute a deterministic Quran snapshot identity. */
+export class QuranSnapshotHashError extends Schema.TaggedError()("QuranSnapshotHashError", {}) {
+}
+/** Serializes Quran snapshot facts in stable signed field order. */
+export function canonicalizeQuranSnapshot(input) {
+    return JSON.stringify({
+        activeAppLocales: input.activeAppLocales,
+        attributionCount: input.attributionCount,
+        chunkCount: input.chunkCount,
+        format: QURAN_SNAPSHOT_FORMAT,
+        projectionCount: input.projectionCount,
+        projectionDigest: input.projectionDigest,
+        provenanceDigest: input.provenanceDigest,
+        provenanceStatus: input.provenanceStatus,
+        runtimeCount: input.runtimeCount,
+        runtimeDigest: input.runtimeDigest,
+        searchCount: input.searchCount,
+        searchDigest: input.searchDigest,
+        sourceBytes: input.sourceBytes,
+        sourceDigest: input.sourceDigest,
+        sourceFileCount: input.sourceFileCount,
+        surahCount: input.surahCount,
+        tafsirLocales: input.tafsirLocales,
+        verseCount: input.verseCount,
+    });
+}
+/** Creates the content-addressed identity of one complete Quran snapshot. */
+export const makeQuranSnapshot = Effect.fn("AksaraContracts.makeQuranSnapshot")((input) => Effect.try({
+    catch: () => new QuranSnapshotHashError(),
+    try: () => {
+        const snapshotId = Sha256HashSchema.make(`sha256:${createHash("sha256")
+            .update(`${SNAPSHOT_DOMAIN}\n${canonicalizeQuranSnapshot(input)}`)
+            .digest("hex")}`);
+        return QuranSnapshotSchema.make({
+            ...input,
+            format: QURAN_SNAPSHOT_FORMAT,
+            snapshotId,
+        });
+    },
+}));
+/** Recomputes the content identity of one stored current snapshot. */
+export function verifyQuranSnapshotHash(snapshot) {
+    const { format: _format, snapshotId: _snapshotId, ...facts } = snapshot;
+    return makeQuranSnapshot(facts).pipe(Effect.map((value) => value.snapshotId));
+}