@nakafa/aksara-contracts 0.27.0

package/dist/renderer/component.js

@@ -0,0 +1,102 @@
+import { Schema } from "effect";
+import { compareCodeUnits } from "#contracts/text/order";
+const COMPONENT_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+/** Renderer names are simple identifiers, never dotted member paths. */
+export const RendererComponentNameSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((name) => COMPONENT_NAME_PATTERN.test(name), {
+    message: "Expected a component name matching /^[A-Za-z][A-Za-z0-9]*$/.",
+})));
+/** One named renderer capability and its positive contract version. */
+export const RendererComponentRequirementSchema = Schema.Struct({
+    name: RendererComponentNameSchema,
+    version: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+});
+/** Orders renderer requirements canonically by name and then version. */
+function compareRequirements(left, right) {
+    return (compareCodeUnits(left.name, right.name) || left.version - right.version);
+}
+/** Checks that requirement pairs are unique and canonically ordered. */
+function hasCanonicalRequirementPairs(requirements) {
+    for (let index = 1; index < requirements.length; index += 1) {
+        const previous = requirements[index - 1];
+        const current = requirements[index];
+        if (!(previous && current) || compareRequirements(previous, current) >= 0) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Checks that each component name selects at most one version. */
+function hasOneVersionPerComponent(requirements) {
+    for (let index = 1; index < requirements.length; index += 1) {
+        if (requirements[index - 1]?.name === requirements[index]?.name) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Canonically sorts component requirements by name and then version. */
+export function sortRendererComponentRequirements(requirements) {
+    return [...requirements].sort(compareRequirements);
+}
+const CanonicalRendererRequirementsSchema = Schema.Array(RendererComponentRequirementSchema).pipe(Schema.check(Schema.makeFilter(hasCanonicalRequirementPairs, {
+    message: "Expected unique renderer requirement pairs sorted by name and version.",
+})));
+/** Canonical runtime capabilities; an empty route domain is valid. */
+export const RendererSupportedComponentsSchema = CanonicalRendererRequirementsSchema;
+/** Canonical compiler choices; an empty route domain is valid. */
+export const RendererAuthoringComponentsSchema = CanonicalRendererRequirementsSchema.pipe(Schema.check(Schema.makeFilter(hasOneVersionPerComponent, {
+    message: "Expected exactly one authoring version for each component name.",
+})));
+/** Canonical runtime capabilities; multiple versions per name are allowed. */
+export const RendererManifestSupportedComponentsSchema = RendererSupportedComponentsSchema.pipe(Schema.check(Schema.isMinLength(1)));
+/** Canonical compiler choices; exactly one version exists for every name. */
+export const RendererManifestAuthoringComponentsSchema = RendererAuthoringComponentsSchema.pipe(Schema.check(Schema.isMinLength(1)));
+/** Canonical artifact requirements; an artifact chooses one version per name. */
+export const CompiledContentRequirementsSchema = CanonicalRendererRequirementsSchema.pipe(Schema.check(Schema.makeFilter(hasOneVersionPerComponent, {
+    message: "Expected at most one version for each required component.",
+})));
+/** Shared schema fields for one physical renderer registry capability. */
+const RendererCapabilityFields = {
+    authoringComponents: RendererManifestAuthoringComponentsSchema,
+    supportedComponents: RendererManifestSupportedComponentsSchema,
+};
+const RendererCapabilityStructSchema = Schema.Struct(RendererCapabilityFields);
+/** Checks that authoring pins select every supported component exactly once. */
+export function hasCompleteRendererSelection(components) {
+    const authoringNames = new Set(components.authoringComponents.map(({ name }) => name));
+    const supportedNames = new Set(components.supportedComponents.map(({ name }) => name));
+    if (authoringNames.size !== supportedNames.size) {
+        return false;
+    }
+    return components.authoringComponents.every((selection) => components.supportedComponents.some((supported) => supported.name === selection.name &&
+        supported.version === selection.version));
+}
+/** One complete component contract owned by one physical registry scope. */
+export const RendererCapabilitySchema = RendererCapabilityStructSchema.pipe(Schema.check(Schema.makeFilter(hasCompleteRendererSelection, {
+    message: "Expected one supported authoring selection for every component name.",
+})));
+/** More than one authoring version was selected for one component name. */
+export class RendererAuthoringComponentDuplicateError extends Schema.TaggedError()("RendererAuthoringComponentDuplicateError", { componentName: RendererComponentNameSchema }) {
+}
+/** A runtime-supported component has no pinned authoring version. */
+export class RendererAuthoringComponentMissingError extends Schema.TaggedError()("RendererAuthoringComponentMissingError", { componentName: RendererComponentNameSchema }) {
+}
+/** Authoring selected a component name absent from runtime support. */
+export class RendererAuthoringComponentExtraError extends Schema.TaggedError()("RendererAuthoringComponentExtraError", { componentName: RendererComponentNameSchema }) {
+}
+/** Authoring selected a version absent from runtime support. */
+export class RendererAuthoringComponentUnsupportedError extends Schema.TaggedError()("RendererAuthoringComponentUnsupportedError", {
+    componentName: RendererComponentNameSchema,
+    version: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThan(0))),
+}) {
+}
+/** Authoring selections were not sorted by canonical component order. */
+export class RendererAuthoringSelectionNonCanonicalError extends Schema.TaggedError()("RendererAuthoringSelectionNonCanonicalError", {
+    componentName: RendererComponentNameSchema,
+    index: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+}) {
+}
+/** Serializes one selected compiler component set in canonical order. */
+export function canonicalizeRendererAuthoringSelection(authoringComponents) {
+    return JSON.stringify(authoringComponents.map(({ name, version }) => ({ name, version })));
+}

package/dist/renderer/contract.d.ts

@@ -0,0 +1,144 @@
+import { Effect, Schema } from "effect";
+import { type RendererCapability } from "#contracts/renderer/component";
+/** Domain-scoped renderer wire version shared with Nakafa. */
+export declare const RENDERER_CONTRACT_VERSION = "1.0.0";
+/** Stable wire format for a domain-scoped Nakafa renderer manifest. */
+export declare const RENDERER_MANIFEST_FORMAT = "nakafa-mdx-renderer-v1";
+/** Canonical semantic version carried by a renderer runtime boundary. */
+export declare const RendererContractVersionSchema: Schema.String;
+export type RendererContractVersion = typeof RendererContractVersionSchema.Type;
+/** One route-domain component contract with an exact real domain name. */
+export declare const RendererDomainCapabilitySchema: 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;
+    }>>;
+}>;
+export type RendererDomainCapability = typeof RendererDomainCapabilitySchema.Type;
+/** Canonical route domains that the deployed Nakafa app can publish. */
+export declare const RendererPublishedDomainsSchema: Schema.$Array<Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>>;
+export type RendererPublishedDomains = typeof RendererPublishedDomainsSchema.Type;
+/** Sorts route-domain registries with cross-machine code-unit ordering. */
+export declare function sortRendererDomains<T extends RendererDomainCapability>(domains: readonly T[]): T[];
+/** Canonical persisted domains, including older known domain subsets. */
+export declare const RendererManifestDomainsSchema: 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;
+    }>>;
+}>>;
+/** Complete current domain set required from a newly created live manifest. */
+export declare const LiveRendererManifestDomainsSchema: 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;
+    }>>;
+}>>;
+/** Hash-authenticated renderer envelope persisted with one signed release. */
+export declare const RendererManifestEnvelopeSchema: 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 RendererManifestEnvelope = typeof RendererManifestEnvelopeSchema.Type;
+declare const RendererDomainCapabilityMissingError_base: Schema.Class<RendererDomainCapabilityMissingError, Schema.TaggedStruct<"RendererDomainCapabilityMissingError", {
+    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>;
+/** A persisted renderer envelope does not carry the requested domain. */
+export declare class RendererDomainCapabilityMissingError extends RendererDomainCapabilityMissingError_base {
+}
+/** Selects the one physical route registry authorized for a document. */
+export declare const selectRendererDomainCapability: (manifest: {
+    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";
+}, rendererDomain: "ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math") => Effect.Effect<{
+    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;
+    }[];
+}, RendererDomainCapabilityMissingError, never>;
+declare const RendererManifestHashComputeError_base: Schema.Class<RendererManifestHashComputeError, Schema.TaggedStruct<"RendererManifestHashComputeError", {
+    readonly cause: Schema.Unknown;
+}>, import("effect/Cause").YieldableError>;
+/** SHA-256 could not be calculated for the renderer contract bytes. */
+export declare class RendererManifestHashComputeError extends RendererManifestHashComputeError_base {
+}
+declare const RendererManifestHashMismatchError_base: Schema.Class<RendererManifestHashMismatchError, Schema.TaggedStruct<"RendererManifestHashMismatchError", {
+    readonly actualHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, import("effect/Cause").YieldableError>;
+/** The renderer envelope hash does not authenticate its canonical tuple. */
+export declare class RendererManifestHashMismatchError extends RendererManifestHashMismatchError_base {
+}
+/** Serializes the exact domain-scoped renderer tuple covered by SHA-256. */
+export declare function canonicalizeRendererManifestContract(input: {
+    readonly base: RendererCapability;
+    readonly domains: readonly RendererDomainCapability[];
+    readonly publishedDomains: RendererPublishedDomains;
+}): string;
+export {};

package/dist/renderer/contract.js

@@ -0,0 +1,122 @@
+import { Effect, Schema } from "effect";
+import { Sha256HashSchema } from "#contracts/ids";
+import { hasCompleteRendererSelection, RendererAuthoringComponentsSchema, RendererCapabilitySchema, RendererSupportedComponentsSchema, } from "#contracts/renderer/component";
+import { RENDERER_DOMAINS, RendererDomainSchema, } from "#contracts/renderer/domain";
+import { compareCodeUnits } from "#contracts/text/order";
+const RENDERER_CONTRACT_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+/** Domain-scoped renderer wire version shared with Nakafa. */
+export const RENDERER_CONTRACT_VERSION = "1.0.0";
+/** Stable wire format for a domain-scoped Nakafa renderer manifest. */
+export const RENDERER_MANIFEST_FORMAT = "nakafa-mdx-renderer-v1";
+/** Canonical semantic version carried by a renderer runtime boundary. */
+export const RendererContractVersionSchema = Schema.String.pipe(Schema.check(Schema.isPattern(RENDERER_CONTRACT_VERSION_PATTERN)));
+/** One route-domain component contract with an exact real domain name. */
+export const RendererDomainCapabilitySchema = Schema.Struct({
+    authoringComponents: RendererAuthoringComponentsSchema,
+    name: RendererDomainSchema,
+    supportedComponents: RendererSupportedComponentsSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCompleteRendererSelection, {
+    message: "Expected one supported authoring selection for every domain component.",
+})));
+/** Checks published route domains are unique and ordered by code unit. */
+function hasCanonicalPublishedDomains(domains) {
+    const canonical = [...domains].sort(compareCodeUnits);
+    return domains.every((domain, index) => domain === canonical[index] && domain !== domains[index - 1]);
+}
+/** Canonical route domains that the deployed Nakafa app can publish. */
+export const RendererPublishedDomainsSchema = Schema.Array(RendererDomainSchema).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter(hasCanonicalPublishedDomains, {
+    message: "Expected unique published renderer domains in canonical order.",
+})));
+/** Sorts route-domain registries with cross-machine code-unit ordering. */
+export function sortRendererDomains(domains) {
+    return [...domains].sort((left, right) => compareCodeUnits(left.name, right.name));
+}
+/** Checks persisted route domains are unique and canonically ordered. */
+function hasCanonicalRendererDomains(domains) {
+    const canonical = sortRendererDomains(domains);
+    return domains.every((domain, index) => domain.name === canonical[index]?.name &&
+        domain.name !== domains[index - 1]?.name);
+}
+/** Canonical persisted domains, including older known domain subsets. */
+export const RendererManifestDomainsSchema = Schema.Array(RendererDomainCapabilitySchema).pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.makeFilter(hasCanonicalRendererDomains, {
+    message: "Expected unique renderer domains in canonical order.",
+})));
+/** Complete current domain set required from a newly created live manifest. */
+export const LiveRendererManifestDomainsSchema = RendererManifestDomainsSchema.pipe(Schema.check(Schema.makeFilter((domains) => domains.length === RENDERER_DOMAINS.length &&
+    domains.every(({ name }, index) => name === RENDERER_DOMAINS[index]), {
+    message: "Expected every live renderer domain in canonical order.",
+})));
+/** Keeps base component names out of every route-owned registry. */
+function hasDistinctBaseComponents(manifest) {
+    const baseNames = new Set(manifest.base.supportedComponents.map(({ name }) => name));
+    for (const domain of manifest.domains) {
+        for (const { name } of domain.supportedComponents) {
+            if (baseNames.has(name)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/** Keeps published domains bound to capabilities in the same envelope. */
+function hasPublishedDomainCapabilities(manifest) {
+    const capabilities = new Set(manifest.domains.map(({ name }) => name));
+    return manifest.publishedDomains.every((domain) => capabilities.has(domain));
+}
+/** Hash-authenticated renderer envelope persisted with one signed release. */
+export const RendererManifestEnvelopeSchema = Schema.Struct({
+    base: RendererCapabilitySchema,
+    domains: RendererManifestDomainsSchema,
+    format: Schema.Literal(RENDERER_MANIFEST_FORMAT),
+    hash: Sha256HashSchema,
+    publishedDomains: RendererPublishedDomainsSchema,
+    rendererContractVersion: Schema.Literal(RENDERER_CONTRACT_VERSION),
+}).pipe(Schema.check(Schema.makeFilter(hasPublishedDomainCapabilities, {
+    message: "Expected every published renderer domain to have a capability.",
+})), Schema.check(Schema.makeFilter(hasDistinctBaseComponents, {
+    message: "Expected base and route-domain component names to be disjoint.",
+})));
+/** A persisted renderer envelope does not carry the requested domain. */
+export class RendererDomainCapabilityMissingError extends Schema.TaggedError()("RendererDomainCapabilityMissingError", { rendererDomain: RendererDomainSchema }) {
+}
+/** Selects the one physical route registry authorized for a document. */
+export const selectRendererDomainCapability = Effect.fn("AksaraContracts.selectRendererDomainCapability")(function* (manifest, rendererDomain) {
+    const capability = manifest.domains.find(({ name }) => name === rendererDomain);
+    if (!capability) {
+        return yield* new RendererDomainCapabilityMissingError({ rendererDomain });
+    }
+    return capability;
+});
+/** SHA-256 could not be calculated for the renderer contract bytes. */
+export class RendererManifestHashComputeError extends Schema.TaggedError()("RendererManifestHashComputeError", { cause: Schema.Unknown }) {
+}
+/** The renderer envelope hash does not authenticate its canonical tuple. */
+export class RendererManifestHashMismatchError extends Schema.TaggedError()("RendererManifestHashMismatchError", {
+    actualHash: Sha256HashSchema,
+    expectedHash: Sha256HashSchema,
+}) {
+}
+/** Serializes the exact domain-scoped renderer tuple covered by SHA-256. */
+export function canonicalizeRendererManifestContract(input) {
+    /** Copies one registry capability into exact canonical wire fields. */
+    const capability = (value) => ({
+        authoringComponents: value.authoringComponents.map(({ name, version }) => ({
+            name,
+            version,
+        })),
+        supportedComponents: value.supportedComponents.map(({ name, version }) => ({
+            name,
+            version,
+        })),
+    });
+    return JSON.stringify([
+        RENDERER_MANIFEST_FORMAT,
+        RENDERER_CONTRACT_VERSION,
+        capability(input.base),
+        sortRendererDomains(input.domains).map(({ name, ...domain }) => ({
+            name,
+            ...capability(domain),
+        })),
+        input.publishedDomains,
+    ]);
+}

package/dist/renderer/domain.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+/** Renderer domains backed by real route-owned Nakafa registries. */
+export declare const RENDERER_DOMAINS: readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"];
+/** Exact route-domain identity carried by authored and compiled content. */
+export declare const RendererDomainSchema: Schema.Literals<readonly ["ai-ds", "biology", "chemistry", "mathematics", "physics", "politics", "site", "snbt-general", "snbt-math", "snbt-plain", "snbt-quant", "tka-math"]>;
+export type RendererDomain = typeof RendererDomainSchema.Type;

package/dist/renderer/domain.js

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+/** Renderer domains backed by real route-owned Nakafa registries. */
+export const RENDERER_DOMAINS = [
+    "ai-ds",
+    "biology",
+    "chemistry",
+    "mathematics",
+    "physics",
+    "politics",
+    "site",
+    "snbt-general",
+    "snbt-math",
+    "snbt-plain",
+    "snbt-quant",
+    "tka-math",
+];
+/** Exact route-domain identity carried by authored and compiled content. */
+export const RendererDomainSchema = Schema.Literals(RENDERER_DOMAINS);

package/dist/renderer/manifest.d.ts

@@ -0,0 +1,86 @@
+import { Effect } from "effect";
+import { RendererManifestHashComputeError, RendererManifestHashMismatchError } from "#contracts/renderer/contract";
+/** Creates a canonical renderer envelope from real registry capabilities. */
+export declare const createRendererManifest: (input: unknown) => Effect.Effect<{
+    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";
+}, import("../errors.js").ContractDecodeError | import("#contracts/renderer/component").RendererAuthoringComponentDuplicateError | import("#contracts/renderer/component").RendererAuthoringComponentExtraError | import("#contracts/renderer/component").RendererAuthoringComponentMissingError | import("#contracts/renderer/component").RendererAuthoringComponentUnsupportedError | import("#contracts/renderer/component").RendererAuthoringSelectionNonCanonicalError | RendererManifestHashComputeError, never>;
+/** Verifies one persisted envelope, including a known historical domain subset. */
+export declare const validateRendererManifestHash: (input: unknown) => Effect.Effect<{
+    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";
+}, import("../errors.js").ContractDecodeError | import("#contracts/renderer/component").RendererAuthoringComponentDuplicateError | import("#contracts/renderer/component").RendererAuthoringComponentExtraError | import("#contracts/renderer/component").RendererAuthoringComponentMissingError | import("#contracts/renderer/component").RendererAuthoringComponentUnsupportedError | import("#contracts/renderer/component").RendererAuthoringSelectionNonCanonicalError | RendererManifestHashComputeError | RendererManifestHashMismatchError, never>;
+/** Verifies one complete manifest supplied by a current live renderer. */
+export declare const validateLiveRendererManifestHash: (input: unknown) => Effect.Effect<{
+    base: {
+        readonly authoringComponents: readonly {
+            readonly name: string;
+            readonly version: number;
+        }[];
+        readonly supportedComponents: readonly {
+            readonly name: string;
+            readonly version: number;
+        }[];
+    };
+    format: "nakafa-mdx-renderer-v1";
+    hash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    publishedDomains: readonly ("ai-ds" | "biology" | "chemistry" | "mathematics" | "physics" | "politics" | "site" | "snbt-general" | "snbt-math" | "snbt-plain" | "snbt-quant" | "tka-math")[];
+    rendererContractVersion: "1.0.0";
+    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;
+        }[];
+    }[];
+}, import("../errors.js").ContractDecodeError | import("#contracts/renderer/component").RendererAuthoringComponentDuplicateError | import("#contracts/renderer/component").RendererAuthoringComponentExtraError | import("#contracts/renderer/component").RendererAuthoringComponentMissingError | import("#contracts/renderer/component").RendererAuthoringComponentUnsupportedError | import("#contracts/renderer/component").RendererAuthoringSelectionNonCanonicalError | RendererManifestHashComputeError | RendererManifestHashMismatchError, never>;

package/dist/renderer/manifest.js

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+import { decodeContract } from "#contracts/decode";
+import { hashText } from "#contracts/hash/text";
+import { Sha256HashSchema } from "#contracts/ids";
+import { RendererComponentRequirementSchema } from "#contracts/renderer/component";
+import { canonicalizeRendererManifestContract, LiveRendererManifestDomainsSchema, RENDERER_CONTRACT_VERSION, RENDERER_MANIFEST_FORMAT, RendererManifestEnvelopeSchema, RendererManifestHashComputeError, RendererManifestHashMismatchError, RendererPublishedDomainsSchema, } from "#contracts/renderer/contract";
+import { RendererDomainSchema, } from "#contracts/renderer/domain";
+import { normalizeRendererSelection } from "#contracts/renderer/selection";
+import { compareCodeUnits } from "#contracts/text/order";
+const CapabilityCreationFields = {
+    authoringComponents: Schema.Array(RendererComponentRequirementSchema),
+    supportedComponents: Schema.Array(RendererComponentRequirementSchema),
+};
+const RendererManifestCreationSchema = Schema.Struct({
+    base: Schema.Struct(CapabilityCreationFields),
+    domains: Schema.Array(Schema.Struct({ name: RendererDomainSchema, ...CapabilityCreationFields })),
+    publishedDomains: Schema.Array(RendererDomainSchema),
+});
+const RendererManifestWireSchema = Schema.Struct({
+    ...RendererManifestCreationSchema.fields,
+    format: Schema.Literal(RENDERER_MANIFEST_FORMAT),
+    hash: Sha256HashSchema,
+    rendererContractVersion: Schema.Literal(RENDERER_CONTRACT_VERSION),
+});
+/** Sorts and decodes the exact route domains exposed by the deployed app. */
+const normalizePublishedDomains = Effect.fn("AksaraContracts.normalizePublishedDomains")((domains) => decodeContract(RendererPublishedDomainsSchema, "RendererPublishedDomains", [...domains].sort(compareCodeUnits)));
+/** Hashes the canonical base and domain-scoped renderer contract. */
+const hashRendererContract = Effect.fn("AksaraContracts.hashRendererContract")((input) => hashText(canonicalizeRendererManifestContract(input)).pipe(Effect.mapError(({ cause }) => new RendererManifestHashComputeError({ cause }))));
+/** Creates a canonical renderer envelope from real registry capabilities. */
+export const createRendererManifest = Effect.fn("AksaraContracts.createRendererManifest")((input) => decodeContract(RendererManifestCreationSchema, "RendererManifestCreation", input).pipe(Effect.flatMap((wire) => Effect.all({
+    contract: normalizeRendererSelection(wire).pipe(Effect.flatMap((contract) => decodeContract(LiveRendererManifestDomainsSchema, "LiveRendererManifestDomains", contract.domains).pipe(Effect.map((domains) => ({ ...contract, domains }))))),
+    publishedDomains: normalizePublishedDomains(wire.publishedDomains),
+})), Effect.flatMap(({ contract, publishedDomains }) => hashRendererContract({ ...contract, publishedDomains }).pipe(Effect.flatMap((hash) => decodeContract(RendererManifestEnvelopeSchema, "RendererManifestEnvelope", {
+    ...contract,
+    format: RENDERER_MANIFEST_FORMAT,
+    hash,
+    publishedDomains,
+    rendererContractVersion: RENDERER_CONTRACT_VERSION,
+}))))));
+/** Verifies one persisted envelope, including a known historical domain subset. */
+export const validateRendererManifestHash = Effect.fn("AksaraContracts.validateRendererManifestHash")((input) => decodeContract(RendererManifestWireSchema, "RendererManifestEnvelope", input).pipe(Effect.flatMap((wire) => Effect.all({
+    contract: normalizeRendererSelection(wire),
+    publishedDomains: normalizePublishedDomains(wire.publishedDomains),
+}).pipe(Effect.flatMap(({ contract, publishedDomains }) => hashRendererContract({ ...contract, publishedDomains }).pipe(Effect.filterOrFail((actualHash) => actualHash === wire.hash, (actualHash) => new RendererManifestHashMismatchError({
+    actualHash,
+    expectedHash: wire.hash,
+})), Effect.flatMap(() => decodeContract(RendererManifestEnvelopeSchema, "RendererManifestEnvelope", { ...wire, ...contract, publishedDomains }))))))));
+/** Verifies one complete manifest supplied by a current live renderer. */
+export const validateLiveRendererManifestHash = Effect.fn("AksaraContracts.validateLiveRendererManifestHash")((input) => validateRendererManifestHash(input).pipe(Effect.flatMap((manifest) => decodeContract(LiveRendererManifestDomainsSchema, "LiveRendererManifestDomains", manifest.domains).pipe(Effect.map((domains) => ({ ...manifest, domains }))))));

package/dist/renderer/selection.d.ts

@@ -0,0 +1,39 @@
+import { Effect } from "effect";
+import { RendererAuthoringComponentDuplicateError, RendererAuthoringComponentExtraError, RendererAuthoringComponentMissingError, RendererAuthoringComponentUnsupportedError, RendererAuthoringSelectionNonCanonicalError, type RendererComponentRequirement } from "#contracts/renderer/component";
+import type { RendererDomain } from "#contracts/renderer/domain";
+/** Unnormalized component contract accepted at the manifest boundary. */
+export interface RendererCapabilityInput {
+    readonly authoringComponents: readonly RendererComponentRequirement[];
+    readonly supportedComponents: readonly RendererComponentRequirement[];
+}
+/** Unnormalized route-domain contract accepted at the manifest boundary. */
+export interface RendererDomainInput extends RendererCapabilityInput {
+    readonly name: RendererDomain;
+}
+/** Normalizes the exact base plus every canonical route-domain registry. */
+export declare const normalizeRendererSelection: (input: {
+    readonly base: RendererCapabilityInput;
+    readonly domains: readonly RendererDomainInput[];
+}) => Effect.Effect<{
+    base: {
+        readonly authoringComponents: readonly {
+            readonly name: string;
+            readonly version: number;
+        }[];
+        readonly supportedComponents: readonly {
+            readonly name: string;
+            readonly version: number;
+        }[];
+    };
+    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;
+        }[];
+    }[];
+}, import("../errors.js").ContractDecodeError | RendererAuthoringComponentDuplicateError | RendererAuthoringComponentExtraError | RendererAuthoringComponentMissingError | RendererAuthoringComponentUnsupportedError | RendererAuthoringSelectionNonCanonicalError, never>;