@knpkv/control-center 0.1.0

package/dist/server/server/persistence/repositories/readiness/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/readiness/contract.ts"],"names":[],"mappings":"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"}

package/dist/server/server/persistence/repositories/readiness/materialization.d.ts

@@ -0,0 +1,459 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { ReadinessAssessmentId, WorkspaceId } from "../../../../domain/identifiers.js";
+import { Database } from "../../Database.js";
+import { ReadinessMaterializedEvidenceRow, ReadinessMaterializedReleaseChildRow, ReadinessMaterializedSourceRow } from "./rows.js";
+type EvidenceRow = typeof ReadinessMaterializedEvidenceRow.Type;
+type SourceRow = typeof ReadinessMaterializedSourceRow.Type;
+type ChildRow = typeof ReadinessMaterializedReleaseChildRow.Type;
+interface MaterializationRows {
+    readonly evidence: ReadonlyArray<EvidenceRow>;
+    readonly sources: ReadonlyArray<SourceRow>;
+    readonly children: ReadonlyArray<ChildRow>;
+}
+export interface GroupedMaterialization {
+    readonly evidence: ReadonlyMap<ReadinessAssessmentId, ReadonlyArray<EvidenceRow>>;
+    readonly sources: ReadonlyMap<ReadinessAssessmentId, ReadonlyArray<SourceRow>>;
+    readonly children: ReadonlyMap<ReadinessAssessmentId, ReadonlyArray<ChildRow>>;
+}
+/** Index each persisted dependency exactly once before aggregate verification. */
+export declare const groupReadinessMaterialization: (rows: MaterializationRows) => GroupedMaterialization;
+export declare const makeReadinessMaterialization: Effect.Effect<{
+    load: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly assessmentIds: ReadonlyArray<ReadinessAssessmentId>;
+    }) => Effect.Effect<GroupedMaterialization, Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError | import("./quarantine.js").MalformedReadinessRecord, never>;
+    verify: (assessment: Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.Literal<"environment">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"environment", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly inputComplete: Schema.Boolean;
+        readonly facts: Schema.$Array<Schema.Struct<{
+            readonly definition: Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+            }>;
+            readonly observation: Schema.NullOr<Schema.Struct<{
+                readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                readonly state: Schema.TaggedUnion<{
+                    readonly relationship: Schema.TaggedStruct<"relationship", {
+                        readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                    }>;
+                    readonly approval: Schema.TaggedStruct<"approval", {
+                        readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                    }>;
+                    readonly check: Schema.TaggedStruct<"check", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                    }>;
+                    readonly execution: Schema.TaggedStruct<"execution", {
+                        readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                    readonly documentation: Schema.TaggedStruct<"documentation", {
+                        readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                    }>;
+                    readonly deployment: Schema.TaggedStruct<"deployment", {
+                        readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                        readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                            readonly _tag: Schema.tag<"count">;
+                            readonly completed: Schema.Int;
+                            readonly total: Schema.Int;
+                        }>, Schema.TaggedStruct<"percent", {
+                            readonly value: Schema.Number;
+                        }>]>>;
+                    }>;
+                }>;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                    readonly source: Schema.TaggedUnion<{
+                        readonly plugin: Schema.TaggedStruct<"plugin", {
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                        }>;
+                        readonly local: Schema.TaggedStruct<"local", {
+                            readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                        }>;
+                    }>;
+                    readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                    readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                    readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                }>>;
+            }>>;
+            readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly requiredFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly verifiedFactIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.Literal<"release">;
+        readonly candidate: Schema.Struct<{
+            readonly scope: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            }>;
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly releaseRevision: Schema.Int;
+            readonly artifactRevision: Schema.String;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly environments: Schema.NonEmptyArray<Schema.Struct<{
+            readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+            readonly candidateDigest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+            readonly inputComplete: Schema.Boolean;
+            readonly facts: Schema.$Array<Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly kind: Schema.Literals<readonly ["relationship", "approval", "check", "execution", "documentation", "deployment"]>;
+                    readonly requirement: Schema.Literals<readonly ["required", "advisory"]>;
+                }>;
+                readonly observation: Schema.NullOr<Schema.Struct<{
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    readonly state: Schema.TaggedUnion<{
+                        readonly relationship: Schema.TaggedStruct<"relationship", {
+                            readonly status: Schema.Literals<readonly ["missing", "inferred", "proposed", "verified", "governed", "rejected", "superseded"]>;
+                        }>;
+                        readonly approval: Schema.TaggedStruct<"approval", {
+                            readonly status: Schema.Literals<readonly ["missing", "pending", "approved", "rejected", "expired"]>;
+                        }>;
+                        readonly check: Schema.TaggedStruct<"check", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "passed", "failed", "cancelled"]>;
+                        }>;
+                        readonly execution: Schema.TaggedStruct<"execution", {
+                            readonly status: Schema.Literals<readonly ["missing", "queued", "running", "succeeded", "failed", "stopped"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                        readonly documentation: Schema.TaggedStruct<"documentation", {
+                            readonly status: Schema.Literals<readonly ["missing", "draft", "current", "stale", "superseded"]>;
+                        }>;
+                        readonly deployment: Schema.TaggedStruct<"deployment", {
+                            readonly status: Schema.Literals<readonly ["not-started", "pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                            readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                                readonly _tag: Schema.tag<"count">;
+                                readonly completed: Schema.Int;
+                                readonly total: Schema.Int;
+                            }>, Schema.TaggedStruct<"percent", {
+                                readonly value: Schema.Number;
+                            }>]>>;
+                        }>;
+                    }>;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                        readonly source: Schema.TaggedUnion<{
+                            readonly plugin: Schema.TaggedStruct<"plugin", {
+                                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                            }>;
+                            readonly local: Schema.TaggedStruct<"local", {
+                                readonly origin: Schema.Literals<readonly ["human", "agent", "system"]>;
+                            }>;
+                        }>;
+                        readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                        readonly validity: Schema.Literals<readonly ["valid", "expired"]>;
+                        readonly reevaluateAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    }>>;
+                }>>;
+                readonly result: Schema.Literals<readonly ["verified", "pending", "failed", "gap", "advisory"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+            readonly stages: Schema.Struct<{
+                readonly build: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly verify: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+                readonly production: Schema.Struct<{
+                    readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                    readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                    readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                    readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"count">;
+                        readonly completed: Schema.Int;
+                        readonly total: Schema.Int;
+                    }>, Schema.TaggedStruct<"percent", {
+                        readonly value: Schema.Number;
+                    }>]>>;
+                }>;
+            }>;
+            readonly blockers: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly gaps: Schema.$Array<Schema.Struct<{
+                readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+                readonly subject: Schema.TaggedUnion<{
+                    readonly source: Schema.TaggedStruct<"source", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly fact: Schema.TaggedStruct<"fact", {
+                        readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                    }>;
+                    readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+                }>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+                readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly assessmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">;
+        readonly previousAssessmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReadinessAssessmentId">>;
+        readonly rule: Schema.Struct<{
+            readonly ruleId: Schema.String;
+            readonly version: Schema.brand<Schema.Int, "ReadinessRuleVersion">;
+            readonly digest: Schema.brand<Schema.String, "ReadinessCandidateDigest">;
+        }>;
+        readonly derivationVersion: Schema.brand<Schema.Int, "ReadinessDerivationVersion">;
+        readonly evaluatedAt: Schema.DateTimeUtcFromString;
+        readonly nextEvaluationAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+        readonly verdict: Schema.Literals<readonly ["blocked", "ready", "deploying", "building", "shipped", "held"]>;
+        readonly stages: Schema.Struct<{
+            readonly build: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "queued", "running", "succeeded", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly verify: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "pending", "passed", "failed", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+            readonly production: Schema.Struct<{
+                readonly state: Schema.Literals<readonly ["not-started", "waiting", "deploying", "succeeded", "failed", "rolled-back", "held"]>;
+                readonly factIds: Schema.$Array<Schema.brand<Schema.String, "ReadinessFactId">>;
+                readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+                readonly progress: Schema.NullOr<Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"count">;
+                    readonly completed: Schema.Int;
+                    readonly total: Schema.Int;
+                }>, Schema.TaggedStruct<"percent", {
+                    readonly value: Schema.Number;
+                }>]>>;
+            }>;
+        }>;
+        readonly blockers: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly gaps: Schema.$Array<Schema.Struct<{
+            readonly code: Schema.Literals<readonly ["input-incomplete", "relationship-missing", "relationship-unverified", "relationship-rejected", "relationship-superseded", "approval-missing", "approval-pending", "approval-rejected", "approval-expired", "check-missing", "check-pending", "check-failed", "check-cancelled", "execution-missing", "execution-pending", "execution-failed", "execution-stopped", "documentation-missing", "documentation-draft", "documentation-stale", "documentation-superseded", "deployment-missing", "deployment-failed", "deployment-rolled-back", "source-stale", "source-missing", "source-unavailable", "plugin-degraded", "evidence-expired"]>;
+            readonly subject: Schema.TaggedUnion<{
+                readonly source: Schema.TaggedStruct<"source", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                }>;
+                readonly fact: Schema.TaggedStruct<"fact", {
+                    readonly factId: Schema.brand<Schema.String, "ReadinessFactId">;
+                }>;
+                readonly candidate: Schema.TaggedStruct<"candidate", {}>;
+            }>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly sourceFreshness: Schema.$Array<Schema.Struct<{
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly freshness: Schema.Literals<readonly ["current", "stale", "missing", "unavailable"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "degraded", "unavailable", "disabled"]>;
+            readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+        }>>;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">>;
+    }, "Type">, row: unknown, grouped: GroupedMaterialization) => Effect.Effect<undefined, import("./quarantine.js").MalformedReadinessRecord, never>;
+}, never, Database>;
+export {};
+//# sourceMappingURL=materialization.d.ts.map

package/dist/server/server/persistence/repositories/readiness/materialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialization.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/readiness/materialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE3F,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG5C,OAAO,EAEL,gCAAgC,EAChC,oCAAoC,EACpC,8BAA8B,EAC/B,MAAM,WAAW,CAAA;AAElB,KAAK,WAAW,GAAG,OAAO,gCAAgC,CAAC,IAAI,CAAA;AAC/D,KAAK,SAAS,GAAG,OAAO,8BAA8B,CAAC,IAAI,CAAA;AAC3D,KAAK,QAAQ,GAAG,OAAO,oCAAoC,CAAC,IAAI,CAAA;AAEhE,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IAC7C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IAC1C,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,qBAAqB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,CAAA;IACjF,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,qBAAqB,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC,CAAA;IAC9E,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,qBAAqB,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAA;CAC/E;AAcD,kFAAkF;AAClF,eAAO,MAAM,6BAA6B,GAAI,MAAM,mBAAmB,KAAG,sBAIxE,CAAA;AAEF,eAAO,MAAM,4BAA4B;;8BAcf,WAAW;gCACT,aAAa,CAAC,qBAAqB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA2G9D,CAAA"}

package/dist/server/server/persistence/repositories/readiness/quarantine.d.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import type { PersistedRecordError } from "../../errors.js";
+import type { QuarantineDiagnosticSummary, QuarantineReasonCode, QuarantineRecordKind } from "../models.js";
+type ReadinessQuarantineRecordKind = Extract<QuarantineRecordKind, "readiness-assessment" | "readiness-environment-head" | "readiness-release-head" | "readiness-rule">;
+interface ReadinessQuarantineDiagnostic {
+    readonly diagnosticCode: QuarantineReasonCode;
+    readonly diagnosticSummary: QuarantineDiagnosticSummary;
+    readonly recordKind: ReadinessQuarantineRecordKind;
+}
+/** Internal carrier that keeps malformed readiness values out of the public error channel. */
+export declare class MalformedReadinessRecord {
+    readonly _tag = "MalformedReadinessRecord";
+    readonly error: PersistedRecordError;
+    readonly row: unknown;
+    constructor(error: PersistedRecordError, row: unknown);
+}
+/** Attach an ephemeral raw row to a bounded readiness decode failure for quarantine after commit. */
+export declare const captureMalformedReadinessRow: (row: unknown) => <Success, Failure, Requirements>(effect: Effect.Effect<Success, Failure, Requirements>) => Effect.Effect<Success, MalformedReadinessRecord | Exclude<Failure, Failure & PersistedRecordError>, Requirements>;
+/** Translate readiness decode failures into the fixed metadata accepted by quarantine storage. */
+export declare const readinessQuarantineDiagnostic: (error: PersistedRecordError) => ReadinessQuarantineDiagnostic | null;
+export {};
+//# sourceMappingURL=quarantine.d.ts.map

package/dist/server/server/persistence/repositories/readiness/quarantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quarantine.d.ts","sourceRoot":"","sources":["../../../../../../src/server/persistence/repositories/readiness/quarantine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AAE3G,KAAK,6BAA6B,GAAG,OAAO,CAC1C,oBAAoB,EACpB,sBAAsB,GAAG,4BAA4B,GAAG,wBAAwB,GAAG,gBAAgB,CACpG,CAAA;AAED,UAAU,6BAA6B;IACrC,QAAQ,CAAC,cAAc,EAAE,oBAAoB,CAAA;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,2BAA2B,CAAA;IACvD,QAAQ,CAAC,UAAU,EAAE,6BAA6B,CAAA;CACnD;AAED,8FAA8F;AAC9F,qBAAa,wBAAwB;IACnC,QAAQ,CAAC,IAAI,8BAA6B;IAC1C,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAA;IACpC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAA;gBAET,KAAK,EAAE,oBAAoB,EAAE,GAAG,EAAE,OAAO;CAItD;AAED,qGAAqG;AACrG,eAAO,MAAM,4BAA4B,GACtC,KAAK,OAAO,MAAM,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,sHAKrG,CAAA;AAcL,kGAAkG;AAClG,eAAO,MAAM,6BAA6B,GAAI,OAAO,oBAAoB,KAAG,6BAA6B,GAAG,IAyE3G,CAAA"}