@knpkv/control-center 0.1.0

package/dist/server/server/governance/internal/execution-store/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/live.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mCAAmC,CAAA;AACpE,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAA;AAkCjF,mGAAmG;AACnG,eAAO,MAAM,iCAAiC,GAAI,aAAa,WAAW,uZAIvE,CAAA"}

package/dist/server/server/governance/internal/execution-store/preparation.d.ts

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { WorkspaceId } from "../../../../domain/identifiers.js";
+import { Database } from "../../../persistence/Database.js";
+import { PersistedRecordError, RecordNotFoundError } from "../../../persistence/errors.js";
+import { GovernedActionPreparationTokenDigest } from "./tokens.js";
+declare const PreparationRow: Schema.Struct<{
+    readonly preparationTokenDigest: Schema.brand<Schema.String, "GovernedActionPreparationTokenDigest">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    readonly expectedHeadTransitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+    readonly expectedEnvelopeDigest: Schema.brand<Schema.String, string>;
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+}>;
+export type GovernedActionExecutionPreparationRow = typeof PreparationRow.Type;
+/** Exact preparation lookup for the transaction that converts inspection into durable intent. */
+export declare const makeGovernedActionExecutionPreparationReader: Effect.Effect<{
+    consume: (preparation: Schema.Struct.ReadonlySide<{
+        readonly preparationTokenDigest: Schema.brand<Schema.String, "GovernedActionPreparationTokenDigest">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+        readonly expectedHeadTransitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+        readonly expectedEnvelopeDigest: Schema.brand<Schema.String, string>;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly expiresAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<boolean, unknown, never>;
+    read: (input: {
+        readonly workspaceId: WorkspaceId;
+        readonly preparationTokenDigest: GovernedActionPreparationTokenDigest;
+    }) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly preparationTokenDigest: Schema.brand<Schema.String, "GovernedActionPreparationTokenDigest">;
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+        readonly expectedHeadTransitionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionTransitionId">;
+        readonly expectedEnvelopeDigest: Schema.brand<Schema.String, string>;
+        readonly createdAt: Schema.DateTimeUtcFromString;
+        readonly expiresAt: Schema.DateTimeUtcFromString;
+    }, "Type">, RecordNotFoundError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError, never>;
+}, never, Database>;
+export {};
+//# sourceMappingURL=preparation.d.ts.map

package/dist/server/server/governance/internal/execution-store/preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preparation.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/preparation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAgD,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAE7G,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AAE1F,OAAO,EAAE,oCAAoC,EAAE,MAAM,aAAa,CAAA;AAElE,QAAA,MAAM,cAAc;;;;;;;;EAQlB,CAAA;AAEF,MAAM,MAAM,qCAAqC,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAE9E,iGAAiG;AACjG,eAAO,MAAM,4CAA4C;;;;;;;;;;;8BAI/B,WAAW;yCACA,oCAAoC;;;;;;;;;;mBAsDvE,CAAA"}

package/dist/server/server/governance/internal/execution-store/provider-outcome-fold.d.ts

@@ -0,0 +1,33 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { GovernedActionCommandDigest } from "../../../../domain/governedAction/index.js";
+import { GovernedActionId, WorkspaceId } from "../../../../domain/identifiers.js";
+import { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+import type { GovernedActionPermitTokenDigest, GovernedActionRecoveryTokenDigest } from "./tokens.js";
+declare const ProviderOutcomeSourceKind: Schema.Literals<readonly ["dispatch", "reconciliation"]>;
+declare const ProviderOutcomeResultKind: Schema.Literals<readonly ["accepted", "succeeded", "failed", "cancelled", "unknown", "manual-unknown", "pending", "recovery-unavailable"]>;
+interface ExpectedProviderOutcome {
+    readonly actionId: GovernedActionId;
+    readonly commandDigest: typeof GovernedActionCommandDigest.Type;
+    readonly outcomeDigest: string;
+    readonly outcomeId: string;
+    readonly outcomeJson: string;
+    readonly observedAt: UtcTimestamp;
+    readonly resultKind: typeof ProviderOutcomeResultKind.Type;
+    readonly sourceKind: typeof ProviderOutcomeSourceKind.Type;
+    readonly sourceTokenDigest: GovernedActionPermitTokenDigest | GovernedActionRecoveryTokenDigest;
+    readonly workspaceId: WorkspaceId;
+}
+/** Own every canonical verification, replay check, transaction, and fold for provider outcomes. */
+export declare const makeGovernedActionExecutionProviderOutcomeFolder: Effect.Effect<{
+    foldExpected: (operation: "record-dispatch" | "record-recovery-unavailable" | "record-unknown" | "record-reconciliation", expected: ExpectedProviderOutcome) => Effect.Effect<"unknown" | "proposed" | "expired" | "failed" | "cancelled" | "succeeded" | "cancel-requested" | "denied" | "authorized" | "started" | "cancel-requested-unknown", GovernedActionExecutionStoreError, never>;
+    foldPending: (reference: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    }, "Type">) => Effect.Effect<"unknown" | "proposed" | "expired" | "failed" | "cancelled" | "succeeded" | "cancel-requested" | "denied" | "authorized" | "started" | "cancel-requested-unknown" | null, GovernedActionExecutionStoreError, never>;
+}, never, Crypto.Crypto | Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+export {};
+//# sourceMappingURL=provider-outcome-fold.d.ts.map

package/dist/server/server/governance/internal/execution-store/provider-outcome-fold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-outcome-fold.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/provider-outcome-fold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAA;AACxF,OAAO,EAAE,gBAAgB,EAA8B,WAAW,EAAE,MAAM,mCAAmC,CAAA;AAC7G,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAO3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAgBtF,OAAO,KAAK,EAAE,+BAA+B,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAA;AASrG,QAAA,MAAM,yBAAyB,0DAAkD,CAAA;AACjF,QAAA,MAAM,yBAAyB,4IAS7B,CAAA;AAKF,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,aAAa,EAAE,OAAO,2BAA2B,CAAC,IAAI,CAAA;IAC/D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,OAAO,yBAAyB,CAAC,IAAI,CAAA;IAC1D,QAAQ,CAAC,UAAU,EAAE,OAAO,yBAAyB,CAAC,IAAI,CAAA;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,+BAA+B,GAAG,iCAAiC,CAAA;IAC/F,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAClC;AAwFD,mGAAmG;AACnG,eAAO,MAAM,gDAAgD;;;;;;8HAsL3D,CAAA"}

package/dist/server/server/governance/internal/execution-store/reconciliation-inbox.d.ts

@@ -0,0 +1,20 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+import { type ReconciliationInboxOutcome } from "./reconciliation-outcome.js";
+import { type GovernedActionRecoveryToken } from "./tokens.js";
+type ReconciliationInboxOperation = "record-reconciliation" | "record-recovery-unavailable";
+interface ReconciliationInboxInput {
+    readonly operation: ReconciliationInboxOperation;
+    readonly outcome: ReconciliationInboxOutcome;
+    readonly receivedAt: UtcTimestamp;
+    readonly recoveryToken: GovernedActionRecoveryToken;
+}
+/** Build the durable append-then-fold boundary shared by reconciliation-side outcomes. */
+export declare const makeGovernedActionExecutionReconciliationInbox: Effect.Effect<{
+    recordOutcome: (input: ReconciliationInboxInput) => Effect.Effect<"unknown" | "proposed" | "expired" | "failed" | "cancelled" | "succeeded" | "cancel-requested" | "denied" | "authorized" | "started" | "cancel-requested-unknown", GovernedActionExecutionStoreError, never>;
+}, never, Crypto.Crypto | Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+export {};
+//# sourceMappingURL=reconciliation-inbox.d.ts.map

package/dist/server/server/governance/internal/execution-store/reconciliation-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-inbox.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/reconciliation-inbox.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAG3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAGtF,OAAO,EAEL,KAAK,0BAA0B,EAKhC,MAAM,6BAA6B,CAAA;AACpC,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,aAAa,CAAA;AAEpB,KAAK,4BAA4B,GAAG,uBAAuB,GAAG,6BAA6B,CAAA;AAE3F,UAAU,wBAAwB;IAChC,QAAQ,CAAC,SAAS,EAAE,4BAA4B,CAAA;IAChD,QAAQ,CAAC,OAAO,EAAE,0BAA0B,CAAA;IAC5C,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAA;CACpD;AAmED,0FAA0F;AAC1F,eAAO,MAAM,8CAA8C;;8HA4JzD,CAAA"}

package/dist/server/server/governance/internal/execution-store/reconciliation-locator.d.ts

@@ -0,0 +1,5 @@
+import type { PluginActionReconciliationRequestV1 } from "../../../../domain/plugins/actions.js";
+import type { GovernedActionRecord } from "../../../persistence/repositories/governed-action/contract.js";
+/** Resolve the provider key retained by lineage, or null for immutable idempotency recovery. */
+export declare const governedActionReconciliationKey: (record: GovernedActionRecord) => PluginActionReconciliationRequestV1["reconciliationKey"];
+//# sourceMappingURL=reconciliation-locator.d.ts.map

package/dist/server/server/governance/internal/execution-store/reconciliation-locator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-locator.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/reconciliation-locator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAA;AAChG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+DAA+D,CAAA;AAEzG,gGAAgG;AAChG,eAAO,MAAM,+BAA+B,GAC1C,QAAQ,oBAAoB,KAC3B,mCAAmC,CAAC,mBAAmB,CAWzD,CAAA"}

package/dist/server/server/governance/internal/execution-store/reconciliation-outcome.d.ts

@@ -0,0 +1,123 @@
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import type { GovernedActionTransitionCommand } from "../../../../domain/governedAction/index.js";
+import type { PluginActionReconciliationKey } from "../../../../domain/plugins/actions.js";
+import type { UtcTimestamp } from "../../../../domain/utcTimestamp.js";
+import { type EncodedGovernedActionDispatchOutcome, GovernedActionDigestError } from "../../governedActionDigests.js";
+/** Versioned local evidence that the dispatch-owning runtime generation cannot be recovered. */
+export declare const GovernedActionRecoveryUnavailableOutcomeV1: Schema.TaggedStruct<"recovery-unavailable", {
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly reason: Schema.Literal<"runtime-generation-unavailable">;
+}>;
+/** Closed reconciliation-side artifacts accepted by the durable provider-outcome inbox. */
+export declare const ReconciliationInboxOutcome: Schema.Union<readonly [Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"pending", {
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"succeeded">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"failed">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>, Schema.Struct<{
+    readonly _tag: Schema.tag<"cancelled">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}>]>, Schema.TaggedStruct<"recovery-unavailable", {
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly reason: Schema.Literal<"runtime-generation-unavailable">;
+}>]>;
+/** Decoded reconciliation-side inbox artifact. */
+export type ReconciliationInboxOutcome = typeof ReconciliationInboxOutcome.Type;
+/** Closed persisted kinds for reconciliation results. */
+export declare const ReconciliationResultKind: Schema.Literals<readonly ["pending", "succeeded", "failed", "cancelled", "recovery-unavailable"]>;
+/** Project one reconciliation-side artifact to its immutable inbox kind. */
+export declare const reconciliationInboxOutcomeKind: (outcome: ReconciliationInboxOutcome) => typeof ReconciliationResultKind.Type;
+/** Project the source observation retained separately from trusted host receipt time. */
+export declare const reconciliationInboxOutcomeObservedAt: (outcome: ReconciliationInboxOutcome, receivedAt: UtcTimestamp) => UtcTimestamp;
+/** Reconstruct the lifecycle command represented by one reconciliation-side inbox outcome. */
+export declare const reconciliationInboxOutcomeCommand: (outcome: ReconciliationInboxOutcome, reconciliationKey: typeof PluginActionReconciliationKey.Type | null, observedAt: UtcTimestamp) => GovernedActionTransitionCommand;
+/** Canonically encode and hash either provider reconciliation output or local unavailable evidence. */
+export declare const encodeReconciliationInboxOutcome: (outcome: Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"succeeded">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"failed">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"cancelled">;
+    readonly receipt: Schema.Union<readonly [Schema.Struct<{
+        readonly status: Schema.Literal<"accepted">;
+        readonly reconciliationKey: Schema.brand<Schema.String, string>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["succeeded", "failed", "cancelled"]>;
+        readonly providerOperationId: Schema.brand<Schema.String, string>;
+        readonly safeSummary: Schema.String;
+        readonly observedAt: Schema.DateTimeUtcFromString;
+    }>]>;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"pending">;
+    readonly checkedAt: Schema.DateTimeUtcFromString;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly _tag: Schema.tag<"recovery-unavailable">;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly reason: Schema.Literal<"runtime-generation-unavailable">;
+}, "Type">) => Effect.Effect<EncodedGovernedActionDispatchOutcome, GovernedActionDigestError, Crypto.Crypto>;
+//# sourceMappingURL=reconciliation-outcome.d.ts.map

package/dist/server/server/governance/internal/execution-store/reconciliation-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconciliation-outcome.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/reconciliation-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4CAA4C,CAAA;AACjG,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAA;AAE1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACtE,OAAO,EAGL,KAAK,oCAAoC,EACzC,yBAAyB,EAC1B,MAAM,gCAAgC,CAAA;AAEvC,gGAAgG;AAChG,eAAO,MAAM,0CAA0C;;;EAGrD,CAAA;AAEF,2FAA2F;AAC3F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGrC,CAAA;AAEF,kDAAkD;AAClD,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAE/E,yDAAyD;AACzD,eAAO,MAAM,wBAAwB,mGAMnC,CAAA;AAIF,4EAA4E;AAC5E,eAAO,MAAM,8BAA8B,GACzC,SAAS,0BAA0B,KAClC,OAAO,wBAAwB,CAAC,IAAoB,CAAA;AAEvD,yFAAyF;AACzF,eAAO,MAAM,oCAAoC,GAC/C,SAAS,0BAA0B,EACnC,YAAY,YAAY,KACvB,YAK6B,CAAA;AAEhC,8FAA8F;AAC9F,eAAO,MAAM,iCAAiC,GAC5C,SAAS,0BAA0B,EACnC,mBAAmB,OAAO,6BAA6B,CAAC,IAAI,GAAG,IAAI,EACnE,YAAY,YAAY,KACvB,+BAkCF,CAAA;AAED,uGAAuG;AACvG,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4GAiB3C,CAAA"}

package/dist/server/server/governance/internal/execution-store/record-blocked.d.ts

@@ -0,0 +1,13 @@
+import * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Consume one exact preparation and record that provider preflight denied dispatch. */
+export declare const makeGovernedActionExecutionRecordBlocked: Effect.Effect<{
+    recordBlocked: (input: {
+        readonly preparationToken: import("./tokens.js").GovernedActionPreparationToken;
+        readonly preflight: import("../../../../index.ts").BlockedPluginActionPreflightV1;
+        readonly observedAt: import("../../../../index.ts").UtcTimestamp;
+        readonly scope: import("../../../index.ts").PluginRuntimeScope;
+    }) => Effect.Effect<import("../../../../domain/governedAction/stateMachine.ts").GovernedActionState, GovernedActionExecutionStoreError>;
+}, never, Crypto.Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=record-blocked.d.ts.map

package/dist/server/server/governance/internal/execution-store/record-blocked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-blocked.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/record-blocked.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAUvC,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAyBtF,wFAAwF;AACxF,eAAO,MAAM,wCAAwC;;;;;;;yKAyGnD,CAAA"}

package/dist/server/server/governance/internal/execution-store/record-dispatch.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import { PluginActionDispatchResultV1 } from "../../../../domain/plugins/actions.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Append one provider dispatch result to its immutable inbox and fold it into the current head. */
+export declare const makeGovernedActionExecutionRecordDispatch: Effect.Effect<{
+    recordDispatch: (input: {
+        readonly permitToken: import("./tokens.ts").GovernedActionPermitToken;
+        readonly result: PluginActionDispatchResultV1;
+        readonly observedAt: import("../../../../index.ts").UtcTimestamp;
+    }) => Effect.Effect<import("../../../../index.ts").GovernedActionState, GovernedActionExecutionStoreError>;
+}, never, import("effect/Crypto").Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=record-dispatch.d.ts.map

package/dist/server/server/governance/internal/execution-store/record-dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-dispatch.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/record-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAA;AAEpF,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAMtF,oGAAoG;AACpG,eAAO,MAAM,yCAAyC;;;;;;0LAkBpD,CAAA"}

package/dist/server/server/governance/internal/execution-store/record-reconciliation.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import { PluginActionReconciliationResultV1 } from "../../../../domain/plugins/actions.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Append one provider reconciliation result and fold it into the governed lifecycle. */
+export declare const makeGovernedActionExecutionRecordReconciliation: Effect.Effect<{
+    recordReconciliation: (input: {
+        readonly recoveryToken: import("./tokens.ts").GovernedActionRecoveryToken;
+        readonly result: PluginActionReconciliationResultV1;
+        readonly observedAt: import("../../../../index.ts").UtcTimestamp;
+    }) => Effect.Effect<import("../../../../index.ts").GovernedActionState, GovernedActionExecutionStoreError>;
+}, never, import("effect/Crypto").Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=record-reconciliation.d.ts.map

package/dist/server/server/governance/internal/execution-store/record-reconciliation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-reconciliation.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/record-reconciliation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,kCAAkC,EAAE,MAAM,uCAAuC,CAAA;AAE1F,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAMtF,yFAAyF;AACzF,eAAO,MAAM,+CAA+C;;;;;;0LAkB1D,CAAA"}

package/dist/server/server/governance/internal/execution-store/record-recovery-unavailable.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Persist unavailable runtime-generation evidence without converting ambiguity into a terminal state. */
+export declare const makeGovernedActionExecutionRecordRecoveryUnavailable: Effect.Effect<{
+    recordRecoveryUnavailable: (input: {
+        readonly recoveryToken: import("./tokens.ts").GovernedActionRecoveryToken;
+        readonly observedAt: import("../../../../index.ts").UtcTimestamp;
+        readonly reason: "runtime-generation-unavailable";
+    }) => Effect.Effect<import("../../../../index.ts").GovernedActionState, GovernedActionExecutionStoreError>;
+}, never, import("effect/Crypto").Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=record-recovery-unavailable.d.ts.map

package/dist/server/server/governance/internal/execution-store/record-recovery-unavailable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-recovery-unavailable.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/record-recovery-unavailable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAOtF,0GAA0G;AAC1G,eAAO,MAAM,oDAAoD;;;;;;0LAwB/D,CAAA"}

package/dist/server/server/governance/internal/execution-store/record-unknown.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+import { GovernedActionUnknownOutcome } from "../../../../domain/governedAction/index.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Persist a locally synthesized unknown outcome at a trusted host receipt time. */
+export declare const makeGovernedActionExecutionRecordUnknown: Effect.Effect<{
+    recordUnknown: (input: {
+        readonly permitToken: import("./tokens.ts").GovernedActionPermitToken;
+        readonly outcome: GovernedActionUnknownOutcome;
+    }) => Effect.Effect<import("../../../../domain/governedAction/stateMachine.ts").GovernedActionState, GovernedActionExecutionStoreError>;
+}, never, import("effect/Crypto").Crypto | import("../../../persistence/Database.ts").Database | import("../../../persistence/repositories/quarantineRepository.ts").QuarantineRepository>;
+//# sourceMappingURL=record-unknown.d.ts.map

package/dist/server/server/governance/internal/execution-store/record-unknown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-unknown.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/record-unknown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,4BAA4B,EAAE,MAAM,4CAA4C,CAAA;AAEzF,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAMtF,oFAAoF;AACpF,eAAO,MAAM,wCAAwC;;;;;0LAoBnD,CAAA"}

package/dist/server/server/governance/internal/execution-store/recovery-candidates.d.ts

@@ -0,0 +1,12 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Read one stable, bounded startup batch without claiming or executing any action. */
+export declare const makeGovernedActionRecoveryCandidates: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<{
+    recoveryCandidates: Effect.Effect<readonly Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly actionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
+    }, "Type">[], GovernedActionExecutionStoreError, never>;
+}, never, Database>;
+//# sourceMappingURL=recovery-candidates.d.ts.map

package/dist/server/server/governance/internal/execution-store/recovery-candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery-candidates.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/recovery-candidates.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAE3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAetF,uFAAuF;AACvF,eAAO,MAAM,oCAAoC;;;;;mBAwB/C,CAAA"}

package/dist/server/server/governance/internal/execution-store/recovery-claim-expiry.d.ts

@@ -0,0 +1,9 @@
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import { Database } from "../../../persistence/Database.js";
+import { GovernedActionExecutionStoreError } from "../GovernedActionExecutionStore.js";
+/** Append shutdown expirations for every still-live recovery claim in one workspace. */
+export declare const makeGovernedActionRecoveryClaimExpiry: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<{
+    expire: (expiredAt: DateTime.Utc) => Effect.Effect<number, GovernedActionExecutionStoreError, never>;
+}, never, Database>;
+//# sourceMappingURL=recovery-claim-expiry.d.ts.map

package/dist/server/server/governance/internal/execution-store/recovery-claim-expiry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery-claim-expiry.d.ts","sourceRoot":"","sources":["../../../../../../src/server/governance/internal/execution-store/recovery-claim-expiry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAA;AAE3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAA;AAQtF,wFAAwF;AACxF,eAAO,MAAM,qCAAqC;;mBA0BhD,CAAA"}