@nakafa/aksara-contracts 0.27.0

package/dist/release/head.js

@@ -0,0 +1,131 @@
+import { Schema } from "effect";
+import { ContentFamilySchema, compareContentHeads } from "#contracts/content";
+import { ContentDeliveryClassSchema } from "#contracts/delivery";
+import { ContentKeySchema, CorpusSourcePathSchema, PublicPathSchema, ReleaseIdSchema, Sha256HashSchema, } from "#contracts/ids";
+import { ArtifactLocaleSchema } from "#contracts/locale";
+import { RendererDomainSchema } from "#contracts/renderer/domain";
+import { MAX_HEAD_PAGE_COUNT } from "#contracts/transport/limits";
+const HeadCursorSchema = Schema.NullOr(Schema.Trimmed.check(Schema.isNonEmpty()).pipe(Schema.check(Schema.isMaxLength(4096))));
+const ContentHeadFields = {
+    artifactHash: Sha256HashSchema,
+    artifactLocale: ArtifactLocaleSchema,
+    compilerConfigHash: Sha256HashSchema,
+    contentKey: ContentKeySchema,
+    delivery: ContentDeliveryClassSchema,
+    projectionHash: Sha256HashSchema,
+    publicPath: Schema.optional(PublicPathSchema),
+    rendererDomain: RendererDomainSchema,
+    sourceHash: Sha256HashSchema,
+    sourcePath: CorpusSourcePathSchema,
+};
+/** Compact authoritative identity used to diff one published article head. */
+export const ArticleHeadSchema = Schema.Struct({
+    ...ContentHeadFields,
+    family: Schema.Literal("article"),
+});
+/** Compact authoritative identity used to diff one published material head. */
+export const MaterialHeadSchema = Schema.Struct({
+    ...ContentHeadFields,
+    family: Schema.Literal("material"),
+});
+/** Compact authoritative identity used to diff one published page head. */
+export const PageHeadSchema = Schema.Struct({
+    ...ContentHeadFields,
+    family: Schema.Literal("page"),
+}).pipe(Schema.check(Schema.makeFilter(({ publicPath }) => publicPath !== undefined, {
+    message: "Expected page heads to retain their public path.",
+})));
+/** Compact authoritative identity used to diff one published question body. */
+export const QuestionHeadSchema = Schema.Struct({
+    ...ContentHeadFields,
+    family: Schema.Literal("question"),
+}).pipe(Schema.check(Schema.makeFilter(({ publicPath }) => publicPath === undefined, {
+    message: "Expected question heads to remain route-free.",
+})));
+/** Complete compact-head vocabulary backed by implemented content families. */
+export const ContentHeadSchema = Schema.Union([
+    ArticleHeadSchema,
+    MaterialHeadSchema,
+    PageHeadSchema,
+    QuestionHeadSchema,
+]);
+/** Serializes one compact head in stable catalog field order. */
+export function canonicalizeContentHead(head) {
+    return JSON.stringify({
+        artifactHash: head.artifactHash,
+        artifactLocale: head.artifactLocale,
+        compilerConfigHash: head.compilerConfigHash,
+        contentKey: head.contentKey,
+        delivery: head.delivery,
+        family: head.family,
+        projectionHash: head.projectionHash,
+        ...(head.publicPath === undefined ? {} : { publicPath: head.publicPath }),
+        rendererDomain: head.rendererDomain,
+        sourceHash: head.sourceHash,
+        sourcePath: head.sourcePath,
+    });
+}
+/** Requests one bounded family-owned head page from an exact active release. */
+export const HeadPageRequestSchema = Schema.Struct({
+    activeManifestHash: Sha256HashSchema,
+    activeReleaseId: ReleaseIdSchema,
+    cursor: HeadCursorSchema,
+    family: ContentFamilySchema,
+    limit: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isBetween({ maximum: MAX_HEAD_PAGE_COUNT, minimum: 1 }))),
+});
+/** Checks deterministic head order and opaque cursor progress. */
+function hasCanonicalHeadPage(page) {
+    const hasCanonicalOrder = page.heads.every((head, index) => {
+        const previous = page.heads[index - 1];
+        return previous === undefined || compareContentHeads(previous, head) < 0;
+    });
+    if (!hasCanonicalOrder) {
+        return false;
+    }
+    if (page.done) {
+        return page.nextCursor === null;
+    }
+    return page.nextCursor !== null && page.nextCursor !== page.cursor;
+}
+const HeadPageFields = {
+    activeManifestHash: Sha256HashSchema,
+    activeReleaseId: ReleaseIdSchema,
+    cursor: HeadCursorSchema,
+    done: Schema.Boolean,
+    nextCursor: HeadCursorSchema,
+};
+const ArticleHeadPageSchema = Schema.Struct({
+    ...HeadPageFields,
+    family: Schema.Literal("article"),
+    heads: Schema.Array(ArticleHeadSchema).pipe(Schema.check(Schema.isMaxLength(MAX_HEAD_PAGE_COUNT))),
+}).pipe(Schema.check(Schema.makeFilter(hasCanonicalHeadPage, {
+    message: "Expected canonical article heads with coherent cursor progress.",
+})));
+const MaterialHeadPageSchema = Schema.Struct({
+    ...HeadPageFields,
+    family: Schema.Literal("material"),
+    heads: Schema.Array(MaterialHeadSchema).pipe(Schema.check(Schema.isMaxLength(MAX_HEAD_PAGE_COUNT))),
+}).pipe(Schema.check(Schema.makeFilter(hasCanonicalHeadPage, {
+    message: "Expected canonical material heads with coherent cursor progress.",
+})));
+const PageHeadPageSchema = Schema.Struct({
+    ...HeadPageFields,
+    family: Schema.Literal("page"),
+    heads: Schema.Array(PageHeadSchema).pipe(Schema.check(Schema.isMaxLength(MAX_HEAD_PAGE_COUNT))),
+}).pipe(Schema.check(Schema.makeFilter(hasCanonicalHeadPage, {
+    message: "Expected canonical page heads with coherent cursor progress.",
+})));
+const QuestionHeadPageSchema = Schema.Struct({
+    ...HeadPageFields,
+    family: Schema.Literal("question"),
+    heads: Schema.Array(QuestionHeadSchema).pipe(Schema.check(Schema.isMaxLength(MAX_HEAD_PAGE_COUNT))),
+}).pipe(Schema.check(Schema.makeFilter(hasCanonicalHeadPage, {
+    message: "Expected canonical question heads with coherent cursor progress.",
+})));
+/** Bounded canonical page proving one exact family-owned head inventory. */
+export const HeadPageSchema = Schema.Union([
+    ArticleHeadPageSchema,
+    MaterialHeadPageSchema,
+    PageHeadPageSchema,
+    QuestionHeadPageSchema,
+]);

package/dist/release/items.d.ts

@@ -0,0 +1,98 @@
+import { Effect, Schema, Stream } from "effect";
+import { type ContentReleaseManifest } from "#contracts/release/spec";
+declare const ReleaseItemDecodeError_base: Schema.Class<ReleaseItemDecodeError, Schema.TaggedStruct<"ReleaseItemDecodeError", {
+    readonly itemOffset: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** One release item failed strict wire decoding. */
+export declare class ReleaseItemDecodeError extends ReleaseItemDecodeError_base {
+}
+declare const ReleaseItemCountMismatchError_base: Schema.Class<ReleaseItemCountMismatchError, Schema.TaggedStruct<"ReleaseItemCountMismatchError", {
+    readonly actualCount: Schema.Finite;
+    readonly expectedCount: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The separate item stream does not have the signed manifest length. */
+export declare class ReleaseItemCountMismatchError extends ReleaseItemCountMismatchError_base {
+}
+declare const ReleaseItemOperationCountMismatchError_base: Schema.Class<ReleaseItemOperationCountMismatchError, Schema.TaggedStruct<"ReleaseItemOperationCountMismatchError", {
+    readonly actualDeletes: Schema.Finite;
+    readonly actualUpserts: Schema.Finite;
+    readonly expectedDeletes: Schema.Finite;
+    readonly expectedUpserts: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Upsert and delete totals do not match the counts signed by the manifest. */
+export declare class ReleaseItemOperationCountMismatchError extends ReleaseItemOperationCountMismatchError_base {
+}
+declare const ReleaseItemReleaseMismatchError_base: Schema.Class<ReleaseItemReleaseMismatchError, Schema.TaggedStruct<"ReleaseItemReleaseMismatchError", {
+    readonly itemOffset: Schema.Finite;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** An item belongs to another release envelope. */
+export declare class ReleaseItemReleaseMismatchError extends ReleaseItemReleaseMismatchError_base {
+}
+declare const ReleaseItemIndexMismatchError_base: Schema.Class<ReleaseItemIndexMismatchError, Schema.TaggedStruct<"ReleaseItemIndexMismatchError", {
+    readonly actualIndex: Schema.Finite;
+    readonly expectedIndex: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** An item is missing, duplicated, or out of its signed sequence. */
+export declare class ReleaseItemIndexMismatchError extends ReleaseItemIndexMismatchError_base {
+}
+declare const ReleaseItemOrderError_base: Schema.Class<ReleaseItemOrderError, Schema.TaggedStruct<"ReleaseItemOrderError", {
+    readonly itemOffset: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Item heads are duplicated or not in canonical content-head order. */
+export declare class ReleaseItemOrderError extends ReleaseItemOrderError_base {
+}
+declare const ReleaseItemScopeError_base: Schema.Class<ReleaseItemScopeError, Schema.TaggedStruct<"ReleaseItemScopeError", {
+    readonly itemOffset: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** One signed item falls outside the release's exact publication scope. */
+export declare class ReleaseItemScopeError extends ReleaseItemScopeError_base {
+}
+declare const ReleaseItemsDigestMismatchError_base: Schema.Class<ReleaseItemsDigestMismatchError, Schema.TaggedStruct<"ReleaseItemsDigestMismatchError", {
+    readonly actualDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** The separate ordered items do not match the signed digest. */
+export declare class ReleaseItemsDigestMismatchError extends ReleaseItemsDigestMismatchError_base {
+}
+/** Counts derived without retaining a complete release-item collection. */
+export interface VerifiedContentReleaseItems {
+    readonly deleteCount: number;
+    readonly upsertCount: number;
+}
+/**
+ * Strictly decodes a replayable item stream without retaining its bodies.
+ * Every evaluation owns fresh ordering and route-collision state.
+ */
+export declare function decodeContentReleaseItems<E, R>(input: {
+    readonly items: Stream.Stream<unknown, E, R>;
+    readonly manifest: ContentReleaseManifest;
+}): Stream.Stream<{
+    readonly change: {
+        readonly artifactHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+        readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+        readonly delivery: "authenticated" | "entitled" | "public";
+        readonly family: "article" | "material" | "page" | "question";
+        readonly operation: "upsert";
+        readonly rendererDomain: "ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math";
+        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 family: "article" | "material" | "page" | "question";
+        readonly operation: "delete";
+    };
+    readonly index: number;
+    readonly releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+}, E | ReleaseItemDecodeError | ReleaseItemIndexMismatchError | ReleaseItemOrderError | ReleaseItemReleaseMismatchError | ReleaseItemScopeError, R>;
+/** Authenticates a replayable ordered stream against its signed manifest. */
+export declare const verifyContentReleaseItems: <E, R>(input: {
+    readonly items: Stream.Stream<unknown, E, R>;
+    readonly manifest: ContentReleaseManifest;
+}) => Effect.Effect<{
+    deleteCount: number;
+    upsertCount: number;
+}, E | ReleaseItemCountMismatchError | ReleaseItemDecodeError | ReleaseItemIndexMismatchError | ReleaseItemOperationCountMismatchError | ReleaseItemOrderError | ReleaseItemReleaseMismatchError | ReleaseItemScopeError | ReleaseItemsDigestMismatchError | import("#contracts/release/digest").ReleaseItemsHashComputationError, R>;
+export {};

package/dist/release/items.js

@@ -0,0 +1,114 @@
+import { Effect, Schema, Stream } from "effect";
+import { compareContentHeads } from "#contracts/content";
+import { ReleaseIdSchema, Sha256HashSchema } from "#contracts/ids";
+import { digestItems } from "#contracts/release/digest";
+import { publicationScopeSelectsContent } from "#contracts/release/snapshot/scope";
+import { ContentReleaseItemSchema, } from "#contracts/release/spec";
+const ItemCountSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** One release item failed strict wire decoding. */
+export class ReleaseItemDecodeError extends Schema.TaggedError()("ReleaseItemDecodeError", { itemOffset: ItemCountSchema }) {
+}
+/** The separate item stream does not have the signed manifest length. */
+export class ReleaseItemCountMismatchError extends Schema.TaggedError()("ReleaseItemCountMismatchError", { actualCount: ItemCountSchema, expectedCount: ItemCountSchema }) {
+}
+/** Upsert and delete totals do not match the counts signed by the manifest. */
+export class ReleaseItemOperationCountMismatchError extends Schema.TaggedError()("ReleaseItemOperationCountMismatchError", {
+    actualDeletes: ItemCountSchema,
+    actualUpserts: ItemCountSchema,
+    expectedDeletes: ItemCountSchema,
+    expectedUpserts: ItemCountSchema,
+}) {
+}
+/** An item belongs to another release envelope. */
+export class ReleaseItemReleaseMismatchError extends Schema.TaggedError()("ReleaseItemReleaseMismatchError", { itemOffset: ItemCountSchema, releaseId: ReleaseIdSchema }) {
+}
+/** An item is missing, duplicated, or out of its signed sequence. */
+export class ReleaseItemIndexMismatchError extends Schema.TaggedError()("ReleaseItemIndexMismatchError", { actualIndex: ItemCountSchema, expectedIndex: ItemCountSchema }) {
+}
+/** Item heads are duplicated or not in canonical content-head order. */
+export class ReleaseItemOrderError extends Schema.TaggedError()("ReleaseItemOrderError", { itemOffset: ItemCountSchema }) {
+}
+/** One signed item falls outside the release's exact publication scope. */
+export class ReleaseItemScopeError extends Schema.TaggedError()("ReleaseItemScopeError", { itemOffset: ItemCountSchema }) {
+}
+/** The separate ordered items do not match the signed digest. */
+export class ReleaseItemsDigestMismatchError extends Schema.TaggedError()("ReleaseItemsDigestMismatchError", {
+    actualDigest: Sha256HashSchema,
+    expectedDigest: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+}) {
+}
+/** Verifies one item's signed release identity and sequence position. */
+function validateItemIdentity(manifest, item, expectedIndex) {
+    if (item.releaseId !== manifest.releaseId) {
+        return Effect.fail(new ReleaseItemReleaseMismatchError({
+            itemOffset: expectedIndex,
+            releaseId: manifest.releaseId,
+        }));
+    }
+    if (item.index !== expectedIndex) {
+        return Effect.fail(new ReleaseItemIndexMismatchError({
+            actualIndex: item.index,
+            expectedIndex,
+        }));
+    }
+    if (!publicationScopeSelectsContent(manifest.scope, item.change)) {
+        return Effect.fail(new ReleaseItemScopeError({ itemOffset: expectedIndex }));
+    }
+    return Effect.void;
+}
+/** Rejects a head that is duplicated or outside canonical head order. */
+function validateItemOrder(state, item) {
+    if (state.previous &&
+        compareContentHeads(state.previous.change, item.change) >= 0) {
+        return Effect.fail(new ReleaseItemOrderError({ itemOffset: item.index }));
+    }
+    state.previous = item;
+    return Effect.void;
+}
+/** Decodes one item and applies stateful canonical stream invariants. */
+const decodeItem = Effect.fn("AksaraContracts.decodeReleaseItem")(function* (manifest, state, source, itemOffset) {
+    const item = yield* Schema.decodeUnknownEffect(ContentReleaseItemSchema)(source, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new ReleaseItemDecodeError({ itemOffset })));
+    yield* validateItemIdentity(manifest, item, itemOffset);
+    yield* validateItemOrder(state, item);
+    return item;
+});
+/**
+ * Strictly decodes a replayable item stream without retaining its bodies.
+ * Every evaluation owns fresh ordering and route-collision state.
+ */
+export function decodeContentReleaseItems(input) {
+    return Stream.unwrap(Effect.sync(() => {
+        const state = { previous: undefined };
+        return input.items.pipe(Stream.zipWithIndex, Stream.mapEffect(([source, itemOffset]) => decodeItem(input.manifest, state, source, itemOffset)));
+    }));
+}
+/** Authenticates a replayable ordered stream against its signed manifest. */
+export const verifyContentReleaseItems = Effect.fn("AksaraContracts.verifyContentReleaseItems")(function* (input) {
+    const summary = yield* digestItems(input.manifest.releaseId, decodeContentReleaseItems(input));
+    if (summary.count !== input.manifest.itemCount) {
+        return yield* new ReleaseItemCountMismatchError({
+            actualCount: summary.count,
+            expectedCount: input.manifest.itemCount,
+        });
+    }
+    if (summary.deleteCount !== input.manifest.deleteCount) {
+        return yield* new ReleaseItemOperationCountMismatchError({
+            actualDeletes: summary.deleteCount,
+            actualUpserts: summary.upsertCount,
+            expectedDeletes: input.manifest.deleteCount,
+            expectedUpserts: input.manifest.upsertCount,
+        });
+    }
+    if (summary.digest !== input.manifest.itemsDigest) {
+        return yield* new ReleaseItemsDigestMismatchError({
+            actualDigest: summary.digest,
+            expectedDigest: input.manifest.itemsDigest,
+            releaseId: input.manifest.releaseId,
+        });
+    }
+    return {
+        deleteCount: summary.deleteCount,
+        upsertCount: summary.upsertCount,
+    };
+});

package/dist/release/lifecycle.d.ts

@@ -0,0 +1,297 @@
+import { Schema } from "effect";
+import { type RollbackSignedContentRelease } from "#contracts/release/spec";
+/** Maximum rows the backend may delete in one cleanup transaction. */
+export declare const MAX_CLEANUP_PAGE_COUNT = 100;
+/** Exact immutable release identity requested from durable target state. */
+export declare const ContentReleaseStatusRequestSchema: Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type ContentReleaseStatusRequest = typeof ContentReleaseStatusRequestSchema.Type;
+/** Frozen renderer and signed release required for exact crash recovery. */
+export declare const ContentReleaseBundleSchema: Schema.Struct<{
+    readonly release: Schema.Struct<{
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly manifest: Schema.Struct<{
+            readonly baseActiveAppLocales: Schema.NullOr<Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>>;
+            readonly baseManifestHash: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+            readonly baseReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+            readonly baseResultCount: Schema.Finite;
+            readonly baseResultDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly deleteCount: Schema.Finite;
+            readonly itemCount: Schema.Finite;
+            readonly itemsDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly origin: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"git">;
+                readonly sha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"rollback">;
+                readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+            }>]>;
+            readonly projectionCount: Schema.Finite;
+            readonly projectionDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+            readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly resultCount: Schema.Finite;
+            readonly resultDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly rollbackCount: Schema.Finite;
+            readonly rollbackDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly routeCount: Schema.Finite;
+            readonly routeDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly scope: Schema.Struct<{
+                content: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+                    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+                    readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+                }>>>;
+                families: Schema.$Array<Schema.Literals<readonly ["article", "material", "page", "question"]>>;
+                snapshots: Schema.$Array<Schema.Literals<readonly ["program", "quran", "tryout"]>>;
+            }>;
+            readonly snapshots: Schema.Struct<{
+                readonly program: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+                readonly quran: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+                readonly tryout: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+            }>;
+            readonly upsertCount: Schema.Finite;
+            readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+            readonly format: Schema.Literal<"localized-content-release">;
+        }>;
+        readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly rendererManifest: Schema.Struct<{
+        readonly base: Schema.Struct<{
+            authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>;
+        readonly domains: Schema.$Array<Schema.Struct<{
+            readonly authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            readonly name: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+            readonly supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>>;
+        readonly format: Schema.Literal<"nakafa-mdx-renderer-v1">;
+        readonly hash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publishedDomains: Schema.$Array<Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>>;
+        readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+    }>;
+}>;
+export type ContentReleaseBundle = typeof ContentReleaseBundleSchema.Type;
+/** Frozen renderer plus one signed rollback release at recovery boundaries. */
+export type RollbackContentReleaseBundle = ContentReleaseBundle & {
+    readonly release: RollbackSignedContentRelease;
+};
+/** Exact renderer-bound bundle accepted only for recovery publication. */
+export declare const RollbackContentReleaseBundleSchema: Schema.refine<RollbackContentReleaseBundle, Schema.Struct<{
+    readonly release: Schema.Struct<{
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly manifest: Schema.Struct<{
+            readonly baseActiveAppLocales: Schema.NullOr<Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>>;
+            readonly baseManifestHash: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+            readonly baseReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+            readonly baseResultCount: Schema.Finite;
+            readonly baseResultDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly deleteCount: Schema.Finite;
+            readonly itemCount: Schema.Finite;
+            readonly itemsDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly origin: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"git">;
+                readonly sha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"rollback">;
+                readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+            }>]>;
+            readonly projectionCount: Schema.Finite;
+            readonly projectionDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+            readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly resultCount: Schema.Finite;
+            readonly resultDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly rollbackCount: Schema.Finite;
+            readonly rollbackDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly routeCount: Schema.Finite;
+            readonly routeDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly scope: Schema.Struct<{
+                content: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+                    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+                    readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+                }>>>;
+                families: Schema.$Array<Schema.Literals<readonly ["article", "material", "page", "question"]>>;
+                snapshots: Schema.$Array<Schema.Literals<readonly ["program", "quran", "tryout"]>>;
+            }>;
+            readonly snapshots: Schema.Struct<{
+                readonly program: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+                readonly quran: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+                readonly tryout: Schema.Struct<{
+                    readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                    readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                    readonly rowCount: Schema.Int;
+                    readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                }>;
+            }>;
+            readonly upsertCount: Schema.Finite;
+            readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+            readonly format: Schema.Literal<"localized-content-release">;
+        }>;
+        readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly rendererManifest: Schema.Struct<{
+        readonly base: Schema.Struct<{
+            authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>;
+        readonly domains: Schema.$Array<Schema.Struct<{
+            readonly authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            readonly name: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+            readonly supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>>;
+        readonly format: Schema.Literal<"nakafa-mdx-renderer-v1">;
+        readonly hash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publishedDomains: Schema.$Array<Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>>;
+        readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+    }>;
+}>>;
+/** Persisted release phase bound to one exact signed manifest identity. */
+export declare const ContentReleaseStatusSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly phase: Schema.Literal<"missing">;
+}>, Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly phase: Schema.Literals<readonly ["staging", "verifying", "verified", "aborting", "aborted"]>;
+}>, Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly phase: Schema.Literal<"completed">;
+    readonly receipt: Schema.Struct<{
+        readonly activatedHeads: Schema.Finite;
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        readonly deletedHeads: Schema.Finite;
+        readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly projectionDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+        readonly resultCount: Schema.Finite;
+        readonly resultDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly routeDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly snapshots: Schema.Struct<{
+            readonly program: Schema.Struct<{
+                readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly rowCount: Schema.Int;
+                readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly quran: Schema.Struct<{
+                readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly rowCount: Schema.Int;
+                readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly tryout: Schema.Struct<{
+                readonly baseSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly mode: Schema.Literals<readonly ["inherit", "replace", "restore"]>;
+                readonly resultSnapshotId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">>;
+                readonly rowCount: Schema.Int;
+                readonly rowDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+        }>;
+        readonly stagedArtifacts: Schema.Finite;
+        readonly stagedItems: Schema.Finite;
+        readonly stagedProjections: Schema.Finite;
+        readonly stagedRoutes: Schema.Finite;
+        readonly stagedSnapshotRows: Schema.Finite;
+    }>;
+}>]>;
+export type ContentReleaseStatus = typeof ContentReleaseStatusSchema.Type;
+/** One invisible staged release whose rows should be abandoned. */
+export declare const ReleaseAbortRequestSchema: Schema.Struct<{
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type ReleaseAbortRequest = typeof ReleaseAbortRequestSchema.Type;
+/** Identifies the active release and retained inverse accepted by an operator. */
+export declare const ReleaseAcceptRequestSchema: Schema.Struct<{
+    readonly recoveryId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type ReleaseAcceptRequest = typeof ReleaseAcceptRequestSchema.Type;
+/** Durable cumulative evidence from one server-owned abort page. */
+export declare const ReleaseAbortReceiptSchema: Schema.Struct<{
+    readonly complete: Schema.Boolean;
+    readonly processedItems: Schema.Finite;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly totalItems: Schema.Finite;
+}>;
+export type ReleaseAbortReceipt = typeof ReleaseAbortReceiptSchema.Type;
+/** One release whose unreachable rows should advance through server-owned state. */
+export declare const ReleaseCleanupRequestSchema: Schema.Struct<{
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type ReleaseCleanupRequest = typeof ReleaseCleanupRequestSchema.Type;
+/** Durable cumulative evidence returned after server-owned cleanup progress. */
+export declare const ReleaseCleanupReceiptSchema: Schema.Struct<{
+    readonly complete: Schema.Boolean;
+    readonly deletedArtifacts: Schema.Finite;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly retryAt: Schema.optional<Schema.Finite>;
+}>;
+export type ReleaseCleanupReceipt = typeof ReleaseCleanupReceiptSchema.Type;