@knpkv/control-center 0.1.0

package/dist/server/server/governance/internal/execution-store/recovery-claim.d.ts

@@ -0,0 +1,465 @@
+import * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Build atomic, expiring recovery claims over one transaction-owned aggregate snapshot. */
+export declare const makeGovernedActionExecutionRecoveryClaim: Effect.Effect<{
+    claim: (record: Schema.Struct.ReadonlySide<{
+        readonly envelope: Schema.Struct<{
+            readonly envelopeDigest: Schema.brand<Schema.String, string>;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly pluginId: Schema.brand<Schema.String, string>;
+            readonly pluginContractVersion: Schema.Struct<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }>;
+            readonly pluginAdapterVersion: Schema.Struct<{
+                readonly major: Schema.Int;
+                readonly minor: Schema.Int;
+                readonly patch: Schema.Int;
+            }>;
+            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+            readonly capability: Schema.Struct<{
+                readonly capabilityId: Schema.Literal<"action.execute">;
+                readonly version: Schema.Int;
+            }>;
+            readonly targetEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+            readonly proposal: Schema.Struct<{
+                readonly proposalKey: Schema.brand<Schema.String, string>;
+                readonly capabilityVersion: Schema.Int;
+                readonly request: Schema.Struct<{
+                    readonly actionKind: Schema.brand<Schema.String, string>;
+                    readonly target: Schema.Struct<{
+                        entityType: Schema.brand<Schema.String, string>;
+                        vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                    }>;
+                    readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+                    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+                readonly summary: Schema.String;
+                readonly impact: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high", "critical"]>;
+                    readonly summary: Schema.String;
+                }>;
+                readonly proposedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly evidence: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly currentUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly evaluatedAt: Schema.DateTimeUtcFromString;
+                readonly source: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+            }>>;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly policy: Schema.Struct<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly origin: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly initiatingSessionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">>;
+                }>;
+            }>;
+            readonly proposalExpiresAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }>;
+        readonly head: Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly lineage: Schema.TaggedUnion<{
+                readonly none: Schema.TaggedStruct<"none", {}>;
+                readonly accepted: Schema.TaggedStruct<"accepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                    readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                }>;
+                readonly manual: Schema.TaggedStruct<"manual", {
+                    readonly providerOperationId: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+                readonly terminal: Schema.TaggedStruct<"terminal", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+            }>;
+        }>;
+        readonly headTransition: Schema.Struct<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
+            }>;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }>;
+        readonly history: Schema.$Array<Schema.Struct<{
+            readonly commandDigest: Schema.brand<Schema.String, "GovernedActionCommandDigest">;
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly transitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+            readonly previousTransitionId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">>;
+            readonly commandId: Schema.brand<Schema.String, string>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly sequence: Schema.Int;
+            readonly fromState: Schema.NullOr<Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>>;
+            readonly toState: Schema.Literals<readonly ["proposed", "authorized", "denied", "expired", "cancelled", "started", "cancel-requested", "cancel-requested-unknown", "succeeded", "failed", "unknown"]>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly command: Schema.TaggedUnion<{
+                readonly propose: Schema.TaggedStruct<"propose", {}>;
+                readonly authorize: Schema.TaggedStruct<"authorize", {
+                    readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+                }>;
+                readonly deny: Schema.TaggedStruct<"deny", {
+                    readonly reason: Schema.Literals<readonly ["revision-changed", "evidence-stale", "evidence-invalid", "policy-denied", "session-invalid", "capability-changed", "plugin-unavailable", "preflight-blocked"]>;
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly expire: Schema.TaggedStruct<"expire", {
+                    readonly reason: Schema.Literals<readonly ["proposal-expired", "authorization-expired"]>;
+                }>;
+                readonly cancel: Schema.TaggedStruct<"cancel", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly start: Schema.TaggedStruct<"start", {
+                    readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+                }>;
+                readonly requestCancellation: Schema.TaggedStruct<"requestCancellation", {
+                    readonly safeSummary: Schema.String;
+                }>;
+                readonly recordAccepted: Schema.TaggedStruct<"recordAccepted", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literal<"accepted">;
+                        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                }>;
+                readonly recordSucceeded: Schema.TaggedStruct<"recordSucceeded", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordFailed: Schema.TaggedStruct<"recordFailed", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordUnknown: Schema.TaggedStruct<"recordUnknown", {
+                    readonly outcome: Schema.TaggedUnion<{
+                        readonly reconcilable: Schema.TaggedStruct<"reconcilable", {
+                            readonly reconciliationKey: Schema.brand<Schema.String, string>;
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                        }>;
+                        readonly manual: Schema.TaggedStruct<"manual", {
+                            readonly observedAt: Schema.DateTimeUtcFromString;
+                            readonly safeSummary: Schema.String;
+                            readonly reason: Schema.Literals<readonly ["dispatch-deadline-exceeded", "interrupted-after-intent", "provider-defect-after-intent", "malformed-provider-result", "receipt-persistence-failed", "missing-reconciliation-locator"]>;
+                        }>;
+                    }>;
+                }>;
+                readonly recordCancelled: Schema.TaggedStruct<"recordCancelled", {
+                    readonly receipt: Schema.Struct<{
+                        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+                        readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        readonly safeSummary: Schema.String;
+                        readonly observedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly direct: Schema.TaggedStruct<"direct", {}>;
+                        readonly providerOperation: Schema.TaggedStruct<"providerOperation", {
+                            readonly providerOperationId: Schema.brand<Schema.String, string>;
+                        }>;
+                        readonly reconciliation: Schema.TaggedStruct<"reconciliation", {
+                            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                        }>;
+                    }>;
+                }>;
+                readonly reconciliationPending: Schema.TaggedStruct<"reconciliationPending", {
+                    readonly checkedAt: Schema.DateTimeUtcFromString;
+                    readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+                }>;
+            }>;
+            readonly cause: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly actor: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly actor: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.brand<Schema.String, string>;
+                }>;
+            }>;
+            readonly occurredAt: Schema.DateTimeUtcFromString;
+            readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+            readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+        }>>;
+        readonly authorization: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly pluginConnectionRevision: Schema.brand<Schema.Int, "GovernedActionPluginConnectionRevision">;
+            readonly pluginConnectionAuthorityDigest: Schema.brand<Schema.String, string>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly policyDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly capabilityVersion: Schema.Int;
+            readonly actor: Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+            readonly sessionPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly sessionExpiresAt: Schema.DateTimeUtcFromString;
+            readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            readonly authorizedAt: Schema.DateTimeUtcFromString;
+            readonly expiresAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly policyEvaluation: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly policy: Schema.Struct<{
+                readonly policyId: Schema.brand<Schema.String, string>;
+                readonly policyVersion: Schema.Int;
+                readonly policyDigest: Schema.brand<Schema.String, string>;
+                readonly requiredPermission: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+            }>;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+            readonly evidenceSetDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly decision: Schema.Literals<readonly ["allowed", "denied"]>;
+            readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        }>>;
+        readonly attempt: Schema.NullOr<Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<1>;
+            readonly attemptId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAttemptId">;
+            readonly authorizationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionAuthorizationId">;
+            readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly idempotencyKey: Schema.brand<Schema.String, "GovernedActionIdempotencyKey">;
+            readonly attemptNumber: Schema.Literal<1>;
+            readonly actionEnvelopeDigest: Schema.brand<Schema.String, string>;
+            readonly expectedRevision: Schema.brand<Schema.String, "Revision">;
+            readonly policyEvaluationDigest: Schema.brand<Schema.String, string>;
+            readonly preflight: Schema.TaggedStruct<"ready", {
+                readonly checkedRevision: Schema.brand<Schema.String, "Revision">;
+                readonly checkedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly startedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type">, observedAt: DateTime.Utc) => Effect.Effect<{
+        _tag: "reconcile";
+        recoveryToken: import("effect/Redacted").Redacted<string & import("effect/Brand").Brand<"GovernedActionRecoveryToken">>;
+        runtimeAuthorityToken: string & import("effect/Brand").Brand<"PluginRuntimeAuthorityToken">;
+        reconciliationDeadline: DateTime.Utc;
+        scope: {
+            workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+            pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+        };
+        request: Schema.Struct.ReadonlySide<{
+            readonly reconciliationKey: Schema.NullOr<Schema.brand<Schema.String, string>>;
+            readonly idempotencyKey: Schema.brand<Schema.String, string>;
+            readonly payloadDigest: Schema.brand<Schema.String, "PluginActionPayloadDigest">;
+        }, "Type">;
+    } | null, GovernedActionExecutionStoreError, never>;
+}, never, Crypto.Crypto | Database>;
+//# sourceMappingURL=recovery-claim.d.ts.map

package/dist/server/server/governance/internal/execution-store/recovery-claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery-claim.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/recovery-claim.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAI3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAuCtF,4FAA4F;AAC5F,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAiFnD,CAAA"}

package/dist/server/server/governance/internal/execution-store/tokens.d.ts

@@ -0,0 +1,52 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+/** One-use capability that binds final preflight to an authorized action head. */
+export declare const GovernedActionPreparationToken: Schema.RedactedFromValue<Schema.brand<Schema.String, "GovernedActionPreparationToken">>;
+/** Decoded dispatch-preparation capability. */
+export type GovernedActionPreparationToken = typeof GovernedActionPreparationToken.Type;
+/** One-use capability that authorizes recording the result of one provider dispatch. */
+export declare const GovernedActionPermitToken: Schema.RedactedFromValue<Schema.brand<Schema.String, "GovernedActionPermitToken">>;
+/** Decoded provider-dispatch capability. */
+export type GovernedActionPermitToken = typeof GovernedActionPermitToken.Type;
+/** One-use capability that authorizes one non-replaying provider reconciliation. */
+export declare const GovernedActionRecoveryToken: Schema.RedactedFromValue<Schema.brand<Schema.String, "GovernedActionRecoveryToken">>;
+/** Decoded provider-recovery capability. */
+export type GovernedActionRecoveryToken = typeof GovernedActionRecoveryToken.Type;
+/** Fixed-size preparation digest persisted instead of the live capability. */
+export declare const GovernedActionPreparationTokenDigest: Schema.brand<Schema.String, "GovernedActionPreparationTokenDigest">;
+/** Decoded at-rest preparation-token digest. */
+export type GovernedActionPreparationTokenDigest = typeof GovernedActionPreparationTokenDigest.Type;
+/** Fixed-size permit digest persisted instead of the live capability. */
+export declare const GovernedActionPermitTokenDigest: Schema.brand<Schema.String, "GovernedActionPermitTokenDigest">;
+/** Decoded at-rest permit-token digest. */
+export type GovernedActionPermitTokenDigest = typeof GovernedActionPermitTokenDigest.Type;
+/** Fixed-size recovery digest persisted instead of the live capability. */
+export declare const GovernedActionRecoveryTokenDigest: Schema.brand<Schema.String, "GovernedActionRecoveryTokenDigest">;
+/** Decoded at-rest recovery-token digest. */
+export type GovernedActionRecoveryTokenDigest = typeof GovernedActionRecoveryTokenDigest.Type;
+declare const GovernedActionExecutionTokenError_base: Schema.Class<GovernedActionExecutionTokenError, Schema.TaggedStruct<"GovernedActionExecutionTokenError", {
+    readonly operation: Schema.Literals<readonly ["digest", "issue"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Closed cryptographic failure while issuing or hashing an execution capability. */
+export declare class GovernedActionExecutionTokenError extends GovernedActionExecutionTokenError_base {
+}
+interface IssuedToken<Token, Digest> {
+    readonly digest: Digest;
+    readonly token: Token;
+}
+/** Issue a preparation capability and its safe at-rest digest. */
+export declare const issueGovernedActionPreparationToken: () => Effect.Effect<IssuedToken<Redacted.Redacted<string & import("effect/Brand").Brand<"GovernedActionPreparationToken">>, string & import("effect/Brand").Brand<"GovernedActionPreparationTokenDigest">>, GovernedActionExecutionTokenError, Crypto.Crypto>;
+/** Issue a dispatch permit and its safe at-rest digest. */
+export declare const issueGovernedActionPermitToken: () => Effect.Effect<IssuedToken<Redacted.Redacted<string & import("effect/Brand").Brand<"GovernedActionPermitToken">>, string & import("effect/Brand").Brand<"GovernedActionPermitTokenDigest">>, GovernedActionExecutionTokenError, Crypto.Crypto>;
+/** Issue a recovery capability and its safe at-rest digest. */
+export declare const issueGovernedActionRecoveryToken: () => Effect.Effect<IssuedToken<Redacted.Redacted<string & import("effect/Brand").Brand<"GovernedActionRecoveryToken">>, string & import("effect/Brand").Brand<"GovernedActionRecoveryTokenDigest">>, GovernedActionExecutionTokenError, Crypto.Crypto>;
+/** Hash a preparation capability for exact database lookup. */
+export declare const digestGovernedActionPreparationToken: (token: GovernedActionPreparationToken) => Effect.Effect<GovernedActionPreparationTokenDigest, GovernedActionExecutionTokenError, Crypto.Crypto>;
+/** Hash a dispatch permit for exact database lookup. */
+export declare const digestGovernedActionPermitToken: (token: GovernedActionPermitToken) => Effect.Effect<GovernedActionPermitTokenDigest, GovernedActionExecutionTokenError, Crypto.Crypto>;
+/** Hash a recovery capability for exact database lookup. */
+export declare const digestGovernedActionRecoveryToken: (token: GovernedActionRecoveryToken) => Effect.Effect<GovernedActionRecoveryTokenDigest, GovernedActionExecutionTokenError, Crypto.Crypto>;
+export {};
+//# sourceMappingURL=tokens.d.ts.map

package/dist/server/server/governance/internal/execution-store/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAoBvC,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,yFAG1C,CAAA;AAED,+CAA+C;AAC/C,MAAM,MAAM,8BAA8B,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AAEvF,wFAAwF;AACxF,eAAO,MAAM,yBAAyB,oFAGrC,CAAA;AAED,4CAA4C;AAC5C,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,oFAAoF;AACpF,eAAO,MAAM,2BAA2B,sFAGvC,CAAA;AAED,4CAA4C;AAC5C,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAA;AAEjF,8EAA8E;AAC9E,eAAO,MAAM,oCAAoC,qEAAwD,CAAA;AAEzG,gDAAgD;AAChD,MAAM,MAAM,oCAAoC,GAAG,OAAO,oCAAoC,CAAC,IAAI,CAAA;AAEnG,yEAAyE;AACzE,eAAO,MAAM,+BAA+B,gEAAmD,CAAA;AAE/F,2CAA2C;AAC3C,MAAM,MAAM,+BAA+B,GAAG,OAAO,+BAA+B,CAAC,IAAI,CAAA;AAEzF,2EAA2E;AAC3E,eAAO,MAAM,iCAAiC,kEAAqD,CAAA;AAEnG,6CAA6C;AAC7C,MAAM,MAAM,iCAAiC,GAAG,OAAO,iCAAiC,CAAC,IAAI,CAAA;;;;AAE7F,qFAAqF;AACrF,qBAAa,iCAAkC,SAAQ,sCAGtD;CAAG;AAEJ,UAAU,WAAW,CAAC,KAAK,EAAE,MAAM;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CACtB;AAwCD,kEAAkE;AAClE,eAAO,MAAM,mCAAmC,+PAc9C,CAAA;AAEF,2DAA2D;AAC3D,eAAO,MAAM,8BAA8B,qPAczC,CAAA;AAEF,+DAA+D;AAC/D,eAAO,MAAM,gCAAgC,yPAc3C,CAAA;AAEF,+DAA+D;AAC/D,eAAO,MAAM,oCAAoC,GAC/C,OAAO,8BAA8B,KACpC,MAAM,CAAC,MAAM,CAAC,oCAAoC,EAAE,iCAAiC,EAAE,MAAM,CAAC,MAAM,CAIpG,CAAA;AAEH,wDAAwD;AACxD,eAAO,MAAM,+BAA+B,GAC1C,OAAO,yBAAyB,KAC/B,MAAM,CAAC,MAAM,CAAC,+BAA+B,EAAE,iCAAiC,EAAE,MAAM,CAAC,MAAM,CACK,CAAA;AAEvG,4DAA4D;AAC5D,eAAO,MAAM,iCAAiC,GAC5C,OAAO,2BAA2B,KACjC,MAAM,CAAC,MAAM,CAAC,iCAAiC,EAAE,iCAAiC,EAAE,MAAM,CAAC,MAAM,CACO,CAAA"}

package/dist/server/server/http/StaticApplication.d.ts

@@ -0,0 +1,8 @@
+import * as Layer from "effect/Layer";
+import * as HttpRouter from "effect/unstable/http/HttpRouter";
+import { StaticAssetStore } from "./security/StaticAssetStore.js";
+/** Register immutable GET assets; Effect's router serves matching HEAD requests without a body. */
+export declare const staticApplicationLayer: Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", StaticAssetStore>>;
+/** Supply the immutable asset service to the static browser route. */
+export declare const staticApplicationWithAssetsLayer: <Error, Requirements>(assets: Layer.Layer<StaticAssetStore, Error, Requirements>) => Layer.Layer<never, Error, HttpRouter.HttpRouter | HttpRouter.Request<"Requires", StaticAssetStore> | Requirements>;
+//# sourceMappingURL=StaticApplication.d.ts.map

package/dist/server/server/http/StaticApplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticApplication.d.ts","sourceRoot":"","sources":["../../../../src/server/http/StaticApplication.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAA;AAI7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AA6BjE,mGAAmG;AACnG,eAAO,MAAM,sBAAsB,qGAAwE,CAAA;AAE3G,sEAAsE;AACtE,eAAO,MAAM,gCAAgC,GAAI,KAAK,EAAE,YAAY,EAClE,QAAQ,KAAK,CAAC,KAAK,CAAC,gBAAgB,EAAE,KAAK,EAAE,YAAY,CAAC,uHACL,CAAA"}

package/dist/server/server/http/index.d.ts

@@ -0,0 +1,4 @@
+/** Server-only HTTP transport and static application composition. @packageDocumentation */
+export * from "./security/index.js";
+export { staticApplicationLayer, staticApplicationWithAssetsLayer } from "./StaticApplication.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/http/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/http/index.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,cAAc,qBAAqB,CAAA;AACnC,OAAO,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/server/server/http/security/HttpLimits.d.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect";
+/** Positive integral byte limit used at HTTP trust boundaries. */
+export declare const HttpByteLimit: Schema.brand<Schema.Number, "HttpByteLimit">;
+/** Decoded positive HTTP byte limit. */
+export type HttpByteLimit = typeof HttpByteLimit.Type;
+/** Closed HTTP security budgets shared by request, response, static, and media boundaries. */
+export declare const HttpSecurityLimits: Schema.Struct<{
+    readonly maximumRequestBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumResponseBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumRequestUrlBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumHeaderBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumHeaderCount: Schema.Number;
+    readonly maximumStaticIndexBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumStaticAssetBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumStaticTotalBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+    readonly maximumMediaSourceBytes: Schema.brand<Schema.Number, "HttpByteLimit">;
+}>;
+/** Decoded HTTP security budgets. */
+export type HttpSecurityLimits = typeof HttpSecurityLimits.Type;
+/** Conservative defaults for the first authenticated server implementation. */
+export declare const DEFAULT_HTTP_SECURITY_LIMITS: HttpSecurityLimits;
+//# sourceMappingURL=HttpLimits.d.ts.map

package/dist/server/server/http/security/HttpLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpLimits.d.ts","sourceRoot":"","sources":["../../../../../src/server/http/security/HttpLimits.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,kEAAkE;AAClE,eAAO,MAAM,aAAa,8CAGW,CAAA;AAErC,wCAAwC;AACxC,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD,8FAA8F;AAC9F,eAAO,MAAM,kBAAkB;;;;;;;;;;EAU7B,CAAA;AAEF,qCAAqC;AACrC,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;AAE/D,+EAA+E;AAC/E,eAAO,MAAM,4BAA4B,EAAE,kBAUzC,CAAA"}

package/dist/server/server/http/security/RequestPolicy.d.ts

@@ -0,0 +1,26 @@
+import { Effect, Schema, Stream } from "effect";
+import { HttpByteLimit } from "./HttpLimits.js";
+declare const RequestBodyPolicyError_base: Schema.Class<RequestBodyPolicyError, Schema.TaggedStruct<"RequestBodyPolicyError", {
+    readonly reason: Schema.Literals<readonly ["invalid-metadata", "compressed-body-rejected", "conflicting-length-headers", "body-too-large", "safe-method-body-rejected", "content-type-required", "content-type-rejected"]>;
+    readonly maximumBytes: Schema.NullOr<Schema.brand<Schema.Number, "HttpByteLimit">>;
+}>, import("effect/Cause").YieldableError>;
+/** A request body failed the centralized transport and size policy. */
+export declare class RequestBodyPolicyError extends RequestBodyPolicyError_base {
+}
+/** Inputs for evaluating request body metadata before any body accessor is used. */
+export interface AuthorizeRequestBodyInput {
+    readonly metadata: unknown;
+    readonly expectsJson: boolean;
+    readonly maximumBytes?: number | undefined;
+}
+/** Trusted body policy returned after headers and declared length are accepted. */
+export interface AuthorizedRequestBody {
+    readonly declaredBytes: number | null;
+    readonly maximumBytes: HttpByteLimit;
+}
+/** Authorize request headers and declared length before reading an API body. */
+export declare const authorizeRequestBody: (input: AuthorizeRequestBodyInput) => Effect.Effect<AuthorizedRequestBody, RequestBodyPolicyError, never>;
+/** Count actual streamed bytes so chunked and dishonest-length bodies cannot bypass limits. */
+export declare const limitRequestBodyStream: <Error, Requirements>(stream: Stream.Stream<Uint8Array, Error, Requirements>, maximumBytes: HttpByteLimit) => Stream.Stream<Uint8Array, Error | RequestBodyPolicyError, Requirements>;
+export {};
+//# sourceMappingURL=RequestPolicy.d.ts.map

package/dist/server/server/http/security/RequestPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RequestPolicy.d.ts","sourceRoot":"","sources":["../../../../../src/server/http/security/RequestPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAEvD,OAAO,EAAgC,aAAa,EAAE,MAAM,iBAAiB,CAAA;;;;;AAiB7E,uEAAuE;AACvE,qBAAa,sBAAuB,SAAQ,2BAc3C;CAAG;AAEJ,oFAAoF;AACpF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC3C;AAED,mFAAmF;AACnF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IACrC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAA;CACrC;AAUD,gFAAgF;AAChF,eAAO,MAAM,oBAAoB,2GAoC/B,CAAA;AAOF,+FAA+F;AAC/F,eAAO,MAAM,sBAAsB,GAAI,KAAK,EAAE,YAAY,EACxD,QAAQ,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,YAAY,CAAC,EACtD,cAAc,aAAa,KAC1B,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,KAAK,GAAG,sBAAsB,EAAE,YAAY,CAWtE,CAAA"}