@fungi.computer/puffball 0.0.0-stage → 0.0.1

package/dist/internal/app-release-schema.d.ts

@@ -0,0 +1,1676 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { AppId, AppTransitionId, ArtifactRef, ImmutableArtifactBytes, IdempotencyKey, PublicSurfaceId, ReleaseId, Sha256Digest, SourceRevision, StableRoute } from "./app-release-contract.js";
+/** Cairn owns the App transition identity grammar and parser. */
+export declare const appTransitionIdCodec: import("@fungi.computer/cairn/id").IdCodec<"app-release", "transition", 1>;
+export declare const appSurfaceIdCodec: import("@fungi.computer/cairn/id").IdCodec<"app-release", "surface", 1>;
+export declare const appErasureIdCodec: import("@fungi.computer/cairn/id").IdCodec<"app-release", "erasure", 1>;
+/** Canonical Effect Schema for one Global App identifier. */
+export declare const appIdSchema: Schema.refine<AppId, Schema.String>;
+/** Canonical Effect Schema for one immutable Release identifier. */
+export declare const releaseIdSchema: Schema.refine<ReleaseId, Schema.String>;
+/** Canonical Effect Schema for one anonymous public-Surface identifier. */
+export declare const publicSurfaceIdSchema: Schema.refine<PublicSurfaceId, Schema.String>;
+/** Canonical Effect Schema for one bounded artifact reference. */
+export declare const artifactRefSchema: Schema.refine<ArtifactRef, Schema.String>;
+/** Canonical Effect Schema for one caller-provided idempotency key. */
+export declare const idempotencyKeySchema: Schema.refine<IdempotencyKey, Schema.String>;
+/** Canonical Effect Schema for one pinned lowercase Git source revision. */
+export declare const sourceRevisionSchema: Schema.refine<SourceRevision, Schema.String>;
+/** Canonical Effect Schema for one lowercase SHA-256 digest. */
+export declare const sha256DigestSchema: Schema.refine<Sha256Digest, Schema.String>;
+/** Canonical Effect Schema for one canonical local stable route. */
+export declare const stableRouteSchema: Schema.refine<StableRoute, Schema.String>;
+/** Canonical Effect Schema for a Global App record. */
+export declare const appSchema: Schema.Struct<{
+    readonly appId: Schema.refine<AppId, Schema.String>;
+}>;
+/** Canonical Effect Schema for immutable source and build provenance. */
+export declare const artifactProvenanceSchema: Schema.Struct<{
+    readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+    readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+    readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+}>;
+/** Canonical Effect Schema for immutable artifact identity and provenance. */
+export declare const releaseArtifactSchema: Schema.Struct<{
+    readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+    readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+    readonly provenance: Schema.Struct<{
+        readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+        readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+        readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+    }>;
+}>;
+/** Canonical Effect Schema for one immutable App Release. */
+export declare const releaseSchema: Schema.Struct<{
+    readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+    readonly appId: Schema.refine<AppId, Schema.String>;
+    readonly artifact: Schema.Struct<{
+        readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+        readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+        readonly provenance: Schema.Struct<{
+            readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+            readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+        }>;
+    }>;
+}>;
+/** Canonical Effect Schema for one App-owned anonymous public Surface. */
+export declare const publicSurfaceSchema: Schema.Struct<{
+    readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+    readonly appId: Schema.refine<AppId, Schema.String>;
+    readonly stableRoute: Schema.refine<StableRoute, Schema.String>;
+}>;
+/** Supported immutable artifact representation formats at the storage boundary. */
+export declare const artifactMediaTypeSchema: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json", "application/vnd.fungi.app+json"]>;
+/** Canonical persisted metadata derived only by App artifact verification. */
+export declare const verifiedAppDescriptionSchema: Schema.Struct<{
+    readonly format: Schema.Literal<"fungi-app-v1">;
+    readonly ui: Schema.NullOr<Schema.Struct<{
+        readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+        readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+        readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+        readonly version: Schema.String;
+        readonly byteLength: Schema.Number;
+    }>>;
+    readonly backend: Schema.NullOr<Schema.Struct<{
+        readonly artifact: Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+            readonly version: Schema.String;
+            readonly byteLength: Schema.Number;
+        }>;
+        readonly profile: Schema.Struct<{
+            readonly runtime: Schema.Struct<{
+                readonly kind: Schema.Literal<"durable-facet">;
+                readonly stateSchema: Schema.Number;
+            }>;
+            readonly compatibilityDate: Schema.String;
+            readonly exportName: Schema.String;
+        }>;
+    }>>;
+    readonly declaration: Schema.withDecodingDefaultType<Schema.Codec<Readonly<{
+        api?: import("../app-vocabulary.js").AppApi;
+        displayName?: string | undefined;
+        capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+        calls?: readonly Readonly<{
+            appId: string;
+            methods: readonly string[];
+        }>[] | undefined;
+        guidance?: string | undefined;
+        handlers: readonly import("../app-vocabulary.js").AppHandler[];
+        receives?: readonly "git.push"[] | undefined;
+        icon?: string;
+        roles: readonly import("../app-vocabulary.js").AppRole[];
+        storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+        commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+        gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+        backend?: Readonly<{
+            bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+            sync?: Readonly<{
+                method: string;
+            }>;
+        }> | undefined;
+    }>, Readonly<{
+        api?: import("../app-vocabulary.js").AppApi;
+        displayName?: string | undefined;
+        capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+        calls?: readonly Readonly<{
+            appId: string;
+            methods: readonly string[];
+        }>[] | undefined;
+        guidance?: string | undefined;
+        handlers: readonly import("../app-vocabulary.js").AppHandler[];
+        receives?: readonly "git.push"[] | undefined;
+        icon?: string;
+        roles: readonly import("../app-vocabulary.js").AppRole[];
+        storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+        commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+        gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+        backend?: Readonly<{
+            bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+            sync?: Readonly<{
+                method: string;
+            }>;
+        }> | undefined;
+    }>, never, never>, never>;
+}>;
+/** Canonical Effect Schema for a verified immutable artifact snapshot. */
+export declare const verifiedArtifactReadSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"verified">;
+    readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+    readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json", "application/vnd.fungi.app+json"]>;
+    readonly bytes: Schema.refine<{
+        readonly byteLength: number;
+        readonly copy: Function;
+    } & ImmutableArtifactBytes, Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly copy: Schema.instanceOf<Function, unknown>;
+    }>>;
+    readonly byteLength: Schema.Number;
+}>;
+/** Canonical Effect Schema for the complete hostile artifact-reader result. */
+export declare const artifactReadResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"verified">;
+    readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+    readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json", "application/vnd.fungi.app+json"]>;
+    readonly bytes: Schema.refine<{
+        readonly byteLength: number;
+        readonly copy: Function;
+    } & ImmutableArtifactBytes, Schema.Struct<{
+        readonly byteLength: Schema.Number;
+        readonly copy: Schema.instanceOf<Function, unknown>;
+    }>>;
+    readonly byteLength: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"unavailable">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"missing">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"digest-mismatch">;
+    readonly actualDigest: Schema.refine<Sha256Digest, Schema.String>;
+}>]>;
+/** Canonical Effect Schema for one explicit App lookup result. */
+export declare const appReadSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly app: Schema.Struct<{
+        readonly appId: Schema.refine<AppId, Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>]>;
+/** Canonical Effect Schema for one explicit App create-or-observe result. */
+export declare const appCreateSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"created">;
+    readonly app: Schema.Struct<{
+        readonly appId: Schema.refine<AppId, Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"existing">;
+    readonly app: Schema.Struct<{
+        readonly appId: Schema.refine<AppId, Schema.String>;
+    }>;
+}>]>;
+/** Canonical Effect Schema for one explicit Release lookup result. */
+export declare const releaseReadSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly release: Schema.Struct<{
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly artifact: Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly provenance: Schema.Struct<{
+                readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+                readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+            }>;
+        }>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>]>;
+/** Canonical Effect Schema for one explicit Release create-or-observe result. */
+export declare const releaseCreateSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"created">;
+    readonly release: Schema.Struct<{
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly artifact: Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly provenance: Schema.Struct<{
+                readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+                readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+            }>;
+        }>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"existing">;
+    readonly release: Schema.Struct<{
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly artifact: Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly provenance: Schema.Struct<{
+                readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+                readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+            }>;
+        }>;
+    }>;
+}>]>;
+/** Canonical Effect Schema for one explicit public-Surface lookup result. */
+export declare const publicSurfaceReadSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly surface: Schema.Struct<{
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly stableRoute: Schema.refine<StableRoute, Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>]>;
+/** Canonical Effect Schema for one public-Surface create-or-observe result. */
+export declare const publicSurfaceCreateSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"created">;
+    readonly surface: Schema.Struct<{
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly stableRoute: Schema.refine<StableRoute, Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"existing">;
+    readonly surface: Schema.Struct<{
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly stableRoute: Schema.refine<StableRoute, Schema.String>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"conflict">;
+}>]>;
+/** Canonical Effect Schema for a verified/unverified Release fact. */
+export declare const releaseVerificationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"verified">;
+    readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+    readonly mediaType: Schema.Literal<"application/vnd.fungi.app+json">;
+    readonly description: Schema.Struct<{
+        readonly format: Schema.Literal<"fungi-app-v1">;
+        readonly ui: Schema.NullOr<Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+            readonly version: Schema.String;
+            readonly byteLength: Schema.Number;
+        }>>;
+        readonly backend: Schema.NullOr<Schema.Struct<{
+            readonly artifact: Schema.Struct<{
+                readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+                readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+                readonly version: Schema.String;
+                readonly byteLength: Schema.Number;
+            }>;
+            readonly profile: Schema.Struct<{
+                readonly runtime: Schema.Struct<{
+                    readonly kind: Schema.Literal<"durable-facet">;
+                    readonly stateSchema: Schema.Number;
+                }>;
+                readonly compatibilityDate: Schema.String;
+                readonly exportName: Schema.String;
+            }>;
+        }>>;
+        readonly declaration: Schema.withDecodingDefaultType<Schema.Codec<Readonly<{
+            api?: import("../app-vocabulary.js").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("../app-vocabulary.js").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("../app-vocabulary.js").AppRole[];
+            storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+            commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, Readonly<{
+            api?: import("../app-vocabulary.js").AppApi;
+            displayName?: string | undefined;
+            capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+            calls?: readonly Readonly<{
+                appId: string;
+                methods: readonly string[];
+            }>[] | undefined;
+            guidance?: string | undefined;
+            handlers: readonly import("../app-vocabulary.js").AppHandler[];
+            receives?: readonly "git.push"[] | undefined;
+            icon?: string;
+            roles: readonly import("../app-vocabulary.js").AppRole[];
+            storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+            commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+            gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+            backend?: Readonly<{
+                bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                sync?: Readonly<{
+                    method: string;
+                }>;
+            }> | undefined;
+        }>, never, never>, never>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"unverified">;
+}>]>;
+/** Canonical Effect Schema for a live/revoked Release fact. */
+export declare const releaseRevocationSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"active">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"revoked">;
+}>]>;
+/** Canonical Effect Schema for one owner-issued transition command. */
+export declare const releaseTransitionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"promotion">;
+    readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+    readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+    readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"rollback">;
+    readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+    readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+    readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"revocation">;
+    readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+    readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+}>]>;
+/** The sole Effect Schema wrapper around Cairn's transition codec parser. */
+export declare const appTransitionIdSchema: Schema.declare<AppTransitionId, AppTransitionId>;
+/** Canonical Effect Schema for a terminal owner-issued transition receipt. */
+export declare const transitionReceiptSchema: Schema.Struct<{
+    readonly transition: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"promotion">;
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"rollback">;
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"revocation">;
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+    }>]>;
+    readonly transitionId: Schema.declare<AppTransitionId, AppTransitionId>;
+}>;
+/** Canonical Effect Schema for durable Release lifecycle facts. */
+export declare const releaseLifecycleSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly release: Schema.Struct<{
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly artifact: Schema.Struct<{
+            readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+            readonly artifactDigest: Schema.refine<Sha256Digest, Schema.String>;
+            readonly provenance: Schema.Struct<{
+                readonly sourceRevision: Schema.refine<SourceRevision, Schema.String>;
+                readonly sourceTreeDigest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly buildRecipeDigest: Schema.refine<Sha256Digest, Schema.String>;
+            }>;
+        }>;
+    }>;
+    readonly verification: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"verified">;
+        readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+        readonly mediaType: Schema.Literal<"application/vnd.fungi.app+json">;
+        readonly description: Schema.Struct<{
+            readonly format: Schema.Literal<"fungi-app-v1">;
+            readonly ui: Schema.NullOr<Schema.Struct<{
+                readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+                readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+                readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+                readonly version: Schema.String;
+                readonly byteLength: Schema.Number;
+            }>>;
+            readonly backend: Schema.NullOr<Schema.Struct<{
+                readonly artifact: Schema.Struct<{
+                    readonly artifactRef: Schema.refine<ArtifactRef, Schema.String>;
+                    readonly digest: Schema.refine<Sha256Digest, Schema.String>;
+                    readonly mediaType: Schema.Literals<readonly ["text/html; charset=utf-8", "application/vnd.fungi.app-backend+json", "application/vnd.fungi.app-assets+json"]>;
+                    readonly version: Schema.String;
+                    readonly byteLength: Schema.Number;
+                }>;
+                readonly profile: Schema.Struct<{
+                    readonly runtime: Schema.Struct<{
+                        readonly kind: Schema.Literal<"durable-facet">;
+                        readonly stateSchema: Schema.Number;
+                    }>;
+                    readonly compatibilityDate: Schema.String;
+                    readonly exportName: Schema.String;
+                }>;
+            }>>;
+            readonly declaration: Schema.withDecodingDefaultType<Schema.Codec<Readonly<{
+                api?: import("../app-vocabulary.js").AppApi;
+                displayName?: string | undefined;
+                capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                calls?: readonly Readonly<{
+                    appId: string;
+                    methods: readonly string[];
+                }>[] | undefined;
+                guidance?: string | undefined;
+                handlers: readonly import("../app-vocabulary.js").AppHandler[];
+                receives?: readonly "git.push"[] | undefined;
+                icon?: string;
+                roles: readonly import("../app-vocabulary.js").AppRole[];
+                storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+                commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+                gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+                backend?: Readonly<{
+                    bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                    sync?: Readonly<{
+                        method: string;
+                    }>;
+                }> | undefined;
+            }>, Readonly<{
+                api?: import("../app-vocabulary.js").AppApi;
+                displayName?: string | undefined;
+                capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                calls?: readonly Readonly<{
+                    appId: string;
+                    methods: readonly string[];
+                }>[] | undefined;
+                guidance?: string | undefined;
+                handlers: readonly import("../app-vocabulary.js").AppHandler[];
+                receives?: readonly "git.push"[] | undefined;
+                icon?: string;
+                roles: readonly import("../app-vocabulary.js").AppRole[];
+                storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+                commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+                gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+                backend?: Readonly<{
+                    bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                    sync?: Readonly<{
+                        method: string;
+                    }>;
+                }> | undefined;
+            }>, never, never>, never>;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"unverified">;
+    }>]>;
+    readonly revocation: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"active">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"revoked">;
+    }>]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>]>;
+/** Canonical Effect Schema for durable public-Surface selection facts. */
+export declare const publicSurfaceLifecycleSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly surface: Schema.Struct<{
+        readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+        readonly appId: Schema.refine<AppId, Schema.String>;
+        readonly stableRoute: Schema.refine<StableRoute, Schema.String>;
+    }>;
+    readonly selection: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"selected">;
+        readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+    }>]>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>]>;
+/** Canonical Effect Schema for an operation-scoped receipt lookup. */
+export declare const transitionLookupSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"absent">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"found">;
+    readonly receipt: Schema.Struct<{
+        readonly transition: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"promotion">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"rollback">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"revocation">;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>]>;
+        readonly transitionId: Schema.declare<AppTransitionId, AppTransitionId>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"conflict">;
+}>]>;
+/** Canonical Effect Schema for atomic transition persistence. */
+export declare const transitionPersistenceSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"created">;
+    readonly receipt: Schema.Struct<{
+        readonly transition: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"promotion">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"rollback">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"revocation">;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>]>;
+        readonly transitionId: Schema.declare<AppTransitionId, AppTransitionId>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"existing">;
+    readonly receipt: Schema.Struct<{
+        readonly transition: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"promotion">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"rollback">;
+            readonly publicSurfaceId: Schema.refine<PublicSurfaceId, Schema.String>;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"revocation">;
+            readonly releaseId: Schema.refine<ReleaseId, Schema.String>;
+            readonly idempotencyKey: Schema.refine<IdempotencyKey, Schema.String>;
+        }>]>;
+        readonly transitionId: Schema.declare<AppTransitionId, AppTransitionId>;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"conflict">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"identity-collision">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"lifecycle-conflict">;
+}>]>;
+/** Canonical Effect Schema for a closed App Release store infrastructure failure. */
+export declare const appReleaseStoreFailureSchema: Schema.Struct<{
+    readonly kind: Schema.Literal<"unavailable">;
+}>;
+/** Canonical Effect Schema for a closed App-read store result envelope. */
+export declare const appReadStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "found";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    } | {
+        readonly kind: "absent";
+    }, {
+        readonly kind: "found";
+        readonly app: {
+            readonly appId: string;
+        };
+    } | {
+        readonly kind: "absent";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a closed App-create store result envelope. */
+export declare const appCreateStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "created";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    }, {
+        readonly kind: "created";
+        readonly app: {
+            readonly appId: string;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly app: {
+            readonly appId: string;
+        };
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a closed Release-read store result envelope. */
+export declare const releaseReadStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    } | {
+        readonly kind: "absent";
+    }, {
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: string;
+            readonly appId: string;
+            readonly artifact: {
+                readonly artifactRef: string;
+                readonly artifactDigest: string;
+                readonly provenance: {
+                    readonly sourceRevision: string;
+                    readonly sourceTreeDigest: string;
+                    readonly buildRecipeDigest: string;
+                };
+            };
+        };
+    } | {
+        readonly kind: "absent";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a closed Release-create store result envelope. */
+export declare const releaseCreateStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "created";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    } | {
+        readonly kind: "existing";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    }, {
+        readonly kind: "created";
+        readonly release: {
+            readonly releaseId: string;
+            readonly appId: string;
+            readonly artifact: {
+                readonly artifactRef: string;
+                readonly artifactDigest: string;
+                readonly provenance: {
+                    readonly sourceRevision: string;
+                    readonly sourceTreeDigest: string;
+                    readonly buildRecipeDigest: string;
+                };
+            };
+        };
+    } | {
+        readonly kind: "existing";
+        readonly release: {
+            readonly releaseId: string;
+            readonly appId: string;
+            readonly artifact: {
+                readonly artifactRef: string;
+                readonly artifactDigest: string;
+                readonly provenance: {
+                    readonly sourceRevision: string;
+                    readonly sourceTreeDigest: string;
+                    readonly buildRecipeDigest: string;
+                };
+            };
+        };
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a closed public-Surface-read store result envelope. */
+export declare const publicSurfaceReadStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "found";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "absent";
+    }, {
+        readonly kind: "found";
+        readonly surface: {
+            readonly publicSurfaceId: string;
+            readonly appId: string;
+            readonly stableRoute: string;
+        };
+    } | {
+        readonly kind: "absent";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a closed public-Surface-create store result envelope. */
+export declare const publicSurfaceCreateStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "created";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "conflict";
+    }, {
+        readonly kind: "created";
+        readonly surface: {
+            readonly publicSurfaceId: string;
+            readonly appId: string;
+            readonly stableRoute: string;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly surface: {
+            readonly publicSurfaceId: string;
+            readonly appId: string;
+            readonly stableRoute: string;
+        };
+    } | {
+        readonly kind: "conflict";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a Release lifecycle store result envelope. */
+export declare const releaseLifecycleStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+        readonly verification: {
+            readonly kind: "verified";
+            readonly digest: Sha256Digest;
+            readonly mediaType: "application/vnd.fungi.app+json";
+            readonly description: {
+                readonly format: "fungi-app-v1";
+                readonly ui: {
+                    readonly artifactRef: ArtifactRef;
+                    readonly digest: Sha256Digest;
+                    readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                    readonly version: string;
+                    readonly byteLength: number;
+                } | null;
+                readonly backend: {
+                    readonly artifact: {
+                        readonly artifactRef: ArtifactRef;
+                        readonly digest: Sha256Digest;
+                        readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                        readonly version: string;
+                        readonly byteLength: number;
+                    };
+                    readonly profile: {
+                        readonly runtime: {
+                            readonly kind: "durable-facet";
+                            readonly stateSchema: number;
+                        };
+                        readonly compatibilityDate: string;
+                        readonly exportName: string;
+                    };
+                } | null;
+                readonly declaration: Readonly<{
+                    api?: import("../app-vocabulary.js").AppApi;
+                    displayName?: string | undefined;
+                    capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                    calls?: readonly Readonly<{
+                        appId: string;
+                        methods: readonly string[];
+                    }>[] | undefined;
+                    guidance?: string | undefined;
+                    handlers: readonly import("../app-vocabulary.js").AppHandler[];
+                    receives?: readonly "git.push"[] | undefined;
+                    icon?: string;
+                    roles: readonly import("../app-vocabulary.js").AppRole[];
+                    storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+                    commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+                    gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+                    backend?: Readonly<{
+                        bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                        sync?: Readonly<{
+                            method: string;
+                        }>;
+                    }> | undefined;
+                }>;
+            };
+        } | {
+            readonly kind: "unverified";
+        };
+        readonly revocation: {
+            readonly kind: "active";
+        } | {
+            readonly kind: "revoked";
+        };
+    } | {
+        readonly kind: "absent";
+    }, {
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: string;
+            readonly appId: string;
+            readonly artifact: {
+                readonly artifactRef: string;
+                readonly artifactDigest: string;
+                readonly provenance: {
+                    readonly sourceRevision: string;
+                    readonly sourceTreeDigest: string;
+                    readonly buildRecipeDigest: string;
+                };
+            };
+        };
+        readonly verification: {
+            readonly kind: "verified";
+            readonly digest: string;
+            readonly mediaType: "application/vnd.fungi.app+json";
+            readonly description: {
+                readonly format: "fungi-app-v1";
+                readonly backend: {
+                    readonly artifact: {
+                        readonly artifactRef: string;
+                        readonly digest: string;
+                        readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                        readonly version: string;
+                        readonly byteLength: number;
+                    };
+                    readonly profile: {
+                        readonly runtime: {
+                            readonly kind: "durable-facet";
+                            readonly stateSchema: number;
+                        };
+                        readonly compatibilityDate: string;
+                        readonly exportName: string;
+                    };
+                } | null;
+                readonly ui: {
+                    readonly artifactRef: string;
+                    readonly digest: string;
+                    readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                    readonly version: string;
+                    readonly byteLength: number;
+                } | null;
+                readonly declaration?: Readonly<{
+                    api?: import("../app-vocabulary.js").AppApi;
+                    displayName?: string | undefined;
+                    capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                    calls?: readonly Readonly<{
+                        appId: string;
+                        methods: readonly string[];
+                    }>[] | undefined;
+                    guidance?: string | undefined;
+                    handlers: readonly import("../app-vocabulary.js").AppHandler[];
+                    receives?: readonly "git.push"[] | undefined;
+                    icon?: string;
+                    roles: readonly import("../app-vocabulary.js").AppRole[];
+                    storage?: readonly import("../app-vocabulary.js").AppStorageKey[] | undefined;
+                    commands?: readonly import("../app-vocabulary.js").AppDeclaredCommand[] | undefined;
+                    gills?: readonly import("@fungi.computer/gills").AppDeclaredGill[] | undefined;
+                    backend?: Readonly<{
+                        bindings: readonly import("../app-backend-binding-vocabulary.js").AppBackendBinding[];
+                        sync?: Readonly<{
+                            method: string;
+                        }>;
+                    }> | undefined;
+                }> | undefined;
+            };
+        } | {
+            readonly kind: "unverified";
+        };
+        readonly revocation: {
+            readonly kind: "active";
+        } | {
+            readonly kind: "revoked";
+        };
+    } | {
+        readonly kind: "absent";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a Release verification record result envelope. */
+export declare const releaseVerificationRecordStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "recorded";
+    }, {
+        readonly kind: "recorded";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for a transition lookup store result envelope. */
+export declare const transitionLookupStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "absent";
+    } | {
+        readonly kind: "found";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    }, {
+        readonly kind: "absent";
+    } | {
+        readonly kind: "found";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Canonical Effect Schema for transition persistence store result envelope. */
+export declare const transitionPersistenceStoreResultSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly value: Schema.Codec<{
+        readonly kind: "created";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    } | {
+        readonly kind: "identity-collision";
+    } | {
+        readonly kind: "lifecycle-conflict";
+    }, {
+        readonly kind: "created";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: string;
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: string;
+                readonly idempotencyKey: string;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    } | {
+        readonly kind: "identity-collision";
+    } | {
+        readonly kind: "lifecycle-conflict";
+    }, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly failure: Schema.Struct<{
+        readonly kind: Schema.Literal<"unavailable">;
+    }>;
+}>]>;
+/** Decode one Global App identifier through its canonical closed Effect Schema. */
+export declare const decodeAppId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<AppId, Schema.SchemaError>;
+/** Decode one immutable Release identifier through its canonical closed Effect Schema. */
+export declare const decodeReleaseId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<ReleaseId, Schema.SchemaError>;
+/** Decode one public-Surface identifier through its canonical closed Effect Schema. */
+export declare const decodePublicSurfaceId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<PublicSurfaceId, Schema.SchemaError>;
+/** Decode one bounded artifact reference through its canonical closed Effect Schema. */
+export declare const decodeArtifactRef: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<ArtifactRef, Schema.SchemaError>;
+/** Decode one idempotency key through its canonical closed Effect Schema. */
+export declare const decodeIdempotencyKey: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<IdempotencyKey, Schema.SchemaError>;
+/** Decode one pinned source revision through its canonical closed Effect Schema. */
+export declare const decodeSourceRevision: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<SourceRevision, Schema.SchemaError>;
+/** Decode one SHA-256 digest through its canonical closed Effect Schema. */
+export declare const decodeSha256Digest: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<Sha256Digest, Schema.SchemaError>;
+/** Decode one local stable route through its canonical closed Effect Schema. */
+export declare const decodeStableRoute: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<StableRoute, Schema.SchemaError>;
+/** Decode a Cairn-issued App transition identity through its sole wrapper. */
+export declare const decodeAppTransitionId: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<AppTransitionId, Schema.SchemaError>;
+/** Decode a hostile artifact-reader result through its canonical closed schema. */
+export declare const decodeArtifactReadResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+    readonly kind: "verified";
+    readonly digest: Sha256Digest;
+    readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json" | "application/vnd.fungi.app+json";
+    readonly bytes: {
+        readonly byteLength: number;
+        readonly copy: Function;
+    } & ImmutableArtifactBytes;
+    readonly byteLength: number;
+} | {
+    readonly kind: "unavailable";
+} | {
+    readonly kind: "missing";
+} | {
+    readonly kind: "digest-mismatch";
+    readonly actualDigest: Sha256Digest;
+}, Schema.SchemaError, never>;
+/** Decode a hostile App record through its canonical closed schema. */
+export declare const decodeApp: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly appId: AppId;
+}, Schema.SchemaError>;
+/** Decode a hostile Release record through its canonical closed schema. */
+export declare const decodeRelease: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly releaseId: ReleaseId;
+    readonly appId: AppId;
+    readonly artifact: {
+        readonly artifactRef: ArtifactRef;
+        readonly artifactDigest: Sha256Digest;
+        readonly provenance: {
+            readonly sourceRevision: SourceRevision;
+            readonly sourceTreeDigest: Sha256Digest;
+            readonly buildRecipeDigest: Sha256Digest;
+        };
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile public Surface through its canonical closed schema. */
+export declare const decodePublicSurface: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly publicSurfaceId: PublicSurfaceId;
+    readonly appId: AppId;
+    readonly stableRoute: StableRoute;
+}, Schema.SchemaError>;
+export declare const decodePublicSurfaceDefinition: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly publisher: {
+        readonly kind: "platform" | "customer";
+        readonly teamId: string;
+        readonly userId: string;
+        readonly requestKey: string;
+    };
+    readonly publicSurfaceId: PublicSurfaceId;
+    readonly appId: AppId;
+    readonly stableRoute: StableRoute;
+}, Schema.SchemaError>;
+/** Decode a hostile App-read store result through its canonical closed schema. */
+export declare const decodeAppReadStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "found";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    } | {
+        readonly kind: "absent";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile App-create store result through its canonical closed schema. */
+export declare const decodeAppCreateStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "created";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly app: {
+            readonly appId: AppId;
+        };
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile Release-read store result through its canonical closed schema. */
+export declare const decodeReleaseReadStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    } | {
+        readonly kind: "absent";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile Release-create store result through its canonical closed schema. */
+export declare const decodeReleaseCreateStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "created";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    } | {
+        readonly kind: "existing";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile public-Surface-read store result through its canonical closed schema. */
+export declare const decodePublicSurfaceReadStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "found";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "absent";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile public-Surface-create store result through its canonical closed schema. */
+export declare const decodePublicSurfaceCreateStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "created";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly surface: {
+            readonly publicSurfaceId: PublicSurfaceId;
+            readonly appId: AppId;
+            readonly stableRoute: StableRoute;
+        };
+    } | {
+        readonly kind: "conflict";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode an owner-issued transition through its canonical closed schema. */
+export declare const decodeReleaseTransition: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "promotion";
+    readonly publicSurfaceId: PublicSurfaceId;
+    readonly releaseId: ReleaseId;
+    readonly idempotencyKey: IdempotencyKey;
+} | {
+    readonly kind: "rollback";
+    readonly publicSurfaceId: PublicSurfaceId;
+    readonly releaseId: ReleaseId;
+    readonly idempotencyKey: IdempotencyKey;
+} | {
+    readonly kind: "revocation";
+    readonly releaseId: ReleaseId;
+    readonly idempotencyKey: IdempotencyKey;
+}, Schema.SchemaError>;
+/** Decode a hostile Release lifecycle store result. */
+export declare const decodeReleaseLifecycleStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "found";
+        readonly release: {
+            readonly releaseId: ReleaseId;
+            readonly appId: AppId;
+            readonly artifact: {
+                readonly artifactRef: ArtifactRef;
+                readonly artifactDigest: Sha256Digest;
+                readonly provenance: {
+                    readonly sourceRevision: SourceRevision;
+                    readonly sourceTreeDigest: Sha256Digest;
+                    readonly buildRecipeDigest: Sha256Digest;
+                };
+            };
+        };
+        readonly verification: {
+            readonly kind: "verified";
+            readonly digest: Sha256Digest;
+            readonly mediaType: "application/vnd.fungi.app+json";
+            readonly description: {
+                readonly format: "fungi-app-v1";
+                readonly ui: {
+                    readonly artifactRef: ArtifactRef;
+                    readonly digest: Sha256Digest;
+                    readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                    readonly version: string;
+                    readonly byteLength: number;
+                } | null;
+                readonly backend: {
+                    readonly artifact: {
+                        readonly artifactRef: ArtifactRef;
+                        readonly digest: Sha256Digest;
+                        readonly mediaType: "text/html; charset=utf-8" | "application/vnd.fungi.app-backend+json" | "application/vnd.fungi.app-assets+json";
+                        readonly version: string;
+                        readonly byteLength: number;
+                    };
+                    readonly profile: {
+                        readonly runtime: {
+                            readonly kind: "durable-facet";
+                            readonly stateSchema: number;
+                        };
+                        readonly compatibilityDate: string;
+                        readonly exportName: string;
+                    };
+                } | null;
+                readonly declaration: Readonly<{
+                    api?: Readonly<{
+                        methods: Readonly<Record<string, Readonly<{
+                            description: string;
+                            input: object;
+                            output: object;
+                            effect: "read" | "write" | "external";
+                            requires: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                            pending?: true | undefined;
+                            hidden?: true | undefined;
+                            anonymous?: true | undefined;
+                        }>>>;
+                        toolFamily?: Readonly<{
+                            name: string;
+                            list: string;
+                            call: string;
+                        }>;
+                        events?: Readonly<Record<string, Readonly<{
+                            description: string;
+                            payload: object;
+                        }>>>;
+                    }>;
+                    displayName?: string | undefined;
+                    capabilities: readonly import("../app-vocabulary.js").AppCapabilityId[];
+                    calls?: readonly Readonly<{
+                        appId: string;
+                        methods: readonly string[];
+                    }>[] | undefined;
+                    guidance?: string | undefined;
+                    handlers: readonly import("../app-vocabulary.js").AppHandler[];
+                    receives?: readonly "git.push"[] | undefined;
+                    icon?: string;
+                    roles: readonly import("../app-vocabulary.js").AppRole[];
+                    storage?: readonly Readonly<{
+                        key: string;
+                        scopes: readonly import("../app-vocabulary.js").AppStorageScope[];
+                        maxBytes: number;
+                    }>[] | undefined;
+                    commands?: readonly Readonly<{
+                        id: string;
+                        title: string;
+                        category: string;
+                        description?: string | undefined;
+                        sigil?: string | undefined;
+                        projections?: Readonly<{
+                            bindings?: (Readonly<{
+                                order?: number | undefined;
+                            }> & Readonly<{
+                                values: readonly string[];
+                            }>) | undefined;
+                            agent?: (Readonly<{
+                                order?: number | undefined;
+                            }> & Readonly<{
+                                keybind?: string | undefined;
+                            }>) | undefined;
+                            help?: Readonly<{
+                                order?: number | undefined;
+                            }> | undefined;
+                            menu?: Readonly<{
+                                order?: number | undefined;
+                            }> | undefined;
+                            palette?: Readonly<{
+                                order?: number | undefined;
+                            }> | undefined;
+                            slash?: (Readonly<{
+                                order?: number | undefined;
+                            }> & Readonly<{
+                                aliases: readonly string[];
+                            }>) | undefined;
+                        }> | undefined;
+                    }>[] | undefined;
+                    gills?: readonly Readonly<{
+                        id: string;
+                        source: string;
+                        title: string;
+                        params?: readonly Readonly<{
+                            key: string;
+                            label: string;
+                            kind: "computer" | "repository" | "branch";
+                            required: boolean;
+                            options?: string | undefined;
+                        }>[] | undefined;
+                        watch?: import("@fungi.computer/gills").AppGillWatch | undefined;
+                        desktop?: Readonly<{
+                            sizes: readonly import("@fungi.computer/gills").AppGillDesktopSize[];
+                        }> | undefined;
+                    }>[] | undefined;
+                    backend?: Readonly<{
+                        bindings: readonly Readonly<{
+                            name: import("../app-backend-binding-vocabulary.js").AppBackendBindingName;
+                            operations: readonly string[];
+                        }>[];
+                        sync?: Readonly<{
+                            method: string;
+                        }>;
+                    }> | undefined;
+                }>;
+            };
+        } | {
+            readonly kind: "unverified";
+        };
+        readonly revocation: {
+            readonly kind: "active";
+        } | {
+            readonly kind: "revoked";
+        };
+    } | {
+        readonly kind: "absent";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile verification-record store result. */
+export declare const decodeReleaseVerificationRecordStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "recorded";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile transition lookup store result. */
+export declare const decodeTransitionLookupStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "absent";
+    } | {
+        readonly kind: "found";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;
+/** Decode a hostile transition-persistence store result. */
+export declare const decodeTransitionPersistenceStoreResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Result").Result<{
+    readonly kind: "success";
+    readonly value: {
+        readonly kind: "created";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "existing";
+        readonly receipt: {
+            readonly transition: {
+                readonly kind: "promotion";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "rollback";
+                readonly publicSurfaceId: PublicSurfaceId;
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            } | {
+                readonly kind: "revocation";
+                readonly releaseId: ReleaseId;
+                readonly idempotencyKey: IdempotencyKey;
+            };
+            readonly transitionId: AppTransitionId;
+        };
+    } | {
+        readonly kind: "conflict";
+    } | {
+        readonly kind: "identity-collision";
+    } | {
+        readonly kind: "lifecycle-conflict";
+    };
+} | {
+    readonly kind: "failure";
+    readonly failure: {
+        readonly kind: "unavailable";
+    };
+}, Schema.SchemaError>;