@nakafa/aksara-contracts 0.27.0

package/dist/projection/verify.d.ts

@@ -0,0 +1,281 @@
+import { Effect, Schema, Stream } from "effect";
+import type { ContentReleaseManifest } from "#contracts/release/spec";
+declare const ProjectionDecodeError_base: Schema.Class<ProjectionDecodeError, Schema.TaggedStruct<"ProjectionDecodeError", {
+    readonly projectionIndex: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** One streamed projection failed strict schema decoding. */
+export declare class ProjectionDecodeError extends ProjectionDecodeError_base {
+}
+declare const ProjectionOrderError_base: Schema.Class<ProjectionOrderError, Schema.TaggedStruct<"ProjectionOrderError", {
+    readonly projectionIndex: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Projections are duplicated or not in canonical content-head order. */
+export declare class ProjectionOrderError extends ProjectionOrderError_base {
+}
+declare const ProjectionRouteError_base: Schema.Class<ProjectionRouteError, Schema.TaggedStruct<"ProjectionRouteError", {
+    readonly duplicateIndex: Schema.Finite;
+    readonly firstIndex: Schema.Finite;
+    readonly publicPath: Schema.brand<Schema.String, "@NakafaAI/AksaraPublicPath">;
+}>, import("effect/Cause").YieldableError>;
+/** Two content projections claim the same locale-specific public route. */
+export declare class ProjectionRouteError extends ProjectionRouteError_base {
+}
+declare const ProjectionCountError_base: Schema.Class<ProjectionCountError, Schema.TaggedStruct<"ProjectionCountError", {
+    readonly actualCount: Schema.Finite;
+    readonly expectedCount: Schema.Finite;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** The streamed projection count differs from the signed manifest. */
+export declare class ProjectionCountError extends ProjectionCountError_base {
+}
+declare const ProjectionDigestError_base: Schema.Class<ProjectionDigestError, Schema.TaggedStruct<"ProjectionDigestError", {
+    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 streamed projection digest differs from the signed manifest. */
+export declare class ProjectionDigestError extends ProjectionDigestError_base {
+}
+/** Count authenticated without retaining complete projection bodies. */
+export interface VerifiedContentProjections {
+    readonly count: number;
+}
+/** Strictly decodes a replayable canonical content projection stream. */
+export declare function decodeContentProjections<E, R>(projections: Stream.Stream<unknown, E, R>): Stream.Stream<{
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly articleRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly articleSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleSlug">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly category: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleCategory">;
+    readonly categoryRouteSlug: string & import("effect/Brand").Brand<"@NakafaAI/AksaraArticleRouteSlug">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly graph: {
+        readonly alignmentId: string;
+        readonly assetId: string;
+        readonly conceptId: string;
+        readonly learningObjectId: string;
+        readonly lensId: string;
+    };
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly categoryTitle: string;
+    readonly kind: "article";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly description?: string | undefined;
+        readonly title: string;
+    };
+    readonly official: boolean;
+    readonly parentPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly references: readonly {
+        readonly authors: string;
+        readonly citation?: string | undefined;
+        readonly details?: string | undefined;
+        readonly publication?: string | undefined;
+        readonly title: string;
+        readonly url?: string | undefined;
+        readonly year: number;
+    }[];
+    readonly sitemap: true;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly graph: {
+        readonly alignmentId: string;
+        readonly assetId: string;
+        readonly conceptId: string;
+        readonly learningObjectId: string;
+        readonly lensId: string;
+    };
+    readonly materialKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialKey">;
+    readonly order: number;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly sectionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraMaterialSection">;
+    readonly kind: "subject-lesson";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly description?: string | undefined;
+        readonly subject?: string | undefined;
+        readonly title: string;
+    };
+    readonly parentPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly sitemap: true;
+    readonly topicTitle: string;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly pageKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPageKey">;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly kind: "public-page";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly description: string;
+        readonly title: string;
+    };
+    readonly sitemap: true;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+} | {
+    readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly pageKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPageKey">;
+    readonly publicPath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraPublicPath">;
+    readonly kind: "public-page";
+    readonly metadata: {
+        readonly description: string;
+        readonly lastModified: string;
+        readonly title: string;
+    };
+    readonly sitemap: true;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+} | {
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: number;
+    readonly setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: "question";
+    readonly blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    readonly kind: "question-body";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    readonly stimulusKey?: string;
+    readonly response: {
+        readonly categories: readonly {
+            readonly categoryKey: string;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly order: number;
+        }[];
+        readonly kind: "category";
+        readonly statements: readonly {
+            readonly correctCategoryKey: string;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly order: number;
+            readonly statementKey: string;
+        }[];
+    } | {
+        readonly kind: "multiple-choice";
+        readonly options: readonly {
+            readonly isCorrect: boolean;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly optionKey: string;
+            readonly order: number;
+        }[];
+    } | {
+        readonly kind: "single-choice";
+        readonly options: readonly {
+            readonly isCorrect: boolean;
+            readonly label: readonly [{
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            }, ...({
+                readonly display: "block" | "inline";
+                readonly kind: "math";
+                readonly math: string;
+            } | {
+                readonly kind: "text";
+                readonly text: string;
+            })[]];
+            readonly optionKey: string;
+            readonly order: number;
+        }[];
+    };
+} | {
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: number;
+    readonly setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: "answer";
+    readonly blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    readonly kind: "question-body";
+    readonly metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    readonly stimulusKey?: string;
+}, E | ProjectionDecodeError | ProjectionOrderError | ProjectionRouteError, R>;
+/** Authenticates a replayable projection stream against its signed manifest. */
+export declare const verifyContentProjections: <E, R>(input: {
+    readonly manifest: ContentReleaseManifest;
+    readonly projections: Stream.Stream<unknown, E, R>;
+}) => Effect.Effect<{
+    count: number;
+}, E | ProjectionCountError | ProjectionDecodeError | ProjectionDigestError | import("#contracts/projection/digest").ProjectionHashError | ProjectionOrderError | ProjectionRouteError, R>;
+export {};

package/dist/projection/verify.js

@@ -0,0 +1,86 @@
+import { Effect, Schema, Stream } from "effect";
+import { compareContentHeads, routeIdentity } from "#contracts/content";
+import { PublicPathSchema, ReleaseIdSchema, Sha256HashSchema, } from "#contracts/ids";
+import { digestProjections } from "#contracts/projection/digest";
+import { ContentProjectionSchema, } from "#contracts/projection/spec";
+const ProjectionIndexSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** One streamed projection failed strict schema decoding. */
+export class ProjectionDecodeError extends Schema.TaggedError()("ProjectionDecodeError", { projectionIndex: ProjectionIndexSchema }) {
+}
+/** Projections are duplicated or not in canonical content-head order. */
+export class ProjectionOrderError extends Schema.TaggedError()("ProjectionOrderError", { projectionIndex: ProjectionIndexSchema }) {
+}
+/** Two content projections claim the same locale-specific public route. */
+export class ProjectionRouteError extends Schema.TaggedError()("ProjectionRouteError", {
+    duplicateIndex: ProjectionIndexSchema,
+    firstIndex: ProjectionIndexSchema,
+    publicPath: PublicPathSchema,
+}) {
+}
+/** The streamed projection count differs from the signed manifest. */
+export class ProjectionCountError extends Schema.TaggedError()("ProjectionCountError", {
+    actualCount: ProjectionIndexSchema,
+    expectedCount: ProjectionIndexSchema,
+    releaseId: ReleaseIdSchema,
+}) {
+}
+/** The streamed projection digest differs from the signed manifest. */
+export class ProjectionDigestError extends Schema.TaggedError()("ProjectionDigestError", {
+    actualDigest: Sha256HashSchema,
+    expectedDigest: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+}) {
+}
+/** Decodes one row and applies canonical order and route uniqueness rules. */
+const decodeProjection = Effect.fn("AksaraContracts.decodeProjection")(function* (state, source, projectionIndex) {
+    const projection = yield* Schema.decodeUnknownEffect(ContentProjectionSchema)(source, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new ProjectionDecodeError({ projectionIndex })));
+    if (state.previous &&
+        compareContentHeads(state.previous, projection) >= 0) {
+        return yield* new ProjectionOrderError({ projectionIndex });
+    }
+    state.previous = projection;
+    if (projection.kind === "question-body") {
+        return projection;
+    }
+    const { appLocale, publicPath } = projection;
+    const identity = routeIdentity({ appLocale, publicPath });
+    const firstIndex = state.firstIndexByRoute.get(identity);
+    if (firstIndex !== undefined) {
+        return yield* new ProjectionRouteError({
+            duplicateIndex: projectionIndex,
+            firstIndex,
+            publicPath,
+        });
+    }
+    state.firstIndexByRoute.set(identity, projectionIndex);
+    return projection;
+});
+/** Strictly decodes a replayable canonical content projection stream. */
+export function decodeContentProjections(projections) {
+    return Stream.unwrap(Effect.sync(() => {
+        const state = {
+            firstIndexByRoute: new Map(),
+            previous: undefined,
+        };
+        return projections.pipe(Stream.zipWithIndex, Stream.mapEffect(([source, projectionIndex]) => decodeProjection(state, source, projectionIndex)));
+    }));
+}
+/** Authenticates a replayable projection stream against its signed manifest. */
+export const verifyContentProjections = Effect.fn("AksaraContracts.verifyContentProjections")(function* (input) {
+    const summary = yield* digestProjections(input.manifest.releaseId, decodeContentProjections(input.projections));
+    if (summary.count !== input.manifest.projectionCount) {
+        return yield* new ProjectionCountError({
+            actualCount: summary.count,
+            expectedCount: input.manifest.projectionCount,
+            releaseId: input.manifest.releaseId,
+        });
+    }
+    if (summary.digest !== input.manifest.projectionDigest) {
+        return yield* new ProjectionDigestError({
+            actualDigest: summary.digest,
+            expectedDigest: input.manifest.projectionDigest,
+            releaseId: input.manifest.releaseId,
+        });
+    }
+    return { count: summary.count };
+});

package/dist/question/identity.d.ts

@@ -0,0 +1,175 @@
+import { Schema } from "effect";
+/** Stable namespace shared by every try-out question-bank identity. */
+export declare const QUESTION_BANK_KEY_ROOT = "question-bank/tryout";
+/** Canonical terminal directory identity for one numbered question. */
+export declare const QuestionSegmentSchema: Schema.String;
+/** Authored MDX body roles carried by each localized question. */
+export declare const QuestionBodyKindSchema: Schema.Literals<readonly ["question", "answer"]>;
+export type QuestionBodyKind = typeof QuestionBodyKindSchema.Type;
+/** Generic hierarchy derived from one canonical try-out question set. */
+export declare const QuestionSetPartsSchema: Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+}>;
+export type QuestionSetParts = typeof QuestionSetPartsSchema.Type;
+/** Generic hierarchy and authored order derived from one question key. */
+export declare const QuestionKeyPartsSchema: Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly questionNumber: Schema.Finite;
+}>;
+export type QuestionKeyParts = typeof QuestionKeyPartsSchema.Type;
+/** Stable logical identity shared by every locale and body of one question. */
+export declare const QuestionKeySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+export type QuestionKey = typeof QuestionKeySchema.Type;
+/** Stable logical identity shared by every question within one authored set. */
+export declare const QuestionSetKeySchema: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionSetKey">;
+export type QuestionSetKey = typeof QuestionSetKeySchema.Type;
+/** Derives the renderer-owned bank identity above one authored set. */
+export declare function questionBankKey(questionSetKey: QuestionSetKey): string;
+/** Derives generic country, exam, bank, section, and set identities. */
+export declare function questionSetKeyParts(questionSetKey: QuestionSetKey): {
+    readonly countryKey: string;
+    readonly examKey: string;
+    readonly intermediateBankKeys: readonly string[];
+    readonly sectionKey: string;
+    readonly setKey: string;
+};
+/** Derives the parent hierarchy and safe authored order from one question. */
+export declare function questionKeyParts(questionKey: QuestionKey): {
+    countryKey: string;
+    examKey: string;
+    intermediateBankKeys: readonly string[];
+    sectionKey: string;
+    setKey: string;
+    questionNumber: number;
+    questionSetKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+};
+/** Complete physical MDX source identity derived from one question body. */
+export declare const QuestionBodySourcePartsSchema: Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly questionNumber: Schema.Finite;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly bodyKind: Schema.Literals<readonly ["question", "answer"]>;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly kind: Schema.Literal<"body">;
+}>;
+/** Complete physical TypeScript source identity for one assessment item. */
+export declare const QuestionItemSourcePartsSchema: Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly questionNumber: Schema.Finite;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly kind: Schema.Literal<"item">;
+}>;
+/** Every direct authored source accepted inside one question directory. */
+export declare const QuestionSourcePartsSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly questionNumber: Schema.Finite;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly bodyKind: Schema.Literals<readonly ["question", "answer"]>;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly kind: Schema.Literal<"body">;
+}>, Schema.Struct<{
+    readonly countryKey: Schema.String;
+    readonly examKey: Schema.String;
+    readonly intermediateBankKeys: Schema.$Array<Schema.String>;
+    readonly sectionKey: Schema.String;
+    readonly setKey: Schema.String;
+    readonly questionNumber: Schema.Finite;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    readonly kind: Schema.Literal<"item">;
+}>]>;
+export type QuestionSourceParts = typeof QuestionSourcePartsSchema.Type;
+/** Exact direct authored source path below one Aksara question directory. */
+export declare const QuestionSourcePathSchema: Schema.brand<Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">, "@NakafaAI/AksaraQuestionSourcePath">;
+export type QuestionSourcePath = typeof QuestionSourcePathSchema.Type;
+/** Derives every logical identity from one validated physical source path. */
+export declare function questionSourcePathParts(sourcePath: QuestionSourcePath): {
+    readonly countryKey: string;
+    readonly examKey: string;
+    readonly intermediateBankKeys: readonly string[];
+    readonly sectionKey: string;
+    readonly setKey: string;
+    readonly questionNumber: number;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+    readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    readonly bodyKind: "answer" | "question";
+    readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    readonly kind: "body";
+} | {
+    readonly countryKey: string;
+    readonly examKey: string;
+    readonly intermediateBankKeys: readonly string[];
+    readonly sectionKey: string;
+    readonly setKey: string;
+    readonly questionNumber: number;
+    readonly questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+    readonly kind: "item";
+};
+/** Exact stable identity carried by one localized question prompt. */
+export declare const QuestionPromptIdentitySchema: Schema.Struct<{
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: Schema.Finite;
+    readonly setKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: Schema.Literal<"question">;
+}>;
+export type QuestionPromptIdentity = typeof QuestionPromptIdentitySchema.Type;
+/** Exact stable identity carried by one localized entitled answer. */
+export declare const QuestionAnswerIdentitySchema: Schema.Struct<{
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: Schema.Finite;
+    readonly setKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: Schema.Literal<"answer">;
+}>;
+export type QuestionAnswerIdentity = typeof QuestionAnswerIdentitySchema.Type;
+/** Complete prompt and answer identity vocabulary for question bodies. */
+export declare const QuestionBodyIdentitySchema: Schema.Union<readonly [Schema.Struct<{
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: Schema.Finite;
+    readonly setKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: Schema.Literal<"question">;
+}>, Schema.Struct<{
+    readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly peerContentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly questionKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionKey">;
+    readonly questionNumber: Schema.Finite;
+    readonly setKey: Schema.brand<Schema.String, "@NakafaAI/AksaraQuestionSetKey">;
+    readonly bodyKind: Schema.Literal<"answer">;
+}>]>;
+export type QuestionBodyIdentity = typeof QuestionBodyIdentitySchema.Type;