@nakafa/aksara-contracts 0.27.0

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

@@ -0,0 +1,97 @@
+import { Effect } from "effect";
+import { ContentRuntimeMismatchError } from "#contracts/runtime/error";
+/** Verifies one retained-snapshot batch and every ordered signed artifact. */
+export declare const verifyProtectedContentRuntimeExchange: (input: {
+    readonly rendererManifest: unknown;
+    readonly request: unknown;
+    readonly response: 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("../../artifact/spec.js").ArtifactCompiledByteLengthMismatchError | import("../../artifact/spec.js").ArtifactHashComputationError | import("../../artifact/spec.js").ArtifactHashMismatchError | import("../../artifact/spec.js").ArtifactPayloadFieldByteLimitError | import("../../artifact/spec.js").ArtifactRendererComponentMissingError | import("../../artifact/spec.js").ArtifactRendererDomainUnpublishedError | import("../../artifact/spec.js").ArtifactRendererVersionUnsupportedError | import("../../artifact/spec.js").ArtifactSourceHashComputationError | import("../../artifact/spec.js").ArtifactSourceHashMismatchError | import("../../artifact/spec.js").ArtifactVerificationByteLimitError | import("../../artifact/spec.js").ArtifactVerificationDecodeError | ContentRuntimeMismatchError | import("../../errors.js").ContractDecodeError | import("../../signature/spec.js").PublicKeyParseError | import("../../signature/spec.js").PublicKeyTypeError | import("../../renderer/component.js").RendererAuthoringComponentDuplicateError | import("../../renderer/component.js").RendererAuthoringComponentExtraError | import("../../renderer/component.js").RendererAuthoringComponentMissingError | import("../../renderer/component.js").RendererAuthoringComponentUnsupportedError | import("../../renderer/component.js").RendererAuthoringSelectionNonCanonicalError | import("../../artifact/spec.js").RendererContractVersionMismatchError | import("#contracts/renderer/contract").RendererDomainCapabilityMissingError | import("#contracts/renderer/contract").RendererManifestHashComputeError | import("#contracts/renderer/contract").RendererManifestHashMismatchError | import("../../signature/spec.js").SignatureCheckError | import("../../signature/spec.js").SignatureInvalidError | import("../../signature/spec.js").SigningKeyNotFoundError | import("../../signature/spec.js").SigningKeyResolutionError | import("../../tryout/runtime/hash.js").TryoutRuntimeBundleHashComputationError | import("#contracts/tryout/runtime/verify").TryoutRuntimeBundleHashMismatchError | import("#contracts/tryout/runtime/verify").TryoutRuntimeBundleRendererMismatchError | import("#contracts/tryout/runtime/verify").TryoutRuntimeBundleSnapshotMismatchError | import("#contracts/tryout/runtime/verify").TryoutRuntimeBundleVerificationDecodeError, import("../../signature/spec.js").ContentVerificationKeyResolver>;

package/dist/runtime/protected/verify.js

@@ -0,0 +1,72 @@
+import { Effect, Array as ReadonlyArray } from "effect";
+import { verifySignedContentArtifact } from "#contracts/artifact/verify";
+import { verifyContentRendererCompatibility } from "#contracts/renderer/compatibility";
+import { validateLiveRendererManifestHash } from "#contracts/renderer/manifest";
+import { ContentRuntimeMismatchError } from "#contracts/runtime/error";
+import { decodeProtectedContentRuntimeRequest, decodeProtectedContentRuntimeResponse, } from "#contracts/runtime/protected/spec";
+import { verifySignedTryoutRuntimeBundle } from "#contracts/tryout/runtime/verify";
+/** Checks one protected body path matches its exact content and artifact locale. */
+function hasProtectedSourcePath(contentKey, artifactLocale, sourcePath) {
+    const separator = contentKey.lastIndexOf("/");
+    const sourceRoot = contentKey.slice(0, separator);
+    const bodyKind = contentKey.slice(separator + 1);
+    return (sourcePath ===
+        `packages/corpus/${sourceRoot}/${bodyKind}.${artifactLocale}.mdx`);
+}
+/** Verifies one returned item belongs to its ordered snapshot selector. */
+const verifyProtectedItem = Effect.fn("AksaraContracts.verifyProtectedRuntimeItem")(function* (selector, item, bundle, bundleRenderer, liveRenderer) {
+    if (item.delivery !== selector.delivery) {
+        return yield* new ContentRuntimeMismatchError({ reason: "delivery" });
+    }
+    if (item.artifact.artifactHash !== selector.artifactHash) {
+        return yield* new ContentRuntimeMismatchError({ reason: "artifactHash" });
+    }
+    if (item.artifact.payload.contentKey !== selector.contentKey) {
+        return yield* new ContentRuntimeMismatchError({ reason: "contentKey" });
+    }
+    if (!hasProtectedSourcePath(selector.contentKey, item.artifact.payload.artifactLocale, item.sourcePath)) {
+        return yield* new ContentRuntimeMismatchError({ reason: "sourcePath" });
+    }
+    const artifact = yield* verifySignedContentArtifact({
+        artifact: item.artifact,
+        rendererContractVersion: bundleRenderer.rendererContractVersion,
+        rendererManifest: bundleRenderer,
+    });
+    if (liveRenderer.hash !== bundle.payload.rendererManifestHash) {
+        yield* verifyContentRendererCompatibility({
+            payload: artifact.payload,
+            rendererContractVersion: bundleRenderer.rendererContractVersion,
+            rendererManifest: liveRenderer,
+        });
+    }
+});
+/** Binds one protected batch to its exact permanent runtime bundle. */
+const verifyProtectedBundle = Effect.fn("AksaraContracts.verifyProtectedRuntimeBundle")(function* (request, bundle) {
+    if (bundle.bundleHash !== request.bundleHash) {
+        return yield* new ContentRuntimeMismatchError({ reason: "bundleHash" });
+    }
+    if (bundle.payload.snapshot.snapshotId !== request.snapshotId) {
+        return yield* new ContentRuntimeMismatchError({ reason: "snapshotId" });
+    }
+});
+/** Verifies one retained-snapshot batch and every ordered signed artifact. */
+export const verifyProtectedContentRuntimeExchange = Effect.fn("AksaraContracts.verifyProtectedContentRuntimeExchange")(function* (input) {
+    const request = yield* decodeProtectedContentRuntimeRequest(input.request);
+    const response = yield* decodeProtectedContentRuntimeResponse(input.response);
+    if (response.kind !== "found") {
+        return response;
+    }
+    if (response.items.length !== request.selectors.length) {
+        return yield* new ContentRuntimeMismatchError({
+            reason: "selectorCount",
+        });
+    }
+    const bundle = yield* verifySignedTryoutRuntimeBundle({
+        bundle: response.bundle,
+        rendererManifest: response.rendererManifest,
+    });
+    const liveRenderer = yield* validateLiveRendererManifestHash(input.rendererManifest);
+    yield* verifyProtectedBundle(request, bundle);
+    yield* Effect.forEach(ReadonlyArray.zip(request.selectors, response.items), ([selector, item]) => verifyProtectedItem(selector, item, bundle, response.rendererManifest, liveRenderer), { concurrency: "unbounded", discard: true });
+    return response;
+});

package/dist/runtime/result.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+/** Exact absence response distinct from runtime or integrity failures. */
+export declare const ContentRuntimeMissingSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"missing">;
+}>;
+/** Sanitized failure codes exposed by server-only runtime endpoints. */
+export declare const ContentRuntimeFailureCodeSchema: Schema.Literals<readonly ["CONTENT_RUNTIME_INTERNAL", "CONTENT_RUNTIME_INVALID", "CONTENT_RUNTIME_RESPONSE_TOO_LARGE", "CONTENT_RUNTIME_UNAUTHORIZED"]>;
+/** Sanitized runtime failure without implementation details or body bytes. */
+export declare const ContentRuntimeFailureSchema: 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">;
+}>;

package/dist/runtime/result.js

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/** Exact absence response distinct from runtime or integrity failures. */
+export const ContentRuntimeMissingSchema = Schema.Struct({
+    kind: Schema.Literal("missing"),
+});
+/** Sanitized failure codes exposed by server-only runtime endpoints. */
+export const ContentRuntimeFailureCodeSchema = Schema.Literals([
+    "CONTENT_RUNTIME_INTERNAL",
+    "CONTENT_RUNTIME_INVALID",
+    "CONTENT_RUNTIME_RESPONSE_TOO_LARGE",
+    "CONTENT_RUNTIME_UNAUTHORIZED",
+]);
+/** Sanitized runtime failure without implementation details or body bytes. */
+export const ContentRuntimeFailureSchema = Schema.Struct({
+    code: ContentRuntimeFailureCodeSchema,
+    kind: Schema.Literal("failure"),
+});