@makaio/framework 1.0.0-dev-1788721567504 → 1.0.0-dev-1788832451167

package/dist/{execution-attempt-repository-CRdrgou3.d.mts → execution-attempt-repository-CgB7uiYD.d.mts}

@@ -1,6 +1,94 @@
-import { a as ProviderOperationClaim, i as ProcessBoundProvisionerLossProof, l as ProviderOperationOwnershipRecord, o as ProviderOperationClaimDecision, s as ProviderOperationMutationDecision } from "./provider-operation-DbdyFwNm.mjs";
-import { BoundedRecoveryEvidence, ExecutionAttemptOperationKind, ProviderAllocationRef, WorkerAllocationLifetime } from "@makaio/framework/contracts";
+import { a as ProviderOperationClaim, i as ProcessBoundProvisionerLossProof, l as ProviderOperationOwnershipRecord, o as ProviderOperationClaimDecision, s as ProviderOperationMutationDecision } from "./provider-operation-B2wQST6N.mjs";
+import { BoundedRecoveryEvidence, ExecutionAttemptInstruction, ExecutionAttemptOperationKind, ExecutionAttemptOperationReportRequest, ExecutionAttemptOperationReportResponse, ExecutionAttemptPreparationResult, ExecutionAttemptWorkspaceBinding, ProviderAllocationRef, WorkerAllocationLifetime } from "@makaio/framework/contracts";
 
+//#region subsystems/workflow-engine/src/execution-attempt-decisions.d.ts
+/** Facts read coherently by a realization before decoding runtime control state. */
+interface AttemptReachability {
+  /** Whether the requested attempt exists and belongs to the requested owner. */
+  readonly matchesExecution: boolean;
+  /** Whether the attempt has a terminal settlement. */
+  readonly settled: boolean;
+  /** Whether this is still the owner's active attempt. */
+  readonly active: boolean;
+  /** Whether an allocation exists and is not durably terminated. */
+  readonly allocated: boolean;
+}
+/** Refusals shared by registration, admission, and readiness, before control decoding. */
+type AttemptReachabilityDecision = Extract<RuntimeRegistrationDecision, {
+  readonly kind: 'not-found' | 'resolved' | 'fenced' | 'not-allocated';
+}>;
+/**
+ * Evaluate the common reachability precedence without reading or mutating storage.
+ * A null result only permits further evaluation; it never authorizes an unguarded write.
+ * @param facts - Coherent lifecycle, owner, and allocation facts supplied by the realization.
+ * @returns The first refusal, or null when runtime control may be decoded and evaluated.
+ */
+declare function evaluateAttemptReachability(facts: AttemptReachability): AttemptReachabilityDecision | null;
+/**
+ * Evaluate process-loss applicability after evidence parsing and claim authorization.
+ * Owner, lifetime, and incarnation refusals precede a recorded allocation.
+ * A null result permits only the realization's existing guarded settlement.
+ * @param attempt - Coherently read immutable provider binding and allocation facts.
+ * @param input - Owner identity and process-loss proof whose evidence the realization already parsed.
+ * @returns The first applicability refusal, or null to attempt the guarded write.
+ */
+declare function evaluateProvisionerIncarnationLoss(attempt: Pick<ExecutionAttemptRecord, 'executionId' | 'allocationLifetime' | 'provisionerIncarnationId' | 'allocationRef'>, input: Pick<RecordProvisionerIncarnationLostInput, 'executionId' | 'proof'>): Extract<ProvisionerIncarnationLossDecision, {
+  readonly kind: 'not-found' | 'not-process-bound' | 'incarnation-mismatch' | 'allocated';
+}> | null;
+/**
+ * Evaluate registration after reachability, preserving replay before busy refusal.
+ * An orphaned runtime probe may be reclaimed; a workload operation may not.
+ * @param control - Current decoded control state, not modified by this function.
+ * @param input - Runtime registration being considered.
+ * @returns A non-write decision, or null to attempt the realization's guarded registration.
+ */
+declare function evaluateRuntimeRegistration(control: AttemptControlState, input: RegisterRuntimeInput): Exclude<RuntimeRegistrationDecision, {
+  readonly kind: 'registered';
+}> | null;
+/**
+ * Evaluate admission after reachability: replay, busy, gate, readiness, generation, then Preparation.
+ * Probe operations are admitted before readiness because they establish that proof.
+ * @param control - Current decoded control state, not modified by this function.
+ * @param input - Operation admission being considered.
+ * @param fallbackAdmittedAt - Realization-supplied instant for a duplicate missing its stored instant.
+ * @param execution - Frozen assignment and Preparation receipts read with the control state.
+ * @returns A non-write decision, or null to attempt the realization's guarded admission.
+ */
+declare function evaluateOperationAdmission(control: AttemptControlState, input: AdmitOperationInput, fallbackAdmittedAt: string, execution: AttemptExecutionState): Exclude<OperationAdmissionDecision, {
+  readonly kind: 'admitted';
+}> | null;
+/**
+ * Evaluate successful Preparation, retaining historical replay before current-runtime fences.
+ * A null decision permits only a guarded write that saves the receipt and frees the slot together.
+ * @param reachability - Coherent owner, allocation and lifecycle facts.
+ * @param control - Current operation and runtime state.
+ * @param execution - Frozen instruction and retained Preparation history.
+ * @param input - Owner-scoped successful Preparation report.
+ * @returns A historical duplicate or refusal, or null to atomically accept the result.
+ */
+declare function evaluatePreparationReport(reachability: AttemptReachability, control: AttemptControlState, execution: AttemptExecutionState, input: ReportOperationInput): Exclude<OperationReportDecision, {
+  readonly kind: 'accepted';
+}> | null;
+/**
+ * Evaluate completion after presence and settlement checks, without owner or allocation fences.
+ * A replay is recognized even after its active slot has been cleared or reused.
+ * @param control - Current decoded control state, not modified by this function.
+ * @param input - Operation completion being considered.
+ * @returns A non-write decision, or null to attempt the realization's guarded completion.
+ */
+declare function evaluateOperationCompletion(control: AttemptControlState, input: CompleteOperationInput): Exclude<OperationCompletionDecision, {
+  readonly kind: 'completed';
+}> | null;
+/**
+ * Evaluate readiness after reachability: generation fence, replay, then busy refusal.
+ * @param control - Current decoded control state, not modified by this function.
+ * @param input - Runtime readiness report being considered.
+ * @returns A non-write decision, or null to attempt the realization's guarded readiness write.
+ */
+declare function evaluateRuntimeReadiness(control: AttemptControlState, input: MarkRuntimeReadyInput): Exclude<RuntimeReadinessDecision, {
+  readonly kind: 'ready';
+}> | null;
+//#endregion
 //#region subsystems/workflow-engine/src/execution-attempt-repository.d.ts
 /**
  * Ordered constant array of every execution attempt lifecycle status.
@@ -59,6 +147,28 @@ declare const ATTEMPT_OPERATION_START_GATES: readonly ["open", "closed"];
  *   begin — when a newer attempt supersedes it, and when it settles.
  */
 type AttemptOperationStartGate = (typeof ATTEMPT_OPERATION_START_GATES)[number];
+/** Coherent durable facts required before an attempt may enter runtime registration. */
+interface BootstrapStartState {
+  /** A terminal outcome or infrastructure settlement has been recorded. */
+  readonly settled: boolean;
+  /** The owner's active pointer still names this attempt, independently of settlement. */
+  readonly active: boolean;
+  /** An allocation reference is recorded, independently of its termination. */
+  readonly allocated: boolean;
+  /** Provider-operation state durably confirms allocation termination. */
+  readonly allocationTerminated: boolean;
+  /** One-way durable gate controlling whether new work may start. */
+  readonly operationStartGate: AttemptOperationStartGate;
+  /** Immutable ISO deadline, or null for legacy attempts that cannot newly bootstrap. */
+  readonly bootstrapDeadlineAt: string | null;
+}
+/** Trusted owner and attempt identity for the narrow bootstrap observation. */
+interface ReadBootstrapStartStateInput {
+  /** Authenticated durable owner of the attempt. */
+  readonly executionId: ExecutionOwnerId;
+  /** Attempt whose durable start facts are observed. */
+  readonly executionAttemptId: string;
+}
 /**
  * Compare two provider allocation references as values.
  *
@@ -407,7 +517,7 @@ interface AttemptControlState {
  * is what makes that omission a type error at the place the record is built,
  * rather than a default silently resolved at each place it is read.
  */
-interface ExecutionAttemptRecord extends AttemptControlState {
+interface ExecutionAttemptRecord extends AttemptControlState, AttemptExecutionState {
   /** Authority-created attempt identifier. */
   readonly executionAttemptId: string;
   /** Owner identifier of the aggregate this attempt belongs to. */
@@ -418,6 +528,8 @@ interface ExecutionAttemptRecord extends AttemptControlState {
   readonly allocationRef: ProviderAllocationRef | null;
   /** ISO-8601 timestamp when the attempt was created. */
   readonly createdAt: string;
+  /** Immutable creation-time bootstrap deadline; null only for legacy records. */
+  readonly bootstrapDeadlineAt: string | null;
   /**
    * Provider bound to this attempt, or `null` before provisioning began.
    *
@@ -514,7 +626,50 @@ interface ExecutionAttemptCreate {
   readonly executionAttemptId: string;
   /** Owner identifier the attempt belongs to. */
   readonly executionId: ExecutionOwnerId;
+  /** Portable assignment snapshotted before this attempt becomes dispatchable. */
+  readonly instruction: ExecutionAttemptInstruction;
+  /** Explicit positive safe-integer bootstrap budget in milliseconds, frozen at creation. */
+  readonly bootstrapTimeoutMs: number;
+}
+/** Durable acceptance of one successful Preparation operation. */
+interface PreparationReceipt {
+  /** Identity of the completed Preparation operation. */
+  readonly operationId: string;
+  /** Runtime realization to which the binding belongs. */
+  readonly runtimeGeneration: number;
+  /** Original semantic result, retained for replay comparison and diagnostics. */
+  readonly result: ExecutionAttemptPreparationResult;
+}
+/** Immutable assignment and accepted Preparation facts read with control state. */
+interface AttemptExecutionState {
+  /** The attempt's original assignment, never the owner's latest configuration. */
+  readonly instruction: ExecutionAttemptInstruction;
+  /** Accepted historical results; only the current generation permits Invocation. */
+  readonly preparationReceipts: readonly PreparationReceipt[];
+}
+/** Owner-scoped query for the immutable assignment of one attempt. */
+interface GetInstructionInput {
+  /** Owning aggregate, supplied by the authenticated host boundary. */
+  readonly executionId: ExecutionOwnerId;
+  /** Attempt whose stored assignment is requested. */
+  readonly executionAttemptId: string;
 }
+/** Successful Preparation report plus its trusted owner identity. */
+type ReportOperationInput = ExecutionAttemptOperationReportRequest & {
+  /** Owning aggregate, supplied by the authenticated host boundary. */readonly executionId: ExecutionOwnerId;
+};
+/** Semantic acceptance or refusal of a Preparation result. */
+type OperationReportDecision = {
+  readonly kind: 'accepted';
+  readonly binding: ExecutionAttemptWorkspaceBinding;
+} | {
+  readonly kind: 'duplicate';
+  readonly binding: ExecutionAttemptWorkspaceBinding;
+} | {
+  readonly kind: Extract<ExecutionAttemptOperationReportResponse, {
+    decision: 'refused';
+  }>['refusalReason'];
+};
 /**
  * Input for claiming the provisioning phase of an attempt.
  *
@@ -562,7 +717,29 @@ interface ExecutionAttemptOutcomeCommit<TOutcome> {
    * submission once and never reads its own object again.
    */
   readonly result: DurableOutcome<TOutcome>;
+  /** Runtime correlation checked atomically for a fresh commit; owner-only paths may omit it. */
+  readonly runtimeFence?: RuntimeOutcomeFence;
+}
+/** Runtime and operation expected to remain current when an outcome becomes durable. */
+interface RuntimeOutcomeFence {
+  /** Registered runtime generation that produced the result. */
+  readonly runtimeGeneration: number;
+  /** Admitted operation, or null for a startup failure before any operation. */
+  readonly operationId: string | null;
 }
+/** A runtime result lost its execution slot before commit; the attempt remains available to its current runtime. */
+declare class RuntimeOutcomeFenceMismatchError extends Error {
+  constructor();
+}
+/**
+ * Require a fresh runtime outcome to belong to the coherently read execution slot.
+ * Repositories call this after canonical replay/settlement decisions and repeat its
+ * predicates in the committing write. A mismatch must not settle the attempt's waiter.
+ * @param control - Current runtime and operation facts.
+ * @param fence - Expected runtime slot, absent for owner-only outcome submission.
+ * @throws RuntimeOutcomeFenceMismatchError when the originating runtime slot changed.
+ */
+declare function assertRuntimeOutcomeFence(control: AttemptControlState, fence: RuntimeOutcomeFence | undefined): void;
 /** Input for extending the lease of a currently held provider operation. */
 interface RenewProviderOperationClaimInput {
   /** Claim the caller currently believes it holds. */
@@ -1122,6 +1299,11 @@ type RuntimeRegistrationDecision = {
  * - `stale-generation`: the caller fenced against a generation the attempt has
  *   moved past. The current generation is reported so the caller can re-fence
  *   rather than re-read.
+ * - `preparation-required`: Invocation requires a Workspace but no Preparation
+ *   receipt belongs to the current runtime generation.
+ * - `preparation-not-required`: the assignment does not request a Workspace.
+ * - `preparation-already-completed`: Preparation succeeded for this generation;
+ *   a fresh admission key must not run setup again.
  */
 type OperationAdmissionDecision = {
   readonly kind: 'admitted';
@@ -1148,6 +1330,12 @@ type OperationAdmissionDecision = {
   readonly kind: 'gate-closed';
 } | {
   readonly kind: 'not-ready';
+} | {
+  readonly kind: 'preparation-required';
+} | {
+  readonly kind: 'preparation-not-required';
+} | {
+  readonly kind: 'preparation-already-completed';
 } | {
   readonly kind: 'stale-generation';
   readonly runtimeGeneration: number;
@@ -1160,6 +1348,8 @@ type OperationAdmissionDecision = {
  * - `duplicate`: this operation was already completed. A replay, answered from
  *   {@link AttemptControlState.lastCompletedOperationId} rather than from an
  *   active operation that is by then gone.
+ * - `result-required`: Preparation must submit its semantic report, and generic
+ *   Invocation must submit its terminal outcome, instead of merely freeing the slot.
  * - `mismatch`: a different operation occupies the attempt. The active one is
  *   reported, because the caller's next move depends on which it is.
  * - `not-active`: no operation occupies the attempt and this one is not the
@@ -1175,6 +1365,8 @@ type OperationCompletionDecision = {
   readonly kind: 'completed';
 } | {
   readonly kind: 'duplicate';
+} | {
+  readonly kind: 'result-required';
 } | {
   readonly kind: 'mismatch';
   readonly activeOperationId: string;
@@ -1235,9 +1427,12 @@ type RuntimeReadinessDecision = {
 /**
  * Passive injected port for durable execution attempt persistence.
  *
- * The consuming host application owns the concrete implementation and all
- * durable decisions. The Authority service calls through this port but never
- * owns the underlying tables or storage.
+ * The port owns decision semantics, including refusal and replay precedence;
+ * the consuming host owns their atomic realization. The shared pure runtime
+ * evaluators report non-write decisions or null to attempt a guarded write.
+ * They never replace transactional reads, conditional writes, affected-row
+ * checks, or re-evaluation after contention. The Authority service calls
+ * through this port but never owns the underlying tables or storage.
  *
  * The port owns two related records per attempt: canonical attempt state, and
  * the fenced provider operation that tracks who may act on the attempt's
@@ -1390,6 +1585,12 @@ interface ExecutionAttemptRepository<TOutcome> {
    * Called by the Authority before dispatch. The Authority owns
    * `executionAttemptId` generation; the repository only persists. The new
    * attempt atomically becomes the active attempt for its execution.
+   * The instruction is validated and snapshotted before any write. It remains
+   * immutable for the attempt's lifetime; no owner-context lookup may replace it.
+   * The explicit bootstrap budget must be a positive safe integer whose sum with
+   * the single creation instant is a representable Date. Validate it before any
+   * mutation, and persist createdAt and bootstrapDeadlineAt from that same instant.
+   * Later host policy changes never extend an existing attempt's deadline.
    *
    * The new attempt starts with its {@link AttemptControlState} at rest:
    * generation `0`, no incarnation, no readiness, no active operation, and
@@ -1417,11 +1618,38 @@ interface ExecutionAttemptRepository<TOutcome> {
    * writers — but a realization that lets the driver's own error escape would
    * make the same caller bug indistinguishable from a storage fault, and
    * distinguishable only by message text between one realization and another.
-   * @param input - Attempt identity to persist.
+   * @param input - Attempt identity and immutable assignment to persist.
    * @returns The created attempt record.
    * @throws A {@link DuplicateExecutionAttemptError} when an attempt with the same `executionAttemptId` already exists.
    */
   createAttempt(input: ExecutionAttemptCreate): Promise<ExecutionAttemptRecord>;
+  /**
+   * Read owner matching, settlement, active pointer, allocation, terminal provider
+   * state, start gate and immutable deadline in one coherent observation. This is
+   * a required bootstrap port, not a recovery capability. It must not decode the
+   * instruction, Preparation receipts or outcome to answer the narrow lookup.
+   * Legacy records without a deadline remain readable with a null deadline; only
+   * fresh bootstrap is refused, never unrelated reads or already-running work.
+   * @param input - Trusted owner and attempt identity.
+   * @returns The coherent state, or null for a missing attempt or mismatched owner.
+   */
+  readBootstrapStartState(input: ReadBootstrapStartStateInput): Promise<BootstrapStartState | null>;
+  /**
+   * Read the frozen instruction of an owner-matching attempt, including historical attempts.
+   * The returned snapshot must not allow mutation of the persisted assignment.
+   * @param input - Attempt and owner identity.
+   * @returns The original assignment, or null when the attempt does not belong to the owner.
+   */
+  getInstruction(input: GetInstructionInput): Promise<ExecutionAttemptInstruction | null>;
+  /**
+   * Accept Preparation and release its active slot in one durable transition.
+   * Historical identical reports return their original binding without restoring readiness.
+   * Conflicting reports preserve the first accepted result. Neither success nor replay
+   * settles the attempt; terminal failures use the canonical outcome boundary.
+   * @param input - Successful Preparation report and trusted owner identity.
+   * @returns Durable acceptance, historical duplicate, or refusal.
+   */
+  reportOperation(input: ReportOperationInput): Promise<OperationReportDecision>;
   /**
    * Claim the durable provisioning phase immediately before a provider call.
    *
@@ -1738,7 +1966,12 @@ interface ExecutionAttemptRepository<TOutcome> {
    *    {@link recordProvisionerIncarnationLost}. That transition won the
    *    terminal CAS, so a late outcome may neither overwrite its
    *    `settlementKind` nor reopen the attempt.
-   * 4. `accepted` — the outcome becomes canonical, the attempt settles as
+   * 4. When supplied, `runtimeFence` must still match the current runtime
+   *    generation and operation (including its generation). A mismatch throws
+   *    {@link RuntimeOutcomeFenceMismatchError} without changing the attempt.
+   *    Checking this in the same write prevents owner decoding/validation awaits
+   *    from committing a startup failure against a replacement runtime.
+   * 5. `accepted` — the outcome becomes canonical, the attempt settles as
    *    `outcome`, and its operation closes.
    *
    * The submission arrives already rendered, as the {@link DurableOutcome} the
@@ -1864,4 +2097,4 @@ interface ExecutionAttemptRecoveryOperations {
   getRecoverableAttempts(executionId: ExecutionOwnerId): Promise<readonly RecoverableAttemptRecord[]>;
 }
 //#endregion
-export { OutcomeCodec as A, RecordProvisioningAbsentInput as B, ExecutionAttemptStatus as C, MarkRuntimeReadyInput as D, InfrastructureFailureDecision as E, RecordAllocationInput as F, RuntimeRegistrationDecision as G, RegisterRuntimeInput as H, RecordAllocationTerminatedInput as I, durableOutcome as J, TakeOverProviderOperationInput as K, RecordInfrastructureFailureInput as L, ProvisionerIncarnationLossDecision as M, ProvisioningAbsenceDecision as N, OperationAdmissionDecision as O, ProvisioningClaimDecision as P, RecordProviderOperationUncertaintyInput as R, ExecutionAttemptSettlementKind as S, HandoffProviderOperationInput as T, RenewProviderOperationClaimInput as U, RecoverableAttemptRecord as V, RuntimeReadinessDecision as W, sameDurableOutcome as X, sameAllocationRef as Y, ExecutionAttemptOutcomeCommit as _, AllocationRefEvolutionDecision as a, ExecutionAttemptRecoveryOperations as b, AttemptOperationStartGate as c, DiscoveredAllocationDecision as d, DuplicateExecutionAttemptError as f, ExecutionAttemptCreate as g, EXECUTION_ATTEMPT_STATUSES as h, AllocationRefEvolution as i, PendingAttemptAbandonmentDecision as j, OperationCompletionDecision as k, BeginProvisioningInput as l, EXECUTION_ATTEMPT_SETTLEMENT_KINDS as m, AdmitOperationInput as n, AllocationTerminationDecision as o, DurableOutcome as p, decodeDurableOutcome as q, AllocationRecordingDecision as r, AttemptControlState as s, ATTEMPT_OPERATION_START_GATES as t, CompleteOperationInput as u, ExecutionAttemptOutcomeDecision as v, ExecutionOwnerId as w, ExecutionAttemptRepository as x, ExecutionAttemptRecord as y, RecordProvisionerIncarnationLostInput as z };
+export { RuntimeReadinessDecision as $, MarkRuntimeReadyInput as A, ReadBootstrapStartStateInput as B, ExecutionAttemptRepository as C, GetInstructionInput as D, ExecutionOwnerId as E, PendingAttemptAbandonmentDecision as F, RecordProvisionerIncarnationLostInput as G, RecordAllocationTerminatedInput as H, PreparationReceipt as I, RegisterRuntimeInput as J, RecordProvisioningAbsentInput as K, ProvisionerIncarnationLossDecision as L, OperationCompletionDecision as M, OperationReportDecision as N, HandoffProviderOperationInput as O, OutcomeCodec as P, RuntimeOutcomeFenceMismatchError as Q, ProvisioningAbsenceDecision as R, ExecutionAttemptRecoveryOperations as S, ExecutionAttemptStatus as T, RecordInfrastructureFailureInput as U, RecordAllocationInput as V, RecordProviderOperationUncertaintyInput as W, ReportOperationInput as X, RenewProviderOperationClaimInput as Y, RuntimeOutcomeFence as Z, EXECUTION_ATTEMPT_STATUSES as _, AllocationRefEvolutionDecision as a, sameAllocationRef as at, ExecutionAttemptOutcomeDecision as b, AttemptExecutionState as c, AttemptReachabilityDecision as ct, BootstrapStartState as d, evaluateOperationCompletion as dt, RuntimeRegistrationDecision as et, CompleteOperationInput as f, evaluatePreparationReport as ft, EXECUTION_ATTEMPT_SETTLEMENT_KINDS as g, DurableOutcome as h, evaluateRuntimeRegistration as ht, AllocationRefEvolution as i, durableOutcome as it, OperationAdmissionDecision as j, InfrastructureFailureDecision as k, AttemptOperationStartGate as l, evaluateAttemptReachability as lt, DuplicateExecutionAttemptError as m, evaluateRuntimeReadiness as mt, AdmitOperationInput as n, assertRuntimeOutcomeFence as nt, AllocationTerminationDecision as o, sameDurableOutcome as ot, DiscoveredAllocationDecision as p, evaluateProvisionerIncarnationLoss as pt, RecoverableAttemptRecord as q, AllocationRecordingDecision as r, decodeDurableOutcome as rt, AttemptControlState as s, AttemptReachability as st, ATTEMPT_OPERATION_START_GATES as t, TakeOverProviderOperationInput as tt, BeginProvisioningInput as u, evaluateOperationAdmission as ut, ExecutionAttemptCreate as v, ExecutionAttemptSettlementKind as w, ExecutionAttemptRecord as x, ExecutionAttemptOutcomeCommit as y, ProvisioningClaimDecision as z };

package/dist/execution-attempt-repository-D0cCU7dI.mjs

@@ -0,0 +1 @@
+import{canonicalStringify as e}from"@makaio/framework/utils";function t(e){return e.matchesExecution?e.settled?{kind:`resolved`}:e.active?e.allocated?null:{kind:`not-allocated`}:{kind:`fenced`}:{kind:`not-found`}}function n(e,t){return e.executionId===t.executionId?e.allocationLifetime===`provisioner-process-bound`?e.provisionerIncarnationId===null||e.provisionerIncarnationId!==t.proof.provisionerIncarnationId?{kind:`incarnation-mismatch`,provisionerIncarnationId:e.provisionerIncarnationId}:e.allocationRef===null?null:{kind:`allocated`,allocationRef:e.allocationRef}:{kind:`not-process-bound`,allocationLifetime:e.allocationLifetime}:{kind:`not-found`}}function r(e,t){return e.runtimeIncarnationId===t.runtimeIncarnationId?{kind:`duplicate`,runtimeGeneration:e.runtimeGeneration,runtimeReadyAt:e.runtimeReadyAt}:e.activeOperationId!==null&&e.activeOperationKind!==`runtime-probe`?{kind:`operation-active`,operationId:e.activeOperationId}:null}function i(e,t,n,r){if(e.activeOperationId!==null)return e.activeOperationKey===t.admissionKey?{kind:`duplicate`,operationId:e.activeOperationId,runtimeGeneration:e.activeOperationGeneration??e.runtimeGeneration,admittedAt:e.activeOperationAdmittedAt??n}:{kind:`operation-active`,operationId:e.activeOperationId};if(e.operationStartGate===`closed`)return{kind:`gate-closed`};if(t.operationKind!==`runtime-probe`&&e.runtimeReadyAt===null)return{kind:`not-ready`};if(e.runtimeGeneration!==t.runtimeGeneration)return{kind:`stale-generation`,runtimeGeneration:e.runtimeGeneration};let i=r.instruction.workspace!==void 0,a=r.preparationReceipts.some(t=>t.runtimeGeneration===e.runtimeGeneration);if(t.operationKind===`workspace-preparation`){if(!i)return{kind:`preparation-not-required`};if(a)return{kind:`preparation-already-completed`}}return(t.operationKind===`workload-invocation`||t.operationKind===`workflow-run`)&&i&&!a?{kind:`preparation-required`}:null}function a(n,r,i,a){if(!n.matchesExecution)return{kind:`not-found`};let o=i.preparationReceipts.find(e=>e.operationId===a.operationId);if(o!==void 0)return o.runtimeGeneration===a.runtimeGeneration&&e(o.result)===e(a.result)?{kind:`duplicate`,binding:o.result.binding}:{kind:`conflict`};let s=t(n);if(s!==null)return s;if(r.runtimeGeneration!==a.runtimeGeneration)return{kind:`stale-generation`};if(r.activeOperationId===null)return{kind:`no-active-operation`};if(r.activeOperationId!==a.operationId||r.activeOperationKind!==`workspace-preparation`)return{kind:`operation-mismatch`};if(r.activeOperationGeneration!==a.runtimeGeneration)return{kind:`stale-generation`};let c=i.instruction.workspace;if(c===void 0)return{kind:`preparation-not-required`};let l=c.sourceRoots.map(e=>e.id).sort(),u=a.result.binding.sourceRoots.map(e=>e.id).sort();return e(l)===e(u)?null:{kind:`binding-mismatch`}}function o(e,t){return e.lastCompletedOperationId===t.operationId?{kind:`duplicate`}:e.activeOperationId===null?{kind:`not-active`}:e.activeOperationId===t.operationId?e.activeOperationGeneration===t.runtimeGeneration?e.activeOperationKind===`workspace-preparation`||e.activeOperationKind===`workload-invocation`?{kind:`result-required`}:null:{kind:`stale-generation`}:{kind:`mismatch`,activeOperationId:e.activeOperationId}}function s(e,t){return e.runtimeGeneration===t.runtimeGeneration?e.runtimeReadyAt===null?e.activeOperationId===null?null:{kind:`operation-active`,operationId:e.activeOperationId}:{kind:`duplicate`,acceptedAt:e.runtimeReadyAt}:{kind:`stale-generation`}}const c=[`pending`,`provisioning`,`allocated`,`settled`],l=[`outcome`,`abandoned`,`infrastructure-failure`],u=[`open`,`closed`];function d(t,n){return e(t)===e(n)}function f(t,n){return e(JSON.parse(t))===e(JSON.parse(n))}function p(e,t){let n=e.serialize(e.parse(t));return{text:n,outcome:m(e,n)}}function m(e,t){return e.parse(JSON.parse(t))}var h=class extends Error{executionAttemptId;constructor(e,t){super(`Execution attempt '${e}' already exists`,t),this.name=`DuplicateExecutionAttemptError`,this.executionAttemptId=e}},g=class extends Error{constructor(){super(`Runtime outcome no longer matches the current generation and operation`),this.name=`RuntimeOutcomeFenceMismatchError`}};function _(e,t){if(t!==void 0&&(e.runtimeGeneration!==t.runtimeGeneration||e.activeOperationId!==t.operationId||t.operationId!==null&&e.activeOperationGeneration!==t.runtimeGeneration))throw new g}export{r as _,g as a,p as c,t as d,i as f,s as g,n as h,c as i,d as l,a as m,h as n,_ as o,o as p,l as r,m as s,u as t,f as u};

package/dist/{execution-target-H0RWV7Py.mjs → execution-target-BcoF_oDB.mjs}

@@ -1 +1 @@
-import{A as e,E as t,M as n,N as r,O as i,_ as a,j as o,k as s,m as c,v as l,w as u}from"./schemas-TK29KWx-.mjs";import"./services/execution-target/namespace.mjs";import{z as d}from"zod";import{channelSubject as f,createBusNamespace as p,localSubject as m}from"@makaio/framework/core";const h=`docker-bootstrap`,g=p(`docker`,{"container.spawn":{request:i,response:s},"bootstrap.spawn":f({request:c,response:s}),"bootstrap.getChannelToken":m({request:d.object({}),response:d.object({token:d.string().min(1)})}),"container.stop":{request:n,response:r},"container.status":{request:e,response:o},"container.created":a,"container.started":u,"container.stopped":t,"container.destroyed":l}),_=g.subjects,v=g,y=_;export{_ as a,g as i,y as n,h as r,v as t};
+import{A as e,E as t,M as n,N as r,O as i,_ as a,j as o,k as s,m as c,v as l,w as u}from"./schemas-CeHU889f.mjs";import"./services/execution-target/namespace.mjs";import{z as d}from"zod";import{channelSubject as f,createBusNamespace as p,localSubject as m}from"@makaio/framework/core";const h=`docker-bootstrap`,g=p(`docker`,{"container.spawn":{request:i,response:s},"bootstrap.spawn":f({request:c,response:s}),"bootstrap.getChannelToken":m({request:d.object({}),response:d.object({token:d.string().min(1)})}),"container.stop":{request:n,response:r},"container.status":{request:e,response:o},"container.created":a,"container.started":u,"container.stopped":t,"container.destroyed":l}),_=g.subjects,v=g,y=_;export{_ as a,g as i,y as n,h as r,v as t};

package/dist/{hook-responses-9Ywsqzzq.d.mts → hook-responses-DcapjzLb.d.mts}

@@ -1,4 +1,4 @@
-import { t as ExtensionContext } from "./extension-context-QmFuHdq5.mjs";
+import { t as ExtensionContext } from "./extension-context-BmU5XKjI.mjs";
 import { z } from "zod";
 
 //#region core/contracts/src/version/primitives.d.ts