@nakafa/aksara-contracts 0.27.0

package/dist/transport/response.js

@@ -0,0 +1,181 @@
+import { Effect, Schema } from "effect";
+import { decodeContract } from "#contracts/decode";
+import { RecoveryLookupSchema } from "#contracts/release/current/evidence";
+import { ContentReleaseCurrentSchema } from "#contracts/release/current/state";
+import { HeadPageSchema } from "#contracts/release/head";
+import { ContentReleaseStatusSchema, ReleaseAbortReceiptSchema, ReleaseCleanupReceiptSchema, } from "#contracts/release/lifecycle";
+import { RollbackPageSchema } from "#contracts/release/rollback/spec";
+import { RoutePageSchema } from "#contracts/release/route/page";
+import { PublicationReceiptSchema, ReleaseVerificationStatusSchema, } from "#contracts/release/spec";
+import { StageBatchReceiptSchema } from "#contracts/transport/batch";
+import { PublicationFailureSchema } from "#contracts/transport/failure";
+import { StageGroupSuccessSchema } from "#contracts/transport/group";
+import { StageTryoutRuntimeBundleReceiptSchema } from "#contracts/transport/runtime";
+import { StageSnapshotBatchReceiptSchema, StageSnapshotReceiptSchema, } from "#contracts/transport/snapshot";
+/** Returns authoritative active, candidate, and recovery identities. */
+export const PublicationCurrentSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("current"),
+    value: ContentReleaseCurrentSchema,
+});
+/** Returns durable cumulative progress from one release abort page. */
+export const PublicationAbortSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("abort"),
+    value: ReleaseAbortReceiptSchema,
+});
+/** Returns terminal discard evidence for one exact retained inverse. */
+export const PublicationAcceptSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("accept"),
+    value: ReleaseAbortReceiptSchema,
+});
+/** Returns one bounded authoritative material-head page. */
+export const PublicationHeadPageSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("headPage"),
+    value: HeadPageSchema,
+});
+/** Returns exact historical recovery completion or explicit absence. */
+export const PublicationRecoverySuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("recovery"),
+    value: RecoveryLookupSchema,
+});
+/** Durable release status that proves stageRelease found or created a row. */
+export const StagedReleaseStatusSchema = ContentReleaseStatusSchema.pipe(Schema.check(Schema.makeFilter((status) => status.phase !== "missing", {
+    message: "Expected stageRelease to return a stored release status.",
+})));
+/** Confirms the exact durable status created or resumed by staging. */
+export const StageReleaseSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageRelease"),
+    value: StagedReleaseStatusSchema,
+});
+/** Confirms the exact durable inverse status created or resumed by staging. */
+export const StageRecoverySuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageRecovery"),
+    value: StagedReleaseStatusSchema,
+});
+/** Confirms the idempotent outcome of one structured-family manifest. */
+export const StageSnapshotSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageSnapshot"),
+    value: StageSnapshotReceiptSchema,
+});
+/** Confirms the idempotent outcome of one structured-snapshot row batch. */
+export const StageSnapshotBatchSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageSnapshotBatch"),
+    value: StageSnapshotBatchReceiptSchema,
+});
+/** Confirms the idempotent outcome of one permanent runtime bundle. */
+export const StageTryoutRuntimeBundleSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageTryoutRuntimeBundle"),
+    value: StageTryoutRuntimeBundleReceiptSchema,
+});
+/** Confirms the idempotent outcome of one ordered item batch. */
+export const StageItemBatchSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageItemBatch"),
+    value: StageBatchReceiptSchema,
+});
+/** Confirms the idempotent outcome of one ordered route batch. */
+export const StageRouteBatchSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageRouteBatch"),
+    value: StageBatchReceiptSchema,
+});
+/** Confirms the idempotent outcome of one projection batch. */
+export const StageProjectionBatchSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageProjectionBatch"),
+    value: StageBatchReceiptSchema,
+});
+/** Confirms the idempotent outcome of one immutable artifact batch. */
+export const StageArtifactBatchSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("stageArtifactBatch"),
+    value: StageBatchReceiptSchema,
+});
+/** Returns the durable phase for the requested exact manifest identity. */
+export const PublicationStatusSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("status"),
+    value: ContentReleaseStatusSchema,
+});
+/** Returns bounded progress or final evidence for durable verification. */
+export const VerifyReleaseSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("verify"),
+    value: ReleaseVerificationStatusSchema,
+});
+/** Returns the atomic activation receipt for one verified release. */
+export const ActivateReleaseSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("activate"),
+    value: PublicationReceiptSchema,
+});
+/** Returns the atomic activation receipt for one retained inverse release. */
+export const ActivateRecoverySuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("activateRecovery"),
+    value: PublicationReceiptSchema,
+});
+/** Returns one exact bounded page used to build a forward rollback. */
+export const PublicationRollbackSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("rollbackPage"),
+    value: RollbackPageSchema,
+});
+/** Returns one bounded prior-owner page used to reverse signed routes. */
+export const PublicationRoutePageSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("routePage"),
+    value: RoutePageSchema,
+});
+/** Returns durable cumulative evidence from server-owned cleanup progress. */
+export const PublicationCleanupSuccessSchema = Schema.Struct({
+    ok: Schema.Literal(true),
+    operation: Schema.Literal("cleanup"),
+    value: ReleaseCleanupReceiptSchema,
+});
+/** Complete success vocabulary returned by publication ingress. */
+export const PublicationSuccessSchema = Schema.Union([
+    PublicationAcceptSuccessSchema,
+    PublicationAbortSuccessSchema,
+    PublicationCurrentSuccessSchema,
+    PublicationHeadPageSuccessSchema,
+    PublicationRecoverySuccessSchema,
+    StageReleaseSuccessSchema,
+    StageRecoverySuccessSchema,
+    StageSnapshotSuccessSchema,
+    StageSnapshotBatchSuccessSchema,
+    StageTryoutRuntimeBundleSuccessSchema,
+    StageGroupSuccessSchema,
+    StageItemBatchSuccessSchema,
+    StageRouteBatchSuccessSchema,
+    StageProjectionBatchSuccessSchema,
+    StageArtifactBatchSuccessSchema,
+    PublicationStatusSuccessSchema,
+    VerifyReleaseSuccessSchema,
+    ActivateReleaseSuccessSchema,
+    ActivateRecoverySuccessSchema,
+    PublicationRollbackSuccessSchema,
+    PublicationRoutePageSuccessSchema,
+    PublicationCleanupSuccessSchema,
+]);
+/** Wraps one stable typed failure without exposing implementation messages. */
+export const PublicationFailureResponseSchema = Schema.Struct({
+    failure: PublicationFailureSchema,
+    ok: Schema.Literal(false),
+});
+/** Complete framework-neutral response vocabulary for publication ingress. */
+export const PublicationResponseSchema = Schema.Union([
+    PublicationSuccessSchema,
+    PublicationFailureResponseSchema,
+]);
+/** Strictly decodes one unknown publication response without throwing. */
+export const decodePublicationResponse = Effect.fn("AksaraContracts.decodePublicationResponse")((input) => decodeContract(PublicationResponseSchema, "PublicationResponse", input));

package/dist/transport/runtime.d.ts

@@ -0,0 +1,77 @@
+import { Schema } from "effect";
+/** Canonical input for staging one permanent signed runtime bundle. */
+export declare const StageTryoutRuntimeBundleInputSchema: Schema.Struct<{
+    bundle: Schema.Struct<{
+        readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: Schema.Struct<{
+            readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly snapshot: Schema.Struct<{
+                readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+                readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly counts: Schema.Struct<{
+                    readonly country: Schema.Int;
+                    readonly exam: Schema.Int;
+                    readonly section: Schema.Int;
+                    readonly set: Schema.Int;
+                    readonly track: Schema.Int;
+                }>;
+                readonly placementCount: Schema.Int;
+                readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly routeCount: Schema.Int;
+                readonly format: Schema.Literal<"localized-tryout-snapshot">;
+                readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+        }>;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type StageTryoutRuntimeBundleInput = typeof StageTryoutRuntimeBundleInputSchema.Type;
+/** Stages one permanent signed runtime bundle before release verification. */
+export declare const StageTryoutRuntimeBundleRequestSchema: Schema.Struct<{
+    readonly bundle: Schema.Struct<{
+        readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+        readonly keyId: Schema.brand<Schema.String, "@NakafaAI/AksaraSigningKeyId">;
+        readonly payload: Schema.Struct<{
+            readonly format: Schema.Literal<"signed-tryout-runtime-bundle">;
+            readonly rendererManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly snapshot: Schema.Struct<{
+                readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+                readonly catalogDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly counts: Schema.Struct<{
+                    readonly country: Schema.Int;
+                    readonly exam: Schema.Int;
+                    readonly section: Schema.Int;
+                    readonly set: Schema.Int;
+                    readonly track: Schema.Int;
+                }>;
+                readonly placementCount: Schema.Int;
+                readonly placementDigest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly routeCount: Schema.Int;
+                readonly format: Schema.Literal<"localized-tryout-snapshot">;
+                readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            }>;
+            readonly sourceGitSha: Schema.brand<Schema.String, "@NakafaAI/AksaraGitCommitSha">;
+            readonly sourceManifestHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly sourceReleaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+        }>;
+        readonly signature: Schema.brand<Schema.String, "@NakafaAI/AksaraEd25519Signature">;
+    }>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly operation: Schema.Literal<"stageTryoutRuntimeBundle">;
+}>;
+export type StageTryoutRuntimeBundleRequest = typeof StageTryoutRuntimeBundleRequestSchema.Type;
+/** Idempotent outcome for one content-addressed runtime bundle. */
+export declare const StageTryoutRuntimeBundleReceiptSchema: Schema.Struct<{
+    readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly created: Schema.Literals<readonly [0, 1]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly unchanged: Schema.Literals<readonly [0, 1]>;
+}>;
+export type StageTryoutRuntimeBundleReceipt = typeof StageTryoutRuntimeBundleReceiptSchema.Type;

package/dist/transport/runtime.js

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema } from "#contracts/ids";
+import { SignedTryoutRuntimeBundleSchema } from "#contracts/tryout/runtime/spec";
+const OutcomeCountSchema = Schema.Literals([0, 1]);
+const StageTryoutRuntimeBundleFields = {
+    bundle: SignedTryoutRuntimeBundleSchema,
+    releaseId: ReleaseIdSchema,
+};
+/** Requires a staged bundle to identify the release that created its source. */
+function hasBoundSourceRelease(input) {
+    return input.bundle.payload.sourceReleaseId === input.releaseId;
+}
+/** Canonical input for staging one permanent signed runtime bundle. */
+export const StageTryoutRuntimeBundleInputSchema = Schema.Struct(StageTryoutRuntimeBundleFields).pipe(Schema.check(Schema.makeFilter(hasBoundSourceRelease, {
+    message: "Expected the runtime bundle to share its source release.",
+})));
+/** Stages one permanent signed runtime bundle before release verification. */
+export const StageTryoutRuntimeBundleRequestSchema = Schema.Struct({
+    ...StageTryoutRuntimeBundleFields,
+    operation: Schema.Literal("stageTryoutRuntimeBundle"),
+}).pipe(Schema.check(Schema.makeFilter(hasBoundSourceRelease, {
+    message: "Expected the runtime bundle to share its source release.",
+})));
+/** Idempotent outcome for one content-addressed runtime bundle. */
+export const StageTryoutRuntimeBundleReceiptSchema = Schema.Struct({
+    bundleHash: Sha256HashSchema,
+    created: OutcomeCountSchema,
+    releaseId: ReleaseIdSchema,
+    snapshotId: Sha256HashSchema,
+    unchanged: OutcomeCountSchema,
+}).pipe(Schema.check(Schema.makeFilter(({ created, unchanged }) => created + unchanged === 1, {
+    message: "Expected exactly one created or unchanged runtime bundle.",
+})));