@nakafa/aksara-contracts 0.27.0

package/LICENSE

@@ -0,0 +1,185 @@
+# Nakafa Source Available License 1.0
+
+Effective date: April 24, 2026
+
+Copyright (c) 2026 PT NAKAFA TEKNO KREATIF. All rights reserved.
+
+This is not an open-source license. Nakafa source code is public so people can
+inspect it, learn from it, review it, and propose improvements. The public
+source code does not grant permission to rebrand, redistribute, host, sell,
+monetize, or turn Nakafa into another product without written permission.
+
+## 1. Definitions
+
+`Nakafa` means the software, source code, build files, configuration, scripts,
+database schema, prompts, UI, and related code made available in this repository.
+
+`You` means the individual or entity receiving or using Nakafa.
+
+`Personal use` means use by one individual for that individual's own learning,
+research, testing, security review, or hobby evaluation. Personal use does not
+include use for an employer, client, school, organization, product, service,
+team, or business purpose.
+
+`Local use` means use on a device or development environment controlled by you,
+without making Nakafa available to any other person over the internet, an
+intranet, a private network, a shared server, or any hosted environment.
+
+`Written permission` means a separate written agreement signed by PT NAKAFA
+TEKNO KREATIF, or a written approval sent from an official Nakafa email address.
+
+## 2. Scope
+
+This license applies to the software source code in this repository unless a
+file says that a different license applies.
+
+This license does not apply to:
+
+- Third-party dependencies, packages, services, fonts, or libraries, which keep
+  their own licenses.
+- Educational content, articles, exercises, explanations, datasets, copy,
+  images, video, audio, and other non-code materials, which are covered by
+  `CONTENT_LICENSE.md` unless a file says otherwise.
+- The Nakafa name, logos, domains, product names, visual identity, and other
+  brand assets, which are covered by `TRADEMARKS.md`.
+- Prior copies of Nakafa that were lawfully received under a previous license.
+  Those older copies remain under the license terms that applied when they were
+  received. New changes published after the effective date above are covered by
+  this license.
+
+All rights not expressly granted by this license are reserved by PT NAKAFA TEKNO
+KREATIF.
+
+## 3. Allowed Use Without Written Permission
+
+You may do only the following without written permission from PT NAKAFA TEKNO
+KREATIF:
+
+- View, read, inspect, and audit the source code.
+- Clone or download one copy for personal review.
+- Create a GitHub fork only to prepare and submit contributions back to Nakafa,
+  as long as the fork is not used as a standalone project, hosted service,
+  mirror, product, rebrand, or distribution channel.
+- Run the unmodified software locally for your own personal, non-commercial
+  learning, research, testing, security review, or hobby evaluation.
+- Make temporary technical copies that are necessary for the allowed personal
+  local use above.
+- Submit issues, suggestions, or pull requests under the contribution terms in
+  `.github/CONTRIBUTING.md`.
+
+These permissions are personal, limited, non-exclusive, non-transferable, and
+revocable if you violate this license.
+
+## 4. Permission Required
+
+You must get prior written permission from PT NAKAFA TEKNO KREATIF before doing
+anything not listed in Section 3.
+
+The following uses always require prior written permission:
+
+- Commercial use.
+- Revenue-generating use.
+- Use in a product, service, course, school system, learning management system,
+  SaaS, API, internal company tool, agency project, client project, consulting
+  work, paid training, or paid content.
+- Use by a company, school, institution, nonprofit organization, government
+  organization, team, or other entity outside personal local evaluation.
+- Any hosted deployment outside your own local machine, whether public or
+  private, and whether or not anyone else can access it.
+- Distribution, redistribution, mirroring, publishing, uploading, packaging,
+  reselling, sublicensing, or sharing copies of the software.
+- Modification, forked product development, derivative works, white-label use,
+  private-label use, rebranding, or presenting Nakafa as your own project.
+- Removing, hiding, or changing copyright, license, attribution, source,
+  trademark, or brand notices.
+- Using Nakafa code, content, structure, datasets, or outputs to train,
+  fine-tune, benchmark, evaluate, seed, or improve AI models, search indexes,
+  datasets, embeddings, retrieval systems, or competing educational products.
+
+Commercial or revenue-generating use includes use connected to subscriptions,
+ads, sponsorships, affiliate revenue, lead generation, paid access, paid
+support, paid tutoring, paid courses, paid school services, sales enablement,
+customer acquisition, investor demos, or any other direct or indirect business
+benefit.
+
+## 5. Brand Rights
+
+This license grants no trademark, service mark, trade name, domain name, logo,
+design, or brand rights. You may not use the Nakafa brand in a way that suggests
+ownership, endorsement, partnership, official status, or source confusion.
+
+See `TRADEMARKS.md` for the brand rules.
+
+## 6. Content Rights
+
+This license grants no rights to copy, redistribute, sell, mirror, scrape,
+repackage, rebrand, or monetize Nakafa educational content.
+
+See `CONTENT_LICENSE.md` for the content rules.
+
+## 7. Contributions
+
+By submitting a contribution, you agree to the contribution terms in
+`.github/CONTRIBUTING.md`.
+
+If you cannot grant those contribution rights, do not submit the contribution.
+
+## 8. Termination
+
+Your rights under this license end immediately if you violate any term.
+
+After termination, you must stop using the software and delete all copies under
+your control, except copies you are required to keep for legal compliance.
+
+PT NAKAFA TEKNO KREATIF may reinstate your rights only in writing.
+
+## 9. Mandatory Legal Rights
+
+This license does not limit rights that applicable law says cannot be waived,
+limited, or conditioned by contract.
+
+## 10. No Warranty
+
+Nakafa is provided "as is" and "as available", without warranties or conditions
+of any kind, whether express, implied, statutory, or otherwise.
+
+PT NAKAFA TEKNO KREATIF does not warrant that Nakafa is accurate, secure,
+complete, uninterrupted, error-free, fit for a particular purpose, or
+non-infringing.
+
+## 11. Limitation of Liability
+
+To the fullest extent permitted by law, PT NAKAFA TEKNO KREATIF will not be
+liable for any indirect, incidental, special, consequential, exemplary, punitive,
+or similar damages, or for any loss of profits, revenue, data, goodwill, or
+business opportunity, arising from or related to Nakafa or this license.
+
+## 12. Governing Law and Venue
+
+This license is governed by the laws of the Republic of Indonesia, without
+regard to conflict of law principles.
+
+Except where prohibited by applicable law, any dispute arising out of or related
+to this license or Nakafa must be brought exclusively in the courts of the
+Republic of Indonesia.
+
+## 13. No Waiver
+
+If PT NAKAFA TEKNO KREATIF does not enforce a term immediately, that does not
+waive the right to enforce that term later.
+
+Any waiver must be in writing and signed by PT NAKAFA TEKNO KREATIF.
+
+## 14. Severability
+
+If any part of this license is found unenforceable, the rest remains in effect.
+The unenforceable part will be interpreted as narrowly as possible so it becomes
+enforceable while preserving the original intent.
+
+## 15. Written Permission
+
+Commercial, hosted, institutional, redistribution, modification, white-label,
+private-label, rebrand, AI-training, or other non-personal use requires a
+separate written agreement.
+
+Contact: nakafaai@gmail.com

package/README.md

@@ -0,0 +1,73 @@
+# @nakafa/aksara-contracts
+
+This package defines exact runtime contracts for the Aksara compiler and
+publisher. Nakafa runtime adoption is a separate cutover gated by a proven
+immutable release archive and compatible renderer support.
+
+This package contains schemas, branded identifiers, canonical wire encodings,
+and Web Crypto signature verification. It contains no corpus, renderer
+implementation, signing key, deployment credential, or browser-side MDX
+runtime.
+
+Consumers install the exact attested GitHub Release archive recorded in their
+pnpm lockfile. Content requiring a newer contract may be activated only after a
+compatible Nakafa renderer is live.
+
+Node-only writer and incremental digest exports remain isolated behind package
+conditions. Default-runtime exports used by Convex are audited to reject
+reachable Node built-ins. Verification accepts only reviewed, signed Aksara
+artifacts and releases. It does not make MDX safe for arbitrary uploads; MDX
+remains trusted executable source.
+
+## Consumer boundaries
+
+Current consumers use unversioned semantic Interfaces:
+
+- `graph/family` classifies either a complete graph identity or one exact
+  asset ID into its application locale and content family.
+- `tryout/catalog` owns minimal catalog node schemas, while `tryout/identity`
+  builds their pure lookup identities before complete signed rows are loaded.
+- `projection/material` owns the application-locale material namespace and
+  validates every signed route and projection against it.
+- `projection/page` owns stable public page identities, localized paths, and
+  signed metadata for human, agent, and sitemap delivery.
+## Publication dates
+
+Article, material, and public page metadata carries one required
+`datePublished` and one optional `dateModified`, both as exact `DateOnly`
+values.
+
+- `datePublished` is the first verified public availability of that specific
+  locale page.
+- `dateModified` is the public activation date of a later signed release that
+  contains a meaningful content change.
+- When present, `dateModified` must be strictly later than `datePublished`.
+
+Neither value may be derived from a build clock, import time, Convex
+`_creationTime`, an unsigned source commit, or an unactivated candidate. The
+signed release and activation history remain the audit evidence for both
+values. These rules keep visible dates and structured data aligned with
+[Google publication date guidance](https://developers.google.com/search/docs/appearance/publication-dates)
+and
+[Article structured data](https://developers.google.com/search/docs/appearance/structured-data/article).
+
+Runtime verification authenticates the independently signed release and
+artifact values against the exact renderer manifest frozen into that release.
+Execution verification also proves the selected artifact against the complete
+live renderer when the deployed manifest hash differs. Non-rendering evidence
+verification authenticates the same frozen release and artifact without
+claiming that its consumer can execute the artifact. This directional
+execution check lets an additive live renderer serve an older release only when
+it still publishes the selected domain and supports every required component
+version. It never authorizes publication: new releases, activation, and
+recovery preflight remain bound to the exact complete live renderer. The
+renderer is not a third signed value. Current production trusts authenticated
+Convex state for route/head membership, delivery class, and the active pointer;
+a release result digest is not a per-row inclusion proof. This boundary is
+recorded explicitly in
+[ADR 0002](https://github.com/nakafaai/aksara/blob/main/docs/adr/0002-release-state.md).
+
+The package source is publicly readable for supply-chain review. All use and
+redistribution remain subject to the included Nakafa Source Available License
+1.0. The package grants no rights to the Nakafa corpus, branding, or
+educational material.

package/dist/artifact/integrity.d.ts

@@ -0,0 +1,29 @@
+import { Effect } from "effect";
+import { ArtifactHashComputationError, ArtifactHashMismatchError, ArtifactVerificationDecodeError } from "#contracts/artifact/spec";
+import { type CompiledContentPayload } from "#contracts/content";
+/** Computes the immutable identity of one canonical compiled payload. */
+export declare function hashCompiledContentPayload(payload: CompiledContentPayload): string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+/** Strictly authenticates artifact integrity without renderer compatibility. */
+export declare const verifySignedContentArtifactIntegrity: (input: unknown) => Effect.Effect<{
+    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">;
+}, import("#contracts/artifact/spec").ArtifactCompiledByteLengthMismatchError | ArtifactHashComputationError | ArtifactHashMismatchError | import("#contracts/artifact/spec").ArtifactPayloadFieldByteLimitError | import("#contracts/artifact/spec").ArtifactSourceHashComputationError | import("#contracts/artifact/spec").ArtifactSourceHashMismatchError | import("#contracts/artifact/spec").ArtifactVerificationByteLimitError | ArtifactVerificationDecodeError | import("../signature/spec.js").PublicKeyParseError | import("../signature/spec.js").PublicKeyTypeError | import("../signature/spec.js").SignatureCheckError | import("../signature/spec.js").SignatureInvalidError | import("../signature/spec.js").SigningKeyNotFoundError | import("../signature/spec.js").SigningKeyResolutionError, import("../signature/spec.js").ContentVerificationKeyResolver>;

package/dist/artifact/integrity.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+import { Effect, Schema } from "effect";
+import { validateArtifactByteIntegrity } from "#contracts/artifact/limits";
+import { verifyCompiledContentSourceHash } from "#contracts/artifact/source";
+import { ArtifactHashComputationError, ArtifactHashMismatchError, ArtifactVerificationDecodeError, } from "#contracts/artifact/spec";
+import { canonicalizeCompiledContentPayload, canonicalizeContentArtifactSigningInput, SignedContentArtifactSchema, } from "#contracts/content";
+import { Sha256HashSchema } from "#contracts/ids";
+import { verifyEd25519Signature } from "#contracts/signature/verify";
+/** Computes the immutable identity of one canonical compiled payload. */
+export function hashCompiledContentPayload(payload) {
+    return Sha256HashSchema.make(`sha256:${createHash("sha256")
+        .update(canonicalizeCompiledContentPayload(payload))
+        .digest("hex")}`);
+}
+/** Computes an artifact hash while preserving typed computation failures. */
+function hashPayload(payload) {
+    return Effect.try({
+        catch: () => new ArtifactHashComputationError({ contentKey: payload.contentKey }),
+        try: () => hashCompiledContentPayload(payload),
+    });
+}
+/** Confirms that an artifact envelope identifies its canonical payload. */
+function validateArtifactHash(artifact, actualHash) {
+    if (artifact.artifactHash === actualHash) {
+        return Effect.void;
+    }
+    return Effect.fail(new ArtifactHashMismatchError({
+        actualHash,
+        contentKey: artifact.payload.contentKey,
+        expectedHash: artifact.artifactHash,
+    }));
+}
+/** Verifies immutable bytes, hashes, source, and signature without a renderer. */
+function authenticateSignedArtifact(artifact) {
+    return Effect.gen(function* () {
+        const actualHash = yield* hashPayload(artifact.payload);
+        yield* validateArtifactHash(artifact, actualHash);
+        yield* verifyEd25519Signature({
+            keyId: artifact.keyId,
+            message: canonicalizeContentArtifactSigningInput(artifact.artifactHash, artifact.payload),
+            signature: artifact.signature,
+            subject: "artifact",
+        });
+        yield* validateArtifactByteIntegrity(artifact);
+        yield* verifyCompiledContentSourceHash(artifact.payload);
+        return artifact;
+    });
+}
+/** Strictly authenticates artifact integrity without renderer compatibility. */
+export const verifySignedContentArtifactIntegrity = Effect.fn("AksaraContracts.verifySignedContentArtifactIntegrity")((input) => Schema.decodeUnknownEffect(SignedContentArtifactSchema)(input, {
+    onExcessProperty: "error",
+}).pipe(Effect.mapError(() => new ArtifactVerificationDecodeError({
+    message: "Artifact verification input does not satisfy its exact wire contract.",
+})), Effect.flatMap(authenticateSignedArtifact)));

package/dist/artifact/limits.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { ArtifactCompiledByteLengthMismatchError, ArtifactPayloadFieldByteLimitError, ArtifactVerificationByteLimitError } from "#contracts/artifact/spec";
+/** Verifies complete wire, declared bytes, and every bounded payload field. */
+export declare const validateArtifactByteIntegrity: (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">;
+}) => Effect.Effect<undefined, ArtifactCompiledByteLengthMismatchError | ArtifactPayloadFieldByteLimitError | ArtifactVerificationByteLimitError, never>;

package/dist/artifact/limits.js

@@ -0,0 +1,46 @@
+import { Buffer } from "node:buffer";
+import { Effect } from "effect";
+import { ArtifactCompiledByteLengthMismatchError, ArtifactPayloadFieldByteLimitError, ArtifactVerificationByteLimitError, } from "#contracts/artifact/spec";
+import { canonicalizeCompiledContentPayload, canonicalizeSignedContentArtifact, } from "#contracts/content";
+import { MAX_CANONICAL_PAYLOAD_BYTES, MAX_COMPILED_CODE_BYTES, MAX_PLAIN_TEXT_BYTES, MAX_RAW_MDX_BYTES, MAX_SIGNED_ARTIFACT_BYTES, } from "#contracts/limits";
+/** Rejects a complete signed artifact envelope above its wire ceiling. */
+function enforceSignedWireLimit(artifact) {
+    const actualBytes = Buffer.byteLength(canonicalizeSignedContentArtifact(artifact), "utf8");
+    if (actualBytes <= MAX_SIGNED_ARTIFACT_BYTES) {
+        return Effect.void;
+    }
+    return Effect.fail(new ArtifactVerificationByteLimitError({
+        actualBytes,
+        maxBytes: MAX_SIGNED_ARTIFACT_BYTES,
+    }));
+}
+/** Rejects one authenticated payload field above its shared ceiling. */
+function enforcePayloadFieldLimit(payload, field, value, maxBytes) {
+    const actualBytes = Buffer.byteLength(value, "utf8");
+    if (actualBytes <= maxBytes) {
+        return Effect.void;
+    }
+    return Effect.fail(new ArtifactPayloadFieldByteLimitError({
+        actualBytes,
+        contentKey: payload.contentKey,
+        field,
+        maxBytes,
+    }));
+}
+/** Verifies complete wire, declared bytes, and every bounded payload field. */
+export const validateArtifactByteIntegrity = Effect.fn("AksaraContracts.validateArtifactByteIntegrity")(function* (artifact) {
+    yield* enforceSignedWireLimit(artifact);
+    const { payload } = artifact;
+    const compiledBytes = Buffer.byteLength(payload.compiledCode, "utf8");
+    if (payload.byteLength !== compiledBytes) {
+        return yield* new ArtifactCompiledByteLengthMismatchError({
+            actualBytes: compiledBytes,
+            contentKey: payload.contentKey,
+            declaredBytes: payload.byteLength,
+        });
+    }
+    yield* enforcePayloadFieldLimit(payload, "rawMdx", payload.rawMdx, MAX_RAW_MDX_BYTES);
+    yield* enforcePayloadFieldLimit(payload, "compiledCode", payload.compiledCode, MAX_COMPILED_CODE_BYTES);
+    yield* enforcePayloadFieldLimit(payload, "plainText", payload.plainText, MAX_PLAIN_TEXT_BYTES);
+    yield* enforcePayloadFieldLimit(payload, "canonicalPayload", canonicalizeCompiledContentPayload(payload), MAX_CANONICAL_PAYLOAD_BYTES);
+});

package/dist/artifact/source.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { ArtifactSourceHashComputationError, ArtifactSourceHashMismatchError } from "#contracts/artifact/spec";
+/** Verifies that sourceHash identifies the complete authenticated raw MDX. */
+export declare const verifyCompiledContentSourceHash: (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">;
+}) => Effect.Effect<void, ArtifactSourceHashComputationError | ArtifactSourceHashMismatchError, never>;

package/dist/artifact/source.js

@@ -0,0 +1,24 @@
+import { createHash } from "node:crypto";
+import { Effect } from "effect";
+import { ArtifactSourceHashComputationError, ArtifactSourceHashMismatchError, } from "#contracts/artifact/spec";
+import { Sha256HashSchema } from "#contracts/ids";
+/** Computes the authenticated hash of the complete authored MDX source. */
+function hashAuthoredSource(payload) {
+    return Effect.try({
+        catch: () => new ArtifactSourceHashComputationError({
+            contentKey: payload.contentKey,
+        }),
+        try: () => Sha256HashSchema.make(`sha256:${createHash("sha256").update(payload.rawMdx).digest("hex")}`),
+    });
+}
+/** Verifies that sourceHash identifies the complete authenticated raw MDX. */
+export const verifyCompiledContentSourceHash = Effect.fn("AksaraContracts.verifyCompiledContentSourceHash")((payload) => hashAuthoredSource(payload).pipe(Effect.flatMap((actualHash) => {
+    if (actualHash === payload.sourceHash) {
+        return Effect.void;
+    }
+    return Effect.fail(new ArtifactSourceHashMismatchError({
+        actualHash,
+        contentKey: payload.contentKey,
+        expectedHash: payload.sourceHash,
+    }));
+})));

package/dist/artifact/spec.d.ts

@@ -0,0 +1,148 @@
+import { Schema } from "effect";
+/**
+ * Complete server-only input needed to authenticate one compiled artifact.
+ * `rendererContractVersion` comes from the active release because payloads do
+ * not duplicate that release-scoped value.
+ */
+export declare const ArtifactVerificationRequestSchema: 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 rendererContractVersion: Schema.String;
+    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 ArtifactVerificationRequest = typeof ArtifactVerificationRequestSchema.Type;
+declare const ArtifactVerificationDecodeError_base: Schema.Class<ArtifactVerificationDecodeError, Schema.TaggedStruct<"ArtifactVerificationDecodeError", {
+    readonly message: Schema.Literal<"Artifact verification input does not satisfy its exact wire contract.">;
+}>, import("effect/Cause").YieldableError>;
+/** Unknown artifact input did not exactly satisfy the verification contract. */
+export declare class ArtifactVerificationDecodeError extends ArtifactVerificationDecodeError_base {
+}
+declare const ArtifactVerificationByteLimitError_base: Schema.Class<ArtifactVerificationByteLimitError, Schema.TaggedStruct<"ArtifactVerificationByteLimitError", {
+    readonly actualBytes: Schema.Finite;
+    readonly maxBytes: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** A signed artifact exceeded the canonical UTF-8 wire ceiling. */
+export declare class ArtifactVerificationByteLimitError extends ArtifactVerificationByteLimitError_base {
+}
+declare const ArtifactCompiledByteLengthMismatchError_base: Schema.Class<ArtifactCompiledByteLengthMismatchError, Schema.TaggedStruct<"ArtifactCompiledByteLengthMismatchError", {
+    readonly actualBytes: Schema.Finite;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly declaredBytes: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Declared compiled bytes differ from the authenticated function body. */
+export declare class ArtifactCompiledByteLengthMismatchError extends ArtifactCompiledByteLengthMismatchError_base {
+}
+declare const ArtifactPayloadFieldByteLimitError_base: Schema.Class<ArtifactPayloadFieldByteLimitError, Schema.TaggedStruct<"ArtifactPayloadFieldByteLimitError", {
+    readonly actualBytes: Schema.Finite;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly field: Schema.Literals<readonly ["rawMdx", "compiledCode", "plainText", "canonicalPayload"]>;
+    readonly maxBytes: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** One authenticated payload field exceeded its shared runtime ceiling. */
+export declare class ArtifactPayloadFieldByteLimitError extends ArtifactPayloadFieldByteLimitError_base {
+}
+declare const ArtifactHashComputationError_base: Schema.Class<ArtifactHashComputationError, Schema.TaggedStruct<"ArtifactHashComputationError", {
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 computation failed before authenticity could be established. */
+export declare class ArtifactHashComputationError extends ArtifactHashComputationError_base {
+}
+declare const ArtifactHashMismatchError_base: Schema.Class<ArtifactHashMismatchError, Schema.TaggedStruct<"ArtifactHashMismatchError", {
+    readonly actualHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly expectedHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The signed artifact hash does not identify its canonical payload. */
+export declare class ArtifactHashMismatchError extends ArtifactHashMismatchError_base {
+}
+declare const ArtifactSourceHashComputationError_base: Schema.Class<ArtifactSourceHashComputationError, Schema.TaggedStruct<"ArtifactSourceHashComputationError", {
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 could not be calculated for the authenticated authored source. */
+export declare class ArtifactSourceHashComputationError extends ArtifactSourceHashComputationError_base {
+}
+declare const ArtifactSourceHashMismatchError_base: Schema.Class<ArtifactSourceHashMismatchError, Schema.TaggedStruct<"ArtifactSourceHashMismatchError", {
+    readonly actualHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly expectedHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The authenticated source hash does not identify the complete raw MDX. */
+export declare class ArtifactSourceHashMismatchError extends ArtifactSourceHashMismatchError_base {
+}
+declare const RendererContractVersionMismatchError_base: Schema.Class<RendererContractVersionMismatchError, Schema.TaggedStruct<"RendererContractVersionMismatchError", {
+    readonly actualVersion: Schema.String;
+    readonly expectedVersion: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The runtime and hash-validated renderer envelope disagree globally. */
+export declare class RendererContractVersionMismatchError extends RendererContractVersionMismatchError_base {
+}
+declare const ArtifactRendererComponentMissingError_base: Schema.Class<ArtifactRendererComponentMissingError, Schema.TaggedStruct<"ArtifactRendererComponentMissingError", {
+    readonly componentName: Schema.String;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+}>, import("effect/Cause").YieldableError>;
+/** A custom component required by the artifact is absent from the renderer. */
+export declare class ArtifactRendererComponentMissingError extends ArtifactRendererComponentMissingError_base {
+}
+declare const ArtifactRendererVersionUnsupportedError_base: Schema.Class<ArtifactRendererVersionUnsupportedError, Schema.TaggedStruct<"ArtifactRendererVersionUnsupportedError", {
+    readonly componentName: Schema.String;
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly requiredVersion: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** The renderer does not implement the exact required component version. */
+export declare class ArtifactRendererVersionUnsupportedError extends ArtifactRendererVersionUnsupportedError_base {
+}
+declare const ArtifactRendererDomainUnpublishedError_base: Schema.Class<ArtifactRendererDomainUnpublishedError, Schema.TaggedStruct<"ArtifactRendererDomainUnpublishedError", {
+    readonly contentKey: Schema.brand<Schema.String, "@NakafaAI/AksaraContentKey">;
+    readonly rendererDomain: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The deployed Nakafa app cannot route this artifact's renderer domain. */
+export declare class ArtifactRendererDomainUnpublishedError extends ArtifactRendererDomainUnpublishedError_base {
+}
+export {};