@nakafa/aksara-contracts 0.27.0

package/dist/projection/article.d.ts

@@ -0,0 +1,145 @@
+import { Schema } from "effect";
+/** Stable source-owned category segment used below the article route family. */
+export declare const ArticleCategorySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleCategory">;
+export type ArticleCategory = typeof ArticleCategorySchema.Type;
+/** Localized display title owned by one reviewed article category source. */
+export declare const ArticleCategoryTitleSchema: Schema.Trimmed;
+export type ArticleCategoryTitle = typeof ArticleCategoryTitleSchema.Type;
+/** Stable source-owned article segment used below its category route. */
+export declare const ArticleSlugSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleSlug">;
+export type ArticleSlug = typeof ArticleSlugSchema.Type;
+/** Locale-owned public route segment for one article category or body. */
+export declare const ArticleRouteSlugSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleRouteSlug">;
+export type ArticleRouteSlug = typeof ArticleRouteSlugSchema.Type;
+/** Exact reviewed citation fields consumed by Nakafa article pages. */
+export declare const ArticleReferenceSchema: Schema.Struct<{
+    readonly authors: Schema.String;
+    readonly citation: Schema.optional<Schema.String>;
+    readonly details: Schema.optional<Schema.String>;
+    readonly publication: Schema.optional<Schema.String>;
+    readonly title: Schema.String;
+    readonly url: Schema.optional<Schema.String>;
+    readonly year: Schema.Finite;
+}>;
+export type ArticleReference = typeof ArticleReferenceSchema.Type;
+/** Exact metadata contract required from newly authored article sources. */
+export declare const ArticleMetadataSchema: Schema.Struct<{
+    readonly dateModified: Schema.optionalKey<Schema.String>;
+    readonly datePublished: Schema.String;
+    readonly authors: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly title: Schema.String;
+}>;
+export type ArticleMetadata = typeof ArticleMetadataSchema.Type;
+/** Source-owned identity and public route for one localized article body. */
+export declare const ArticleRouteSchema: Schema.Struct<{
+    appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    articleRouteSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleRouteSlug">;
+    articleSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleSlug">;
+    artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    category: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleCategory">;
+    categoryRouteSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleRouteSlug">;
+    contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    graph: Schema.Struct<{
+        readonly alignmentId: Schema.String;
+        readonly assetId: Schema.String;
+        readonly conceptId: Schema.String;
+        readonly learningObjectId: Schema.String;
+        readonly lensId: Schema.String;
+    }>;
+    publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+}>;
+export type ArticleRoute = typeof ArticleRouteSchema.Type;
+/** Canonical published read model for one reviewed article body. */
+export declare const ArticleProjectionSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly articleRouteSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleRouteSlug">;
+    readonly articleSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleSlug">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly category: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleCategory">;
+    readonly categoryRouteSlug: Schema.brand<Schema.String, "@NakafaAI/AksaraArticleRouteSlug">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    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 publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly categoryTitle: Schema.Trimmed;
+    readonly kind: Schema.Literal<"article">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly authors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+        }>>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly title: Schema.String;
+    }>;
+    readonly official: Schema.Boolean;
+    readonly parentPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly references: Schema.$Array<Schema.Struct<{
+        readonly authors: Schema.String;
+        readonly citation: Schema.optional<Schema.String>;
+        readonly details: Schema.optional<Schema.String>;
+        readonly publication: Schema.optional<Schema.String>;
+        readonly title: Schema.String;
+        readonly url: Schema.optional<Schema.String>;
+        readonly year: Schema.Finite;
+    }>>;
+    readonly sitemap: Schema.Literal<true>;
+}>;
+export type ArticleProjection = typeof ArticleProjectionSchema.Type;
+/** Combines source-owned routing with decoded metadata and references. */
+export declare function makeArticleProjection(input: {
+    readonly categoryTitle: ArticleCategoryTitle;
+    readonly metadata: ArticleMetadata;
+    readonly official: boolean;
+    readonly references: readonly ArticleReference[];
+    readonly route: ArticleRoute;
+}): {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly articleRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly articleSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleSlug">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly category: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleCategory">;
+    readonly categoryRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly graph: {
+        readonly alignmentId: string;
+        readonly assetId: string;
+        readonly conceptId: string;
+        readonly learningObjectId: string;
+        readonly lensId: string;
+    };
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly categoryTitle: string;
+    readonly kind: "article";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly description?: string | undefined;
+        readonly title: string;
+    };
+    readonly official: boolean;
+    readonly parentPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly references: readonly {
+        readonly authors: string;
+        readonly citation?: string | undefined;
+        readonly details?: string | undefined;
+        readonly publication?: string | undefined;
+        readonly title: string;
+        readonly url?: string | undefined;
+        readonly year: number;
+    }[];
+    readonly sitemap: true;
+};
+/** Serializes one article projection with stable signed field order. */
+export declare function canonicalizeArticleProjection(projection: ArticleProjection): string;

package/dist/projection/article.js

@@ -0,0 +1,150 @@
+import { Schema } from "effect";
+import { ContentAuthorSchema } from "#contracts/content";
+import { withPublicationDates } from "#contracts/date";
+import { canonicalizeLearningGraphIdentity, LearningGraphIdentitySchema, } from "#contracts/graph/spec";
+import { ContentKeySchema, PublicPathSchema } from "#contracts/ids";
+import { AppLocaleSchema, ArtifactLocaleSchema } from "#contracts/locale";
+import { isLowerKebab } from "#contracts/text/syntax";
+/** Stable source-owned category segment used below the article route family. */
+export const ArticleCategorySchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab)), Schema.brand("@NakafaAI/AksaraArticleCategory"));
+/** Localized display title owned by one reviewed article category source. */
+export const ArticleCategoryTitleSchema = Schema.Trimmed.check(Schema.isNonEmpty());
+/** Stable source-owned article segment used below its category route. */
+export const ArticleSlugSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab)), Schema.brand("@NakafaAI/AksaraArticleSlug"));
+/** Locale-owned public route segment for one article category or body. */
+export const ArticleRouteSlugSchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab)), Schema.brand("@NakafaAI/AksaraArticleRouteSlug"));
+/** Exact reviewed citation fields consumed by Nakafa article pages. */
+export const ArticleReferenceSchema = Schema.Struct({
+    authors: Schema.String,
+    citation: Schema.optional(Schema.String),
+    details: Schema.optional(Schema.String),
+    publication: Schema.optional(Schema.String),
+    title: Schema.String,
+    url: Schema.optional(Schema.String),
+    year: Schema.Finite,
+});
+const ArticleMetadataFields = {
+    authors: Schema.Array(ContentAuthorSchema),
+    description: Schema.optional(Schema.String),
+    title: Schema.String,
+};
+/** Exact metadata contract required from newly authored article sources. */
+export const ArticleMetadataSchema = withPublicationDates(ArticleMetadataFields);
+const ArticleProjectionMetadataSchema = withPublicationDates(ArticleMetadataFields);
+const ArticleRouteFields = {
+    appLocale: AppLocaleSchema,
+    articleRouteSlug: ArticleRouteSlugSchema,
+    articleSlug: ArticleSlugSchema,
+    artifactLocale: ArtifactLocaleSchema,
+    category: ArticleCategorySchema,
+    categoryRouteSlug: ArticleRouteSlugSchema,
+    contentKey: ContentKeySchema,
+    graph: LearningGraphIdentitySchema,
+    publicPath: PublicPathSchema,
+};
+/** Checks graph identities against the source-owned article category and slug. */
+function hasCoherentArticleGraph(input) {
+    const lens = `article:${input.category}`;
+    const object = `article:${input.category}:${input.articleSlug}`;
+    return (input.graph.alignmentId === `alignment:${lens}:${object}` &&
+        input.graph.assetId === `asset:${input.appLocale}:${lens}:${object}` &&
+        input.graph.conceptId === `concept:${lens}` &&
+        input.graph.learningObjectId === `lo:${object}` &&
+        input.graph.lensId === `lens:${lens}`);
+}
+/** Checks stable content identity separately from locale-owned public routing. */
+function hasCoherentArticleRoute(input) {
+    return (input.contentKey === `articles/${input.category}/${input.articleSlug}` &&
+        input.publicPath ===
+            `articles/${input.categoryRouteSlug}/${input.articleRouteSlug}`);
+}
+/** Public article bodies use the same locale for routes and artifacts. */
+function hasCoherentArticleLocales(input) {
+    return input.appLocale === input.artifactLocale;
+}
+/** Source-owned identity and public route for one localized article body. */
+export const ArticleRouteSchema = Schema.Struct(ArticleRouteFields).pipe(Schema.check(Schema.makeFilter(hasCoherentArticleLocales, {
+    message: "Expected public article route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentArticleRoute, {
+    message: "Expected stable article identity and locale-owned public route to be coherent.",
+})), Schema.check(Schema.makeFilter(hasCoherentArticleGraph, {
+    message: "Expected article graph identities to match its stable source keys.",
+})));
+/** Canonical published read model for one reviewed article body. */
+export const ArticleProjectionSchema = Schema.Struct({
+    ...ArticleRouteFields,
+    categoryTitle: ArticleCategoryTitleSchema,
+    kind: Schema.Literal("article"),
+    metadata: ArticleProjectionMetadataSchema,
+    official: Schema.Boolean,
+    parentPath: PublicPathSchema,
+    references: Schema.Array(ArticleReferenceSchema),
+    sitemap: Schema.Literal(true),
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentArticleLocales, {
+    message: "Expected public article route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentArticleRoute, {
+    message: "Expected stable article identity and locale-owned public route to be coherent.",
+})), Schema.check(Schema.makeFilter((projection) => projection.parentPath === `articles/${projection.categoryRouteSlug}`, {
+    message: "Expected the article parent path to match its category route.",
+})), Schema.check(Schema.makeFilter(hasCoherentArticleGraph, {
+    message: "Expected article graph identities to match its stable source keys.",
+})));
+/** Combines source-owned routing with decoded metadata and references. */
+export function makeArticleProjection(input) {
+    return ArticleProjectionSchema.make({
+        ...input.route,
+        categoryTitle: input.categoryTitle,
+        kind: "article",
+        metadata: input.metadata,
+        official: input.official,
+        parentPath: PublicPathSchema.make(`articles/${input.route.categoryRouteSlug}`),
+        references: [...input.references],
+        sitemap: true,
+    });
+}
+/** Serializes one article projection with stable signed field order. */
+export function canonicalizeArticleProjection(projection) {
+    const metadata = {
+        authors: projection.metadata.authors.map(({ name }) => ({ name })),
+        ...(projection.metadata.dateModified === undefined
+            ? {}
+            : { dateModified: projection.metadata.dateModified }),
+        datePublished: projection.metadata.datePublished,
+        ...(projection.metadata.description === undefined
+            ? {}
+            : { description: projection.metadata.description }),
+        title: projection.metadata.title,
+    };
+    return JSON.stringify({
+        appLocale: projection.appLocale,
+        articleRouteSlug: projection.articleRouteSlug,
+        articleSlug: projection.articleSlug,
+        artifactLocale: projection.artifactLocale,
+        category: projection.category,
+        categoryRouteSlug: projection.categoryRouteSlug,
+        categoryTitle: projection.categoryTitle,
+        contentKey: projection.contentKey,
+        graph: canonicalizeLearningGraphIdentity(projection.graph),
+        kind: projection.kind,
+        metadata,
+        official: projection.official,
+        parentPath: projection.parentPath,
+        publicPath: projection.publicPath,
+        references: projection.references.map((reference) => ({
+            authors: reference.authors,
+            ...(reference.citation === undefined
+                ? {}
+                : { citation: reference.citation }),
+            ...(reference.details === undefined
+                ? {}
+                : { details: reference.details }),
+            ...(reference.publication === undefined
+                ? {}
+                : { publication: reference.publication }),
+            title: reference.title,
+            ...(reference.url === undefined ? {} : { url: reference.url }),
+            year: reference.year,
+        })),
+        sitemap: projection.sitemap,
+    });
+}

package/dist/projection/digest.d.ts

@@ -0,0 +1,261 @@
+import { Effect, Schema, Stream } from "effect";
+import { ReleaseIdSchema } from "#contracts/ids";
+import { type ContentProjection } from "#contracts/projection/spec";
+declare const ProjectionHashError_base: Schema.Class<ProjectionHashError, Schema.TaggedStruct<"ProjectionHashError", {
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 computation failed before projection integrity was established. */
+export declare class ProjectionHashError extends ProjectionHashError_base {
+}
+/** Keeps Node hash state private while exposing only canonical counters. */
+declare class ProjectionDigestState {
+    #private;
+    count: number;
+    /** Initializes a domain-separated incremental projection hash. */
+    constructor();
+    /** Adds one canonical projection to this invocation-owned digest. */
+    update(projection: ContentProjection): void;
+    /** Consumes the hash and returns its branded immutable identity. */
+    digest(): string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}
+/** Creates a fresh domain-separated projection digest state. */
+export declare function createProjectionDigest(releaseId: typeof ReleaseIdSchema.Type): Effect.Effect<ProjectionDigestState, ProjectionHashError, never>;
+/** Adds one canonical content projection to an incremental digest. */
+export declare function updateProjectionDigest(releaseId: typeof ReleaseIdSchema.Type, state: ProjectionDigestState, projection: ContentProjection): Effect.Effect<ProjectionDigestState, ProjectionHashError, never>;
+/** Finalizes one incremental projection digest with typed hash failures. */
+export declare function finalizeProjectionDigest(releaseId: typeof ReleaseIdSchema.Type, state: ProjectionDigestState): Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, ProjectionHashError, never>;
+/** Digests a projection stream without retaining its content bodies. */
+export declare const digestProjections: <E, R>(releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">, projections: Stream.Stream<{
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly graph: {
+        readonly alignmentId: string;
+        readonly assetId: string;
+        readonly conceptId: string;
+        readonly learningObjectId: string;
+        readonly lensId: string;
+    };
+    readonly materialKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialKey">;
+    readonly order: number;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly sectionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialSection">;
+    readonly kind: "subject-lesson";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly description?: string | undefined;
+        readonly subject?: string | undefined;
+        readonly title: string;
+    };
+    readonly parentPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly sitemap: true;
+    readonly topicTitle: string;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly articleRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly articleSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleSlug">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly category: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleCategory">;
+    readonly categoryRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly graph: {
+        readonly alignmentId: string;
+        readonly assetId: string;
+        readonly conceptId: string;
+        readonly learningObjectId: string;
+        readonly lensId: string;
+    };
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly categoryTitle: string;
+    readonly kind: "article";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly description?: string | undefined;
+        readonly title: string;
+    };
+    readonly official: boolean;
+    readonly parentPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly references: readonly {
+        readonly authors: string;
+        readonly citation?: string | undefined;
+        readonly details?: string | undefined;
+        readonly publication?: string | undefined;
+        readonly title: string;
+        readonly url?: string | undefined;
+        readonly year: number;
+    }[];
+    readonly sitemap: true;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly pageKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPageKey">;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly kind: "public-page";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly description: string;
+        readonly title: string;
+    };
+    readonly sitemap: true;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+} | {
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: number;
+    readonly setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: "question";
+    readonly blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    readonly kind: "question-body";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    readonly stimulusKey?: string;
+    readonly response: {
+        readonly kind: "single-choice";
+        readonly options: readonly {
+            readonly isCorrect: boolean;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly optionKey: string;
+            readonly order: number;
+        }[];
+    } | {
+        readonly kind: "multiple-choice";
+        readonly options: readonly {
+            readonly isCorrect: boolean;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly optionKey: string;
+            readonly order: number;
+        }[];
+    } | {
+        readonly categories: readonly {
+            readonly categoryKey: string;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly order: number;
+        }[];
+        readonly kind: "category";
+        readonly statements: readonly {
+            readonly correctCategoryKey: string;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly order: number;
+            readonly statementKey: string;
+        }[];
+    };
+} | {
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: number;
+    readonly setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: "answer";
+    readonly blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    readonly kind: "question-body";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    readonly stimulusKey?: string;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly pageKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPageKey">;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly kind: "public-page";
+    readonly metadata: {
+        readonly description: string;
+        readonly lastModified: string;
+        readonly title: string;
+    };
+    readonly sitemap: true;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+}, E, R>) => Effect.Effect<{
+    count: number;
+    digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, E | ProjectionHashError, R>;
+export {};

package/dist/projection/digest.js

@@ -0,0 +1,59 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema, Stream } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema, } from "#contracts/ids";
+import { canonicalizeContentProjection, } from "#contracts/projection/spec";
+const CONTENT_PROJECTION_DIGEST_DOMAIN = "nakafa.aksara.content-projections";
+/** SHA-256 computation failed before projection integrity was established. */
+export class ProjectionHashError extends Schema.TaggedError()("ProjectionHashError", { releaseId: ReleaseIdSchema }) {
+}
+/** Keeps Node hash state private while exposing only canonical counters. */
+class ProjectionDigestState {
+    #hash = createHash("sha256");
+    count = 0;
+    /** Initializes a domain-separated incremental projection hash. */
+    constructor() {
+        this.#hash.update(CONTENT_PROJECTION_DIGEST_DOMAIN);
+        this.#hash.update("\n");
+    }
+    /** Adds one canonical projection to this invocation-owned digest. */
+    update(projection) {
+        this.#hash.update(canonicalizeContentProjection(projection));
+        this.#hash.update("\n");
+        this.count += 1;
+    }
+    /** Consumes the hash and returns its branded immutable identity. */
+    digest() {
+        return Sha256HashSchema.make(`sha256:${this.#hash.digest("hex")}`);
+    }
+}
+/** Creates a fresh domain-separated projection digest state. */
+export function createProjectionDigest(releaseId) {
+    return Effect.try({
+        catch: () => new ProjectionHashError({ releaseId }),
+        try: () => new ProjectionDigestState(),
+    });
+}
+/** Adds one canonical content projection to an incremental digest. */
+export function updateProjectionDigest(releaseId, state, projection) {
+    return Effect.try({
+        catch: () => new ProjectionHashError({ releaseId }),
+        try: () => {
+            state.update(projection);
+            return state;
+        },
+    });
+}
+/** Finalizes one incremental projection digest with typed hash failures. */
+export function finalizeProjectionDigest(releaseId, state) {
+    return Effect.try({
+        catch: () => new ProjectionHashError({ releaseId }),
+        try: () => state.digest(),
+    });
+}
+/** Digests a projection stream without retaining its content bodies. */
+export const digestProjections = Effect.fn("AksaraContracts.digestProjections")(function* (releaseId, projections) {
+    const initial = yield* createProjectionDigest(releaseId);
+    const state = yield* projections.pipe(Stream.runFoldEffect(() => initial, (current, projection) => updateProjectionDigest(releaseId, current, projection)));
+    const digest = yield* finalizeProjectionDigest(releaseId, state);
+    return { count: state.count, digest };
+});

package/dist/projection/hash.d.ts

@@ -0,0 +1,3 @@
+import { type ContentProjection } from "#contracts/projection/spec";
+/** Hashes one canonical projection for authoritative content-head diffing. */
+export declare function hashContentProjection(projection: ContentProjection): string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;

package/dist/projection/hash.js

@@ -0,0 +1,10 @@
+import { createHash } from "node:crypto";
+import { Sha256HashSchema } from "#contracts/ids";
+import { canonicalizeContentProjection, } from "#contracts/projection/spec";
+/** Hashes one canonical projection for authoritative content-head diffing. */
+export function hashContentProjection(projection) {
+    const digest = createHash("sha256")
+        .update(canonicalizeContentProjection(projection))
+        .digest("hex");
+    return Sha256HashSchema.make(`sha256:${digest}`);
+}