@knpkv/control-center 0.1.0

package/dist/server/assets/domainEvent-x7yeq-gU.js

@@ -0,0 +1,2130 @@
+import * as Schema$1 from "effect/Schema";
+import { DateTime, Schema, SchemaTransformation } from "effect";
+import * as DateTime$1 from "effect/DateTime";
+import * as Effect$1 from "effect/Effect";
+import * as Result$1 from "effect/Result";
+//#region src/domain/identifiers.ts
+var CANONICAL_LOWERCASE_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var canonicalUuid7 = (brand) => Schema.String.check(Schema.isUUID(7)).pipe(Schema.decodeTo(Schema.String.check(Schema.isUUID(7), Schema.isPattern(CANONICAL_LOWERCASE_UUID_PATTERN, { expected: "a canonical lowercase UUID v7" })), SchemaTransformation.toLowerCase()), Schema.brand(brand));
+/** Canonical identifier of an isolated Control Center workspace. */
+var WorkspaceId = canonicalUuid7("WorkspaceId");
+/** Canonical identifier of a release aggregate. */
+var ReleaseId = canonicalUuid7("ReleaseId");
+/** Canonical identifier of a normalized delivery entity. */
+var EntityId = canonicalUuid7("EntityId");
+/** Canonical identifier of a human collaborator. */
+var PersonId = canonicalUuid7("PersonId");
+/** Canonical identifier of an automated agent. */
+var AgentId = canonicalUuid7("AgentId");
+/** Canonical identifier of a deployment environment. */
+var EnvironmentId = canonicalUuid7("EnvironmentId");
+/** Canonical identifier of a configured plugin connection. */
+var PluginConnectionId = canonicalUuid7("PluginConnectionId");
+/** Canonical identifier of one external provider account followed by a workspace. */
+var ProviderAccountId = canonicalUuid7("ProviderAccountId");
+/** Canonical identifier of one repository, pipeline, site, or workspace being followed. */
+var FollowedResourceId = canonicalUuid7("FollowedResourceId");
+/** Canonical identifier of a collaborator role assignment. */
+var RoleAssignmentId = canonicalUuid7("RoleAssignmentId");
+/** Canonical identifier of one delivery-graph relationship. */
+var RelationshipId = canonicalUuid7("RelationshipId");
+/** Canonical identifier of one governed relationship-repair proposal. */
+var RelationshipRepairProposalId = canonicalUuid7("RelationshipRepairProposalId");
+/** Canonical identifier of one immutable relationship-repair review. */
+var RelationshipRepairReviewId = canonicalUuid7("RelationshipRepairReviewId");
+/** Canonical identifier of one immutable evidence claim. */
+var EvidenceClaimId = canonicalUuid7("EvidenceClaimId");
+/** Canonical identifier of one immutable evidence observation envelope. */
+var EvidenceId = canonicalUuid7("EvidenceId");
+/** Canonical identifier of one immutable readiness assessment. */
+var ReadinessAssessmentId = canonicalUuid7("ReadinessAssessmentId");
+/** Canonical identifier of one resolved or explicitly missing graph node. */
+var GraphNodeId = canonicalUuid7("GraphNodeId");
+/** Workspace-local monotonic position used for durable event replay. */
+var EventCursor = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("EventCursor"));
+/** Canonical identifier of one durable domain event. */
+var DomainEventId = canonicalUuid7("DomainEventId");
+/** Canonical identifier of one asynchronous Control Center job. */
+var JobId = canonicalUuid7("JobId");
+/** Canonical identifier of one durable release-scoped agent thread. */
+var AgentThreadId = canonicalUuid7("AgentThreadId");
+/** Canonical identifier of an authenticated browser session. */
+var SessionId = canonicalUuid7("SessionId");
+/** Canonical identifier of one exact-scope authenticated share grant. */
+var ShareId = canonicalUuid7("ShareId");
+/** Canonical identifier of one governed provider action. */
+var GovernedActionId = canonicalUuid7("GovernedActionId");
+/** Canonical identifier of one immutable governed-action transition. */
+var GovernedActionTransitionId = canonicalUuid7("GovernedActionTransitionId");
+/** Canonical identifier of one immutable human action authorization. */
+var GovernedActionAuthorizationId = canonicalUuid7("GovernedActionAuthorizationId");
+/** Canonical identifier of one governed-action execution attempt. */
+var GovernedActionAttemptId = canonicalUuid7("GovernedActionAttemptId");
+//#endregion
+//#region src/domain/utcTimestamp.ts
+/**
+* Codec for instants that normalizes accepted ISO-8601 input to UTC and encodes
+* it as a canonical UTC ISO-8601 string.
+*/
+var UtcTimestamp = Schema.DateTimeUtcFromString.annotate({ identifier: "UtcTimestamp" });
+//#endregion
+//#region src/domain/sourceRevision.ts
+var boundedOpaqueSourceValue = Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(512));
+/** Stable persisted provider names, independent of package abbreviations. */
+var ProviderId = Schema.Literals([
+	"codecommit",
+	"codepipeline",
+	"jira",
+	"confluence",
+	"clockify"
+]).annotate({ identifier: "ProviderId" });
+/** Opaque immutable identifier assigned to an object by its source provider. */
+var VendorImmutableId = boundedOpaqueSourceValue.pipe(Schema.brand("VendorImmutableId"));
+/** Opaque source-provider revision, version, digest, or ETag. */
+var Revision = boundedOpaqueSourceValue.pipe(Schema.brand("Revision"));
+/** Positive version of the normalization schema used for a source record. */
+var NormalizationSchemaVersion = Schema.Number.check(Schema.isInt(), Schema.isGreaterThan(0)).pipe(Schema.brand("NormalizationSchemaVersion"));
+var hasNoControlCharacters = (value) => Array.from(value).every((character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && !(codePoint >= 0 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159);
+});
+/** Safe navigable URL for an exact provider object, without embedded credentials. */
+var SourceUrl = Schema.String.check(Schema.isMaxLength(4096), Schema.makeFilter(hasNoControlCharacters, { expected: "a source URL without control characters" })).pipe(Schema.decodeTo(Schema.URL, SchemaTransformation.urlFromString), Schema.check(Schema.makeFilter(({ protocol }) => protocol === "https:" || protocol === "http:", { expected: "an HTTP or HTTPS source URL" }), Schema.makeFilter(({ password, username }) => password.length === 0 && username.length === 0, { expected: "a source URL without embedded credentials" })));
+/**
+* Immutable provenance needed to reconcile a normalized record with the exact
+* provider object and revision from which it was derived.
+*/
+var SourceRevision = Schema.Struct({
+	providerId: ProviderId,
+	pluginConnectionId: PluginConnectionId,
+	vendorImmutableId: VendorImmutableId,
+	revision: Revision,
+	sourceUrl: Schema.Union([SourceUrl, Schema.Null]),
+	firstObservedAt: UtcTimestamp,
+	lastObservedAt: UtcTimestamp,
+	synchronizedAt: UtcTimestamp,
+	normalizationSchemaVersion: NormalizationSchemaVersion
+}).check(Schema.makeFilter((sourceRevision) => {
+	if (DateTime.toEpochMillis(sourceRevision.firstObservedAt) > DateTime.toEpochMillis(sourceRevision.lastObservedAt)) return {
+		path: ["lastObservedAt"],
+		issue: "lastObservedAt must not precede firstObservedAt"
+	};
+	return DateTime.toEpochMillis(sourceRevision.lastObservedAt) <= DateTime.toEpochMillis(sourceRevision.synchronizedAt) ? void 0 : {
+		path: ["synchronizedAt"],
+		issue: "synchronizedAt must not precede lastObservedAt"
+	};
+})).annotate({ identifier: "SourceRevision" });
+//#endregion
+//#region src/domain/freshness.ts
+var StaleAfterSeconds = Schema$1.Int.check(Schema$1.isGreaterThan(0));
+var SafeHealthMessage = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isMinLength(1), Schema$1.isMaxLength(500));
+/** Stable failure classes exposed by plugin health without leaking raw causes. */
+var PluginFailureClass = Schema$1.Literals([
+	"authentication",
+	"authorization",
+	"rate-limit",
+	"timeout",
+	"malformed-response",
+	"outage",
+	"unknown"
+]);
+var HealthyPluginHealth = Schema$1.TaggedStruct("healthy", { checkedAt: UtcTimestamp });
+var DegradedPluginHealth = Schema$1.TaggedStruct("degraded", {
+	checkedAt: UtcTimestamp,
+	failureClass: PluginFailureClass,
+	retryAt: Schema$1.NullOr(UtcTimestamp),
+	safeMessage: SafeHealthMessage
+}).check(Schema$1.makeFilter(({ checkedAt, retryAt }) => retryAt === null || DateTime$1.Order(checkedAt, retryAt) <= 0, { expected: "plugin retry time to be at or after its health check" }));
+var UnavailablePluginHealth = Schema$1.TaggedStruct("unavailable", {
+	checkedAt: UtcTimestamp,
+	failureClass: PluginFailureClass,
+	retryAt: Schema$1.NullOr(UtcTimestamp),
+	safeMessage: SafeHealthMessage
+}).check(Schema$1.makeFilter(({ checkedAt, retryAt }) => retryAt === null || DateTime$1.Order(checkedAt, retryAt) <= 0, { expected: "plugin retry time to be at or after its health check" }));
+var DisabledPluginHealth = Schema$1.TaggedStruct("disabled", { checkedAt: UtcTimestamp });
+/** Health of the plugin connection responsible for a normalized object. */
+var PluginHealth = Schema$1.Union([
+	HealthyPluginHealth,
+	DegradedPluginHealth,
+	UnavailablePluginHealth,
+	DisabledPluginHealth
+]).pipe(Schema$1.toTaggedUnion("_tag"));
+var UsablePluginHealth = Schema$1.Union([HealthyPluginHealth, DegradedPluginHealth]);
+var ProviderProvenance = Schema$1.TaggedStruct("provider", { sourceRevision: SourceRevision });
+var CachedProvenance = Schema$1.TaggedStruct("cache", {
+	cachedAt: UtcTimestamp,
+	sourceRevision: SourceRevision
+}).check(Schema$1.makeFilter(({ cachedAt, sourceRevision }) => DateTime$1.Order(sourceRevision.synchronizedAt, cachedAt) <= 0, { expected: "the cache time to be at or after source synchronization" }));
+var NoCacheProvenance = Schema$1.TaggedStruct("none", { pluginConnectionId: PluginConnectionId });
+var sourceAgeSecondsAt = (sourceObservedAt, evaluatedAt) => (DateTime$1.toEpochMillis(evaluatedAt) - DateTime$1.toEpochMillis(sourceObservedAt)) / 1e3;
+var freshnessEvaluation = { evaluatedAt: Schema$1.optional(UtcTimestamp) };
+var evaluatedAtOrHealthCheck = (evaluatedAt, pluginHealth) => evaluatedAt ?? pluginHealth.checkedAt;
+var CurrentFreshness = Schema$1.TaggedStruct("current", {
+	...freshnessEvaluation,
+	pluginHealth: UsablePluginHealth,
+	provenance: Schema$1.Union([ProviderProvenance, CachedProvenance]),
+	sourceObservedAt: UtcTimestamp,
+	staleAfterSeconds: StaleAfterSeconds,
+	synchronizedAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ evaluatedAt, pluginHealth, provenance, sourceObservedAt, staleAfterSeconds, synchronizedAt }) => DateTime$1.Equivalence(sourceObservedAt, provenance.sourceRevision.lastObservedAt) && DateTime$1.Order(provenance.sourceRevision.synchronizedAt, synchronizedAt) <= 0 && (provenance._tag === "provider" || DateTime$1.Order(provenance.cachedAt, synchronizedAt) <= 0) && DateTime$1.Order(synchronizedAt, pluginHealth.checkedAt) <= 0 && (evaluatedAt === void 0 || DateTime$1.Order(pluginHealth.checkedAt, evaluatedAt) <= 0) && sourceAgeSecondsAt(sourceObservedAt, evaluatedAtOrHealthCheck(evaluatedAt, pluginHealth)) >= 0 && sourceAgeSecondsAt(sourceObservedAt, evaluatedAtOrHealthCheck(evaluatedAt, pluginHealth)) <= staleAfterSeconds, { expected: "current source data to match its revision and remain within its stale threshold" }));
+var StaleFreshness = Schema$1.TaggedStruct("stale", {
+	...freshnessEvaluation,
+	pluginHealth: PluginHealth,
+	provenance: CachedProvenance,
+	sourceObservedAt: UtcTimestamp,
+	staleAfterSeconds: StaleAfterSeconds,
+	synchronizedAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ evaluatedAt, pluginHealth, provenance, sourceObservedAt, staleAfterSeconds, synchronizedAt }) => DateTime$1.Equivalence(sourceObservedAt, provenance.sourceRevision.lastObservedAt) && DateTime$1.Order(sourceObservedAt, synchronizedAt) <= 0 && DateTime$1.Order(provenance.cachedAt, synchronizedAt) <= 0 && DateTime$1.Order(synchronizedAt, pluginHealth.checkedAt) <= 0 && (evaluatedAt === void 0 || DateTime$1.Order(pluginHealth.checkedAt, evaluatedAt) <= 0) && sourceAgeSecondsAt(sourceObservedAt, evaluatedAtOrHealthCheck(evaluatedAt, pluginHealth)) > staleAfterSeconds, { expected: "stale cache data to be chronological and beyond its stale threshold" }));
+var MissingFreshness = Schema$1.TaggedStruct("missing", {
+	pluginHealth: HealthyPluginHealth,
+	provenance: NoCacheProvenance,
+	sourceObservedAt: Schema$1.Null,
+	staleAfterSeconds: StaleAfterSeconds,
+	synchronizedAt: UtcTimestamp
+});
+var UnavailableFreshness = Schema$1.TaggedStruct("unavailable", {
+	pluginHealth: Schema$1.Union([UnavailablePluginHealth, DisabledPluginHealth]),
+	provenance: NoCacheProvenance,
+	sourceObservedAt: Schema$1.Null,
+	staleAfterSeconds: StaleAfterSeconds,
+	synchronizedAt: Schema$1.Null
+});
+/**
+* Freshness of normalized data, preserving cached stale data while separating
+* absence from a connection that cannot currently be queried.
+*/
+var Freshness = Schema$1.Union([
+	CurrentFreshness,
+	StaleFreshness,
+	MissingFreshness,
+	UnavailableFreshness
+]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Re-evaluate persisted freshness for a read projection without rewriting its source facts. */
+var evaluateFreshnessAt = Effect$1.fn("Freshness.evaluateAt")(function* (freshness, evaluatedAt) {
+	if (freshness._tag !== "current" && freshness._tag !== "stale") return freshness;
+	const isStale = freshness._tag === "stale" || sourceAgeSecondsAt(freshness.sourceObservedAt, evaluatedAt) > freshness.staleAfterSeconds;
+	const provenance = isStale ? freshness.provenance._tag === "cache" ? freshness.provenance : {
+		_tag: "cache",
+		cachedAt: freshness.synchronizedAt,
+		sourceRevision: freshness.provenance.sourceRevision
+	} : freshness.provenance;
+	return yield* Schema$1.decodeUnknownEffect(Schema$1.toType(Freshness))({
+		...freshness,
+		_tag: isStale ? "stale" : "current",
+		evaluatedAt,
+		provenance
+	});
+});
+//#endregion
+//#region src/domain/plugins/bounds.ts
+var jsonEncoder$1 = new TextEncoder();
+var hasMaximumJsonBytes$1 = (maximumBytes) => Schema$1.makeFilter((value) => {
+	const serialized = JSON.stringify(value);
+	return serialized !== void 0 && jsonEncoder$1.encode(serialized).byteLength <= maximumBytes;
+}, { expected: `JSON encoded as at most ${maximumBytes} UTF-8 bytes` });
+/** Maximum persisted or dispatched JSON payload accepted from a plugin boundary. */
+var MaximumPluginPayloadBytes = 262144;
+/** Maximum encoded size of one atomic normalized sync page. */
+var MaximumPluginSyncPageBytes = 1048576;
+/** Maximum canonical descriptor JSON accepted before adapter construction. */
+var MaximumPluginDescriptorBytes = 61440;
+/** Bounded JSON for normalized evidence and governed-action payloads. */
+var PluginPayloadJson = Schema$1.Json.check(hasMaximumJsonBytes$1(MaximumPluginPayloadBytes)).annotate({ identifier: "PluginPayloadJson" });
+/** Applies a deterministic upper bound to an already-decoded JSON-shaped value. */
+var hasMaximumPluginJsonBytes = hasMaximumJsonBytes$1;
+//#endregion
+//#region src/domain/readiness/policy.ts
+/** Locale-independent ordering used by canonical readiness records and digests. */
+var compareReadinessText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+/** Sorted unique string-like values for deterministic assessment material. */
+var sortedReadinessUnique = (values) => Array.from(new Set(values)).sort(compareReadinessText);
+/** Whether definitions form the complete provider-neutral V1 delivery policy. */
+var readinessDefinitionsShapeIsV1 = (definitions) => {
+	const deployments = definitions.filter(({ kind }) => kind === "deployment");
+	return definitions.some(({ kind, requirement }) => kind === "execution" && requirement === "required") && definitions.some(({ kind, requirement }) => requirement === "required" && [
+		"relationship",
+		"approval",
+		"check",
+		"documentation"
+	].includes(kind)) && deployments.length === 1 && deployments[0]?.requirement === "advisory";
+};
+/** Whether definitions and observations form a complete V1 delivery policy shape. */
+var readinessPolicyShapeIsV1 = (definitions, observations) => readinessDefinitionsShapeIsV1(definitions) && observations.some(({ state }) => state._tag === "deployment");
+/** Whether one exact evidence dependency is current enough for a verdict. */
+var readinessEvidenceIsCurrent = (evidence) => evidence.freshness === "current" && evidence.validity === "valid" && (evidence.source._tag === "local" || evidence.source.health === "healthy" || evidence.source.health === "degraded");
+/** Whether every evidence dependency of an observed fact is current and valid. */
+var readinessObservationIsCurrent = (observation) => observation.evidence.length > 0 && observation.evidence.every(readinessEvidenceIsCurrent);
+/** Whether a normalized observation is semantically positive. */
+var readinessObservationIsPositive = (observation) => {
+	switch (observation.state._tag) {
+		case "relationship": return observation.state.status === "verified" || observation.state.status === "governed";
+		case "approval": return observation.state.status === "approved";
+		case "check": return observation.state.status === "passed";
+		case "execution": return observation.state.status === "succeeded";
+		case "documentation": return observation.state.status === "current";
+		case "deployment": return observation.state.status === "succeeded";
+	}
+};
+/** Machine-readable explicit-failure reason, independent of freshness. */
+var readinessFailureCode = (observation) => {
+	switch (observation.state._tag) {
+		case "relationship": return observation.state.status === "rejected" ? "relationship-rejected" : null;
+		case "approval": return observation.state.status === "rejected" ? "approval-rejected" : null;
+		case "check": return observation.state.status === "failed" ? "check-failed" : observation.state.status === "cancelled" ? "check-cancelled" : null;
+		case "execution": return observation.state.status === "failed" ? "execution-failed" : observation.state.status === "stopped" ? "execution-stopped" : null;
+		case "documentation": return null;
+		case "deployment": return observation.state.status === "failed" ? "deployment-failed" : observation.state.status === "rolled-back" ? "deployment-rolled-back" : null;
+	}
+};
+/** Machine-readable non-positive reason for one normalized observation. */
+var readinessNonPositiveCode = (observation) => {
+	switch (observation.state._tag) {
+		case "relationship": switch (observation.state.status) {
+			case "missing": return "relationship-missing";
+			case "inferred":
+			case "proposed": return "relationship-unverified";
+			case "superseded": return "relationship-superseded";
+			default: return null;
+		}
+		case "approval": switch (observation.state.status) {
+			case "missing": return "approval-missing";
+			case "pending": return "approval-pending";
+			case "expired": return "approval-expired";
+			default: return null;
+		}
+		case "check": return observation.state.status === "missing" ? "check-missing" : observation.state.status === "queued" || observation.state.status === "running" ? "check-pending" : null;
+		case "execution": return observation.state.status === "missing" ? "execution-missing" : observation.state.status === "queued" || observation.state.status === "running" ? "execution-pending" : null;
+		case "documentation": switch (observation.state.status) {
+			case "missing": return "documentation-missing";
+			case "draft": return "documentation-draft";
+			case "stale": return "documentation-stale";
+			case "superseded": return "documentation-superseded";
+			default: return null;
+		}
+		case "deployment": return null;
+	}
+};
+/** Whether this observation represents active build or check work. */
+var readinessObservationIsDeliveryActivity = (definition, observation) => definition.requirement === "required" && observation !== null && (observation.state._tag === "execution" && (observation.state.status === "queued" || observation.state.status === "running") || observation.state._tag === "check" && (observation.state.status === "queued" || observation.state.status === "running")) && readinessObservationIsCurrent(observation);
+/** Canonical semantic result retained for one fact evaluation. */
+var readinessFactResult = (definition, observation) => {
+	if (observation === null) return definition.requirement === "required" ? "gap" : "advisory";
+	if (readinessFailureCode(observation) !== null) return definition.requirement === "required" || definition.kind === "deployment" ? "failed" : "advisory";
+	if (readinessObservationIsPositive(observation) && readinessObservationIsCurrent(observation)) return "verified";
+	const code = readinessNonPositiveCode(observation);
+	if (code === "approval-pending" || code === "check-pending" || code === "execution-pending") return "pending";
+	return definition.requirement === "required" ? "gap" : "advisory";
+};
+var missingCode = (definition) => {
+	switch (definition.kind) {
+		case "relationship": return "relationship-missing";
+		case "approval": return "approval-missing";
+		case "check": return "check-missing";
+		case "execution": return "execution-missing";
+		case "documentation": return "documentation-missing";
+		case "deployment": return "deployment-missing";
+	}
+};
+var observationEvidenceIds = (observation) => observation === null ? [] : sortedReadinessUnique(observation.evidence.map(({ evidenceId }) => evidenceId));
+var factFinding = (code, definition, observation) => ({
+	code,
+	subject: {
+		_tag: "fact",
+		factId: definition.factId
+	},
+	evidenceIds: observationEvidenceIds(observation)
+});
+var evidenceFinding = (evidence, definition) => {
+	const code = evidence.validity === "expired" ? "evidence-expired" : evidence.freshness === "stale" ? "source-stale" : evidence.freshness === "missing" ? "source-missing" : evidence.freshness === "unavailable" || evidence.source._tag === "plugin" && (evidence.source.health === "unavailable" || evidence.source.health === "disabled") ? "source-unavailable" : evidence.source._tag === "plugin" && evidence.source.health === "degraded" ? "plugin-degraded" : null;
+	if (code === null) return null;
+	return {
+		code,
+		subject: evidence.source._tag === "plugin" ? {
+			_tag: "source",
+			pluginConnectionId: evidence.source.pluginConnectionId
+		} : {
+			_tag: "fact",
+			factId: definition.factId
+		},
+		evidenceIds: [evidence.evidenceId]
+	};
+};
+/** Stable sort/deduplication key for readiness findings. */
+var readinessFindingKey = (finding) => {
+	const subject = finding.subject._tag === "fact" ? finding.subject.factId : finding.subject._tag === "source" ? finding.subject.pluginConnectionId : "candidate";
+	return `${finding.code}:${finding.subject._tag}:${subject}:${finding.evidenceIds.join(",")}`;
+};
+var normalizedFindings = (findings) => {
+	const byKey = new Map(findings.map((finding) => [readinessFindingKey(finding), finding]));
+	return Array.from(byKey.values()).sort((left, right) => compareReadinessText(readinessFindingKey(left), readinessFindingKey(right)));
+};
+/** Exact blocker, warning, and gap sets implied by retained fact evaluations. */
+var deriveReadinessFindings = (facts, complete) => {
+	const blockers = [];
+	const warnings = [];
+	const gaps = complete ? [] : [{
+		code: "input-incomplete",
+		subject: { _tag: "candidate" },
+		evidenceIds: []
+	}];
+	for (const { definition, observation } of facts) {
+		if (observation === null) {
+			if (definition.requirement === "required") gaps.push(factFinding(missingCode(definition), definition, observation));
+			continue;
+		}
+		const failure = readinessFailureCode(observation);
+		if (failure !== null) {
+			const finding = factFinding(failure, definition, observation);
+			if (definition.requirement === "required" || definition.kind === "deployment") blockers.push(finding);
+			else warnings.push(finding);
+		} else if (!readinessObservationIsPositive(observation) || !readinessObservationIsCurrent(observation)) {
+			const code = readinessNonPositiveCode(observation);
+			if (code !== null) {
+				const finding = factFinding(code, definition, observation);
+				const active = code === "approval-pending" || code === "check-pending" || code === "execution-pending";
+				if (active || definition.requirement === "advisory") warnings.push(finding);
+				if (!active && definition.requirement === "required") gaps.push(finding);
+			}
+		}
+		for (const evidence of observation.evidence) {
+			const finding = evidenceFinding(evidence, definition);
+			if (finding === null) continue;
+			warnings.push(finding);
+			if (definition.requirement === "required" && finding.code !== "plugin-degraded" && failure === null) gaps.push(finding);
+		}
+	}
+	return {
+		blockers: normalizedFindings(blockers),
+		warnings: normalizedFindings(warnings),
+		gaps: normalizedFindings(gaps)
+	};
+};
+var freshnessRank = {
+	current: 0,
+	stale: 1,
+	missing: 2,
+	unavailable: 3
+};
+var healthRank = {
+	healthy: 0,
+	degraded: 1,
+	unavailable: 2,
+	disabled: 3
+};
+/** Exact worst-state summaries for plugin evidence retained by facts. */
+var deriveReadinessSourceSummaries = (facts) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const evidence of facts.flatMap(({ observation }) => observation?.evidence ?? [])) {
+		if (evidence.source._tag !== "plugin") continue;
+		const current = grouped.get(evidence.source.pluginConnectionId) ?? [];
+		current.push(evidence);
+		grouped.set(evidence.source.pluginConnectionId, current);
+	}
+	return Array.from(grouped.entries()).map(([pluginConnectionId, evidence]) => ({
+		pluginConnectionId,
+		freshness: evidence.reduce((worst, item) => freshnessRank[item.freshness] > freshnessRank[worst] ? item.freshness : worst, "current"),
+		health: evidence.reduce((worst, item) => {
+			const health = item.source._tag === "plugin" ? item.source.health : "healthy";
+			return healthRank[health] > healthRank[worst] ? health : worst;
+		}, "healthy"),
+		evidenceIds: sortedReadinessUnique(evidence.map(({ evidenceId }) => evidenceId))
+	})).sort((left, right) => compareReadinessText(left.pluginConnectionId, right.pluginConnectionId));
+};
+/** Earliest evidence freshness boundary retained by one environment assessment. */
+var deriveReadinessNextEvaluationAt = (facts) => facts.flatMap(({ observation }) => observation?.evidence ?? []).flatMap(({ reevaluateAt }) => reevaluateAt === null ? [] : [reevaluateAt]).reduce((earliest, boundary) => earliest === null || DateTime$1.Order(boundary, earliest) < 0 ? boundary : earliest, null);
+var observationProgress = (observation) => {
+	if (observation?.state._tag === "execution" || observation?.state._tag === "deployment") return observation.state.progress;
+	return null;
+};
+var stageEvidence = (facts) => sortedReadinessUnique(facts.flatMap(({ evidenceIds }) => evidenceIds));
+/** Derive the exact three delivery stages from canonical fact evaluations. */
+var deriveReadinessStages = (facts) => {
+	const build = facts.filter(({ definition }) => definition.kind === "execution");
+	const verify = facts.filter(({ definition }) => [
+		"relationship",
+		"approval",
+		"check",
+		"documentation"
+	].includes(definition.kind));
+	const production = facts.filter(({ definition }) => definition.kind === "deployment");
+	const deployment = production.find(({ observation }) => observation?.state._tag === "deployment")?.observation;
+	const requiredBuild = build.filter(({ definition }) => definition.requirement === "required");
+	const requiredVerify = verify.filter(({ definition }) => definition.requirement === "required");
+	const activeBuild = requiredBuild.filter(({ observation }) => observation !== null && observation.state._tag === "execution" && (observation.state.status === "queued" || observation.state.status === "running") && readinessObservationIsCurrent(observation));
+	const runningBuild = activeBuild.find(({ observation }) => observation?.state._tag === "execution" && observation.state.status === "running");
+	const queuedBuild = activeBuild.find(({ observation }) => observation?.state._tag === "execution" && observation.state.status === "queued");
+	const activeVerify = requiredVerify.find(({ observation }) => observation !== null && (observation.state._tag === "check" && (observation.state.status === "queued" || observation.state.status === "running") || observation.state._tag === "approval" && observation.state.status === "pending") && readinessObservationIsCurrent(observation));
+	const buildState = build.some(({ result }) => result === "failed") ? "failed" : runningBuild !== void 0 ? "running" : queuedBuild !== void 0 ? "queued" : requiredBuild.every(({ result }) => result === "verified") ? "succeeded" : build.some(({ observation }) => observation !== null) ? "held" : "not-started";
+	const verifyState = verify.some(({ result }) => result === "failed") ? "failed" : activeVerify !== void 0 ? "pending" : requiredVerify.every(({ result }) => result === "verified") ? "passed" : verify.some(({ observation }) => observation !== null) ? "held" : "not-started";
+	let productionState = "not-started";
+	if (deployment?.state._tag === "deployment") {
+		const current = readinessObservationIsCurrent(deployment);
+		switch (deployment.state.status) {
+			case "failed":
+				productionState = "failed";
+				break;
+			case "rolled-back":
+				productionState = "rolled-back";
+				break;
+			case "deploying":
+				productionState = current ? "deploying" : "held";
+				break;
+			case "pending":
+				productionState = current ? "waiting" : "held";
+				break;
+			case "succeeded":
+				productionState = current ? "succeeded" : "held";
+				break;
+			case "not-started":
+				productionState = current ? "not-started" : "held";
+				break;
+		}
+	}
+	return {
+		build: {
+			state: buildState,
+			factIds: sortedReadinessUnique(build.map(({ definition }) => definition.factId)),
+			evidenceIds: stageEvidence(build),
+			progress: observationProgress(runningBuild?.observation ?? queuedBuild?.observation ?? void 0)
+		},
+		verify: {
+			state: verifyState,
+			factIds: sortedReadinessUnique(verify.map(({ definition }) => definition.factId)),
+			evidenceIds: stageEvidence(verify),
+			progress: null
+		},
+		production: {
+			state: productionState,
+			factIds: sortedReadinessUnique(production.map(({ definition }) => definition.factId)),
+			evidenceIds: stageEvidence(production),
+			progress: observationProgress(deployment ?? void 0)
+		}
+	};
+};
+/** Derive the canonical verdict from facts, findings, and exact stage state. */
+var deriveEnvironmentReadinessVerdict = (input) => {
+	if (input.blockers.length > 0) return "blocked";
+	if (input.stages.production.state === "deploying") return "deploying";
+	if (input.facts.some(({ definition, observation }) => readinessObservationIsDeliveryActivity(definition, observation))) return "building";
+	if (input.gaps.length > 0 || input.stages.build.state === "held" || input.stages.verify.state === "held" || input.stages.production.state === "held" || input.facts.some(({ definition, result }) => definition.requirement === "required" && result !== "verified")) return "held";
+	return input.stages.production.state === "succeeded" ? "shipped" : "ready";
+};
+/** Exact merged findings implied by retained environment summaries. */
+var deriveReleaseReadinessFindings = (environments) => ({
+	blockers: normalizedFindings(environments.flatMap(({ blockers }) => blockers)),
+	warnings: normalizedFindings(environments.flatMap(({ warnings }) => warnings)),
+	gaps: normalizedFindings(environments.flatMap(({ gaps }) => gaps))
+});
+/** Exact worst-state source summaries implied by retained environments. */
+var deriveReleaseReadinessSourceSummaries = (environments) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const summary of environments.flatMap(({ sourceFreshness }) => sourceFreshness)) {
+		const current = grouped.get(summary.pluginConnectionId) ?? [];
+		current.push(summary);
+		grouped.set(summary.pluginConnectionId, current);
+	}
+	return Array.from(grouped.entries()).map(([pluginConnectionId, summaries]) => ({
+		pluginConnectionId,
+		freshness: summaries.reduce((worst, summary) => freshnessRank[summary.freshness] > freshnessRank[worst] ? summary.freshness : worst, "current"),
+		health: summaries.reduce((worst, summary) => healthRank[summary.health] > healthRank[worst] ? summary.health : worst, "healthy"),
+		evidenceIds: sortedReadinessUnique(summaries.flatMap(({ evidenceIds }) => evidenceIds))
+	})).sort((left, right) => compareReadinessText(left.pluginConnectionId, right.pluginConnectionId));
+};
+/** Earliest child freshness boundary implied by retained environments. */
+var deriveReleaseReadinessNextEvaluationAt = (environments) => environments.reduce((earliest, { nextEvaluationAt }) => {
+	if (nextEvaluationAt === null) return earliest;
+	return earliest === null || DateTime$1.Order(nextEvaluationAt, earliest) < 0 ? nextEvaluationAt : earliest;
+}, null);
+var firstReleaseProgress = (environments, stage) => environments.slice().sort((left, right) => compareReadinessText(left.environmentId, right.environmentId)).find((environment) => environment.stages[stage].progress !== null)?.stages[stage].progress ?? null;
+/** Exact three-stage roll-up implied by retained environment summaries. */
+var deriveReleaseReadinessStages = (environments) => {
+	const buildStates = environments.map(({ stages }) => stages.build.state);
+	const verifyStates = environments.map(({ stages }) => stages.verify.state);
+	const productionStates = environments.map(({ stages }) => stages.production.state);
+	const buildState = buildStates.includes("failed") ? "failed" : buildStates.includes("running") ? "running" : buildStates.includes("queued") ? "queued" : buildStates.every((state) => state === "succeeded") ? "succeeded" : buildStates.every((state) => state === "not-started") ? "not-started" : "held";
+	const verifyState = verifyStates.includes("failed") ? "failed" : verifyStates.includes("pending") ? "pending" : verifyStates.every((state) => state === "passed") ? "passed" : verifyStates.every((state) => state === "not-started") ? "not-started" : "held";
+	let productionState = "not-started";
+	if (productionStates.includes("failed")) productionState = "failed";
+	else if (productionStates.includes("rolled-back")) productionState = "rolled-back";
+	else if (productionStates.includes("deploying")) productionState = "deploying";
+	else if (productionStates.includes("held")) productionState = "held";
+	else if (productionStates.every((state) => state === "succeeded")) productionState = "succeeded";
+	else if (productionStates.some((state) => state === "waiting" || state === "succeeded")) productionState = "waiting";
+	return {
+		build: {
+			state: buildState,
+			factIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.build.factIds)),
+			evidenceIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.build.evidenceIds)),
+			progress: firstReleaseProgress(environments, "build")
+		},
+		verify: {
+			state: verifyState,
+			factIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.verify.factIds)),
+			evidenceIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.verify.evidenceIds)),
+			progress: null
+		},
+		production: {
+			state: productionState,
+			factIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.production.factIds)),
+			evidenceIds: sortedReadinessUnique(environments.flatMap(({ stages }) => stages.production.evidenceIds)),
+			progress: firstReleaseProgress(environments, "production")
+		}
+	};
+};
+/** Canonical cross-environment precedence for release readiness. */
+var deriveReleaseReadinessVerdict = (environments) => {
+	const verdicts = environments.map(({ verdict }) => verdict);
+	if (verdicts.includes("blocked")) return "blocked";
+	if (verdicts.includes("deploying")) return "deploying";
+	if (verdicts.includes("building")) return "building";
+	if (verdicts.includes("held")) return "held";
+	return verdicts.every((verdict) => verdict === "shipped") ? "shipped" : "ready";
+};
+var sameStringArray = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+var progressIsEqual = (left, right) => left === null || right === null ? left === right : left._tag === "count" && right._tag === "count" ? left.completed === right.completed && left.total === right.total : left._tag === "percent" && right._tag === "percent" && left.value === right.value;
+/** Structural equality for canonical stage records without serialization shortcuts. */
+var readinessStagesAreEqual = (left, right) => left.build.state === right.build.state && sameStringArray(left.build.factIds, right.build.factIds) && sameStringArray(left.build.evidenceIds, right.build.evidenceIds) && progressIsEqual(left.build.progress, right.build.progress) && left.verify.state === right.verify.state && sameStringArray(left.verify.factIds, right.verify.factIds) && sameStringArray(left.verify.evidenceIds, right.verify.evidenceIds) && progressIsEqual(left.verify.progress, right.verify.progress) && left.production.state === right.production.state && sameStringArray(left.production.factIds, right.production.factIds) && sameStringArray(left.production.evidenceIds, right.production.evidenceIds) && progressIsEqual(left.production.progress, right.production.progress);
+//#endregion
+//#region src/domain/readiness/model.ts
+var boundedIdentifier$1 = (maximumLength, identifier) => Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isMinLength(1), Schema$1.isMaxLength(maximumLength)).annotate({ identifier });
+var unique = (values) => new Set(values).size === values.length;
+var sameOrderedStrings = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+var isCanonicalStrings = (values) => sameOrderedStrings(values, sortedReadinessUnique(values));
+/** Maximum exact evidence dependencies in one environment or release assessment. */
+var MAX_READINESS_EVIDENCE_REFERENCES = 512;
+/** Maximum blockers, warnings, or gaps retained in one assessment. */
+var MAX_READINESS_FINDINGS = 1025;
+/** Stable identity of one V1 readiness fact, independent of display copy. */
+var ReadinessFactId = boundedIdentifier$1(200, "ReadinessFactId").pipe(Schema$1.check(Schema$1.isPattern(/^[a-z0-9][a-z0-9._:/-]*$/u)), Schema$1.brand("ReadinessFactId"));
+/** Hash of the complete canonical candidate input assembled by the application layer. */
+var ReadinessCandidateDigest = Schema$1.String.check(Schema$1.isPattern(/^sha256:[0-9a-f]{64}$/u)).pipe(Schema$1.brand("ReadinessCandidateDigest"));
+/** Positive version of the rule policy used for one assessment. */
+var ReadinessRuleVersion = Schema$1.Int.check(Schema$1.isGreaterThan(0)).pipe(Schema$1.brand("ReadinessRuleVersion"));
+/** Positive version of the evaluator implementation used for one assessment. */
+var ReadinessDerivationVersion = Schema$1.Int.check(Schema$1.isGreaterThan(0)).pipe(Schema$1.brand("ReadinessDerivationVersion"));
+/** V1 readiness policy version. */
+var READINESS_RULE_VERSION_V1 = ReadinessRuleVersion.make(1);
+/** V1 evaluator implementation version. */
+var READINESS_DERIVATION_VERSION_V1 = ReadinessDerivationVersion.make(1);
+/** Positive source revision of the release candidate. */
+var ReadinessReleaseRevision = Schema$1.Int.check(Schema$1.isGreaterThan(0));
+/** Bounded immutable artifact revision, such as a commit or image digest. */
+var ReadinessArtifactRevision = boundedIdentifier$1(512, "ReadinessArtifactRevision");
+/** Stable identity of a readiness rule set. */
+var ReadinessRuleId = boundedIdentifier$1(200, "ReadinessRuleId");
+/** Explicit release or target-environment scope of an assessment. */
+var ReadinessScope = Schema$1.TaggedUnion({
+	release: { releaseId: ReleaseId },
+	environment: {
+		releaseId: ReleaseId,
+		environmentId: EnvironmentId
+	}
+});
+var CandidateIdentityBase = {
+	workspaceId: WorkspaceId,
+	releaseRevision: ReadinessReleaseRevision,
+	artifactRevision: ReadinessArtifactRevision,
+	digest: ReadinessCandidateDigest
+};
+/** Immutable target-environment candidate whose complete material is digest-bound. */
+var EnvironmentReadinessCandidateIdentity = Schema$1.Struct({
+	...CandidateIdentityBase,
+	scope: Schema$1.TaggedStruct("environment", {
+		releaseId: ReleaseId,
+		environmentId: EnvironmentId
+	})
+});
+/** Immutable release-scope candidate whose child assessments are digest-bound. */
+var ReleaseReadinessCandidateIdentity = Schema$1.Struct({
+	...CandidateIdentityBase,
+	scope: Schema$1.TaggedStruct("release", { releaseId: ReleaseId })
+});
+/** Immutable deployable candidate whose complete material is bound by a digest. */
+var ReadinessCandidateIdentity = Schema$1.Union([EnvironmentReadinessCandidateIdentity, ReleaseReadinessCandidateIdentity]);
+/** Stable rule-set identity and content digest retained with every assessment. */
+var ReadinessRuleReference = Schema$1.Struct({
+	ruleId: ReadinessRuleId,
+	version: ReadinessRuleVersion,
+	digest: ReadinessCandidateDigest
+});
+/** Canonical six-state readiness verdict. */
+var ReadinessVerdict = Schema$1.Literals([
+	"blocked",
+	"ready",
+	"deploying",
+	"building",
+	"shipped",
+	"held"
+]);
+/** Closed provider-neutral fact categories understood by the V1 evaluator. */
+var ReadinessFactKind = Schema$1.Literals([
+	"relationship",
+	"approval",
+	"check",
+	"execution",
+	"documentation",
+	"deployment"
+]);
+/** Whether a fact gates readiness or only contributes context. */
+var ReadinessFactRequirement = Schema$1.Literals(["required", "advisory"]);
+/** Policy definition that makes missing observations explicit rather than successful by absence. */
+var ReadinessFactDefinition = Schema$1.Struct({
+	factId: ReadinessFactId,
+	kind: ReadinessFactKind,
+	requirement: ReadinessFactRequirement
+});
+var CountProgress = Schema$1.TaggedStruct("count", {
+	completed: Schema$1.Int.check(Schema$1.isGreaterThanOrEqualTo(0)),
+	total: Schema$1.Int.check(Schema$1.isGreaterThan(0))
+}).check(Schema$1.makeFilter(({ completed, total }) => completed <= total, { expected: "readiness progress completed count not to exceed its total" }));
+var PercentProgress = Schema$1.TaggedStruct("percent", { value: Schema$1.Number.check(Schema$1.makeFilter((value) => value >= 0 && value <= 100, { expected: "readiness progress percentage between zero and one hundred" })) });
+/** Typed progress for builds and deployments without copied display text. */
+var ReadinessProgress = Schema$1.Union([CountProgress, PercentProgress]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Closed normalized observation states; vendor strings never enter rule evaluation. */
+var ReadinessFactState = Schema$1.TaggedUnion({
+	relationship: { status: Schema$1.Literals([
+		"missing",
+		"inferred",
+		"proposed",
+		"verified",
+		"governed",
+		"rejected",
+		"superseded"
+	]) },
+	approval: { status: Schema$1.Literals([
+		"missing",
+		"pending",
+		"approved",
+		"rejected",
+		"expired"
+	]) },
+	check: { status: Schema$1.Literals([
+		"missing",
+		"queued",
+		"running",
+		"passed",
+		"failed",
+		"cancelled"
+	]) },
+	execution: {
+		status: Schema$1.Literals([
+			"missing",
+			"queued",
+			"running",
+			"succeeded",
+			"failed",
+			"stopped"
+		]),
+		progress: Schema$1.NullOr(ReadinessProgress)
+	},
+	documentation: { status: Schema$1.Literals([
+		"missing",
+		"draft",
+		"current",
+		"stale",
+		"superseded"
+	]) },
+	deployment: {
+		status: Schema$1.Literals([
+			"not-started",
+			"pending",
+			"deploying",
+			"succeeded",
+			"failed",
+			"rolled-back"
+		]),
+		progress: Schema$1.NullOr(ReadinessProgress)
+	}
+});
+/** Exact origin of evidence used for dependency tracking and plugin-health invalidation. */
+var ReadinessEvidenceSource = Schema$1.TaggedUnion({
+	plugin: {
+		pluginConnectionId: PluginConnectionId,
+		health: Schema$1.Literals([
+			"healthy",
+			"degraded",
+			"unavailable",
+			"disabled"
+		])
+	},
+	local: { origin: Schema$1.Literals([
+		"human",
+		"agent",
+		"system"
+	]) }
+});
+/** Exact evidence dependency and its freshness at the injected evaluation boundary. */
+var ReadinessEvidenceReference = Schema$1.Struct({
+	evidenceId: EvidenceId,
+	source: ReadinessEvidenceSource,
+	freshness: Schema$1.Literals([
+		"current",
+		"stale",
+		"missing",
+		"unavailable"
+	]),
+	validity: Schema$1.Literals(["valid", "expired"]),
+	reevaluateAt: Schema$1.NullOr(UtcTimestamp)
+});
+var stateRequiresEvidence = (state) => state.status !== "missing";
+/** One normalized observation for a policy-defined fact. */
+var ReadinessFactObservation = Schema$1.Struct({
+	factId: ReadinessFactId,
+	state: ReadinessFactState,
+	evidence: Schema$1.Array(ReadinessEvidenceReference).check(Schema$1.isMaxLength(128))
+}).check(Schema$1.makeFilter(({ evidence }) => unique(evidence.map(({ evidenceId }) => evidenceId)), { expected: "readiness observation evidence identifiers to be unique" }), Schema$1.makeFilter(({ evidence, state }) => !stateRequiresEvidence(state) || evidence.length > 0, { expected: "a non-empty readiness observation state to reference evidence" }));
+/** Stable machine-readable reason emitted by the V1 rule policy. */
+var ReadinessFindingCode = Schema$1.Literals([
+	"input-incomplete",
+	"relationship-missing",
+	"relationship-unverified",
+	"relationship-rejected",
+	"relationship-superseded",
+	"approval-missing",
+	"approval-pending",
+	"approval-rejected",
+	"approval-expired",
+	"check-missing",
+	"check-pending",
+	"check-failed",
+	"check-cancelled",
+	"execution-missing",
+	"execution-pending",
+	"execution-failed",
+	"execution-stopped",
+	"documentation-missing",
+	"documentation-draft",
+	"documentation-stale",
+	"documentation-superseded",
+	"deployment-missing",
+	"deployment-failed",
+	"deployment-rolled-back",
+	"source-stale",
+	"source-missing",
+	"source-unavailable",
+	"plugin-degraded",
+	"evidence-expired"
+]);
+/** Stable subject of a readiness finding. */
+var ReadinessFindingSubject = Schema$1.TaggedUnion({
+	fact: { factId: ReadinessFactId },
+	source: { pluginConnectionId: PluginConnectionId },
+	candidate: {}
+});
+/** One blocker, warning, or evidence gap without presentation prose. */
+var ReadinessFinding = Schema$1.Struct({
+	code: ReadinessFindingCode,
+	subject: ReadinessFindingSubject,
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(128))
+}).check(Schema$1.makeFilter(({ evidenceIds }) => unique(evidenceIds), { expected: "readiness finding evidence identifiers to be unique" }));
+/** Outcome retained for every evaluated fact. */
+var ReadinessFactResult = Schema$1.Literals([
+	"verified",
+	"pending",
+	"failed",
+	"gap",
+	"advisory"
+]);
+/** Auditable fact evaluation retained in an environment assessment. */
+var ReadinessFactEvaluation = Schema$1.Struct({
+	definition: ReadinessFactDefinition,
+	observation: Schema$1.NullOr(ReadinessFactObservation),
+	result: ReadinessFactResult,
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(128))
+}).check(Schema$1.makeFilter(({ definition, evidenceIds, observation, result }) => observation === null ? evidenceIds.length === 0 && result === readinessFactResult(definition, observation) : observation.factId === definition.factId && observation.state._tag === definition.kind && sameOrderedStrings(evidenceIds, sortedReadinessUnique(observation.evidence.map(({ evidenceId }) => evidenceId))) && result === readinessFactResult(definition, observation), { expected: "readiness fact evaluation to match its definition, observation, evidence, and result" }));
+/** Worst current source state for one contributing plugin connection. */
+var ReadinessSourceSummary = Schema$1.Struct({
+	pluginConnectionId: PluginConnectionId,
+	freshness: Schema$1.Literals([
+		"current",
+		"stale",
+		"missing",
+		"unavailable"
+	]),
+	health: Schema$1.Literals([
+		"healthy",
+		"degraded",
+		"unavailable",
+		"disabled"
+	]),
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(512))
+});
+var ReadinessStageBase = {
+	factIds: Schema$1.Array(ReadinessFactId).check(Schema$1.isMaxLength(512)),
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(512)),
+	progress: Schema$1.NullOr(ReadinessProgress)
+};
+/** Server-derived Build stage. */
+var BuildReadinessStage = Schema$1.Struct({
+	...ReadinessStageBase,
+	state: Schema$1.Literals([
+		"not-started",
+		"queued",
+		"running",
+		"succeeded",
+		"failed",
+		"held"
+	])
+});
+/** Server-derived Verify stage. */
+var VerifyReadinessStage = Schema$1.Struct({
+	...ReadinessStageBase,
+	state: Schema$1.Literals([
+		"not-started",
+		"pending",
+		"passed",
+		"failed",
+		"held"
+	])
+});
+/** Server-derived Production stage. */
+var ProductionReadinessStage = Schema$1.Struct({
+	...ReadinessStageBase,
+	state: Schema$1.Literals([
+		"not-started",
+		"waiting",
+		"deploying",
+		"succeeded",
+		"failed",
+		"rolled-back",
+		"held"
+	])
+});
+/** Exactly three authoritative delivery stages. */
+var ReadinessStages = Schema$1.Struct({
+	build: BuildReadinessStage,
+	verify: VerifyReadinessStage,
+	production: ProductionReadinessStage
+});
+/** Complete, decoded input for one environment evaluation. */
+var EnvironmentReadinessEvaluationInput = Schema$1.Struct({
+	assessmentId: ReadinessAssessmentId,
+	previousAssessmentId: Schema$1.NullOr(ReadinessAssessmentId),
+	candidate: EnvironmentReadinessCandidateIdentity,
+	rule: ReadinessRuleReference,
+	derivationVersion: ReadinessDerivationVersion,
+	evaluatedAt: UtcTimestamp,
+	complete: Schema$1.Boolean,
+	definitions: Schema$1.Array(ReadinessFactDefinition).check(Schema$1.isMaxLength(512)),
+	observations: Schema$1.Array(ReadinessFactObservation).check(Schema$1.isMaxLength(512))
+}).check(Schema$1.makeFilter(({ assessmentId, previousAssessmentId }) => previousAssessmentId === null || previousAssessmentId !== assessmentId, { expected: "an environment readiness input not to supersede itself" }), Schema$1.makeFilter(({ derivationVersion }) => derivationVersion === READINESS_DERIVATION_VERSION_V1, { expected: "the V1 environment evaluator to use derivation version 1" }), Schema$1.makeFilter(({ definitions }) => unique(definitions.map(({ factId }) => factId)), { expected: "readiness fact definitions to have unique identities" }), Schema$1.makeFilter(({ observations }) => unique(observations.map(({ factId }) => factId)), { expected: "readiness fact observations to have unique identities" }), Schema$1.makeFilter(({ observations }) => observations.reduce((total, observation) => total + observation.evidence.length, 0) <= 512, { expected: "environment readiness input to fit its bounded assessment evidence set" }), Schema$1.makeFilter(({ definitions, observations }) => {
+	const definitionsById = new Map(definitions.map((definition) => [definition.factId, definition]));
+	return observations.every((observation) => definitionsById.get(observation.factId)?.kind === observation.state._tag);
+}, { expected: "readiness observations to match one policy fact of the same kind" }), Schema$1.makeFilter(({ definitions, observations }) => readinessPolicyShapeIsV1(definitions, observations), { expected: "environment readiness input to contain the complete V1 policy shape" }));
+var factEvidenceIds = (facts) => sortedReadinessUnique(facts.flatMap(({ evidenceIds }) => evidenceIds));
+var factsOfKinds = (facts, kinds) => facts.filter(({ definition }) => kinds.includes(definition.kind));
+var stageMatchesFacts = (stage, facts) => sameOrderedStrings(stage.factIds, sortedReadinessUnique(facts.map(({ definition }) => definition.factId))) && sameOrderedStrings(stage.evidenceIds, factEvidenceIds(facts));
+var canonicalAssessmentCollections = (assessment) => {
+	const evidence = new Set(assessment.evidenceIds);
+	const findings = [
+		assessment.blockers,
+		assessment.warnings,
+		assessment.gaps
+	];
+	return isCanonicalStrings(assessment.evidenceIds) && findings.every((items) => sameOrderedStrings(items.map(readinessFindingKey), items.map(readinessFindingKey).sort(compareReadinessText)) && unique(items.map(readinessFindingKey)) && items.every(({ evidenceIds }) => isCanonicalStrings(evidenceIds) && evidenceIds.every((evidenceId) => evidence.has(evidenceId)))) && isCanonicalStrings(assessment.stages.build.factIds) && isCanonicalStrings(assessment.stages.build.evidenceIds) && isCanonicalStrings(assessment.stages.verify.factIds) && isCanonicalStrings(assessment.stages.verify.evidenceIds) && isCanonicalStrings(assessment.stages.production.factIds) && isCanonicalStrings(assessment.stages.production.evidenceIds) && isCanonicalStrings(assessment.sourceFreshness.map(({ pluginConnectionId }) => pluginConnectionId)) && assessment.sourceFreshness.every(({ evidenceIds }) => isCanonicalStrings(evidenceIds) && evidenceIds.every((evidenceId) => evidence.has(evidenceId)));
+};
+var AssessmentBase = {
+	assessmentId: ReadinessAssessmentId,
+	previousAssessmentId: Schema$1.NullOr(ReadinessAssessmentId),
+	candidate: ReadinessCandidateIdentity,
+	rule: ReadinessRuleReference,
+	derivationVersion: ReadinessDerivationVersion,
+	evaluatedAt: UtcTimestamp,
+	nextEvaluationAt: Schema$1.NullOr(UtcTimestamp),
+	verdict: ReadinessVerdict,
+	stages: ReadinessStages,
+	blockers: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	warnings: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	gaps: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	sourceFreshness: Schema$1.Array(ReadinessSourceSummary).check(Schema$1.isMaxLength(512)),
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(512))
+};
+/** Immutable environment assessment retaining exact facts and evidence. */
+var EnvironmentReadinessAssessment = Schema$1.Struct({
+	...AssessmentBase,
+	_tag: Schema$1.Literal("environment"),
+	candidate: EnvironmentReadinessCandidateIdentity,
+	inputComplete: Schema$1.Boolean,
+	facts: Schema$1.Array(ReadinessFactEvaluation).check(Schema$1.isMaxLength(512)),
+	requiredFactIds: Schema$1.Array(ReadinessFactId).check(Schema$1.isMaxLength(512)),
+	verifiedFactIds: Schema$1.Array(ReadinessFactId).check(Schema$1.isMaxLength(512))
+}).check(Schema$1.makeFilter(({ derivationVersion }) => derivationVersion === READINESS_DERIVATION_VERSION_V1, { expected: "an environment readiness assessment derived by V1" }), Schema$1.makeFilter(({ assessmentId, previousAssessmentId }) => previousAssessmentId === null || previousAssessmentId !== assessmentId, { expected: "a readiness assessment not to supersede itself" }), Schema$1.makeFilter(({ facts }) => isCanonicalStrings(facts.map(({ definition }) => definition.factId)), { expected: "environment readiness facts to have canonical unique identities" }), Schema$1.makeFilter(({ facts }) => readinessPolicyShapeIsV1(facts.map(({ definition }) => definition), facts.flatMap(({ observation }) => observation === null ? [] : [observation])), { expected: "environment readiness assessment to retain the complete V1 policy shape" }), Schema$1.makeFilter(({ facts, requiredFactIds }) => sameOrderedStrings(requiredFactIds, sortedReadinessUnique(facts.filter(({ definition }) => definition.requirement === "required").map(({ definition }) => definition.factId))), { expected: "environment readiness required facts to match retained evaluations" }), Schema$1.makeFilter(({ facts, verifiedFactIds }) => sameOrderedStrings(verifiedFactIds, sortedReadinessUnique(facts.filter(({ result }) => result === "verified").map(({ definition }) => definition.factId))), { expected: "environment readiness verified facts to match retained evaluations" }), Schema$1.makeFilter(({ blockers, facts, gaps, inputComplete, warnings }) => {
+	const expected = deriveReadinessFindings(facts, inputComplete);
+	return sameOrderedStrings(blockers.map(readinessFindingKey), expected.blockers.map(readinessFindingKey)) && sameOrderedStrings(warnings.map(readinessFindingKey), expected.warnings.map(readinessFindingKey)) && sameOrderedStrings(gaps.map(readinessFindingKey), expected.gaps.map(readinessFindingKey));
+}, { expected: "environment readiness findings to match retained fact evaluations" }), Schema$1.makeFilter(({ evidenceIds, facts }) => sameOrderedStrings(evidenceIds, factEvidenceIds(facts)), { expected: "environment readiness evidence to match retained fact dependencies" }), Schema$1.makeFilter(({ facts, stages }) => {
+	const build = factsOfKinds(facts, ["execution"]);
+	const verify = factsOfKinds(facts, [
+		"relationship",
+		"approval",
+		"check",
+		"documentation"
+	]);
+	const production = factsOfKinds(facts, ["deployment"]);
+	return stageMatchesFacts(stages.build, build) && stageMatchesFacts(stages.verify, verify) && stageMatchesFacts(stages.production, production);
+}, { expected: "environment readiness stages to retain their exact fact and evidence dependencies" }), Schema$1.makeFilter(({ facts, stages }) => readinessStagesAreEqual(stages, deriveReadinessStages(facts)), { expected: "environment readiness stage states to match retained fact evaluations" }), Schema$1.makeFilter(({ facts, sourceFreshness }) => {
+	const expected = deriveReadinessSourceSummaries(facts);
+	return sourceFreshness.length === expected.length && sourceFreshness.every((summary, index) => {
+		const item = expected[index];
+		return item !== void 0 && summary.pluginConnectionId === item.pluginConnectionId && summary.freshness === item.freshness && summary.health === item.health && sameOrderedStrings(summary.evidenceIds, item.evidenceIds);
+	});
+}, { expected: "environment readiness source summaries to match retained evidence" }), Schema$1.makeFilter(({ facts, nextEvaluationAt }) => {
+	const expected = deriveReadinessNextEvaluationAt(facts);
+	return expected === null || nextEvaluationAt === null ? expected === nextEvaluationAt : DateTime$1.Order(expected, nextEvaluationAt) === 0;
+}, { expected: "environment readiness reevaluation time to match retained evidence" }), Schema$1.makeFilter(canonicalAssessmentCollections, { expected: "environment readiness collections to be canonical and evidence-bound" }), Schema$1.makeFilter((assessment) => assessment.verdict === deriveEnvironmentReadinessVerdict(assessment), { expected: "environment readiness verdict to agree with retained facts, findings, and stages" }));
+/** Compact immutable child retained by a release-scope roll-up. */
+var EnvironmentReadinessSummary = Schema$1.Struct({
+	assessmentId: ReadinessAssessmentId,
+	environmentId: EnvironmentId,
+	candidateDigest: ReadinessCandidateDigest,
+	inputComplete: Schema$1.Boolean,
+	facts: Schema$1.Array(ReadinessFactEvaluation).check(Schema$1.isMaxLength(512)),
+	nextEvaluationAt: Schema$1.NullOr(UtcTimestamp),
+	verdict: ReadinessVerdict,
+	stages: ReadinessStages,
+	blockers: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	warnings: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	gaps: Schema$1.Array(ReadinessFinding).check(Schema$1.isMaxLength(MAX_READINESS_FINDINGS)),
+	sourceFreshness: Schema$1.Array(ReadinessSourceSummary).check(Schema$1.isMaxLength(512)),
+	evidenceIds: Schema$1.Array(EvidenceId).check(Schema$1.isMaxLength(512))
+}).check(Schema$1.makeFilter(({ facts }) => isCanonicalStrings(facts.map(({ definition }) => definition.factId)), { expected: "an environment readiness summary to have canonical unique facts" }), Schema$1.makeFilter(({ facts }) => readinessPolicyShapeIsV1(facts.map(({ definition }) => definition), facts.flatMap(({ observation }) => observation === null ? [] : [observation])), { expected: "an environment readiness summary to retain the complete V1 policy shape" }), Schema$1.makeFilter(({ blockers, facts, gaps, inputComplete, warnings }) => {
+	const expected = deriveReadinessFindings(facts, inputComplete);
+	return sameOrderedStrings(blockers.map(readinessFindingKey), expected.blockers.map(readinessFindingKey)) && sameOrderedStrings(warnings.map(readinessFindingKey), expected.warnings.map(readinessFindingKey)) && sameOrderedStrings(gaps.map(readinessFindingKey), expected.gaps.map(readinessFindingKey));
+}, { expected: "environment readiness summary findings to match retained facts" }), Schema$1.makeFilter(({ evidenceIds, facts }) => sameOrderedStrings(evidenceIds, factEvidenceIds(facts)), { expected: "environment readiness summary evidence to match retained facts" }), Schema$1.makeFilter(({ facts, stages }) => readinessStagesAreEqual(stages, deriveReadinessStages(facts)), { expected: "environment readiness summary stages to match retained facts" }), Schema$1.makeFilter(({ facts, sourceFreshness }) => {
+	const expected = deriveReadinessSourceSummaries(facts);
+	return sourceFreshness.length === expected.length && sourceFreshness.every((summary, index) => {
+		const item = expected[index];
+		return item !== void 0 && summary.pluginConnectionId === item.pluginConnectionId && summary.freshness === item.freshness && summary.health === item.health && sameOrderedStrings(summary.evidenceIds, item.evidenceIds);
+	});
+}, { expected: "environment readiness summary sources to match retained facts" }), Schema$1.makeFilter(({ facts, nextEvaluationAt }) => {
+	const expected = deriveReadinessNextEvaluationAt(facts);
+	return expected === null || nextEvaluationAt === null ? expected === nextEvaluationAt : DateTime$1.Order(expected, nextEvaluationAt) === 0;
+}, { expected: "environment readiness summary reevaluation time to match retained facts" }), Schema$1.makeFilter(canonicalAssessmentCollections, { expected: "environment readiness summary collections to be canonical and evidence-bound" }), Schema$1.makeFilter((summary) => summary.verdict === deriveEnvironmentReadinessVerdict(summary), { expected: "environment readiness summary verdict to match retained facts, findings, and stages" }));
+/** Immutable release assessment rolled up from current target environments. */
+var ReleaseReadinessAssessment = Schema$1.Struct({
+	...AssessmentBase,
+	_tag: Schema$1.Literal("release"),
+	candidate: ReleaseReadinessCandidateIdentity,
+	environments: Schema$1.NonEmptyArray(EnvironmentReadinessSummary).check(Schema$1.isMaxLength(512))
+}).check(Schema$1.makeFilter(({ derivationVersion }) => derivationVersion === READINESS_DERIVATION_VERSION_V1, { expected: "a release readiness assessment derived by V1" }), Schema$1.makeFilter(({ assessmentId, previousAssessmentId }) => previousAssessmentId === null || previousAssessmentId !== assessmentId, { expected: "a release readiness assessment not to supersede itself" }), Schema$1.makeFilter(({ environments }) => isCanonicalStrings(environments.map(({ environmentId }) => environmentId)), { expected: "release readiness environments to have canonical unique identities" }), Schema$1.makeFilter(({ environments, stages }) => readinessStagesAreEqual(stages, deriveReleaseReadinessStages(environments)), { expected: "release readiness stages to match retained environment summaries" }), Schema$1.makeFilter(({ blockers, environments, gaps, warnings }) => {
+	const expected = deriveReleaseReadinessFindings(environments);
+	return sameOrderedStrings(blockers.map(readinessFindingKey), expected.blockers.map(readinessFindingKey)) && sameOrderedStrings(warnings.map(readinessFindingKey), expected.warnings.map(readinessFindingKey)) && sameOrderedStrings(gaps.map(readinessFindingKey), expected.gaps.map(readinessFindingKey));
+}, { expected: "release readiness findings to match retained environment summaries" }), Schema$1.makeFilter(({ environments, sourceFreshness }) => {
+	const expected = deriveReleaseReadinessSourceSummaries(environments);
+	return sourceFreshness.length === expected.length && sourceFreshness.every((summary, index) => {
+		const item = expected[index];
+		return item !== void 0 && summary.pluginConnectionId === item.pluginConnectionId && summary.freshness === item.freshness && summary.health === item.health && sameOrderedStrings(summary.evidenceIds, item.evidenceIds);
+	});
+}, { expected: "release readiness sources to match retained environment summaries" }), Schema$1.makeFilter(({ environments, nextEvaluationAt }) => {
+	const expected = deriveReleaseReadinessNextEvaluationAt(environments);
+	return expected === null || nextEvaluationAt === null ? expected === nextEvaluationAt : DateTime$1.Order(expected, nextEvaluationAt) === 0;
+}, { expected: "release readiness reevaluation time to match retained environment summaries" }), Schema$1.makeFilter(({ environments, evidenceIds }) => sameOrderedStrings(evidenceIds, sortedReadinessUnique(environments.flatMap(({ evidenceIds }) => evidenceIds))), { expected: "release readiness evidence to match retained environment summaries" }), Schema$1.makeFilter(canonicalAssessmentCollections, { expected: "release readiness collections to be canonical and evidence-bound" }), Schema$1.makeFilter(({ environments, verdict }) => verdict === deriveReleaseReadinessVerdict(environments), { expected: "release readiness verdict to agree with its environment summaries" }));
+/** Any immutable server-authoritative readiness assessment. */
+var ReadinessAssessment = Schema$1.Union([EnvironmentReadinessAssessment, ReleaseReadinessAssessment]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Complete, decoded input for one release-scope roll-up. */
+var ReleaseReadinessRollupInput = Schema$1.Struct({
+	assessmentId: ReadinessAssessmentId,
+	previousAssessmentId: Schema$1.NullOr(ReadinessAssessmentId),
+	candidate: ReleaseReadinessCandidateIdentity,
+	evaluatedAt: UtcTimestamp,
+	environments: Schema$1.NonEmptyArray(EnvironmentReadinessAssessment).check(Schema$1.isMaxLength(512))
+}).check(Schema$1.makeFilter(({ assessmentId, previousAssessmentId }) => previousAssessmentId === null || previousAssessmentId !== assessmentId, { expected: "a release readiness roll-up input not to supersede itself" }), Schema$1.makeFilter(({ environments }) => unique(environments.map(({ candidate }) => candidate.scope.environmentId)), { expected: "release readiness roll-up environment identities to be unique" }), Schema$1.makeFilter(({ candidate, environments }) => environments.every((assessment) => assessment.candidate.workspaceId === candidate.workspaceId && assessment.candidate.scope.releaseId === candidate.scope.releaseId && assessment.candidate.releaseRevision === candidate.releaseRevision && assessment.candidate.artifactRevision === candidate.artifactRevision), { expected: "release readiness roll-up children to name the same workspace, release, and candidate revision" }), Schema$1.makeFilter(({ environments }) => environments.every((assessment) => assessment.rule.ruleId === environments[0]?.rule.ruleId && assessment.rule.version === environments[0]?.rule.version && assessment.rule.digest === environments[0]?.rule.digest && assessment.derivationVersion === environments[0]?.derivationVersion), { expected: "release readiness roll-up children to use one rule and derivation version" }), Schema$1.makeFilter(({ environments }) => sortedReadinessUnique(environments.flatMap(({ evidenceIds }) => evidenceIds)).length <= 512, { expected: "release readiness roll-up evidence to fit its bounded assessment" }), Schema$1.makeFilter(({ environments }) => [
+	"build",
+	"verify",
+	"production"
+].every((stage) => {
+	if (stage === "build") return sortedReadinessUnique(environments.flatMap(({ stages }) => stages.build.factIds)).length <= 512;
+	if (stage === "verify") return sortedReadinessUnique(environments.flatMap(({ stages }) => stages.verify.factIds)).length <= 512;
+	return sortedReadinessUnique(environments.flatMap(({ stages }) => stages.production.factIds)).length <= 512;
+}), { expected: "release readiness roll-up facts to fit its bounded stages" }), Schema$1.makeFilter(({ environments }) => environments.reduce((total, assessment) => total + assessment.blockers.length, 0) <= 1025 && environments.reduce((total, assessment) => total + assessment.warnings.length, 0) <= 1025 && environments.reduce((total, assessment) => total + assessment.gaps.length, 0) <= 1025, { expected: "release readiness roll-up findings to fit its bounded assessment" }), Schema$1.makeFilter(({ environments }) => sortedReadinessUnique(environments.flatMap(({ sourceFreshness }) => sourceFreshness.map(({ pluginConnectionId }) => pluginConnectionId))).length <= 512, { expected: "release readiness roll-up sources to fit its bounded assessment" }), Schema$1.makeFilter(({ environments, evaluatedAt }) => environments.every((assessment) => DateTime$1.Order(assessment.evaluatedAt, evaluatedAt) <= 0), { expected: "release readiness roll-up not to predate its child assessments" }));
+//#endregion
+//#region src/domain/actors.ts
+var DisplayName = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isMinLength(1), Schema$1.isMaxLength(200));
+var AvatarReferenceValue = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isMinLength(1), Schema$1.isMaxLength(500));
+var Initials = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isMinLength(1), Schema$1.isMaxLength(4));
+/** An immutable provider identity associated with a canonical person. */
+var PersonSourceIdentity = Schema$1.Struct({
+	pluginConnectionId: PluginConnectionId,
+	providerId: ProviderId,
+	vendorPersonId: VendorImmutableId
+});
+/** Avatar media reference or deterministic initials fallback. */
+var PersonAvatar = Schema$1.TaggedUnion({
+	initials: { text: Initials },
+	reference: { reference: AvatarReferenceValue }
+});
+/**
+* Derives a stable one- or two-token initials fallback from a display name.
+* The first code point of the first and last non-empty tokens is used.
+*/
+var derivePersonInitials = (displayName) => {
+	const tokens = displayName.trim().split(/\s+/u).filter(Boolean);
+	const firstToken = tokens.at(0) ?? "";
+	const lastToken = tokens.at(-1) ?? "";
+	return `${Array.from(firstToken).at(0) ?? ""}${tokens.length > 1 ? Array.from(lastToken).at(0) ?? "" : ""}`.toLocaleUpperCase("en-US");
+};
+/** Canonical person with provider identities and an accessible avatar fallback. */
+var Person = Schema$1.Struct({
+	avatar: PersonAvatar,
+	displayName: DisplayName,
+	isActive: Schema$1.Boolean,
+	personId: PersonId,
+	sourceIdentities: Schema$1.Array(PersonSourceIdentity)
+}).check(Schema$1.makeFilter(({ avatar, displayName }) => avatar._tag === "reference" || avatar.text === derivePersonInitials(displayName), { expected: "initials avatar to match the deterministic display-name fallback" }), Schema$1.makeFilter(({ sourceIdentities }) => {
+	const identityKeys = sourceIdentities.map(({ pluginConnectionId, providerId, vendorPersonId }) => `${providerId}\u0000${pluginConnectionId}\u0000${vendorPersonId}`);
+	return new Set(identityKeys).size === identityKeys.length;
+}, { expected: "person source identities to be unique" }));
+/** Human collaborator responsible for a domain action. */
+var HumanActor = Schema$1.TaggedStruct("human", { personId: PersonId });
+/** Automated agent responsible for a domain action. */
+var AgentActor = Schema$1.TaggedStruct("agent", { agentId: AgentId });
+/** Human or agent responsible for a domain action. */
+var Actor = Schema$1.Union([HumanActor, AgentActor]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Explicit collaboration role stored with an assignment. */
+var Role = Schema$1.Literals([
+	"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"
+]);
+/** Exact domain scope to which a role assignment applies. */
+var RoleScope = Schema$1.TaggedUnion({
+	entity: {
+		entityId: EntityId,
+		workspaceId: WorkspaceId
+	},
+	environment: {
+		environmentId: EnvironmentId,
+		releaseId: ReleaseId,
+		workspaceId: WorkspaceId
+	},
+	release: {
+		releaseId: ReleaseId,
+		workspaceId: WorkspaceId
+	},
+	workspace: { workspaceId: WorkspaceId }
+});
+var ActiveAssignmentLifecycle = Schema$1.TaggedStruct("active", { assignedAt: UtcTimestamp });
+var EndedAssignmentLifecycle = Schema$1.TaggedStruct("ended", {
+	assignedAt: UtcTimestamp,
+	endedAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ assignedAt, endedAt }) => DateTime$1.Order(assignedAt, endedAt) <= 0, { expected: "assignment end time to be at or after assignment time" }));
+var RevokedAssignmentLifecycle = Schema$1.TaggedStruct("revoked", {
+	assignedAt: UtcTimestamp,
+	revokedAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ assignedAt, revokedAt }) => DateTime$1.Order(assignedAt, revokedAt) <= 0, { expected: "assignment revocation time to be at or after assignment time" }));
+/** Lifecycle and chronological bounds of a role assignment. */
+var AssignmentLifecycle = Schema$1.Union([
+	ActiveAssignmentLifecycle,
+	EndedAssignmentLifecycle,
+	RevokedAssignmentLifecycle
+]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Persisted binding of a human or agent role to one exact domain scope. */
+var RoleAssignment = Schema$1.Struct({
+	actor: Actor,
+	assignmentId: RoleAssignmentId,
+	lifecycle: AssignmentLifecycle,
+	role: Role,
+	scope: RoleScope
+});
+//#endregion
+//#region src/domain/releaseRelay.ts
+/** Canonical persisted algorithm label for the current Release Relay projection. */
+var RELEASE_RELAY_ALGORITHM = "relay/v1";
+/** Explicit v1 alias retained beside the versioned catalog constants. */
+var RELEASE_RELAY_V1_ALGORITHM = RELEASE_RELAY_ALGORITHM;
+var freezeCatalog = (catalog) => Object.freeze(catalog);
+/** Frozen adjective catalog whose order is part of the relay/v1 contract. */
+var RELEASE_RELAY_V1_ADJECTIVES = freezeCatalog([
+	"Amber",
+	"Azure",
+	"Copper",
+	"Ember",
+	"Golden",
+	"Lunar",
+	"Moss",
+	"Nova",
+	"Quiet",
+	"Silver",
+	"Solar",
+	"Tidal",
+	"Velvet",
+	"Verdant",
+	"Wild",
+	"Winter"
+]);
+/** Frozen noun catalog whose order is part of the relay/v1 contract. */
+var RELEASE_RELAY_V1_NOUNS = freezeCatalog([
+	"Anchor",
+	"Beacon",
+	"Bridge",
+	"Comet",
+	"Finch",
+	"Fork",
+	"Gate",
+	"Grove",
+	"Harbor",
+	"Orbit",
+	"Pulse",
+	"Reef",
+	"Relay",
+	"Spark",
+	"Wave",
+	"Willow"
+]);
+/** Schema for the relay/v1 algorithm discriminator. */
+var ReleaseRelayAlgorithm = Schema.Literal(RELEASE_RELAY_ALGORITHM);
+/** Persisted relay/v1 adjective. */
+var ReleaseRelayAdjective = Schema.Literals(RELEASE_RELAY_V1_ADJECTIVES);
+/** Persisted relay/v1 noun. */
+var ReleaseRelayNoun = Schema.Literals(RELEASE_RELAY_V1_NOUNS);
+/** Persisted relay/v1 codename assembled from the frozen catalogs. */
+var ReleaseRelayCodename = Schema.TemplateLiteral([
+	ReleaseRelayAdjective,
+	" ",
+	ReleaseRelayNoun
+]);
+/** Closed index into rly's separately versioned 16-symbol presentation catalog. */
+var ReleaseRelaySymbolIndex = Schema.Literals([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15
+]);
+/** Exactly three distinct persisted indices into the release-symbol catalog. */
+var ReleaseRelaySymbolIndices = Schema.Tuple([
+	ReleaseRelaySymbolIndex,
+	ReleaseRelaySymbolIndex,
+	ReleaseRelaySymbolIndex
+]).check(Schema.isUnique({ expected: "three distinct release symbol indices" }));
+/** Versioned, persisted Release Relay identity owned by the Control Center domain. */
+var ReleaseRelayProjection = Schema.Struct({
+	algorithm: ReleaseRelayAlgorithm,
+	codename: ReleaseRelayCodename,
+	symbolIndices: ReleaseRelaySymbolIndices
+});
+var FNV_1A_OFFSET_BASIS = 2166136261;
+var FNV_1A_PRIME = 16777619;
+var fnv1a32 = (asciiValue) => {
+	let hash = FNV_1A_OFFSET_BASIS;
+	for (let index = 0; index < asciiValue.length; index += 1) {
+		hash ^= asciiValue.charCodeAt(index);
+		hash = Math.imul(hash, FNV_1A_PRIME) >>> 0;
+	}
+	return hash;
+};
+var symbolIndexFromRemainder = (remainder) => {
+	switch (remainder) {
+		case 0: return 0;
+		case 1: return 1;
+		case 2: return 2;
+		case 3: return 3;
+		case 4: return 4;
+		case 5: return 5;
+		case 6: return 6;
+		case 7: return 7;
+		case 8: return 8;
+		case 9: return 9;
+		case 10: return 10;
+		case 11: return 11;
+		case 12: return 12;
+		case 13: return 13;
+		case 14: return 14;
+		default: return 15;
+	}
+};
+var catalogValueAt = (catalog, index) => {
+	switch (index) {
+		case 0: return catalog[0];
+		case 1: return catalog[1];
+		case 2: return catalog[2];
+		case 3: return catalog[3];
+		case 4: return catalog[4];
+		case 5: return catalog[5];
+		case 6: return catalog[6];
+		case 7: return catalog[7];
+		case 8: return catalog[8];
+		case 9: return catalog[9];
+		case 10: return catalog[10];
+		case 11: return catalog[11];
+		case 12: return catalog[12];
+		case 13: return catalog[13];
+		case 14: return catalog[14];
+		default: return catalog[15];
+	}
+};
+var deriveSymbolIndices = (releaseId) => {
+	const firstIndex = symbolIndexFromRemainder(fnv1a32(`${RELEASE_RELAY_ALGORITHM}|symbol/0|${releaseId}`) % 16);
+	const secondRank = fnv1a32(`${RELEASE_RELAY_ALGORITHM}|symbol/1|${releaseId}`) % 15;
+	const secondIndex = symbolIndexFromRemainder(secondRank < firstIndex ? secondRank : secondRank + 1);
+	const lowerExcludedIndex = Math.min(firstIndex, secondIndex);
+	const upperExcludedIndex = Math.max(firstIndex, secondIndex);
+	const thirdRank = fnv1a32(`${RELEASE_RELAY_ALGORITHM}|symbol/2|${releaseId}`) % 14;
+	return [
+		firstIndex,
+		secondIndex,
+		symbolIndexFromRemainder(thirdRank < lowerExcludedIndex ? thirdRank : thirdRank < upperExcludedIndex - 1 ? thirdRank + 1 : thirdRank + 2)
+	];
+};
+/**
+* Derive the stable relay/v1 projection for one canonical immutable release identifier.
+*
+* relay/v1 applies unsigned 32-bit FNV-1a to the ASCII domains
+* `relay/v1|adjective|<release-id>`, `relay/v1|noun|<release-id>`, and
+* `relay/v1|symbol/<position>|<release-id>`. Symbol hashes select ranks from the
+* remaining 16, 15, then 14 indices, making distinctness constructive.
+*/
+var deriveReleaseRelay = (releaseId) => {
+	const adjectiveIndex = symbolIndexFromRemainder(fnv1a32(`${RELEASE_RELAY_ALGORITHM}|adjective|${releaseId}`) % 16);
+	const nounIndex = symbolIndexFromRemainder(fnv1a32(`${RELEASE_RELAY_ALGORITHM}|noun|${releaseId}`) % 16);
+	return {
+		algorithm: RELEASE_RELAY_ALGORITHM,
+		codename: `${catalogValueAt(RELEASE_RELAY_V1_ADJECTIVES, adjectiveIndex)} ${catalogValueAt(RELEASE_RELAY_V1_NOUNS, nounIndex)}`,
+		symbolIndices: deriveSymbolIndices(releaseId)
+	};
+};
+//#endregion
+//#region src/domain/release.ts
+/** Human-readable service name retained independently of provider identity. */
+var ReleaseServiceName = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(200)).pipe(Schema$1.brand("ReleaseServiceName"));
+/** Provider-neutral release version or immutable release label. */
+var ReleaseVersion = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(100)).pipe(Schema$1.brand("ReleaseVersion"));
+/** Lifecycle of the release aggregate, separate from readiness and pipeline state. */
+var ReleaseLifecycle = Schema$1.Literals([
+	"assembling",
+	"candidate",
+	"deploying",
+	"released",
+	"cancelled"
+]);
+var ReleaseRecord = Schema$1.Struct({
+	createdAt: UtcTimestamp,
+	freshness: Freshness,
+	id: ReleaseId,
+	lifecycle: ReleaseLifecycle,
+	relay: ReleaseRelayProjection,
+	roleAssignments: Schema$1.Array(RoleAssignment),
+	serviceName: ReleaseServiceName,
+	sourceRevisions: Schema$1.Array(SourceRevision),
+	targetEnvironmentIds: Schema$1.Array(EnvironmentId).check(Schema$1.isUnique({ expected: "unique target environment identifiers" })),
+	updatedAt: UtcTimestamp,
+	version: ReleaseVersion,
+	workspaceId: WorkspaceId
+});
+var encodeSourceRevision = Schema$1.encodeSync(SourceRevision);
+var sourceRevisionEquivalence = Schema$1.toEquivalence(Schema$1.toEncoded(SourceRevision));
+/**
+* Foundational release aggregate. Readiness, evidence, stages, and delivery
+* relationships extend this record in their owning slices.
+*/
+var Release = ReleaseRecord.check(Schema$1.makeFilter(({ createdAt, updatedAt }) => DateTime$1.Order(createdAt, updatedAt) <= 0, { expected: "release update time to be at or after creation time" }), Schema$1.makeFilter(({ roleAssignments, workspaceId }) => roleAssignments.every(({ scope }) => scope.workspaceId === workspaceId), { expected: "every role assignment to belong to the release workspace" }), Schema$1.makeFilter(({ id, roleAssignments }) => roleAssignments.every(({ scope }) => scope._tag === "release" || scope._tag === "environment" ? scope.releaseId === id : true), { expected: "release-scoped assignments to name this release" }), Schema$1.makeFilter(({ roleAssignments, targetEnvironmentIds }) => {
+	const targets = new Set(targetEnvironmentIds);
+	return roleAssignments.every(({ scope }) => scope._tag === "environment" ? targets.has(scope.environmentId) : true);
+}, { expected: "environment-scoped assignments to name a release target" }), Schema$1.makeFilter(({ roleAssignments }) => {
+	const assignmentIds = roleAssignments.map(({ assignmentId }) => assignmentId);
+	return new Set(assignmentIds).size === assignmentIds.length;
+}, { expected: "unique role assignment identifiers" }), Schema$1.makeFilter(({ sourceRevisions }) => {
+	const sourceKeys = sourceRevisions.map(({ pluginConnectionId, providerId, vendorImmutableId }) => `${providerId}\u0000${pluginConnectionId}\u0000${vendorImmutableId}`);
+	return new Set(sourceKeys).size === sourceKeys.length;
+}, { expected: "one current source revision per provider object" }), Schema$1.makeFilter(({ freshness, sourceRevisions }) => {
+	if (freshness._tag !== "current" && freshness._tag !== "stale") return true;
+	const freshnessRevision = encodeSourceRevision(freshness.provenance.sourceRevision);
+	return sourceRevisions.filter((sourceRevision) => sourceRevisionEquivalence(encodeSourceRevision(sourceRevision), freshnessRevision)).length === 1;
+}, { expected: "current or stale freshness provenance to match one release source revision" }), Schema$1.makeFilter(({ id, relay }) => {
+	const expected = deriveReleaseRelay(id);
+	return relay.algorithm === expected.algorithm && relay.codename === expected.codename && relay.symbolIndices.every((symbolIndex, index) => symbolIndex === expected.symbolIndices[index]);
+}, { expected: "persisted relay projection to match the canonical release identifier" })).annotate({ identifier: "Release" });
+//#endregion
+//#region src/domain/plugins/descriptor.ts
+var NonNegativeInteger = Schema$1.Int.check(Schema$1.isGreaterThanOrEqualTo(0));
+var PositiveInteger = Schema$1.Int.check(Schema$1.isGreaterThan(0));
+var boundedIdentifier = (name, maximum) => Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(maximum)).pipe(Schema$1.brand(name));
+/** Stable reverse-DNS identity of a plugin, independent of package abbreviations. */
+var PluginId = boundedIdentifier("PluginId", 200);
+/** Strict structured semantic version used by plugin and adapter contracts. */
+var SemanticVersion = Schema$1.Struct({
+	major: NonNegativeInteger,
+	minor: NonNegativeInteger,
+	patch: NonNegativeInteger
+}).annotate({ identifier: "SemanticVersion" });
+/** Independently versioned operations understood by the Control Center host. */
+var PluginCapabilityId = Schema$1.Literals([
+	"entity.read",
+	"sync.incremental",
+	"action.propose",
+	"action.execute",
+	"action.cancel",
+	"action.reconcile",
+	"diff.inventory",
+	"diff.content"
+]).annotate({ identifier: "PluginCapabilityId" });
+/** A capability and the contract versions an adapter can implement. */
+var PluginCapabilityOfferV1 = Schema$1.Struct({
+	capabilityId: PluginCapabilityId,
+	supportedVersions: Schema$1.Array(PositiveInteger).check(Schema$1.isNonEmpty(), Schema$1.isUnique(), Schema$1.makeFilter((versions) => versions.length <= 16, { expected: "at most 16 supported capability versions" })),
+	requirement: Schema$1.Literals(["required", "optional"])
+}).annotate({ identifier: "PluginCapabilityOfferV1" });
+var ConfigurationKey = boundedIdentifier("PluginConfigurationKey", 100);
+var ConfigurationLabel = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(200));
+var commonConfigurationFields = {
+	key: ConfigurationKey,
+	label: ConfigurationLabel,
+	description: Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(500)),
+	required: Schema$1.Boolean
+};
+var TextConfigurationField = Schema$1.TaggedStruct("text", commonConfigurationFields);
+var UrlConfigurationField = Schema$1.TaggedStruct("url", commonConfigurationFields);
+var BooleanConfigurationField = Schema$1.TaggedStruct("boolean", commonConfigurationFields);
+var IntegerConfigurationField = Schema$1.TaggedStruct("integer", {
+	...commonConfigurationFields,
+	minimum: Schema$1.NullOr(Schema$1.Int),
+	maximum: Schema$1.NullOr(Schema$1.Int)
+}).check(Schema$1.makeFilter(({ maximum, minimum }) => maximum === null || minimum === null || minimum <= maximum, { expected: "plugin integer configuration minimum not to exceed maximum" }));
+var SelectConfigurationField = Schema$1.TaggedStruct("select", {
+	...commonConfigurationFields,
+	options: Schema$1.Array(Schema$1.Struct({
+		label: ConfigurationLabel,
+		value: boundedIdentifier("PluginConfigurationOption", 200)
+	})).check(Schema$1.isNonEmpty(), Schema$1.makeFilter((options) => options.length <= 100, { expected: "at most 100 plugin configuration options" }), Schema$1.makeFilter((options) => new Set(options.map(({ value }) => value)).size === options.length, { expected: "unique plugin configuration option values" }))
+});
+var SecretReferenceConfigurationField = Schema$1.TaggedStruct("secret-reference", {
+	...commonConfigurationFields,
+	secretKind: Schema$1.Literals([
+		"token",
+		"password",
+		"private-key",
+		"certificate",
+		"opaque"
+	])
+});
+/** Secret-free metadata describing a plugin configuration field. */
+var PluginConfigurationFieldV1 = Schema$1.Union([
+	TextConfigurationField,
+	UrlConfigurationField,
+	BooleanConfigurationField,
+	IntegerConfigurationField,
+	SelectConfigurationField,
+	SecretReferenceConfigurationField
+]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Raw version-one descriptor decoded before an adapter factory may run. */
+var PluginDescriptorV1 = Schema$1.Struct({
+	contractId: Schema$1.Literal("dev.knpkv.control-center.plugin"),
+	contractVersion: SemanticVersion,
+	pluginId: PluginId,
+	adapterVersion: SemanticVersion,
+	displayName: Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(200)),
+	configurationFields: Schema$1.Array(PluginConfigurationFieldV1).check(Schema$1.makeFilter((fields) => fields.length <= 100, { expected: "at most 100 plugin configuration fields" }), Schema$1.makeFilter((fields) => new Set(fields.map(({ key }) => key)).size === fields.length, { expected: "unique plugin configuration field keys" })),
+	capabilities: Schema$1.Array(PluginCapabilityOfferV1).check(Schema$1.isNonEmpty(), Schema$1.makeFilter((capabilities) => capabilities.length <= 32, { expected: "at most 32 plugin capability offers" }))
+}).check(hasMaximumPluginJsonBytes(MaximumPluginDescriptorBytes)).annotate({ identifier: "PluginDescriptorV1" });
+/** One capability version selected by the host during negotiation. */
+var NegotiatedPluginCapabilityV1 = Schema$1.Struct({
+	capabilityId: PluginCapabilityId,
+	version: PositiveInteger
+}).annotate({ identifier: "NegotiatedPluginCapabilityV1" });
+/** Descriptor accepted by the host after contract and capability negotiation. */
+var NegotiatedPluginDescriptorV1 = Schema$1.Struct({
+	descriptor: PluginDescriptorV1,
+	capabilities: Schema$1.Array(NegotiatedPluginCapabilityV1).check(Schema$1.isNonEmpty(), Schema$1.makeFilter((capabilities) => capabilities.length <= 32, { expected: "at most 32 negotiated plugin capabilities" }), Schema$1.makeFilter((capabilities) => new Set(capabilities.map(({ capabilityId }) => capabilityId)).size === capabilities.length, { expected: "unique negotiated plugin capabilities" }))
+}).annotate({ identifier: "NegotiatedPluginDescriptorV1" });
+//#endregion
+//#region src/domain/normalizedIssue.ts
+var boundedText$1 = (maximum, identifier) => Schema$1.String.check(Schema$1.isMaxLength(maximum)).annotate({ identifier });
+var boundedNonEmptyText = (maximum, identifier) => boundedText$1(maximum, identifier).check(Schema$1.isTrimmed(), Schema$1.isNonEmpty());
+var boundedArray = (schema, maximum) => Schema$1.Array(schema).check(Schema$1.isMaxLength(maximum));
+var MAXIMUM_NORMALIZED_ISSUE_LABELS = 200;
+var MAXIMUM_NORMALIZED_ISSUE_COMPONENTS = 100;
+var MAXIMUM_NORMALIZED_ISSUE_FIX_VERSIONS = 99;
+var MAXIMUM_NORMALIZED_ISSUE_SUBTASKS = 200;
+var MAXIMUM_NORMALIZED_ISSUE_COLLABORATORS = 200;
+var MAXIMUM_NORMALIZED_ISSUE_COMMENTS = 200;
+var MAXIMUM_NORMALIZED_ISSUE_HISTORY = 200;
+var MAXIMUM_NORMALIZED_ISSUE_HISTORY_CHANGES = 100;
+var SourceObjectId = boundedNonEmptyText(512, "NormalizedIssueSourceObjectId");
+var SourcePersonId = boundedNonEmptyText(512, "NormalizedIssueSourcePersonId");
+var ShortText = boundedText$1(255, "NormalizedIssueShortText");
+var RichText = boundedText$1(16e3, "NormalizedIssueRichText");
+var TimestampText = boundedNonEmptyText(100, "NormalizedIssueTimestamp");
+var AvatarUrl = boundedNonEmptyText(2048, "NormalizedIssueAvatarUrl").check(Schema$1.makeFilter((value) => Result$1.isSuccess(Schema$1.decodeUnknownResult(SourceUrl)(value)), { expected: "an HTTP(S) source URL without embedded credentials" }));
+/** Provider-neutral named source object retained with a bounded source identity. */
+var NormalizedIssueNamedValue = Schema$1.Struct({
+	sourceId: Schema$1.NullOr(SourceObjectId),
+	name: Schema$1.NullOr(ShortText)
+}).annotate({ identifier: "NormalizedIssueNamedValue" });
+/** Provider-neutral project identity and presentation retained from an issue source. */
+var NormalizedIssueProject = Schema$1.Struct({
+	sourceId: Schema$1.NullOr(SourceObjectId),
+	key: Schema$1.NullOr(boundedNonEmptyText(100, "NormalizedIssueProjectKey")),
+	name: Schema$1.NullOr(ShortText)
+}).annotate({ identifier: "NormalizedIssueProject" });
+/** Provider-neutral release/version reference retained from an issue source. */
+var NormalizedIssueFixVersion = Schema$1.Struct({
+	sourceId: Schema$1.NullOr(SourceObjectId),
+	name: Schema$1.NullOr(ShortText),
+	released: Schema$1.Boolean,
+	releaseDate: Schema$1.NullOr(TimestampText)
+}).annotate({ identifier: "NormalizedIssueFixVersion" });
+/** Provider-neutral parent or subtask reference retained from an issue source. */
+var NormalizedRelatedIssue = Schema$1.Struct({
+	sourceId: Schema$1.NullOr(SourceObjectId),
+	key: Schema$1.NullOr(boundedNonEmptyText(100, "NormalizedRelatedIssueKey")),
+	summary: Schema$1.NullOr(boundedText$1(500, "NormalizedRelatedIssueSummary")),
+	status: Schema$1.NullOr(NormalizedIssueNamedValue)
+}).annotate({ identifier: "NormalizedRelatedIssue" });
+/** Bounded source collaborator used for attribution without provider response types. */
+var NormalizedIssueCollaborator = Schema$1.Struct({
+	sourcePersonId: SourcePersonId,
+	displayName: boundedNonEmptyText(200, "NormalizedIssueCollaboratorDisplayName"),
+	avatarUrl: Schema$1.NullOr(AvatarUrl),
+	active: Schema$1.Boolean,
+	roles: boundedArray(boundedNonEmptyText(100, "NormalizedIssueCollaboratorRole"), 16).check(Schema$1.isUnique())
+}).annotate({ identifier: "NormalizedIssueCollaborator" });
+/** Bounded provider-neutral issue comment. */
+var NormalizedIssueComment = Schema$1.Struct({
+	sourceId: SourceObjectId,
+	authorSourcePersonId: Schema$1.NullOr(SourcePersonId),
+	updateAuthorSourcePersonId: Schema$1.NullOr(SourcePersonId),
+	body: Schema$1.NullOr(RichText),
+	createdAt: Schema$1.NullOr(TimestampText),
+	updatedAt: Schema$1.NullOr(TimestampText)
+}).annotate({ identifier: "NormalizedIssueComment" });
+/** One bounded provider-neutral field transition. */
+var NormalizedIssueHistoryChange = Schema$1.Struct({
+	field: boundedNonEmptyText(255, "NormalizedIssueHistoryField"),
+	from: Schema$1.NullOr(boundedText$1(1e3, "NormalizedIssueHistoryValue")),
+	to: Schema$1.NullOr(boundedText$1(1e3, "NormalizedIssueHistoryValue"))
+}).annotate({ identifier: "NormalizedIssueHistoryChange" });
+/** Bounded provider-neutral issue history entry. */
+var NormalizedIssueHistoryEntry = Schema$1.Struct({
+	sourceId: SourceObjectId,
+	authorSourcePersonId: Schema$1.NullOr(SourcePersonId),
+	createdAt: Schema$1.NullOr(TimestampText),
+	changes: boundedArray(NormalizedIssueHistoryChange, 100)
+}).annotate({ identifier: "NormalizedIssueHistoryEntry" });
+/** Fields whose source material may be deliberately reduced to remain within synchronization bounds. */
+var NormalizedIssueTruncatedField = Schema$1.Literals([
+	"acceptanceCriteria",
+	"collaborators",
+	"comments",
+	"components",
+	"description",
+	"environment",
+	"fixVersions",
+	"history",
+	"issueType",
+	"key",
+	"labels",
+	"parent",
+	"priority",
+	"project",
+	"resolution",
+	"summary",
+	"status",
+	"subtasks",
+	"updatedAt",
+	"createdAt",
+	"dueDate",
+	"resolvedAt"
+]);
+/**
+* Shared provider-neutral issue detail accepted from normalized plugins.
+*
+* The original compact key/status/priority/estimate fields remain required.
+* Rich fields are optional so older normalized plugins and persisted projections
+* remain valid; first-party Jira synchronization always supplies every rich field.
+*/
+var NormalizedIssueAttributes = Schema$1.Struct({
+	key: boundedNonEmptyText(100, "NormalizedIssueKey"),
+	status: boundedNonEmptyText(100, "NormalizedIssueStatus"),
+	priority: Schema$1.NullOr(boundedNonEmptyText(100, "NormalizedIssuePriority")),
+	estimatePoints: Schema$1.NullOr(Schema$1.Number.check(Schema$1.isGreaterThanOrEqualTo(0))),
+	summary: Schema$1.optionalKey(boundedText$1(500, "NormalizedIssueSummary")),
+	description: Schema$1.optionalKey(Schema$1.NullOr(RichText)),
+	acceptanceCriteria: Schema$1.optionalKey(Schema$1.NullOr(RichText)),
+	environment: Schema$1.optionalKey(Schema$1.NullOr(RichText)),
+	issueType: Schema$1.optionalKey(Schema$1.NullOr(NormalizedIssueNamedValue)),
+	project: Schema$1.optionalKey(Schema$1.NullOr(NormalizedIssueProject)),
+	resolution: Schema$1.optionalKey(Schema$1.NullOr(NormalizedIssueNamedValue)),
+	labels: Schema$1.optionalKey(boundedArray(boundedNonEmptyText(255, "NormalizedIssueLabel"), 200)),
+	components: Schema$1.optionalKey(boundedArray(NormalizedIssueNamedValue, 100)),
+	fixVersions: Schema$1.optionalKey(boundedArray(NormalizedIssueFixVersion, 99)),
+	createdAt: Schema$1.optionalKey(Schema$1.NullOr(TimestampText)),
+	updatedAt: Schema$1.optionalKey(Schema$1.NullOr(TimestampText)),
+	dueDate: Schema$1.optionalKey(Schema$1.NullOr(TimestampText)),
+	resolvedAt: Schema$1.optionalKey(Schema$1.NullOr(TimestampText)),
+	parent: Schema$1.optionalKey(Schema$1.NullOr(NormalizedRelatedIssue)),
+	subtasks: Schema$1.optionalKey(boundedArray(NormalizedRelatedIssue, 200)),
+	assigneeSourcePersonId: Schema$1.optionalKey(Schema$1.NullOr(SourcePersonId)),
+	reporterSourcePersonId: Schema$1.optionalKey(Schema$1.NullOr(SourcePersonId)),
+	creatorSourcePersonId: Schema$1.optionalKey(Schema$1.NullOr(SourcePersonId)),
+	collaborators: Schema$1.optionalKey(boundedArray(NormalizedIssueCollaborator, 200)),
+	comments: Schema$1.optionalKey(boundedArray(NormalizedIssueComment, 200)),
+	commentTotal: Schema$1.optionalKey(Schema$1.Int.check(Schema$1.isGreaterThanOrEqualTo(0))),
+	commentsTruncated: Schema$1.optionalKey(Schema$1.Boolean),
+	commentBodiesTruncated: Schema$1.optionalKey(Schema$1.Boolean),
+	history: Schema$1.optionalKey(boundedArray(NormalizedIssueHistoryEntry, 200)),
+	historyTotal: Schema$1.optionalKey(Schema$1.Int.check(Schema$1.isGreaterThanOrEqualTo(0))),
+	historyTruncated: Schema$1.optionalKey(Schema$1.Boolean),
+	truncatedFields: Schema$1.optionalKey(boundedArray(NormalizedIssueTruncatedField, 32).check(Schema$1.isUnique()))
+}).annotate({ identifier: "NormalizedIssueAttributes" });
+//#endregion
+//#region src/domain/deliveryGraph.ts
+var boundedText = (maximum, identifier) => Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(maximum)).annotate({ identifier });
+/** Provider-neutral kind of an object participating in delivery. */
+var DeliveryEntityKind = Schema$1.Literals([
+	"issue",
+	"pull-request",
+	"page",
+	"pipeline-execution",
+	"deployment",
+	"time-entry"
+]);
+/** Connected service responsible for a normalized delivery entity. */
+var DeliveryEntityService = Schema$1.Literals([
+	"jira",
+	"codecommit",
+	"confluence",
+	"codepipeline",
+	"clockify"
+]);
+/** Coarse cross-provider lifecycle used by workspace item search. */
+var DeliveryEntityStatusGroup = Schema$1.Literals([
+	"active",
+	"done",
+	"failed"
+]);
+/** Canonical semantic kind recorded for either endpoint of a relationship. */
+var RelationshipEndpointKind = Schema$1.Union([DeliveryEntityKind, Schema$1.Literals(["release", "environment"])]);
+/** Positive immutable revision of a normalized entity or relationship. */
+var LedgerRevision = Schema$1.Int.check(Schema$1.isGreaterThan(0)).pipe(Schema$1.brand("LedgerRevision"));
+var IssueDetails = Schema$1.TaggedStruct("issue", { ...NormalizedIssueAttributes.fields });
+var PullRequestDetails = Schema$1.TaggedStruct("pull-request", {
+	repository: boundedText(200, "RepositoryName"),
+	sourceBranch: boundedText(500, "SourceBranch"),
+	targetBranch: boundedText(500, "TargetBranch"),
+	headRevision: boundedText(512, "HeadRevision"),
+	reviewState: Schema$1.Literals([
+		"not-requested",
+		"requested",
+		"changes-requested",
+		"approved",
+		"merged"
+	])
+});
+var PageDetails = Schema$1.TaggedStruct("page", {
+	spaceKey: boundedText(100, "SpaceKey"),
+	revision: boundedText(512, "PageRevision"),
+	status: Schema$1.Literals([
+		"draft",
+		"current",
+		"superseded"
+	]),
+	linkedIssueKeys: Schema$1.optional(Schema$1.Array(boundedText(100, "LinkedIssueKey")).check(Schema$1.isUnique(), Schema$1.isMaxLength(100))),
+	linkedReleaseVersions: Schema$1.optional(Schema$1.Array(boundedText(100, "LinkedReleaseVersion")).check(Schema$1.isUnique(), Schema$1.isMaxLength(100)))
+});
+var PipelineDetails = Schema$1.TaggedStruct("pipeline-execution", {
+	pipelineName: boundedText(200, "PipelineName"),
+	executionId: boundedText(512, "PipelineExecutionId"),
+	status: Schema$1.Literals([
+		"queued",
+		"running",
+		"succeeded",
+		"failed",
+		"stopped"
+	]),
+	triggerRevision: boundedText(512, "PipelineTriggerRevision")
+});
+var DeploymentDetails = Schema$1.TaggedStruct("deployment", {
+	environmentId: EnvironmentId,
+	revision: boundedText(512, "DeploymentRevision"),
+	status: Schema$1.Literals([
+		"pending",
+		"deploying",
+		"succeeded",
+		"failed",
+		"rolled-back"
+	])
+});
+var TimeEntryDetails = Schema$1.TaggedStruct("time-entry", {
+	durationMinutes: Schema$1.Int.check(Schema$1.isGreaterThanOrEqualTo(0)),
+	billable: Schema$1.Boolean,
+	approvalState: Schema$1.Literals([
+		"pending",
+		"approved",
+		"rejected",
+		"not-required"
+	])
+});
+/** Provider-neutral entity extension decoded before graph persistence. */
+var DeliveryEntityDetails = Schema$1.Union([
+	IssueDetails,
+	PullRequestDetails,
+	PageDetails,
+	PipelineDetails,
+	DeploymentDetails,
+	TimeEntryDetails
+]).pipe(Schema$1.toTaggedUnion("_tag"));
+/** Immutable normalized projection for one exact entity source revision. */
+var DeliveryEntityProjection = Schema$1.Struct({
+	workspaceId: WorkspaceId,
+	entityId: EntityId,
+	projectionRevision: LedgerRevision,
+	sourceEntityRevision: LedgerRevision,
+	supersedesProjectionRevision: Schema$1.NullOr(LedgerRevision),
+	projectionSchemaVersion: Schema$1.Int.check(Schema$1.isGreaterThan(0)),
+	entityState: Schema$1.Literals(["present", "deleted"]),
+	entityType: DeliveryEntityKind,
+	displayKey: boundedText(200, "EntityDisplayKey"),
+	title: boundedText(500, "EntityTitle"),
+	details: DeliveryEntityDetails
+}).check(Schema$1.makeFilter(({ details, entityType }) => details._tag === entityType, { expected: "entity details whose tag matches the entity kind" }), Schema$1.makeFilter(({ projectionRevision, supersedesProjectionRevision }) => projectionRevision === 1 ? supersedesProjectionRevision === null : supersedesProjectionRevision === projectionRevision - 1, { expected: "entity projection to supersede its exact preceding revision" }));
+/** Resolved graph target with an exact canonical object identity. */
+var ResolvedDeliveryNode = Schema$1.TaggedUnion({
+	entity: {
+		entityId: EntityId,
+		entityKind: DeliveryEntityKind
+	},
+	environment: {
+		environmentId: EnvironmentId,
+		releaseId: ReleaseId
+	},
+	release: { releaseId: ReleaseId }
+});
+/** Resolved or intentionally missing node stored as trusted graph state. */
+var DeliveryNode = Schema$1.Struct({
+	workspaceId: WorkspaceId,
+	nodeId: GraphNodeId,
+	endpointKind: RelationshipEndpointKind,
+	resolution: Schema$1.TaggedUnion({
+		resolved: { target: ResolvedDeliveryNode },
+		missing: {
+			expectedKind: Schema$1.Literals([
+				"entity",
+				"release",
+				"environment"
+			]),
+			expectedEntityKind: Schema$1.NullOr(DeliveryEntityKind),
+			missingKey: boundedText(512, "MissingDeliveryNodeKey")
+		}
+	}),
+	createdAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ resolution }) => resolution._tag !== "missing" || resolution.expectedKind === "entity" === (resolution.expectedEntityKind !== null), { expected: "only missing entity nodes to carry an expected entity kind" }), Schema$1.makeFilter(({ endpointKind, resolution }) => {
+	if (resolution._tag === "missing") return resolution.expectedKind === "entity" ? endpointKind === resolution.expectedEntityKind : endpointKind === resolution.expectedKind;
+	return resolution.target._tag === "entity" ? endpointKind === resolution.target.entityKind : endpointKind === resolution.target._tag;
+}, { expected: "graph node endpoint kind to match its resolved or expected target kind" }));
+/** Semantic relationship between delivery nodes. Direction is significant. */
+var RelationshipKind = Schema$1.Literals([
+	"contains",
+	"implements",
+	"depends-on",
+	"verified-by",
+	"delivered-by",
+	"documented-by",
+	"tracks-time-for"
+]);
+var ALL_RELATIONSHIP_ENDPOINT_KINDS = [
+	"issue",
+	"pull-request",
+	"page",
+	"pipeline-execution",
+	"deployment",
+	"time-entry",
+	"release",
+	"environment"
+];
+/**
+* Version-one canonical direction matrix. Passive relationship names read from
+* source to target: for example, a pull request is `delivered-by` a pipeline
+* execution. `depends-on` is intentionally the one generic graph edge.
+*/
+var RELATIONSHIP_ENDPOINT_MATRIX_V1 = {
+	"contains": {
+		source: ["release"],
+		target: [
+			"issue",
+			"pull-request",
+			"page",
+			"pipeline-execution",
+			"deployment",
+			"time-entry"
+		]
+	},
+	"implements": {
+		source: ["pull-request"],
+		target: ["issue"]
+	},
+	"depends-on": {
+		source: ALL_RELATIONSHIP_ENDPOINT_KINDS,
+		target: ALL_RELATIONSHIP_ENDPOINT_KINDS
+	},
+	"verified-by": {
+		source: ["pull-request"],
+		target: ["pipeline-execution"]
+	},
+	"delivered-by": {
+		source: ["pull-request"],
+		target: ["pipeline-execution"]
+	},
+	"documented-by": {
+		source: ["issue", "release"],
+		target: ["page"]
+	},
+	"tracks-time-for": {
+		source: ["time-entry"],
+		target: ["issue"]
+	}
+};
+var relationshipEndpointIsAllowed = (kind, sourceNodeKind, targetNodeKind) => {
+	const rule = RELATIONSHIP_ENDPOINT_MATRIX_V1[kind];
+	return rule.source.some((candidate) => candidate === sourceNodeKind) && rule.target.some((candidate) => candidate === targetNodeKind);
+};
+/** Explainable confidence; inferred links can never masquerade as confirmed. */
+var RelationshipConfidence = Schema$1.TaggedUnion({
+	unknown: { rationale: boundedText(1e3, "UnknownRelationshipConfidenceRationale") },
+	confirmed: {},
+	inferred: {
+		score: Schema$1.Number.check(Schema$1.isBetween({
+			minimum: 0,
+			maximum: 1
+		})),
+		rationale: boundedText(1e3, "RelationshipConfidenceRationale")
+	}
+});
+/** Attribution for creation of a relationship revision. */
+var RelationshipProvenance = Schema$1.TaggedUnion({
+	plugin: {
+		pluginConnectionId: PluginConnectionId,
+		sourceEntityId: EntityId,
+		sourceEntityRevision: LedgerRevision
+	},
+	human: {
+		personId: PersonId,
+		rationale: boundedText(1e3, "HumanRelationshipRationale")
+	},
+	agent: {
+		agentId: AgentId,
+		rationale: boundedText(1e3, "AgentRelationshipRationale")
+	},
+	rule: {
+		ruleId: boundedText(200, "RelationshipRuleId"),
+		ruleVersion: Schema$1.Int.check(Schema$1.isGreaterThan(0)),
+		rationale: boundedText(1e3, "RuleRelationshipRationale")
+	}
+});
+/** Lifecycle of one relationship revision. Prior revisions remain immutable. */
+var RelationshipLifecycle = Schema$1.TaggedUnion({
+	missing: {
+		effectiveAt: UtcTimestamp,
+		reason: boundedText(1e3, "MissingRelationshipReason")
+	},
+	inferred: { effectiveAt: UtcTimestamp },
+	proposed: { effectiveAt: UtcTimestamp },
+	verified: { effectiveAt: UtcTimestamp },
+	governed: { effectiveAt: UtcTimestamp },
+	rejected: {
+		effectiveAt: UtcTimestamp,
+		reason: boundedText(1e3, "RejectionReason")
+	},
+	superseded: {
+		effectiveAt: UtcTimestamp,
+		reason: boundedText(1e3, "SupersessionReason")
+	}
+});
+/** Exact release or environment slice in which a relationship is evaluated. */
+var RelationshipScope = Schema$1.NullOr(Schema$1.TaggedUnion({
+	release: { releaseId: ReleaseId },
+	environment: {
+		releaseId: ReleaseId,
+		environmentId: EnvironmentId
+	}
+}));
+/** Human, agent, or system that appended an immutable ledger revision. */
+var LedgerActor = Schema$1.TaggedUnion({
+	human: { personId: PersonId },
+	agent: { agentId: AgentId },
+	system: { component: boundedText(200, "LedgerSystemComponent") }
+});
+/** Immutable relationship ledger revision. */
+var DeliveryRelationship = Schema$1.Struct({
+	workspaceId: WorkspaceId,
+	relationshipId: RelationshipId,
+	relationshipSchemaVersion: Schema$1.Literal(1),
+	revision: LedgerRevision,
+	supersedesRevision: Schema$1.NullOr(LedgerRevision),
+	kind: RelationshipKind,
+	sourceNodeId: GraphNodeId,
+	sourceNodeKind: RelationshipEndpointKind,
+	targetNodeId: GraphNodeId,
+	targetNodeKind: RelationshipEndpointKind,
+	scope: RelationshipScope,
+	lifecycle: RelationshipLifecycle,
+	confidence: RelationshipConfidence,
+	provenance: RelationshipProvenance,
+	recordedBy: LedgerActor,
+	evidenceClaimIds: Schema$1.Array(EvidenceClaimId).check(Schema$1.isMaxLength(128)),
+	recordedAt: UtcTimestamp
+}).check(Schema$1.makeFilter(({ evidenceClaimIds }) => new Set(evidenceClaimIds).size === evidenceClaimIds.length, { expected: "relationship evidence references to be unique" }), Schema$1.makeFilter(({ confidence, evidenceClaimIds }) => confidence._tag !== "confirmed" || evidenceClaimIds.length > 0, { expected: "confirmed relationship confidence to reference immutable evidence" }), Schema$1.makeFilter(({ sourceNodeId, targetNodeId }) => sourceNodeId !== targetNodeId, { expected: "relationship source and target to differ" }), Schema$1.makeFilter(({ kind, sourceNodeKind, targetNodeKind }) => relationshipEndpointIsAllowed(kind, sourceNodeKind, targetNodeKind), { expected: "relationship endpoints to follow the canonical version-one direction matrix" }), Schema$1.makeFilter(({ kind, scope }) => kind !== "contains" || scope !== null, { expected: "release containment to carry an explicit release or environment scope" }), Schema$1.makeFilter(({ confidence, lifecycle }) => lifecycle._tag !== "inferred" || confidence._tag !== "confirmed", { expected: "an inferred relationship lifecycle not to claim confirmed confidence" }), Schema$1.makeFilter(({ revision, supersedesRevision }) => revision === 1 ? supersedesRevision === null : supersedesRevision === revision - 1, { expected: "relationship to supersede its exact preceding revision" }));
+/** Closed assertion vocabulary used by immutable evidence claims. */
+var EvidencePredicate = Schema$1.Literals([
+	"relationship-observed",
+	"status-observed",
+	"approval-recorded",
+	"check-observed",
+	"execution-observed",
+	"deployment-observed",
+	"documentation-observed",
+	"time-observed"
+]);
+/** Bounded, provider-neutral evidence value. */
+var EvidenceValue = Schema$1.TaggedUnion({
+	flag: { value: Schema$1.Boolean },
+	state: { value: boundedText(500, "EvidenceState") },
+	revision: { value: boundedText(512, "EvidenceRevision") },
+	reference: { targetNodeId: GraphNodeId }
+});
+/** Exact actor or source revision responsible for an evidence claim. */
+var EvidenceAttribution = Schema$1.TaggedUnion({
+	plugin: {
+		pluginConnectionId: PluginConnectionId,
+		sourceEntityId: EntityId,
+		sourceEntityRevision: LedgerRevision
+	},
+	human: { personId: PersonId },
+	agent: { agentId: AgentId },
+	system: { component: boundedText(200, "EvidenceSystemComponent") }
+});
+/** Explicit retention policy attached when evidence is recorded. */
+var EvidenceRetention = Schema$1.Struct({
+	classification: Schema$1.Literals([
+		"audit",
+		"evidence",
+		"normalized-cache"
+	]),
+	retainUntil: Schema$1.NullOr(UtcTimestamp),
+	legalHold: Schema$1.Boolean
+});
+/** Independent verification of an evidence observation. */
+var EvidenceVerifier = Schema$1.TaggedUnion({
+	human: { personId: PersonId },
+	agent: { agentId: AgentId },
+	system: { component: boundedText(200, "EvidenceVerifierComponent") }
+});
+/** Immutable observation envelope with provenance, validity, and retention. */
+var EvidenceItem = Schema$1.Struct({
+	workspaceId: WorkspaceId,
+	evidenceId: EvidenceId,
+	schemaVersion: Schema$1.Int.check(Schema$1.isGreaterThan(0)),
+	attribution: EvidenceAttribution,
+	verifier: EvidenceVerifier,
+	observedAt: UtcTimestamp,
+	recordedAt: UtcTimestamp,
+	validUntil: Schema$1.NullOr(UtcTimestamp),
+	freshness: Freshness,
+	retention: EvidenceRetention
+}).check(Schema$1.makeFilter(({ attribution, freshness }) => {
+	if (attribution._tag !== "plugin") return true;
+	return freshness.provenance._tag !== "none" && attribution.pluginConnectionId === freshness.provenance.sourceRevision.pluginConnectionId;
+}, { expected: "plugin evidence attribution to carry its exact freshness source revision" }), Schema$1.makeFilter(({ observedAt, recordedAt }) => DateTime$1.Order(observedAt, recordedAt) <= 0, { expected: "evidence observation time not to follow recording time" }), Schema$1.makeFilter(({ observedAt, validUntil }) => validUntil === null || DateTime$1.Order(observedAt, validUntil) < 0, { expected: "evidence validity to end after observation" }), Schema$1.makeFilter(({ recordedAt, retention }) => retention.retainUntil === null || DateTime$1.Order(recordedAt, retention.retainUntil) <= 0, { expected: "evidence retention not to end before recording" }));
+/** One immutable normalized claim derived from an evidence observation. */
+var EvidenceClaim = Schema$1.Struct({
+	workspaceId: WorkspaceId,
+	evidenceClaimId: EvidenceClaimId,
+	evidenceId: EvidenceId,
+	subjectNodeId: GraphNodeId,
+	predicate: EvidencePredicate,
+	value: EvidenceValue,
+	recordedAt: UtcTimestamp,
+	supersedesEvidenceClaimId: Schema$1.NullOr(EvidenceClaimId)
+}).check(Schema$1.makeFilter(({ evidenceClaimId, supersedesEvidenceClaimId }) => evidenceClaimId !== supersedesEvidenceClaimId, { expected: "evidence not to supersede itself" }));
+var sourceFreshnessAt = (freshness, at) => {
+	if (freshness._tag !== "current") return freshness._tag;
+	return DateTime$1.toEpochMillis(at) - DateTime$1.toEpochMillis(freshness.sourceObservedAt) < freshness.staleAfterSeconds * 1e3 ? "current" : "stale";
+};
+/** Determine source freshness and evidence validity at an injected instant. */
+var evidenceFreshnessAt = (evidence, at) => ({
+	source: sourceFreshnessAt(evidence.freshness, at),
+	validity: evidence.validUntil === null || DateTime$1.Order(at, evidence.validUntil) < 0 ? "valid" : "expired"
+});
+/** Determine whether retained evidence bytes are eligible for governed cleanup. */
+var evidenceRetentionEligibilityAt = (evidence, at) => !evidence.retention.legalHold && evidence.retention.retainUntil !== null && DateTime$1.Order(evidence.retention.retainUntil, at) <= 0 ? "eligible" : "retain";
+//#endregion
+//#region src/domain/relationshipRepair.ts
+/** Explicit decision proposed for an incomplete delivery relationship. */
+var RelationshipRepairDisposition = Schema$1.Literals([
+	"link",
+	"verify",
+	"reject"
+]);
+/** Bounded human-readable justification stored with a repair proposal. */
+var RelationshipRepairRationale = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(1e3)).annotate({ identifier: "RelationshipRepairRationale" });
+/** Authenticated origin retained for proposal review and later audit. */
+var RelationshipRepairProposalOrigin = Schema$1.Struct({
+	actor: Actor,
+	sessionId: SessionId
+});
+/** Final reviewer decision over one exact proposal. */
+var RelationshipRepairReviewDecision = Schema$1.Literals(["approved", "rejected"]);
+/** Immutable review evidence retained with a finalized proposal. */
+var RelationshipRepairReview = Schema$1.Struct({
+	reviewId: RelationshipRepairReviewId,
+	decision: RelationshipRepairReviewDecision,
+	rationale: RelationshipRepairRationale,
+	origin: RelationshipRepairProposalOrigin,
+	reviewedAt: UtcTimestamp
+}).annotate({ identifier: "RelationshipRepairReview" });
+/** Immutable evidence that one approved proposal appended an exact ledger revision. */
+var RelationshipRepairApplication = Schema$1.Struct({
+	proposalId: RelationshipRepairProposalId,
+	relationshipId: RelationshipId,
+	appliedRevision: LedgerRevision,
+	origin: RelationshipRepairProposalOrigin,
+	appliedAt: UtcTimestamp
+}).annotate({ identifier: "RelationshipRepairApplication" });
+/** Durable proposal bound to one exact immutable relationship revision. */
+var RelationshipRepairProposal = Schema$1.Struct({
+	schemaVersion: Schema$1.Literal(2),
+	proposalId: RelationshipRepairProposalId,
+	workspaceId: WorkspaceId,
+	releaseId: ReleaseId,
+	environmentId: Schema$1.NullOr(EnvironmentId),
+	relationshipId: RelationshipId,
+	expectedRevision: LedgerRevision,
+	disposition: RelationshipRepairDisposition,
+	rationale: RelationshipRepairRationale,
+	origin: RelationshipRepairProposalOrigin,
+	status: Schema$1.Literals([
+		"pending",
+		"approved",
+		"rejected"
+	]),
+	proposedAt: UtcTimestamp,
+	review: Schema$1.NullOr(RelationshipRepairReview)
+}).annotate({ identifier: "RelationshipRepairProposal" });
+//#endregion
+//#region src/domain/timeline.ts
+/** Actor classes that can contribute durable activity to a workspace Timeline. */
+var TimelineActorKind = Schema$1.Literals([
+	"agent",
+	"human",
+	"plugin",
+	"system"
+]);
+/** Durable source streams merged by the Timeline projection. */
+var TimelineSourceKind = Schema$1.Literals([
+	"action",
+	"plugin-sync",
+	"relationship",
+	"system"
+]);
+/** Connected provider identity retained when a durable event has provenance. */
+var TimelineService = Schema$1.Literals([
+	"codecommit",
+	"codepipeline",
+	"jira",
+	"confluence",
+	"clockify"
+]);
+/** Stable cursor for newest-first Timeline pagination. */
+var TimelineCursor = Schema$1.Struct({
+	eventKey: Schema$1.String.check(Schema$1.isNonEmpty(), Schema$1.isMaxLength(1024)),
+	occurredAt: UtcTimestamp
+}).annotate({ identifier: "TimelineCursor" });
+/** Default-redacted, human-readable event from one durable workspace source. */
+var TimelineEvent = Schema$1.Struct({
+	eventKey: TimelineCursor.fields.eventKey,
+	occurredAt: UtcTimestamp,
+	actor: Schema$1.Struct({
+		kind: TimelineActorKind,
+		label: Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(200))
+	}),
+	sourceKind: TimelineSourceKind,
+	service: Schema$1.NullOr(TimelineService),
+	eventType: Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(200)),
+	title: Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(300)),
+	href: Schema$1.NullOr(Schema$1.String.check(Schema$1.isNonEmpty(), Schema$1.isMaxLength(2048)))
+}).annotate({ identifier: "TimelineEvent" });
+var TimelineRawIdentifier = Schema$1.String.check(Schema$1.isNonEmpty(), Schema$1.isMaxLength(2048));
+/** Owner-visible durable identifiers for one exact Timeline event. */
+var TimelineEventIdentifiers = Schema$1.Struct({
+	actorId: Schema$1.NullOr(TimelineRawIdentifier),
+	actionId: Schema$1.NullOr(TimelineRawIdentifier),
+	relationshipId: Schema$1.NullOr(TimelineRawIdentifier),
+	pluginConnectionId: Schema$1.NullOr(TimelineRawIdentifier),
+	releaseId: Schema$1.NullOr(TimelineRawIdentifier),
+	entityId: Schema$1.NullOr(TimelineRawIdentifier)
+}).annotate({ identifier: "TimelineEventIdentifiers" });
+/** Owner-visible reference to the local agent job attributable to an event. */
+var TimelineAgentJobDetail = Schema$1.Struct({ jobId: TimelineRawIdentifier }).annotate({ identifier: "TimelineAgentJobDetail" });
+/** Deliberate owner-only expansion of one otherwise redacted Timeline event. */
+var TimelineEventDetail = Schema$1.Struct({
+	event: TimelineEvent,
+	identifiers: TimelineEventIdentifiers,
+	agentJob: Schema$1.NullOr(TimelineAgentJobDetail)
+}).annotate({ identifier: "TimelineEventDetail" });
+/** One bounded Timeline page. */
+var TimelinePage = Schema$1.Struct({
+	events: Schema$1.Array(TimelineEvent).check(Schema$1.makeFilter((events) => events.length <= 100, { expected: "at most 100 Timeline events" })),
+	nextCursor: Schema$1.NullOr(TimelineCursor)
+}).annotate({ identifier: "TimelinePage" });
+//#endregion
+//#region src/domain/domainEvent.ts
+var jsonEncoder = new TextEncoder();
+var hasMaximumJsonBytes = (maximumBytes) => Schema$1.makeFilter((value) => {
+	const serialized = JSON.stringify(value);
+	return serialized !== void 0 && jsonEncoder.encode(serialized).byteLength <= maximumBytes;
+}, { expected: `JSON encoded as at most ${maximumBytes} UTF-8 bytes` });
+var PersistedEventCursor = EventCursor.check(Schema$1.isGreaterThan(0));
+/** Maximum decoded JSON carried by one durable domain event. */
+var MaximumDomainEventPayloadBytes = 65536;
+/** Bounded trace identifier safe to persist independently of the HTTP API. */
+var DomainEventCorrelationId = Schema$1.String.check(Schema$1.isTrimmed(), Schema$1.isNonEmpty(), Schema$1.isMaxLength(128), Schema$1.isPattern(/^[A-Za-z0-9._:-]+$/u, { expected: "a domain-safe correlation identifier" })).pipe(Schema$1.brand("DomainEventCorrelationId"));
+/** Optional normalized identities explaining which portfolio facts changed. */
+var DomainEventMetadataV1 = Schema$1.Struct({
+	releaseId: Schema$1.optionalKey(ReleaseId),
+	pluginConnectionId: Schema$1.optionalKey(PluginConnectionId),
+	entityId: Schema$1.optionalKey(EntityId),
+	jobId: Schema$1.optionalKey(JobId)
+}).annotate({ identifier: "DomainEventMetadataV1" });
+/** Portfolio projection that must be refreshed after a durable invalidation. */
+var PortfolioInvalidationReason = Schema$1.Literals(["release-projection", "plugin-health"]);
+/** Bounded typed payload persisted with a portfolio invalidation. */
+var PortfolioInvalidatedPayloadV1 = Schema$1.Struct({ reason: PortfolioInvalidationReason }).check(hasMaximumJsonBytes(MaximumDomainEventPayloadBytes)).annotate({ identifier: "PortfolioInvalidatedPayloadV1" });
+/** Durable workspace-local event declaring that the authoritative portfolio changed. */
+var PortfolioInvalidatedEventV1 = Schema$1.Struct({
+	schemaVersion: Schema$1.Literal(1),
+	eventId: DomainEventId,
+	eventCursor: PersistedEventCursor,
+	workspaceId: WorkspaceId,
+	eventType: Schema$1.Literal("portfolio-invalidated"),
+	occurredAt: UtcTimestamp,
+	ingestedAt: UtcTimestamp,
+	causationId: Schema$1.NullOr(DomainEventId),
+	correlationId: Schema$1.NullOr(DomainEventCorrelationId),
+	metadata: DomainEventMetadataV1,
+	payload: PortfolioInvalidatedPayloadV1
+}).annotate({ identifier: "PortfolioInvalidatedEventV1" });
+//#endregion
+export { MAXIMUM_NORMALIZED_ISSUE_HISTORY as $, readinessObservationIsDeliveryActivity as $n, MAX_READINESS_EVIDENCE_REFERENCES as $t, EvidenceAttribution as A, ReadinessVerdict as An, GovernedActionAuthorizationId as Ar, ReleaseRelayAlgorithm as At, RelationshipConfidence as B, deriveReadinessStages as Bn, RelationshipRepairProposalId as Br, HumanActor as Bt, DeliveryEntityDetails as C, ReadinessReleaseRevision as Cn, EntityId as Cr, ReleaseServiceName as Ct, DeliveryEntityStatusGroup as D, ReadinessScope as Dn, EvidenceId as Dr, RELEASE_RELAY_V1_ALGORITHM as Dt, DeliveryEntityService as E, ReadinessRuleVersion as En, EvidenceClaimId as Er, RELEASE_RELAY_V1_ADJECTIVES as Et, EvidenceValue as F, compareReadinessText as Fn, PersonId as Fr, ReleaseRelaySymbolIndices as Ft, RelationshipScope as G, deriveReleaseReadinessVerdict as Gn, ShareId as Gr, RoleAssignment as Gt, RelationshipKind as H, deriveReleaseReadinessNextEvaluationAt as Hn, ReleaseId as Hr, PersonAvatar as Ht, EvidenceVerifier as I, deriveEnvironmentReadinessVerdict as In, PluginConnectionId as Ir, deriveReleaseRelay as It, evidenceRetentionEligibilityAt as J, readinessFactResult as Jn, BuildReadinessStage as Jt, ResolvedDeliveryNode as K, readinessDefinitionsShapeIsV1 as Kn, WorkspaceId as Kr, RoleScope as Kt, LedgerActor as L, deriveReadinessFindings as Ln, ProviderAccountId as Lr, Actor as Lt, EvidenceItem as M, ReleaseReadinessCandidateIdentity as Mn, GovernedActionTransitionId as Mr, ReleaseRelayNoun as Mt, EvidencePredicate as N, ReleaseReadinessRollupInput as Nn, GraphNodeId as Nr, ReleaseRelayProjection as Nt, DeliveryNode as O, ReadinessSourceSummary as On, FollowedResourceId as Or, RELEASE_RELAY_V1_NOUNS as Ot, EvidenceRetention as P, VerifyReadinessStage as Pn, JobId as Pr, ReleaseRelaySymbolIndex as Pt, MAXIMUM_NORMALIZED_ISSUE_FIX_VERSIONS as Q, readinessObservationIsCurrent as Qn, EnvironmentReadinessSummary as Qt, LedgerRevision as R, deriveReadinessNextEvaluationAt as Rn, ReadinessAssessmentId as Rr, AgentActor as Rt, RelationshipRepairReviewDecision as S, ReadinessProgress as Sn, DomainEventId as Sr, ReleaseLifecycle as St, DeliveryEntityProjection as T, ReadinessRuleReference as Tn, EventCursor as Tr, RELEASE_RELAY_ALGORITHM as Tt, RelationshipLifecycle as U, deriveReleaseReadinessSourceSummaries as Un, RoleAssignmentId as Ur, PersonSourceIdentity as Ut, RelationshipEndpointKind as V, deriveReleaseReadinessFindings as Vn, RelationshipRepairReviewId as Vr, Person as Vt, RelationshipProvenance as W, deriveReleaseReadinessStages as Wn, SessionId as Wr, Role as Wt, MAXIMUM_NORMALIZED_ISSUE_COMMENTS as X, readinessFindingKey as Xn, EnvironmentReadinessCandidateIdentity as Xt, MAXIMUM_NORMALIZED_ISSUE_COLLABORATORS as Y, readinessFailureCode as Yn, EnvironmentReadinessAssessment as Yt, MAXIMUM_NORMALIZED_ISSUE_COMPONENTS as Z, readinessNonPositiveCode as Zn, EnvironmentReadinessEvaluationInput as Zt, RelationshipRepairDisposition as _, ReadinessFactResult as _n, SourceUrl as _r, PluginConfigurationFieldV1 as _t, PortfolioInvalidatedPayloadV1 as a, ReadinessAssessment as an, MaximumPluginPayloadBytes as ar, NormalizedIssueComment as at, RelationshipRepairRationale as b, ReadinessFindingCode as bn, AgentId as br, SemanticVersion as bt, TimelineAgentJobDetail as c, ReadinessDerivationVersion as cn, hasMaximumPluginJsonBytes as cr, NormalizedIssueHistoryEntry as ct, TimelineEventDetail as d, ReadinessFactDefinition as dn, PluginHealth as dr, NormalizedIssueTruncatedField as dt, MAX_READINESS_FINDINGS as en, readinessObservationIsPositive as er, MAXIMUM_NORMALIZED_ISSUE_HISTORY_CHANGES as et, TimelineEventIdentifiers as f, ReadinessFactEvaluation as fn, evaluateFreshnessAt as fr, NormalizedRelatedIssue as ft, RelationshipRepairApplication as g, ReadinessFactRequirement as gn, SourceRevision as gr, PluginCapabilityOfferV1 as gt, TimelineSourceKind as h, ReadinessFactObservation as hn, Revision as hr, PluginCapabilityId as ht, PortfolioInvalidatedEventV1 as i, ReadinessArtifactRevision as in, MaximumPluginDescriptorBytes as ir, NormalizedIssueCollaborator as it, EvidenceClaim as j, ReleaseReadinessAssessment as jn, GovernedActionId as jr, ReleaseRelayCodename as jt, DeliveryRelationship as k, ReadinessStages as kn, GovernedActionAttemptId as kr, ReleaseRelayAdjective as kt, TimelineCursor as l, ReadinessEvidenceReference as ln, Freshness as lr, NormalizedIssueNamedValue as lt, TimelineService as m, ReadinessFactKind as mn, ProviderId as mr, NegotiatedPluginDescriptorV1 as mt, DomainEventMetadataV1 as n, READINESS_DERIVATION_VERSION_V1 as nn, readinessStagesAreEqual as nr, MAXIMUM_NORMALIZED_ISSUE_SUBTASKS as nt, PortfolioInvalidationReason as o, ReadinessCandidateDigest as on, MaximumPluginSyncPageBytes as or, NormalizedIssueFixVersion as ot, TimelinePage as p, ReadinessFactId as pn, NormalizationSchemaVersion as pr, NegotiatedPluginCapabilityV1 as pt, evidenceFreshnessAt as q, readinessEvidenceIsCurrent as qn, derivePersonInitials as qt, MaximumDomainEventPayloadBytes as r, READINESS_RULE_VERSION_V1 as rn, sortedReadinessUnique as rr, NormalizedIssueAttributes as rt, TimelineActorKind as s, ReadinessCandidateIdentity as sn, PluginPayloadJson as sr, NormalizedIssueHistoryChange as st, DomainEventCorrelationId as t, ProductionReadinessStage as tn, readinessPolicyShapeIsV1 as tr, MAXIMUM_NORMALIZED_ISSUE_LABELS as tt, TimelineEvent as u, ReadinessEvidenceSource as un, PluginFailureClass as ur, NormalizedIssueProject as ut, RelationshipRepairProposal as v, ReadinessFactState as vn, VendorImmutableId as vr, PluginDescriptorV1 as vt, DeliveryEntityKind as w, ReadinessRuleId as wn, EnvironmentId as wr, ReleaseVersion as wt, RelationshipRepairReview as x, ReadinessFindingSubject as xn, AgentThreadId as xr, Release as xt, RelationshipRepairProposalOrigin as y, ReadinessFinding as yn, UtcTimestamp as yr, PluginId as yt, RELATIONSHIP_ENDPOINT_MATRIX_V1 as z, deriveReadinessSourceSummaries as zn, RelationshipId as zr, AssignmentLifecycle as zt };
+
+//# sourceMappingURL=domainEvent-x7yeq-gU.js.map