@knpkv/control-center 0.1.0

package/dist/server/assets/manualPluginSynchronization-C0aHB4UM.js

@@ -0,0 +1,1805 @@
+import { Cr as EntityId, Dr as EvidenceId, Er as EvidenceClaimId, F as EvidenceValue, Fr as PersonId, H as RelationshipKind, Hr as ReleaseId, It as deriveReleaseRelay, N as EvidencePredicate, Nr as GraphNodeId, R as LedgerRevision, Vt as Person, dr as PluginHealth, mt as NegotiatedPluginDescriptorV1, pr as NormalizationSchemaVersion, qt as derivePersonInitials, rt as NormalizedIssueAttributes, vr as VendorImmutableId, wr as EnvironmentId, xt as Release, zr as RelationshipId } from "./domainEvent-x7yeq-gU.js";
+import { Ct as PluginCheckpointV1, jt as PluginSyncRequestV1 } from "./readiness-CzU3vjYQ.js";
+import { Kn as PersistenceOperationError, L as Persistence, Ot as DeliveryGraphWriteBatch, Q as PluginMalformedResponseFailure, S as ApplicationInvalidRequest, T as ApplicationServiceUnavailable, Z as PluginConflictFailure, i as supportsFirstPartySynchronization, it as pluginFailureClass, n as DomainEventWakeups, r as firstPartySyncStreamKey, st as PluginStreamKey, t as appendPortfolioInvalidation, v as PluginConnection, w as ApplicationResourceNotFound } from "./portfolioInvalidation-Ds9Xm4_P.js";
+import * as Schema from "effect/Schema";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as Context from "effect/Context";
+import * as Encoding from "effect/Encoding";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Stream from "effect/Stream";
+import * as Crypto from "effect/Crypto";
+import * as Clock from "effect/Clock";
+//#region src/server/application/pluginSynchronizationAuthority.ts
+var conflict = () => new PluginConflictFailure({
+	operation: "manual-sync",
+	diagnosticCode: "manual-sync-runtime-authority-changed"
+});
+var authorityFor = Effect.fn("PluginSynchronizationAuthority.forConnection")(function* (persistence, connection) {
+	const configuration = yield* persistence.pluginConfigurations.get(connection.workspaceId, connection.pluginConnectionId);
+	return {
+		workspaceId: connection.workspaceId,
+		pluginConnectionId: connection.pluginConnectionId,
+		providerId: connection.providerId,
+		connectionRevision: connection.revision,
+		configurationRevision: Option.isSome(configuration) ? configuration.value.revision : null
+	};
+});
+/** Capture connection and configuration revisions in one durable read transaction. */
+var capturePluginSynchronizationAuthority = Effect.fn("PluginSynchronizationAuthority.capture")(function* (persistence, workspaceId, pluginConnectionId) {
+	return yield* persistence.transact(Effect.gen(function* () {
+		const connection = yield* persistence.pluginConnections.get(workspaceId, pluginConnectionId);
+		return {
+			connection,
+			authority: yield* authorityFor(persistence, connection)
+		};
+	}));
+});
+/** Reject a write transaction when its runtime no longer owns current connection authority. */
+var verifyPluginSynchronizationAuthority = Effect.fn("PluginSynchronizationAuthority.verify")(function* (persistence, expected) {
+	const connection = yield* persistence.pluginConnections.get(expected.workspaceId, expected.pluginConnectionId).pipe(Effect.catchTag("RecordNotFoundError", () => conflict()));
+	const current = yield* authorityFor(persistence, connection);
+	if (!connection.isEnabled || current.providerId !== expected.providerId || current.connectionRevision !== expected.connectionRevision || current.configurationRevision !== expected.configurationRevision) return yield* conflict();
+});
+//#endregion
+//#region src/server/application/relationshipInference.ts
+var MAXIMUM_INFERENCE_CANDIDATES = 2e3;
+var addCandidate = (accumulator, candidate) => {
+	if (accumulator.candidates.length >= MAXIMUM_INFERENCE_CANDIDATES) {
+		accumulator.truncated = true;
+		return;
+	}
+	accumulator.candidates.push(candidate);
+};
+var OWNED_RULE_IDS = /* @__PURE__ */ new Set([
+	"codepipeline-trigger-revision-v1",
+	"confluence-jira-link-v1",
+	"confluence-release-link-v1",
+	"jira-key-in-clockify-description-v1",
+	"jira-key-in-confluence-metadata-v1",
+	"jira-key-in-pull-request-metadata-v1",
+	"release-in-confluence-metadata-v1"
+]);
+var present = (entity) => entity.projection.entityState === "present";
+var resolved = (kind, nodeId) => ({
+	_tag: "resolved",
+	kind,
+	nodeId
+});
+var missing = (kind, missingKey, identityKey) => ({
+	_tag: "missing",
+	identityKey,
+	kind,
+	missingKey
+});
+var currentRelationship = (relationship) => relationship.lifecycle._tag !== "missing" && relationship.lifecycle._tag !== "rejected" && relationship.lifecycle._tag !== "superseded";
+var currentExternalRelationship = (relationship) => currentRelationship(relationship) && !(relationship.lifecycle._tag === "inferred" && relationship.provenance._tag === "rule" && OWNED_RULE_IDS.has(relationship.provenance.ruleId));
+var currentOwnedRelationship = (relationship) => currentRelationship(relationship) && relationship.lifecycle._tag === "inferred" && relationship.provenance._tag === "rule" && OWNED_RULE_IDS.has(relationship.provenance.ruleId);
+var currentInferenceRelationship = (relationship) => relationship.lifecycle._tag !== "rejected" && relationship.lifecycle._tag !== "superseded" && relationship.provenance._tag === "rule" && (relationship.provenance.ruleId === "delivery-gap-v1" || OWNED_RULE_IDS.has(relationship.provenance.ruleId));
+var relationshipInRelease = (relationship, releaseId) => relationship.scope?._tag === "release" && relationship.scope.releaseId === releaseId;
+var containsToken = (text, token) => {
+	const normalizedText = text.toUpperCase();
+	const normalizedToken = token.toUpperCase();
+	let offset = normalizedText.indexOf(normalizedToken);
+	while (offset >= 0) {
+		const before = normalizedText[offset - 1];
+		const after = normalizedText[offset + normalizedToken.length];
+		const boundary = (character) => character === void 0 || !/[A-Z0-9]/u.test(character);
+		if (boundary(before) && boundary(after)) return true;
+		offset = normalizedText.indexOf(normalizedToken, offset + normalizedToken.length);
+	}
+	return false;
+};
+var containsReleaseVersion = (text, version) => {
+	const normalizedText = text.toUpperCase();
+	const normalizedVersion = version.toUpperCase();
+	let offset = normalizedText.indexOf(normalizedVersion);
+	while (offset >= 0) {
+		const before = normalizedText[offset - 1];
+		const after = normalizedText[offset + normalizedVersion.length];
+		const boundary = (character) => character === void 0 || !/[A-Z0-9._+-]/u.test(character);
+		if (boundary(before) && boundary(after)) return true;
+		offset = normalizedText.indexOf(normalizedVersion, offset + normalizedVersion.length);
+	}
+	return false;
+};
+var metadata = (entity) => {
+	const details = entity.projection.details;
+	return details._tag === "pull-request" ? [
+		entity.projection.title,
+		entity.projection.displayKey,
+		details.sourceBranch,
+		details.targetBranch
+	].join("\n") : [entity.projection.title, entity.projection.displayKey].join("\n");
+};
+var observationKey = (...entities) => entities.map(({ projection }) => `${projection.entityId}@${String(projection.projectionRevision)}`).sort().join("+");
+var inferred = (input) => ({
+	...input,
+	lifecycle: "inferred"
+});
+var gap = (input) => ({
+	...input,
+	confidence: null,
+	evidenceEntityId: null,
+	lifecycle: "missing",
+	observationKey: input.identityKey,
+	ruleId: "delivery-gap-v1"
+});
+var candidateIdentity = (kind, releaseId, source, target) => `relationship:${kind}:${releaseId}:${source}:${target}`;
+var issueGapIdentity = (releaseId, issueNodeId) => `gap:implements:${releaseId}:${issueNodeId}`;
+var pipelineGapIdentity = (releaseId, pullRequestNodeId) => `gap:delivered-by:${releaseId}:${pullRequestNodeId}`;
+var candidateGapKey = (candidate) => {
+	if (candidate.lifecycle !== "missing") return null;
+	if (candidate.kind === "implements" && candidate.target._tag === "resolved") return `${candidate.kind}:${candidate.releaseId}:${candidate.target.nodeId}`;
+	if (candidate.kind === "delivered-by" && candidate.source._tag === "resolved") return `${candidate.kind}:${candidate.releaseId}:${candidate.source.nodeId}`;
+	return null;
+};
+var relationshipGapKey = (relationship) => {
+	if (relationship.lifecycle._tag !== "missing" || relationship.provenance._tag !== "rule" || relationship.provenance.ruleId !== "delivery-gap-v1" || relationship.scope?._tag !== "release") return null;
+	if (relationship.kind === "implements") return `${relationship.kind}:${relationship.scope.releaseId}:${relationship.targetNodeId}`;
+	if (relationship.kind === "delivered-by") return `${relationship.kind}:${relationship.scope.releaseId}:${relationship.sourceNodeId}`;
+	return null;
+};
+var hasRelationship = (relationships, releaseId, kind, sourceNodeId, targetNodeId) => relationships.some((relationship) => currentExternalRelationship(relationship) && relationshipInRelease(relationship, releaseId) && relationship.kind === kind && (sourceNodeId === null || relationship.sourceNodeId === sourceNodeId) && (targetNodeId === null || relationship.targetNodeId === targetNodeId));
+var addIssueAndTimeCandidates = (entities, accumulator) => {
+	const issues = entities.filter((entity) => entity.projection.details._tag === "issue");
+	const timeEntries = entities.filter((entity) => entity.projection.details._tag === "time-entry");
+	for (const timeEntry of timeEntries) for (const issue of issues) {
+		const details = issue.projection.details;
+		if (details._tag !== "issue" || !containsToken(metadata(timeEntry), details.key)) continue;
+		for (const releaseId of issue.releaseIds) addCandidate(accumulator, inferred({
+			confidence: {
+				score: .95,
+				rationale: `The Clockify description contains Jira key ${details.key}.`
+			},
+			evidenceEntityId: timeEntry.projection.entityId,
+			identityKey: candidateIdentity("tracks-time-for", releaseId, timeEntry.nodeId, issue.nodeId),
+			kind: "tracks-time-for",
+			observationKey: observationKey(timeEntry, issue),
+			releaseId,
+			ruleId: "jira-key-in-clockify-description-v1",
+			source: resolved("time-entry", timeEntry.nodeId),
+			target: resolved("issue", issue.nodeId)
+		}));
+	}
+};
+var addDocumentationCandidates = (entities, releases, accumulator) => {
+	const issues = entities.filter((entity) => entity.projection.details._tag === "issue");
+	const releaseVersionCounts = /* @__PURE__ */ new Map();
+	for (const release of releases) {
+		const version = release.version.toUpperCase();
+		releaseVersionCounts.set(version, (releaseVersionCounts.get(version) ?? 0) + 1);
+	}
+	const pages = entities.filter((entity) => entity.projection.details._tag === "page" && entity.projection.details.status === "current");
+	for (const page of pages) {
+		const pageDetails = page.projection.details;
+		if (pageDetails._tag !== "page") continue;
+		const pageMetadata = metadata(page);
+		for (const issue of issues) {
+			const details = issue.projection.details;
+			if (details._tag !== "issue") continue;
+			const explicitLink = pageDetails.linkedIssueKeys?.some((key) => key.toUpperCase() === details.key.toUpperCase()) ?? false;
+			if (!explicitLink && !containsToken(pageMetadata, details.key)) continue;
+			for (const releaseId of issue.releaseIds) addCandidate(accumulator, inferred({
+				confidence: {
+					score: explicitLink ? .97 : .9,
+					rationale: explicitLink ? `Confluence metadata links Jira key ${details.key}.` : `Confluence page metadata contains Jira key ${details.key}.`
+				},
+				evidenceEntityId: page.projection.entityId,
+				identityKey: candidateIdentity("documented-by", releaseId, issue.nodeId, page.nodeId),
+				kind: "documented-by",
+				observationKey: observationKey(page, issue),
+				releaseId,
+				ruleId: explicitLink ? "confluence-jira-link-v1" : "jira-key-in-confluence-metadata-v1",
+				source: resolved("issue", issue.nodeId),
+				target: resolved("page", page.nodeId)
+			}));
+		}
+		for (const release of releases) {
+			if ((releaseVersionCounts.get(release.version.toUpperCase()) ?? 0) > 1) continue;
+			const explicitLink = pageDetails.linkedReleaseVersions?.some((version) => version.toUpperCase() === release.version.toUpperCase()) ?? false;
+			if (!explicitLink && !containsReleaseVersion(pageMetadata, release.version)) continue;
+			addCandidate(accumulator, inferred({
+				confidence: {
+					score: explicitLink ? .96 : .88,
+					rationale: explicitLink ? `Confluence metadata links release ${release.version}.` : `Confluence page metadata contains release ${release.version}.`
+				},
+				evidenceEntityId: page.projection.entityId,
+				identityKey: candidateIdentity("documented-by", release.releaseId, release.nodeId, page.nodeId),
+				kind: "documented-by",
+				observationKey: observationKey(page),
+				releaseId: release.releaseId,
+				ruleId: explicitLink ? "confluence-release-link-v1" : "release-in-confluence-metadata-v1",
+				source: resolved("release", release.nodeId),
+				target: resolved("page", page.nodeId)
+			}));
+		}
+	}
+};
+/**
+* Infer a deterministic relationship set from current canonical facts. Rules
+* only propose `inferred` or `missing`; confirmation remains governed.
+*/
+var deriveRelationshipInference = (input) => {
+	const entities = input.entities.filter(present).map((entity) => ({
+		...entity,
+		releaseIds: entity.releaseIds.filter((releaseId) => {
+			const touchesEntity = (relationship) => relationshipInRelease(relationship, releaseId) && (relationship.sourceNodeId === entity.nodeId || relationship.targetNodeId === entity.nodeId);
+			return !input.relationships.some((relationship) => currentInferenceRelationship(relationship) && touchesEntity(relationship)) || input.relationships.some((relationship) => currentExternalRelationship(relationship) && touchesEntity(relationship));
+		})
+	}));
+	const issues = entities.filter((entity) => entity.projection.details._tag === "issue");
+	const pullRequests = entities.filter((entity) => entity.projection.details._tag === "pull-request");
+	const pipelines = entities.filter((entity) => entity.projection.details._tag === "pipeline-execution");
+	const accumulator = {
+		candidates: [],
+		truncated: false
+	};
+	const obsoleteGaps = /* @__PURE__ */ new Set();
+	const inferredIssueLinks = /* @__PURE__ */ new Set();
+	const pullRequestReleases = /* @__PURE__ */ new Map();
+	for (const pullRequest of pullRequests) {
+		if (pullRequest.projection.details._tag !== "pull-request") continue;
+		const releaseIds = new Set(pullRequest.releaseIds.filter((releaseId) => {
+			const touchesPullRequest = (relationship) => relationshipInRelease(relationship, releaseId) && (relationship.sourceNodeId === pullRequest.nodeId || relationship.targetNodeId === pullRequest.nodeId);
+			return !input.relationships.some((relationship) => currentOwnedRelationship(relationship) && touchesPullRequest(relationship)) || input.relationships.some((relationship) => currentExternalRelationship(relationship) && touchesPullRequest(relationship));
+		}));
+		for (const issue of issues) {
+			const issueDetails = issue.projection.details;
+			if (issueDetails._tag !== "issue" || !containsToken(metadata(pullRequest), issueDetails.key)) continue;
+			for (const releaseId of issue.releaseIds) {
+				const identityKey = candidateIdentity("implements", releaseId, pullRequest.nodeId, issue.nodeId);
+				if (!(input.rejectedCandidateIdentityKeys?.has(identityKey) ?? false)) {
+					releaseIds.add(releaseId);
+					inferredIssueLinks.add(`${releaseId}:${issue.nodeId}`);
+					obsoleteGaps.add(issueGapIdentity(releaseId, issue.nodeId));
+				}
+				addCandidate(accumulator, inferred({
+					confidence: {
+						score: containsToken(pullRequest.projection.title, issueDetails.key) ? .98 : .94,
+						rationale: `The immutable pull-request metadata contains Jira key ${issueDetails.key}.`
+					},
+					evidenceEntityId: pullRequest.projection.entityId,
+					identityKey,
+					kind: "implements",
+					observationKey: observationKey(pullRequest, issue),
+					releaseId,
+					ruleId: "jira-key-in-pull-request-metadata-v1",
+					source: resolved("pull-request", pullRequest.nodeId),
+					target: resolved("issue", issue.nodeId)
+				}));
+			}
+		}
+		for (const relationship of input.relationships) if (currentExternalRelationship(relationship) && relationship.kind === "implements" && relationship.sourceNodeId === pullRequest.nodeId && relationship.scope?._tag === "release") releaseIds.add(relationship.scope.releaseId);
+		pullRequestReleases.set(pullRequest.nodeId, releaseIds);
+	}
+	for (const issue of issues) for (const releaseId of issue.releaseIds) {
+		const identityKey = issueGapIdentity(releaseId, issue.nodeId);
+		if (inferredIssueLinks.has(`${releaseId}:${issue.nodeId}`) || hasRelationship(input.relationships, releaseId, "implements", null, issue.nodeId)) obsoleteGaps.add(identityKey);
+		else {
+			const details = issue.projection.details;
+			if (details._tag !== "issue") continue;
+			addCandidate(accumulator, gap({
+				identityKey,
+				kind: "implements",
+				releaseId,
+				source: missing("pull-request", `${details.key}:pull-request`, issue.nodeId),
+				target: resolved("issue", issue.nodeId)
+			}));
+		}
+	}
+	const inferredPipelineLinks = /* @__PURE__ */ new Set();
+	for (const pullRequest of pullRequests) {
+		const pullRequestDetails = pullRequest.projection.details;
+		if (pullRequestDetails._tag !== "pull-request") continue;
+		for (const pipeline of pipelines) {
+			const pipelineDetails = pipeline.projection.details;
+			if (pipelineDetails._tag !== "pipeline-execution" || pipelineDetails.triggerRevision !== pullRequestDetails.headRevision) continue;
+			for (const releaseId of pullRequestReleases.get(pullRequest.nodeId) ?? []) {
+				const identityKey = candidateIdentity("delivered-by", releaseId, pullRequest.nodeId, pipeline.nodeId);
+				if (!(input.rejectedCandidateIdentityKeys?.has(identityKey) ?? false)) {
+					inferredPipelineLinks.add(`${releaseId}:${pullRequest.nodeId}`);
+					obsoleteGaps.add(pipelineGapIdentity(releaseId, pullRequest.nodeId));
+				}
+				addCandidate(accumulator, inferred({
+					confidence: {
+						score: .99,
+						rationale: `The pipeline trigger revision exactly matches pull-request head ${pullRequestDetails.headRevision}.`
+					},
+					evidenceEntityId: pipeline.projection.entityId,
+					identityKey,
+					kind: "delivered-by",
+					observationKey: observationKey(pullRequest, pipeline),
+					releaseId,
+					ruleId: "codepipeline-trigger-revision-v1",
+					source: resolved("pull-request", pullRequest.nodeId),
+					target: resolved("pipeline-execution", pipeline.nodeId)
+				}));
+			}
+		}
+	}
+	for (const pullRequest of pullRequests) for (const releaseId of pullRequestReleases.get(pullRequest.nodeId) ?? []) {
+		const identityKey = pipelineGapIdentity(releaseId, pullRequest.nodeId);
+		if (inferredPipelineLinks.has(`${releaseId}:${pullRequest.nodeId}`) || hasRelationship(input.relationships, releaseId, "delivered-by", pullRequest.nodeId, null) || hasRelationship(input.relationships, releaseId, "verified-by", pullRequest.nodeId, null)) obsoleteGaps.add(identityKey);
+		else addCandidate(accumulator, gap({
+			identityKey,
+			kind: "delivered-by",
+			releaseId,
+			source: resolved("pull-request", pullRequest.nodeId),
+			target: missing("pipeline-execution", `${pullRequest.projection.displayKey}:pipeline-execution`, pullRequest.nodeId)
+		}));
+	}
+	addIssueAndTimeCandidates(entities, accumulator);
+	addDocumentationCandidates(entities, input.releases, accumulator);
+	const unique = new Map(accumulator.candidates.map((candidate) => [candidate.identityKey, candidate]));
+	const candidateEdges = new Set([...unique.values()].flatMap((candidate) => candidate.lifecycle === "inferred" && candidate.source._tag === "resolved" && candidate.target._tag === "resolved" ? [`${candidate.kind}:${candidate.releaseId}:${candidate.source.nodeId}:${candidate.target.nodeId}`] : []));
+	const candidateGaps = new Set([...unique.values()].flatMap((candidate) => {
+		const key = candidateGapKey(candidate);
+		return key === null ? [] : [key];
+	}));
+	const obsoleteRelationshipIds = input.relationships.flatMap((relationship) => {
+		const gapKey = relationshipGapKey(relationship);
+		const obsoleteInference = relationship.lifecycle._tag === "inferred" && relationship.provenance._tag === "rule" && OWNED_RULE_IDS.has(relationship.provenance.ruleId) && relationship.scope?._tag === "release" && !candidateEdges.has(`${relationship.kind}:${relationship.scope.releaseId}:${relationship.sourceNodeId}:${relationship.targetNodeId}`);
+		const obsoleteGap = gapKey !== null && !candidateGaps.has(gapKey);
+		return obsoleteInference || obsoleteGap ? [relationship.relationshipId] : [];
+	});
+	return {
+		candidates: [...unique.values()].sort((left, right) => left.identityKey.localeCompare(right.identityKey)),
+		obsoleteGapIdentityKeys: [...obsoleteGaps].sort(),
+		obsoleteRelationshipIds: [...new Set(obsoleteRelationshipIds)].sort(),
+		truncated: accumulator.truncated
+	};
+};
+//#endregion
+//#region src/server/application/relationshipInferenceMaterialization.ts
+var MAXIMUM_INFERENCE_ENTITIES = 500;
+var MAXIMUM_INFERENCE_RELEASES = 50;
+var MAXIMUM_INFERENCE_RELATIONSHIPS = 2e3;
+var COMPONENT = "relationship-inference";
+var readRelationship = Effect.fn("RelationshipInferenceMaterialization.readRelationship")(function* (persistence, workspaceId, relationshipId) {
+	const result = yield* persistence.deliveryGraph.read(workspaceId, {
+		_tag: "relationship",
+		relationshipId,
+		revision: null
+	}).pipe(Effect.result);
+	if (Result.isFailure(result)) {
+		if (result.failure._tag === "RecordNotFoundError") return null;
+		return yield* result.failure;
+	}
+	return result.success._tag === "relationship" ? result.success.value : null;
+});
+var nodeExists = Effect.fn("RelationshipInferenceMaterialization.nodeExists")(function* (persistence, workspaceId, nodeId) {
+	const result = yield* persistence.deliveryGraph.read(workspaceId, {
+		_tag: "node",
+		nodeId
+	}).pipe(Effect.result);
+	if (Result.isSuccess(result)) return true;
+	if (result.failure._tag === "RecordNotFoundError") return false;
+	return yield* result.failure;
+});
+var writeGraph$1 = Effect.fn("RelationshipInferenceMaterialization.writeGraph")(function* (persistence, workspaceId, batch) {
+	const encoded = yield* Schema.encodeEffect(DeliveryGraphWriteBatch)(batch).pipe(Effect.mapError(() => new PersistenceOperationError({ operation: "relationship-inference.encode" })));
+	return yield* persistence.deliveryGraph.write(workspaceId, encoded);
+});
+var relationshipIdentity = (workspaceId, identityKey) => `${workspaceId}\u0000relationship-inference\u0000relationship\u0000${identityKey}`;
+var missingNodeIdentity = (workspaceId, endpointKind, missingKey) => `${workspaceId}\u0000relationship-inference\u0000missing-node\u0000${endpointKind}\u0000${missingKey}`;
+var evidenceIdentity = (workspaceId, identityKey, observationKey, kind) => `${workspaceId}\u0000relationship-inference\u0000evidence-${kind}\u0000${identityKey}\u0000${observationKey}`;
+var entityNodeIdentity = (workspaceId, entity) => {
+	const source = entity.sourceRevision;
+	return `${workspaceId}\u0000${source.pluginConnectionId}\u0000${source.providerId}\u0000entity-node\u0000${source.vendorImmutableId}`;
+};
+var releaseNodeIdentity = (workspaceId, pluginConnectionId, providerId, vendorImmutableId) => `${workspaceId}\u0000${pluginConnectionId}\u0000${providerId}\u0000release-node\u0000${vendorImmutableId}`;
+var relationshipIdFor = (identity, workspaceId, identityKey) => identity(relationshipIdentity(workspaceId, identityKey)).pipe(Effect.map(RelationshipId.make));
+var endpointNode = (identity, scope, endpoint) => endpoint._tag === "resolved" ? Effect.succeed({
+	node: null,
+	nodeId: endpoint.nodeId
+}) : identity(missingNodeIdentity(scope.workspaceId, endpoint.kind, endpoint.identityKey)).pipe(Effect.map((value) => {
+	const nodeId = GraphNodeId.make(value);
+	return {
+		nodeId,
+		node: {
+			workspaceId: scope.workspaceId,
+			nodeId,
+			endpointKind: endpoint.kind,
+			resolution: {
+				_tag: "missing",
+				expectedKind: "entity",
+				expectedEntityKind: endpoint.kind,
+				missingKey: endpoint.missingKey
+			},
+			createdAt: scope.committedAt
+		}
+	};
+}));
+var evidenceFor = Effect.fn("RelationshipInferenceMaterialization.evidenceFor")(function* (persistence, identity, scope, candidate, sourceNodeId, targetNodeId, entity) {
+	const evidenceId = EvidenceId.make(yield* identity(evidenceIdentity(scope.workspaceId, candidate.identityKey, candidate.observationKey, "item")));
+	const evidenceClaimId = EvidenceClaimId.make(yield* identity(evidenceIdentity(scope.workspaceId, candidate.identityKey, candidate.observationKey, "claim")));
+	const source = entity.sourceRevision;
+	const sourceStreamKey = yield* Schema.decodeUnknownEffect(PluginStreamKey)(firstPartySyncStreamKey(source.providerId)).pipe(Effect.mapError(() => new PersistenceOperationError({ operation: "relationship-inference.source-stream" })));
+	const pluginHealth = yield* persistence.pluginRuntime.getLastSuccessfulHealth(scope.workspaceId, source.pluginConnectionId, sourceStreamKey);
+	if (pluginHealth === null) return yield* new PersistenceOperationError({ operation: "relationship-inference.source-health" });
+	const sourceAgeSeconds = Math.max(0, (DateTime.toEpochMillis(scope.committedAt) - DateTime.toEpochMillis(source.lastObservedAt)) / 1e3);
+	return {
+		item: {
+			workspaceId: scope.workspaceId,
+			evidenceId,
+			schemaVersion: 1,
+			attribution: {
+				_tag: "system",
+				component: COMPONENT
+			},
+			verifier: {
+				_tag: "system",
+				component: COMPONENT
+			},
+			observedAt: source.lastObservedAt,
+			recordedAt: scope.committedAt,
+			validUntil: null,
+			freshness: {
+				_tag: "current",
+				evaluatedAt: scope.committedAt,
+				pluginHealth,
+				provenance: {
+					_tag: "provider",
+					sourceRevision: source
+				},
+				sourceObservedAt: source.lastObservedAt,
+				staleAfterSeconds: Math.max(1, Math.ceil(sourceAgeSeconds) + 86400),
+				synchronizedAt: source.synchronizedAt
+			},
+			retention: {
+				classification: "evidence",
+				retainUntil: null,
+				legalHold: false
+			}
+		},
+		claim: {
+			workspaceId: scope.workspaceId,
+			evidenceClaimId,
+			evidenceId,
+			subjectNodeId: sourceNodeId,
+			predicate: "relationship-observed",
+			value: {
+				_tag: "reference",
+				targetNodeId
+			},
+			recordedAt: scope.committedAt,
+			supersedesEvidenceClaimId: null
+		}
+	};
+});
+var unchanged = (previous, candidate, sourceNodeId, targetNodeId, claimId) => previous !== null && previous.kind === candidate.kind && previous.sourceNodeId === sourceNodeId && previous.targetNodeId === targetNodeId && previous.scope?._tag === "release" && previous.scope.releaseId === candidate.releaseId && previous.lifecycle._tag === candidate.lifecycle && (claimId === null || previous.evidenceClaimIds.includes(claimId));
+var protectedByDecision = (previous) => previous?.lifecycle._tag === "governed" || previous?.lifecycle._tag === "verified" || previous?.lifecycle._tag === "rejected";
+var materializeCandidate = Effect.fn("RelationshipInferenceMaterialization.materializeCandidate")(function* (persistence, identity, scope, candidate, entityById) {
+	const relationshipId = yield* relationshipIdFor(identity, scope.workspaceId, candidate.identityKey);
+	const previous = yield* readRelationship(persistence, scope.workspaceId, relationshipId);
+	if (protectedByDecision(previous)) return {
+		evidenceClaimCount: 0,
+		evidenceItemCount: 0,
+		nodeCount: 0,
+		relationshipCount: 0,
+		skippedDueToBounds: false
+	};
+	const source = yield* endpointNode(identity, scope, candidate.source);
+	const target = yield* endpointNode(identity, scope, candidate.target);
+	const evidenceEntity = candidate.evidenceEntityId === null ? null : entityById.get(candidate.evidenceEntityId) ?? null;
+	const evidence = evidenceEntity === null ? null : yield* evidenceFor(persistence, identity, scope, candidate, source.nodeId, target.nodeId, evidenceEntity);
+	if (unchanged(previous, candidate, source.nodeId, target.nodeId, evidence?.claim.evidenceClaimId ?? null)) return {
+		evidenceClaimCount: 0,
+		evidenceItemCount: 0,
+		nodeCount: 0,
+		relationshipCount: 0,
+		skippedDueToBounds: false
+	};
+	const nodes = [];
+	if (source.node !== null && !(yield* nodeExists(persistence, scope.workspaceId, source.nodeId))) nodes.push(source.node);
+	if (target.node !== null && !(yield* nodeExists(persistence, scope.workspaceId, target.nodeId))) nodes.push(target.node);
+	const confidence = candidate.confidence === null ? {
+		_tag: "unknown",
+		rationale: "No matching provider evidence is currently synchronized."
+	} : {
+		_tag: "inferred",
+		...candidate.confidence
+	};
+	const relationship = {
+		workspaceId: scope.workspaceId,
+		relationshipId,
+		relationshipSchemaVersion: 1,
+		revision: LedgerRevision.make((previous?.revision ?? 0) + 1),
+		supersedesRevision: previous?.revision ?? null,
+		kind: candidate.kind,
+		sourceNodeId: source.nodeId,
+		sourceNodeKind: candidate.source.kind,
+		targetNodeId: target.nodeId,
+		targetNodeKind: candidate.target.kind,
+		scope: {
+			_tag: "release",
+			releaseId: candidate.releaseId
+		},
+		lifecycle: candidate.lifecycle === "missing" ? {
+			_tag: "missing",
+			effectiveAt: scope.committedAt,
+			reason: "No synchronized provider evidence currently resolves this required delivery link."
+		} : {
+			_tag: "inferred",
+			effectiveAt: scope.committedAt
+		},
+		confidence,
+		provenance: {
+			_tag: "rule",
+			ruleId: candidate.ruleId,
+			ruleVersion: 1,
+			rationale: candidate.confidence?.rationale ?? "Required delivery link has no synchronized match."
+		},
+		recordedBy: {
+			_tag: "system",
+			component: COMPONENT
+		},
+		evidenceClaimIds: evidence === null ? [] : [evidence.claim.evidenceClaimId],
+		recordedAt: scope.committedAt
+	};
+	return {
+		...yield* writeGraph$1(persistence, scope.workspaceId, {
+			entityProjections: [],
+			nodes,
+			evidenceItems: evidence === null ? [] : [evidence.item],
+			evidenceClaims: evidence === null ? [] : [evidence.claim],
+			relationships: [relationship]
+		}),
+		skippedDueToBounds: false
+	};
+});
+var supersedeObsoleteGap = Effect.fn("RelationshipInferenceMaterialization.supersedeObsoleteGap")(function* (persistence, identity, scope, identityKey) {
+	const relationshipId = yield* relationshipIdFor(identity, scope.workspaceId, identityKey);
+	const previous = yield* readRelationship(persistence, scope.workspaceId, relationshipId);
+	if (previous?.lifecycle._tag !== "missing") return 0;
+	const relationship = {
+		...previous,
+		revision: LedgerRevision.make(previous.revision + 1),
+		supersedesRevision: previous.revision,
+		lifecycle: {
+			_tag: "superseded",
+			effectiveAt: scope.committedAt,
+			reason: "New synchronized evidence resolved the previously missing link."
+		},
+		recordedAt: scope.committedAt
+	};
+	return (yield* writeGraph$1(persistence, scope.workspaceId, {
+		entityProjections: [],
+		nodes: [],
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: [relationship]
+	})).relationshipCount;
+});
+var supersedeObsoleteRelationship = Effect.fn("RelationshipInferenceMaterialization.supersedeObsoleteRelationship")(function* (persistence, scope, relationshipId, reason) {
+	const previous = yield* readRelationship(persistence, scope.workspaceId, relationshipId);
+	if (previous?.lifecycle._tag !== "inferred" && previous?.lifecycle._tag !== "missing") return 0;
+	const relationship = {
+		...previous,
+		revision: LedgerRevision.make(previous.revision + 1),
+		supersedesRevision: previous.revision,
+		lifecycle: {
+			_tag: "superseded",
+			effectiveAt: scope.committedAt,
+			reason: reason ?? (previous.lifecycle._tag === "missing" ? "The entity is no longer in the release scope that required this missing link." : "Current synchronized metadata no longer supports this inferred link.")
+		},
+		recordedAt: scope.committedAt
+	};
+	return (yield* writeGraph$1(persistence, scope.workspaceId, {
+		entityProjections: [],
+		nodes: [],
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: [relationship]
+	})).relationshipCount;
+});
+var emptyReceipt = (skippedDueToBounds) => ({
+	evidenceClaimCount: 0,
+	evidenceItemCount: 0,
+	nodeCount: 0,
+	relationshipCount: 0,
+	skippedDueToBounds
+});
+var retireInferenceForReleases = Effect.fn("RelationshipInferenceMaterialization.retireInferenceForReleases")(function* (persistence, scope, releaseIds, reason) {
+	const reads = yield* Effect.forEach(releaseIds ?? [null], (releaseId) => persistence.deliveryGraph.read(scope.workspaceId, {
+		_tag: "componentRelationships",
+		releaseId,
+		component: COMPONENT,
+		limit: MAXIMUM_INFERENCE_RELATIONSHIPS
+	}));
+	if (reads.some((read) => read._tag !== "componentRelationships" || read.value.truncated)) return emptyReceipt(true);
+	const relationshipIds = new Set(reads.flatMap((read) => read._tag === "componentRelationships" ? read.value.relationships.map(({ relationshipId }) => relationshipId) : []));
+	let relationshipCount = 0;
+	for (const relationshipId of relationshipIds) relationshipCount += yield* supersedeObsoleteRelationship(persistence, scope, relationshipId, reason);
+	return {
+		...emptyReceipt(true),
+		relationshipCount
+	};
+});
+var retireInferenceAtEntityBound = Effect.fn("RelationshipInferenceMaterialization.retireInferenceAtEntityBound")(function* (persistence, scope) {
+	return yield* retireInferenceForReleases(persistence, scope, null, "Inference inputs exceeded the bounded workspace snapshot, so this relationship can no longer be proven.");
+});
+/** Persist current rule candidates after a normalized page has committed. */
+var materializeRelationshipInference = Effect.fn("RelationshipInferenceMaterialization.reconcile")(function* (persistence, identity, scope) {
+	const projectionResult = yield* persistence.deliveryGraph.read(scope.workspaceId, {
+		_tag: "workspaceEntityProjections",
+		owner: null,
+		query: null,
+		service: null,
+		status: null,
+		type: null,
+		limit: MAXIMUM_INFERENCE_ENTITIES
+	});
+	if (projectionResult._tag !== "workspaceEntityProjections") return emptyReceipt(true);
+	if (projectionResult.value.truncated) return yield* retireInferenceAtEntityBound(persistence, scope);
+	const records = yield* Effect.forEach(projectionResult.value.items, ({ projection }) => persistence.entities.get(scope.workspaceId, projection.entityId), { concurrency: 10 });
+	const entityById = new Map(records.map((record) => [record.entityId, record]));
+	const entities = [];
+	for (const item of projectionResult.value.items) {
+		const entity = entityById.get(item.projection.entityId);
+		if (entity === void 0) continue;
+		entities.push({
+			projection: item.projection,
+			releaseIds: item.releaseIds,
+			nodeId: GraphNodeId.make(yield* identity(entityNodeIdentity(scope.workspaceId, entity)))
+		});
+	}
+	const releases = yield* persistence.releases.list(scope.workspaceId, 51);
+	if (releases.length > MAXIMUM_INFERENCE_RELEASES) return yield* retireInferenceAtEntityBound(persistence, scope);
+	const inferenceReleases = [];
+	for (const { release } of releases) {
+		const candidates = yield* Effect.forEach(release.sourceRevisions, (source) => Effect.gen(function* () {
+			const nodeId = GraphNodeId.make(yield* identity(releaseNodeIdentity(scope.workspaceId, source.pluginConnectionId, source.providerId, source.vendorImmutableId)));
+			return {
+				exists: yield* nodeExists(persistence, scope.workspaceId, nodeId),
+				nodeId
+			};
+		}));
+		const selected = candidates.find(({ exists }) => exists) ?? candidates[0];
+		if (selected === void 0) continue;
+		inferenceReleases.push({
+			inferenceRelease: {
+				nodeId: selected.nodeId,
+				releaseId: release.id,
+				version: release.version
+			},
+			node: selected.exists ? null : {
+				workspaceId: scope.workspaceId,
+				nodeId: selected.nodeId,
+				endpointKind: "release",
+				resolution: {
+					_tag: "resolved",
+					target: {
+						_tag: "release",
+						releaseId: release.id
+					}
+				},
+				createdAt: scope.committedAt
+			}
+		});
+	}
+	const releaseIds = releases.map(({ release }) => release.id);
+	const slices = yield* Effect.forEach(releaseIds, (releaseId) => persistence.deliveryGraph.read(scope.workspaceId, {
+		_tag: "releaseSlice",
+		releaseId,
+		environmentId: null,
+		limit: MAXIMUM_INFERENCE_ENTITIES
+	}));
+	const truncatedReleaseIds = slices.flatMap((slice, index) => {
+		const releaseId = releaseIds[index];
+		return releaseId !== void 0 && (slice._tag !== "releaseSlice" || slice.value.truncated) ? [releaseId] : [];
+	});
+	if (truncatedReleaseIds.length > 0) return yield* retireInferenceForReleases(persistence, scope, truncatedReleaseIds, "The bounded release relationship snapshot was incomplete, so this inference can no longer be proven.");
+	const relationships = slices.flatMap((slice) => slice._tag === "releaseSlice" ? slice.value.relationships : []);
+	const inferenceInput = {
+		entities,
+		releases: inferenceReleases.map(({ inferenceRelease }) => inferenceRelease),
+		relationships
+	};
+	const initialInference = deriveRelationshipInference(inferenceInput);
+	const rejectedCandidateIdentityKeys = /* @__PURE__ */ new Set();
+	for (const candidate of initialInference.candidates) {
+		if (candidate.lifecycle !== "inferred") continue;
+		const relationshipId = yield* relationshipIdFor(identity, scope.workspaceId, candidate.identityKey);
+		if ((yield* readRelationship(persistence, scope.workspaceId, relationshipId))?.lifecycle._tag === "rejected") rejectedCandidateIdentityKeys.add(candidate.identityKey);
+	}
+	const inference = rejectedCandidateIdentityKeys.size === 0 ? initialInference : deriveRelationshipInference({
+		...inferenceInput,
+		rejectedCandidateIdentityKeys
+	});
+	if (inference.truncated) return yield* retireInferenceAtEntityBound(persistence, scope);
+	let receipt = emptyReceipt(false);
+	const missingReleaseNodes = inferenceReleases.flatMap(({ node }) => node === null ? [] : [node]);
+	if (missingReleaseNodes.length > 0) {
+		const current = yield* writeGraph$1(persistence, scope.workspaceId, {
+			entityProjections: [],
+			nodes: missingReleaseNodes,
+			evidenceItems: [],
+			evidenceClaims: [],
+			relationships: []
+		});
+		receipt = {
+			...receipt,
+			nodeCount: current.nodeCount
+		};
+	}
+	for (const candidate of inference.candidates) {
+		const current = yield* materializeCandidate(persistence, identity, scope, candidate, entityById);
+		receipt = {
+			evidenceClaimCount: receipt.evidenceClaimCount + current.evidenceClaimCount,
+			evidenceItemCount: receipt.evidenceItemCount + current.evidenceItemCount,
+			nodeCount: receipt.nodeCount + current.nodeCount,
+			relationshipCount: receipt.relationshipCount + current.relationshipCount,
+			skippedDueToBounds: false
+		};
+	}
+	for (const identityKey of inference.obsoleteGapIdentityKeys) receipt = {
+		...receipt,
+		relationshipCount: receipt.relationshipCount + (yield* supersedeObsoleteGap(persistence, identity, scope, identityKey))
+	};
+	for (const relationshipId of inference.obsoleteRelationshipIds) receipt = {
+		...receipt,
+		relationshipCount: receipt.relationshipCount + (yield* supersedeObsoleteRelationship(persistence, scope, relationshipId))
+	};
+	return receipt;
+});
+//#endregion
+//#region src/server/application/normalizedPluginPageMaterialization.ts
+var OptionalText = Schema.optionalKey(Schema.NullOr(Schema.String));
+var NamedText = Schema.Union([Schema.String, Schema.Struct({ name: Schema.optionalKey(Schema.NullOr(Schema.String)) })]);
+var EntityAttributes = Schema.Struct({
+	key: OptionalText,
+	status: Schema.optionalKey(Schema.NullOr(NamedText)),
+	priority: Schema.optionalKey(Schema.NullOr(NamedText)),
+	estimatePoints: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+	repository: OptionalText,
+	sourceBranch: OptionalText,
+	targetBranch: OptionalText,
+	headRevision: OptionalText,
+	reviewState: OptionalText,
+	spaceKey: OptionalText,
+	spaceId: OptionalText,
+	currentVersion: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+	linkedIssueKeys: Schema.optionalKey(Schema.Array(Schema.String)),
+	linkedReleaseVersions: Schema.optionalKey(Schema.Array(Schema.String)),
+	pipelineName: OptionalText,
+	executionId: OptionalText,
+	triggerRevision: OptionalText,
+	sourceRevisions: Schema.optionalKey(Schema.Array(Schema.Struct({ revisionId: OptionalText }))),
+	environmentId: OptionalText,
+	revision: OptionalText,
+	durationMinutes: Schema.optionalKey(Schema.NullOr(Schema.Number)),
+	billable: Schema.optionalKey(Schema.Boolean),
+	approvalState: OptionalText,
+	interval: Schema.optionalKey(Schema.Struct({
+		duration: OptionalText,
+		state: OptionalText
+	}))
+});
+var LegacyIssueAttributes = Schema.Struct({
+	key: OptionalText,
+	status: Schema.optionalKey(Schema.NullOr(NamedText)),
+	priority: Schema.optionalKey(Schema.NullOr(NamedText)),
+	estimatePoints: Schema.optionalKey(Schema.NullOr(Schema.Number))
+});
+var LegacyIssueAttributeKeys = /* @__PURE__ */ new Set([
+	"key",
+	"status",
+	"priority",
+	"estimatePoints",
+	"schemaVersion",
+	"summary"
+]);
+var ReleaseAttributes = Schema.Struct({
+	serviceName: Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(200)),
+	version: Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(100)),
+	lifecycle: Schema.Literals([
+		"assembling",
+		"candidate",
+		"deploying",
+		"released",
+		"cancelled"
+	])
+});
+var JiraIssueRelationshipSnapshot = Schema.Struct({
+	fixVersions: Schema.Array(Schema.Struct({ sourceId: Schema.NullOr(Schema.String) })),
+	truncatedFields: Schema.Array(Schema.String)
+});
+var EvidenceData = Schema.Struct({
+	predicate: Schema.optionalKey(EvidencePredicate),
+	value: Schema.optionalKey(EvidenceValue)
+});
+/** Redacted failure raised before a normalized page can become a canonical projection. */
+var NormalizedPluginPageMaterializationError = class extends Schema.TaggedErrorClass()("NormalizedPluginPageMaterializationError", {
+	diagnosticCode: Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(100)),
+	eventId: Schema.NullOr(Schema.String.check(Schema.isTrimmed(), Schema.isNonEmpty(), Schema.isMaxLength(512)))
+}) {};
+var malformed = (diagnosticCode, eventId = null) => new NormalizedPluginPageMaterializationError({
+	diagnosticCode,
+	eventId
+});
+var decodedAttributes = Effect.fn("NormalizedPluginPageMaterialization.decodeAttributes")(function* (event) {
+	return yield* Schema.decodeUnknownEffect(EntityAttributes)(event.attributes).pipe(Effect.mapError(() => malformed("normalized-entity-attributes-invalid", event.eventId)));
+});
+var bounded = (value, fallback, maximum) => {
+	const normalized = value?.trim();
+	return (normalized === void 0 || normalized.length === 0 ? fallback : normalized).slice(0, maximum);
+};
+var namedText = (value) => typeof value === "string" ? value : value?.name ?? null;
+var decodedIssueAttributes = Effect.fn("NormalizedPluginPageMaterialization.decodeIssueAttributes")(function* (event) {
+	const normalized = Schema.decodeUnknownResult(NormalizedIssueAttributes)(event.attributes);
+	if (Result.isSuccess(normalized)) return normalized.success;
+	if (Object.keys(event.attributes).some((key) => !LegacyIssueAttributeKeys.has(key))) return yield* malformed("normalized-issue-attributes-invalid", event.eventId);
+	const legacy = yield* Schema.decodeUnknownEffect(LegacyIssueAttributes)(event.attributes).pipe(Effect.mapError(() => malformed("normalized-issue-attributes-invalid", event.eventId)));
+	const key = bounded(legacy.key, event.vendorImmutableId, 100);
+	return yield* Schema.decodeUnknownEffect(NormalizedIssueAttributes)({
+		key,
+		status: bounded(namedText(legacy.status), "unknown", 100),
+		priority: legacy.priority === null || legacy.priority === void 0 ? null : bounded(namedText(legacy.priority), "unknown", 100),
+		estimatePoints: legacy.estimatePoints ?? null
+	}).pipe(Effect.mapError(() => malformed("normalized-issue-attributes-invalid", event.eventId)));
+});
+var canonicalKind = (entityType) => {
+	switch (entityType) {
+		case "issue":
+		case "jira.issue": return "issue";
+		case "pull-request": return "pull-request";
+		case "page":
+		case "confluence-page": return "page";
+		case "pipeline-execution":
+		case "aws.codepipeline.execution": return "pipeline-execution";
+		case "deployment": return "deployment";
+		case "time-entry":
+		case "clockify.time-entry": return "time-entry";
+		default: return null;
+	}
+};
+var reviewState = (value) => {
+	switch (value?.toLowerCase()) {
+		case "requested":
+		case "open": return "requested";
+		case "changes-requested":
+		case "changes requested": return "changes-requested";
+		case "approved": return "approved";
+		case "merged":
+		case "closed": return "merged";
+		default: return "not-requested";
+	}
+};
+var pipelineStatus = (value) => {
+	switch (value?.toLowerCase()) {
+		case "inprogress":
+		case "in-progress":
+		case "running": return "running";
+		case "succeeded":
+		case "success": return "succeeded";
+		case "failed":
+		case "failure": return "failed";
+		case "stopped":
+		case "stopping":
+		case "superseded":
+		case "abandoned": return "stopped";
+		default: return "queued";
+	}
+};
+var isoDurationMinutes = (value) => {
+	if (value === null || value === void 0) return 0;
+	const match = /^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/u.exec(value);
+	if (match === null) return 0;
+	const hours = Number(match[1] ?? 0);
+	const minutes = Number(match[2] ?? 0);
+	const seconds = Number(match[3] ?? 0);
+	return Math.max(0, Math.round(hours * 60 + minutes + seconds / 60));
+};
+var entityPresentation = Effect.fn("NormalizedPluginPageMaterialization.entityPresentation")(function* (event, kind) {
+	const attributes = yield* decodedAttributes(event);
+	switch (kind) {
+		case "issue": {
+			const issueAttributes = yield* decodedIssueAttributes(event);
+			return {
+				displayKey: issueAttributes.key,
+				details: {
+					_tag: "issue",
+					...issueAttributes
+				}
+			};
+		}
+		case "pull-request": return {
+			displayKey: bounded(event.vendorImmutableId, event.vendorImmutableId, 200),
+			details: {
+				_tag: "pull-request",
+				repository: bounded(attributes.repository, "unknown", 200),
+				sourceBranch: bounded(attributes.sourceBranch, "unknown", 500),
+				targetBranch: bounded(attributes.targetBranch, "unknown", 500),
+				headRevision: bounded(attributes.headRevision, event.revision, 512),
+				reviewState: reviewState(attributes.reviewState ?? namedText(attributes.status))
+			}
+		};
+		case "page": return {
+			displayKey: bounded(event.vendorImmutableId, event.vendorImmutableId, 200),
+			details: {
+				_tag: "page",
+				spaceKey: bounded(attributes.spaceKey ?? attributes.spaceId, "unknown", 100),
+				revision: bounded(attributes.currentVersion === null || attributes.currentVersion === void 0 ? attributes.revision : String(attributes.currentVersion), event.revision, 512),
+				status: namedText(attributes.status)?.toLowerCase() === "superseded" ? "superseded" : "current",
+				linkedIssueKeys: attributes.linkedIssueKeys?.map((key) => key.trim()).filter((key, index, keys) => key.length > 0 && key.length <= 100 && keys.indexOf(key) === index).slice(0, 100),
+				linkedReleaseVersions: attributes.linkedReleaseVersions?.map((version) => version.trim()).filter((version, index, versions) => version.length > 0 && version.length <= 100 && versions.indexOf(version) === index).slice(0, 100)
+			}
+		};
+		case "pipeline-execution": {
+			const executionId = bounded(attributes.executionId, event.vendorImmutableId, 512);
+			const pipelineName = bounded(attributes.pipelineName, "unknown", 200);
+			const sourceRevision = attributes.sourceRevisions?.find(({ revisionId }) => revisionId !== null)?.revisionId;
+			return {
+				displayKey: bounded(`${pipelineName}/${executionId}`, executionId, 200),
+				details: {
+					_tag: "pipeline-execution",
+					pipelineName,
+					executionId,
+					status: pipelineStatus(namedText(attributes.status)),
+					triggerRevision: bounded(attributes.triggerRevision ?? sourceRevision, event.revision, 512)
+				}
+			};
+		}
+		case "deployment": {
+			const environmentId = yield* Schema.decodeUnknownEffect(EnvironmentId)(attributes.environmentId).pipe(Effect.mapError(() => malformed("normalized-deployment-environment-invalid", event.eventId)));
+			const status = pipelineStatus(namedText(attributes.status));
+			return {
+				displayKey: bounded(event.vendorImmutableId, event.vendorImmutableId, 200),
+				details: {
+					_tag: "deployment",
+					environmentId,
+					revision: bounded(attributes.revision, event.revision, 512),
+					status: status === "queued" ? "pending" : status === "running" ? "deploying" : status === "stopped" ? "rolled-back" : status
+				}
+			};
+		}
+		case "time-entry": return {
+			displayKey: bounded(event.vendorImmutableId, event.vendorImmutableId, 200),
+			details: {
+				_tag: "time-entry",
+				durationMinutes: Math.max(0, Math.round(attributes.durationMinutes ?? isoDurationMinutes(attributes.interval?.duration))),
+				billable: attributes.billable ?? false,
+				approvalState: attributes.approvalState === "approved" || attributes.approvalState === "rejected" ? attributes.approvalState : attributes.interval?.state === "running" ? "pending" : "not-required"
+			}
+		};
+	}
+});
+var stableUuid = Effect.fn("NormalizedPluginPageMaterialization.stableUuid")(function* (cryptoService, identity, eventId) {
+	const bytes = yield* Effect.fromResult(Encoding.decodeBase64(Encoding.encodeBase64(identity))).pipe(Effect.mapError(() => malformed("normalized-identity-encoding-failed", eventId)));
+	const digest = yield* cryptoService.digest("SHA-256", bytes).pipe(Effect.mapError(() => malformed("normalized-identity-digest-failed", eventId)));
+	const hex = Encoding.encodeHex(digest);
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-7${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+});
+var sourceIdentity = (scope, vendorImmutableId) => ({
+	pluginConnectionId: scope.pluginConnectionId,
+	providerId: scope.providerId,
+	vendorImmutableId
+});
+var findEntity = Effect.fn("NormalizedPluginPageMaterialization.findEntity")(function* (persistence, scope, vendorImmutableId) {
+	const found = yield* persistence.entities.findBySourceIdentity(scope.workspaceId, sourceIdentity(scope, vendorImmutableId)).pipe(Effect.result);
+	if (Result.isSuccess(found)) return found.success;
+	if (found.failure._tag === "RecordNotFoundError") return null;
+	return yield* found.failure;
+});
+var readProjection = Effect.fn("NormalizedPluginPageMaterialization.readProjection")(function* (persistence, workspaceId, entityId) {
+	const found = yield* persistence.deliveryGraph.read(workspaceId, {
+		_tag: "entityProjection",
+		entityId,
+		revision: null
+	}).pipe(Effect.result);
+	if (Result.isSuccess(found)) return found.success._tag === "entityProjection" ? found.success.value : null;
+	if (found.failure._tag === "RecordNotFoundError") return null;
+	return yield* found.failure;
+});
+var materializationKey = (scope, kind, externalId) => `${scope.workspaceId}\u0000${scope.pluginConnectionId}\u0000${scope.providerId}\u0000${kind}\u0000${externalId}`;
+var entityIdFor = Effect.fn("NormalizedPluginPageMaterialization.entityIdFor")(function* (cryptoService, scope, vendorImmutableId, eventId) {
+	return EntityId.make(yield* stableUuid(cryptoService, materializationKey(scope, "entity", vendorImmutableId), eventId));
+});
+var nodeIdFor = Effect.fn("NormalizedPluginPageMaterialization.nodeIdFor")(function* (cryptoService, scope, vendorImmutableId, eventId) {
+	return GraphNodeId.make(yield* stableUuid(cryptoService, materializationKey(scope, "entity-node", vendorImmutableId), eventId));
+});
+var releaseIdFor = Effect.fn("NormalizedPluginPageMaterialization.releaseIdFor")(function* (cryptoService, scope, vendorImmutableId, eventId) {
+	return ReleaseId.make(yield* stableUuid(cryptoService, materializationKey(scope, "release", vendorImmutableId), eventId));
+});
+var releaseNodeIdFor = Effect.fn("NormalizedPluginPageMaterialization.releaseNodeIdFor")(function* (cryptoService, scope, vendorImmutableId, eventId) {
+	return GraphNodeId.make(yield* stableUuid(cryptoService, materializationKey(scope, "release-node", vendorImmutableId), eventId));
+});
+var sourceRevision = (scope, event, firstObservedAt, sourceUrl) => ({
+	...sourceIdentity(scope, event.vendorImmutableId),
+	revision: event.revision,
+	sourceUrl,
+	firstObservedAt,
+	lastObservedAt: event.observedAt,
+	synchronizedAt: scope.committedAt,
+	normalizationSchemaVersion: NormalizationSchemaVersion.make(1)
+});
+var laterTimestamp = (left, right) => DateTime.Order(left, right) >= 0 ? left : right;
+var sameSourceUrl = (left, right) => left?.href === right?.href;
+var writeGraph = Effect.fn("NormalizedPluginPageMaterialization.writeGraph")(function* (persistence, workspaceId, batch, eventId) {
+	const encoded = yield* Schema.encodeEffect(DeliveryGraphWriteBatch)(batch).pipe(Effect.mapError(() => malformed("normalized-delivery-graph-batch-invalid", eventId)));
+	return yield* persistence.deliveryGraph.write(workspaceId, encoded);
+});
+var materializeUpsertEntity = Effect.fn("NormalizedPluginPageMaterialization.upsertEntity")(function* (persistence, cryptoService, scope, event) {
+	const kind = canonicalKind(event.entityType);
+	if (kind === null) return {
+		entityProjectionCount: 0,
+		nodeCount: 0,
+		skippedEntityCount: 1
+	};
+	const presentation = yield* entityPresentation(event, kind);
+	const existing = yield* findEntity(persistence, scope, event.vendorImmutableId);
+	const entityId = existing?.entityId ?? (yield* entityIdFor(cryptoService, scope, event.vendorImmutableId, event.eventId));
+	const currentProjection = existing === null ? null : yield* readProjection(persistence, scope.workspaceId, entityId);
+	if (existing !== null && existing.sourceRevision.revision === event.revision && currentProjection?.projection.entityState === "present") return {
+		entityProjectionCount: 0,
+		nodeCount: 0,
+		skippedEntityCount: 0
+	};
+	const persisted = existing === null ? yield* persistence.entities.create(scope.workspaceId, {
+		entityId,
+		entityType: kind,
+		sourceRevision: sourceRevision(scope, event, event.observedAt, event.sourceUrl),
+		createdAt: scope.committedAt
+	}) : existing.sourceRevision.revision === event.revision ? existing : yield* persistence.entities.updateSourceRevision(scope.workspaceId, entityId, {
+		sourceRevision: sourceRevision(scope, event, existing.sourceRevision.firstObservedAt, event.sourceUrl),
+		expectedRevision: existing.revision,
+		updatedAt: scope.committedAt
+	});
+	const projectionRevision = LedgerRevision.make((currentProjection?.projection.projectionRevision ?? 0) + 1);
+	const nodeId = yield* nodeIdFor(cryptoService, scope, event.vendorImmutableId, event.eventId);
+	const batch = {
+		entityProjections: [{
+			projection: {
+				workspaceId: scope.workspaceId,
+				entityId,
+				projectionRevision,
+				sourceEntityRevision: LedgerRevision.make(persisted.revision),
+				supersedesProjectionRevision: currentProjection?.projection.projectionRevision ?? null,
+				projectionSchemaVersion: 1,
+				entityState: "present",
+				entityType: kind,
+				displayKey: presentation.displayKey,
+				title: event.title,
+				details: presentation.details
+			},
+			recordedAt: scope.committedAt
+		}],
+		nodes: currentProjection === null ? [{
+			workspaceId: scope.workspaceId,
+			nodeId,
+			endpointKind: kind,
+			resolution: {
+				_tag: "resolved",
+				target: {
+					_tag: "entity",
+					entityId,
+					entityKind: kind
+				}
+			},
+			createdAt: scope.committedAt
+		}] : [],
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: []
+	};
+	return {
+		...yield* writeGraph(persistence, scope.workspaceId, batch, event.eventId),
+		skippedEntityCount: 0
+	};
+});
+var materializeRelease = Effect.fn("NormalizedPluginPageMaterialization.upsertRelease")(function* (persistence, cryptoService, scope, event) {
+	const attributes = yield* Schema.decodeUnknownEffect(ReleaseAttributes)(event.attributes).pipe(Effect.mapError(() => malformed("normalized-release-attributes-invalid", event.eventId)));
+	const releaseId = yield* releaseIdFor(cryptoService, scope, event.vendorImmutableId, event.eventId);
+	const existing = yield* persistence.releases.get(scope.workspaceId, releaseId).pipe(Effect.result);
+	if (Result.isFailure(existing) && existing.failure._tag !== "RecordNotFoundError") return yield* existing.failure;
+	const previous = Result.isSuccess(existing) ? existing.success : null;
+	const previousSource = previous?.release.sourceRevisions.find(({ pluginConnectionId, providerId, vendorImmutableId }) => pluginConnectionId === scope.pluginConnectionId && providerId === scope.providerId && vendorImmutableId === event.vendorImmutableId);
+	const observedAt = previousSource === void 0 ? event.observedAt : laterTimestamp(previousSource.lastObservedAt, event.observedAt);
+	const refreshedSource = {
+		...sourceRevision(scope, event, previousSource?.firstObservedAt ?? event.observedAt, event.sourceUrl),
+		lastObservedAt: observedAt
+	};
+	const sourceAgeSeconds = Math.max(0, (DateTime.toEpochMillis(scope.committedAt) - DateTime.toEpochMillis(observedAt)) / 1e3);
+	const release = yield* Schema.decodeUnknownEffect(Schema.toType(Release))({
+		createdAt: previous?.release.createdAt ?? event.observedAt,
+		freshness: {
+			_tag: "current",
+			evaluatedAt: scope.committedAt,
+			pluginHealth: scope.successfulHealth,
+			provenance: {
+				_tag: "provider",
+				sourceRevision: refreshedSource
+			},
+			sourceObservedAt: observedAt,
+			staleAfterSeconds: Math.max(1, Math.ceil(sourceAgeSeconds) + 86400),
+			synchronizedAt: scope.committedAt
+		},
+		id: releaseId,
+		lifecycle: attributes.lifecycle,
+		relay: deriveReleaseRelay(releaseId),
+		roleAssignments: previous?.release.roleAssignments ?? [],
+		serviceName: attributes.serviceName,
+		sourceRevisions: [...previous?.release.sourceRevisions.filter(({ pluginConnectionId, providerId, vendorImmutableId }) => pluginConnectionId !== scope.pluginConnectionId || providerId !== scope.providerId || vendorImmutableId !== event.vendorImmutableId) ?? [], refreshedSource],
+		targetEnvironmentIds: previous?.release.targetEnvironmentIds ?? [],
+		updatedAt: scope.committedAt,
+		version: attributes.version,
+		workspaceId: scope.workspaceId
+	}).pipe(Effect.mapError(() => malformed("normalized-release-invalid", event.eventId)));
+	if (previous === null) yield* persistence.releases.create(scope.workspaceId, release);
+	else if (previousSource === void 0 || previousSource.revision !== refreshedSource.revision || !sameSourceUrl(previousSource.sourceUrl, refreshedSource.sourceUrl) || !DateTime.Equivalence(previousSource.lastObservedAt, refreshedSource.lastObservedAt) || !DateTime.Equivalence(previousSource.synchronizedAt, refreshedSource.synchronizedAt) || previous.release.serviceName !== release.serviceName || previous.release.version !== release.version || previous.release.lifecycle !== release.lifecycle) yield* persistence.releases.append(scope.workspaceId, release, previous.revision);
+	const nodeId = yield* releaseNodeIdFor(cryptoService, scope, event.vendorImmutableId, event.eventId);
+	const existingNode = yield* persistence.deliveryGraph.read(scope.workspaceId, {
+		_tag: "node",
+		nodeId
+	}).pipe(Effect.result);
+	if (Result.isSuccess(existingNode)) return { nodeCount: 0 };
+	if (existingNode.failure._tag !== "RecordNotFoundError") return yield* existingNode.failure;
+	return { nodeCount: (yield* writeGraph(persistence, scope.workspaceId, {
+		entityProjections: [],
+		nodes: [{
+			workspaceId: scope.workspaceId,
+			nodeId,
+			endpointKind: "release",
+			resolution: {
+				_tag: "resolved",
+				target: {
+					_tag: "release",
+					releaseId
+				}
+			},
+			createdAt: scope.committedAt
+		}],
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: []
+	}, event.eventId)).nodeCount };
+});
+var materializeTombstoneEntity = Effect.fn("NormalizedPluginPageMaterialization.tombstoneEntity")(function* (persistence, scope, event) {
+	const existing = yield* findEntity(persistence, scope, event.vendorImmutableId);
+	if (existing === null) return { entityProjectionCount: 0 };
+	const current = yield* readProjection(persistence, scope.workspaceId, existing.entityId);
+	if (current === null) return yield* malformed("normalized-tombstone-projection-missing", event.eventId);
+	if (existing.sourceRevision.revision === event.revision && current.projection.entityState === "deleted") return { entityProjectionCount: 0 };
+	const persisted = existing.sourceRevision.revision === event.revision ? existing : yield* persistence.entities.updateSourceRevision(scope.workspaceId, existing.entityId, {
+		sourceRevision: sourceRevision(scope, event, existing.sourceRevision.firstObservedAt, existing.sourceRevision.sourceUrl),
+		expectedRevision: existing.revision,
+		updatedAt: scope.committedAt
+	});
+	const projectionRevision = LedgerRevision.make(current.projection.projectionRevision + 1);
+	return { entityProjectionCount: (yield* writeGraph(persistence, scope.workspaceId, {
+		entityProjections: [{
+			projection: {
+				...current.projection,
+				projectionRevision,
+				sourceEntityRevision: LedgerRevision.make(persisted.revision),
+				supersedesProjectionRevision: current.projection.projectionRevision,
+				entityState: "deleted"
+			},
+			recordedAt: scope.committedAt
+		}],
+		nodes: [],
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: []
+	}, event.eventId)).entityProjectionCount };
+});
+var materializePerson = Effect.fn("NormalizedPluginPageMaterialization.upsertPerson")(function* (persistence, cryptoService, scope, event) {
+	const identity = {
+		pluginConnectionId: scope.pluginConnectionId,
+		providerId: scope.providerId,
+		vendorPersonId: VendorImmutableId.make(event.vendorPersonId)
+	};
+	const existing = yield* persistence.people.findPersonBySourceIdentity(scope.workspaceId, identity).pipe(Effect.result);
+	if (Result.isFailure(existing) && existing.failure._tag !== "RecordNotFoundError") return yield* existing.failure;
+	const personId = Result.isSuccess(existing) ? existing.success.person.personId : PersonId.make(yield* stableUuid(cryptoService, materializationKey(scope, "person", event.vendorPersonId), event.eventId));
+	const avatar = event.avatarUrl !== null && event.avatarUrl.toString().length <= 500 ? {
+		_tag: "reference",
+		reference: event.avatarUrl.toString()
+	} : {
+		_tag: "initials",
+		text: derivePersonInitials(event.displayName)
+	};
+	const person = yield* Schema.decodeUnknownEffect(Schema.toType(Person))({
+		personId,
+		displayName: event.displayName,
+		avatar,
+		isActive: event.active,
+		sourceIdentities: Result.isSuccess(existing) ? existing.success.person.sourceIdentities : [identity]
+	}).pipe(Effect.mapError(() => malformed("normalized-person-invalid", event.eventId)));
+	if (Result.isSuccess(existing) && existing.success.person.displayName === person.displayName && existing.success.person.isActive === person.isActive && existing.success.person.avatar._tag === person.avatar._tag && (existing.success.person.avatar._tag === "initials" ? existing.success.person.avatar.text === (person.avatar._tag === "initials" ? person.avatar.text : "") : existing.success.person.avatar.reference === (person.avatar._tag === "reference" ? person.avatar.reference : ""))) return 0;
+	if (Result.isSuccess(existing)) yield* persistence.people.updatePerson(scope.workspaceId, person, existing.success.revision, scope.committedAt);
+	else yield* persistence.people.createPerson(scope.workspaceId, person, scope.committedAt);
+	return 1;
+});
+var evidencePredicate = (event) => {
+	const decoded = Schema.decodeUnknownResult(EvidencePredicate)(event.evidenceType);
+	if (Result.isSuccess(decoded)) return decoded.success;
+	return "status-observed";
+};
+var materializeEvidence = Effect.fn("NormalizedPluginPageMaterialization.appendEvidence")(function* (persistence, cryptoService, scope, event) {
+	const subject = yield* findEntity(persistence, scope, event.subject.vendorImmutableId);
+	if (subject === null) return yield* malformed("normalized-evidence-subject-missing", event.eventId);
+	if (canonicalKind(event.subject.entityType) === null) return yield* malformed("normalized-evidence-subject-unsupported", event.eventId);
+	const nodeId = yield* nodeIdFor(cryptoService, scope, event.subject.vendorImmutableId, event.eventId);
+	const evidenceId = EvidenceId.make(yield* stableUuid(cryptoService, materializationKey(scope, "evidence", event.evidenceId), event.eventId));
+	const evidenceClaimId = EvidenceClaimId.make(yield* stableUuid(cryptoService, materializationKey(scope, "evidence-claim", event.evidenceId), event.eventId));
+	const decodedData = Schema.decodeUnknownResult(EvidenceData)(event.data);
+	const predicate = Result.isSuccess(decodedData) && decodedData.success.predicate !== void 0 ? decodedData.success.predicate : evidencePredicate(event);
+	const value = Result.isSuccess(decodedData) && decodedData.success.value !== void 0 ? decodedData.success.value : {
+		_tag: "state",
+		value: event.summary
+	};
+	const source = subject.sourceRevision;
+	const ageSeconds = Math.max(0, (DateTime.toEpochMillis(scope.committedAt) - DateTime.toEpochMillis(source.lastObservedAt)) / 1e3);
+	const health = scope.successfulHealth._tag === "healthy" ? {
+		_tag: "healthy",
+		checkedAt: scope.committedAt
+	} : {
+		...scope.successfulHealth,
+		checkedAt: scope.committedAt
+	};
+	const receipt = yield* writeGraph(persistence, scope.workspaceId, {
+		entityProjections: [],
+		nodes: [],
+		evidenceItems: [{
+			workspaceId: scope.workspaceId,
+			evidenceId,
+			schemaVersion: 1,
+			attribution: {
+				_tag: "plugin",
+				pluginConnectionId: scope.pluginConnectionId,
+				sourceEntityId: subject.entityId,
+				sourceEntityRevision: LedgerRevision.make(subject.revision)
+			},
+			verifier: {
+				_tag: "system",
+				component: "normalized-plugin-page-materializer"
+			},
+			observedAt: event.capturedAt,
+			recordedAt: scope.committedAt,
+			validUntil: null,
+			freshness: {
+				_tag: "current",
+				evaluatedAt: scope.committedAt,
+				pluginHealth: health,
+				provenance: {
+					_tag: "provider",
+					sourceRevision: source
+				},
+				sourceObservedAt: source.lastObservedAt,
+				staleAfterSeconds: Math.max(1, Math.ceil(ageSeconds) + 1),
+				synchronizedAt: scope.committedAt
+			},
+			retention: {
+				classification: "evidence",
+				retainUntil: null,
+				legalHold: false
+			}
+		}],
+		evidenceClaims: [{
+			workspaceId: scope.workspaceId,
+			evidenceClaimId,
+			evidenceId,
+			subjectNodeId: nodeId,
+			predicate,
+			value,
+			recordedAt: scope.committedAt,
+			supersedesEvidenceClaimId: null
+		}],
+		relationships: []
+	}, event.eventId);
+	return {
+		evidenceItemCount: receipt.evidenceItemCount,
+		evidenceClaimCount: receipt.evidenceClaimCount
+	};
+});
+var materializeRelationship = Effect.fn("NormalizedPluginPageMaterialization.proposeRelationship")(function* (persistence, cryptoService, scope, event) {
+	const resolveEndpoint = Effect.fn("NormalizedPluginPageMaterialization.resolveRelationshipEndpoint")(function* (reference) {
+		if (reference.entityType === "release") {
+			const releaseId = yield* releaseIdFor(cryptoService, scope, reference.vendorImmutableId, event.eventId);
+			const release = yield* persistence.releases.get(scope.workspaceId, releaseId).pipe(Effect.result);
+			if (Result.isFailure(release)) {
+				if (release.failure._tag === "RecordNotFoundError") return yield* malformed("normalized-relationship-endpoint-missing", event.eventId);
+				return yield* release.failure;
+			}
+			const nodeId = yield* releaseNodeIdFor(cryptoService, scope, reference.vendorImmutableId, event.eventId);
+			const existingNode = yield* persistence.deliveryGraph.read(scope.workspaceId, {
+				_tag: "node",
+				nodeId
+			}).pipe(Effect.result);
+			if (Result.isFailure(existingNode) && existingNode.failure._tag !== "RecordNotFoundError") return yield* existingNode.failure;
+			return {
+				entity: null,
+				kind: "release",
+				node: Result.isSuccess(existingNode) ? null : {
+					workspaceId: scope.workspaceId,
+					nodeId,
+					endpointKind: "release",
+					resolution: {
+						_tag: "resolved",
+						target: {
+							_tag: "release",
+							releaseId
+						}
+					},
+					createdAt: scope.committedAt
+				},
+				nodeId,
+				releaseId
+			};
+		}
+		const entity = yield* findEntity(persistence, scope, reference.vendorImmutableId);
+		const kind = canonicalKind(reference.entityType);
+		if (entity === null) return yield* malformed("normalized-relationship-endpoint-missing", event.eventId);
+		if (kind === null) return yield* malformed("normalized-relationship-endpoint-unsupported", event.eventId);
+		return {
+			entity,
+			kind,
+			node: null,
+			nodeId: yield* nodeIdFor(cryptoService, scope, reference.vendorImmutableId, event.eventId),
+			releaseId: null
+		};
+	});
+	const source = yield* resolveEndpoint(event.from);
+	const target = yield* resolveEndpoint(event.to);
+	const kind = yield* Schema.decodeUnknownEffect(RelationshipKind)(event.relationshipType).pipe(Effect.mapError(() => malformed("normalized-relationship-kind-invalid", event.eventId)));
+	const provenanceEntity = source.entity ?? target.entity;
+	if (provenanceEntity === null) return yield* malformed("normalized-relationship-provenance-entity-missing", event.eventId);
+	const relationshipScope = source.releaseId !== null ? {
+		_tag: "release",
+		releaseId: source.releaseId
+	} : null;
+	const relationshipId = RelationshipId.make(yield* stableUuid(cryptoService, materializationKey(scope, "relationship", event.relationshipId), event.eventId));
+	const existing = yield* persistence.deliveryGraph.read(scope.workspaceId, {
+		_tag: "relationship",
+		relationshipId,
+		revision: null
+	}).pipe(Effect.result);
+	if (Result.isFailure(existing) && existing.failure._tag !== "RecordNotFoundError") return yield* existing.failure;
+	const previous = Result.isSuccess(existing) && existing.success._tag === "relationship" ? existing.success.value : null;
+	const revision = LedgerRevision.make((previous?.revision ?? 0) + 1);
+	const nodes = [];
+	if (source.node !== null) nodes.push(source.node);
+	if (target.node !== null && target.node.nodeId !== source.nodeId) nodes.push(target.node);
+	const receipt = yield* writeGraph(persistence, scope.workspaceId, {
+		entityProjections: [],
+		nodes,
+		evidenceItems: [],
+		evidenceClaims: [],
+		relationships: [{
+			workspaceId: scope.workspaceId,
+			relationshipId,
+			relationshipSchemaVersion: 1,
+			revision,
+			supersedesRevision: previous?.revision ?? null,
+			kind,
+			sourceNodeId: source.nodeId,
+			sourceNodeKind: source.kind,
+			targetNodeId: target.nodeId,
+			targetNodeKind: target.kind,
+			scope: relationshipScope,
+			lifecycle: {
+				_tag: "proposed",
+				effectiveAt: event.observedAt
+			},
+			confidence: {
+				_tag: "inferred",
+				score: event.confidence,
+				rationale: `Proposed by ${scope.providerId} normalized synchronization.`
+			},
+			provenance: {
+				_tag: "plugin",
+				pluginConnectionId: scope.pluginConnectionId,
+				sourceEntityId: provenanceEntity.entityId,
+				sourceEntityRevision: LedgerRevision.make(provenanceEntity.revision)
+			},
+			recordedBy: {
+				_tag: "system",
+				component: "normalized-plugin-page-materializer"
+			},
+			evidenceClaimIds: yield* Effect.forEach(event.evidenceIds, (evidenceId) => stableUuid(cryptoService, materializationKey(scope, "evidence-claim", evidenceId), event.eventId).pipe(Effect.map(EvidenceClaimId.make))),
+			recordedAt: scope.committedAt
+		}]
+	}, event.eventId);
+	return {
+		nodeCount: receipt.nodeCount,
+		relationshipCount: receipt.relationshipCount
+	};
+});
+var hasAuthoritativeJiraFixVersions = (event) => {
+	if (event._tag !== "UpsertEntity" || event.entityType !== "jira.issue") return false;
+	const snapshot = Schema.decodeUnknownResult(JiraIssueRelationshipSnapshot)(event.attributes);
+	return Result.isSuccess(snapshot) && !snapshot.success.truncatedFields.includes("fixVersions");
+};
+var isReleaseContainmentForIssue = (event, issue) => event._tag === "ProposeRelationship" && event.relationshipType === "contains" && event.from.entityType === "release" && event.to.entityType === issue.entityType && event.to.vendorImmutableId === issue.vendorImmutableId;
+var retireMissingJiraReleaseContainments = Effect.fn("NormalizedPluginPageMaterialization.retireMissingJiraReleaseContainments")(function* (persistence, cryptoService, scope, acceptedEvents) {
+	let relationshipCount = 0;
+	for (const issue of acceptedEvents) {
+		if (!hasAuthoritativeJiraFixVersions(issue)) continue;
+		const source = yield* findEntity(persistence, scope, issue.vendorImmutableId);
+		if (source === null) return yield* malformed("normalized-relationship-endpoint-missing", issue.eventId);
+		const issueNodeId = yield* nodeIdFor(cryptoService, scope, issue.vendorImmutableId, issue.eventId);
+		const neighborhood = yield* persistence.deliveryGraph.read(scope.workspaceId, {
+			_tag: "nodeRelationships",
+			nodeId: issueNodeId,
+			limit: 500
+		});
+		if (neighborhood._tag !== "nodeRelationships") continue;
+		if (neighborhood.value.truncated) return yield* malformed("normalized-jira-containment-neighborhood-truncated", issue.eventId);
+		const currentRelationshipIds = new Set(yield* Effect.forEach(acceptedEvents.filter((event) => isReleaseContainmentForIssue(event, issue)), ({ relationshipId }) => stableUuid(cryptoService, materializationKey(scope, "relationship", relationshipId), issue.eventId).pipe(Effect.map(RelationshipId.make))));
+		const removed = neighborhood.value.relationships.filter((relationship) => relationship.kind === "contains" && relationship.sourceNodeKind === "release" && relationship.targetNodeId === issueNodeId && relationship.targetNodeKind === "issue" && relationship.provenance._tag === "plugin" && relationship.provenance.pluginConnectionId === scope.pluginConnectionId && relationship.provenance.sourceEntityId === source.entityId && !currentRelationshipIds.has(relationship.relationshipId));
+		if (removed.length === 0) continue;
+		for (const previous of removed) {
+			if (previous.lifecycle._tag === "rejected" || previous.lifecycle._tag === "superseded") continue;
+			const receipt = yield* writeGraph(persistence, scope.workspaceId, {
+				entityProjections: [],
+				nodes: [],
+				evidenceItems: [],
+				evidenceClaims: [],
+				relationships: [{
+					...previous,
+					revision: LedgerRevision.make(previous.revision + 1),
+					supersedesRevision: previous.revision,
+					lifecycle: {
+						_tag: "superseded",
+						effectiveAt: issue.observedAt,
+						reason: "No longer present in the latest Jira fixVersion observation."
+					},
+					provenance: {
+						_tag: "plugin",
+						pluginConnectionId: scope.pluginConnectionId,
+						sourceEntityId: source.entityId,
+						sourceEntityRevision: LedgerRevision.make(source.revision)
+					},
+					recordedBy: {
+						_tag: "system",
+						component: "normalized-plugin-page-materializer"
+					},
+					recordedAt: scope.committedAt
+				}]
+			}, issue.eventId);
+			relationshipCount += receipt.relationshipCount;
+		}
+	}
+	return relationshipCount;
+});
+/**
+* Commit one decoded page and all accepted canonical projections atomically.
+* The existing plugin checkpoint transaction nests as a savepoint; only its
+* newly accepted event identities cross the materialization seam.
+*/
+var materializeNormalizedPluginPage = Effect.fn("NormalizedPluginPageMaterialization.materializePage")(function* (scope, page) {
+	const cryptoService = yield* Crypto.Crypto;
+	const persistence = yield* Persistence;
+	return yield* persistence.transact(Effect.gen(function* () {
+		if (scope.expectedAuthority !== void 0) yield* verifyPluginSynchronizationAuthority(persistence, scope.expectedAuthority);
+		const committed = yield* persistence.pluginRuntime.commitNormalizedPageReceipt(scope.workspaceId, scope.pluginConnectionId, scope.providerId, scope.streamKey, scope.expectedRevision, page, scope.committedAt, scope.successfulHealth);
+		const accepted = new Set(committed.acceptedEventIds);
+		const events = page.events.filter(({ eventId }) => accepted.has(eventId));
+		let entityProjectionCount = 0;
+		let evidenceClaimCount = 0;
+		let evidenceItemCount = 0;
+		let nodeCount = 0;
+		let personCount = 0;
+		let relationshipCount = 0;
+		let skippedEntityCount = 0;
+		for (const event of events) {
+			if (event._tag !== "UpsertPerson") continue;
+			personCount += yield* materializePerson(persistence, cryptoService, scope, event);
+		}
+		for (const event of events) if (event._tag === "UpsertEntity") {
+			if (event.entityType === "release") {
+				nodeCount += (yield* materializeRelease(persistence, cryptoService, scope, event)).nodeCount;
+				continue;
+			}
+			const receipt = yield* materializeUpsertEntity(persistence, cryptoService, scope, event);
+			entityProjectionCount += receipt.entityProjectionCount;
+			nodeCount += receipt.nodeCount;
+			skippedEntityCount += receipt.skippedEntityCount;
+		} else if (event._tag === "TombstoneEntity") entityProjectionCount += (yield* materializeTombstoneEntity(persistence, scope, event)).entityProjectionCount;
+		for (const event of events) {
+			if (event._tag !== "AppendEvidence") continue;
+			const receipt = yield* materializeEvidence(persistence, cryptoService, scope, event);
+			evidenceItemCount += receipt.evidenceItemCount;
+			evidenceClaimCount += receipt.evidenceClaimCount;
+		}
+		for (const event of events) {
+			if (event._tag !== "ProposeRelationship") continue;
+			const receipt = yield* materializeRelationship(persistence, cryptoService, scope, event);
+			nodeCount += receipt.nodeCount;
+			relationshipCount += receipt.relationshipCount;
+		}
+		relationshipCount += yield* retireMissingJiraReleaseContainments(persistence, cryptoService, scope, events);
+		if (events.length > 0) {
+			const inference = yield* materializeRelationshipInference(persistence, (identity) => stableUuid(cryptoService, identity, "relationship-inference"), scope);
+			evidenceClaimCount += inference.evidenceClaimCount;
+			evidenceItemCount += inference.evidenceItemCount;
+			nodeCount += inference.nodeCount;
+			relationshipCount += inference.relationshipCount;
+		}
+		return {
+			pageCommitted: committed.pageCommitted,
+			acceptedEventCount: events.length,
+			entityProjectionCount,
+			evidenceClaimCount,
+			evidenceItemCount,
+			nodeCount,
+			personCount,
+			relationshipCount,
+			skippedEntityCount
+		};
+	}));
+});
+//#endregion
+//#region src/server/application/manualPluginSynchronization.ts
+var MAXIMUM_PAGES_PER_INVOCATION = 100;
+var SYNCHRONIZATION_CLAIM_LIFETIME_MINUTES = 15;
+var SOURCE_UNAVAILABLE_OUTCOME = "source-unavailable";
+var SYNCHRONIZED_OUTCOME = "synchronized";
+var successfulHealthAt = (health, checkedAt) => health._tag === "healthy" ? {
+	_tag: "healthy",
+	checkedAt
+} : {
+	...health,
+	checkedAt,
+	retryAt: health.retryAt !== null && DateTime.Order(checkedAt, health.retryAt) <= 0 ? health.retryAt : null
+};
+/** Build a deterministic driver registry for production or fixture connections. */
+var makeManualPluginSyncDriverRegistry = (drivers) => {
+	const byProvider = /* @__PURE__ */ new Map();
+	for (const driver of drivers) byProvider.set(driver.providerId, driver);
+	return { get: (providerId) => Option.fromNullishOr(byProvider.get(providerId)) };
+};
+var connectionSync = (connection, request) => connection.sync(request);
+/** Production drivers for first-party connections that currently negotiate synchronization. */
+var firstPartyManualPluginSyncDrivers = makeManualPluginSyncDriverRegistry([
+	{
+		providerId: "codecommit",
+		streamKey: firstPartySyncStreamKey("codecommit"),
+		sync: connectionSync
+	},
+	{
+		providerId: "codepipeline",
+		streamKey: firstPartySyncStreamKey("codepipeline"),
+		sync: connectionSync
+	},
+	{
+		providerId: "jira",
+		streamKey: firstPartySyncStreamKey("jira"),
+		sync: connectionSync
+	},
+	{
+		providerId: "clockify",
+		streamKey: firstPartySyncStreamKey("clockify"),
+		sync: connectionSync
+	},
+	{
+		providerId: "confluence",
+		streamKey: firstPartySyncStreamKey("confluence"),
+		sync: connectionSync
+	}
+]);
+var unavailable = () => new ApplicationServiceUnavailable({ retryAt: null });
+var mapPersistenceRead = (failure) => failure._tag === "RecordNotFoundError" ? new ApplicationResourceNotFound() : unavailable();
+var pluginFailureTags = /* @__PURE__ */ new Set([
+	"PluginAuthenticationFailure",
+	"PluginAuthorizationFailure",
+	"PluginRateLimitFailure",
+	"PluginTimeoutFailure",
+	"PluginMalformedResponseFailure",
+	"PluginOutageFailure",
+	"PluginCancellationFailure",
+	"PluginConflictFailure",
+	"PluginUnsupportedCapabilityFailure",
+	"PluginConfigurationFailure",
+	"PluginUnknownOutcomeFailure"
+]);
+var isPluginFailure = (failure) => Predicate.hasProperty(failure, "_tag") && typeof failure._tag === "string" && pluginFailureTags.has(failure._tag);
+var sourceFailure = (failure) => {
+	if (isPluginFailure(failure)) return failure;
+	if (Predicate.hasProperty(failure, "_tag") && failure._tag === "NormalizedPluginPageMaterializationError") return new PluginMalformedResponseFailure({
+		operation: "manual-sync",
+		diagnosticCode: "normalized-plugin-page-rejected"
+	});
+	if (Predicate.hasProperty(failure, "_tag") && failure._tag === "SourceIdentityMismatchError" && Predicate.hasProperty(failure, "recordKind") && (failure.recordKind === "plugin-sync-event" || failure.recordKind === "plugin-sync-page")) return new PluginMalformedResponseFailure({
+		operation: "manual-sync",
+		diagnosticCode: "plugin-sync-source-identity-conflict"
+	});
+	return null;
+};
+var safeFailureMessage = (failure) => {
+	switch (failure._tag) {
+		case "PluginAuthenticationFailure": return "Provider authentication failed.";
+		case "PluginAuthorizationFailure": return "Provider permission was denied.";
+		case "PluginRateLimitFailure": return "Provider rate limit was reached.";
+		case "PluginTimeoutFailure": return "Provider request timed out.";
+		case "PluginMalformedResponseFailure": return "Provider returned an invalid response.";
+		case "PluginOutageFailure": return "Provider is temporarily unavailable.";
+		case "PluginCancellationFailure": return "Provider synchronization was cancelled.";
+		case "PluginConflictFailure": return "Provider state changed during synchronization.";
+		case "PluginUnsupportedCapabilityFailure": return "Provider synchronization is not supported.";
+		case "PluginConfigurationFailure": return "Provider configuration is incomplete.";
+		case "PluginUnknownOutcomeFailure": return "Provider synchronization outcome is unknown.";
+	}
+};
+var failureHealth = Effect.fn("ManualPluginSynchronization.failureHealth")(function* (failure, checkedAt) {
+	return yield* Schema.decodeUnknownEffect(Schema.toType(PluginHealth))({
+		_tag: "unavailable",
+		checkedAt,
+		failureClass: pluginFailureClass(failure),
+		retryAt: failure._tag === "PluginRateLimitFailure" ? failure.retryAt : null,
+		safeMessage: safeFailureMessage(failure)
+	});
+});
+var stateFromAttemptState = (pluginConnectionId, providerId, streamKey, attemptState) => {
+	const lastAttempt = attemptState.latestAttempt ?? void 0;
+	const lastSuccess = attemptState.latestSynchronized ?? void 0;
+	return {
+		pluginConnectionId,
+		providerId,
+		streamKey,
+		lastAttemptAt: lastAttempt?.startedAt ?? null,
+		lastSuccessAt: lastSuccess?.completedAt ?? null,
+		result: lastAttempt === void 0 ? "never" : lastAttempt.outcome === null ? "running" : lastAttempt.outcome,
+		pagesCommitted: lastAttempt?.pagesCommitted ?? 0
+	};
+};
+/** Build the bounded synchronization application over a scoped provider runtime map. */
+var makeManualPluginSynchronization = Effect.fn("ManualPluginSynchronization.make")(function* (connections, drivers = firstPartyManualPluginSyncDrivers) {
+	const persistence = yield* Persistence;
+	const wakeups = yield* DomainEventWakeups;
+	const cryptoService = yield* Crypto.Crypto;
+	const bind = Effect.fn("ManualPluginSynchronization.bind")(function* (input) {
+		const connection = yield* persistence.pluginConnections.get(input.workspaceId, input.pluginConnectionId).pipe(Effect.mapError(mapPersistenceRead));
+		const driver = drivers.get(connection.providerId);
+		if (Option.isNone(driver)) return yield* new ApplicationInvalidRequest();
+		const runtime = yield* persistence.pluginRuntime.getRuntime(input.workspaceId, input.pluginConnectionId).pipe(Effect.mapError(mapPersistenceRead));
+		const descriptor = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(NegotiatedPluginDescriptorV1))(runtime.descriptorJson).pipe(Effect.mapError(() => new ApplicationInvalidRequest()));
+		if (!supportsFirstPartySynchronization(connection.providerId, descriptor)) return yield* new ApplicationInvalidRequest();
+		const streamKey = yield* Schema.decodeUnknownEffect(PluginStreamKey)(driver.value.streamKey).pipe(Effect.mapError(() => new ApplicationInvalidRequest()));
+		return {
+			...input,
+			providerId: connection.providerId,
+			driver: driver.value,
+			streamKey
+		};
+	});
+	const releaseSynchronization = Effect.fn("ManualPluginSynchronization.releaseSynchronization")(function* (claim) {
+		yield* persistence.pluginRuntime.releaseSyncClaim(claim.workspaceId, claim.pluginConnectionId, claim.streamKey, claim.claimId).pipe(Effect.mapError(() => unavailable()));
+	});
+	const claimSynchronization = Effect.fn("ManualPluginSynchronization.claimSynchronization")(function* (bound) {
+		const claimId = yield* cryptoService.randomUUIDv4.pipe(Effect.mapError(() => unavailable()));
+		const claimedAt = DateTime.makeUnsafe(yield* Effect.clockWith((clock) => clock.currentTimeMillis));
+		const expiresAt = DateTime.add(claimedAt, { minutes: SYNCHRONIZATION_CLAIM_LIFETIME_MINUTES });
+		if (!(yield* persistence.pluginRuntime.claimSync(bound.workspaceId, bound.pluginConnectionId, bound.providerId, bound.streamKey, claimId, claimedAt, expiresAt).pipe(Effect.mapError(() => unavailable())))) return yield* unavailable();
+		return {
+			...bound,
+			claimId
+		};
+	});
+	const stateFor = Effect.fn("ManualPluginSynchronization.stateFor")(function* (bound) {
+		const attemptState = yield* persistence.pluginRuntime.getSyncAttemptState(bound.workspaceId, bound.pluginConnectionId, bound.streamKey).pipe(Effect.mapError(() => unavailable()));
+		return stateFromAttemptState(bound.pluginConnectionId, bound.providerId, bound.streamKey, attemptState);
+	});
+	const readState = Effect.fn("ManualPluginSynchronization.state")(function* (input) {
+		const bound = yield* bind(input);
+		return yield* stateFor(bound);
+	});
+	const persistHealth = Effect.fn("ManualPluginSynchronization.persistHealth")(function* (bound, authority, health, failed) {
+		const persisted = yield* persistence.transact(Effect.gen(function* () {
+			yield* verifyPluginSynchronizationAuthority(persistence, authority);
+			const runtime = yield* persistence.pluginRuntime.getRuntime(bound.workspaceId, bound.pluginConnectionId);
+			yield* persistence.pluginRuntime.recordHealth(bound.workspaceId, bound.pluginConnectionId, runtime.revision, health, failed ? runtime.consecutiveFailures + 1 : 0);
+			yield* appendPortfolioInvalidation({
+				workspaceId: bound.workspaceId,
+				pluginConnectionId: bound.pluginConnectionId,
+				releaseId: null,
+				occurredAt: health.checkedAt,
+				reason: "plugin-health"
+			}).pipe(Effect.provideService(Crypto.Crypto, cryptoService), Effect.provideService(Persistence, persistence));
+			return true;
+		})).pipe(Effect.catchTag("PluginConflictFailure", () => Effect.succeed(false)), Effect.mapError(() => unavailable()));
+		if (persisted) yield* wakeups.notify(bound.workspaceId);
+		return persisted;
+	});
+	const initialCheckpoint = Effect.fn("ManualPluginSynchronization.initialCheckpoint")(function* (bound) {
+		const current = yield* Effect.result(persistence.pluginRuntime.getStream(bound.workspaceId, bound.pluginConnectionId, bound.streamKey));
+		if (Result.isFailure(current)) {
+			if (current.failure._tag === "RecordNotFoundError") return null;
+			return yield* Effect.fail(current.failure);
+		}
+		return current.success.checkpointJson === null ? null : yield* Schema.decodeUnknownEffect(Schema.fromJsonString(PluginCheckpointV1))(current.success.checkpointJson);
+	});
+	const run = Effect.fn("ManualPluginSynchronization.run")(function* (bound, authority, connection, health) {
+		const checkpoint = yield* initialCheckpoint(bound);
+		const request = yield* Schema.decodeUnknownEffect(PluginSyncRequestV1)({
+			streamKey: bound.streamKey,
+			checkpoint
+		});
+		const initialStream = yield* Effect.result(persistence.pluginRuntime.getStream(bound.workspaceId, bound.pluginConnectionId, bound.streamKey));
+		const revision = Result.isSuccess(initialStream) ? initialStream.success.revision : 0;
+		return yield* Stream.runFoldEffect(bound.driver.sync(connection, request).pipe(Stream.take(MAXIMUM_PAGES_PER_INVOCATION)), () => ({
+			health,
+			isTerminal: false,
+			pagesSeen: 0,
+			pagesCommitted: 0,
+			revision
+		}), (state, page) => Effect.gen(function* () {
+			if (state.isTerminal) return yield* new PluginMalformedResponseFailure({
+				operation: "manual-sync",
+				diagnosticCode: "manual-sync-page-after-terminal"
+			});
+			const committedAt = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
+			const successfulHealth = successfulHealthAt(state.health, committedAt);
+			const receipt = yield* materializeNormalizedPluginPage({
+				workspaceId: bound.workspaceId,
+				pluginConnectionId: bound.pluginConnectionId,
+				providerId: bound.providerId,
+				streamKey: bound.streamKey,
+				expectedRevision: state.revision,
+				committedAt,
+				successfulHealth,
+				expectedAuthority: authority
+			}, page).pipe(Effect.provideService(Crypto.Crypto, cryptoService), Effect.provideService(Persistence, persistence));
+			const pagesSeen = state.pagesSeen + 1;
+			return {
+				health: successfulHealth,
+				isTerminal: !page.hasMore,
+				pagesSeen,
+				pagesCommitted: state.pagesCommitted + (receipt.pageCommitted ? 1 : 0),
+				revision: state.revision + (receipt.pageCommitted ? 1 : 0)
+			};
+		}));
+	});
+	const synchronizeBound = Effect.fn("ManualPluginSynchronization.synchronizeBound")(function* (input, bound) {
+		const { authority, connection: connectionRecord } = yield* capturePluginSynchronizationAuthority(persistence, bound.workspaceId, bound.pluginConnectionId).pipe(Effect.mapError(mapPersistenceRead));
+		if (!connectionRecord.isEnabled) return yield* new ApplicationInvalidRequest();
+		const startedAt = DateTime.makeUnsafe(yield* Effect.clockWith((clock) => clock.currentTimeMillis));
+		const attempt = yield* persistence.pluginRuntime.beginSyncAttempt(bound.workspaceId, bound.pluginConnectionId, bound.providerId, bound.streamKey, startedAt).pipe(Effect.mapError(() => unavailable()));
+		const synchronized = yield* Effect.result(Effect.scoped(Effect.flatMap(connections.contextEffect({
+			workspaceId: bound.workspaceId,
+			pluginConnectionId: bound.pluginConnectionId
+		}), (context) => Effect.gen(function* () {
+			const connection = Context.get(context, PluginConnection);
+			const health = yield* connection.health;
+			if (health._tag === "unavailable" || health._tag === "disabled") return health;
+			const completed = yield* run(bound, authority, connection, health);
+			if (!completed.isTerminal && (completed.pagesSeen < MAXIMUM_PAGES_PER_INVOCATION || completed.pagesCommitted === 0)) return yield* new PluginMalformedResponseFailure({
+				operation: "manual-sync",
+				diagnosticCode: "manual-sync-terminal-page-missing"
+			});
+			return completed.health;
+		}).pipe(Effect.provide(context)))));
+		const outcome = yield* Effect.gen(function* () {
+			if (Result.isSuccess(synchronized)) {
+				const health = synchronized.success;
+				const sourceUnavailable = health._tag === "unavailable" || health._tag === "disabled";
+				const healthPersisted = yield* persistHealth(bound, authority, health, sourceUnavailable);
+				return sourceUnavailable || !healthPersisted ? SOURCE_UNAVAILABLE_OUTCOME : SYNCHRONIZED_OUTCOME;
+			}
+			const failure = sourceFailure(synchronized.failure);
+			if (failure === null) return yield* unavailable();
+			const health = yield* failureHealth(failure, DateTime.makeUnsafe(yield* Effect.clockWith((clock) => clock.currentTimeMillis))).pipe(Effect.mapError(() => unavailable()));
+			yield* persistHealth(bound, authority, health, true);
+			return SOURCE_UNAVAILABLE_OUTCOME;
+		});
+		const completedAt = DateTime.makeUnsafe(yield* Effect.clockWith((clock) => clock.currentTimeMillis));
+		yield* persistence.pluginRuntime.completeSyncAttempt(bound.workspaceId, bound.pluginConnectionId, bound.streamKey, attempt.attemptSequence, outcome, completedAt).pipe(Effect.mapError(() => unavailable()));
+		return yield* readState(input);
+	});
+	return {
+		state: readState,
+		synchronize: Effect.fn("ManualPluginSynchronization.synchronize")(function* (input) {
+			const bound = yield* bind(input);
+			return yield* Effect.acquireUseRelease(claimSynchronization(bound), () => synchronizeBound(input, bound), releaseSynchronization);
+		})
+	};
+});
+//#endregion
+export { firstPartyManualPluginSyncDrivers, makeManualPluginSyncDriverRegistry, makeManualPluginSynchronization };
+
+//# sourceMappingURL=manualPluginSynchronization-C0aHB4UM.js.map