@nakafa/aksara-contracts 0.27.0

package/dist/release/snapshot/data.d.ts

@@ -0,0 +1,475 @@
+/** Structured snapshot manifest and row wire contracts. */
+import { Schema } from "effect";
+/** Complete structured snapshot manifest vocabulary staged before its rows. */
+export declare const ContentSnapshotManifestSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly family: Schema.Literal<"program">;
+    readonly manifest: Schema.Struct<{
+        readonly curriculumRowCount: Schema.Int;
+        readonly programRowCount: Schema.Int;
+        readonly rowCount: Schema.Int;
+        readonly sitemapCount: Schema.Int;
+        readonly slugCount: Schema.Int;
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly format: Schema.Literal<"localized-program-snapshot">;
+        readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+}>, Schema.Struct<{
+    readonly family: Schema.Literal<"quran">;
+    readonly manifest: Schema.Struct<{
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        readonly attributionCount: Schema.Int;
+        readonly chunkCount: Schema.Int;
+        readonly projectionCount: Schema.Int;
+        readonly projectionDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly provenanceDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly provenanceStatus: Schema.Literals<readonly ["approved", "blocked"]>;
+        readonly runtimeCount: Schema.Int;
+        readonly runtimeDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly searchCount: Schema.Int;
+        readonly searchDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourceBytes: Schema.Int;
+        readonly sourceDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourceFileCount: Schema.Int;
+        readonly surahCount: Schema.Int;
+        readonly tafsirLocales: Schema.$Array<Schema.Literal<"id">>;
+        readonly verseCount: Schema.Int;
+        readonly format: Schema.Literal<"localized-quran-snapshot">;
+        readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+}>, Schema.Struct<{
+    readonly family: Schema.Literal<"tryout">;
+    readonly manifest: Schema.Struct<{
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly counts: Schema.Struct<{
+            readonly country: Schema.Int;
+            readonly exam: Schema.Int;
+            readonly section: Schema.Int;
+            readonly set: Schema.Int;
+            readonly track: Schema.Int;
+        }>;
+        readonly placementCount: Schema.Int;
+        readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly routeCount: Schema.Int;
+        readonly format: Schema.Literal<"localized-tryout-snapshot">;
+        readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+}>]>;
+export type ContentSnapshotManifest = typeof ContentSnapshotManifestSchema.Type;
+/** Complete current structured row vocabulary accepted by publication. */
+export declare const ContentSnapshotRowSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly family: Schema.Literal<"program">;
+    readonly record: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"program">;
+        readonly row: Schema.Struct<{
+            readonly defaultCoverageStatus: Schema.Literals<readonly ["archived", "available", "hidden", "partial", "planned"]>;
+            readonly displayOrder: Schema.Int;
+            readonly iconKey: Schema.Literals<readonly ["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", "science", "school", "standards", "state"]>;
+            readonly key: Schema.brand<Schema.String, "@NakafaAI/AksaraLearningProgramKey">;
+            readonly kind: Schema.Literals<readonly ["admission-exam", "assessment", "custom-program", "institution-program", "school-curriculum"]>;
+            readonly navigation: Schema.Struct<{
+                readonly levels: Schema.NonEmptyArray<Schema.Literals<readonly ["class", "course", "domain", "lesson", "phase", "section", "set", "stage", "subject", "topic", "track", "unit"]>>;
+                readonly model: Schema.Literals<readonly ["course-unit-lesson", "curriculum-tree", "exam-domain-set", "track-topic"]>;
+            }>;
+            readonly provider: Schema.Struct<{
+                readonly homeCountry: Schema.optional<Schema.String>;
+                readonly kind: Schema.Literals<readonly ["institution", "learner", "nakafa", "official"]>;
+                readonly name: Schema.Trimmed;
+            }>;
+            readonly recommendedCountry: Schema.optional<Schema.String>;
+            readonly sources: Schema.NonEmptyArray<Schema.Struct<{
+                readonly label: Schema.Trimmed;
+                readonly retrievedAt: Schema.String;
+                readonly reviewAfter: Schema.optional<Schema.String>;
+                readonly type: Schema.Literals<readonly ["institution-document", "nakafa-editorial", "official-blueprint", "official-policy", "official-portal"]>;
+                readonly url: Schema.String;
+            }>>;
+            readonly translations: Schema.NonEmptyArray<Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                readonly publicSlug: Schema.String;
+                readonly title: Schema.Trimmed;
+            }>>;
+            readonly version: Schema.Struct<{
+                readonly endsAt: Schema.optional<Schema.String>;
+                readonly label: Schema.Trimmed;
+                readonly startsAt: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly rowHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"curriculum">;
+        readonly row: Schema.Struct<{
+            appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            canonicalPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+            displayGroupIconKey: Schema.optional<Schema.Literals<readonly ["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", "science", "school", "standards", "state"]>>;
+            displayGroupTitle: Schema.optional<Schema.String>;
+            iconKey: Schema.Literals<readonly ["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", "science", "school", "standards", "state"]>;
+            kind: Schema.Literal<"curriculum-context">;
+            level: Schema.Literals<readonly ["class", "course", "domain", "lesson", "phase", "section", "set", "stage", "subject", "topic", "track", "unit"]>;
+            materialCardDescription: Schema.optional<Schema.String>;
+            materialCardTitle: Schema.optional<Schema.String>;
+            materialContextNodeKey: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraCurriculumNodeKey">>;
+            materialContextParentPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+            materialContextPublicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+            materialDomain: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialDomain">>;
+            materialKey: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialKey">>;
+            nodeKey: Schema.String;
+            order: Schema.Int;
+            parentPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+            programKey: Schema.brand<Schema.String, "@NakafaAI/AksaraLearningProgramKey">;
+            publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+            sitemap: Schema.Boolean;
+            sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+            title: Schema.String;
+        }>;
+        readonly rowHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>]>;
+}>, Schema.Struct<{
+    readonly family: Schema.Literal<"quran">;
+    readonly record: Schema.Struct<{
+        readonly payload: Schema.Union<readonly [Schema.Struct<{
+            readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+            readonly kind: Schema.Literal<"quran-attribution">;
+            readonly sources: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                    readonly notice: Schema.Trimmed;
+                    readonly title: Schema.Trimmed;
+                }>>;
+                readonly publisher: Schema.Trimmed;
+                readonly retrievedAt: Schema.String;
+                readonly sourceUrl: Schema.String;
+                readonly updateUrl: Schema.String;
+                readonly version: Schema.Trimmed;
+                readonly artifact: Schema.Struct<{
+                    readonly byteCount: Schema.Int;
+                    readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                    readonly fileCount: Schema.Int;
+                }>;
+                readonly id: Schema.Literals<readonly ["tanzil-text", "tanzil-metadata", "kemenag-names", "bubenheim-names", "quranenc-english", "quranenc-indonesian", "quranenc-german", "quranenc-tafsir"]>;
+                readonly kind: Schema.Literal<"embedded">;
+                readonly terms: Schema.Struct<{
+                    readonly artifact: Schema.Struct<{
+                        readonly byteCount: Schema.Int;
+                        readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                        readonly fileCount: Schema.Int;
+                    }>;
+                    readonly url: Schema.String;
+                }>;
+            }>, Schema.Struct<{
+                readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                    readonly notice: Schema.Trimmed;
+                    readonly title: Schema.Trimmed;
+                }>>;
+                readonly publisher: Schema.Trimmed;
+                readonly retrievedAt: Schema.String;
+                readonly sourceUrl: Schema.String;
+                readonly updateUrl: Schema.String;
+                readonly version: Schema.Trimmed;
+                readonly id: Schema.Literals<readonly ["mokhtasar-english", "mokhtasar-german"]>;
+                readonly kind: Schema.Literal<"external">;
+                readonly terms: Schema.Struct<{
+                    readonly access: Schema.Literal<"link-only">;
+                    readonly url: Schema.String;
+                }>;
+            }>]>>;
+            readonly tafsirAccess: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literal<"en">, "@NakafaAI/AksaraAppLocale">;
+                readonly kind: Schema.Literal<"external">;
+                readonly notice: Schema.Trimmed;
+                readonly sourceId: Schema.Literal<"mokhtasar-english">;
+            }>, Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literal<"id">, "@NakafaAI/AksaraAppLocale">;
+                readonly kind: Schema.Literal<"embedded">;
+                readonly notice: Schema.Trimmed;
+                readonly sourceId: Schema.Literal<"quranenc-tafsir">;
+            }>, Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literal<"de">, "@NakafaAI/AksaraAppLocale">;
+                readonly kind: Schema.Literal<"external">;
+                readonly notice: Schema.Trimmed;
+                readonly sourceId: Schema.Literal<"mokhtasar-german">;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly name: Schema.Struct<{
+                readonly arabic: Schema.String;
+                readonly meaning: Schema.$Record<Schema.Literals<readonly ["en", "id", "de"]>, Schema.String>;
+                readonly transliteration: Schema.String;
+            }>;
+            readonly number: Schema.Int;
+            readonly numberOfVerses: Schema.Int;
+            readonly revelation: Schema.Struct<{
+                readonly order: Schema.Int;
+                readonly place: Schema.Literals<readonly ["Meccan", "Medinan"]>;
+            }>;
+            readonly kind: Schema.Literal<"quran-surah">;
+        }>, Schema.Struct<{
+            readonly firstQuranNumber: Schema.Int;
+            readonly firstVerse: Schema.Int;
+            readonly kind: Schema.Literal<"quran-chunk">;
+            readonly lastVerse: Schema.Int;
+            readonly surahNumber: Schema.Int;
+            readonly verses: Schema.NonEmptyArray<Schema.Struct<{
+                readonly meta: Schema.Struct<{
+                    readonly hizbQuarter: Schema.Int;
+                    readonly juz: Schema.Int;
+                    readonly manzil: Schema.Int;
+                    readonly page: Schema.Int;
+                    readonly ruku: Schema.Int;
+                    readonly sajda: Schema.NullOr<Schema.Literals<readonly ["obligatory", "recommended"]>>;
+                }>;
+                readonly number: Schema.Struct<{
+                    readonly inQuran: Schema.Int;
+                    readonly inSurah: Schema.Int;
+                }>;
+                readonly tafsir: Schema.$Array<Schema.Struct<{
+                    readonly appLocale: Schema.Literal<"id">;
+                    readonly footnotes: Schema.NullOr<Schema.String>;
+                    readonly text: Schema.String;
+                }>>;
+                readonly text: Schema.Struct<{
+                    readonly arabic: Schema.String;
+                }>;
+                readonly translations: Schema.NonEmptyArray<Schema.Struct<{
+                    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                    readonly value: Schema.Struct<{
+                        readonly footnotes: Schema.String;
+                        readonly text: Schema.String;
+                    }>;
+                }>>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly kind: Schema.Literal<"quran-search">;
+            readonly route: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+            readonly surahNumber: Schema.Int;
+            readonly text: Schema.String;
+            readonly title: Schema.String;
+        }>]>;
+        readonly rowHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+}>, Schema.Struct<{
+    readonly family: Schema.Literal<"tryout">;
+    readonly record: Schema.Struct<{
+        readonly row: Schema.Union<readonly [Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly description: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly sourceRevision: Schema.Trimmed;
+            readonly title: Schema.String;
+            readonly countryCode: Schema.String;
+            readonly countryKey: Schema.String;
+            readonly kind: Schema.Literal<"country">;
+            readonly order: Schema.Finite;
+            readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+        }>, Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly description: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly sourceRevision: Schema.Trimmed;
+            readonly title: Schema.String;
+            readonly countryKey: Schema.String;
+            readonly examKey: Schema.String;
+            readonly kind: Schema.Literal<"exam">;
+            readonly order: Schema.Finite;
+            readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+            readonly scoringStrategy: Schema.Literals<readonly ["irt", "raw"]>;
+        }>, Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly description: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly sourceRevision: Schema.Trimmed;
+            readonly title: Schema.String;
+            readonly countryKey: Schema.String;
+            readonly examKey: Schema.String;
+            readonly kind: Schema.Literal<"track">;
+            readonly order: Schema.Finite;
+            readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+            readonly questionCount: Schema.Finite;
+            readonly sectionCount: Schema.Finite;
+            readonly setCount: Schema.Finite;
+            readonly trackKey: Schema.String;
+            readonly trackKind: Schema.Literals<readonly ["subject", "year"]>;
+            readonly visibleSectionCount: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly description: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly sourceRevision: Schema.Trimmed;
+            readonly title: Schema.String;
+            readonly countryKey: Schema.String;
+            readonly examKey: Schema.String;
+            readonly internalEntrySectionKey: Schema.optional<Schema.String>;
+            readonly kind: Schema.Literal<"set">;
+            readonly order: Schema.Finite;
+            readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+            readonly questionCount: Schema.Finite;
+            readonly scoringStrategy: Schema.Literals<readonly ["irt", "raw"]>;
+            readonly sectionCount: Schema.Finite;
+            readonly setKey: Schema.String;
+            readonly trackKey: Schema.String;
+            readonly visibleSectionCount: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly description: Schema.optional<Schema.String>;
+            readonly graph: Schema.Struct<{
+                readonly alignmentId: Schema.String;
+                readonly assetId: Schema.String;
+                readonly conceptId: Schema.String;
+                readonly learningObjectId: Schema.String;
+                readonly lensId: Schema.String;
+            }>;
+            readonly sourceRevision: Schema.Trimmed;
+            readonly title: Schema.String;
+            readonly countryKey: Schema.String;
+            readonly examKey: Schema.String;
+            readonly kind: Schema.Literal<"section">;
+            readonly order: Schema.Finite;
+            readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+            readonly questionCount: Schema.Finite;
+            readonly questionSourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+            readonly sectionKey: Schema.String;
+            readonly setKey: Schema.String;
+            readonly timeLimitSeconds: Schema.Finite;
+            readonly trackKey: Schema.String;
+            readonly visibility: Schema.Literals<readonly ["internal-entry", "visible"]>;
+        }>]>;
+        readonly rowHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    }>;
+    readonly rowKind: Schema.Literal<"catalog">;
+}>, Schema.Struct<{
+    readonly family: Schema.Literal<"tryout">;
+    readonly record: 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">;
+    }>;
+    readonly rowKind: Schema.Literal<"placement">;
+}>]>;
+export type ContentSnapshotRow = typeof ContentSnapshotRowSchema.Type;
+/** Returns the immutable content-addressed identity of one family manifest. */
+export declare function contentSnapshotId(snapshot: ContentSnapshotManifest): string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+/** Serializes one structured row with stable envelope field order. */
+export declare function canonicalizeContentSnapshotRow(row: ContentSnapshotRow): string;

package/dist/release/snapshot/data.js

@@ -0,0 +1,74 @@
+/** Structured snapshot manifest and row wire contracts. */
+import { Schema } from "effect";
+import { ProgramSnapshotRowSchema } from "#contracts/program/snapshot/row";
+import { ProgramSnapshotSchema } from "#contracts/program/snapshot/spec";
+import { QuranSnapshotRowSchema } from "#contracts/quran/snapshot/row";
+import { QuranSnapshotSchema } from "#contracts/quran/snapshot/spec";
+import { TryoutCatalogRecordSchema } from "#contracts/tryout/catalog";
+import { TryoutPlacementRecordSchema } from "#contracts/tryout/placement";
+import { TryoutSnapshotSchema } from "#contracts/tryout/snapshot/spec";
+/** Program manifest selected by one globally signed content release. */
+const ProgramManifestSchema = Schema.Struct({
+    family: Schema.Literal("program"),
+    manifest: ProgramSnapshotSchema,
+});
+/** Quran manifest selected by one globally signed content release. */
+const QuranManifestSchema = Schema.Struct({
+    family: Schema.Literal("quran"),
+    manifest: QuranSnapshotSchema,
+});
+/** Try-out manifest selected by one globally signed content release. */
+const TryoutManifestSchema = Schema.Struct({
+    family: Schema.Literal("tryout"),
+    manifest: TryoutSnapshotSchema,
+});
+/** Complete structured snapshot manifest vocabulary staged before its rows. */
+export const ContentSnapshotManifestSchema = Schema.Union([
+    ProgramManifestSchema,
+    QuranManifestSchema,
+    TryoutManifestSchema,
+]);
+/** One learning-program record staged under its snapshot identity. */
+const ProgramRowSchema = Schema.Struct({
+    family: Schema.Literal("program"),
+    record: ProgramSnapshotRowSchema,
+});
+/** One Quran record already bound to its snapshot identity. */
+const QuranRowSchema = Schema.Struct({
+    family: Schema.Literal("quran"),
+    record: QuranSnapshotRowSchema,
+});
+/** One try-out hierarchy record staged before activation. */
+const TryoutCatalogRowSchema = Schema.Struct({
+    family: Schema.Literal("tryout"),
+    record: TryoutCatalogRecordSchema,
+    rowKind: Schema.Literal("catalog"),
+});
+/** One try-out placement record staged before activation. */
+const TryoutPlacementRowSchema = Schema.Struct({
+    family: Schema.Literal("tryout"),
+    record: TryoutPlacementRecordSchema,
+    rowKind: Schema.Literal("placement"),
+});
+/** Complete current structured row vocabulary accepted by publication. */
+export const ContentSnapshotRowSchema = Schema.Union([
+    ProgramRowSchema,
+    QuranRowSchema,
+    TryoutCatalogRowSchema,
+    TryoutPlacementRowSchema,
+]);
+/** Returns the immutable content-addressed identity of one family manifest. */
+export function contentSnapshotId(snapshot) {
+    return snapshot.manifest.snapshotId;
+}
+/** Serializes one structured row with stable envelope field order. */
+export function canonicalizeContentSnapshotRow(row) {
+    if (row.family === "program" || row.family === "quran") {
+        return JSON.stringify({ family: row.family, record: row.record });
+    }
+    return JSON.stringify({
+        family: row.family,
+        record: row.record,
+        rowKind: row.rowKind,
+    });
+}

package/dist/release/snapshot/evidence-requirement.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Schema, type Stream } from "effect";
+import type { Sha256Hash } from "#contracts/ids";
+import type { ContentSnapshotRow } from "#contracts/release/snapshot/data";
+declare const SnapshotEvidenceError_base: Schema.Class<SnapshotEvidenceError, Schema.TaggedStruct<"SnapshotEvidenceError", {
+    readonly actual: Schema.String;
+    readonly expected: Schema.String;
+    readonly family: Schema.Literals<readonly ["program", "quran", "tryout"]>;
+    readonly field: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Signed snapshot evidence differs from its authenticated row stream. */
+export declare class SnapshotEvidenceError extends SnapshotEvidenceError_base {
+}
+/** Creates a fresh structured-row replay for one verification pass. */
+export type SnapshotRowSource<E, R> = Stream.Stream<ContentSnapshotRow, E, R>;
+/** Fails with one field-level mismatch without exposing row bodies. */
+export declare function requireSnapshotEvidence(input: {
+    readonly actual: number | Sha256Hash;
+    readonly expected: number | Sha256Hash;
+    readonly family: "program" | "quran" | "tryout";
+    readonly field: string;
+}): Effect.Effect<void, never, never> | Effect.Effect<never, SnapshotEvidenceError, never>;
+export {};

package/dist/release/snapshot/evidence-requirement.js

@@ -0,0 +1,21 @@
+import { Effect, Schema } from "effect";
+/** Signed snapshot evidence differs from its authenticated row stream. */
+export class SnapshotEvidenceError extends Schema.TaggedError()("SnapshotEvidenceError", {
+    actual: Schema.String,
+    expected: Schema.String,
+    family: Schema.Literals(["program", "quran", "tryout"]),
+    field: Schema.String,
+}) {
+}
+/** Fails with one field-level mismatch without exposing row bodies. */
+export function requireSnapshotEvidence(input) {
+    if (input.actual === input.expected) {
+        return Effect.void;
+    }
+    return Effect.fail(new SnapshotEvidenceError({
+        actual: String(input.actual),
+        expected: String(input.expected),
+        family: input.family,
+        field: input.field,
+    }));
+}