npm - @knpkv/control-center - Versions diffs - 0.1.0 - Mend

@knpkv/control-center 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (664) hide show

package/dist/server/server/persistence/repositories/deliveryGraphRepository.d.ts ADDED Viewed

@@ -0,0 +1,2121 @@
+import * as Context from "effect/Context";
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type { Success } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Database } from "../Database.js";
+import { DeliveryGraphInputError } from "./delivery-graph/contract.js";
+import { QuarantineRepository } from "./quarantineRepository.js";
+export { DeliveryGraphInputError, DeliveryGraphQuery, DeliveryGraphReadResult, DeliveryGraphWriteBatch, DeliveryGraphWriteReceipt } from "./delivery-graph/contract.js";
+declare const makeDeliveryGraphRepository: Effect.Effect<{
+    write: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly entityProjectionCount: Schema.Int;
+        readonly nodeCount: Schema.Int;
+        readonly evidenceItemCount: Schema.Int;
+        readonly evidenceClaimCount: Schema.Int;
+        readonly relationshipCount: Schema.Int;
+    }, "Type">, import("../errors.ts").PersistenceOperationError | import("../errors.ts").RevisionConflictError | import("../errors.ts").PersistedRecordError | DeliveryGraphInputError, never>;
+    read: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, input: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"relationship">;
+        readonly value: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+            readonly relationshipSchemaVersion: Schema.Literal<1>;
+            readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+            readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+            readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly proposed: Schema.TaggedStruct<"proposed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly verified: Schema.TaggedStruct<"verified", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly governed: Schema.TaggedStruct<"governed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly rejected: Schema.TaggedStruct<"rejected", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly superseded: Schema.TaggedStruct<"superseded", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+            }>;
+            readonly confidence: Schema.TaggedUnion<{
+                readonly unknown: Schema.TaggedStruct<"unknown", {
+                    readonly rationale: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly score: Schema.Number;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+            }>;
+            readonly provenance: Schema.TaggedUnion<{
+                readonly plugin: Schema.TaggedStruct<"plugin", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                }>;
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly rule: Schema.TaggedStruct<"rule", {
+                    readonly ruleId: Schema.String;
+                    readonly ruleVersion: Schema.Int;
+                    readonly rationale: Schema.String;
+                }>;
+            }>;
+            readonly recordedBy: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.String;
+                }>;
+            }>;
+            readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"evidence">;
+        readonly value: Schema.Struct<{
+            readonly evidence: 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 schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"current">;
+                    readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>]>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"stale">;
+                    readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.TaggedStruct<"missing", {
+                    readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.TaggedStruct<"unavailable", {
+                    readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.Null;
+                }>]>;
+                readonly retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>;
+            readonly claims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"releaseSlice">;
+        readonly value: Schema.Struct<{
+            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+            readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+            readonly truncated: Schema.Boolean;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly resolution: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                        readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                        readonly missingKey: Schema.String;
+                    }>;
+                    readonly resolved: Schema.TaggedStruct<"resolved", {
+                        readonly target: Schema.TaggedUnion<{
+                            readonly release: Schema.TaggedStruct<"release", {
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly environment: Schema.TaggedStruct<"environment", {
+                                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly entity: Schema.TaggedStruct<"entity", {
+                                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                                readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly createdAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly entityProjections: Schema.$Array<Schema.Struct<{
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly evidenceClaims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+            readonly evidenceItems: 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 schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"current">;
+                    readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>]>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"stale">;
+                    readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.TaggedStruct<"missing", {
+                    readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.TaggedStruct<"unavailable", {
+                    readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.Null;
+                }>]>;
+                readonly retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"workspaceEntityProjections">;
+        readonly value: Schema.Struct<{
+            readonly matchedCount: Schema.Int;
+            readonly ownerOptions: Schema.$Array<Schema.Struct<{
+                readonly avatarFallback: Schema.String;
+                readonly displayName: Schema.String;
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                readonly roles: Schema.$Array<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 ownerOptionsTruncated: Schema.Boolean;
+            readonly totalCount: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly items: Schema.$Array<Schema.Struct<{
+                readonly canonicalReleaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly owners: Schema.$Array<Schema.Struct<{
+                    readonly avatarFallback: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly roles: Schema.$Array<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 ownersTruncated: Schema.Boolean;
+                readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly releaseMembershipsTruncated: Schema.Boolean;
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"relationshipHistory">;
+        readonly value: Schema.$Array<Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+            readonly relationshipSchemaVersion: Schema.Literal<1>;
+            readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+            readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+            readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+            readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                readonly release: Schema.TaggedStruct<"release", {
+                    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                }>;
+                readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly proposed: Schema.TaggedStruct<"proposed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly verified: Schema.TaggedStruct<"verified", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly governed: Schema.TaggedStruct<"governed", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                }>;
+                readonly rejected: Schema.TaggedStruct<"rejected", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+                readonly superseded: Schema.TaggedStruct<"superseded", {
+                    readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    readonly reason: Schema.String;
+                }>;
+            }>;
+            readonly confidence: Schema.TaggedUnion<{
+                readonly unknown: Schema.TaggedStruct<"unknown", {
+                    readonly rationale: Schema.String;
+                }>;
+                readonly inferred: Schema.TaggedStruct<"inferred", {
+                    readonly score: Schema.Number;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+            }>;
+            readonly provenance: Schema.TaggedUnion<{
+                readonly plugin: Schema.TaggedStruct<"plugin", {
+                    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                }>;
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    readonly rationale: Schema.String;
+                }>;
+                readonly rule: Schema.TaggedStruct<"rule", {
+                    readonly ruleId: Schema.String;
+                    readonly ruleVersion: Schema.Int;
+                    readonly rationale: Schema.String;
+                }>;
+            }>;
+            readonly recordedBy: Schema.TaggedUnion<{
+                readonly human: Schema.TaggedStruct<"human", {
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                }>;
+                readonly agent: Schema.TaggedStruct<"agent", {
+                    readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                }>;
+                readonly system: Schema.TaggedStruct<"system", {
+                    readonly component: Schema.String;
+                }>;
+            }>;
+            readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"entityProjection">;
+        readonly value: Schema.Struct<{
+            readonly projection: Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly projectionSchemaVersion: Schema.Int;
+                readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                readonly displayKey: Schema.String;
+                readonly title: Schema.String;
+                readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                    readonly key: Schema.String;
+                    readonly status: Schema.String;
+                    readonly priority: Schema.NullOr<Schema.String>;
+                    readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                    readonly summary: Schema.optionalKey<Schema.String>;
+                    readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }>>>;
+                    readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                    readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                        readonly released: Schema.Boolean;
+                        readonly releaseDate: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly name: Schema.NullOr<Schema.String>;
+                        readonly released: Schema.Boolean;
+                        readonly releaseDate: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }>>>;
+                    readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.NullOr<Schema.String>;
+                        readonly key: Schema.NullOr<Schema.String>;
+                        readonly summary: Schema.NullOr<Schema.String>;
+                        readonly status: Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourcePersonId: Schema.String;
+                        readonly displayName: Schema.String;
+                        readonly avatarUrl: Schema.NullOr<Schema.String>;
+                        readonly active: Schema.Boolean;
+                        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourcePersonId: Schema.String;
+                        readonly displayName: Schema.String;
+                        readonly avatarUrl: Schema.NullOr<Schema.String>;
+                        readonly active: Schema.Boolean;
+                        readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly body: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly updatedAt: Schema.NullOr<Schema.String>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly body: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly updatedAt: Schema.NullOr<Schema.String>;
+                    }, "Encoded">, never, never>>>;
+                    readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                    readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>;
+                    }, "Type">, Schema.Struct.ReadonlySide<{
+                        readonly sourceId: Schema.String;
+                        readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                        readonly createdAt: Schema.NullOr<Schema.String>;
+                        readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly field: Schema.String;
+                            readonly from: Schema.NullOr<Schema.String>;
+                            readonly to: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>;
+                    }, "Encoded">, never, never>>>;
+                    readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                    readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                    readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                }>, Schema.TaggedStruct<"pull-request", {
+                    readonly repository: Schema.String;
+                    readonly sourceBranch: Schema.String;
+                    readonly targetBranch: Schema.String;
+                    readonly headRevision: Schema.String;
+                    readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                }>, Schema.TaggedStruct<"page", {
+                    readonly spaceKey: Schema.String;
+                    readonly revision: Schema.String;
+                    readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                    readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                    readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                }>, Schema.TaggedStruct<"pipeline-execution", {
+                    readonly pipelineName: Schema.String;
+                    readonly executionId: Schema.String;
+                    readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                    readonly triggerRevision: Schema.String;
+                }>, Schema.TaggedStruct<"deployment", {
+                    readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                    readonly revision: Schema.String;
+                    readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                }>, Schema.TaggedStruct<"time-entry", {
+                    readonly durationMinutes: Schema.Int;
+                    readonly billable: Schema.Boolean;
+                    readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                }>]>;
+            }>;
+            readonly recordedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"node">;
+        readonly value: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+            readonly resolution: Schema.TaggedUnion<{
+                readonly missing: Schema.TaggedStruct<"missing", {
+                    readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                    readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                    readonly missingKey: Schema.String;
+                }>;
+                readonly resolved: Schema.TaggedStruct<"resolved", {
+                    readonly target: Schema.TaggedUnion<{
+                        readonly release: Schema.TaggedStruct<"release", {
+                            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        }>;
+                        readonly environment: Schema.TaggedStruct<"environment", {
+                            readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                            readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                        }>;
+                        readonly entity: Schema.TaggedStruct<"entity", {
+                            readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                            readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+            readonly createdAt: Schema.DateTimeUtcFromString;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"entitySlice">;
+        readonly value: Schema.Struct<{
+            readonly entity: Schema.Struct<{
+                readonly canonicalReleaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly owners: Schema.$Array<Schema.Struct<{
+                    readonly avatarFallback: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    readonly roles: Schema.$Array<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 ownersTruncated: Schema.Boolean;
+                readonly releaseIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+                readonly releaseMembershipsTruncated: Schema.Boolean;
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>;
+            readonly truncated: Schema.Boolean;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly endpointKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly resolution: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly expectedKind: Schema.Literals<readonly ["entity", "release", "environment"]>;
+                        readonly expectedEntityKind: Schema.NullOr<Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>>;
+                        readonly missingKey: Schema.String;
+                    }>;
+                    readonly resolved: Schema.TaggedStruct<"resolved", {
+                        readonly target: Schema.TaggedUnion<{
+                            readonly release: Schema.TaggedStruct<"release", {
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly environment: Schema.TaggedStruct<"environment", {
+                                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                            }>;
+                            readonly entity: Schema.TaggedStruct<"entity", {
+                                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                                readonly entityKind: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+                readonly createdAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relatedEntityProjections: Schema.$Array<Schema.Struct<{
+                readonly projection: Schema.Struct<{
+                    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                    readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                    readonly projectionRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    readonly supersedesProjectionRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                    readonly projectionSchemaVersion: Schema.Int;
+                    readonly entityState: Schema.Literals<readonly ["present", "deleted"]>;
+                    readonly entityType: Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>;
+                    readonly displayKey: Schema.String;
+                    readonly title: Schema.String;
+                    readonly details: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"issue", {
+                        readonly key: Schema.String;
+                        readonly status: Schema.String;
+                        readonly priority: Schema.NullOr<Schema.String>;
+                        readonly estimatePoints: Schema.NullOr<Schema.Number>;
+                        readonly summary: Schema.optionalKey<Schema.String>;
+                        readonly description: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly acceptanceCriteria: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly environment: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly issueType: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly project: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly resolution: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }>>>;
+                        readonly labels: Schema.optionalKey<Schema.$Array<Schema.Codec<string, string, never, never>>>;
+                        readonly components: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly fixVersions: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly name: Schema.NullOr<Schema.String>;
+                            readonly released: Schema.Boolean;
+                            readonly releaseDate: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly createdAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly updatedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly dueDate: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly resolvedAt: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly parent: Schema.optionalKey<Schema.NullOr<Schema.Struct<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }>>>;
+                        readonly subtasks: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.NullOr<Schema.String>;
+                            readonly key: Schema.NullOr<Schema.String>;
+                            readonly summary: Schema.NullOr<Schema.String>;
+                            readonly status: Schema.NullOr<Schema.Struct<{
+                                readonly sourceId: Schema.NullOr<Schema.String>;
+                                readonly name: Schema.NullOr<Schema.String>;
+                            }>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly assigneeSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly reporterSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly creatorSourcePersonId: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly collaborators: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourcePersonId: Schema.String;
+                            readonly displayName: Schema.String;
+                            readonly avatarUrl: Schema.NullOr<Schema.String>;
+                            readonly active: Schema.Boolean;
+                            readonly roles: Schema.$Array<Schema.Codec<string, string, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly comments: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly updateAuthorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly body: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly updatedAt: Schema.NullOr<Schema.String>;
+                        }, "Encoded">, never, never>>>;
+                        readonly commentTotal: Schema.optionalKey<Schema.Int>;
+                        readonly commentsTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly commentBodiesTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly history: Schema.optionalKey<Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Type">, Schema.Struct.ReadonlySide<{
+                            readonly sourceId: Schema.String;
+                            readonly authorSourcePersonId: Schema.NullOr<Schema.String>;
+                            readonly createdAt: Schema.NullOr<Schema.String>;
+                            readonly changes: Schema.$Array<Schema.Codec<Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Type">, Schema.Struct.ReadonlySide<{
+                                readonly field: Schema.String;
+                                readonly from: Schema.NullOr<Schema.String>;
+                                readonly to: Schema.NullOr<Schema.String>;
+                            }, "Encoded">, never, never>>;
+                        }, "Encoded">, never, never>>>;
+                        readonly historyTotal: Schema.optionalKey<Schema.Int>;
+                        readonly historyTruncated: Schema.optionalKey<Schema.Boolean>;
+                        readonly truncatedFields: Schema.optionalKey<Schema.$Array<Schema.Codec<"status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", "status" | "description" | "environment" | "createdAt" | "updatedAt" | "key" | "collaborators" | "history" | "summary" | "acceptanceCriteria" | "comments" | "components" | "fixVersions" | "issueType" | "labels" | "parent" | "priority" | "project" | "resolution" | "subtasks" | "dueDate" | "resolvedAt", never, never>>>;
+                    }>, Schema.TaggedStruct<"pull-request", {
+                        readonly repository: Schema.String;
+                        readonly sourceBranch: Schema.String;
+                        readonly targetBranch: Schema.String;
+                        readonly headRevision: Schema.String;
+                        readonly reviewState: Schema.Literals<readonly ["not-requested", "requested", "changes-requested", "approved", "merged"]>;
+                    }>, Schema.TaggedStruct<"page", {
+                        readonly spaceKey: Schema.String;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["draft", "current", "superseded"]>;
+                        readonly linkedIssueKeys: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly linkedReleaseVersions: Schema.optional<Schema.$Array<Schema.String>>;
+                    }>, Schema.TaggedStruct<"pipeline-execution", {
+                        readonly pipelineName: Schema.String;
+                        readonly executionId: Schema.String;
+                        readonly status: Schema.Literals<readonly ["queued", "running", "succeeded", "failed", "stopped"]>;
+                        readonly triggerRevision: Schema.String;
+                    }>, Schema.TaggedStruct<"deployment", {
+                        readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                        readonly revision: Schema.String;
+                        readonly status: Schema.Literals<readonly ["pending", "deploying", "succeeded", "failed", "rolled-back"]>;
+                    }>, Schema.TaggedStruct<"time-entry", {
+                        readonly durationMinutes: Schema.Int;
+                        readonly billable: Schema.Boolean;
+                        readonly approvalState: Schema.Literals<readonly ["pending", "approved", "rejected", "not-required"]>;
+                    }>]>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+            readonly evidenceClaims: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly evidenceClaimId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">;
+                readonly evidenceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceId">;
+                readonly subjectNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly predicate: Schema.Literals<readonly ["relationship-observed", "status-observed", "approval-recorded", "check-observed", "execution-observed", "deployment-observed", "documentation-observed", "time-observed"]>;
+                readonly value: Schema.TaggedUnion<{
+                    readonly revision: Schema.TaggedStruct<"revision", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly state: Schema.TaggedStruct<"state", {
+                        readonly value: Schema.String;
+                    }>;
+                    readonly reference: Schema.TaggedStruct<"reference", {
+                        readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                    }>;
+                    readonly flag: Schema.TaggedStruct<"flag", {
+                        readonly value: Schema.Boolean;
+                    }>;
+                }>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly supersedesEvidenceClaimId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+            }>>;
+            readonly evidenceItems: 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 schemaVersion: Schema.Int;
+                readonly attribution: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly verifier: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly observedAt: Schema.DateTimeUtcFromString;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+                readonly validUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+                    readonly _tag: Schema.tag<"current">;
+                    readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>]>;
+                    readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>]>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.tag<"stale">;
+                    readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"degraded">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.Struct<{
+                        readonly _tag: Schema.tag<"cache">;
+                        readonly cachedAt: Schema.DateTimeUtcFromString;
+                        readonly sourceRevision: Schema.Struct<{
+                            readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                            readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                            readonly revision: Schema.brand<Schema.String, "Revision">;
+                            readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                            readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                            readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                            readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                            readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+                        }>;
+                    }>;
+                    readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                    readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+                }>, Schema.TaggedStruct<"missing", {
+                    readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                }>, Schema.TaggedStruct<"unavailable", {
+                    readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+                        readonly _tag: Schema.tag<"unavailable">;
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                        readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+                        readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                        readonly safeMessage: Schema.String;
+                    }>, Schema.TaggedStruct<"disabled", {
+                        readonly checkedAt: Schema.DateTimeUtcFromString;
+                    }>]>;
+                    readonly provenance: Schema.TaggedStruct<"none", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                    }>;
+                    readonly sourceObservedAt: Schema.Null;
+                    readonly staleAfterSeconds: Schema.Int;
+                    readonly synchronizedAt: Schema.Null;
+                }>]>;
+                readonly retention: Schema.Struct<{
+                    readonly classification: Schema.Literals<readonly ["audit", "evidence", "normalized-cache"]>;
+                    readonly retainUntil: Schema.NullOr<Schema.DateTimeUtcFromString>;
+                    readonly legalHold: Schema.Boolean;
+                }>;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"nodeRelationships">;
+        readonly value: Schema.Struct<{
+            readonly nodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+            readonly truncated: Schema.Boolean;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"componentRelationships">;
+        readonly value: Schema.Struct<{
+            readonly releaseId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+            readonly truncated: Schema.Boolean;
+            readonly relationships: Schema.$Array<Schema.Struct<{
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+                readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+                readonly relationshipSchemaVersion: Schema.Literal<1>;
+                readonly revision: Schema.brand<Schema.Int, "LedgerRevision">;
+                readonly supersedesRevision: Schema.NullOr<Schema.brand<Schema.Int, "LedgerRevision">>;
+                readonly kind: Schema.Literals<readonly ["contains", "implements", "depends-on", "verified-by", "delivered-by", "documented-by", "tracks-time-for"]>;
+                readonly sourceNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly sourceNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly targetNodeId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GraphNodeId">;
+                readonly targetNodeKind: Schema.Union<readonly [Schema.Literals<readonly ["issue", "pull-request", "page", "pipeline-execution", "deployment", "time-entry"]>, Schema.Literals<readonly ["release", "environment"]>]>;
+                readonly scope: Schema.NullOr<Schema.TaggedUnion<{
+                    readonly release: Schema.TaggedStruct<"release", {
+                        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                    }>;
+                    readonly environment: 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 lifecycle: Schema.TaggedUnion<{
+                    readonly missing: Schema.TaggedStruct<"missing", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly proposed: Schema.TaggedStruct<"proposed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly verified: Schema.TaggedStruct<"verified", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly governed: Schema.TaggedStruct<"governed", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                    }>;
+                    readonly rejected: Schema.TaggedStruct<"rejected", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                    readonly superseded: Schema.TaggedStruct<"superseded", {
+                        readonly effectiveAt: Schema.DateTimeUtcFromString;
+                        readonly reason: Schema.String;
+                    }>;
+                }>;
+                readonly confidence: Schema.TaggedUnion<{
+                    readonly unknown: Schema.TaggedStruct<"unknown", {
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly inferred: Schema.TaggedStruct<"inferred", {
+                        readonly score: Schema.Number;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly confirmed: Schema.TaggedStruct<"confirmed", {}>;
+                }>;
+                readonly provenance: Schema.TaggedUnion<{
+                    readonly plugin: Schema.TaggedStruct<"plugin", {
+                        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                        readonly sourceEntityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                        readonly sourceEntityRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+                    }>;
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                        readonly rationale: Schema.String;
+                    }>;
+                    readonly rule: Schema.TaggedStruct<"rule", {
+                        readonly ruleId: Schema.String;
+                        readonly ruleVersion: Schema.Int;
+                        readonly rationale: Schema.String;
+                    }>;
+                }>;
+                readonly recordedBy: Schema.TaggedUnion<{
+                    readonly human: Schema.TaggedStruct<"human", {
+                        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+                    }>;
+                    readonly agent: Schema.TaggedStruct<"agent", {
+                        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+                    }>;
+                    readonly system: Schema.TaggedStruct<"system", {
+                        readonly component: Schema.String;
+                    }>;
+                }>;
+                readonly evidenceClaimIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EvidenceClaimId">>;
+                readonly recordedAt: Schema.DateTimeUtcFromString;
+            }>>;
+        }>;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly _tag: Schema.tag<"releaseSummary">;
+        readonly value: Schema.Struct<{
+            readonly issues: Schema.Int;
+            readonly pullRequests: Schema.Int;
+            readonly pipelineExecutions: Schema.Int;
+        }>;
+    }, "Type">, Schema.SchemaError | import("../errors.ts").RecordNotFoundError | import("../errors.ts").PersistenceOperationError | import("../errors.ts").PersistedRecordError | import("../errors.ts").QuarantineWriteError | import("effect/unstable/sql/SqlError").SqlError | DeliveryGraphInputError, never>;
+}, never, Crypto.Crypto | Database | QuarantineRepository>;
+/** Deep workspace-safe persistence interface for the complete delivery graph ledger. */
+export interface DeliveryGraphRepositoryService extends Success<typeof makeDeliveryGraphRepository> {
+}
+declare const DeliveryGraphRepository_base: Context.ServiceClass<DeliveryGraphRepository, "@knpkv/control-center/DeliveryGraphRepository", DeliveryGraphRepositoryService>;
+/** Effect service exposing one atomic write and one tagged read operation. */
+export declare class DeliveryGraphRepository extends DeliveryGraphRepository_base {
+    /** Layer binding graph persistence to the shared database and cryptography services. */
+    static readonly layer: Layer.Layer<DeliveryGraphRepository, never, Crypto.Crypto | Database | QuarantineRepository>;
+}
+//# sourceMappingURL=deliveryGraphRepository.d.ts.map