@nakafa/aksara-contracts 0.27.0

package/dist/projection/question.d.ts

@@ -0,0 +1,520 @@
+import { Effect, Schema } from "effect";
+import type { ContentKeySchema } from "#contracts/ids";
+import type { ArtifactLocaleSchema } from "#contracts/locale";
+import { type QuestionBodyKind, type QuestionKey, type QuestionSetKey } from "#contracts/question/identity";
+import { type QuestionItem } from "#contracts/question/item";
+/** Exact metadata authored by every current question and answer body. */
+export declare const QuestionMetadataSchema: Schema.Struct<{
+    readonly dateModified: Schema.optionalKey<Schema.String>;
+    readonly datePublished: Schema.String;
+    readonly authors: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+    readonly title: Schema.String;
+}>;
+export type QuestionMetadata = typeof QuestionMetadataSchema.Type;
+/** Published body and localized response for one authored question prompt. */
+export declare const QuestionPromptProjectionSchema: 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">;
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly kind: Schema.Literal<"question-body">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly authors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+        }>>;
+        readonly title: Schema.String;
+    }>;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+    readonly response: Schema.Union<readonly [Schema.Struct<{
+        readonly categories: Schema.$Array<Schema.Struct<{
+            readonly categoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+        }>>;
+        readonly kind: Schema.Literal<"category">;
+        readonly statements: Schema.$Array<Schema.Struct<{
+            readonly correctCategoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+            readonly statementKey: Schema.String;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multiple-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"single-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>]>;
+}>;
+export type QuestionPromptProjection = typeof QuestionPromptProjectionSchema.Type;
+/** Published body for one entitled answer without a duplicated response. */
+export declare const QuestionAnswerProjectionSchema: 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">;
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly kind: Schema.Literal<"question-body">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly authors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+        }>>;
+        readonly title: Schema.String;
+    }>;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+}>;
+export type QuestionAnswerProjection = typeof QuestionAnswerProjectionSchema.Type;
+/** Complete non-route projection vocabulary for question-bank MDX bodies. */
+export declare const QuestionBodyProjectionSchema: 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">;
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly kind: Schema.Literal<"question-body">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly authors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+        }>>;
+        readonly title: Schema.String;
+    }>;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+    readonly response: Schema.Union<readonly [Schema.Struct<{
+        readonly categories: Schema.$Array<Schema.Struct<{
+            readonly categoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+        }>>;
+        readonly kind: Schema.Literal<"category">;
+        readonly statements: Schema.$Array<Schema.Struct<{
+            readonly correctCategoryKey: Schema.String;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly order: Schema.Int;
+            readonly statementKey: Schema.String;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"multiple-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"single-choice">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly isCorrect: Schema.Boolean;
+            readonly label: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+                readonly display: Schema.Literals<readonly ["block", "inline"]>;
+                readonly kind: Schema.Literal<"math">;
+                readonly math: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"text">;
+                readonly text: Schema.String;
+            }>]>>;
+            readonly optionKey: Schema.String;
+            readonly order: Schema.Int;
+        }>>;
+    }>]>;
+}>, 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">;
+    readonly blueprint: Schema.optionalKey<Schema.Struct<{
+        readonly cognitiveLevel: Schema.String;
+        readonly contentDomain: Schema.String;
+        readonly topic: Schema.String;
+    }>>;
+    readonly kind: Schema.Literal<"question-body">;
+    readonly metadata: Schema.Struct<{
+        readonly dateModified: Schema.optionalKey<Schema.String>;
+        readonly datePublished: Schema.String;
+        readonly authors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+        }>>;
+        readonly title: Schema.String;
+    }>;
+    readonly stimulusKey: Schema.optionalKey<Schema.String>;
+}>]>;
+export type QuestionBodyProjection = typeof QuestionBodyProjectionSchema.Type;
+interface QuestionProjectionInput {
+    readonly artifactLocale: typeof ArtifactLocaleSchema.Type;
+    readonly bodyKind: QuestionBodyKind;
+    readonly contentKey: typeof ContentKeySchema.Type;
+    readonly item: QuestionItem;
+    readonly metadata: QuestionMetadata;
+    readonly peerContentKey: typeof ContentKeySchema.Type;
+    readonly questionKey: QuestionKey;
+    readonly questionNumber: number;
+    readonly setKey: QuestionSetKey;
+}
+/** Builds one prompt projection with its exact-locale frozen response. */
+export declare const makeQuestionPromptProjection: (input: QuestionProjectionInput & {
+    readonly bodyKind: "question";
+}) => Effect.Effect<{
+    artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    questionNumber: number;
+    setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    stimulusKey?: string;
+    bodyKind: "question";
+    kind: "question-body";
+    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;
+        }[];
+    };
+}, import("#contracts/question/item").QuestionResponseLocaleMissingError, never>;
+/** Builds one answer projection without duplicating the prompt response. */
+export declare function makeQuestionAnswerProjection(input: QuestionProjectionInput & {
+    readonly bodyKind: "answer";
+}): {
+    artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    questionNumber: number;
+    setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    stimulusKey?: string;
+    bodyKind: "answer";
+    kind: "question-body";
+};
+/** Builds one strictly bound question or answer projection from authored facts. */
+export declare const makeQuestionBodyProjection: (input: QuestionProjectionInput) => Effect.Effect<{
+    artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    questionNumber: number;
+    setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    stimulusKey?: string;
+    bodyKind: "question";
+    kind: "question-body";
+    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;
+        }[];
+    };
+} | {
+    artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+    contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    metadata: {
+        readonly dateModified?: string;
+        readonly datePublished: string;
+        readonly authors: readonly {
+            readonly name: string;
+        }[];
+        readonly title: string;
+    };
+    peerContentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+    questionKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionKey">;
+    questionNumber: number;
+    setKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraQuestionSetKey">;
+    blueprint?: {
+        readonly cognitiveLevel: string;
+        readonly contentDomain: string;
+        readonly topic: string;
+    };
+    stimulusKey?: string;
+    bodyKind: "answer";
+    kind: "question-body";
+}, import("#contracts/question/item").QuestionResponseLocaleMissingError, never>;
+/** Serializes one question projection with stable signed field order. */
+export declare function canonicalizeQuestionProjection(projection: QuestionBodyProjection): string;
+export {};

package/dist/projection/question.js

@@ -0,0 +1,109 @@
+import { Effect, Schema } from "effect";
+import { ContentAuthorSchema } from "#contracts/content";
+import { withPublicationDates } from "#contracts/date";
+import { QuestionAnswerIdentitySchema, QuestionPromptIdentitySchema, } from "#contracts/question/identity";
+import { canonicalQuestionBlueprint, QuestionBlueprintSchema, questionResponseFor, } from "#contracts/question/item";
+import { canonicalQuestionResponse, QuestionResponseSchema, } from "#contracts/question/response";
+import { TryoutKeySchema } from "#contracts/tryout/key";
+/** Exact metadata authored by every current question and answer body. */
+export const QuestionMetadataSchema = withPublicationDates({
+    authors: Schema.Array(ContentAuthorSchema),
+    title: Schema.String,
+});
+const QuestionProjectionFields = {
+    blueprint: Schema.optionalKey(QuestionBlueprintSchema),
+    kind: Schema.Literal("question-body"),
+    metadata: QuestionMetadataSchema,
+    stimulusKey: Schema.optionalKey(TryoutKeySchema),
+};
+/** Published body and localized response for one authored question prompt. */
+export const QuestionPromptProjectionSchema = QuestionPromptIdentitySchema.mapFields((fields) => ({
+    ...fields,
+    ...QuestionProjectionFields,
+    response: QuestionResponseSchema,
+}), { unsafePreserveChecks: true });
+/** Published body for one entitled answer without a duplicated response. */
+export const QuestionAnswerProjectionSchema = QuestionAnswerIdentitySchema.mapFields((fields) => ({ ...fields, ...QuestionProjectionFields }), { unsafePreserveChecks: true });
+/** Complete non-route projection vocabulary for question-bank MDX bodies. */
+export const QuestionBodyProjectionSchema = Schema.Union([
+    QuestionPromptProjectionSchema,
+    QuestionAnswerProjectionSchema,
+]);
+/** Shared identity and metadata carried by both question body projections. */
+function questionProjectionFields(input) {
+    return {
+        artifactLocale: input.artifactLocale,
+        contentKey: input.contentKey,
+        metadata: input.metadata,
+        peerContentKey: input.peerContentKey,
+        questionKey: input.questionKey,
+        questionNumber: input.questionNumber,
+        setKey: input.setKey,
+        ...(input.item.blueprint === undefined
+            ? {}
+            : { blueprint: input.item.blueprint }),
+        ...(input.item.stimulusKey === undefined
+            ? {}
+            : { stimulusKey: input.item.stimulusKey }),
+    };
+}
+/** Builds one prompt projection with its exact-locale frozen response. */
+export const makeQuestionPromptProjection = Effect.fn("AksaraContracts.makeQuestionPromptProjection")(function* (input) {
+    const response = yield* questionResponseFor(input.item, input.artifactLocale);
+    return {
+        ...questionProjectionFields(input),
+        bodyKind: "question",
+        kind: "question-body",
+        response,
+    };
+});
+/** Builds one answer projection without duplicating the prompt response. */
+export function makeQuestionAnswerProjection(input) {
+    return {
+        ...questionProjectionFields(input),
+        bodyKind: "answer",
+        kind: "question-body",
+    };
+}
+/** Builds one strictly bound question or answer projection from authored facts. */
+export const makeQuestionBodyProjection = Effect.fn("AksaraContracts.makeQuestionBodyProjection")(function* (input) {
+    if (input.bodyKind === "question") {
+        return yield* makeQuestionPromptProjection({
+            ...input,
+            bodyKind: "question",
+        });
+    }
+    return makeQuestionAnswerProjection({ ...input, bodyKind: "answer" });
+});
+/** Serializes one question projection with stable signed field order. */
+export function canonicalizeQuestionProjection(projection) {
+    return JSON.stringify({
+        bodyKind: projection.bodyKind,
+        ...(projection.bodyKind === "question"
+            ? {
+                response: canonicalQuestionResponse(projection.response),
+            }
+            : {}),
+        artifactLocale: projection.artifactLocale,
+        ...(projection.blueprint === undefined
+            ? {}
+            : { blueprint: canonicalQuestionBlueprint(projection.blueprint) }),
+        contentKey: projection.contentKey,
+        kind: projection.kind,
+        metadata: {
+            authors: projection.metadata.authors.map(({ name }) => ({ name })),
+            ...(projection.metadata.dateModified === undefined
+                ? {}
+                : { dateModified: projection.metadata.dateModified }),
+            datePublished: projection.metadata.datePublished,
+            title: projection.metadata.title,
+        },
+        peerContentKey: projection.peerContentKey,
+        questionKey: projection.questionKey,
+        questionNumber: projection.questionNumber,
+        setKey: projection.setKey,
+        ...(projection.stimulusKey === undefined
+            ? {}
+            : { stimulusKey: projection.stimulusKey }),
+    });
+}