@knpkv/control-center 0.1.0

package/dist/server/server/application/pluginAdministration.d.ts.map

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

package/dist/server/server/application/pluginSynchronizationAuthority.d.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import type { PluginConnectionId, WorkspaceId } from "../../domain/identifiers.js";
+import type { ProviderId } from "../../domain/sourceRevision.js";
+import type { PersistenceOperationFailure, PersistenceService } from "../persistence/Persistence.js";
+import type { PluginConnectionRecord } from "../persistence/repositories/models.js";
+import { PluginConflictFailure } from "../plugins/failures.js";
+/** Exact mutable host state that authorized one manual synchronization runtime. */
+export interface PluginSynchronizationAuthority {
+    readonly workspaceId: WorkspaceId;
+    readonly pluginConnectionId: PluginConnectionId;
+    readonly providerId: ProviderId;
+    readonly connectionRevision: number;
+    readonly configurationRevision: number | null;
+}
+/** Capture connection and configuration revisions in one durable read transaction. */
+export declare const capturePluginSynchronizationAuthority: (persistence: PersistenceService, workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">) => Effect.Effect<{
+    readonly connection: PluginConnectionRecord;
+    readonly authority: PluginSynchronizationAuthority;
+}, PersistenceOperationFailure, never>;
+/** Reject a write transaction when its runtime no longer owns current connection authority. */
+export declare const verifyPluginSynchronizationAuthority: (persistence: PersistenceService, expected: PluginSynchronizationAuthority) => Effect.Effect<void, PluginConflictFailure | PersistenceOperationFailure, never>;
+//# sourceMappingURL=pluginSynchronizationAuthority.d.ts.map

package/dist/server/server/application/pluginSynchronizationAuthority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluginSynchronizationAuthority.d.ts","sourceRoot":"","sources":["../../../../src/server/application/pluginSynchronizationAuthority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACpG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAA;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAE9D,mFAAmF;AACnF,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9C;AAyBD,sFAAsF;AACtF,eAAO,MAAM,qCAAqC;yBAOzB,sBAAsB;wBAAsB,8BAA8B;sCAQjG,CAAA;AAEF,+FAA+F;AAC/F,eAAO,MAAM,oCAAoC,gKAqB/C,CAAA"}

package/dist/server/server/application/portfolioInvalidation.d.ts

@@ -0,0 +1,35 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { PortfolioInvalidationReason } from "../../domain/domainEvent.js";
+import { type PluginConnectionId, type ReleaseId, type WorkspaceId } from "../../domain/identifiers.js";
+import type { UtcTimestamp } from "../../domain/utcTimestamp.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Append the durable event consumed by live portfolio projections. */
+export declare const appendPortfolioInvalidation: (input: {
+    readonly workspaceId: WorkspaceId;
+    readonly pluginConnectionId: PluginConnectionId;
+    readonly releaseId: ReleaseId | null;
+    readonly occurredAt: UtcTimestamp;
+    readonly reason: PortfolioInvalidationReason;
+}) => Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly eventId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">;
+    readonly eventCursor: Schema.brand<Schema.Int, "EventCursor">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly eventType: Schema.Literal<"portfolio-invalidated">;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly ingestedAt: Schema.DateTimeUtcFromString;
+    readonly causationId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "DomainEventId">>;
+    readonly correlationId: Schema.NullOr<Schema.brand<Schema.String, "DomainEventCorrelationId">>;
+    readonly metadata: Schema.Struct<{
+        readonly releaseId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">>;
+        readonly pluginConnectionId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">>;
+        readonly entityId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">>;
+        readonly jobId: Schema.optionalKey<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">>;
+    }>;
+    readonly payload: Schema.Struct<{
+        readonly reason: Schema.Literals<readonly ["release-projection", "plugin-health"]>;
+    }>;
+}, "Type">, import("../persistence/Persistence.js").PersistenceOperationFailure, Crypto.Crypto | Persistence>;
+//# sourceMappingURL=portfolioInvalidation.d.ts.map

package/dist/server/server/application/portfolioInvalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portfolioInvalidation.d.ts","sourceRoot":"","sources":["../../../../src/server/application/portfolioInvalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,EAAiB,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACtH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAG3D,uEAAuE;AACvE,eAAO,MAAM,2BAA2B;0BAGhB,WAAW;iCACJ,kBAAkB;wBAC3B,SAAS,GAAG,IAAI;yBACf,YAAY;qBAChB,2BAA2B;;;;;;;;;;;;;;;;;;;;6GA0B5C,CAAA"}

package/dist/server/server/application/portfolioSnapshots.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { PortfolioSnapshot } from "../../api/portfolio.js";
+import { ApplicationServiceUnavailable, PortfolioSnapshots } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct the bird's-eye projection from persisted facts only. */
+export declare const makePortfolioSnapshots: Effect.Effect<{
+    readonly snapshot: (workspaceId: import("../../index.ts").WorkspaceId) => Effect.Effect<PortfolioSnapshot, ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live portfolio projection layer. */
+export declare const portfolioSnapshotsLayer: Layer.Layer<PortfolioSnapshots, never, Persistence>;
+//# sourceMappingURL=portfolioSnapshots.d.ts.map

package/dist/server/server/application/portfolioSnapshots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portfolioSnapshots.d.ts","sourceRoot":"","sources":["../../../../src/server/application/portfolioSnapshots.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,EAKV,iBAAiB,EAClB,MAAM,wBAAwB,CAAA;AAI/B,OAAO,EAAE,6BAA6B,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AACjG,OAAO,EAAE,WAAW,EAA2B,MAAM,+BAA+B,CAAA;AAkFpF,qEAAqE;AACrE,eAAO,MAAM,sBAAsB;;sBAqDjC,CAAA;AAEF,uCAAuC;AACvC,eAAO,MAAM,uBAAuB,qDAA2D,CAAA"}

package/dist/server/server/application/readinessDigests.d.ts

@@ -0,0 +1,3 @@
+/** Application compatibility export for server-wide canonical readiness hashing. */
+export * from "../readinessDigests.js";
+//# sourceMappingURL=readinessDigests.d.ts.map

package/dist/server/server/application/readinessDigests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readinessDigests.d.ts","sourceRoot":"","sources":["../../../../src/server/application/readinessDigests.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,cAAc,wBAAwB,CAAA"}

package/dist/server/server/application/relationshipInference.d.ts

@@ -0,0 +1,57 @@
+import type { DeliveryEntityKind, DeliveryEntityProjection, DeliveryRelationship, RelationshipEndpointKind, RelationshipKind } from "../../domain/deliveryGraph.js";
+import type { EntityId, GraphNodeId, ReleaseId } from "../../domain/identifiers.js";
+/** One current canonical entity exposed to provider-neutral relationship rules. */
+export interface RelationshipInferenceEntity {
+    readonly nodeId: GraphNodeId;
+    readonly projection: DeliveryEntityProjection;
+    readonly releaseIds: ReadonlyArray<ReleaseId>;
+}
+/** One canonical release exposed without provider-specific version objects. */
+export interface RelationshipInferenceRelease {
+    readonly nodeId: GraphNodeId;
+    readonly releaseId: ReleaseId;
+    readonly version: string;
+}
+export type RelationshipInferenceEndpoint = Readonly<{
+    readonly _tag: "resolved";
+    readonly kind: RelationshipEndpointKind;
+    readonly nodeId: GraphNodeId;
+}> | Readonly<{
+    readonly _tag: "missing";
+    readonly identityKey: string;
+    readonly kind: DeliveryEntityKind;
+    readonly missingKey: string;
+}>;
+/** Explainable candidate ready for evidence and ledger materialization. */
+export interface RelationshipInferenceCandidate {
+    readonly confidence: Readonly<{
+        readonly score: number;
+        readonly rationale: string;
+    }> | null;
+    readonly evidenceEntityId: EntityId | null;
+    readonly identityKey: string;
+    readonly kind: RelationshipKind;
+    readonly lifecycle: "inferred" | "missing";
+    readonly observationKey: string;
+    readonly releaseId: ReleaseId;
+    readonly ruleId: string;
+    readonly source: RelationshipInferenceEndpoint;
+    readonly target: RelationshipInferenceEndpoint;
+}
+export interface RelationshipInferenceResult {
+    readonly candidates: ReadonlyArray<RelationshipInferenceCandidate>;
+    readonly obsoleteGapIdentityKeys: ReadonlyArray<string>;
+    readonly obsoleteRelationshipIds: ReadonlyArray<DeliveryRelationship["relationshipId"]>;
+    readonly truncated: boolean;
+}
+/**
+ * Infer a deterministic relationship set from current canonical facts. Rules
+ * only propose `inferred` or `missing`; confirmation remains governed.
+ */
+export declare const deriveRelationshipInference: (input: {
+    readonly entities: ReadonlyArray<RelationshipInferenceEntity>;
+    readonly rejectedCandidateIdentityKeys?: ReadonlySet<string>;
+    readonly releases: ReadonlyArray<RelationshipInferenceRelease>;
+    readonly relationships: ReadonlyArray<DeliveryRelationship>;
+}) => RelationshipInferenceResult;
+//# sourceMappingURL=relationshipInference.d.ts.map

package/dist/server/server/application/relationshipInference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipInference.d.ts","sourceRoot":"","sources":["../../../../src/server/application/relationshipInference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAEnF,mFAAmF;AACnF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAA;IAC7C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAC9C;AAED,+EAA+E;AAC/E,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED,MAAM,MAAM,6BAA6B,GACrC,QAAQ,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAAC,GAC9G,QAAQ,CAAC;IACT,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B,CAAC,CAAA;AAEJ,2EAA2E;AAC3E,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAA;IAC5F,QAAQ,CAAC,gBAAgB,EAAE,QAAQ,GAAG,IAAI,CAAA;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,SAAS,CAAA;IAC1C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,6BAA6B,CAAA;IAC9C,QAAQ,CAAC,MAAM,EAAE,6BAA6B,CAAA;CAC/C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,8BAA8B,CAAC,CAAA;IAClE,QAAQ,CAAC,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACvD,QAAQ,CAAC,uBAAuB,EAAE,aAAa,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,CAAC,CAAA;IACvF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B;AA4SD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,GAAI,OAAO;IACjD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,2BAA2B,CAAC,CAAA;IAC7D,QAAQ,CAAC,6BAA6B,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC5D,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,4BAA4B,CAAC,CAAA;IAC9D,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;CAC5D,KAAG,2BAkNH,CAAA"}

package/dist/server/server/application/relationshipInferenceMaterialization.d.ts

@@ -0,0 +1,26 @@
+import * as Effect from "effect/Effect";
+import type { PluginHealth } from "../../domain/freshness.js";
+import { type WorkspaceId } from "../../domain/identifiers.js";
+import type { UtcTimestamp } from "../../domain/utcTimestamp.js";
+import type { PersistenceOperationFailure, PersistenceService } from "../persistence/Persistence.js";
+import { PluginStreamKey } from "../persistence/repositories/pluginRuntimeModels.js";
+export interface RelationshipInferenceMaterializationScope {
+    readonly committedAt: UtcTimestamp;
+    readonly streamKey: PluginStreamKey;
+    readonly successfulHealth: Extract<PluginHealth, {
+        readonly _tag: "healthy" | "degraded";
+    }>;
+    readonly workspaceId: WorkspaceId;
+}
+export interface RelationshipInferenceMaterializationReceipt {
+    readonly evidenceClaimCount: number;
+    readonly evidenceItemCount: number;
+    readonly nodeCount: number;
+    readonly relationshipCount: number;
+    readonly skippedDueToBounds: boolean;
+}
+type StableIdentity<IdentityError> = (identity: string) => Effect.Effect<string, IdentityError>;
+/** Persist current rule candidates after a normalized page has committed. */
+export declare const materializeRelationshipInference: <IdentityError>(persistence: PersistenceService, identity: StableIdentity<IdentityError>, scope: RelationshipInferenceMaterializationScope) => Effect.Effect<RelationshipInferenceMaterializationReceipt, PersistenceOperationFailure | IdentityError, never>;
+export {};
+//# sourceMappingURL=relationshipInferenceMaterialization.d.ts.map

package/dist/server/server/application/relationshipInferenceMaterialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipInferenceMaterialization.d.ts","sourceRoot":"","sources":["../../../../src/server/application/relationshipInferenceMaterialization.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAWvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAA4D,KAAK,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACxH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAGpG,OAAO,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAA;AAepF,MAAM,WAAW,yCAAyC;IACxD,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAA;IACnC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC,YAAY,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAAA;KAAE,CAAC,CAAA;IAC3F,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AAED,MAAM,WAAW,2CAA2C;IAC1D,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAA;CACrC;AAED,KAAK,cAAc,CAAC,aAAa,IAAI,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AA0Z/F,6EAA6E;AAC7E,eAAO,MAAM,gCAAgC,GAC3C,aAAa,+OAkJb,CAAA"}

package/dist/server/server/application/relationshipRepairProposals.d.ts

@@ -0,0 +1,41 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ApplicationInvalidRequest, RelationshipRepairProposals } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct durable, idempotent relationship-repair proposal operations. */
+export declare const makeRelationshipRepairProposals: Effect.Effect<{
+    readonly create: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly releaseId: import("../../index.ts").ReleaseId;
+        readonly relationshipId: import("../../index.ts").RelationshipId;
+        readonly request: import("../../index.ts").CreateRelationshipRepairProposalRequest;
+        readonly actor: import("../../index.ts").Actor;
+        readonly sessionId: import("../index.ts").SessionId;
+    }) => Effect.Effect<import("../../domain/relationshipRepair.js").RelationshipRepairProposal, import("../api/ApplicationServices.js").ApplicationConflict | ApplicationInvalidRequest | import("../api/ApplicationServices.js").ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly get: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly proposalId: import("../../index.ts").RelationshipRepairProposalId;
+    }) => Effect.Effect<import("../../domain/relationshipRepair.js").RelationshipRepairProposal, import("../api/ApplicationServices.js").ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly list: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly releaseId: import("../../index.ts").ReleaseId;
+        readonly environmentId: import("../../index.ts").EnvironmentId | null;
+        readonly status: import("../../domain/relationshipRepair.js").RelationshipRepairProposal["status"] | null;
+    }) => Effect.Effect<import("../../api/deliveryGraph.ts").RelationshipRepairProposalList, import("../api/ApplicationServices.js").ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly review: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly proposalId: import("../../index.ts").RelationshipRepairProposalId;
+        readonly request: import("../../api/deliveryGraph.ts").ReviewRelationshipRepairProposalRequest;
+        readonly actor: import("../../index.ts").Actor;
+        readonly sessionId: import("../index.ts").SessionId;
+    }) => Effect.Effect<import("../../domain/relationshipRepair.js").RelationshipRepairProposal, import("../api/ApplicationServices.js").ApplicationConflict | ApplicationInvalidRequest | import("../api/ApplicationServices.js").ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly apply: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly proposalId: import("../../index.ts").RelationshipRepairProposalId;
+        readonly actor: import("../../index.ts").Actor;
+        readonly sessionId: import("../index.ts").SessionId;
+    }) => Effect.Effect<import("../../api/deliveryGraph.ts").ApplyRelationshipRepairProposalResponse, import("../api/ApplicationServices.js").ApplicationConflict | ApplicationInvalidRequest | import("../api/ApplicationServices.js").ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live durable relationship-repair proposal layer. */
+export declare const relationshipRepairProposalsLayer: Layer.Layer<RelationshipRepairProposals, never, Persistence>;
+//# sourceMappingURL=relationshipRepairProposals.d.ts.map

package/dist/server/server/application/relationshipRepairProposals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipRepairProposals.d.ts","sourceRoot":"","sources":["../../../../src/server/application/relationshipRepairProposals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AACtG,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAkB3D,6EAA6E;AAC7E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoH1C,CAAA;AAEF,uDAAuD;AACvD,eAAO,MAAM,gCAAgC,8DAG5C,CAAA"}

package/dist/server/server/application/releaseAgent.d.ts

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
+import type { AgentHistoryMessage, AgentPrompt, AgentProvider, ReleaseAgentTurnResponse } from "../../api/agent.js";
+import { ApplicationResourceNotFound, ApplicationServiceUnavailable, PortfolioSnapshots, ReleaseAgentTurns } from "../api/ApplicationServices.js";
+/** Server-only local model configuration. None of these values cross the HTTP boundary. */
+export interface ReleaseAgentRuntimeOptions {
+    readonly cwd: string;
+    readonly enabledProviders: ReadonlyArray<AgentProvider>;
+    readonly codexExecutable?: string;
+    readonly codexModel?: string;
+    readonly claudeExecutable?: string;
+    readonly claudeModel?: string;
+}
+/** Build the release-agent application service around local, ephemeral CLI invocations. */
+export declare const makeReleaseAgentTurns: (options: ReleaseAgentRuntimeOptions) => Effect.Effect<{
+    readonly runTurn: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly releaseId: import("../../index.ts").ReleaseId;
+        readonly provider: AgentProvider;
+        readonly prompt: AgentPrompt;
+        readonly history: ReadonlyArray<AgentHistoryMessage>;
+    }) => Effect.Effect<ReleaseAgentTurnResponse, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, never, FileSystem.FileSystem | PortfolioSnapshots | ChildProcessSpawner.ChildProcessSpawner>;
+/** Live release-agent layer. The provided portfolio is the sole source of release facts. */
+export declare const releaseAgentTurnsLayer: (options: ReleaseAgentRuntimeOptions) => Layer.Layer<ReleaseAgentTurns, never, PortfolioSnapshots | FileSystem.FileSystem | ChildProcessSpawner.ChildProcessSpawner>;
+/** Explicit disabled runtime used when no local provider is configured. */
+export declare const releaseAgentUnavailableLayer: Layer.Layer<ReleaseAgentTurns>;
+//# sourceMappingURL=releaseAgent.d.ts.map

package/dist/server/server/application/releaseAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseAgent.d.ts","sourceRoot":"","sources":["../../../../src/server/application/releaseAgent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,KAAK,mBAAmB,MAAM,6CAA6C,CAAA;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAEnH,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,+BAA+B,CAAA;AAOtC,2FAA2F;AAC3F,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,gBAAgB,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACvD,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAwED,2FAA2F;AAC3F,eAAO,MAAM,qBAAqB;;;;;;;;+FA8DhC,CAAA;AAEF,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB,GACjC,SAAS,0BAA0B,KAClC,KAAK,CAAC,KAAK,CACZ,iBAAiB,EACjB,KAAK,EACL,kBAAkB,GAAG,UAAU,CAAC,UAAU,GAAG,mBAAmB,CAAC,mBAAmB,CAClB,CAAA;AAEpE,2EAA2E;AAC3E,eAAO,MAAM,4BAA4B,EAAE,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAGvE,CAAA"}

package/dist/server/server/application/releaseAgentJobs.d.ts

@@ -0,0 +1,26 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ReleaseAgentThreadCursor } from "../../api/agent.js";
+import { ReleaseId, WorkspaceId } from "../../domain/identifiers.js";
+import { ApplicationServiceUnavailable, ReleaseAgentJobs } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct durable release-agent operations over the server persistence boundary. */
+export declare const makeReleaseAgentJobs: Effect.Effect<{
+    readonly enqueue: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly releaseId: ReleaseId;
+        readonly request: import("../../api/agent.js").EnqueueReleaseAgentJobRequest;
+    }) => Effect.Effect<import("../../api/agent.js").EnqueueReleaseAgentJobResponse, import("../api/ApplicationServices.js").ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly replay: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly releaseId: ReleaseId;
+        readonly after: ReleaseAgentThreadCursor;
+        readonly limit: number;
+    }) => Effect.Effect<import("../../api/agent.js").ReleaseAgentThreadPage, import("../api/ApplicationServices.js").ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, never, Crypto.Crypto | Persistence>;
+/** Live provider-neutral durable release-agent application layer. */
+export declare const releaseAgentJobsLayer: Layer.Layer<ReleaseAgentJobs, never, Crypto.Crypto | Persistence>;
+/** Durable replay remains readable while enqueue is disabled without a configured runtime. */
+export declare const releaseAgentJobsUnavailableLayer: Layer.Layer<ReleaseAgentJobs, never, Crypto.Crypto | Persistence>;
+//# sourceMappingURL=releaseAgentJobs.d.ts.map

package/dist/server/server/application/releaseAgentJobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseAgentJobs.d.ts","sourceRoot":"","sources":["../../../../src/server/application/releaseAgentJobs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC,OAAO,EAGL,wBAAwB,EAEzB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAS,SAAS,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAE3E,OAAO,EAAE,6BAA6B,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAC/F,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAgG3D,uFAAuF;AACvF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;sCAoF/B,CAAA;AAEF,qEAAqE;AACrE,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,KAAK,CAAC,gBAAgB,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,CAGnG,CAAA;AAED,8FAA8F;AAC9F,eAAO,MAAM,gCAAgC,EAAE,KAAK,CAAC,KAAK,CACxD,gBAAgB,EAChB,KAAK,EACL,MAAM,CAAC,MAAM,GAAG,WAAW,CAW5B,CAAA"}

package/dist/server/server/application/releaseSynchronization.d.ts

@@ -0,0 +1,55 @@
+import type * as Crypto from "effect/Crypto";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { PluginConnectionId, WorkspaceId } from "../../domain/identifiers.js";
+import { Release } from "../../domain/release.js";
+import { Persistence, type PersistenceOperationFailure } from "../persistence/Persistence.js";
+import { type PluginFailure } from "../plugins/failures.js";
+import { PluginConnection } from "../plugins/PluginConnection.js";
+import { PluginConnectionMap } from "../plugins/PluginConnectionMap.js";
+import { DomainEventWakeups } from "../runtime/DomainEventWakeups.js";
+import { FakeReleaseNormalizationError } from "./fakeReleaseNormalization.js";
+export interface ReleaseSynchronizationInput {
+    readonly workspaceId: WorkspaceId;
+    readonly pluginConnectionId: PluginConnectionId;
+    readonly streamKey: string;
+}
+export type ReleaseSynchronizationOutcome = {
+    readonly _tag: "synchronized";
+    readonly pagesCommitted: number;
+    readonly releaseId: Release["id"] | null;
+} | {
+    readonly _tag: "source-unavailable";
+    readonly releaseId: Release["id"] | null;
+};
+export type ReleaseSynchronizationFailure = FakeReleaseNormalizationError | PersistenceOperationFailure | PluginFailure | Schema.SchemaError;
+/** Rebuild the server-authoritative release projection from the durable plugin cache. */
+export declare const reconcileFakeReleaseProjection: (input: ReleaseSynchronizationInput, health: Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"degraded">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    readonly safeMessage: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"unavailable">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+    readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+    readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+    readonly safeMessage: Schema.String;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"healthy">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"disabled">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}, "Type">, evaluatedAt: DateTime.Utc) => Effect.Effect<(string & import("effect/Brand").Brand<"ReleaseId">) | null, ReleaseSynchronizationFailure, Crypto.Crypto | Persistence | DomainEventWakeups>;
+/** Recover the last valid release projection from durable cache without acquiring a provider. */
+export declare const recoverFakeReleaseProjection: (input: ReleaseSynchronizationInput) => Effect.Effect<(string & import("effect/Brand").Brand<"ReleaseId">) | null, ReleaseSynchronizationFailure, Crypto.Crypto | Persistence | DomainEventWakeups>;
+/** Close crash-left fake synchronization work as interrupted before startup continues. */
+export declare const reconcileFakeReleaseSyncAttempts: (input: ReleaseSynchronizationInput) => Effect.Effect<number, ReleaseSynchronizationFailure, Persistence>;
+/** Synchronize and materialize one fake release without widening the page transaction boundary. */
+export declare const synchronizeFakeRelease: (input: ReleaseSynchronizationInput) => Effect.Effect<ReleaseSynchronizationOutcome, ReleaseSynchronizationFailure, Crypto.Crypto | Persistence | PluginConnection | DomainEventWakeups>;
+/** Recover the durable projection before acquiring one scoped provider connection and synchronizing it. */
+export declare const synchronizeFakeReleaseFromMap: (input: ReleaseSynchronizationInput) => Effect.Effect<ReleaseSynchronizationOutcome, ReleaseSynchronizationFailure, Crypto.Crypto | Persistence | PluginConnectionMap | DomainEventWakeups>;
+//# sourceMappingURL=releaseSynchronization.d.ts.map

package/dist/server/server/application/releaseSynchronization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseSynchronization.d.ts","sourceRoot":"","sources":["../../../../src/server/application/releaseSynchronization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAElF,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAIjD,OAAO,EAAE,WAAW,EAAE,KAAK,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAE,KAAK,aAAa,EAAsD,MAAM,wBAAwB,CAAA;AAC/G,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AACrE,OAAO,EAEL,6BAA6B,EAG9B,MAAM,+BAA+B,CAAA;AAoFtC,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;IACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAMD,MAAM,MAAM,6BAA6B,GACrC;IACA,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACzC,GACC;IACA,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;IACnC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACzC,CAAA;AAEH,MAAM,MAAM,6BAA6B,GACrC,6BAA6B,GAC7B,2BAA2B,GAC3B,aAAa,GACb,MAAM,CAAC,WAAW,CAAA;AAiRtB,yFAAyF;AACzF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;qMAazC,CAAA;AAEF,iGAAiG;AACjG,eAAO,MAAM,4BAA4B,qMA0BvC,CAAA;AAEF,0FAA0F;AAC1F,eAAO,MAAM,gCAAgC,2GAgB3C,CAAA;AAEF,mGAAmG;AACnG,eAAO,MAAM,sBAAsB,0LA6HjC,CAAA;AAEF,2GAA2G;AAC3G,eAAO,MAAM,6BAA6B,6LAkDxC,CAAA"}

package/dist/server/server/application/timelineExportAudits.d.ts

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ApplicationServiceUnavailable, TimelineExportAudits } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct the durable Timeline export attribution seam. */
+export declare const makeTimelineExportAudits: Effect.Effect<{
+    readonly record: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly personId: import("../../index.ts").PersonId;
+        readonly sessionId: import("../index.ts").SessionId;
+        readonly format: "csv" | "json";
+        readonly actorKind: import("../../index.ts").TimelineActorKind | null;
+        readonly from: import("../../index.ts").UtcTimestamp | null;
+        readonly to: import("../../index.ts").UtcTimestamp | null;
+        readonly requestedLimit: number;
+        readonly returnedCount: number;
+        readonly truncated: boolean;
+    }) => Effect.Effect<void, ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live durable Timeline export attribution layer. */
+export declare const timelineExportAuditsLayer: Layer.Layer<TimelineExportAudits, never, Persistence>;
+//# sourceMappingURL=timelineExportAudits.d.ts.map

package/dist/server/server/application/timelineExportAudits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timelineExportAudits.d.ts","sourceRoot":"","sources":["../../../../src/server/application/timelineExportAudits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,EAAE,6BAA6B,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAI3D,8DAA8D;AAC9D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;sBAQnC,CAAA;AAEF,sDAAsD;AACtD,eAAO,MAAM,yBAAyB,uDAA+D,CAAA"}

package/dist/server/server/application/timelineExports.d.ts

@@ -0,0 +1,46 @@
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import type { WorkspaceId } from "../../domain/identifiers.js";
+import type { TimelineActorKind, TimelineCursor, TimelineEvent, TimelinePage } from "../../domain/timeline.js";
+import type { UtcTimestamp } from "../../domain/utcTimestamp.js";
+import type { ApplicationServiceUnavailable } from "../api/ApplicationServices.js";
+/** Caller-selected filters and hard event cap for one default-redacted export. */
+export interface TimelineExportInput {
+    readonly actorKind: TimelineActorKind | null;
+    readonly eventLimit: number;
+    readonly from: UtcTimestamp | null;
+    readonly to: UtcTimestamp | null;
+    readonly workspaceId: WorkspaceId;
+}
+/** Bounded material shared by the CSV and JSON encoders. */
+export interface TimelineExport {
+    readonly events: ReadonlyArray<TimelineEvent>;
+    readonly metadata: {
+        readonly eventCount: number;
+        readonly eventLimit: number;
+        readonly truncated: boolean;
+    };
+}
+/**
+ * Read through the public Timeline application seam using its stable composite
+ * cursor. One extra event is retained only long enough to report truncation.
+ */
+export declare const collectTimelineExport: (timeline: {
+    readonly page: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly actorKind: TimelineActorKind | null;
+        readonly before: TimelineCursor | null;
+        readonly from: UtcTimestamp | null;
+        readonly limit: number;
+        readonly to: UtcTimestamp | null;
+    }) => Effect.Effect<TimelinePage, ApplicationServiceUnavailable>;
+    readonly detail: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly eventKey: string;
+    }) => Effect.Effect<import("../../domain/timeline.js").TimelineEventDetail, import("../api/ApplicationServices.js").ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, input: TimelineExportInput) => Effect.Effect<TimelineExport, ApplicationServiceUnavailable, never>;
+/** Encode a standards-compatible CSV document one bounded row per byte chunk. */
+export declare const encodeTimelineCsv: (timelineExport: TimelineExport) => Stream.Stream<Uint8Array>;
+/** Encode a JSON object with explicit truncation metadata and bounded event chunks. */
+export declare const encodeTimelineJson: (timelineExport: TimelineExport) => Stream.Stream<Uint8Array>;
+//# sourceMappingURL=timelineExports.d.ts.map

package/dist/server/server/application/timelineExports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timelineExports.d.ts","sourceRoot":"","sources":["../../../../src/server/application/timelineExports.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC9G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,KAAK,EAAE,6BAA6B,EAAiB,MAAM,+BAA+B,CAAA;AAIjG,kFAAkF;AAClF,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAA;IAClC,QAAQ,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AAED,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IAC7C,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;QAC3B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;KAC5B,CAAA;CACF;AAED;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;qGA+BhC,CAAA;AAkCF,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,cAAc,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAI/D,CAAA;AAE5B,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,GAAI,gBAAgB,cAAc,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAS3F,CAAA"}

package/dist/server/server/application/timelineReads.d.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { WorkspaceId } from "../../domain/identifiers.js";
+import type { TimelineEvent, TimelineEventDetail, TimelinePage } from "../../domain/timeline.js";
+import { ApplicationResourceNotFound, ApplicationServiceUnavailable, TimelineReads } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+import type { TimelineRecord } from "../persistence/repositories/timelineRepository.js";
+/** Present one default-redacted durable record for the Timeline client. */
+export declare const presentTimelineEvent: (workspaceId: WorkspaceId, record: TimelineRecord) => TimelineEvent;
+/** Expand one exact Timeline event with owner-visible identifiers and agent attribution. */
+export declare const presentTimelineEventDetail: (workspaceId: WorkspaceId, record: TimelineRecord) => TimelineEventDetail;
+/** Construct the durable activity projection from bounded persistence reads. */
+export declare const makeTimelineReads: Effect.Effect<{
+    readonly page: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly actorKind: import("../../domain/timeline.js").TimelineActorKind | null;
+        readonly before: import("../../domain/timeline.js").TimelineCursor | null;
+        readonly from: import("../../index.ts").UtcTimestamp | null;
+        readonly limit: number;
+        readonly to: import("../../index.ts").UtcTimestamp | null;
+    }) => Effect.Effect<TimelinePage, ApplicationServiceUnavailable>;
+    readonly detail: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly eventKey: string;
+    }) => Effect.Effect<TimelineEventDetail, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live default-redacted Timeline projection. */
+export declare const timelineReadsLayer: Layer.Layer<TimelineReads, never, Persistence>;
+//# sourceMappingURL=timelineReads.d.ts.map

package/dist/server/server/application/timelineReads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timelineReads.d.ts","sourceRoot":"","sources":["../../../../src/server/application/timelineReads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAChG,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,aAAa,EACd,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mDAAmD,CAAA;AA4CvF,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,GAAI,aAAa,WAAW,EAAE,QAAQ,cAAc,KAAG,aAStF,CAAA;AAEF,4FAA4F;AAC5F,eAAO,MAAM,0BAA0B,GACrC,aAAa,WAAW,EACxB,QAAQ,cAAc,KACrB,mBAWD,CAAA;AAEF,gFAAgF;AAChF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;sBAsB5B,CAAA;AAEF,iDAAiD;AACjD,eAAO,MAAM,kBAAkB,gDAAiD,CAAA"}