@nakafa/aksara-contracts 0.27.0

package/dist/release/snapshot/verify.js

@@ -0,0 +1,147 @@
+import { Effect, Schema, Stream } from "effect";
+import { ContentSnapshotManifestSchema, ContentSnapshotRowSchema, } from "#contracts/release/snapshot/data";
+import { verifySnapshotRows } from "#contracts/release/snapshot/evidence";
+import { ContentSnapshotKindSchema, } from "#contracts/release/snapshot/scope";
+import { ContentSnapshotSetSchema, inheritContentSnapshots, replaceContentSnapshot, snapshotRowCount, } from "#contracts/release/snapshot/spec";
+import { tryoutSnapshotRowEvidence } from "#contracts/tryout/snapshot/hash";
+const StreamIndexSchema = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** One replacement manifest failed strict wire decoding. */
+export class SnapshotManifestDecodeError extends Schema.TaggedError()("SnapshotManifestDecodeError", { manifestIndex: StreamIndexSchema }) {
+}
+/** Replacement manifests are duplicated or outside canonical family order. */
+export class SnapshotManifestOrderError extends Schema.TaggedError()("SnapshotManifestOrderError", {
+    actualFamily: ContentSnapshotKindSchema,
+    manifestIndex: StreamIndexSchema,
+    previousFamily: ContentSnapshotKindSchema,
+}) {
+}
+/** One structured snapshot row failed strict wire decoding. */
+export class SnapshotRowDecodeError extends Schema.TaggedError()("SnapshotRowDecodeError", { rowIndex: StreamIndexSchema }) {
+}
+/** A staged row belongs to a family this release does not replace. */
+export class SnapshotRowFamilyError extends Schema.TaggedError()("SnapshotRowFamilyError", {
+    family: ContentSnapshotKindSchema,
+    rowIndex: StreamIndexSchema,
+}) {
+}
+/** A replacement manifest cannot form a coherent forward transition. */
+export class SnapshotTransitionError extends Schema.TaggedError()("SnapshotTransitionError", { family: ContentSnapshotKindSchema }) {
+}
+/** The staged row stream count differs from all signed family evidence. */
+export class SnapshotStagedCountError extends Schema.TaggedError()("SnapshotStagedCountError", {
+    actualCount: StreamIndexSchema,
+    expectedCount: StreamIndexSchema,
+    verifiedCount: StreamIndexSchema,
+}) {
+}
+const familyOrder = {
+    program: 0,
+    quran: 1,
+    tryout: 2,
+};
+/** Derives one replacement's aggregate row evidence in its owning runtime. */
+function snapshotRowEvidence(snapshot) {
+    if (snapshot.family === "program") {
+        return {
+            rowCount: snapshot.manifest.rowCount,
+            rowDigest: snapshot.manifest.rowDigest,
+        };
+    }
+    if (snapshot.family === "quran") {
+        return {
+            rowCount: snapshot.manifest.projectionCount,
+            rowDigest: snapshot.manifest.projectionDigest,
+        };
+    }
+    return tryoutSnapshotRowEvidence(snapshot.manifest);
+}
+/** Strictly decodes one manifest and advances canonical family order. */
+function decodeManifest(state, source, manifestIndex) {
+    return Schema.decodeUnknownEffect(ContentSnapshotManifestSchema)(source, {
+        onExcessProperty: "error",
+    }).pipe(Effect.mapError(() => new SnapshotManifestDecodeError({ manifestIndex })), Effect.tap((manifest) => {
+        const { previous } = state;
+        if (previous !== undefined &&
+            familyOrder[previous] >= familyOrder[manifest.family]) {
+            return Effect.fail(new SnapshotManifestOrderError({
+                actualFamily: manifest.family,
+                manifestIndex,
+                previousFamily: previous,
+            }));
+        }
+        state.previous = manifest.family;
+        return Effect.void;
+    }));
+}
+/** Strictly decodes replayable replacement manifests in canonical order. */
+export function decodeContentSnapshotManifests(manifests) {
+    return Stream.unwrap(Effect.sync(() => {
+        const state = { previous: undefined };
+        return manifests.pipe(Stream.zipWithIndex, Stream.mapEffect(([source, manifestIndex]) => decodeManifest(state, source, manifestIndex)));
+    }));
+}
+/** Strictly decodes replayable structured rows without retaining bodies. */
+export function decodeContentSnapshotRows(rows) {
+    return rows.pipe(Stream.zipWithIndex, Stream.mapEffect(([source, rowIndex]) => Schema.decodeUnknownEffect(ContentSnapshotRowSchema)(source, {
+        onExcessProperty: "error",
+    }).pipe(Effect.mapError(() => new SnapshotRowDecodeError({ rowIndex })))));
+}
+/** Replaces one inherited family state without weakening schema filters. */
+function replaceSnapshotState(snapshots, snapshot) {
+    return Effect.try({
+        catch: () => new SnapshotTransitionError({ family: snapshot.family }),
+        try: () => {
+            const baseSnapshotId = snapshots[snapshot.family].resultSnapshotId;
+            const evidence = snapshotRowEvidence(snapshot);
+            return ContentSnapshotSetSchema.make({
+                ...snapshots,
+                [snapshot.family]: replaceContentSnapshot({
+                    baseSnapshotId,
+                    resultSnapshotId: snapshot.manifest.snapshotId,
+                    ...evidence,
+                }),
+            });
+        },
+    });
+}
+/** Derives all fixed family states from prior results and replacements. */
+function deriveSnapshotSet(previousSnapshots, manifests) {
+    return Effect.reduce(manifests, () => inheritContentSnapshots(previousSnapshots), replaceSnapshotState);
+}
+/** Rejects unowned families while counting the complete staged row stream. */
+function countOwnedRows(rows, snapshots) {
+    return rows.pipe(Stream.zipWithIndex, Stream.runFoldEffect(() => 0, (count, [row, rowIndex]) => {
+        if (snapshots[row.family].mode !== "replace") {
+            return Effect.fail(new SnapshotRowFamilyError({ family: row.family, rowIndex }));
+        }
+        return Effect.succeed(count + 1);
+    }));
+}
+/** Confirms all replay passes agree with signed staged-row evidence. */
+export function verifyStagedSnapshotRows(actualRows, verifiedRows, expectedRows) {
+    if (actualRows === expectedRows && verifiedRows === expectedRows) {
+        return Effect.void;
+    }
+    return Effect.fail(new SnapshotStagedCountError({
+        actualCount: actualRows,
+        expectedCount: expectedRows,
+        verifiedCount: verifiedRows,
+    }));
+}
+/**
+ * Authenticates every replacement through replayable Stream values.
+ * Global rows may interleave families; each filtered family order stays signed.
+ */
+export const verifyContentSnapshots = Effect.fn("AksaraContracts.verifyContentSnapshots")(function* (input) {
+    const decodedManifests = decodeContentSnapshotManifests(input.manifests);
+    const manifests = yield* decodedManifests.pipe(Stream.runCollect);
+    const snapshots = yield* deriveSnapshotSet(input.previousSnapshots, manifests);
+    const actualRows = yield* countOwnedRows(decodeContentSnapshotRows(input.rows), snapshots);
+    const verifiedRows = yield* Effect.reduce(manifests, () => 0, (count, manifest) => verifySnapshotRows(manifest, decodeContentSnapshotRows(input.rows)).pipe(Effect.map((verified) => count + verified)));
+    const expectedRows = snapshotRowCount(snapshots);
+    yield* verifyStagedSnapshotRows(actualRows, verifiedRows, expectedRows);
+    return {
+        snapshots,
+        stagedRows: actualRows,
+    };
+});

package/dist/release/spec.d.ts

@@ -0,0 +1,491 @@
+import { Schema } from "effect";
+import { type ReleaseId } from "#contracts/ids";
+import { type AppLocale } from "#contracts/locale";
+/** Semantic wire identity of the current localized content release. */
+export declare const CONTENT_RELEASE_FORMAT = "localized-content-release";
+/** Nonnegative release inventory count authenticated by one manifest. */
+export declare const ReleaseCountSchema: Schema.Finite;
+/** One immutable artifact selected for a locale-specific content head. */
+export declare const ContentUpsertSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+    readonly operation: Schema.Literal<"upsert">;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>;
+/** One locale-specific content head removed by an explicit tombstone. */
+export declare const ContentDeleteSchema: 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"]>;
+    readonly operation: Schema.Literal<"delete">;
+}>;
+/** Complete tagged change vocabulary accepted by the current release. */
+export declare const ContentChangeSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+    readonly operation: Schema.Literal<"upsert">;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>, 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"]>;
+    readonly operation: Schema.Literal<"delete">;
+}>]>;
+export type ContentChange = typeof ContentChangeSchema.Type;
+export declare const ReleaseItemIndexSchema: Schema.Finite;
+/** One separately stored, ordered item authenticated by a release digest. */
+export declare const ContentReleaseItemSchema: Schema.Struct<{
+    readonly change: Schema.Union<readonly [Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+        readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+        readonly operation: Schema.Literal<"upsert">;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    }>, 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"]>;
+        readonly operation: Schema.Literal<"delete">;
+    }>]>;
+    readonly index: Schema.Finite;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type ContentReleaseItem = typeof ContentReleaseItemSchema.Type;
+/** Deterministic desired-state transition with signed source provenance. */
+export declare const ContentReleaseManifestSchema: 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">;
+}>;
+export type ContentReleaseManifest = typeof ContentReleaseManifestSchema.Type;
+/** Immutable release manifest plus its asymmetric authenticity proof. */
+export declare const SignedContentReleaseSchema: 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">;
+}>;
+export type SignedContentRelease = typeof SignedContentReleaseSchema.Type;
+/** Checks whether one application locale is active in a signed release. */
+export declare function releaseActivatesAppLocale(release: SignedContentRelease, appLocale: AppLocale): boolean;
+/** Signed release whose provenance identifies one exact rollback target. */
+export type RollbackSignedContentRelease = SignedContentRelease & {
+    readonly manifest: SignedContentRelease["manifest"] & {
+        readonly origin: {
+            readonly kind: "rollback";
+            readonly releaseId: ReleaseId;
+        };
+    };
+};
+/** Signed release contract accepted only for rollback-owned operations. */
+export declare const RollbackSignedContentReleaseSchema: Schema.refine<RollbackSignedContentRelease, 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">;
+}>>;
+/** Pre-activation evidence proving the fully staged release is coherent. */
+export declare const ReleaseVerificationEvidenceSchema: Schema.Struct<{
+    readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+    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 deleteHeads: Schema.Finite;
+    readonly itemCount: Schema.Finite;
+    readonly itemsDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    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 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 stagedRoutes: Schema.Finite;
+    readonly stagedSnapshotRows: Schema.Finite;
+    readonly upsertHeads: Schema.Finite;
+}>;
+export type ReleaseVerificationEvidence = typeof ReleaseVerificationEvidenceSchema.Type;
+/** Durable verification has started but has not produced final evidence yet. */
+export declare const ReleaseVerificationPendingSchema: Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly phase: Schema.Literal<"verifying">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+/** Durable verification completed with recomputed release evidence. */
+export declare const ReleaseVerificationCompleteSchema: Schema.Struct<{
+    readonly evidence: Schema.Struct<{
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        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 deleteHeads: Schema.Finite;
+        readonly itemCount: Schema.Finite;
+        readonly itemsDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        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 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 stagedRoutes: Schema.Finite;
+        readonly stagedSnapshotRows: Schema.Finite;
+        readonly upsertHeads: Schema.Finite;
+    }>;
+    readonly phase: Schema.Literal<"verified">;
+}>;
+/** Bounded status returned while durable verification progresses. */
+export declare const ReleaseVerificationStatusSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly phase: Schema.Literal<"verifying">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly evidence: Schema.Struct<{
+        readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+        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 deleteHeads: Schema.Finite;
+        readonly itemCount: Schema.Finite;
+        readonly itemsDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly manifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        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 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 stagedRoutes: Schema.Finite;
+        readonly stagedSnapshotRows: Schema.Finite;
+        readonly upsertHeads: Schema.Finite;
+    }>;
+    readonly phase: Schema.Literal<"verified">;
+}>]>;
+export type ReleaseVerificationStatus = typeof ReleaseVerificationStatusSchema.Type;
+/** Delta evidence returned after a release is staged and activated. */
+export declare const PublicationReceiptSchema: 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 PublicationReceipt = typeof PublicationReceiptSchema.Type;