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

package/dist/{index-BJdkVFX9.d.mts → index-BxOFB25y.d.mts}

@@ -1,8 +1,8 @@
-import { r as ExtensionDiscovery } from "./extension-discovery-Dhu3WplO.mjs";
+import { r as ExtensionDiscovery } from "./extension-discovery-DnO7bINK.mjs";
 import { RegistrableBusNamespaceDefinition } from "@makaio/framework/core";
 import { BusTransport, IMakaioBus, SubjectTelemetryProjectorRegistry } from "@makaio/framework/bus";
-import { ExecutionAttemptOperationAdmitRefusalReason, ExecutionAttemptOperationDelivery, ExecutionAttemptOperationKind, ExecutionAttemptOperationReceipt, ExecutionAttemptRuntimeRegisterRefusalReason, ExtensionConfigProvider, IWorkerProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, LoopGateHandler, MakaioNodeExtension, NormalizedWorkerCapabilities, OutcomeAckDecision, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerAllocatedOutcome, WorkerBootstrapClaimResponse, WorkerCapabilities, WorkerContributionManifest, WorkerContributionRef, WorkerDispatch, WorkerMaterializationSpec, WorkerProvisionRequest, WorkerRequirements, WorkerRuntimeContext, WorkflowDefinition, WorkflowRunContext, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerCompletion, WorkflowRunnerCompletion as WorkflowRunnerCompletion$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas } from "@makaio/framework/contracts";
-import { DispatchingAuth, TransportAuth } from "@makaio/framework/node/transports";
+import { ExecutionAttemptBootstrapStartRefusalReason, ExecutionAttemptInstruction, ExecutionAttemptOperationAdmitRefusalReason, ExecutionAttemptOperationDelivery, ExecutionAttemptOperationKind, ExecutionAttemptOperationReceipt, ExecutionAttemptOutcome, ExecutionAttemptRuntimeRegisterRefusalReason, ExecutionAttemptWorkspaceBinding, ExtensionConfigProvider, IWorkerProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, JsonValue, LoopGateHandler, MakaioNodeExtension, NormalizedWorkerCapabilities, OutcomeAckDecision, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerAllocatedOutcome, WorkerBootstrapCredentials, WorkerCapabilities, WorkerContributionManifest, WorkerContributionRef, WorkerDispatch, WorkerMaterializationSpec, WorkerProvisionRequest, WorkerRequirements, WorkerRuntimeContext, WorkflowDefinition, WorkflowRunContext, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerCompletion, WorkflowRunnerCompletion as WorkflowRunnerCompletion$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas, WorkspaceRequirement } from "@makaio/framework/contracts";
+import { DispatchingAuth, HmacAuth, TransportAuth } from "@makaio/framework/node/transports";
 import { ContributionProcessor, ExtensionCoordinator, ExtensionRuntimeSurface, KernelExtensionContext, KernelMakaioExtension, RuntimeCapability, TransportProvider, WindowRegistry } from "@makaio/framework/kernel";
 import { StorageEngine } from "@makaio/framework/storage/drizzle";
 import { Toolset } from "@makaio/framework/tools";
@@ -13,7 +13,7 @@ import { IAdapterConfigRepository as IAdapterConfigRepository$1, PlatformDefault
 import { PersistedMachineIdentity } from "@makaio/framework/node/machine-identity";
 import { Hono } from "hono";
 import { ConfigProvider } from "@makaio/framework/providers";
-import { ExecutionAttemptAuthority, ExecutionAttemptRepository, WorkflowMaterializationSpecResolver } from "@makaio/framework/workflow-engine";
+import { ExecutionAttemptAuthority, ExecutionAttemptRepository, WorkflowAttemptOutcome, WorkflowMaterializationSpecResolver } from "@makaio/framework/workflow-engine";
 import { Server } from "node:http";
 
 //#region runtimes/node/src/compose-adapter-runtime.d.ts
@@ -1065,7 +1065,9 @@ interface CoreBootOptions {
    * without attempt tracking. Worker mode fails fast at boot when this
    * is not provided.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowAttemptOutcome>;
+  /** Required when constructing an attempt Authority: creation-time bootstrap budget in milliseconds. */
+  readonly executionAttemptBootstrapTimeoutMs?: number;
   /**
    * Runtime data home for config, database, machine identity, and installed
    * extensions. Defaults to the `MAKAIO_HOME` environment override when set,
@@ -1325,12 +1327,14 @@ interface WorkflowWorkerReadyMessage {
 interface ThinWorkflowPiscinaAttemptBinding {
   /** Authority-created attempt the dispatched thread registers against. */
   readonly executionAttemptId: string;
+  /** Persisted absolute deadline of this Attempt. */
+  readonly bootstrapDeadlineAt: string;
 }
 /** Result and readiness promises for one workflow worker dispatch. */
 interface ThinWorkflowPiscinaRunWithReadiness {
   /** Terminal workflow result returned by the worker. */
   readonly result: Promise<WorkflowRunResult$1>;
-  /** Resolves when the worker bus is connected and cancellation routing is subscribed. */
+  /** Resolves after the Authority accepts this Runtime and admits its workflow run. */
   readonly ready: Promise<WorkflowWorkerReadyMessage>;
 }
 /**
@@ -1403,6 +1407,66 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
   private materializeTask;
 }
 //#endregion
+//#region runtimes/node/src/workflow-worker/worker-bus-auth.d.ts
+/**
+ * Build transport authentication without interpreting credentials as grants.
+ * @param secret - HMAC secret; undefined means no HMAC authentication.
+ * @param identityId - Optional identity for the server's trusted-peer resolver.
+ * @returns HMAC authenticator when a secret is supplied.
+ */
+declare function createWorkerBusAuth(secret: string | undefined, identityId?: string): HmacAuth | undefined;
+//#endregion
+//#region runtimes/node/src/workflow-worker/worker-bootstrap-budget.d.ts
+/** The immutable Attempt bootstrap budget has elapsed. */
+declare class BootstrapDeadlineExceededError extends Error {
+  readonly code = "WORKER_BOOTSTRAP_DEADLINE_EXCEEDED";
+  constructor();
+}
+/**
+ * Bound a bootstrap callback without adding reconnect or retry semantics.
+ * @param bootstrapDeadlineAt - The Attempt's immutable absolute ISO deadline.
+ * @param signal - Caller cancellation.
+ * @param operation - Callback receiving cancellation bounded by that deadline.
+ * @returns The timely callback result.
+ */
+declare function withWorkerBootstrapDeadline<T>(bootstrapDeadlineAt: string, signal: AbortSignal, operation: (signal: AbortSignal) => Promise<T>): Promise<T>;
+//#endregion
+//#region runtimes/node/src/workflow-worker/worker-bootstrap-exchange.d.ts
+/** Valid, schema-parsed protocol response; refusal is a nonretryable adapter error. */
+type BootstrapExchangeResult<TValue> = {
+  readonly status: 'pending';
+} | {
+  readonly status: 'complete';
+  readonly value: TValue;
+};
+/** Adapters keep credential and start-authorization protocols outside the session loop. */
+interface WorkerBootstrapExchangeOptions<TSession, TValue> {
+  readonly bootstrapDeadlineAt: string;
+  readonly signal: AbortSignal;
+  /** Acquire a handle synchronously, before any asynchronous connection work. */
+  readonly createSession: () => TSession;
+  /** Include authentication and subscription readiness; disable transport auto-reconnect. */
+  readonly connect: (session: TSession, signal: AbortSignal) => Promise<void>;
+  /** Parse protocol responses before returning; throw typed refusal errors. */
+  readonly exchange: (session: TSession, options: {
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+  }) => Promise<BootstrapExchangeResult<TValue>>;
+  /** Revoke the handle, including pending connect, so late completion cannot revive it. */
+  readonly dispose: (session: TSession) => void | Promise<void>;
+}
+/**
+ * Connect and repeat a pre-registration exchange within one durable bootstrap budget.
+ * Failed sessions are disposed before reconnecting. A successful session transfers
+ * to the caller; no timer survives to affect registration or workload execution.
+ * @param options - Protocol adapters and the Attempt's immutable deadline.
+ * @returns Surviving session and the timely, parsed completion value.
+ */
+declare function runWorkerBootstrapExchange<TSession, TValue>(options: WorkerBootstrapExchangeOptions<TSession, TValue>): Promise<{
+  readonly session: TSession;
+  readonly value: TValue;
+}>;
+//#endregion
 //#region runtimes/node/src/workflow-worker/node-workflow-runner-factory.d.ts
 /** Parameters for composing workflow engine runner package options. */
 interface CreateNodeWorkflowRunnerPackageOptionsParams {
@@ -1421,7 +1485,8 @@ interface CreateNodeWorkflowRunnerPackageOptionsParams {
    *
    * Required when `workflowRunner.mode` is `'in-process'` or omitted on an
    * explicit runner object. Also used by Worker mode when no explicit
-   * dispatch function is supplied. Ignored for Piscina mode.
+   * dispatch function is supplied, and reads portable owner context for
+   * path-backed Worker executions. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
   /**
@@ -1431,7 +1496,9 @@ interface CreateNodeWorkflowRunnerPackageOptionsParams {
    * through to the workflow engine service options so the Authority
    * service can delegate durable decisions.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowAttemptOutcome>;
+  /** Explicit creation-time bootstrap budget, required whenever a repository is injected. */
+  readonly executionAttemptBootstrapTimeoutMs?: number;
   /** Host-owned resolvers for portable path-backed workflow starts. */
   readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
@@ -1453,18 +1520,17 @@ interface NodeWorkflowRunnerPackageOptions {
   /**
    * Injected execution attempt persistence port.
    *
-   * Present only when the workflow runner uses Worker dispatch mode.
-   * Forwarded to the workflow engine service for Authority construction.
+   * Forwarded whenever the host supplies it, independently of runner mode.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowAttemptOutcome>;
   /**
    * Execution attempt Authority constructed from the injected repository.
    *
-   * Present only when the workflow runner uses Worker dispatch mode.
-   * Shared between the runner (for attempt creation before dispatch) and
+   * Present whenever the host supplies a repository and bootstrap budget.
+   * Shared between an Authority-backed runner (for attempt creation before dispatch) and
    * the workflow engine service (for outcome commitment).
    */
-  readonly executionAttemptAuthority?: ExecutionAttemptAuthority<WorkflowRunResult>;
+  readonly executionAttemptAuthority?: ExecutionAttemptAuthority<WorkflowAttemptOutcome>;
   /** Host-owned resolvers forwarded to the workflow engine service. */
   readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
@@ -1490,7 +1556,8 @@ interface CreateNodeWorkflowRunnerParams {
    *
    * Required when `runner` is present and its `mode` is `'in-process'` or
    * omitted. Also required for `'worker'` mode when no explicit dispatch
-   * function is supplied. Ignored for Piscina mode.
+   * function is supplied, and for reading portable owner context before
+   * path-backed Worker dispatch. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
   /**
@@ -1499,7 +1566,7 @@ interface CreateNodeWorkflowRunnerParams {
    * Required when `runner.mode` is `'worker'`. The runner uses this
    * to create attempts before dispatch and wait for committed outcomes.
    */
-  readonly authority?: ExecutionAttemptAuthority<WorkflowRunResult>;
+  readonly authority?: ExecutionAttemptAuthority<WorkflowAttemptOutcome>;
 }
 /**
  * Create a workflow-level runner based on the Node runtime configuration.
@@ -1531,7 +1598,15 @@ interface WorkerRunnerOptions {
    * Required for authority-committed completions. When absent, the runner
    * cannot create attempts or wait for durable outcomes.
    */
-  readonly authority: ExecutionAttemptAuthority<WorkflowRunResult>;
+  readonly authority: ExecutionAttemptAuthority<WorkflowAttemptOutcome>;
+  /**
+   * Read portable owner input before creating a path-backed Attempt.
+   * Self-contained source and definition configs need no storage lookup.
+   * @param executionId - Workflow execution whose executable source is being frozen.
+   * @param signal - Cancellation signal for the owner-context read.
+   * @returns The portable owner context, or null when none was persisted.
+   */
+  readonly readRunContext?: (executionId: string, signal: AbortSignal) => Promise<WorkflowRunContext | null>;
   /**
    * Extension contribution manifest forwarded to dispatched workers.
    *
@@ -1561,6 +1636,8 @@ interface WorkerRunnerOptions {
  */
 declare class WorkerRunner implements IWorkflowRunner {
   private readonly options;
+  /** The Attempt owner commits and converges results before runner completion. */
+  readonly terminalAuthority = "authority";
   /**
    * @param options - Dispatch seam, authority, optional manifest, and optional requirements.
    */
@@ -1627,6 +1704,17 @@ interface OutcomeSubmitPayload {
   readonly executionId: string;
   readonly result: WorkflowRunResult;
 }
+/** Payload for the generic terminal Attempt outcome ingress. */
+interface AttemptOutcomeSubmitPayload {
+  /** Authority-created Attempt identity. */
+  readonly executionAttemptId: string;
+  /** Runtime generation accepted during registration. */
+  readonly runtimeGeneration: number;
+  /** Admitted operation for non-startup outcomes. */
+  readonly operationId?: string;
+  /** Technical failure or opaque workload result. */
+  readonly outcome: ExecutionAttemptOutcome;
+}
 /**
  * Outcome ACK decisions that confirm durable delivery.
  *
@@ -1654,6 +1742,26 @@ declare class OutcomeDeliveryError extends Error {
    */
   constructor(decision: OutcomeAckDecision | 'deadline-exceeded', result: WorkflowRunResult, reason?: OutcomeDeliveryFailureReason);
 }
+/** Error from delivery through the generic Attempt outcome ingress. */
+declare class AttemptOutcomeDeliveryError extends Error {
+  readonly decision: OutcomeAckDecision | 'deadline-exceeded';
+  readonly payload: AttemptOutcomeSubmitPayload;
+  readonly reason: OutcomeDeliveryFailureReason;
+  /**
+   * @param decision - Authority rejection decision or deadline marker.
+   * @param payload - Immutable Attempt outcome that could not be acknowledged.
+   * @param reason - Stable delivery failure classification.
+   */
+  constructor(decision: OutcomeAckDecision | 'deadline-exceeded', payload: AttemptOutcomeSubmitPayload, reason?: OutcomeDeliveryFailureReason);
+}
+/** Deadline failure for a non-terminal Authority request retried by the Runtime. */
+declare class AuthorityRequestDeliveryError extends Error {
+  readonly reason: 'deadline-exceeded';
+  /**
+   * @param reason - Stable reason the request could not complete.
+   */
+  constructor(reason?: 'deadline-exceeded');
+}
 /**
  * Optional reconnect callback invoked before each retry when the
  * previous attempt failed with a transport-level error.
@@ -1664,6 +1772,11 @@ declare class OutcomeDeliveryError extends Error {
  * will naturally fail again if the transport is still down.
  */
 type OutcomeReconnect = () => Promise<void>;
+/** Common retry options for either legacy workflow or generic Attempt outcome delivery. */
+interface OutcomeSubmitOptions {
+  readonly retry?: OutcomeSubmitRetryConfig;
+  readonly reconnect?: OutcomeReconnect;
+}
 /**
  * Submit a workflow outcome for durable acknowledgement with
  * decision-aware, reconnect-capable retry.
@@ -1688,10 +1801,16 @@ type OutcomeReconnect = () => Promise<void>;
  * @returns Durable ACK decision (`accepted` or `duplicate`).
  * @throws {@link OutcomeDeliveryError} On non-transient rejection or deadline expiry.
  */
-declare function submitOutcomeWithAck(bus: IMakaioBus, payload: OutcomeSubmitPayload, options?: {
-  readonly retry?: OutcomeSubmitRetryConfig;
-  readonly reconnect?: OutcomeReconnect;
-}): Promise<OutcomeAckDecision>;
+declare function submitOutcomeWithAck(bus: IMakaioBus, payload: OutcomeSubmitPayload, options?: OutcomeSubmitOptions): Promise<OutcomeAckDecision>;
+/**
+ * Submit a generic Attempt terminal outcome with the same bounded retry policy
+ * as legacy workflow results.
+ * @param bus - Runtime bus authenticated as the Attempt peer.
+ * @param payload - Fenced Attempt result and optional admitted operation.
+ * @param options - Retry and reconnect behavior.
+ * @returns Durable Authority acknowledgement.
+ */
+declare function submitAttemptOutcomeWithAck(bus: IMakaioBus, payload: AttemptOutcomeSubmitPayload, options?: OutcomeSubmitOptions): Promise<OutcomeAckDecision>;
 //#endregion
 //#region runtimes/node/src/workflow-worker/piscina-thin-workflow-provider.d.ts
 /**
@@ -1998,7 +2117,7 @@ declare function createIsolatedWorkflowRuntime(options: CreateIsolatedWorkflowRu
  * The harness receives these credentials after a successful bootstrap claim
  * and uses them to establish the authenticated bus connection.
  */
-type HeadlessWorkerBootstrapCredentials = WorkerBootstrapClaimResponse;
+type HeadlessWorkerBootstrapCredentials = WorkerBootstrapCredentials;
 /**
  * Bootstrap the worker by claiming execution-scoped bus credentials.
  *
@@ -2020,21 +2139,18 @@ type HeadlessWorkerBootstrap = (signal: AbortSignal) => Promise<HeadlessWorkerBo
  */
 type HeadlessWorkerBusConnector = (bus: IMakaioBus, credentials: HeadlessWorkerBootstrapCredentials, signal: AbortSignal) => Promise<void>;
 /**
- * Result of materializing a portable run context into worker-local paths.
+ * Workflow executable and contribution paths acquired inside Invocation.
  *
- * The optional {@link cleanup} callback is invoked by the harness in its
- * finally teardown (best-effort, idempotent-safe) after runtime shutdown.
- * Implementations that acquire temporary resources (snapshot dirs, file
- * handles) should provide a cleanup callback to release them.
+ * This legacy name does not declare a project Workspace. Cleanup is permitted
+ * only after an acknowledged workload result without preservation obligations. A root
+ * shared with the prepared project Workspace has that Workspace's cleanup owner.
  */
 interface MaterializedWorkspace {
   /** Materialized worker-local runtime context with absolute paths. */
   readonly context: WorkerRuntimeContext;
   /**
-   * Optional cleanup callback invoked during harness teardown.
-   *
-   * Must be idempotent — the harness may call it multiple times or
-   * after partial initialization. Rejections are swallowed.
+   * Optional idempotent executable-root cleanup, after acknowledged execution.
+   * Never called for technical failure, cancellation, unacknowledged outcomes or roots overlapping a project Workspace.
    */
   readonly cleanup?: () => Promise<void>;
 }
@@ -2044,7 +2160,7 @@ interface MaterializedWorkspace {
  * The implementation resolves workspace snapshots or local directories,
  * verifies contribution integrity, and returns a {@link MaterializedWorkspace}
  * with absolute worker-local paths and an optional cleanup callback.
- * @param runContext - Persisted portable run context from the Authority.
+ * @param runContext - Local DTO reconstructed from frozen input and selected Runtime inputs.
  * @param signal - Cancellation signal.
  * @returns Materialized workspace with runtime context and optional cleanup.
  */
@@ -2064,7 +2180,7 @@ type HeadlessWorkerContributionLoader = (runtimeContext: WorkerRuntimeContext, s
  * The implementation loads the workflow from the run context and drives it
  * through the orchestrator. The returned result is immutable.
  * @param bus - Connected worker-local bus.
- * @param runContext - Persisted portable run context.
+ * @param runContext - Local DTO reconstructed from frozen input and selected Runtime inputs.
  * @param runtimeContext - Materialized worker-local runtime context.
  * @param signal - Effective cancellation signal (combines caller + bus cancel).
  * @returns Immutable terminal workflow run result.
@@ -2092,11 +2208,19 @@ interface HeadlessWorkflowWorkerDeps {
   readonly executionId: string;
   /** Authority-created attempt identifier. */
   readonly executionAttemptId: string;
+  /** Immutable absolute deadline created with the Attempt, shared by every bootstrap phase. */
+  readonly bootstrapDeadlineAt: string;
+  /** Explicit host-delivered workflow environment; never inferred from ambient process state. */
+  readonly workflowEnv: Readonly<Record<string, string>>;
+  /** Private setup-process environment, supplied separately from workflowEnv and never persisted. */
+  readonly setupEnv?: Readonly<NodeJS.ProcessEnv>;
   /** Claim execution-scoped bus credentials. */
   readonly bootstrap: HeadlessWorkerBootstrap;
   /** Establish the authenticated bus connection. */
   readonly connectBus: HeadlessWorkerBusConnector;
-  /** Materialize the portable spec into worker-local context. */
+  /** Explicit project Workspace path; required only by an instruction requesting one. */
+  readonly workspaceRoot?: string;
+  /** Materialize executable and contribution paths inside admitted Invocation. */
   readonly materialize: HeadlessWorkerMaterializer;
   /** Load contribution packages from materialized entrypoints. */
   readonly loadContributions: HeadlessWorkerContributionLoader;
@@ -2122,34 +2246,146 @@ interface HeadlessWorkflowWorkerDeps {
 /**
  * Terminal result of a headless worker execution.
  *
- * Contains the immutable workflow result and the Authority's durable ACK
- * decision so callers can distinguish first-time acceptance from replay.
+ * Preserves technical failure, cancellation and actual workflow results, together with
+ * the Authority's durable acknowledgement.
  */
 interface HeadlessWorkflowWorkerResult {
-  /** Immutable terminal workflow run result. */
-  readonly result: WorkflowRunResult;
+  /** Canonical technical failure, cancellation or the workflow's actual returned result. */
+  readonly outcome: ExecutionAttemptOutcome;
   /** Durable ACK decision from the Authority. */
   readonly decision: OutcomeAckDecision;
 }
 /**
- * Run a single workflow execution through the portable headless worker harness.
+ * Register one Runtime, then run optional Workspace Preparation and Invocation.
  *
- * The runtime proves itself to the Authority before it asks for work: the
- * delivery endpoint is installed first, `execution-attempt.runtime.register`
- * returns only after the Authority made readiness durable, and the whole legacy
- * run then passes the attempt's start gate as one admitted `workflow-run`
- * operation. Kernel readiness is emitted later, by
- * `createIsolatedWorkflowRuntime` during composition.
- * @param deps - Injected provider and product dependencies.
- * @param signal - Cancellation signal from the process/caller.
- * @returns Terminal result and durable ACK decision.
- * @throws {@link OutcomeDeliveryError} When the Authority rejects the outcome.
- * @throws {@link RuntimeRegistrationRefusedError} When the Authority refuses this runtime.
- * @throws {@link OperationAdmissionRefusedError} When the Authority refuses the run.
- * @throws When bootstrap, connection, materialization, or runtime composition fails.
+ * The authenticated control bus stays connected through the canonical outcome
+ * acknowledgement. Workflow code acquisition and runtime composition happen
+ * only inside the installed workflow adapter's admitted Invocation.
+ * @param deps - Provider and installed workflow adapter dependencies.
+ * @param signal - Cancellation signal from the process or caller.
+ * @returns Canonical outcome and durable acknowledgement.
  */
 declare function runHeadlessWorkflowWorker(deps: HeadlessWorkflowWorkerDeps, signal: AbortSignal): Promise<HeadlessWorkflowWorkerResult>;
 //#endregion
+//#region runtimes/node/src/workspace-preparation/setup-command.d.ts
+/** Result of one bounded setup command, after its owned process group has stopped. */
+interface SetupCommandResult {
+  readonly status: 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'spawn-failed' | 'stop-failed';
+  readonly exitCode: number | null;
+  /** Generic diagnostics deliberately exclude command arguments and environment values. */
+  readonly message?: string;
+}
+//#endregion
+//#region runtimes/node/src/workspace-preparation/workspace-preparation.d.ts
+/** First failed setup command, or successful completion of the complete frozen recipe. */
+interface WorkspaceSetupResult extends SetupCommandResult {
+  readonly commandIndex?: number;
+}
+/** Setup inputs supplied by the host, not stored in the portable workspace requirement. */
+interface WorkspaceSetupOptions {
+  readonly signal?: AbortSignal;
+  readonly env?: NodeJS.ProcessEnv;
+}
+/** A local realization whose release remains an explicit caller decision. */
+interface LocalWorkspaceHandle {
+  readonly binding: ExecutionAttemptWorkspaceBinding;
+  /** Execute the already-authorized recipe; failures retain the handle and files. */
+  runSetup(options?: WorkspaceSetupOptions): Promise<WorkspaceSetupResult>;
+  /** Call only after preservation policy permits release. External roots are never deleted. */
+  release(): Promise<void>;
+}
+//#endregion
+//#region runtimes/node/src/workflow-worker/workload-invocation.d.ts
+/** One installed, versioned local executor for an opaque workload instruction. */
+interface InstalledWorkloadAdapter {
+  /** Workload kind this adapter accepts. */
+  readonly kind: string;
+  /** Exact frozen input version this adapter accepts. */
+  readonly version: string;
+  /**
+   * Bind workload-local control before any mutating operation is admitted.
+   *
+   * The returned signal may combine caller cancellation with workload-specific
+   * control. Its release stays live through terminal acknowledgement so a
+   * cancellation cannot race a locally detached subscription.
+   * @param input - Frozen instruction and outer Runtime cancellation signal.
+   * @returns Effective work signal and a release operation for local control state.
+   */
+  bindControl?(input: {
+    readonly instruction: ExecutionAttemptInstruction;
+    readonly signal?: AbortSignal;
+  }): Promise<WorkloadControlBinding>;
+  /**
+   * Execute only after Invocation admission.
+   *
+   * An adapter may acquire and load its own executable artifact here. That is
+   * workload execution, not Workspace Preparation.
+   * @param input - Frozen instruction, accepted optional Workspace binding and cancellation.
+   * @returns Opaque JSON result interpreted by the owner-side adapter.
+   */
+  invoke(input: {
+    readonly instruction: ExecutionAttemptInstruction;
+    readonly workspace?: ExecutionAttemptWorkspaceBinding;
+    readonly signal?: AbortSignal;
+  }): Promise<JsonValue>;
+}
+/** Workload-local control subscription retained through the terminal outcome acknowledgement. */
+interface WorkloadControlBinding {
+  /** Effective signal for local setup and workload execution. */
+  readonly signal: AbortSignal;
+  /** Detach local control state after the terminal outcome is acknowledged. */
+  release(): void;
+}
+/** Runtime-local dependencies for realizing one optional Workspace requirement. */
+interface WorkloadInvocationPreparation {
+  /** Bind/create and retain one local Workspace until explicit release. */
+  prepare(input: {
+    readonly requirement: WorkspaceRequirement;
+    readonly workspaceRoot: string;
+    readonly signal?: AbortSignal;
+  }): Promise<LocalWorkspaceHandle>;
+}
+/** Inputs for the fixed Preparation → Invocation sequence of an already registered Runtime. */
+interface RunWorkloadInvocationOptions {
+  /** Authority-created Attempt identity. */
+  readonly executionAttemptId: string;
+  /** Generation accepted during Runtime registration. */
+  readonly runtimeGeneration: number;
+  /** Explicit host-selected local root, required only by a declared Workspace. */
+  readonly workspaceRoot?: string;
+  /** Private host environment for setup subprocesses; never included in the portable instruction or receipts. */
+  readonly setupEnv?: Readonly<NodeJS.ProcessEnv>;
+  /** Installed workload adapters available in this Runtime. */
+  readonly adapters: readonly InstalledWorkloadAdapter[];
+  /** Cancellation signal forwarded to source preparation, setup and workload execution. */
+  readonly signal?: AbortSignal;
+  /** Reconnect hook reused for terminal outcome acknowledgement. */
+  readonly reconnect?: OutcomeReconnect;
+  /** Bounded retry policy reused for terminal outcome acknowledgement. */
+  readonly retry?: OutcomeSubmitRetryConfig;
+  /** Local Workspace realization seam; defaults to the Node bind/create helper. */
+  readonly preparation?: WorkloadInvocationPreparation;
+}
+/** Durable result visible after generic terminal-outcome acknowledgement. */
+interface WorkloadInvocationResult {
+  /** Exact technical failure or opaque workload result committed by the Authority. */
+  readonly outcome: ExecutionAttemptOutcome;
+  /** Authority acknowledgement after canonical owner convergence. */
+  readonly decision: OutcomeAckDecision;
+}
+/**
+ * Execute the fixed generic workload sequence for an already registered Runtime.
+ *
+ * No Workspace is synthesized for workspace-less instructions. The default
+ * Preparation installs no source strategy; an injected Preparation can supply
+ * one. Executable acquisition stays inside the admitted adapter invocation.
+ * @param bus - Runtime bus authenticated as this Attempt.
+ * @param options - Registered Attempt, installed adapters and optional local Workspace locator.
+ * @returns The terminal outcome after canonical Authority acknowledgement.
+ * @throws AuthorityRequestDeliveryError When admission or Preparation acknowledgement exceeds its delivery deadline.
+ */
+declare function runWorkloadInvocation(bus: IMakaioBus, options: RunWorkloadInvocationOptions): Promise<WorkloadInvocationResult>;
+//#endregion
 //#region runtimes/node/src/workflow-worker/workflow-loader.d.ts
 /**
  * Resolve a {@link RuntimeLoadedWorkflow} from the parsed worker config.
@@ -2292,9 +2528,10 @@ interface OperationDeliveryEndpoint {
  * @param bus - Connected runtime bus the endpoint is installed on.
  * @param identity - Attempt and incarnation this runtime is; the delivery filter.
  * @param handlers - Handlers for the operation kinds this runtime can execute.
+ * @param signal - Optional cancellation while the endpoint becomes visible.
  * @returns The installed endpoint: a generation binder and its cleanup.
  */
-declare function installOperationDeliveryEndpoint(bus: IMakaioBus, identity: OperationDeliveryEndpointIdentity, handlers: OperationDeliveryHandlers): Promise<OperationDeliveryEndpoint>;
+declare function installOperationDeliveryEndpoint(bus: IMakaioBus, identity: OperationDeliveryEndpointIdentity, handlers: OperationDeliveryHandlers, signal?: AbortSignal): Promise<OperationDeliveryEndpoint>;
 /**
  * Error thrown when the authority refuses a runtime registration.
  *
@@ -2327,20 +2564,6 @@ declare class OperationAdmissionRefusedError extends Error {
    */
   constructor(executionAttemptId: string, admissionKey: string, refusalReason: ExecutionAttemptOperationAdmitRefusalReason | undefined);
 }
-/**
- * How long a registration keeps retrying a `not-allocated` refusal.
- *
- * The allocation-visibility window: a provider that runs its runtime in
- * process starts it inside `provision()`, and the pool records the returned
- * allocation only afterwards. Until that record is durable the authority
- * answers `not-allocated`, which is a fact about timing, not about this
- * runtime. Same value and same reasoning as `BOOTSTRAP_CONNECT_TIMEOUT_MS` in
- * the container entrypoint's bootstrap claim, which retries the equivalent
- * `attempt-pending` rejection. The window exists because no provider has an
- * activation step the pool drives after the record is durable; until such a
- * barrier exists, the retry is the runtime's only way to wait for the record.
- */
-declare const ALLOCATION_VISIBILITY_DEADLINE_MS = 10000;
 /** Parameters for registering this runtime incarnation with the authority. */
 interface RegisterWorkerRuntimeOptions {
   /** Authority-created attempt identifier this runtime claims. */
@@ -2349,13 +2572,6 @@ interface RegisterWorkerRuntimeOptions {
   readonly runtimeIncarnationId: string;
   /** Cancellation signal for the registration request. */
   readonly signal?: AbortSignal;
-  /**
-   * How long to keep retrying a `not-allocated` refusal, in milliseconds.
-   *
-   * Defaults to {@link ALLOCATION_VISIBILITY_DEADLINE_MS}. Exists so a test can
-   * pin the deadline without waiting ten seconds for it.
-   */
-  readonly allocationVisibilityDeadlineMs?: number;
 }
 /**
  * Register this runtime incarnation as the endpoint of its ExecutionAttempt.
@@ -2364,9 +2580,8 @@ interface RegisterWorkerRuntimeOptions {
  * it allocates the generation, admits and delivers the bounded probe to the
  * endpoint installed by {@link installOperationDeliveryEndpoint}, persists the
  * completion, and publishes `execution-attempt.runtime.ready`. The reply is
- * the complete answer; the only refusal retried here is `not-allocated`, and
- * only inside the allocation-visibility window described at
- * {@link ALLOCATION_VISIBILITY_DEADLINE_MS}.
+ * the complete answer. Allocation visibility is awaited by the separate
+ * bootstrap start barrier; registration itself never retries a refusal.
  *
  * A `duplicate` decision is readiness: the authority answers it only for an
  * incarnation that already holds a readiness instant, and it carries the same
@@ -2438,4 +2653,46 @@ interface AdmittedWorkflowRun {
  */
 declare function registerAndAdmitWorkflowRun(bus: IMakaioBus, options: RegisterAndAdmitWorkflowRunOptions): Promise<AdmittedWorkflowRun>;
 //#endregion
-export { ThinWorkflowPiscinaRunner as $, runHeadlessWorkflowWorker as A, initializeNodeDatabase as At, PiscinaThinWorkflowProviderOptions as B, HttpRouteGraphBuilder as Bt, HeadlessWorkerContributionLoader as C, verifyContribution as Ct, HeadlessWorkflowWorkerDeps as D, DatabaseBootOptions as Dt, HeadlessWorkerPostCommitObserver as E, resolveWorkflowWorkerEntry as Et, WorkflowRuntimeContributionLoader as F, BridgeBrowserOptions as Ft, OutcomeSubmitRetryConfig as G, HonoRouteGraphOptions as Gt, OutcomeDeliveryError as H, HttpContributionPhase as Ht, createIsolatedWorkflowRuntime as I, FrameworkModuleResolver as It, WorkerRunnerOptions as J, ActivatedAdapterRuntimeIdentity as Jt, submitOutcomeWithAck as K, createHonoRouteGraph as Kt, InProcessWorkflowRunner as L, NodeFrameworkModuleResolver as Lt, IsolatedWorkflowRuntime as M, normalizeNodeHostCapabilities as Mt, IsolatedWorkflowRuntimeContext as N, selectFrameworkCorePackages as Nt, HeadlessWorkflowWorkerResult as O, InitializeNodeDatabaseOptions as Ot, WorkflowRuntimeAuthorityConnector as P, ShutdownStep as Pt, createNodeWorkflowRunnerPackageOptions as Q, prepareAdapterRuntime as Qt, InProcessWorkflowRunnerOptions as R, NoopFrameworkModuleResolver as Rt, HeadlessWorkerBusConnector as S, parseSriIntegrity as St, HeadlessWorkerMaterializer as T, WorkflowWorkerEntryResolverOptions as Tt, OutcomeReconnect as U, HttpRouteContribution as Ut, DELIVERED_DECISIONS as V, createHttpRouteGraphBuilder as Vt, OutcomeSubmitPayload as W, HonoRouteGraph as Wt, NodeWorkflowRunnerPackageOptions as X, PreparedAdapterRuntime as Xt, CreateNodeWorkflowRunnerPackageOptionsParams as Y, PrepareAdapterRuntimeInput as Yt, createNodeWorkflowRunner as Z, activateAdapterRuntimeIdentity as Zt, loadWorkflowModule as _, assertNoSymlinkEscape as _t, OperationAdmissionRefusedError as a, BootMakaioRuntimeOptions as at, HeadlessWorkerBootstrap as b, computeFileDigest as bt, OperationDeliveryHandler as c, ServerTransportProvider as ct, RegisterWorkerRuntimeOptions as d, WorkflowRunnerBootOptions as dt, IWorkflowRunner$1 as et, RuntimeRegistrationRefusedError as f, LocalDirectoryMaterializerOptions as ft, registerWorkerRuntime as g, assertContainedIn as gt, registerAndAdmitWorkflowRun as h, WorkspaceRootResolver as ht, DeliverableOperationKind as i, BootCoordinatorSetupContext as it, CreateIsolatedWorkflowRuntimeOptions as j, HostCapabilityDeclaration as jt, MaterializedWorkspace as k, InitializeNodeDatabaseResult as kt, OperationDeliveryHandlers as l, TransportReadyInfo as lt, installOperationDeliveryEndpoint as m, ParsedSriIntegrity as mt, AdmitWorkflowRunOperationOptions as n, ThinWorkflowPiscinaRunnerOptions as nt, OperationDeliveryEndpoint as o, CoreBootOptions as ot, admitWorkflowRunOperation as p, MaterializationError as pt, WorkerRunner as q, ActivateAdapterRuntimeIdentityInput as qt, AdmittedWorkflowRun as r, WorkflowRunResult$1 as rt, OperationDeliveryEndpointIdentity as s, MakaioRuntime as st, ALLOCATION_VISIBILITY_DEADLINE_MS as t, RuntimeLoadedWorkflow as tt, RegisterAndAdmitWorkflowRunOptions as u, UpstreamTelemetryBootOptions as ut, loadWorkflowModules as v, computeContributionPackageDigest as vt, HeadlessWorkerExecutor as w, WorkflowWorkerEntryMode as wt, HeadlessWorkerBootstrapCredentials as x, materializeLocalDirectory as xt, loadWorkflowFromConfig as y, computeDirectoryDigest as yt, PiscinaThinWorkflowProvider as z, resolveFrameworkSpecifier as zt };
+//#region runtimes/node/src/workflow-worker/bootstrap-start-client.d.ts
+/** Synchronously acquired connection ownership, including an unfinished connect. */
+interface BootstrapRuntimeConnection {
+  /** Fresh isolated bus, owned until close or successful transfer. */
+  readonly bus: IMakaioBus;
+  /**
+   * Connect authentication and subscription readiness.
+   * @param signal - Cancellation of this pre-registration connection phase.
+   */
+  connect(signal: AbortSignal): Promise<void>;
+  /** Revoke this session, including an unfinished connection. */
+  close(): void | Promise<void>;
+}
+/** One surviving authenticated connection whose start permission was granted. */
+interface StartedWorkerRuntime {
+  readonly connection: BootstrapRuntimeConnection;
+  readonly endpoint: OperationDeliveryEndpoint;
+}
+/** Durable Attempt identity and provider-specific connection acquisition. */
+interface BootstrapWorkerRuntimeOptions {
+  readonly executionAttemptId: string;
+  readonly runtimeIncarnationId: string;
+  readonly bootstrapDeadlineAt: string;
+  readonly signal: AbortSignal;
+  readonly createConnection: () => BootstrapRuntimeConnection;
+}
+/** Explicit Authority refusal: reconnecting cannot turn it into permission. */
+declare class BootstrapStartRefusedError extends Error {
+  readonly refusalReason: ExecutionAttemptBootstrapStartRefusalReason;
+  /**
+   * @param refusalReason - Non-secret refusal from the authoritative start gate.
+   */
+  constructor(refusalReason: ExecutionAttemptBootstrapStartRefusalReason);
+}
+/**
+ * Install the endpoint and await durable allocation permission before registration.
+ * A failed connection and its endpoint are revoked before a fresh session starts.
+ * @param options - Attempt budget, identity and synchronous connection factory.
+ * @returns The surviving control connection and installed operation endpoint.
+ */
+declare function bootstrapWorkerRuntime(options: BootstrapWorkerRuntimeOptions): Promise<StartedWorkerRuntime>;
+//#endregion
+export { AuthorityRequestDeliveryError as $, selectFrameworkCorePackages as $t, HeadlessWorkerBootstrap as A, UpstreamTelemetryBootOptions as At, runHeadlessWorkflowWorker as B, computeFileDigest as Bt, loadWorkflowFromConfig as C, WorkflowRunResult$1 as Ct, WorkloadInvocationPreparation as D, MakaioRuntime as Dt, WorkloadControlBinding as E, CoreBootOptions as Et, HeadlessWorkerMaterializer as F, WorkspaceRootResolver as Ft, WorkflowRuntimeContributionLoader as G, WorkflowWorkerEntryResolverOptions as Gt, IsolatedWorkflowRuntime as H, parseSriIntegrity as Ht, HeadlessWorkerPostCommitObserver as I, assertContainedIn as It, InProcessWorkflowRunnerOptions as J, InitializeNodeDatabaseOptions as Jt, createIsolatedWorkflowRuntime as K, resolveWorkflowWorkerEntry as Kt, HeadlessWorkflowWorkerDeps as L, assertNoSymlinkEscape as Lt, HeadlessWorkerBusConnector as M, LocalDirectoryMaterializerOptions as Mt, HeadlessWorkerContributionLoader as N, MaterializationError as Nt, WorkloadInvocationResult as O, ServerTransportProvider as Ot, HeadlessWorkerExecutor as P, ParsedSriIntegrity as Pt, AttemptOutcomeSubmitPayload as Q, normalizeNodeHostCapabilities as Qt, HeadlessWorkflowWorkerResult as R, computeContributionPackageDigest as Rt, loadWorkflowModules as S, ThinWorkflowPiscinaRunnerOptions as St, RunWorkloadInvocationOptions as T, BootMakaioRuntimeOptions as Tt, IsolatedWorkflowRuntimeContext as U, verifyContribution as Ut, CreateIsolatedWorkflowRuntimeOptions as V, materializeLocalDirectory as Vt, WorkflowRuntimeAuthorityConnector as W, WorkflowWorkerEntryMode as Wt, PiscinaThinWorkflowProviderOptions as X, initializeNodeDatabase as Xt, PiscinaThinWorkflowProvider as Y, InitializeNodeDatabaseResult as Yt, AttemptOutcomeDeliveryError as Z, HostCapabilityDeclaration as Zt, admitWorkflowRunOperation as _, activateAdapterRuntimeIdentity as _n, withWorkerBootstrapDeadline as _t, bootstrapWorkerRuntime as a, resolveFrameworkSpecifier as an, submitAttemptOutcomeWithAck as at, registerWorkerRuntime as b, IWorkflowRunner$1 as bt, DeliverableOperationKind as c, HttpContributionPhase as cn, WorkerRunnerOptions as ct, OperationDeliveryEndpointIdentity as d, HonoRouteGraphOptions as dn, createNodeWorkflowRunner as dt, ShutdownStep as en, DELIVERED_DECISIONS as et, OperationDeliveryHandler as f, createHonoRouteGraph as fn, createNodeWorkflowRunnerPackageOptions as ft, RuntimeRegistrationRefusedError as g, PreparedAdapterRuntime as gn, BootstrapDeadlineExceededError as gt, RegisterWorkerRuntimeOptions as h, PrepareAdapterRuntimeInput as hn, runWorkerBootstrapExchange as ht, StartedWorkerRuntime as i, NoopFrameworkModuleResolver as in, OutcomeSubmitRetryConfig as it, HeadlessWorkerBootstrapCredentials as j, WorkflowRunnerBootOptions as jt, runWorkloadInvocation as k, TransportReadyInfo as kt, OperationAdmissionRefusedError as l, HttpRouteContribution as ln, CreateNodeWorkflowRunnerPackageOptionsParams as lt, RegisterAndAdmitWorkflowRunOptions as m, ActivatedAdapterRuntimeIdentity as mn, WorkerBootstrapExchangeOptions as mt, BootstrapStartRefusedError as n, FrameworkModuleResolver as nn, OutcomeReconnect as nt, AdmitWorkflowRunOperationOptions as o, HttpRouteGraphBuilder as on, submitOutcomeWithAck as ot, OperationDeliveryHandlers as p, ActivateAdapterRuntimeIdentityInput as pn, BootstrapExchangeResult as pt, InProcessWorkflowRunner as q, DatabaseBootOptions as qt, BootstrapWorkerRuntimeOptions as r, NodeFrameworkModuleResolver as rn, OutcomeSubmitPayload as rt, AdmittedWorkflowRun as s, createHttpRouteGraphBuilder as sn, WorkerRunner as st, BootstrapRuntimeConnection as t, BridgeBrowserOptions as tn, OutcomeDeliveryError as tt, OperationDeliveryEndpoint as u, HonoRouteGraph as un, NodeWorkflowRunnerPackageOptions as ut, installOperationDeliveryEndpoint as v, prepareAdapterRuntime as vn, createWorkerBusAuth as vt, InstalledWorkloadAdapter as w, BootCoordinatorSetupContext as wt, loadWorkflowModule as x, RuntimeLoadedWorkflow as xt, registerAndAdmitWorkflowRun as y, ThinWorkflowPiscinaRunner as yt, MaterializedWorkspace as z, computeDirectoryDigest as zt };