@nakafa/aksara-contracts 0.27.0

package/dist/transport/batch.js

@@ -0,0 +1,101 @@
+import { Schema } from "effect";
+import { SignedContentArtifactSchema } from "#contracts/content";
+import { ReleaseIdSchema } from "#contracts/ids";
+import { ContentProjectionSchema, CurrentContentProjectionSchema, } from "#contracts/projection/spec";
+import { ContentRouteItemSchema } from "#contracts/release/route/spec";
+import { ContentReleaseItemSchema } from "#contracts/release/spec";
+import { MAX_ARTIFACT_BATCH_COUNT, MAX_ITEM_BATCH_COUNT, MAX_PROJECTION_BATCH_COUNT, MAX_ROUTE_BATCH_COUNT, } from "#contracts/transport/limits";
+const BatchIndexSchema = Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+const ReleaseItemBatchSchema = Schema.NonEmptyArray(ContentReleaseItemSchema).pipe(Schema.check(Schema.isMaxLength(MAX_ITEM_BATCH_COUNT)));
+const StageItemBatchFields = {
+    batchIndex: BatchIndexSchema,
+    items: ReleaseItemBatchSchema,
+    releaseId: ReleaseIdSchema,
+};
+/** Checks batch ownership and contiguous signed item indexes. */
+function hasBoundReleaseItems(input) {
+    const [first] = input.items;
+    return input.items.every((item, offset) => item.releaseId === input.releaseId && item.index === first.index + offset);
+}
+/** Canonical input for one bounded ordered-item staging operation. */
+export const StageItemBatchInputSchema = Schema.Struct(StageItemBatchFields).pipe(Schema.check(Schema.makeFilter(hasBoundReleaseItems, {
+    message: "Expected contiguous release items bound to the batch release identity.",
+})));
+/**
+ * Stages one non-empty bounded batch of ordered signed release items.
+ *
+ * Rollback targets bind each upsert to its retained immutable artifact here;
+ * later verification must reject any missing or mismatched retained body.
+ */
+export const StageItemBatchRequestSchema = Schema.Struct({
+    ...StageItemBatchFields,
+    operation: Schema.Literal("stageItemBatch"),
+}).pipe(Schema.check(Schema.makeFilter(hasBoundReleaseItems, {
+    message: "Expected contiguous release items bound to the batch release identity.",
+})));
+const RouteItemBatchSchema = Schema.NonEmptyArray(ContentRouteItemSchema).pipe(Schema.check(Schema.isMaxLength(MAX_ROUTE_BATCH_COUNT)));
+const StageRouteBatchFields = {
+    batchIndex: BatchIndexSchema,
+    releaseId: ReleaseIdSchema,
+    routes: RouteItemBatchSchema,
+};
+/** Checks batch ownership and contiguous signed route indexes. */
+function hasBoundRouteItems(input) {
+    const [first] = input.routes;
+    return input.routes.every((route, offset) => route.releaseId === input.releaseId &&
+        route.index === first.index + offset);
+}
+/** Canonical input for one bounded ordered-route staging operation. */
+export const StageRouteBatchInputSchema = Schema.Struct(StageRouteBatchFields).pipe(Schema.check(Schema.makeFilter(hasBoundRouteItems, {
+    message: "Expected contiguous route items bound to the batch release identity.",
+})));
+/** Stages one non-empty bounded batch of ordered signed route items. */
+export const StageRouteBatchRequestSchema = Schema.Struct({
+    ...StageRouteBatchFields,
+    operation: Schema.Literal("stageRouteBatch"),
+}).pipe(Schema.check(Schema.makeFilter(hasBoundRouteItems, {
+    message: "Expected contiguous route items bound to the batch release identity.",
+})));
+const StageProjectionBatchFields = {
+    batchIndex: BatchIndexSchema,
+    projections: Schema.NonEmptyArray(CurrentContentProjectionSchema).pipe(Schema.check(Schema.isMaxLength(MAX_PROJECTION_BATCH_COUNT))),
+    releaseId: ReleaseIdSchema,
+};
+/** Canonical input for one bounded projection staging operation. */
+export const StageProjectionBatchInputSchema = Schema.Struct(StageProjectionBatchFields);
+/** Stages one non-empty bounded batch of canonical content projections. */
+export const StageProjectionBatchRequestSchema = Schema.Struct({
+    ...StageProjectionBatchFields,
+    operation: Schema.Literal("stageProjectionBatch"),
+});
+const StageRollbackProjectionBatchFields = {
+    batchIndex: BatchIndexSchema,
+    projections: Schema.NonEmptyArray(ContentProjectionSchema).pipe(Schema.check(Schema.isMaxLength(MAX_PROJECTION_BATCH_COUNT))),
+    releaseId: ReleaseIdSchema,
+};
+/** Canonical input reserved for one authenticated rollback release. */
+export const StageRollbackProjectionBatchInputSchema = Schema.Struct(StageRollbackProjectionBatchFields);
+/** Carries historical projections only inside a rollback staging group. */
+export const StageRollbackProjectionBatchRequestSchema = Schema.Struct({
+    ...StageRollbackProjectionBatchFields,
+    operation: Schema.Literal("stageRollbackProjectionBatch"),
+});
+const StageArtifactBatchFields = {
+    artifacts: Schema.NonEmptyArray(SignedContentArtifactSchema).pipe(Schema.check(Schema.isMaxLength(MAX_ARTIFACT_BATCH_COUNT))),
+    batchIndex: BatchIndexSchema,
+    releaseId: ReleaseIdSchema,
+};
+/** Canonical input for one bounded immutable-artifact staging operation. */
+export const StageArtifactBatchInputSchema = Schema.Struct(StageArtifactBatchFields);
+/** Stages one non-empty bounded batch of immutable signed artifacts. */
+export const StageArtifactBatchRequestSchema = Schema.Struct({
+    ...StageArtifactBatchFields,
+    operation: Schema.Literal("stageArtifactBatch"),
+});
+/** Idempotent row counts returned by one bounded staging transaction. */
+export const StageBatchReceiptSchema = Schema.Struct({
+    batchIndex: BatchIndexSchema,
+    created: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+    releaseId: ReleaseIdSchema,
+    unchanged: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+});

package/dist/transport/failure.d.ts

@@ -0,0 +1,168 @@
+import { Schema } from "effect";
+/** Stable rejection codes that require no message parsing by clients. */
+export declare const PublicationDomainRejectionCodeSchema: Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+export type PublicationDomainRejectionCode = typeof PublicationDomainRejectionCodeSchema.Type;
+/** Stable rejection codes that require no message parsing by clients. */
+export declare const PublicationRejectionCodeSchema: Schema.Union<readonly [Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>, Schema.Literal<"CONTENT_RELEASE_INVALID_REQUEST">]>;
+export type PublicationRejectionCode = typeof PublicationRejectionCodeSchema.Type;
+/** Complete stable code vocabulary with one canonical HTTP status mapping. */
+export declare const PublicationFailureCodeSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>, Schema.Literal<"CONTENT_RELEASE_INVALID_REQUEST">]>, Schema.Literals<readonly ["CONTENT_RELEASE_UNAUTHORIZED", "CONTENT_RELEASE_CONFLICT", "CONTENT_RELEASE_STALE_BASE"]>]>;
+export type PublicationFailureCode = typeof PublicationFailureCodeSchema.Type;
+/** Exact HTTP statuses returned for stable publication failures. */
+export declare const PublicationFailureStatusSchema: Schema.Literals<readonly [400, 401, 404, 409, 413, 415, 422]>;
+export type PublicationFailureStatus = typeof PublicationFailureStatusSchema.Type;
+/** Canonical publication failure-code to HTTP-status contract. */
+export declare const PUBLICATION_FAILURE_STATUSES: Readonly<{
+    [Code in PublicationFailureCode]: PublicationFailureStatus;
+}>;
+/** Resolves the exact HTTP status owned by one stable failure code. */
+export declare function publicationFailureStatus(code: PublicationFailureCode): 400 | 401 | 404 | 409 | 413 | 415 | 422;
+/** Authentication failed before any publication capability was invoked. */
+export declare const PublicationUnauthorizedSchema: Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_UNAUTHORIZED">;
+    readonly kind: Schema.Literal<"unauthorized">;
+}>;
+export type PublicationUnauthorized = typeof PublicationUnauthorizedSchema.Type;
+/** Request body was rejected before a publication operation could be decoded. */
+export declare const PublicationPredecodeRejectedSchema: Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Null;
+    readonly releaseId: Schema.Null;
+}>;
+export type PublicationPredecodeRejected = typeof PublicationPredecodeRejectedSchema.Type;
+/** One request was invalid or rejected by a stable authenticated domain rule. */
+export declare const PublicationRejectedSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_INVALID_REQUEST">;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Null;
+    readonly releaseId: Schema.Null;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Null;
+    readonly releaseId: Schema.Null;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Literals<readonly ["accept", "abort", "stageRelease", "stageRecovery", "stageSnapshot", "stageSnapshotBatch", "stageTryoutRuntimeBundle", "stageGroup", "headPage", "recovery", "stageItemBatch", "stageRouteBatch", "stageProjectionBatch", "stageArtifactBatch", "status", "verify", "activate", "activateRecovery", "rollbackPage", "routePage", "cleanup"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Literal<"current">;
+    readonly releaseId: Schema.Null;
+}>]>;
+export type PublicationRejected = typeof PublicationRejectedSchema.Type;
+/** Immutable request identity was reused with different persisted bytes. */
+export declare const PublicationConflictSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literals<readonly ["accept", "abort", "stageRelease", "stageRecovery", "stageGroup", "status", "verify", "activate", "activateRecovery", "rollbackPage", "routePage", "cleanup"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly batchIndex: Schema.Finite;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literals<readonly ["stageItemBatch", "stageRouteBatch", "stageProjectionBatch", "stageArtifactBatch"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly family: Schema.Literals<readonly ["program", "quran", "tryout"]>;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageSnapshot">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, Schema.Struct<{
+    readonly batchIndex: Schema.Int;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly family: Schema.Literals<readonly ["program", "quran", "tryout"]>;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageSnapshotBatch">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, Schema.Struct<{
+    readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageTryoutRuntimeBundle">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>]>;
+export type PublicationConflict = typeof PublicationConflictSchema.Type;
+/** Active publication state no longer matches the signed release base. */
+export declare const PublicationStaleBaseSchema: Schema.Struct<{
+    readonly activeReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_STALE_BASE">;
+    readonly expectedBaseReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+    readonly kind: Schema.Literal<"stale-base">;
+    readonly operation: Schema.Literals<readonly ["stageRelease", "activate"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>;
+export type PublicationStaleBase = typeof PublicationStaleBaseSchema.Type;
+/** Complete stable publication failure vocabulary returned on the wire. */
+export declare const PublicationFailureSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_UNAUTHORIZED">;
+    readonly kind: Schema.Literal<"unauthorized">;
+}>, Schema.Union<readonly [Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_INVALID_REQUEST">;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Null;
+    readonly releaseId: Schema.Null;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Null;
+    readonly releaseId: Schema.Null;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Literals<readonly ["accept", "abort", "stageRelease", "stageRecovery", "stageSnapshot", "stageSnapshotBatch", "stageTryoutRuntimeBundle", "stageGroup", "headPage", "recovery", "stageItemBatch", "stageRouteBatch", "stageProjectionBatch", "stageArtifactBatch", "status", "verify", "activate", "activateRecovery", "rollbackPage", "routePage", "cleanup"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly code: Schema.Literals<readonly ["CONTENT_RELEASE_INTEGRITY", "CONTENT_RELEASE_LIMIT", "CONTENT_RELEASE_MISSING", "CONTENT_RELEASE_ROUTE", "CONTENT_RELEASE_SIZE", "CONTENT_RELEASE_STATE", "CONTENT_RELEASE_UNSUPPORTED"]>;
+    readonly kind: Schema.Literal<"rejected">;
+    readonly operation: Schema.Literal<"current">;
+    readonly releaseId: Schema.Null;
+}>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literals<readonly ["accept", "abort", "stageRelease", "stageRecovery", "stageGroup", "status", "verify", "activate", "activateRecovery", "rollbackPage", "routePage", "cleanup"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly batchIndex: Schema.Finite;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literals<readonly ["stageItemBatch", "stageRouteBatch", "stageProjectionBatch", "stageArtifactBatch"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>, Schema.Struct<{
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly family: Schema.Literals<readonly ["program", "quran", "tryout"]>;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageSnapshot">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, Schema.Struct<{
+    readonly batchIndex: Schema.Int;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly family: Schema.Literals<readonly ["program", "quran", "tryout"]>;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageSnapshotBatch">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>, Schema.Struct<{
+    readonly bundleHash: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_CONFLICT">;
+    readonly kind: Schema.Literal<"conflict">;
+    readonly operation: Schema.Literal<"stageTryoutRuntimeBundle">;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+    readonly snapshotId: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+}>]>, Schema.Struct<{
+    readonly activeReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+    readonly code: Schema.Literal<"CONTENT_RELEASE_STALE_BASE">;
+    readonly expectedBaseReleaseId: Schema.NullOr<Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">>;
+    readonly kind: Schema.Literal<"stale-base">;
+    readonly operation: Schema.Literals<readonly ["stageRelease", "activate"]>;
+    readonly releaseId: Schema.brand<Schema.String, "@NakafaAI/AksaraReleaseId">;
+}>]>;
+export type PublicationFailure = typeof PublicationFailureSchema.Type;

package/dist/transport/failure.js

@@ -0,0 +1,194 @@
+import { Schema } from "effect";
+import { ReleaseIdSchema, Sha256HashSchema } from "#contracts/ids";
+import { ContentSnapshotKindSchema } from "#contracts/release/snapshot/scope";
+/** Stable rejection codes that require no message parsing by clients. */
+export const PublicationDomainRejectionCodeSchema = Schema.Literals([
+    "CONTENT_RELEASE_INTEGRITY",
+    "CONTENT_RELEASE_LIMIT",
+    "CONTENT_RELEASE_MISSING",
+    "CONTENT_RELEASE_ROUTE",
+    "CONTENT_RELEASE_SIZE",
+    "CONTENT_RELEASE_STATE",
+    "CONTENT_RELEASE_UNSUPPORTED",
+]);
+/** Stable rejection codes that require no message parsing by clients. */
+export const PublicationRejectionCodeSchema = Schema.Union([
+    PublicationDomainRejectionCodeSchema,
+    Schema.Literal("CONTENT_RELEASE_INVALID_REQUEST"),
+]);
+/** Complete stable code vocabulary with one canonical HTTP status mapping. */
+export const PublicationFailureCodeSchema = Schema.Union([
+    PublicationRejectionCodeSchema,
+    Schema.Literals([
+        "CONTENT_RELEASE_UNAUTHORIZED",
+        "CONTENT_RELEASE_CONFLICT",
+        "CONTENT_RELEASE_STALE_BASE",
+    ]),
+]);
+/** Exact HTTP statuses returned for stable publication failures. */
+export const PublicationFailureStatusSchema = Schema.Literals([
+    400, 401, 404, 409, 413, 415, 422,
+]);
+/** Canonical publication failure-code to HTTP-status contract. */
+export const PUBLICATION_FAILURE_STATUSES = Object.freeze({
+    CONTENT_RELEASE_CONFLICT: 409,
+    CONTENT_RELEASE_INTEGRITY: 422,
+    CONTENT_RELEASE_INVALID_REQUEST: 400,
+    CONTENT_RELEASE_LIMIT: 413,
+    CONTENT_RELEASE_MISSING: 404,
+    CONTENT_RELEASE_ROUTE: 422,
+    CONTENT_RELEASE_SIZE: 413,
+    CONTENT_RELEASE_STALE_BASE: 409,
+    CONTENT_RELEASE_STATE: 422,
+    CONTENT_RELEASE_UNAUTHORIZED: 401,
+    CONTENT_RELEASE_UNSUPPORTED: 415,
+});
+/** Resolves the exact HTTP status owned by one stable failure code. */
+export function publicationFailureStatus(code) {
+    return PUBLICATION_FAILURE_STATUSES[code];
+}
+/** Authentication failed before any publication capability was invoked. */
+export const PublicationUnauthorizedSchema = Schema.Struct({
+    code: Schema.Literal("CONTENT_RELEASE_UNAUTHORIZED"),
+    kind: Schema.Literal("unauthorized"),
+});
+const PublicationInvalidRequestSchema = Schema.Struct({
+    code: Schema.Literal("CONTENT_RELEASE_INVALID_REQUEST"),
+    kind: Schema.Literal("rejected"),
+    operation: Schema.Null,
+    releaseId: Schema.Null,
+});
+/** Request body was rejected before a publication operation could be decoded. */
+export const PublicationPredecodeRejectedSchema = Schema.Struct({
+    code: Schema.Literals([
+        "CONTENT_RELEASE_SIZE",
+        "CONTENT_RELEASE_UNSUPPORTED",
+    ]),
+    kind: Schema.Literal("rejected"),
+    operation: Schema.Null,
+    releaseId: Schema.Null,
+});
+const PublicationReleaseRejectedSchema = Schema.Struct({
+    code: PublicationDomainRejectionCodeSchema,
+    kind: Schema.Literal("rejected"),
+    operation: Schema.Literals([
+        "accept",
+        "abort",
+        "stageRelease",
+        "stageRecovery",
+        "stageSnapshot",
+        "stageSnapshotBatch",
+        "stageTryoutRuntimeBundle",
+        "stageGroup",
+        "headPage",
+        "recovery",
+        "stageItemBatch",
+        "stageRouteBatch",
+        "stageProjectionBatch",
+        "stageArtifactBatch",
+        "status",
+        "verify",
+        "activate",
+        "activateRecovery",
+        "rollbackPage",
+        "routePage",
+        "cleanup",
+    ]),
+    releaseId: ReleaseIdSchema,
+});
+const PublicationCurrentRejectedSchema = Schema.Struct({
+    code: PublicationDomainRejectionCodeSchema,
+    kind: Schema.Literal("rejected"),
+    operation: Schema.Literal("current"),
+    releaseId: Schema.Null,
+});
+/** One request was invalid or rejected by a stable authenticated domain rule. */
+export const PublicationRejectedSchema = Schema.Union([
+    PublicationInvalidRequestSchema,
+    PublicationPredecodeRejectedSchema,
+    PublicationReleaseRejectedSchema,
+    PublicationCurrentRejectedSchema,
+]);
+const ReleaseConflictSchema = Schema.Struct({
+    code: Schema.Literal("CONTENT_RELEASE_CONFLICT"),
+    kind: Schema.Literal("conflict"),
+    operation: Schema.Literals([
+        "accept",
+        "abort",
+        "stageRelease",
+        "stageRecovery",
+        "stageGroup",
+        "status",
+        "verify",
+        "activate",
+        "activateRecovery",
+        "rollbackPage",
+        "routePage",
+        "cleanup",
+    ]),
+    releaseId: ReleaseIdSchema,
+});
+const BatchConflictSchema = Schema.Struct({
+    batchIndex: Schema.Finite.pipe(Schema.check(Schema.isInt()), Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+    code: Schema.Literal("CONTENT_RELEASE_CONFLICT"),
+    kind: Schema.Literal("conflict"),
+    operation: Schema.Literals([
+        "stageItemBatch",
+        "stageRouteBatch",
+        "stageProjectionBatch",
+        "stageArtifactBatch",
+    ]),
+    releaseId: ReleaseIdSchema,
+});
+const SnapshotManifestConflictSchema = Schema.Struct({
+    code: Schema.Literal("CONTENT_RELEASE_CONFLICT"),
+    family: ContentSnapshotKindSchema,
+    kind: Schema.Literal("conflict"),
+    operation: Schema.Literal("stageSnapshot"),
+    releaseId: ReleaseIdSchema,
+    snapshotId: Sha256HashSchema,
+});
+const SnapshotBatchConflictSchema = Schema.Struct({
+    batchIndex: Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0))),
+    code: Schema.Literal("CONTENT_RELEASE_CONFLICT"),
+    family: ContentSnapshotKindSchema,
+    kind: Schema.Literal("conflict"),
+    operation: Schema.Literal("stageSnapshotBatch"),
+    releaseId: ReleaseIdSchema,
+    snapshotId: Sha256HashSchema,
+});
+const TryoutRuntimeBundleConflictSchema = Schema.Struct({
+    bundleHash: Sha256HashSchema,
+    code: Schema.Literal("CONTENT_RELEASE_CONFLICT"),
+    kind: Schema.Literal("conflict"),
+    operation: Schema.Literal("stageTryoutRuntimeBundle"),
+    releaseId: ReleaseIdSchema,
+    snapshotId: Sha256HashSchema,
+});
+/** Immutable request identity was reused with different persisted bytes. */
+export const PublicationConflictSchema = Schema.Union([
+    ReleaseConflictSchema,
+    BatchConflictSchema,
+    SnapshotManifestConflictSchema,
+    SnapshotBatchConflictSchema,
+    TryoutRuntimeBundleConflictSchema,
+]);
+/** Active publication state no longer matches the signed release base. */
+export const PublicationStaleBaseSchema = Schema.Struct({
+    activeReleaseId: Schema.NullOr(ReleaseIdSchema),
+    code: Schema.Literal("CONTENT_RELEASE_STALE_BASE"),
+    expectedBaseReleaseId: Schema.NullOr(ReleaseIdSchema),
+    kind: Schema.Literal("stale-base"),
+    operation: Schema.Literals(["stageRelease", "activate"]),
+    releaseId: ReleaseIdSchema,
+}).pipe(Schema.check(Schema.makeFilter(({ activeReleaseId, expectedBaseReleaseId, releaseId }) => activeReleaseId !== expectedBaseReleaseId &&
+    activeReleaseId !== releaseId, {
+    message: "Expected the active release to differ from the requested base and candidate.",
+})));
+/** Complete stable publication failure vocabulary returned on the wire. */
+export const PublicationFailureSchema = Schema.Union([
+    PublicationUnauthorizedSchema,
+    PublicationRejectedSchema,
+    PublicationConflictSchema,
+    PublicationStaleBaseSchema,
+]);