@nakafa/aksara-contracts 0.27.0

package/dist/projection/material.d.ts

@@ -0,0 +1,109 @@
+import { Schema } from "effect";
+import { type AppLocale } from "#contracts/locale";
+/** Locale-owned root namespace for public material routes. */
+export declare const MaterialPublicNamespaceSchema: Schema.Literals<readonly ["subjects", "materi", "faecher"]>;
+export type MaterialPublicNamespace = typeof MaterialPublicNamespaceSchema.Type;
+/** Resolves the only public material namespace owned by one app locale. */
+export declare function materialPublicNamespace(appLocale: AppLocale): MaterialPublicNamespace;
+/** Stable reusable material identity preserved from Nakafa's source registry. */
+export declare const MaterialKeySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialKey">;
+export type MaterialKey = typeof MaterialKeySchema.Type;
+/** Stable lesson-section identity preserved across localized public routes. */
+export declare const MaterialSectionSchema: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialSection">;
+export type MaterialSection = typeof MaterialSectionSchema.Type;
+/** Exact metadata contract required from newly authored material sources. */
+export declare const MaterialMetadataSchema: 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 subject: Schema.optional<Schema.String>;
+    readonly title: Schema.String;
+}>;
+export type MaterialMetadata = typeof MaterialMetadataSchema.Type;
+/** Non-authored material route fields preserved from Nakafa's registry. */
+export declare const MaterialLessonRouteSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    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 materialKey: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialKey">;
+    readonly order: Schema.Finite;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly sectionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialSection">;
+    readonly topicTitle: Schema.String;
+}>;
+export type MaterialLessonRoute = typeof MaterialLessonRouteSchema.Type;
+/** Canonical route read model for one published material lesson body. */
+export declare const MaterialLessonProjectionSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    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 materialKey: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialKey">;
+    readonly order: Schema.Finite;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly sectionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraMaterialSection">;
+    readonly kind: Schema.Literal<"subject-lesson">;
+    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 subject: Schema.optional<Schema.String>;
+        readonly title: Schema.String;
+    }>;
+    readonly parentPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly sitemap: Schema.Literal<true>;
+    readonly topicTitle: Schema.String;
+}>;
+export type MaterialLessonProjection = typeof MaterialLessonProjectionSchema.Type;
+/** Combines registry-owned routing with metadata decoded from authored MDX. */
+export declare function makeMaterialLessonProjection(route: MaterialLessonRoute, metadata: MaterialMetadata): {
+    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;
+};
+/** Serializes one material projection with stable signed field order. */
+export declare function canonicalizeMaterialProjection(projection: MaterialLessonProjection): string;

package/dist/projection/material.js

@@ -0,0 +1,160 @@
+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";
+const MATERIAL_KEY_PATTERN = /^lesson\.[a-z0-9]+(?:-[a-z0-9]+)*\.[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const SECTION_KEY_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const MaterialPublicPathSchema = PublicPathSchema.pipe(Schema.check(Schema.makeFilter((value) => value.includes("/"), {
+    message: "Expected a material lesson path with a parent route.",
+})));
+/** Locale-owned root namespace for public material routes. */
+export const MaterialPublicNamespaceSchema = Schema.Literals([
+    "subjects",
+    "materi",
+    "faecher",
+]);
+/** Resolves the only public material namespace owned by one app locale. */
+export function materialPublicNamespace(appLocale) {
+    if (appLocale === AppLocaleSchema.make("en")) {
+        return "subjects";
+    }
+    if (appLocale === AppLocaleSchema.make("id")) {
+        return "materi";
+    }
+    return "faecher";
+}
+/** Stable reusable material identity preserved from Nakafa's source registry. */
+export const MaterialKeySchema = Schema.String.pipe(Schema.check(Schema.isPattern(MATERIAL_KEY_PATTERN, {
+    description: "Stable lesson key with domain and material segments.",
+    identifier: "MaterialKey",
+    message: "Invalid material key.",
+})), Schema.brand("@NakafaAI/AksaraMaterialKey"));
+/** Stable lesson-section identity preserved across localized public routes. */
+export const MaterialSectionSchema = Schema.String.pipe(Schema.check(Schema.isPattern(SECTION_KEY_PATTERN)), Schema.brand("@NakafaAI/AksaraMaterialSection"));
+const MaterialMetadataFields = {
+    authors: Schema.Array(ContentAuthorSchema),
+    description: Schema.optional(Schema.String),
+    subject: Schema.optional(Schema.String),
+    title: Schema.String,
+};
+/** Exact metadata contract required from newly authored material sources. */
+export const MaterialMetadataSchema = withPublicationDates(MaterialMetadataFields);
+const MaterialProjectionMetadataSchema = withPublicationDates(MaterialMetadataFields);
+/** Stable route fields shared by material routes and published projections. */
+const MaterialLessonRouteFields = {
+    appLocale: AppLocaleSchema,
+    artifactLocale: ArtifactLocaleSchema,
+    contentKey: ContentKeySchema,
+    graph: LearningGraphIdentitySchema,
+    materialKey: MaterialKeySchema,
+    order: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+    publicPath: MaterialPublicPathSchema,
+    sectionKey: MaterialSectionSchema,
+};
+/** Fields shared by the filtered material projection contract. */
+const MaterialLessonProjectionFields = {
+    ...MaterialLessonRouteFields,
+    kind: Schema.Literal("subject-lesson"),
+    metadata: MaterialProjectionMetadataSchema,
+    parentPath: PublicPathSchema,
+    sitemap: Schema.Literal(true),
+};
+/** Returns the canonical parent route owned by one lesson public path. */
+function materialParentPath(publicPath) {
+    return publicPath.slice(0, publicPath.lastIndexOf("/"));
+}
+/** Checks that a projection cannot claim an unrelated material parent. */
+function hasCoherentParentPath(input) {
+    return input.parentPath === materialParentPath(input.publicPath);
+}
+/** Checks signed graph identities against stable material source keys. */
+function hasCoherentMaterialGraph(input) {
+    const identity = input.materialKey.slice("lesson.".length);
+    const separator = identity.indexOf(".");
+    const domain = identity.slice(0, separator);
+    const topic = identity.slice(separator + 1);
+    const lens = `material:lesson:${domain}`;
+    const object = `material-section:${domain}:${topic}:${input.sectionKey}`;
+    return (input.graph.alignmentId === `alignment:${lens}:${object}` &&
+        input.graph.assetId === `asset:${input.appLocale}:${lens}:${object}` &&
+        input.graph.conceptId === `concept:${lens}:${topic}` &&
+        input.graph.learningObjectId === `lo:${object}` &&
+        input.graph.lensId === `lens:${lens}`);
+}
+/** Public material bodies use the same locale for routes and artifacts. */
+function hasCoherentMaterialLocales(input) {
+    return input.appLocale === input.artifactLocale;
+}
+/** Checks one signed material route against its locale-owned namespace. */
+function hasCoherentMaterialNamespace(input) {
+    return input.publicPath.startsWith(`${materialPublicNamespace(input.appLocale)}/`);
+}
+/** Non-authored material route fields preserved from Nakafa's registry. */
+export const MaterialLessonRouteSchema = Schema.Struct({
+    ...MaterialLessonRouteFields,
+    topicTitle: Schema.String,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentMaterialLocales, {
+    message: "Expected public material route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentMaterialNamespace, {
+    message: "Expected the material public path to use its locale-owned namespace.",
+})), Schema.check(Schema.makeFilter(hasCoherentMaterialGraph, {
+    message: "Expected material graph identities to match its stable source keys.",
+})));
+/** Canonical route read model for one published material lesson body. */
+export const MaterialLessonProjectionSchema = Schema.Struct({
+    ...MaterialLessonProjectionFields,
+    topicTitle: Schema.String,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentMaterialLocales, {
+    message: "Expected public material route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentParentPath, {
+    message: "Expected the material parent path to match the lesson public path.",
+})), Schema.check(Schema.makeFilter(hasCoherentMaterialNamespace, {
+    message: "Expected the material public path to use its locale-owned namespace.",
+})), Schema.check(Schema.makeFilter(hasCoherentMaterialGraph, {
+    message: "Expected material graph identities to match its stable source keys.",
+})));
+/** Combines registry-owned routing with metadata decoded from authored MDX. */
+export function makeMaterialLessonProjection(route, metadata) {
+    const parentPath = materialParentPath(route.publicPath);
+    return MaterialLessonProjectionSchema.make({
+        ...route,
+        kind: "subject-lesson",
+        metadata,
+        parentPath: PublicPathSchema.make(parentPath),
+        sitemap: true,
+    });
+}
+/** Serializes one material projection with stable signed field order. */
+export function canonicalizeMaterialProjection(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 }),
+        ...(projection.metadata.subject === undefined
+            ? {}
+            : { subject: projection.metadata.subject }),
+        title: projection.metadata.title,
+    };
+    return JSON.stringify({
+        appLocale: projection.appLocale,
+        artifactLocale: projection.artifactLocale,
+        contentKey: projection.contentKey,
+        graph: canonicalizeLearningGraphIdentity(projection.graph),
+        kind: projection.kind,
+        materialKey: projection.materialKey,
+        metadata,
+        order: projection.order,
+        parentPath: projection.parentPath,
+        publicPath: projection.publicPath,
+        sectionKey: projection.sectionKey,
+        sitemap: projection.sitemap,
+        topicTitle: projection.topicTitle,
+    });
+}

package/dist/projection/page.d.ts

@@ -0,0 +1,112 @@
+import { Schema } from "effect";
+import { CorpusSourcePathSchema } from "#contracts/ids";
+/** Stable source-owned identity for one reviewed public site page. */
+export declare const PageKeySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+export type PageKey = typeof PageKeySchema.Type;
+/** Exact metadata consumed by human, agent, and sitemap page surfaces. */
+export declare const PageMetadataSchema: Schema.Struct<{
+    readonly dateModified: Schema.optionalKey<Schema.String>;
+    readonly datePublished: Schema.String;
+    readonly description: Schema.Trimmed;
+    readonly title: Schema.Trimmed;
+}>;
+export type PageMetadata = typeof PageMetadataSchema.Type;
+/** Stable identity and locale-owned public route for one reviewed site page. */
+export declare const PublicPageRouteSchema: Schema.Struct<{
+    appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    pageKey: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+    publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+}>;
+export type PublicPageRoute = typeof PublicPageRouteSchema.Type;
+/** Canonical signed read model for one reviewed public site page. */
+export declare const PublicPageProjectionSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly pageKey: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly kind: Schema.Literal<"public-page">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly description: Schema.Trimmed;
+        readonly title: Schema.Trimmed;
+    }>;
+    readonly sitemap: Schema.Literal<true>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>;
+export type PublicPageProjection = typeof PublicPageProjectionSchema.Type;
+/** Exact predecessor Page bytes required for rollback and stored-state reads. */
+export declare const HistoricalPublicPageProjectionSchema: Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly pageKey: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly kind: Schema.Literal<"public-page">;
+    readonly metadata: Schema.Struct<{
+        readonly description: Schema.Trimmed;
+        readonly lastModified: Schema.String;
+        readonly title: Schema.Trimmed;
+    }>;
+    readonly sitemap: Schema.Literal<true>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>;
+export type HistoricalPublicPageProjection = typeof HistoricalPublicPageProjectionSchema.Type;
+/** Current Page values plus exact predecessor bytes needed for safe rollout. */
+export declare const ReadablePublicPageProjectionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly pageKey: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly kind: Schema.Literal<"public-page">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly description: Schema.Trimmed;
+        readonly title: Schema.Trimmed;
+    }>;
+    readonly sitemap: Schema.Literal<true>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>, Schema.Struct<{
+    readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly pageKey: Schema.brand<Schema.String, "@NakafaAI/AksaraPageKey">;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+    readonly kind: Schema.Literal<"public-page">;
+    readonly metadata: Schema.Struct<{
+        readonly description: Schema.Trimmed;
+        readonly lastModified: Schema.String;
+        readonly title: Schema.Trimmed;
+    }>;
+    readonly sitemap: Schema.Literal<true>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>]>;
+export type ReadablePublicPageProjection = typeof ReadablePublicPageProjectionSchema.Type;
+/** Combines one reviewed page route with its strict localized metadata. */
+export declare function makePublicPageProjection(input: {
+    readonly metadata: PageMetadata;
+    readonly route: PublicPageRoute;
+    readonly sourcePath: typeof CorpusSourcePathSchema.Type;
+}): {
+    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">;
+};
+/** Serializes one public page projection with stable signed field order. */
+export declare function canonicalizePublicPageProjection(projection: ReadablePublicPageProjection): string;

package/dist/projection/page.js

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+import { DateOnlySchema, withPublicationDates } from "#contracts/date";
+import { ContentKeySchema, CorpusSourcePathSchema, PublicPathSchema, } from "#contracts/ids";
+import { AppLocaleSchema, ArtifactLocaleSchema } from "#contracts/locale";
+import { isLowerKebab } from "#contracts/text/syntax";
+/** Stable source-owned identity for one reviewed public site page. */
+export const PageKeySchema = Schema.String.pipe(Schema.check(Schema.makeFilter(isLowerKebab)), Schema.brand("@NakafaAI/AksaraPageKey"));
+/** Exact metadata consumed by human, agent, and sitemap page surfaces. */
+export const PageMetadataSchema = withPublicationDates({
+    description: Schema.Trimmed.check(Schema.isNonEmpty()),
+    title: Schema.Trimmed.check(Schema.isNonEmpty()),
+});
+/** Immutable metadata retained only for authenticated historical Page reads. */
+const HistoricalPageMetadataSchema = Schema.Struct({
+    description: Schema.Trimmed.check(Schema.isNonEmpty()),
+    lastModified: DateOnlySchema,
+    title: Schema.Trimmed.check(Schema.isNonEmpty()),
+});
+const PublicPageRouteFields = {
+    appLocale: AppLocaleSchema,
+    artifactLocale: ArtifactLocaleSchema,
+    contentKey: ContentKeySchema,
+    pageKey: PageKeySchema,
+    publicPath: PublicPathSchema,
+};
+/** Checks stable page identity separately from its locale-owned public path. */
+function hasCoherentPageRoute(input) {
+    return input.contentKey === `pages/${input.pageKey}`;
+}
+/** Public page bodies use the same locale for routes and artifacts. */
+function hasCoherentPageLocales(input) {
+    return input.appLocale === input.artifactLocale;
+}
+/** Stable identity and locale-owned public route for one reviewed site page. */
+export const PublicPageRouteSchema = Schema.Struct(PublicPageRouteFields).pipe(Schema.check(Schema.makeFilter(hasCoherentPageLocales, {
+    message: "Expected public page route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentPageRoute, {
+    message: "Expected the public page content key to match its page key.",
+})));
+/** Canonical signed read model for one reviewed public site page. */
+export const PublicPageProjectionSchema = Schema.Struct({
+    ...PublicPageRouteFields,
+    kind: Schema.Literal("public-page"),
+    metadata: PageMetadataSchema,
+    sitemap: Schema.Literal(true),
+    sourcePath: CorpusSourcePathSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentPageLocales, {
+    message: "Expected public page route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentPageRoute, {
+    message: "Expected the public page content key to match its page key.",
+})));
+/** Exact predecessor Page bytes required for rollback and stored-state reads. */
+export const HistoricalPublicPageProjectionSchema = Schema.Struct({
+    ...PublicPageRouteFields,
+    kind: Schema.Literal("public-page"),
+    metadata: HistoricalPageMetadataSchema,
+    sitemap: Schema.Literal(true),
+    sourcePath: CorpusSourcePathSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentPageLocales, {
+    message: "Expected historical page route and artifact locales to match.",
+})), Schema.check(Schema.makeFilter(hasCoherentPageRoute, {
+    message: "Expected the historical page content key to match its page key.",
+})));
+/** Current Page values plus exact predecessor bytes needed for safe rollout. */
+export const ReadablePublicPageProjectionSchema = Schema.Union([
+    PublicPageProjectionSchema,
+    HistoricalPublicPageProjectionSchema,
+]);
+/** Combines one reviewed page route with its strict localized metadata. */
+export function makePublicPageProjection(input) {
+    return PublicPageProjectionSchema.make({
+        ...input.route,
+        kind: "public-page",
+        metadata: input.metadata,
+        sitemap: true,
+        sourcePath: input.sourcePath,
+    });
+}
+/** Serializes one public page projection with stable signed field order. */
+export function canonicalizePublicPageProjection(projection) {
+    const metadata = "lastModified" in projection.metadata
+        ? {
+            description: projection.metadata.description,
+            lastModified: projection.metadata.lastModified,
+            title: projection.metadata.title,
+        }
+        : {
+            ...(projection.metadata.dateModified === undefined
+                ? {}
+                : { dateModified: projection.metadata.dateModified }),
+            datePublished: projection.metadata.datePublished,
+            description: projection.metadata.description,
+            title: projection.metadata.title,
+        };
+    return JSON.stringify({
+        appLocale: projection.appLocale,
+        artifactLocale: projection.artifactLocale,
+        contentKey: projection.contentKey,
+        kind: projection.kind,
+        metadata,
+        pageKey: projection.pageKey,
+        publicPath: projection.publicPath,
+        sitemap: projection.sitemap,
+        sourcePath: projection.sourcePath,
+    });
+}