@nakafa/aksara-contracts 0.27.0

package/dist/release/spec.js

@@ -0,0 +1,200 @@
+import { Schema } from "effect";
+import { ContentFamilySchema } from "#contracts/content";
+import { ContentDeliveryClassSchema } from "#contracts/delivery";
+import { ContentKeySchema, CorpusSourcePathSchema, Ed25519SignatureSchema, ReleaseIdSchema, Sha256HashSchema, SigningKeyIdSchema, } from "#contracts/ids";
+import { ActiveAppLocaleListSchema, ArtifactLocaleSchema, } from "#contracts/locale";
+import { ReleaseOriginSchema } from "#contracts/release/origin";
+import { EMPTY_RESULT_CATALOG_DIGEST } from "#contracts/release/result/spec";
+import { PublicationScopeSchema } from "#contracts/release/snapshot/scope";
+import { ContentSnapshotSetSchema, hasEmptySnapshotBases, hasGitSnapshotModes, hasRollbackSnapshotModes, hasScopedSnapshotTransitions, snapshotRowCount, } from "#contracts/release/snapshot/spec";
+import { RENDERER_CONTRACT_VERSION } from "#contracts/renderer/contract";
+import { RendererDomainSchema } from "#contracts/renderer/domain";
+/** Semantic wire identity of the current localized content release. */
+export const CONTENT_RELEASE_FORMAT = "localized-content-release";
+/** Nonnegative release inventory count authenticated by one manifest. */
+export const ReleaseCountSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** Stable inventory and provenance fields owned by the current release. */
+const ContentReleaseManifestFields = {
+    baseActiveAppLocales: Schema.NullOr(ActiveAppLocaleListSchema),
+    baseManifestHash: Schema.NullOr(Sha256HashSchema),
+    baseReleaseId: Schema.NullOr(ReleaseIdSchema),
+    baseResultCount: ReleaseCountSchema,
+    baseResultDigest: Sha256HashSchema,
+    deleteCount: ReleaseCountSchema,
+    itemCount: ReleaseCountSchema,
+    itemsDigest: Sha256HashSchema,
+    origin: ReleaseOriginSchema,
+    projectionCount: ReleaseCountSchema,
+    projectionDigest: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+    rendererContractVersion: Schema.Literal(RENDERER_CONTRACT_VERSION),
+    rendererManifestHash: Sha256HashSchema,
+    resultCount: ReleaseCountSchema,
+    resultDigest: Sha256HashSchema,
+    rollbackCount: ReleaseCountSchema,
+    rollbackDigest: Sha256HashSchema,
+    routeCount: ReleaseCountSchema,
+    routeDigest: Sha256HashSchema,
+    scope: PublicationScopeSchema,
+    snapshots: ContentSnapshotSetSchema,
+    upsertCount: ReleaseCountSchema,
+};
+/** Checks rollback provenance against forward release identities. */
+function hasCoherentReleaseOrigin(input) {
+    const hasBaseRelease = input.baseReleaseId !== null;
+    if (hasBaseRelease !== (input.baseManifestHash !== null) ||
+        hasBaseRelease !== (input.baseActiveAppLocales !== null) ||
+        input.baseReleaseId === input.releaseId ||
+        input.deleteCount + input.upsertCount !== input.itemCount ||
+        input.rollbackCount !== input.itemCount ||
+        !hasScopedSnapshotTransitions(input.scope, input.snapshots)) {
+        return false;
+    }
+    if (!hasBaseRelease &&
+        (input.baseResultCount !== 0 ||
+            input.baseResultDigest !== EMPTY_RESULT_CATALOG_DIGEST)) {
+        return false;
+    }
+    if (!(hasBaseRelease || hasEmptySnapshotBases(input.snapshots))) {
+        return false;
+    }
+    if (input.origin.kind === "git") {
+        return hasGitSnapshotModes(input.snapshots);
+    }
+    return (input.baseReleaseId === input.origin.releaseId &&
+        input.releaseId !== input.origin.releaseId &&
+        hasRollbackSnapshotModes(input.snapshots));
+}
+/** One immutable artifact selected for a locale-specific content head. */
+export const ContentUpsertSchema = Schema.Struct({
+    artifactHash: Sha256HashSchema,
+    artifactLocale: ArtifactLocaleSchema,
+    contentKey: ContentKeySchema,
+    delivery: ContentDeliveryClassSchema,
+    family: ContentFamilySchema,
+    operation: Schema.Literal("upsert"),
+    rendererDomain: RendererDomainSchema,
+    sourcePath: CorpusSourcePathSchema,
+});
+/** One locale-specific content head removed by an explicit tombstone. */
+export const ContentDeleteSchema = Schema.Struct({
+    artifactLocale: ArtifactLocaleSchema,
+    contentKey: ContentKeySchema,
+    family: ContentFamilySchema,
+    operation: Schema.Literal("delete"),
+});
+/** Complete tagged change vocabulary accepted by the current release. */
+export const ContentChangeSchema = Schema.Union([
+    ContentUpsertSchema,
+    ContentDeleteSchema,
+]);
+export const ReleaseItemIndexSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+/** One separately stored, ordered item authenticated by a release digest. */
+export const ContentReleaseItemSchema = Schema.Struct({
+    change: ContentChangeSchema,
+    index: ReleaseItemIndexSchema,
+    releaseId: ReleaseIdSchema,
+});
+/** Deterministic desired-state transition with signed source provenance. */
+export const ContentReleaseManifestSchema = Schema.Struct({
+    activeAppLocales: ActiveAppLocaleListSchema,
+    ...ContentReleaseManifestFields,
+    format: Schema.Literal(CONTENT_RELEASE_FORMAT),
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentReleaseOrigin, {
+    message: "Expected a new release identity and a coherent source origin.",
+})));
+/** Immutable release manifest plus its asymmetric authenticity proof. */
+export const SignedContentReleaseSchema = Schema.Struct({
+    keyId: SigningKeyIdSchema,
+    manifest: ContentReleaseManifestSchema,
+    manifestHash: Sha256HashSchema,
+    signature: Ed25519SignatureSchema,
+});
+/** Checks whether one application locale is active in a signed release. */
+export function releaseActivatesAppLocale(release, appLocale) {
+    return release.manifest.activeAppLocales.includes(appLocale);
+}
+/** Signed release contract accepted only for rollback-owned operations. */
+export const RollbackSignedContentReleaseSchema = SignedContentReleaseSchema.pipe(Schema.refine((release) => release.manifest.origin.kind === "rollback", { message: "Expected a signed rollback release." }));
+/** Checks that every staged head has exactly one matching item and artifact. */
+function hasCoherentVerificationCounts(input) {
+    const hasBaseRelease = input.baseReleaseId !== null;
+    return (hasBaseRelease === (input.baseManifestHash !== null) &&
+        hasBaseRelease === (input.baseActiveAppLocales !== null) &&
+        (hasBaseRelease ||
+            (input.baseResultCount === 0 &&
+                input.baseResultDigest === EMPTY_RESULT_CATALOG_DIGEST)) &&
+        input.deleteHeads + input.upsertHeads === input.itemCount &&
+        input.rollbackCount === input.itemCount &&
+        input.stagedArtifacts === input.upsertHeads &&
+        input.stagedSnapshotRows === snapshotRowCount(input.snapshots));
+}
+/** Pre-activation evidence proving the fully staged release is coherent. */
+export const ReleaseVerificationEvidenceSchema = Schema.Struct({
+    activeAppLocales: ActiveAppLocaleListSchema,
+    baseActiveAppLocales: Schema.NullOr(ActiveAppLocaleListSchema),
+    baseManifestHash: Schema.NullOr(Sha256HashSchema),
+    baseReleaseId: Schema.NullOr(ReleaseIdSchema),
+    baseResultCount: ReleaseCountSchema,
+    baseResultDigest: Sha256HashSchema,
+    deleteHeads: ReleaseCountSchema,
+    itemCount: ReleaseCountSchema,
+    itemsDigest: Sha256HashSchema,
+    manifestHash: Sha256HashSchema,
+    projectionCount: ReleaseCountSchema,
+    projectionDigest: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+    rendererContractVersion: Schema.Literal(RENDERER_CONTRACT_VERSION),
+    rendererManifestHash: Sha256HashSchema,
+    resultCount: ReleaseCountSchema,
+    resultDigest: Sha256HashSchema,
+    rollbackCount: ReleaseCountSchema,
+    rollbackDigest: Sha256HashSchema,
+    routeCount: ReleaseCountSchema,
+    routeDigest: Sha256HashSchema,
+    snapshots: ContentSnapshotSetSchema,
+    stagedArtifacts: ReleaseCountSchema,
+    stagedRoutes: ReleaseCountSchema,
+    stagedSnapshotRows: ReleaseCountSchema,
+    upsertHeads: ReleaseCountSchema,
+}).pipe(Schema.check(Schema.makeFilter(hasCoherentVerificationCounts, {
+    message: "Expected staged head and artifact counts to match the release items.",
+})));
+/** Durable verification has started but has not produced final evidence yet. */
+export const ReleaseVerificationPendingSchema = Schema.Struct({
+    manifestHash: Sha256HashSchema,
+    phase: Schema.Literal("verifying"),
+    releaseId: ReleaseIdSchema,
+});
+/** Durable verification completed with recomputed release evidence. */
+export const ReleaseVerificationCompleteSchema = Schema.Struct({
+    evidence: ReleaseVerificationEvidenceSchema,
+    phase: Schema.Literal("verified"),
+});
+/** Bounded status returned while durable verification progresses. */
+export const ReleaseVerificationStatusSchema = Schema.Union([
+    ReleaseVerificationPendingSchema,
+    ReleaseVerificationCompleteSchema,
+]);
+/** Delta evidence returned after a release is staged and activated. */
+export const PublicationReceiptSchema = Schema.Struct({
+    activatedHeads: ReleaseCountSchema,
+    activeAppLocales: ActiveAppLocaleListSchema,
+    deletedHeads: ReleaseCountSchema,
+    manifestHash: Sha256HashSchema,
+    projectionDigest: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+    resultCount: ReleaseCountSchema,
+    resultDigest: Sha256HashSchema,
+    routeDigest: Sha256HashSchema,
+    snapshots: ContentSnapshotSetSchema,
+    stagedArtifacts: ReleaseCountSchema,
+    stagedItems: ReleaseCountSchema,
+    stagedProjections: ReleaseCountSchema,
+    stagedRoutes: ReleaseCountSchema,
+    stagedSnapshotRows: ReleaseCountSchema,
+}).pipe(Schema.check(Schema.makeFilter((receipt) => receipt.activatedHeads + receipt.deletedHeads === receipt.stagedItems &&
+    receipt.stagedArtifacts === receipt.activatedHeads &&
+    receipt.stagedSnapshotRows === snapshotRowCount(receipt.snapshots), {
+    message: "Expected activated head and artifact counts to match staged items.",
+})));

package/dist/release/verify.d.ts

@@ -0,0 +1,98 @@
+import { Effect, Schema } from "effect";
+import { type ContentReleaseBundle, type RollbackContentReleaseBundle } from "#contracts/release/lifecycle";
+declare const ReleaseVerificationDecodeError_base: Schema.Class<ReleaseVerificationDecodeError, Schema.TaggedStruct<"ReleaseVerificationDecodeError", {
+    readonly message: Schema.Literal<"Release verification input does not satisfy its exact wire contract.">;
+}>, import("effect/Cause").YieldableError>;
+/** Unknown release input did not exactly satisfy its signed wire contract. */
+export declare class ReleaseVerificationDecodeError extends ReleaseVerificationDecodeError_base {
+}
+declare const ReleaseManifestHashMismatchError_base: Schema.Class<ReleaseManifestHashMismatchError, Schema.TaggedStruct<"ReleaseManifestHashMismatchError", {
+    readonly actualHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly expectedHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, import("effect/Cause").YieldableError>;
+/** The envelope hash does not identify its complete canonical manifest. */
+export declare class ReleaseManifestHashMismatchError extends ReleaseManifestHashMismatchError_base {
+}
+declare const ReleaseBundleVerificationDecodeError_base: Schema.Class<ReleaseBundleVerificationDecodeError, Schema.TaggedStruct<"ReleaseBundleVerificationDecodeError", {
+    readonly message: Schema.Literal<"Release bundle verification input does not satisfy its exact wire contract.">;
+}>, import("effect/Cause").YieldableError>;
+/** Stored release recovery input does not satisfy its exact bundle contract. */
+export declare class ReleaseBundleVerificationDecodeError extends ReleaseBundleVerificationDecodeError_base {
+}
+/** Strictly decodes and authenticates one complete release envelope. */
+export declare const verifySignedContentRelease: (input: unknown) => Effect.Effect<{
+    readonly keyId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSigningKeyId">;
+    readonly manifest: {
+        readonly baseActiveAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]] | null;
+        readonly baseManifestHash: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+        readonly baseReleaseId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">) | null;
+        readonly baseResultCount: number;
+        readonly baseResultDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly deleteCount: number;
+        readonly itemCount: number;
+        readonly itemsDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly origin: {
+            readonly kind: "git";
+            readonly sha: string & import("effect/Brand").Brand<"@NakafaAI/AksaraGitCommitSha">;
+        } | {
+            readonly kind: "rollback";
+            readonly releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+        };
+        readonly projectionCount: number;
+        readonly projectionDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly releaseId: string & import("effect/Brand").Brand<"@NakafaAI/AksaraReleaseId">;
+        readonly rendererContractVersion: "1.0.0";
+        readonly rendererManifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly resultCount: number;
+        readonly resultDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly rollbackCount: number;
+        readonly rollbackDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly routeCount: number;
+        readonly routeDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+        readonly scope: {
+            readonly content?: readonly {
+                readonly artifactLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraArtifactLocale">;
+                readonly contentKey: string & import("effect/Brand").Brand<"@NakafaAI/AksaraContentKey">;
+                readonly family: "article" | "material" | "page" | "question";
+            }[] | undefined;
+            readonly families: readonly ("article" | "material" | "page" | "question")[];
+            readonly snapshots: readonly ("program" | "quran" | "tryout")[];
+        };
+        readonly snapshots: {
+            readonly program: {
+                readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly mode: "inherit" | "replace" | "restore";
+                readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly rowCount: number;
+                readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            };
+            readonly quran: {
+                readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly mode: "inherit" | "replace" | "restore";
+                readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly rowCount: number;
+                readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            };
+            readonly tryout: {
+                readonly baseSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly mode: "inherit" | "replace" | "restore";
+                readonly resultSnapshotId: (string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">) | null;
+                readonly rowCount: number;
+                readonly rowDigest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+            };
+        };
+        readonly upsertCount: number;
+        readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+        readonly format: "localized-content-release";
+    };
+    readonly manifestHash: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly signature: string & import("effect/Brand").Brand<"@NakafaAI/AksaraEd25519Signature">;
+}, import("../signature/spec.js").PublicKeyParseError | import("../signature/spec.js").PublicKeyTypeError | import("#contracts/release/hash").ReleaseHashComputationError | ReleaseManifestHashMismatchError | ReleaseVerificationDecodeError | 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>;
+/** Strictly decodes and authenticates one renderer-bound release bundle. */
+declare function verifyBundle<A extends ContentReleaseBundle, I>(schema: Schema.Codec<A, I>, input: unknown): Effect.Effect<A, import("../errors.js").ContractDecodeError | import("../signature/spec.js").PublicKeyParseError | import("../signature/spec.js").PublicKeyTypeError | ReleaseBundleVerificationDecodeError | import("#contracts/release/hash").ReleaseHashComputationError | ReleaseManifestHashMismatchError | ReleaseVerificationDecodeError | 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("../renderer/contract.js").RendererManifestHashComputeError | import("../renderer/contract.js").RendererManifestHashMismatchError | 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>;
+/** Authenticates one signed release and its frozen renderer contract together. */
+export declare const verifyContentReleaseBundle: (input: unknown) => Effect.Effect<ContentReleaseBundle, Effect.Error<ReturnType<typeof verifyBundle>>, Effect.Services<ReturnType<typeof verifyBundle>>>;
+/** Authenticates a renderer-bound release only when rollback owns its origin. */
+export declare const verifyRollbackContentReleaseBundle: (input: unknown) => Effect.Effect<RollbackContentReleaseBundle, Effect.Error<ReturnType<typeof verifyBundle>>, Effect.Services<ReturnType<typeof verifyBundle>>>;
+export {};

package/dist/release/verify.js

@@ -0,0 +1,70 @@
+import { Effect, Schema } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema } from "#contracts/ids";
+import { hashContentReleaseManifest } from "#contracts/release/hash";
+import { ContentReleaseBundleSchema, RollbackContentReleaseBundleSchema, } from "#contracts/release/lifecycle";
+import { canonicalizeContentReleaseSigningInput } from "#contracts/release/signing";
+import { SignedContentReleaseSchema, } from "#contracts/release/spec";
+import { validateRendererManifestHash } from "#contracts/renderer/manifest";
+import { verifyEd25519Signature } from "#contracts/signature/verify";
+/** Unknown release input did not exactly satisfy its signed wire contract. */
+export class ReleaseVerificationDecodeError extends Schema.TaggedError()("ReleaseVerificationDecodeError", {
+    message: Schema.Literal("Release verification input does not satisfy its exact wire contract."),
+}) {
+}
+/** The envelope hash does not identify its complete canonical manifest. */
+export class ReleaseManifestHashMismatchError extends Schema.TaggedError()("ReleaseManifestHashMismatchError", {
+    actualHash: Sha256HashSchema,
+    expectedHash: Sha256HashSchema,
+    releaseId: ReleaseIdSchema,
+}) {
+}
+/** Stored release recovery input does not satisfy its exact bundle contract. */
+export class ReleaseBundleVerificationDecodeError extends Schema.TaggedError()("ReleaseBundleVerificationDecodeError", {
+    message: Schema.Literal("Release bundle verification input does not satisfy its exact wire contract."),
+}) {
+}
+/** Confirms that a release envelope identifies its canonical manifest. */
+function validateManifestHash(releaseId, expectedHash, actualHash) {
+    if (expectedHash === actualHash) {
+        return Effect.void;
+    }
+    return Effect.fail(new ReleaseManifestHashMismatchError({
+        actualHash,
+        expectedHash,
+        releaseId,
+    }));
+}
+/** Authenticates one already decoded current release. */
+const authenticateRelease = Effect.fn("AksaraContracts.authenticateRelease")(function* (release) {
+    const actualHash = yield* hashContentReleaseManifest(release.manifest);
+    yield* validateManifestHash(release.manifest.releaseId, release.manifestHash, actualHash);
+    const message = canonicalizeContentReleaseSigningInput(release.manifestHash, release.manifest);
+    yield* verifyEd25519Signature({
+        keyId: release.keyId,
+        message,
+        signature: release.signature,
+        subject: "release",
+    });
+    return release;
+});
+/** Strictly decodes and authenticates one complete release envelope. */
+export const verifySignedContentRelease = Effect.fn("AksaraContracts.verifySignedContentRelease")((input) => Schema.decodeUnknownEffect(SignedContentReleaseSchema)(input, {
+    onExcessProperty: "error",
+}).pipe(Effect.mapError(() => new ReleaseVerificationDecodeError({
+    message: "Release verification input does not satisfy its exact wire contract.",
+})), Effect.flatMap(authenticateRelease)));
+/** Strictly decodes and authenticates one renderer-bound release bundle. */
+function verifyBundle(schema, input) {
+    return Schema.decodeUnknownEffect(schema)(input, {
+        onExcessProperty: "error",
+    }).pipe(Effect.mapError(() => new ReleaseBundleVerificationDecodeError({
+        message: "Release bundle verification input does not satisfy its exact wire contract.",
+    })), Effect.tap((bundle) => Effect.all([
+        verifySignedContentRelease(bundle.release),
+        validateRendererManifestHash(bundle.rendererManifest),
+    ], { discard: true })));
+}
+/** Authenticates one signed release and its frozen renderer contract together. */
+export const verifyContentReleaseBundle = Effect.fn("AksaraContracts.verifyContentReleaseBundle")((input) => verifyBundle(ContentReleaseBundleSchema, input));
+/** Authenticates a renderer-bound release only when rollback owns its origin. */
+export const verifyRollbackContentReleaseBundle = Effect.fn("AksaraContracts.verifyRollbackContentReleaseBundle")((input) => verifyBundle(RollbackContentReleaseBundleSchema, input));

package/dist/renderer/compatibility.d.ts

@@ -0,0 +1,35 @@
+import { Effect } from "effect";
+import { ArtifactRendererComponentMissingError, ArtifactRendererDomainUnpublishedError, ArtifactRendererVersionUnsupportedError, type ArtifactVerificationRequest, RendererContractVersionMismatchError } from "#contracts/artifact/spec";
+import type { CompiledContentPayload } from "#contracts/content";
+/** Verifies that a deployed live renderer can route and execute one artifact. */
+export declare const verifyContentRendererCompatibility: (args_0: {
+    readonly payload: CompiledContentPayload;
+    readonly rendererContractVersion: ArtifactVerificationRequest["rendererContractVersion"];
+    readonly rendererManifest: 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";
+}, ArtifactRendererComponentMissingError | ArtifactRendererDomainUnpublishedError | ArtifactRendererVersionUnsupportedError | import("../errors.js").ContractDecodeError | import("./component.js").RendererAuthoringComponentDuplicateError | import("./component.js").RendererAuthoringComponentExtraError | import("./component.js").RendererAuthoringComponentMissingError | import("./component.js").RendererAuthoringComponentUnsupportedError | import("./component.js").RendererAuthoringSelectionNonCanonicalError | RendererContractVersionMismatchError | import("#contracts/renderer/contract").RendererDomainCapabilityMissingError | import("#contracts/renderer/contract").RendererManifestHashComputeError | import("#contracts/renderer/contract").RendererManifestHashMismatchError, never>;

package/dist/renderer/compatibility.js

@@ -0,0 +1,48 @@
+import { Effect } from "effect";
+import { ArtifactRendererComponentMissingError, ArtifactRendererDomainUnpublishedError, ArtifactRendererVersionUnsupportedError, RendererContractVersionMismatchError, } from "#contracts/artifact/spec";
+import { selectRendererDomainCapability, } from "#contracts/renderer/contract";
+import { validateRendererManifestHash } from "#contracts/renderer/manifest";
+/** Confirms that base plus the selected domain implement every requirement. */
+function validateRendererRequirements(payload, manifest) {
+    return Effect.gen(function* () {
+        const domain = yield* selectRendererDomainCapability(manifest, payload.rendererDomain);
+        const supportedComponents = [
+            ...manifest.base.supportedComponents,
+            ...domain.supportedComponents,
+        ];
+        for (const requirement of payload.requiredComponents) {
+            const versions = supportedComponents.filter(({ name }) => name === requirement.name);
+            if (versions.length === 0) {
+                return yield* new ArtifactRendererComponentMissingError({
+                    componentName: requirement.name,
+                    contentKey: payload.contentKey,
+                });
+            }
+            if (!versions.some(({ version }) => version === requirement.version)) {
+                return yield* new ArtifactRendererVersionUnsupportedError({
+                    componentName: requirement.name,
+                    contentKey: payload.contentKey,
+                    requiredVersion: requirement.version,
+                });
+            }
+        }
+    });
+}
+/** Verifies that a deployed live renderer can route and execute one artifact. */
+export const verifyContentRendererCompatibility = Effect.fn("AksaraContracts.verifyContentRendererCompatibility")(function* ({ payload, rendererContractVersion, rendererManifest, }) {
+    const manifest = yield* validateRendererManifestHash(rendererManifest);
+    if (!manifest.publishedDomains.includes(payload.rendererDomain)) {
+        return yield* new ArtifactRendererDomainUnpublishedError({
+            contentKey: payload.contentKey,
+            rendererDomain: payload.rendererDomain,
+        });
+    }
+    if (rendererContractVersion !== manifest.rendererContractVersion) {
+        return yield* new RendererContractVersionMismatchError({
+            actualVersion: rendererContractVersion,
+            expectedVersion: manifest.rendererContractVersion,
+        });
+    }
+    yield* validateRendererRequirements(payload, manifest);
+    return manifest;
+});

package/dist/renderer/component.d.ts

@@ -0,0 +1,99 @@
+import { Schema } from "effect";
+/** Renderer names are simple identifiers, never dotted member paths. */
+export declare const RendererComponentNameSchema: Schema.String;
+/** One named renderer capability and its positive contract version. */
+export declare const RendererComponentRequirementSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>;
+export type RendererComponentRequirement = typeof RendererComponentRequirementSchema.Type;
+/** Canonically sorts component requirements by name and then version. */
+export declare function sortRendererComponentRequirements(requirements: readonly RendererComponentRequirement[]): {
+    readonly name: string;
+    readonly version: number;
+}[];
+/** Canonical runtime capabilities; an empty route domain is valid. */
+export declare const RendererSupportedComponentsSchema: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>>;
+/** Canonical compiler choices; an empty route domain is valid. */
+export declare const RendererAuthoringComponentsSchema: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>>;
+/** Canonical runtime capabilities; multiple versions per name are allowed. */
+export declare const RendererManifestSupportedComponentsSchema: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>>;
+/** Canonical compiler choices; exactly one version exists for every name. */
+export declare const RendererManifestAuthoringComponentsSchema: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>>;
+/** Canonical artifact requirements; an artifact chooses one version per name. */
+export declare const CompiledContentRequirementsSchema: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.Finite;
+}>>;
+declare const RendererCapabilityStructSchema: 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;
+    }>>;
+}>;
+type RendererCapabilityStruct = typeof RendererCapabilityStructSchema.Type;
+/** Checks that authoring pins select every supported component exactly once. */
+export declare function hasCompleteRendererSelection(components: RendererCapabilityStruct): boolean;
+/** One complete component contract owned by one physical registry scope. */
+export declare const RendererCapabilitySchema: 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;
+    }>>;
+}>;
+export type RendererCapability = typeof RendererCapabilitySchema.Type;
+declare const RendererAuthoringComponentDuplicateError_base: Schema.Class<RendererAuthoringComponentDuplicateError, Schema.TaggedStruct<"RendererAuthoringComponentDuplicateError", {
+    readonly componentName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** More than one authoring version was selected for one component name. */
+export declare class RendererAuthoringComponentDuplicateError extends RendererAuthoringComponentDuplicateError_base {
+}
+declare const RendererAuthoringComponentMissingError_base: Schema.Class<RendererAuthoringComponentMissingError, Schema.TaggedStruct<"RendererAuthoringComponentMissingError", {
+    readonly componentName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A runtime-supported component has no pinned authoring version. */
+export declare class RendererAuthoringComponentMissingError extends RendererAuthoringComponentMissingError_base {
+}
+declare const RendererAuthoringComponentExtraError_base: Schema.Class<RendererAuthoringComponentExtraError, Schema.TaggedStruct<"RendererAuthoringComponentExtraError", {
+    readonly componentName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Authoring selected a component name absent from runtime support. */
+export declare class RendererAuthoringComponentExtraError extends RendererAuthoringComponentExtraError_base {
+}
+declare const RendererAuthoringComponentUnsupportedError_base: Schema.Class<RendererAuthoringComponentUnsupportedError, Schema.TaggedStruct<"RendererAuthoringComponentUnsupportedError", {
+    readonly componentName: Schema.String;
+    readonly version: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Authoring selected a version absent from runtime support. */
+export declare class RendererAuthoringComponentUnsupportedError extends RendererAuthoringComponentUnsupportedError_base {
+}
+declare const RendererAuthoringSelectionNonCanonicalError_base: Schema.Class<RendererAuthoringSelectionNonCanonicalError, Schema.TaggedStruct<"RendererAuthoringSelectionNonCanonicalError", {
+    readonly componentName: Schema.String;
+    readonly index: Schema.Finite;
+}>, import("effect/Cause").YieldableError>;
+/** Authoring selections were not sorted by canonical component order. */
+export declare class RendererAuthoringSelectionNonCanonicalError extends RendererAuthoringSelectionNonCanonicalError_base {
+}
+/** Serializes one selected compiler component set in canonical order. */
+export declare function canonicalizeRendererAuthoringSelection(authoringComponents: readonly RendererComponentRequirement[]): string;
+export {};