@knpkv/control-center 0.1.0

package/dist/server/server/api/RequestLimits.d.ts

@@ -0,0 +1,79 @@
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as RateLimiter from "effect/unstable/persistence/RateLimiter";
+export declare const RequestLimitProfile: Schema.Literals<readonly ["pairing", "read", "mutation", "synchronization", "agent", "media"]>;
+export type RequestLimitProfile = typeof RequestLimitProfile.Type;
+/** Stable policy values applied by the API boundary. */
+export interface RequestLimitPolicyValue {
+    readonly maximumBodyBytes: number;
+    readonly pairing: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly read: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly mutation: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly synchronization: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly agent: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly media: {
+        readonly limit: number;
+        readonly window: Duration.Duration;
+    };
+    readonly readTimeout: Duration.Duration;
+    readonly mutationTimeout: Duration.Duration;
+    readonly synchronizationTimeout: Duration.Duration;
+    readonly agentTimeout: Duration.Duration;
+}
+declare const RequestLimitPolicy_base: Context.ServiceClass<RequestLimitPolicy, "@knpkv/control-center/server/api/RequestLimitPolicy", RequestLimitPolicyValue>;
+/** API request limits, replaceable in deterministic tests. */
+export declare class RequestLimitPolicy extends RequestLimitPolicy_base {
+    static readonly defaultLayer: Layer.Layer<RequestLimitPolicy, never, never>;
+}
+declare const RequestTimeLimitExceeded_base: Schema.Class<RequestTimeLimitExceeded, Schema.TaggedStruct<"RequestTimeLimitExceeded", {}>, import("effect/Cause").YieldableError>;
+/** A request exceeded its bounded execution time. */
+export declare class RequestTimeLimitExceeded extends RequestTimeLimitExceeded_base {
+}
+declare const RequestRateLimitExceeded_base: Schema.Class<RequestRateLimitExceeded, Schema.TaggedStruct<"RequestRateLimitExceeded", {
+    readonly limit: Schema.Int;
+    readonly retryAfterSeconds: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** A request exhausted its profile-specific token bucket. */
+export declare class RequestRateLimitExceeded extends RequestRateLimitExceeded_base {
+}
+declare const RequestRateLimitUnavailable_base: Schema.Class<RequestRateLimitUnavailable, Schema.TaggedStruct<"RequestRateLimitUnavailable", {}>, import("effect/Cause").YieldableError>;
+/** The configured rate-limit store could not evaluate a request. */
+export declare class RequestRateLimitUnavailable extends RequestRateLimitUnavailable_base {
+}
+declare const RequestBodyLimitExceeded_base: Schema.Class<RequestBodyLimitExceeded, Schema.TaggedStruct<"RequestBodyLimitExceeded", {
+    readonly maximumBytes: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+/** A declared request body is larger than the API permits. */
+export declare class RequestBodyLimitExceeded extends RequestBodyLimitExceeded_base {
+}
+/** Consume one request token without exposing the backing-store key in failures. */
+export declare const consumeRequestToken: (profile: "agent" | "synchronization" | "read" | "media" | "pairing" | "mutation", key: string) => Effect.Effect<RateLimiter.ConsumeResult, RequestRateLimitExceeded | RequestRateLimitUnavailable, RequestLimitPolicy | RateLimiter.RateLimiter>;
+/** Reject a declared oversized body and bound chunked/body decoding downstream. */
+export declare const enforceRequestBodyLimit: () => Effect.Effect<undefined, RequestBodyLimitExceeded, HttpServerRequest.HttpServerRequest | RequestLimitPolicy>;
+/** Apply the correct total execution budget for a request profile. */
+export declare const withRequestTimeout: <A, E, R>(effect: Effect.Effect<A, E, R>, profile: RequestLimitProfile) => Effect.Effect<A, E | RequestTimeLimitExceeded, R | RequestLimitPolicy>;
+/** Body-size reference read by Node and multipart request decoders. */
+export declare const withMaximumBodySize: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | RequestLimitPolicy>;
+/** Process-local limiter suitable for the single-process local Control Center. */
+export declare const requestRateLimiterLayer: Layer.Layer<RateLimiter.RateLimiter, never, never>;
+export {};
+//# sourceMappingURL=RequestLimits.d.ts.map

package/dist/server/server/api/RequestLimits.d.ts.map

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

package/dist/server/server/api/index.d.ts

@@ -0,0 +1,9 @@
+export { ApiBindConfiguration } from "./ApiConfiguration.js";
+export { authorizePairingRequest, mutationCsrfLayer, sessionCookieAuthLayer } from "./ApiMiddleware.js";
+export { ApplicationRateLimited, ApplicationResourceNotFound, ApplicationServiceUnavailable, AuthorizedShares, DeliveryGraphInspection, LiveEvents, MediaReads, PluginAdministration, PortfolioSnapshots, RelationshipRepairProposals, ReleaseAgentJobs } from "./ApplicationServices.js";
+export { controlCenterApiHandlersLayer, controlCenterApiLayer, controlCenterApiLayerWithLifecycle, controlCenterApiMiddlewareLayer } from "./ControlCenterApiServer.js";
+export { DEFAULT_MAXIMUM_LIVE_STREAMS, DEFAULT_MAXIMUM_LIVE_STREAMS_PER_SESSION, LiveStreamAdmission, LiveStreamAdmissionExceeded, type LiveStreamAdmissionLimits } from "./LiveStreamAdmission.js";
+export { requestBoundaryLayer } from "./RequestBoundary.js";
+export { CurrentRequestContext, makeCurrentRequestContext, provideCurrentRequest, withCorrelationResponse } from "./RequestContext.js";
+export { RequestLimitPolicy, requestRateLimiterLayer } from "./RequestLimits.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAA;AACvG,OAAO,EACL,sBAAsB,EACtB,2BAA2B,EAC3B,6BAA6B,EAC7B,gBAAgB,EAChB,uBAAuB,EACvB,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EACjB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,6BAA6B,EAC7B,qBAAqB,EACrB,kCAAkC,EAClC,+BAA+B,EAChC,MAAM,6BAA6B,CAAA;AACpC,OAAO,EACL,4BAA4B,EAC5B,wCAAwC,EACxC,mBAAmB,EACnB,2BAA2B,EAC3B,KAAK,yBAAyB,EAC/B,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA"}

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

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { AuthorizedShareSummary } from "../../api/shares.js";
+import type { WorkspaceId } from "../../domain/identifiers.js";
+import { ApplicationInvalidRequest, ApplicationResourceNotFound, AuthorizedShares } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct exact-scope authenticated share operations. */
+export declare const makeAuthorizedShares: Effect.Effect<{
+    readonly create: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly request: import("../../api/shares.js").CreateAuthorizedShareRequest;
+        readonly createdByPersonId: import("../../domain/identifiers.js").PersonId;
+        readonly sessionId: import("../../domain/identifiers.js").SessionId;
+    }) => Effect.Effect<AuthorizedShareSummary, import("../api/ApplicationServices.js").ApplicationConflict | ApplicationInvalidRequest | ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly resolve: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly shareId: import("../../domain/identifiers.js").ShareId;
+        readonly actor: import("../../index.ts").Actor;
+    }) => Effect.Effect<import("../../api/shares.js").AuthorizedShareResolution, ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+    readonly revoke: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly shareId: import("../../domain/identifiers.js").ShareId;
+        readonly revokedByPersonId: import("../../domain/identifiers.js").PersonId;
+        readonly sessionId: import("../../domain/identifiers.js").SessionId;
+    }) => Effect.Effect<void, ApplicationResourceNotFound | import("../api/ApplicationServices.js").ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live durable exact-scope authorized-share layer. */
+export declare const authorizedSharesLayer: Layer.Layer<AuthorizedShares, never, Persistence>;
+//# sourceMappingURL=authorizedShares.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authorizedShares.d.ts","sourceRoot":"","sources":["../../../../src/server/application/authorizedShares.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAGjE,OAAO,KAAK,EAAY,WAAW,EAAE,MAAM,6BAA6B,CAAA;AACxE,OAAO,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AACxH,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAe3D,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;sBAsF/B,CAAA;AAEF,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,mDAAuD,CAAA"}

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

@@ -0,0 +1,18 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { AwsResourceDiscoveryRequest, AwsResourceDiscoveryResponse } from "../../api/plugins.js";
+import { ApplicationInvalidRequest, ApplicationRateLimited, ApplicationServiceUnavailable } from "../api/ApplicationServices.js";
+type AwsIdentityDiscoveryError = ApplicationInvalidRequest | ApplicationRateLimited | ApplicationServiceUnavailable;
+/** Testable, credential-free application boundary for explicit AWS discovery. */
+export interface AwsResourceDiscoveryService {
+    readonly discover: (request: AwsResourceDiscoveryRequest) => Effect.Effect<AwsResourceDiscoveryResponse, AwsIdentityDiscoveryError>;
+}
+declare const AwsResourceDiscovery_base: Context.ServiceClass<AwsResourceDiscovery, "@knpkv/control-center/AwsResourceDiscovery", AwsResourceDiscoveryService>;
+/** Injectable application service used by owner-only AWS onboarding. */
+export declare class AwsResourceDiscovery extends AwsResourceDiscovery_base {
+}
+/** Production AWS discovery layer with bounded provider timeouts. */
+export declare const awsResourceDiscoveryLayer: Layer.Layer<AwsResourceDiscovery, never, import("effect/unstable/http/HttpClient").HttpClient>;
+export {};
+//# sourceMappingURL=awsResourceDiscovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"awsResourceDiscovery.d.ts","sourceRoot":"","sources":["../../../../src/server/application/awsResourceDiscovery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,OAAO,KAAK,EACV,2BAA2B,EAC3B,4BAA4B,EAE7B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,6BAA6B,EAC9B,MAAM,+BAA+B,CAAA;AAmBtC,KAAK,yBAAyB,GAAG,yBAAyB,GAAG,sBAAsB,GAAG,6BAA6B,CAAA;AAGnH,iFAAiF;AACjF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,QAAQ,EAAE,CACjB,OAAO,EAAE,2BAA2B,KACjC,MAAM,CAAC,MAAM,CAAC,4BAA4B,EAAE,yBAAyB,CAAC,CAAA;CAC5E;;AAED,wEAAwE;AACxE,qBAAa,oBAAqB,SAAQ,yBAEzC;CAAG;AAwLJ,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,gGAErC,CAAA"}

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

@@ -0,0 +1,50 @@
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { ApplicationInvalidRequest, ApplicationServiceUnavailable } from "../api/ApplicationServices.js";
+/** Bind a healthy connection to its provider-discovered account and resource identities. */
+export declare const materializeConnectionOwnership: (persistence: import("../persistence/Persistence.js").PersistenceService, cryptoService: Crypto.Crypto, connection: import("effect/Schema").Struct.ReadonlySide<{
+    readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+    readonly providerAccountId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ProviderAccountId">>;
+    readonly followedResourceId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "FollowedResourceId">>;
+    readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+    readonly displayName: import("effect/Schema").brand<import("effect/Schema").String, "PluginConnectionDisplayName">;
+    readonly isEnabled: import("effect/Schema").Boolean;
+    readonly revision: import("effect/Schema").brand<import("effect/Schema").Number, "RecordRevision">;
+    readonly createdAt: import("effect/Schema").DateTimeUtcFromString;
+    readonly updatedAt: import("effect/Schema").DateTimeUtcFromString;
+}, "Type">, discovery: import("effect/Schema").Struct.ReadonlySide<{
+    readonly account: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly providerImmutableId: import("effect/Schema").String;
+        readonly displayName: import("effect/Schema").String;
+    }>>;
+    readonly workspace: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly providerImmutableId: import("effect/Schema").String;
+        readonly displayName: import("effect/Schema").String;
+    }>>;
+    readonly resource: import("effect/Schema").decodeTo<import("effect/Schema").toType<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly providerImmutableId: import("effect/Schema").String;
+        readonly displayName: import("effect/Schema").String;
+    }>>>, import("effect/Schema").optional<import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+        readonly providerImmutableId: import("effect/Schema").String;
+        readonly displayName: import("effect/Schema").String;
+    }>>>, never, never>;
+    readonly endpoints: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literals<readonly ["api", "web", "graphql", "webhook"]>;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").URL, import("effect/Schema").String, never, never>;
+        readonly label: import("effect/Schema").NullOr<import("effect/Schema").String>;
+    }>>;
+    readonly discoveredAt: import("effect/Schema").DateTimeUtcFromString;
+}, "Type"> | null, expectedConfigurationRevision: number) => Effect.Effect<import("effect/Schema").Struct.ReadonlySide<{
+    readonly workspaceId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "PluginConnectionId">;
+    readonly providerAccountId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "ProviderAccountId">>;
+    readonly followedResourceId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").decodeTo<import("effect/Schema").String, import("effect/Schema").String, never, never>, "FollowedResourceId">>;
+    readonly providerId: import("effect/Schema").Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+    readonly displayName: import("effect/Schema").brand<import("effect/Schema").String, "PluginConnectionDisplayName">;
+    readonly isEnabled: import("effect/Schema").Boolean;
+    readonly revision: import("effect/Schema").brand<import("effect/Schema").Number, "RecordRevision">;
+    readonly createdAt: import("effect/Schema").DateTimeUtcFromString;
+    readonly updatedAt: import("effect/Schema").DateTimeUtcFromString;
+}, "Type">, import("../api/ApplicationServices.js").ApplicationResourceNotFound | ApplicationServiceUnavailable | import("../api/ApplicationServices.js").ApplicationConflict | ApplicationInvalidRequest, never>;
+//# sourceMappingURL=connectionOwnership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connectionOwnership.d.ts","sourceRoot":"","sources":["../../../../src/server/application/connectionOwnership.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC,OAAO,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAA;AAwCxG,4FAA4F;AAC5F,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iNAqFzC,CAAA"}

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

@@ -0,0 +1,59 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { EvidenceInspection, RelationshipHistoryInspection, RelationshipRepairCandidate, RelationshipRepairCandidates, RelationshipRepairProposalDraft, ReleaseDeliveryGraphInspection, WorkspaceEntityInspection, WorkspaceEntityProjectionIndex } from "../../api/deliveryGraph.js";
+import type { DeliveryRelationship, LedgerRevision } from "../../domain/deliveryGraph.js";
+import type { EntityId, EnvironmentId, RelationshipId, ReleaseId, WorkspaceId } from "../../domain/identifiers.js";
+import { ApplicationResourceNotFound, ApplicationServiceUnavailable, DeliveryGraphInspection } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Derive non-mutating repair suggestions from the current incomplete relationship prefix. */
+export declare const deriveRelationshipRepairCandidates: (slice: ReleaseDeliveryGraphInspection) => RelationshipRepairCandidates;
+/** Draft one future repair proposal only when the selected immutable candidate still exists. */
+export declare const deriveRelationshipRepairProposalDraft: (candidate: RelationshipRepairCandidate, revision: LedgerRevision) => RelationshipRepairProposalDraft | undefined;
+/** Construct bounded workspace-safe delivery graph inspection reads. */
+export declare const makeDeliveryGraphInspection: Effect.Effect<{
+    readonly workspaceEntity: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly entityId: EntityId;
+    }) => Effect.Effect<WorkspaceEntityInspection, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly workspaceEntityProjections: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly owner: import("../../domain/identifiers.js").PersonId | null;
+        readonly query: string | null;
+        readonly service: import("../../domain/deliveryGraph.js").DeliveryEntityService | null;
+        readonly status: import("../../domain/deliveryGraph.js").DeliveryEntityStatusGroup | null;
+        readonly type: import("../../domain/deliveryGraph.js").DeliveryEntityKind | null;
+    }) => Effect.Effect<WorkspaceEntityProjectionIndex, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly releaseSlice: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly releaseId: ReleaseId;
+        readonly environmentId: EnvironmentId | null;
+    }) => Effect.Effect<ReleaseDeliveryGraphInspection, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly repairCandidates: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly releaseId: ReleaseId;
+        readonly environmentId: EnvironmentId | null;
+    }) => Effect.Effect<RelationshipRepairCandidates, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly repairProposalDraft: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly releaseId: ReleaseId;
+        readonly environmentId: EnvironmentId | null;
+        readonly relationshipId: RelationshipId;
+        readonly revision: LedgerRevision;
+    }) => Effect.Effect<RelationshipRepairProposalDraft, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly relationship: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly relationshipId: RelationshipId;
+        readonly revision: LedgerRevision | null;
+    }) => Effect.Effect<DeliveryRelationship, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly relationshipHistory: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly relationshipId: RelationshipId;
+    }) => Effect.Effect<RelationshipHistoryInspection, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+    readonly evidence: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly evidenceId: import("../../domain/identifiers.js").EvidenceId;
+    }) => Effect.Effect<EvidenceInspection, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live delivery graph inspection layer. */
+export declare const deliveryGraphInspectionLayer: Layer.Layer<DeliveryGraphInspection, never, Persistence>;
+//# sourceMappingURL=deliveryGraphInspection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deliveryGraphInspection.d.ts","sourceRoot":"","sources":["../../../../src/server/application/deliveryGraphInspection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,EACV,kBAAkB,EAClB,6BAA6B,EAC7B,2BAA2B,EAC3B,4BAA4B,EAC5B,+BAA+B,EAC/B,8BAA8B,EAC9B,yBAAyB,EACzB,8BAA8B,EAC/B,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEzF,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAClH,OAAO,EACL,2BAA2B,EAC3B,6BAA6B,EAC7B,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AA4C3D,8FAA8F;AAC9F,eAAO,MAAM,kCAAkC,GAC7C,OAAO,8BAA8B,KACpC,4BAQD,CAAA;AAEF,gGAAgG;AAChG,eAAO,MAAM,qCAAqC,GAChD,WAAW,2BAA2B,EACtC,UAAU,cAAc,KACvB,+BAA+B,GAAG,SAUpC,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAsJtC,CAAA;AAEF,4CAA4C;AAC5C,eAAO,MAAM,4BAA4B,0DAAqE,CAAA"}

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

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import { ApplicationConflict, ApplicationInvalidRequest, ApplicationResourceNotFound, ApplicationServiceUnavailable } from "../api/ApplicationServices.js";
+import type { PersistenceOperationFailure } from "../persistence/Persistence.js";
+/** Collapse persistence diagnostics before they cross the authenticated application boundary. */
+export declare const mapPersistenceReadError: (error: PersistenceOperationFailure) => ApplicationResourceNotFound | ApplicationServiceUnavailable;
+/** Collapse a compare-and-swap write without leaking durable record metadata. */
+export declare const mapPersistenceWriteError: (error: PersistenceOperationFailure) => ApplicationConflict | ApplicationInvalidRequest | ApplicationResourceNotFound | ApplicationServiceUnavailable;
+/** Public read mapping helper used at every persistence call site. */
+export declare const mapPersistenceRead: <Value>(effect: Effect.Effect<Value, PersistenceOperationFailure>) => Effect.Effect<Value, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/server/application/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAA;AAEhF,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,GAClC,OAAO,2BAA2B,KACjC,2BAA2B,GAAG,6BAGyB,CAAA;AAE1D,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,GACnC,OAAO,2BAA2B,KACjC,mBAAmB,GAAG,yBAAyB,GAAG,2BAA2B,GAAG,6BAY/C,CAAA;AAEpC,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,GAAI,KAAK,EACtC,QAAQ,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,2BAA2B,CAAC,KACxD,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,2BAA2B,GAAG,6BAA6B,CAC5B,CAAA"}

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

@@ -0,0 +1,152 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { type Person as PersonType } from "../../domain/actors.js";
+import { type PluginHealth } from "../../domain/freshness.js";
+import type { PluginConnectionId, WorkspaceId } from "../../domain/identifiers.js";
+import { type Release as ReleaseType } from "../../domain/release.js";
+import type { ProviderId } from "../../domain/sourceRevision.js";
+import type { UtcTimestamp } from "../../domain/utcTimestamp.js";
+import { type PluginStreamKey } from "../persistence/repositories/pluginRuntimeModels.js";
+/** Strict host fixture carried inside the fake adapter's otherwise generic attributes. */
+export declare const FakeReleaseAttributes: Schema.Struct<{
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+    readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+    readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+    readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly staleAfterSeconds: Schema.Int;
+    readonly collaborators: Schema.$Array<Schema.Struct<{
+        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+        readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+        readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+    }>>;
+}>;
+declare const FakeReleaseNormalizationError_base: Schema.Class<FakeReleaseNormalizationError, Schema.TaggedStruct<"FakeReleaseNormalizationError", {
+    readonly diagnosticCode: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Bounded failure raised before a fake release page can advance its checkpoint. */
+export declare class FakeReleaseNormalizationError extends FakeReleaseNormalizationError_base {
+}
+/** Validate the complete prospective cache before the durable checkpoint transaction starts. */
+export declare const prevalidateFakeReleasePage: (page: Schema.Struct.ReadonlySide<{
+    readonly events: Schema.$Array<Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"UpsertEntity", {
+        readonly sourceUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+        readonly title: Schema.String;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly entityType: Schema.brand<Schema.String, string>;
+        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        readonly eventId: Schema.brand<Schema.String, string>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+    }>, Schema.TaggedStruct<"TombstoneEntity", {
+        readonly reason: Schema.String;
+        readonly entityType: Schema.brand<Schema.String, string>;
+        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        readonly eventId: Schema.brand<Schema.String, string>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+    }>, Schema.TaggedStruct<"AppendEvidence", {
+        readonly evidenceId: Schema.brand<Schema.String, string>;
+        readonly subject: Schema.Struct<{
+            entityType: Schema.brand<Schema.String, string>;
+            vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>;
+        readonly evidenceType: Schema.brand<Schema.String, string>;
+        readonly summary: Schema.String;
+        readonly capturedAt: Schema.DateTimeUtcFromString;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly eventId: Schema.brand<Schema.String, string>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+    }>, Schema.TaggedStruct<"UpsertPerson", {
+        readonly vendorPersonId: Schema.brand<Schema.String, string>;
+        readonly displayName: Schema.String;
+        readonly avatarUrl: Schema.NullOr<Schema.decodeTo<Schema.URL, Schema.String, never, never>>;
+        readonly active: Schema.Boolean;
+        readonly eventId: Schema.brand<Schema.String, string>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+    }>, Schema.TaggedStruct<"ProposeRelationship", {
+        readonly relationshipId: Schema.brand<Schema.String, string>;
+        readonly from: Schema.Struct<{
+            entityType: Schema.brand<Schema.String, string>;
+            vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>;
+        readonly to: Schema.Struct<{
+            entityType: Schema.brand<Schema.String, string>;
+            vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        }>;
+        readonly relationshipType: Schema.brand<Schema.String, string>;
+        readonly confidence: Schema.Number;
+        readonly evidenceIds: Schema.$Array<Schema.brand<Schema.String, string>>;
+        readonly eventId: Schema.brand<Schema.String, string>;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+    }>]>>;
+    readonly checkpointAfterPage: Schema.brand<Schema.String, string>;
+    readonly hasMore: Schema.Boolean;
+}, "Type">, existingRecords: readonly Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+    readonly recordKey: Schema.brand<Schema.String, "PluginRecordKey">;
+    readonly state: Schema.Literals<readonly ["present", "tombstoned"]>;
+    readonly payloadJson: Schema.NullOr<Schema.String>;
+    readonly payloadDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+    readonly sourceRevision: Schema.brand<Schema.String, "Revision">;
+    readonly lastPageId: Schema.brand<Schema.String, "PluginPageId">;
+    readonly cachedAt: Schema.DateTimeUtcFromString;
+    readonly tombstonedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+}, "Type">[], input: FakeReleaseNormalizationInput & {
+    readonly streamKey: PluginStreamKey;
+}) => Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+    readonly vendorPersonId: Schema.brand<Schema.String, "VendorImmutableId">;
+    readonly role: Schema.Literals<readonly ["release-owner", "release-approver"]>;
+}, "Type">[], FakeReleaseNormalizationError, never>;
+export interface FakeReleaseProjection {
+    readonly people: ReadonlyArray<PersonType>;
+    readonly release: ReleaseType;
+}
+export interface FakeReleaseNormalizationInput {
+    readonly workspaceId: WorkspaceId;
+    readonly pluginConnectionId: PluginConnectionId;
+    readonly providerId: ProviderId;
+    readonly pluginHealth: PluginHealth;
+    readonly evaluatedAt: UtcTimestamp;
+    readonly provenance: "provider" | "cache";
+    readonly previousRelease: ReleaseType | null;
+}
+/** Resolve the canonical fixture identity without reading a mutable presentation projection. */
+export declare const fakeReleaseIdFromCache: (records: readonly Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+    readonly recordKey: Schema.brand<Schema.String, "PluginRecordKey">;
+    readonly state: Schema.Literals<readonly ["present", "tombstoned"]>;
+    readonly payloadJson: Schema.NullOr<Schema.String>;
+    readonly payloadDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+    readonly sourceRevision: Schema.brand<Schema.String, "Revision">;
+    readonly lastPageId: Schema.brand<Schema.String, "PluginPageId">;
+    readonly cachedAt: Schema.DateTimeUtcFromString;
+    readonly tombstonedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+}, "Type">[]) => Effect.Effect<Option.Option<string & import("effect/Brand").Brand<"ReleaseId">>, FakeReleaseNormalizationError, never>;
+/** Build one canonical fake release strictly from the committed last-valid cache. */
+export declare const normalizeFakeReleaseCache: (records: readonly Schema.Struct.ReadonlySide<{
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly streamKey: Schema.brand<Schema.String, "PluginStreamKey">;
+    readonly recordKey: Schema.brand<Schema.String, "PluginRecordKey">;
+    readonly state: Schema.Literals<readonly ["present", "tombstoned"]>;
+    readonly payloadJson: Schema.NullOr<Schema.String>;
+    readonly payloadDigest: Schema.NullOr<Schema.brand<Schema.String, "BlobDigest">>;
+    readonly sourceRevision: Schema.brand<Schema.String, "Revision">;
+    readonly lastPageId: Schema.brand<Schema.String, "PluginPageId">;
+    readonly cachedAt: Schema.DateTimeUtcFromString;
+    readonly tombstonedAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+}, "Type">[], input: FakeReleaseNormalizationInput) => Effect.Effect<Option.Option<FakeReleaseProjection>, FakeReleaseNormalizationError, never>;
+export {};
+//# sourceMappingURL=fakeReleaseNormalization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fakeReleaseNormalization.d.ts","sourceRoot":"","sources":["../../../../src/server/application/fakeReleaseNormalization.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAgC,KAAK,MAAM,IAAI,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAChG,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAGlF,OAAO,EAEL,KAAK,OAAO,IAAI,WAAW,EAI5B,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAEhE,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,oDAAoD,CAAA;AAS3D,0FAA0F;AAC1F,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;EAuBkB,CAAA;;;;AAEpD,oFAAoF;AACpF,qBAAa,6BAA8B,SAAQ,kCAKlD;CAAG;AAeJ,gGAAgG;AAChG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAGwB,eAAe;;;;;;mDAwI5E,CAAA;AAaF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC1C,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAC9B;AAED,MAAM,WAAW,6BAA6B;IAC5C,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,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAA;IAClC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAA;IACzC,QAAQ,CAAC,eAAe,EAAE,WAAW,GAAG,IAAI,CAAA;CAC7C;AAED,gGAAgG;AAChG,eAAO,MAAM,sBAAsB;;;;;;;;;;;;uIAkBjC,CAAA;AA4BF,qFAAqF;AACrF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;gJAoHpC,CAAA"}

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

@@ -0,0 +1,17 @@
+/** Durable application adapters for the authenticated HTTP API. @packageDocumentation */
+export { authorizedSharesLayer, makeAuthorizedShares } from "./authorizedShares.js";
+export { deliveryGraphInspectionLayer, makeDeliveryGraphInspection } from "./deliveryGraphInspection.js";
+export { mapPersistenceReadError, mapPersistenceWriteError } from "./errors.js";
+export { liveEventsLayer, makeLiveEvents } from "./liveEvents.js";
+export { makeMediaReads, mediaReadsLayer } from "./mediaReads.js";
+export { listFirstPartyServiceMetadata, listPluginConnectionSummaries, makePluginAdministration, makePluginAdministrationWithConnections, makePluginAdministrationWithOAuth, pluginAdministrationLayer, pluginAdministrationLayerWithConnections, pluginAdministrationOAuthLayer, pluginAdministrationOAuthLayerWithConnections } from "./pluginAdministration.js";
+export { makePortfolioSnapshots, portfolioSnapshotsLayer } from "./portfolioSnapshots.js";
+export { digestEnvironmentReadinessCandidate, digestReadinessRule, digestReleaseReadinessCandidate, ReadinessDigestError } from "./readinessDigests.js";
+export { makeRelationshipRepairProposals, relationshipRepairProposalsLayer } from "./relationshipRepairProposals.js";
+export { makeReleaseAgentTurns, type ReleaseAgentRuntimeOptions, releaseAgentTurnsLayer, releaseAgentUnavailableLayer } from "./releaseAgent.js";
+export { makeReleaseAgentJobs, releaseAgentJobsLayer, releaseAgentJobsUnavailableLayer } from "./releaseAgentJobs.js";
+export { reconcileFakeReleaseProjection, reconcileFakeReleaseSyncAttempts, recoverFakeReleaseProjection, synchronizeFakeRelease, synchronizeFakeReleaseFromMap } from "./releaseSynchronization.js";
+export type { ReleaseSynchronizationFailure, ReleaseSynchronizationInput, ReleaseSynchronizationOutcome } from "./releaseSynchronization.js";
+export { makeTimelineExportAudits, timelineExportAuditsLayer } from "./timelineExportAudits.js";
+export { makeTimelineReads, timelineReadsLayer } from "./timelineReads.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/application/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AACnF,OAAO,EAAE,4BAA4B,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAA;AACxG,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAC/E,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,wBAAwB,EACxB,uCAAuC,EACvC,iCAAiC,EACjC,yBAAyB,EACzB,wCAAwC,EACxC,8BAA8B,EAC9B,6CAA6C,EAC9C,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAA;AACzF,OAAO,EACL,mCAAmC,EACnC,mBAAmB,EACnB,+BAA+B,EAC/B,oBAAoB,EACrB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,+BAA+B,EAAE,gCAAgC,EAAE,MAAM,kCAAkC,CAAA;AACpH,OAAO,EACL,qBAAqB,EACrB,KAAK,0BAA0B,EAC/B,sBAAsB,EACtB,4BAA4B,EAC7B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAA;AACrH,OAAO,EACL,8BAA8B,EAC9B,gCAAgC,EAChC,4BAA4B,EAC5B,sBAAsB,EACtB,6BAA6B,EAC9B,MAAM,6BAA6B,CAAA;AACpC,YAAY,EACV,6BAA6B,EAC7B,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAC/F,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA"}

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

@@ -0,0 +1,22 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import type { ControlCenterLiveEvent } from "../../api/liveEvents.js";
+import type { EventCursor, WorkspaceId } from "../../domain/identifiers.js";
+import { ApplicationServiceUnavailable, LiveEvents, PortfolioSnapshots } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+import { DomainEventWakeups } from "../runtime/DomainEventWakeups.js";
+/** Maximum durable events read into one SSE replay page. */
+export declare const LIVE_EVENT_PAGE_SIZE = 128;
+/** Maximum durable replay distance before an authoritative snapshot reset. */
+export declare const MAXIMUM_LIVE_EVENT_REPLAY_EVENTS = 512;
+/** Construct the durable replay stream behind the authenticated SSE endpoint. */
+export declare const makeLiveEvents: Effect.Effect<{
+    readonly open: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly after: EventCursor | undefined;
+    }) => Effect.Effect<Stream.Stream<ControlCenterLiveEvent>, ApplicationServiceUnavailable, import("effect/Scope").Scope>;
+}, never, Persistence | PortfolioSnapshots | DomainEventWakeups>;
+/** Durable live-event application layer. */
+export declare const liveEventsLayer: Layer.Layer<LiveEvents, never, Persistence | PortfolioSnapshots | DomainEventWakeups>;
+//# sourceMappingURL=liveEvents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"liveEvents.d.ts","sourceRoot":"","sources":["../../../../src/server/application/liveEvents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAErE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAC3E,OAAO,EAAE,6BAA6B,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAC7G,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AAErE,4DAA4D;AAC5D,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAGvC,8EAA8E;AAC9E,eAAO,MAAM,gCAAgC,MAAM,CAAA;AA4BnD,iFAAiF;AACjF,eAAO,MAAM,cAAc;;;;;gEA+HzB,CAAA;AAEF,4CAA4C;AAC5C,eAAO,MAAM,eAAe,uFAA2C,CAAA"}

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

@@ -0,0 +1,41 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import type { PluginSynchronizationState } from "../../api/plugins.js";
+import type { PluginConnectionId, WorkspaceId } from "../../domain/identifiers.js";
+import { type PluginSyncPageV1, PluginSyncRequestV1 } from "../../domain/plugins/events.js";
+import type { ProviderId } from "../../domain/sourceRevision.js";
+import { ApplicationInvalidRequest, type PluginAdministrationError } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+import type { PluginFailure } from "../plugins/failures.js";
+import { type PluginConnectionV1 } from "../plugins/PluginConnection.js";
+import type { PluginConnectionMapV1 } from "../plugins/PluginConnectionMap.js";
+import { DomainEventWakeups } from "../runtime/DomainEventWakeups.js";
+/** One provider-neutral manual synchronization driver with a fixed logical stream identity. */
+export interface ManualPluginSyncDriver {
+    readonly providerId: ProviderId;
+    readonly streamKey: string;
+    readonly sync: (connection: PluginConnectionV1, request: typeof PluginSyncRequestV1.Type) => Stream.Stream<PluginSyncPageV1, PluginFailure>;
+}
+/** Fixed lookup boundary that keeps provider identifiers out of the orchestration state machine. */
+export interface ManualPluginSyncDriverRegistry {
+    readonly get: (providerId: ProviderId) => Option.Option<ManualPluginSyncDriver>;
+}
+/** Build a deterministic driver registry for production or fixture connections. */
+export declare const makeManualPluginSyncDriverRegistry: (drivers: ReadonlyArray<ManualPluginSyncDriver>) => ManualPluginSyncDriverRegistry;
+/** Production drivers for first-party connections that currently negotiate synchronization. */
+export declare const firstPartyManualPluginSyncDrivers: ManualPluginSyncDriverRegistry;
+export interface ManualPluginSynchronizationService {
+    readonly state: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly pluginConnectionId: PluginConnectionId;
+    }) => Effect.Effect<PluginSynchronizationState, ApplicationInvalidRequest | PluginAdministrationError>;
+    readonly synchronize: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly pluginConnectionId: PluginConnectionId;
+    }) => Effect.Effect<PluginSynchronizationState, ApplicationInvalidRequest | PluginAdministrationError>;
+}
+/** Build the bounded synchronization application over a scoped provider runtime map. */
+export declare const makeManualPluginSynchronization: (connections: PluginConnectionMapV1, drivers?: ManualPluginSyncDriverRegistry | undefined) => Effect.Effect<ManualPluginSynchronizationService, never, Crypto.Crypto | Persistence | DomainEventWakeups>;
+//# sourceMappingURL=manualPluginSynchronization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manualPluginSynchronization.d.ts","sourceRoot":"","sources":["../../../../src/server/application/manualPluginSynchronization.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAElF,OAAO,EAAsB,KAAK,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAC/G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAEhE,OAAO,EACL,yBAAyB,EAGzB,KAAK,yBAAyB,EAC/B,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAM3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAG3D,OAAO,EAAoB,KAAK,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAC1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AA6BrE,+FAA+F;AAC/F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE,CACb,UAAU,EAAE,kBAAkB,EAC9B,OAAO,EAAE,OAAO,mBAAmB,CAAC,IAAI,KACrC,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,aAAa,CAAC,CAAA;CACpD;AAED,oGAAoG;AACpG,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,GAAG,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAA;CAChF;AAED,mFAAmF;AACnF,eAAO,MAAM,kCAAkC,GAC7C,SAAS,aAAa,CAAC,sBAAsB,CAAC,KAC7C,8BAIF,CAAA;AAOD,+FAA+F;AAC/F,eAAO,MAAM,iCAAiC,gCAM5C,CAAA;AAgIF,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QACtB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;KAChD,KAAK,MAAM,CAAC,MAAM,CAAC,0BAA0B,EAAE,yBAAyB,GAAG,yBAAyB,CAAC,CAAA;IACtG,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE;QAC5B,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAA;KAChD,KAAK,MAAM,CAAC,MAAM,CAAC,0BAA0B,EAAE,yBAAyB,GAAG,yBAAyB,CAAC,CAAA;CACvG;AAED,wFAAwF;AACxF,eAAO,MAAM,+BAA+B,0MA6R1C,CAAA"}

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

@@ -0,0 +1,14 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { ApplicationResourceNotFound, ApplicationServiceUnavailable, MediaReads } from "../api/ApplicationServices.js";
+import { Persistence } from "../persistence/Persistence.js";
+/** Construct an opaque, workspace-authorized media reader over content-addressed storage. */
+export declare const makeMediaReads: Effect.Effect<{
+    readonly read: (input: {
+        readonly workspaceId: import("../../index.ts").WorkspaceId;
+        readonly mediaId: import("../../api/media.js").OpaqueMediaId;
+    }) => Effect.Effect<import("../api/ApplicationServices.js").MediaRead, ApplicationResourceNotFound | ApplicationServiceUnavailable>;
+}, never, Persistence>;
+/** Live opaque media layer. */
+export declare const mediaReadsLayer: Layer.Layer<MediaReads, never, Persistence>;
+//# sourceMappingURL=mediaReads.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mediaReads.d.ts","sourceRoot":"","sources":["../../../../src/server/application/mediaReads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC,OAAO,EAAE,2BAA2B,EAAE,6BAA6B,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAGtH,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAM3D,6FAA6F;AAC7F,eAAO,MAAM,cAAc;;;;;sBAgCzB,CAAA;AAEF,+BAA+B;AAC/B,eAAO,MAAM,eAAe,6CAA2C,CAAA"}