@nakafa/aksara-contracts 0.27.0

package/dist/release/current/state.js

@@ -0,0 +1,91 @@
+import { Schema } from "effect";
+import { ActiveContentReleaseSchema, hasSameAppLocales, } from "#contracts/release/current/evidence";
+import { hasCurrentTryoutRuntimeBundle } from "#contracts/release/current/runtime";
+import { ContentReleaseBundleSchema, } from "#contracts/release/lifecycle";
+import { EMPTY_RESULT_CATALOG_DIGEST } from "#contracts/release/result/spec";
+import { hasSameContentSnapshots, invertContentSnapshots, } from "#contracts/release/snapshot/spec";
+import { SignedTryoutRuntimeBundleSchema } from "#contracts/tryout/runtime/spec";
+const TryoutRuntimeBundleSchema = Schema.NullOr(SignedTryoutRuntimeBundleSchema);
+const StagedReleasePhaseSchema = Schema.Literals([
+    "staging",
+    "verifying",
+    "verified",
+    "aborting",
+]);
+/** Exact durable release bundle currently owning one invisible slot. */
+export const StagedContentReleaseSchema = ContentReleaseBundleSchema.mapFields((fields) => ({ ...fields, phase: StagedReleasePhaseSchema }), { unsafePreserveChecks: true });
+/** Candidate recovery slot accepted only when it contains a rollback. */
+export const StagedRollbackContentReleaseSchema = StagedContentReleaseSchema.pipe(Schema.refine((release) => release.release.manifest.origin.kind === "rollback", { message: "Expected a staged rollback release." }));
+/** Checks one candidate against its exact active base or genesis identity. */
+function hasCoherentCandidate(active, candidate) {
+    if (candidate === null) {
+        return true;
+    }
+    const { manifest } = candidate.release;
+    if (active === null) {
+        return (manifest.baseReleaseId === null &&
+            manifest.baseManifestHash === null &&
+            manifest.baseActiveAppLocales === null &&
+            manifest.baseResultCount === 0 &&
+            manifest.baseResultDigest === EMPTY_RESULT_CATALOG_DIGEST);
+    }
+    const activeManifest = active.release.manifest;
+    return (activeManifest.releaseId === manifest.baseReleaseId &&
+        active.release.manifestHash === manifest.baseManifestHash &&
+        activeManifest.resultCount === manifest.baseResultCount &&
+        activeManifest.resultDigest === manifest.baseResultDigest &&
+        manifest.baseActiveAppLocales !== null &&
+        hasSameAppLocales(activeManifest.activeAppLocales, manifest.baseActiveAppLocales));
+}
+/** Checks one retained inverse against the candidate or active target it restores. */
+function hasCoherentRecovery(input) {
+    if (input.recovery === null) {
+        return true;
+    }
+    const target = input.candidate ?? input.active;
+    if (target === null) {
+        return false;
+    }
+    const pairedCandidate = input.candidate !== null;
+    if (pairedCandidate &&
+        (input.candidate.phase !== "verified" ||
+            input.recovery.phase === "aborting")) {
+        return false;
+    }
+    if (!pairedCandidate &&
+        input.recovery.phase !== "verified" &&
+        input.recovery.phase !== "aborting") {
+        return false;
+    }
+    const { manifest } = input.recovery.release;
+    const targetManifest = target.release.manifest;
+    const restoredActiveAppLocales = targetManifest.baseActiveAppLocales ?? targetManifest.activeAppLocales;
+    return (manifest.origin.releaseId === targetManifest.releaseId &&
+        manifest.baseReleaseId === targetManifest.releaseId &&
+        manifest.baseManifestHash === target.release.manifestHash &&
+        manifest.baseResultCount === targetManifest.resultCount &&
+        manifest.baseResultDigest === targetManifest.resultDigest &&
+        manifest.baseActiveAppLocales !== null &&
+        hasSameAppLocales(manifest.baseActiveAppLocales, targetManifest.activeAppLocales) &&
+        manifest.resultCount === targetManifest.baseResultCount &&
+        manifest.resultDigest === targetManifest.baseResultDigest &&
+        hasSameAppLocales(manifest.activeAppLocales, restoredActiveAppLocales) &&
+        manifest.releaseId !== input.active?.release.manifest.releaseId &&
+        hasSameContentSnapshots(manifest.snapshots, invertContentSnapshots(targetManifest.snapshots)) &&
+        input.recovery.rendererManifest.hash === target.rendererManifest.hash);
+}
+/** Checks the candidate and retained inverse against their exact bases. */
+function hasCoherentCurrentState(input) {
+    return (hasCoherentCandidate(input.active, input.candidate) &&
+        hasCoherentRecovery(input) &&
+        hasCurrentTryoutRuntimeBundle(input.active, input.tryoutRuntimeBundle));
+}
+/** Authoritative singleton publication state used before release preparation. */
+export const ContentReleaseCurrentSchema = Schema.Struct({
+    active: Schema.NullOr(ActiveContentReleaseSchema),
+    candidate: Schema.NullOr(StagedContentReleaseSchema),
+    recovery: Schema.NullOr(StagedRollbackContentReleaseSchema),
+    tryoutRuntimeBundle: TryoutRuntimeBundleSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentCurrentState, {
+    message: "Expected active, candidate, and recovery identities to be coherent.",
+})));

package/dist/release/digest.d.ts

@@ -0,0 +1,54 @@
+import { Effect, Schema, Stream } from "effect";
+import { type ReleaseId } from "#contracts/ids";
+import type { ContentReleaseItem } from "#contracts/release/spec";
+declare const ReleaseItemsHashComputationError_base: Schema.Class<ReleaseItemsHashComputationError, Schema.TaggedStruct<"ReleaseItemsHashComputationError", {
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 computation failed before item integrity was established. */
+export declare class ReleaseItemsHashComputationError extends ReleaseItemsHashComputationError_base {
+}
+/** Keeps Node hash state private while exposing canonical operation counts. */
+declare class ReleaseItemsDigestState {
+    #private;
+    count: number;
+    deleteCount: number;
+    upsertCount: number;
+    /** Initializes a domain-separated incremental release-item hash. */
+    constructor();
+    /** Adds one canonical release item and updates operation counts. */
+    update(item: ContentReleaseItem): void;
+    /** Consumes the hash and returns its branded immutable identity. */
+    digest(): string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}
+/** Creates a fresh domain-separated digest state for one release stream. */
+export declare function createReleaseItemsDigest(releaseId: ReleaseId): Effect.Effect<ReleaseItemsDigestState, ReleaseItemsHashComputationError, never>;
+/** Adds one canonical release item to its incremental digest and counts. */
+export declare function updateReleaseItemsDigest(releaseId: ReleaseId, state: ReleaseItemsDigestState, item: ContentReleaseItem): Effect.Effect<ReleaseItemsDigestState, ReleaseItemsHashComputationError, never>;
+/** Finalizes one incremental release-item digest with typed hash failures. */
+export declare function finalizeReleaseItemsDigest(releaseId: ReleaseId, state: ReleaseItemsDigestState): Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, ReleaseItemsHashComputationError, never>;
+/** Digests a release-item stream without retaining its content changes. */
+export declare const digestItems: <E, R>(releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">, items: 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, R>) => Effect.Effect<{
+    count: number;
+    deleteCount: number;
+    digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    upsertCount: number;
+}, E | ReleaseItemsHashComputationError, R>;
+export {};

package/dist/release/digest.js

@@ -0,0 +1,71 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema, Stream } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema, } from "#contracts/ids";
+import { canonicalizeContentReleaseItem } from "#contracts/release/canonical";
+const CONTENT_RELEASE_ITEMS_DIGEST_DOMAIN = "nakafa.aksara.content-release-items";
+/** SHA-256 computation failed before item integrity was established. */
+export class ReleaseItemsHashComputationError extends Schema.TaggedError()("ReleaseItemsHashComputationError", { releaseId: ReleaseIdSchema }) {
+}
+/** Keeps Node hash state private while exposing canonical operation counts. */
+class ReleaseItemsDigestState {
+    #hash = createHash("sha256");
+    count = 0;
+    deleteCount = 0;
+    upsertCount = 0;
+    /** Initializes a domain-separated incremental release-item hash. */
+    constructor() {
+        this.#hash.update(CONTENT_RELEASE_ITEMS_DIGEST_DOMAIN);
+        this.#hash.update("\n");
+    }
+    /** Adds one canonical release item and updates operation counts. */
+    update(item) {
+        this.#hash.update(canonicalizeContentReleaseItem(item));
+        this.#hash.update("\n");
+        this.count += 1;
+        if (item.change.operation === "delete") {
+            this.deleteCount += 1;
+            return;
+        }
+        this.upsertCount += 1;
+    }
+    /** Consumes the hash and returns its branded immutable identity. */
+    digest() {
+        return Sha256HashSchema.make(`sha256:${this.#hash.digest("hex")}`);
+    }
+}
+/** Creates a fresh domain-separated digest state for one release stream. */
+export function createReleaseItemsDigest(releaseId) {
+    return Effect.try({
+        catch: () => new ReleaseItemsHashComputationError({ releaseId }),
+        try: () => new ReleaseItemsDigestState(),
+    });
+}
+/** Adds one canonical release item to its incremental digest and counts. */
+export function updateReleaseItemsDigest(releaseId, state, item) {
+    return Effect.try({
+        catch: () => new ReleaseItemsHashComputationError({ releaseId }),
+        try: () => {
+            state.update(item);
+            return state;
+        },
+    });
+}
+/** Finalizes one incremental release-item digest with typed hash failures. */
+export function finalizeReleaseItemsDigest(releaseId, state) {
+    return Effect.try({
+        catch: () => new ReleaseItemsHashComputationError({ releaseId }),
+        try: () => state.digest(),
+    });
+}
+/** Digests a release-item stream without retaining its content changes. */
+export const digestItems = Effect.fn("AksaraContracts.digestItems")(function* (releaseId, items) {
+    const initial = yield* createReleaseItemsDigest(releaseId);
+    const state = yield* items.pipe(Stream.runFoldEffect(() => initial, (current, item) => updateReleaseItemsDigest(releaseId, current, item)));
+    const digest = yield* finalizeReleaseItemsDigest(releaseId, state);
+    return {
+        count: state.count,
+        deleteCount: state.deleteCount,
+        digest,
+        upsertCount: state.upsertCount,
+    };
+});

package/dist/release/hash.d.ts

@@ -0,0 +1,72 @@
+import { Effect, Schema } from "effect";
+declare const ReleaseHashComputationError_base: Schema.Class<ReleaseHashComputationError, Schema.TaggedStruct<"ReleaseHashComputationError", {
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 computation failed before release authenticity was established. */
+export declare class ReleaseHashComputationError extends ReleaseHashComputationError_base {
+}
+/** Computes the immutable identity of one canonical release manifest. */
+export declare const hashContentReleaseManifest: (manifest: {
+    readonly baseActiveAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]] | null;
+    readonly baseManifestHash: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+    readonly baseReleaseId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">) | null;
+    readonly baseResultCount: number;
+    readonly baseResultDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly deleteCount: number;
+    readonly itemCount: number;
+    readonly itemsDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly origin: {
+        readonly kind: "git";
+        readonly sha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+    } | {
+        readonly kind: "rollback";
+        readonly releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+    };
+    readonly projectionCount: number;
+    readonly projectionDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+    readonly rendererContractVersion: "1.0.0";
+    readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly resultCount: number;
+    readonly resultDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly rollbackCount: number;
+    readonly rollbackDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly routeCount: number;
+    readonly routeDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly scope: {
+        readonly content?: readonly {
+            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";
+        }[] | undefined;
+        readonly families: readonly ("article" | "material" | "page" | "question")[];
+        readonly snapshots: readonly ("program" | "quran" | "tryout")[];
+    };
+    readonly snapshots: {
+        readonly program: {
+            readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly mode: "inherit" | "replace" | "restore";
+            readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly rowCount: number;
+            readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        };
+        readonly quran: {
+            readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly mode: "inherit" | "replace" | "restore";
+            readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly rowCount: number;
+            readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        };
+        readonly tryout: {
+            readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly mode: "inherit" | "replace" | "restore";
+            readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+            readonly rowCount: number;
+            readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        };
+    };
+    readonly upsertCount: number;
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly format: "localized-content-release";
+}) => Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, ReleaseHashComputationError, never>;
+export {};

package/dist/release/hash.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema } from "#contracts/ids";
+import { canonicalizeContentReleaseManifest } from "#contracts/release/signing";
+/** SHA-256 computation failed before release authenticity was established. */
+export class ReleaseHashComputationError extends Schema.TaggedError()("ReleaseHashComputationError", { releaseId: ReleaseIdSchema }) {
+}
+/** Computes the immutable identity of one canonical release manifest. */
+export const hashContentReleaseManifest = Effect.fn("AksaraContracts.hashContentReleaseManifest")((manifest) => Effect.try({
+    catch: () => new ReleaseHashComputationError({ releaseId: manifest.releaseId }),
+    try: () => Sha256HashSchema.make(`sha256:${createHash("sha256")
+        .update(canonicalizeContentReleaseManifest(manifest))
+        .digest("hex")}`),
+}));

package/dist/release/head.d.ts

@@ -0,0 +1,206 @@
+import { Schema } from "effect";
+/** Compact authoritative identity used to diff one published article head. */
+export declare const ArticleHeadSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"article">;
+}>;
+export type ArticleHead = typeof ArticleHeadSchema.Type;
+/** Compact authoritative identity used to diff one published material head. */
+export declare const MaterialHeadSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"material">;
+}>;
+export type MaterialHead = typeof MaterialHeadSchema.Type;
+/** Compact authoritative identity used to diff one published page head. */
+export declare const PageHeadSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"page">;
+}>;
+export type PageHead = typeof PageHeadSchema.Type;
+/** Compact authoritative identity used to diff one published question body. */
+export declare const QuestionHeadSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"question">;
+}>;
+export type QuestionHead = typeof QuestionHeadSchema.Type;
+/** Complete compact-head vocabulary backed by implemented content families. */
+export declare const ContentHeadSchema: 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 compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"article">;
+}>, Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"material">;
+}>, Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"page">;
+}>, Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+    readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+    readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly family: Schema.Literal<"question">;
+}>]>;
+export type ContentHead = typeof ContentHeadSchema.Type;
+/** Serializes one compact head in stable catalog field order. */
+export declare function canonicalizeContentHead(head: ContentHead): string;
+/** Requests one bounded family-owned head page from an exact active release. */
+export declare const HeadPageRequestSchema: Schema.Struct<{
+    readonly activeManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly activeReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly cursor: Schema.NullOr<Schema.Trimmed>;
+    readonly family: Schema.Literals<readonly ["article", "material", "page", "question"]>;
+    readonly limit: Schema.Finite;
+}>;
+export type HeadPageRequest = typeof HeadPageRequestSchema.Type;
+/** Bounded canonical page proving one exact family-owned head inventory. */
+export declare const HeadPageSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly activeManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly activeReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly cursor: Schema.NullOr<Schema.Trimmed>;
+    readonly done: Schema.Boolean;
+    readonly nextCursor: Schema.NullOr<Schema.Trimmed>;
+    readonly family: Schema.Literal<"article">;
+    readonly heads: Schema.$Array<Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+        readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+        readonly family: Schema.Literal<"article">;
+    }>>;
+}>, Schema.Struct<{
+    readonly activeManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly activeReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly cursor: Schema.NullOr<Schema.Trimmed>;
+    readonly done: Schema.Boolean;
+    readonly nextCursor: Schema.NullOr<Schema.Trimmed>;
+    readonly family: Schema.Literal<"material">;
+    readonly heads: Schema.$Array<Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+        readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+        readonly family: Schema.Literal<"material">;
+    }>>;
+}>, Schema.Struct<{
+    readonly activeManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly activeReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly cursor: Schema.NullOr<Schema.Trimmed>;
+    readonly done: Schema.Boolean;
+    readonly nextCursor: Schema.NullOr<Schema.Trimmed>;
+    readonly family: Schema.Literal<"page">;
+    readonly heads: Schema.$Array<Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+        readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+        readonly family: Schema.Literal<"page">;
+    }>>;
+}>, Schema.Struct<{
+    readonly activeManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly activeReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly cursor: Schema.NullOr<Schema.Trimmed>;
+    readonly done: Schema.Boolean;
+    readonly nextCursor: Schema.NullOr<Schema.Trimmed>;
+    readonly family: Schema.Literal<"question">;
+    readonly heads: Schema.$Array<Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+        readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["public", "authenticated", "entitled"]>;
+        readonly projectionHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publicPath: Schema.optional<Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">>;
+        readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+        readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+        readonly family: Schema.Literal<"question">;
+    }>>;
+}>]>;
+export type HeadPage = typeof HeadPageSchema.Type;