@nakafa/aksara-contracts 0.27.0

package/dist/renderer/selection.js

@@ -0,0 +1,87 @@
+import { Effect } from "effect";
+import { decodeContract } from "#contracts/decode";
+import { RendererAuthoringComponentDuplicateError, RendererAuthoringComponentExtraError, RendererAuthoringComponentMissingError, RendererAuthoringComponentsSchema, RendererAuthoringComponentUnsupportedError, RendererAuthoringSelectionNonCanonicalError, RendererCapabilitySchema, RendererManifestAuthoringComponentsSchema, RendererManifestSupportedComponentsSchema, RendererSupportedComponentsSchema, sortRendererComponentRequirements, } from "#contracts/renderer/component";
+import { RendererDomainCapabilitySchema, RendererManifestDomainsSchema, sortRendererDomains, } from "#contracts/renderer/contract";
+/** Rejects duplicate component names in one authoring selection. */
+const validateUniqueAuthoringNames = Effect.fn("AksaraContracts.validateUniqueAuthoringNames")(function* (authoringComponents) {
+    const selectedNames = new Set();
+    for (const selection of authoringComponents) {
+        if (selectedNames.has(selection.name)) {
+            return yield* new RendererAuthoringComponentDuplicateError({
+                componentName: selection.name,
+            });
+        }
+        selectedNames.add(selection.name);
+    }
+    return selectedNames;
+});
+/** Rejects authoring selections that are not canonically ordered. */
+const validateCanonicalAuthoringOrder = Effect.fn("AksaraContracts.validateCanonicalAuthoringOrder")(function* (authoringComponents) {
+    const sorted = sortRendererComponentRequirements(authoringComponents);
+    for (const [index, selection] of authoringComponents.entries()) {
+        const canonical = sorted[index];
+        if (canonical?.name !== selection.name ||
+            canonical.version !== selection.version) {
+            return yield* new RendererAuthoringSelectionNonCanonicalError({
+                componentName: selection.name,
+                index,
+            });
+        }
+    }
+});
+/** Rejects authoring pins that the selected registry cannot render. */
+const validateSupportedAuthoringSelections = Effect.fn("AksaraContracts.validateSupportedAuthoringSelections")(function* (supportedComponents, authoringComponents) {
+    for (const selection of authoringComponents) {
+        const supportedVersions = supportedComponents.filter(({ name }) => name === selection.name);
+        if (supportedVersions.length === 0) {
+            return yield* new RendererAuthoringComponentExtraError({
+                componentName: selection.name,
+            });
+        }
+        if (!supportedVersions.some(({ version }) => version === selection.version)) {
+            return yield* new RendererAuthoringComponentUnsupportedError({
+                componentName: selection.name,
+                version: selection.version,
+            });
+        }
+    }
+});
+/** Requires one authoring version for every supported component name. */
+const validateCompleteAuthoringNames = Effect.fn("AksaraContracts.validateCompleteAuthoringNames")(function* (supportedComponents, selectedNames) {
+    for (const supported of supportedComponents) {
+        if (!selectedNames.has(supported.name)) {
+            return yield* new RendererAuthoringComponentMissingError({
+                componentName: supported.name,
+            });
+        }
+    }
+});
+/** Normalizes one complete physical registry component contract. */
+const normalizeRendererCapability = Effect.fn("AksaraContracts.normalizeRendererCapability")(function* (input, allowEmpty) {
+    const supportedSchema = allowEmpty
+        ? RendererSupportedComponentsSchema
+        : RendererManifestSupportedComponentsSchema;
+    const authoringSchema = allowEmpty
+        ? RendererAuthoringComponentsSchema
+        : RendererManifestAuthoringComponentsSchema;
+    const supportedComponents = yield* decodeContract(supportedSchema, "RendererManifestSupportedComponents", sortRendererComponentRequirements(input.supportedComponents));
+    const selectedNames = yield* validateUniqueAuthoringNames(input.authoringComponents);
+    yield* validateCanonicalAuthoringOrder(input.authoringComponents);
+    yield* validateSupportedAuthoringSelections(supportedComponents, input.authoringComponents);
+    yield* validateCompleteAuthoringNames(supportedComponents, selectedNames);
+    const authoringComponents = yield* decodeContract(authoringSchema, "RendererManifestAuthoringComponents", input.authoringComponents);
+    if (allowEmpty) {
+        return { authoringComponents, supportedComponents };
+    }
+    return yield* decodeContract(RendererCapabilitySchema, "RendererCapability", {
+        authoringComponents,
+        supportedComponents,
+    });
+});
+/** Normalizes the exact base plus every canonical route-domain registry. */
+export const normalizeRendererSelection = Effect.fn("AksaraContracts.normalizeRendererSelection")(function* (input) {
+    const base = yield* normalizeRendererCapability(input.base, false);
+    const domains = yield* Effect.forEach(input.domains, (domain) => normalizeRendererCapability(domain, true).pipe(Effect.flatMap((capability) => decodeContract(RendererDomainCapabilitySchema, "RendererDomainCapability", { name: domain.name, ...capability }))));
+    const canonicalDomains = yield* decodeContract(RendererManifestDomainsSchema, "RendererManifestDomains", sortRendererDomains(domains));
+    return { base, domains: canonicalDomains };
+});

package/dist/runtime/error.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+declare const ContentRuntimeMismatchError_base: Schema.Class<ContentRuntimeMismatchError, Schema.TaggedStruct<"ContentRuntimeMismatchError", {
+    readonly reason: Schema.Literals<readonly ["activeManifestHash", "activeReleaseId", "artifactHash", "bundleHash", "contentKey", "delivery", "locale", "projectionHash", "publicPath", "rendererManifest", "selectorCount", "snapshotId", "sourcePath"]>;
+}>, import("effect/Cause").YieldableError>;
+/** A decoded runtime response does not belong to its initiating request. */
+export declare class ContentRuntimeMismatchError extends ContentRuntimeMismatchError_base {
+}
+export {};

package/dist/runtime/error.js

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+/** A decoded runtime response does not belong to its initiating request. */
+export class ContentRuntimeMismatchError extends Schema.TaggedError()("ContentRuntimeMismatchError", {
+    reason: Schema.Literals([
+        "activeManifestHash",
+        "activeReleaseId",
+        "artifactHash",
+        "bundleHash",
+        "contentKey",
+        "delivery",
+        "locale",
+        "projectionHash",
+        "publicPath",
+        "rendererManifest",
+        "selectorCount",
+        "snapshotId",
+        "sourcePath",
+    ]),
+}) {
+}

package/dist/runtime/protected/limits.d.ts

@@ -0,0 +1,10 @@
+/** Maximum protected selectors accepted in one retained-snapshot read. */
+export declare const MAX_PROTECTED_RUNTIME_SELECTORS = 64;
+/** Maximum UTF-8 bytes accepted by the protected batch endpoint. */
+export declare const MAX_PROTECTED_RUNTIME_REQUEST_BYTES: number;
+/** Maximum UTF-8 bytes returned by the protected batch endpoint. */
+export declare const MAX_PROTECTED_RUNTIME_RESPONSE_BYTES: number;
+/** Measures the exact JSON bytes written by the protected HTTP response. */
+export declare function protectedRuntimeResponseBytes(response: object): number;
+/** Keeps every found result inside the protected response wire ceiling. */
+export declare function hasBoundedProtectedRuntimeResponse(response: object): boolean;

package/dist/runtime/protected/limits.js

@@ -0,0 +1,15 @@
+/** Maximum protected selectors accepted in one retained-snapshot read. */
+export const MAX_PROTECTED_RUNTIME_SELECTORS = 64;
+/** Maximum UTF-8 bytes accepted by the protected batch endpoint. */
+export const MAX_PROTECTED_RUNTIME_REQUEST_BYTES = 64 * 1024;
+/** Maximum UTF-8 bytes returned by the protected batch endpoint. */
+export const MAX_PROTECTED_RUNTIME_RESPONSE_BYTES = 4 * 1024 * 1024;
+/** Measures the exact JSON bytes written by the protected HTTP response. */
+export function protectedRuntimeResponseBytes(response) {
+    return new TextEncoder().encode(JSON.stringify(response)).byteLength;
+}
+/** Keeps every found result inside the protected response wire ceiling. */
+export function hasBoundedProtectedRuntimeResponse(response) {
+    return (protectedRuntimeResponseBytes(response) <=
+        MAX_PROTECTED_RUNTIME_RESPONSE_BYTES);
+}

package/dist/runtime/protected/spec.d.ts

@@ -0,0 +1,328 @@
+import { Effect, Schema } from "effect";
+/** One exact frozen try-out body selected after product authorization. */
+export declare const ProtectedContentRuntimeSelectorSchema: Schema.Struct<{
+    readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly delivery: Schema.Literals<readonly ["authenticated", "entitled"]>;
+}>;
+export type ProtectedContentRuntimeSelector = typeof ProtectedContentRuntimeSelectorSchema.Type;
+/** One bounded protected read bound to a permanent signed runtime bundle. */
+export declare const ProtectedContentRuntimeRequestSchema: Schema.Struct<{
+    readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly selectors: Schema.$Array<Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+        readonly delivery: Schema.Literals<readonly ["authenticated", "entitled"]>;
+    }>>;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>;
+export type ProtectedContentRuntimeRequest = typeof ProtectedContentRuntimeRequestSchema.Type;
+/** One selected artifact inside a protected batch response. */
+export declare const ProtectedContentRuntimeItemSchema: Schema.Struct<{
+    readonly artifact: Schema.Struct<{
+        readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: Schema.Struct<{
+            readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+            readonly byteLength: Schema.Finite;
+            readonly compiledCode: Schema.String;
+            readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly compilerVersion: Schema.Literal<"0.1.0">;
+            readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+            readonly format: Schema.Literal<"mdx-function-body">;
+            readonly mdxCompilerVersion: Schema.Literal<"3.1.1">;
+            readonly plainText: Schema.String;
+            readonly rawMdx: Schema.String;
+            readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+            readonly requiredComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        }>;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["authenticated", "entitled"]>;
+    readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+}>;
+export type ProtectedContentRuntimeItem = typeof ProtectedContentRuntimeItemSchema.Type;
+/** Protected frozen bodies selected from one retained try-out snapshot. */
+export declare const ProtectedContentRuntimeFoundSchema: Schema.Struct<{
+    readonly bundle: Schema.Struct<{
+        readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: Schema.Struct<{
+            readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly snapshot: Schema.Struct<{
+                readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+                readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly counts: Schema.Struct<{
+                    readonly country: Schema.Int;
+                    readonly exam: Schema.Int;
+                    readonly section: Schema.Int;
+                    readonly set: Schema.Int;
+                    readonly track: Schema.Int;
+                }>;
+                readonly placementCount: Schema.Int;
+                readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly routeCount: Schema.Int;
+                readonly format: Schema.Literal<"localized-tryout-snapshot">;
+                readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+        }>;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly artifact: Schema.Struct<{
+            readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+            readonly payload: Schema.Struct<{
+                readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+                readonly byteLength: Schema.Finite;
+                readonly compiledCode: Schema.String;
+                readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly compilerVersion: Schema.Literal<"0.1.0">;
+                readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+                readonly format: Schema.Literal<"mdx-function-body">;
+                readonly mdxCompilerVersion: Schema.Literal<"3.1.1">;
+                readonly plainText: Schema.String;
+                readonly rawMdx: Schema.String;
+                readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+                readonly requiredComponents: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly version: Schema.Finite;
+                }>>;
+                readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+        }>;
+        readonly delivery: Schema.Literals<readonly ["authenticated", "entitled"]>;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    }>>;
+    readonly kind: Schema.Literal<"found">;
+    readonly rendererManifest: Schema.Struct<{
+        readonly base: Schema.Struct<{
+            authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>;
+        readonly domains: Schema.$Array<Schema.Struct<{
+            readonly authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            readonly name: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+            readonly supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>>;
+        readonly format: Schema.Literal<"nakafa-mdx-renderer-v1">;
+        readonly hash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publishedDomains: Schema.$Array<Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>>;
+        readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+    }>;
+}>;
+export type ProtectedContentRuntimeFound = typeof ProtectedContentRuntimeFoundSchema.Type;
+/** Complete response vocabulary for the protected batch runtime seam. */
+export declare const ProtectedContentRuntimeResponseSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly bundle: Schema.Struct<{
+        readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: Schema.Struct<{
+            readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly snapshot: Schema.Struct<{
+                readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+                readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly counts: Schema.Struct<{
+                    readonly country: Schema.Int;
+                    readonly exam: Schema.Int;
+                    readonly section: Schema.Int;
+                    readonly set: Schema.Int;
+                    readonly track: Schema.Int;
+                }>;
+                readonly placementCount: Schema.Int;
+                readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly routeCount: Schema.Int;
+                readonly format: Schema.Literal<"localized-tryout-snapshot">;
+                readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+        }>;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly artifact: Schema.Struct<{
+            readonly artifactHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+            readonly payload: Schema.Struct<{
+                readonly artifactLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraArtifactLocale">;
+                readonly byteLength: Schema.Finite;
+                readonly compiledCode: Schema.String;
+                readonly compilerConfigHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly compilerVersion: Schema.Literal<"0.1.0">;
+                readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+                readonly format: Schema.Literal<"mdx-function-body">;
+                readonly mdxCompilerVersion: Schema.Literal<"3.1.1">;
+                readonly plainText: Schema.String;
+                readonly rawMdx: Schema.String;
+                readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+                readonly requiredComponents: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly version: Schema.Finite;
+                }>>;
+                readonly sourceHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+        }>;
+        readonly delivery: Schema.Literals<readonly ["authenticated", "entitled"]>;
+        readonly sourcePath: Schema.brand<Schema.String, "@NakafaAI/AksaraCorpusSourcePath">;
+    }>>;
+    readonly kind: Schema.Literal<"found">;
+    readonly rendererManifest: Schema.Struct<{
+        readonly base: Schema.Struct<{
+            authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>;
+        readonly domains: Schema.$Array<Schema.Struct<{
+            readonly authoringComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+            readonly name: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+            readonly supportedComponents: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly version: Schema.Finite;
+            }>>;
+        }>>;
+        readonly format: Schema.Literal<"nakafa-mdx-renderer-v1">;
+        readonly hash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly publishedDomains: Schema.$Array<Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>>;
+        readonly rendererContractVersion: Schema.Literal<"1.0.0">;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"missing">;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RUNTIME_INTERNAL", "CONTENT_RUNTIME_INVALID", "CONTENT_RUNTIME_RESPONSE_TOO_LARGE", "CONTENT_RUNTIME_UNAUTHORIZED"]>;
+    readonly kind: Schema.Literal<"failure">;
+}>]>;
+export type ProtectedContentRuntimeResponse = typeof ProtectedContentRuntimeResponseSchema.Type;
+/** Strictly decodes one unknown protected batch request. */
+export declare const decodeProtectedContentRuntimeRequest: (input: unknown) => Effect.Effect<{
+    readonly bundleHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly selectors: readonly {
+        readonly artifactHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+        readonly delivery: "authenticated" | "entitled";
+    }[];
+    readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+}, import("../../errors.js").ContractDecodeError, never>;
+/** Strictly decodes one unknown protected batch response. */
+export declare const decodeProtectedContentRuntimeResponse: (input: unknown) => Effect.Effect<{
+    readonly bundle: {
+        readonly bundleHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: {
+            readonly format: "signed-tryout-runtime-bundle";
+            readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly snapshot: {
+                readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+                readonly catalogDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                readonly counts: {
+                    readonly country: number;
+                    readonly exam: number;
+                    readonly section: number;
+                    readonly set: number;
+                    readonly track: number;
+                };
+                readonly placementCount: number;
+                readonly placementDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                readonly routeCount: number;
+                readonly format: "localized-tryout-snapshot";
+                readonly snapshotId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            };
+            readonly sourceGitSha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+            readonly sourceManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly sourceReleaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+        };
+        readonly signature: string & import("effect/Brand").Brand<"@NakafaAI/AksaraEd25519Signature">;
+    };
+    readonly items: readonly {
+        readonly artifact: {
+            readonly artifactHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            readonly keyId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSigningKeyId">;
+            readonly payload: {
+                readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+                readonly byteLength: number;
+                readonly compiledCode: string;
+                readonly compilerConfigHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                readonly compilerVersion: "0.1.0";
+                readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+                readonly format: "mdx-function-body";
+                readonly mdxCompilerVersion: "3.1.1";
+                readonly plainText: string;
+                readonly rawMdx: string;
+                readonly rendererDomain: "ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math";
+                readonly requiredComponents: readonly {
+                    readonly name: string;
+                    readonly version: number;
+                }[];
+                readonly sourceHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            };
+            readonly signature: string & import("effect/Brand").Brand<"@NakafaAI/AksaraEd25519Signature">;
+        };
+        readonly delivery: "authenticated" | "entitled";
+        readonly sourcePath: string & import("effect/Brand").Brand<"@NakafaAI/AksaraCorpusSourcePath">;
+    }[];
+    readonly kind: "found";
+    readonly rendererManifest: {
+        readonly base: {
+            readonly authoringComponents: readonly {
+                readonly name: string;
+                readonly version: number;
+            }[];
+            readonly supportedComponents: readonly {
+                readonly name: string;
+                readonly version: number;
+            }[];
+        };
+        readonly domains: readonly {
+            readonly authoringComponents: readonly {
+                readonly name: string;
+                readonly version: number;
+            }[];
+            readonly name: "ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math";
+            readonly supportedComponents: readonly {
+                readonly name: string;
+                readonly version: number;
+            }[];
+        }[];
+        readonly format: "nakafa-mdx-renderer-v1";
+        readonly hash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly publishedDomains: readonly ("ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math")[];
+        readonly rendererContractVersion: "1.0.0";
+    };
+} | {
+    readonly kind: "missing";
+} | {
+    readonly code: "CONTENT_RUNTIME_INTERNAL" | "CONTENT_RUNTIME_INVALID" | "CONTENT_RUNTIME_RESPONSE_TOO_LARGE" | "CONTENT_RUNTIME_UNAUTHORIZED";
+    readonly kind: "failure";
+}, import("../../errors.js").ContractDecodeError, never>;

package/dist/runtime/protected/spec.js

@@ -0,0 +1,79 @@
+import { Effect, Schema } from "effect";
+import { SignedContentArtifactSchema, } from "#contracts/content";
+import { decodeContract } from "#contracts/decode";
+import { ContentKeySchema, CorpusSourcePathSchema, Sha256HashSchema, } from "#contracts/ids";
+import { QuestionKeySchema } from "#contracts/question/identity";
+import { RendererManifestEnvelopeSchema } from "#contracts/renderer/contract";
+import { hasBoundedProtectedRuntimeResponse, MAX_PROTECTED_RUNTIME_SELECTORS, } from "#contracts/runtime/protected/limits";
+import { ContentRuntimeFailureSchema, ContentRuntimeMissingSchema, } from "#contracts/runtime/result";
+import { SignedTryoutRuntimeBundleSchema } from "#contracts/tryout/runtime/spec";
+/** Checks one protected body selector uses its required delivery class. */
+function hasProtectedBodyKind(input) {
+    const separator = input.contentKey.lastIndexOf("/");
+    if (separator < 1) {
+        return false;
+    }
+    const questionKey = input.contentKey.slice(0, separator);
+    if (!Schema.is(QuestionKeySchema)(questionKey)) {
+        return false;
+    }
+    if (input.delivery === "authenticated") {
+        return input.contentKey.endsWith("/question");
+    }
+    return input.contentKey.endsWith("/answer");
+}
+/** One exact frozen try-out body selected after product authorization. */
+export const ProtectedContentRuntimeSelectorSchema = Schema.Struct({
+    artifactHash: Sha256HashSchema,
+    contentKey: ContentKeySchema,
+    delivery: Schema.Literals(["authenticated", "entitled"]),
+}).pipe(Schema.check(Schema.makeFilter(hasProtectedBodyKind, {
+    message: "Expected authenticated prompts and entitled answer bodies.",
+})));
+/** Checks a batch never requests the same immutable artifact twice. */
+function hasUniqueSelectors(selectors) {
+    const hashes = selectors.map(({ artifactHash }) => artifactHash);
+    return new Set(hashes).size === hashes.length;
+}
+const ProtectedContentRuntimeSelectorsSchema = Schema.Array(ProtectedContentRuntimeSelectorSchema).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(MAX_PROTECTED_RUNTIME_SELECTORS)), Schema.check(Schema.makeFilter(hasUniqueSelectors, {
+    message: "Expected unique protected runtime artifact selectors.",
+})));
+/** One bounded protected read bound to a permanent signed runtime bundle. */
+export const ProtectedContentRuntimeRequestSchema = Schema.Struct({
+    bundleHash: Sha256HashSchema,
+    selectors: ProtectedContentRuntimeSelectorsSchema,
+    snapshotId: Sha256HashSchema,
+});
+/** One selected artifact inside a protected batch response. */
+export const ProtectedContentRuntimeItemSchema = Schema.Struct({
+    artifact: SignedContentArtifactSchema,
+    delivery: Schema.Literals(["authenticated", "entitled"]),
+    sourcePath: CorpusSourcePathSchema,
+});
+/** Checks one protected response never repeats an immutable artifact. */
+function hasUniqueArtifacts(items) {
+    const hashes = items.map(({ artifact }) => artifact.artifactHash);
+    return new Set(hashes).size === hashes.length;
+}
+const ProtectedContentRuntimeItemsSchema = Schema.Array(ProtectedContentRuntimeItemSchema).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isMaxLength(MAX_PROTECTED_RUNTIME_SELECTORS)), Schema.check(Schema.makeFilter(hasUniqueArtifacts, {
+    message: "Expected unique protected runtime artifacts.",
+})));
+/** Protected frozen bodies selected from one retained try-out snapshot. */
+export const ProtectedContentRuntimeFoundSchema = Schema.Struct({
+    bundle: SignedTryoutRuntimeBundleSchema,
+    items: ProtectedContentRuntimeItemsSchema,
+    kind: Schema.Literal("found"),
+    rendererManifest: RendererManifestEnvelopeSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasBoundedProtectedRuntimeResponse, {
+    message: "Expected the protected runtime response to fit its wire ceiling.",
+})));
+/** Complete response vocabulary for the protected batch runtime seam. */
+export const ProtectedContentRuntimeResponseSchema = Schema.Union([
+    ProtectedContentRuntimeFoundSchema,
+    ContentRuntimeMissingSchema,
+    ContentRuntimeFailureSchema,
+]);
+/** Strictly decodes one unknown protected batch request. */
+export const decodeProtectedContentRuntimeRequest = Effect.fn("AksaraContracts.decodeProtectedContentRuntimeRequest")((input) => decodeContract(ProtectedContentRuntimeRequestSchema, "ProtectedContentRuntimeRequest", input));
+/** Strictly decodes one unknown protected batch response. */
+export const decodeProtectedContentRuntimeResponse = Effect.fn("AksaraContracts.decodeProtectedContentRuntimeResponse")((input) => decodeContract(ProtectedContentRuntimeResponseSchema, "ProtectedContentRuntimeResponse", input));