@makaio/framework 1.0.0-dev-1788511348215 → 1.0.0-dev-1788811230746

package/dist/{index-C6aSnO8m.d.mts → index-9PUmCySn.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 { 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,
@@ -1299,9 +1301,16 @@ interface ThinWorkflowPiscinaRunnerOptions {
 }
 //#endregion
 //#region runtimes/node/src/workflow-worker/worker-ready-message.d.ts
-/** Message type posted by workflow workers once bus control routing is ready. */
+/** Message type posted by workflow workers once the authority accepted the runtime. */
 declare const WORKFLOW_WORKER_READY_MESSAGE_TYPE: "makaio.workflow-worker.ready";
-/** Piscina worker-to-pool message emitted after cancel routing is subscribed. */
+/**
+ * Piscina worker-to-pool message emitted after the attempt accepted this runtime.
+ *
+ * The message is posted only by the attempt-bound arm of the worker entrypoint,
+ * after `execution-attempt.runtime.register` returned and the workflow run
+ * passed the attempt's start gate. It therefore means "the authority accepted
+ * this runtime", not "the worker finished composing itself".
+ */
 interface WorkflowWorkerReadyMessage {
   /** Stable message discriminator. */
   readonly type: typeof WORKFLOW_WORKER_READY_MESSAGE_TYPE;
@@ -1309,16 +1318,23 @@ interface WorkflowWorkerReadyMessage {
   readonly executionId: string;
   /** Dynamic workflow cancel subject observed by the worker. */
   readonly cancelSubject: string;
-  /** Adapter identifiers loaded in the worker runtime before readiness. */
-  readonly adapters: readonly string[];
+  /** Attempt whose runtime registration the authority accepted. */
+  readonly executionAttemptId: string;
 }
 //#endregion
 //#region runtimes/node/src/workflow-worker/thin-workflow-piscina-runner.d.ts
+/** Attempt identity a readiness-aware dispatch binds its worker thread to. */
+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>;
 }
 /**
@@ -1353,18 +1369,23 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
    */
   run(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest): Promise<WorkflowRunnerCompletion$1>;
   /**
-   * Execute a workflow and expose the worker bus readiness signal separately.
+   * Execute an attempt-bound workflow and expose its readiness signal separately.
    *
    * The terminal result remains the {@link IWorkflowRunner} contract. The ready
-   * promise is used by {@link PiscinaThinWorkflowProvider} so pool lifecycle
-   * `ready` is not emitted before the worker has connected its bus and subscribed
-   * to cancellation routing.
+   * promise resolves once the worker thread's own
+   * `execution-attempt.runtime.register` reply came back, so readiness here
+   * means the authority accepted that runtime rather than that a thread booted.
+   *
+   * The attempt binding is required because readiness has no meaning without
+   * it: a thread with no attempt registers nothing, posts no ready message, and
+   * would leave this promise to be rejected by the run's own settlement.
    * @param config - Full workflow worker configuration with source, inputs, and bus info.
    * @param signal - AbortSignal for cooperative cancellation.
    * @param manifest - Optional per-call manifest override.
+   * @param attempt - Attempt identity the dispatched thread registers against.
    * @returns Terminal result and readiness promises for this worker run.
    */
-  runWithReadiness(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest): ThinWorkflowPiscinaRunWithReadiness;
+  runWithReadiness(config: WorkflowWorkerConfig, signal: AbortSignal, manifest: WorkerContributionManifest | undefined, attempt: ThinWorkflowPiscinaAttemptBinding): ThinWorkflowPiscinaRunWithReadiness;
   /**
    * Destroy the thread pool and release all worker threads.
    */
@@ -1373,6 +1394,11 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
    * Realize portable filesystem references before transferring a task to
    * Piscina. Worker threads receive only verified absolute paths, never an
    * Authority-relative source or unchecked contribution package path.
+   *
+   * The task is returned as the `unbound` arm; the readiness-aware path
+   * re-stamps it `attempt-bound` with its attempt identity afterwards, so the
+   * attempt identity never becomes an optional field on the shape the
+   * attempt-free path also uses.
    * @param config - Portable worker configuration.
    * @param manifest - Exact contribution identities for this execution.
    * @param signal - Cancellation signal for the dispatch.
@@ -1381,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 {
@@ -1399,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;
   /**
@@ -1409,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[];
 }
@@ -1431,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[];
 }
@@ -1468,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;
   /**
@@ -1477,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.
@@ -1509,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.
    *
@@ -1539,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.
    */
@@ -1605,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.
  *
@@ -1632,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.
@@ -1642,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.
@@ -1666,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
 /**
@@ -1688,9 +1829,10 @@ interface PiscinaThinWorkflowProviderOptions {
    * can supply lightweight fakes without spawning real worker threads.
    *
    * Readiness is part of the requirement rather than an optional refinement:
-   * this provider publishes `control.attempt-ready` from the runner's
-   * post-composition signal, and a runner without one would silently never
-   * make an attempt ready instead of failing where it is wired.
+   * the thread's own registration is what makes the attempt ready, and this
+   * provider watches that signal to abort the allocation when it fails. A
+   * runner without one would silently swallow a refused registration instead
+   * of failing where it is wired.
    */
   readonly runner: ReadinessAwareWorkflowRunner;
   /**
@@ -1731,13 +1873,14 @@ interface PiscinaThinWorkflowProviderOptions {
  */
 interface ReadinessAwareWorkflowRunner extends IWorkflowRunner {
   /**
-   * Run once and separately expose the worker's post-composition readiness.
+   * Run once and separately expose the worker's own registration readiness.
    * @param config - Worker configuration for the run.
    * @param signal - AbortSignal that cancels the run.
    * @param manifest - Optional per-call contribution manifest.
-   * @returns Terminal result promise and post-composition readiness promise.
+   * @param attempt - Attempt identity the dispatched worker registers against.
+   * @returns Terminal result promise and registration readiness promise.
    */
-  runWithReadiness(config: WorkerProvisionRequest['workerConfig'], signal: AbortSignal, manifest?: WorkerProvisionRequest['workerManifest']): ThinWorkflowPiscinaRunWithReadiness;
+  runWithReadiness(config: WorkerProvisionRequest['workerConfig'], signal: AbortSignal, manifest: WorkerProvisionRequest['workerManifest'] | undefined, attempt: ThinWorkflowPiscinaAttemptBinding): ThinWorkflowPiscinaRunWithReadiness;
 }
 /**
  * Built-in thin workflow provider backed by the existing workflow-level
@@ -1750,10 +1893,11 @@ interface ReadinessAwareWorkflowRunner extends IWorkflowRunner {
  * infrastructure-only {@link WorkerHandle}.
  *
  * The handle controls allocation lifecycle (cancel/terminate) but does
- * NOT expose readiness or workflow results. Readiness is signaled via
- * the worker protocol (`control.attempt-ready` bus subject) after runtime
- * composition. Workflow outcomes are submitted and acknowledged through
- * the Authority's `control.outcome.submit` bus subject.
+ * NOT expose readiness or workflow results. Readiness is the worker thread's
+ * own business: it registers its runtime with the ExecutionAttempt authority,
+ * which publishes `execution-attempt.runtime.ready`. Workflow outcomes are
+ * submitted and acknowledged through the Authority's `control.outcome.submit`
+ * bus subject.
  *
  * Piscina is a local thin workflow runner: it declares that it is NOT
  * recoverable. Allocation references are process-local and non-durable.
@@ -1806,9 +1950,14 @@ declare class PiscinaThinWorkflowProvider implements IWorkerProvider {
    * way to positively prove that nothing was created. The narrow type states
    * what it can prove today. Gaining the ability to confirm absence means
    * deliberately widening this signature back to the contract union.
+   * A worker configuration without a bus URL is rejected loudly rather than
+   * allocated: the thread would have no transport, so it could never
+   * authenticate as the attempt or register its runtime, and the allocation
+   * would be a worker that is provisioned and permanently unready.
    * @param request - Full provision request containing worker config and manifest.
    * @param signal - AbortSignal for cooperative cancellation of the provision operation.
    * @returns Allocated outcome with a validated allocation reference and infrastructure handle.
+   * @throws When the worker configuration carries no bus URL.
    */
   provision(request: WorkerProvisionRequest, signal: AbortSignal): Promise<WorkerAllocatedOutcome>;
   /**
@@ -1816,7 +1965,9 @@ declare class PiscinaThinWorkflowProvider implements IWorkerProvider {
    * the runner promise settles.
    *
    * On success, submits the runner's result directly. On failure, builds
-   * a `failed` {@link WorkflowRunResult} from the error message.
+   * a `failed` {@link WorkflowRunResult} from the error message. Attached
+   * only once the thread's run was admitted: a rejection before admission is
+   * infrastructure evidence, not a workflow outcome, and never reaches here.
    *
    * Uses the shared {@link submitOutcomeWithAck} helper for decision-aware
    * retry with bounded exponential back-off. Since the Piscina provider
@@ -1966,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.
  *
@@ -1988,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>;
 }
@@ -2012,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.
  */
@@ -2032,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.
@@ -2060,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;
@@ -2090,28 +2246,145 @@ 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.
  *
- * Kernel readiness is emitted by `createIsolatedWorkflowRuntime` internally;
- * attempt-ready follows after the runtime cancellation handoff completes.
- * @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 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;
+  }): 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 local 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. Source
+ * acquisition remains unsupported by the local Preparation helper; workload
+ * 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.
@@ -2174,4 +2447,251 @@ declare function loadWorkflowModules(source: Exclude<WorkflowWorkerSource, {
  */
 declare function loadWorkflowModule(source: WorkflowWorkerSource): Promise<RuntimeLoadedWorkflow>;
 //#endregion
-export { WorkspaceRootResolver as $, submitOutcomeWithAck as A, createHonoRouteGraph as At, ThinWorkflowPiscinaRunnerOptions as B, PiscinaThinWorkflowProvider as C, resolveFrameworkSpecifier as Ct, OutcomeReconnect as D, HttpRouteContribution as Dt, OutcomeDeliveryError as E, HttpContributionPhase as Et, createNodeWorkflowRunner as F, activateAdapterRuntimeIdentity as Ft, MakaioRuntime as G, BootCoordinatorSetupContext as H, createNodeWorkflowRunnerPackageOptions as I, prepareAdapterRuntime as It, UpstreamTelemetryBootOptions as J, ServerTransportProvider as K, ThinWorkflowPiscinaRunner as L, WorkerRunnerOptions as M, ActivatedAdapterRuntimeIdentity as Mt, CreateNodeWorkflowRunnerPackageOptionsParams as N, PrepareAdapterRuntimeInput as Nt, OutcomeSubmitPayload as O, HonoRouteGraph as Ot, NodeWorkflowRunnerPackageOptions as P, PreparedAdapterRuntime as Pt, ParsedSriIntegrity as Q, IWorkflowRunner$1 as R, InProcessWorkflowRunnerOptions as S, NoopFrameworkModuleResolver as St, DELIVERED_DECISIONS as T, createHttpRouteGraphBuilder as Tt, BootMakaioRuntimeOptions as U, WorkflowRunResult$1 as V, CoreBootOptions as W, LocalDirectoryMaterializerOptions as X, WorkflowRunnerBootOptions as Y, MaterializationError as Z, IsolatedWorkflowRuntimeContext as _, selectFrameworkCorePackages as _t, HeadlessWorkerBootstrapCredentials as a, materializeLocalDirectory as at, createIsolatedWorkflowRuntime as b, FrameworkModuleResolver as bt, HeadlessWorkerExecutor as c, WorkflowWorkerEntryMode as ct, HeadlessWorkflowWorkerDeps as d, DatabaseBootOptions as dt, assertContainedIn as et, HeadlessWorkflowWorkerResult as f, InitializeNodeDatabaseOptions as ft, IsolatedWorkflowRuntime as g, normalizeNodeHostCapabilities as gt, CreateIsolatedWorkflowRuntimeOptions as h, HostCapabilityDeclaration as ht, HeadlessWorkerBootstrap as i, computeFileDigest as it, WorkerRunner as j, ActivateAdapterRuntimeIdentityInput as jt, OutcomeSubmitRetryConfig as k, HonoRouteGraphOptions as kt, HeadlessWorkerMaterializer as l, WorkflowWorkerEntryResolverOptions as lt, runHeadlessWorkflowWorker as m, initializeNodeDatabase as mt, loadWorkflowModules as n, computeContributionPackageDigest as nt, HeadlessWorkerBusConnector as o, parseSriIntegrity as ot, MaterializedWorkspace as p, InitializeNodeDatabaseResult as pt, TransportReadyInfo as q, loadWorkflowFromConfig as r, computeDirectoryDigest as rt, HeadlessWorkerContributionLoader as s, verifyContribution as st, loadWorkflowModule as t, assertNoSymlinkEscape as tt, HeadlessWorkerPostCommitObserver as u, resolveWorkflowWorkerEntry as ut, WorkflowRuntimeAuthorityConnector as v, ShutdownStep as vt, PiscinaThinWorkflowProviderOptions as w, HttpRouteGraphBuilder as wt, InProcessWorkflowRunner as x, NodeFrameworkModuleResolver as xt, WorkflowRuntimeContributionLoader as y, BridgeBrowserOptions as yt, RuntimeLoadedWorkflow as z };
+//#region runtimes/node/src/workflow-worker/runtime-registration-client.d.ts
+/**
+ * Operation kinds a runtime endpoint may be handed by the authority.
+ *
+ * `runtime-probe` is excluded: the bounded probe is the authority's own proof
+ * that the endpoint accepts a fenced instruction, and
+ * {@link installOperationDeliveryEndpoint} answers it itself. A caller-supplied
+ * probe handler would be a second way to answer the same delivery.
+ */
+type DeliverableOperationKind = Exclude<ExecutionAttemptOperationKind, 'runtime-probe'>;
+/**
+ * Runtime-side executor for one delivered operation.
+ *
+ * Receives the delivery verbatim and returns the receipt the authority sees.
+ * A handler that cannot honour the delivery returns a `refused` receipt with
+ * its reason rather than throwing — a throw is reported to the authority as a
+ * failed request, which it reads as an unproven endpoint.
+ * @param delivery - The operation the authority handed to this runtime.
+ * @returns The receipt reported back to the authority.
+ */
+type OperationDeliveryHandler = (delivery: ExecutionAttemptOperationDelivery) => ExecutionAttemptOperationReceipt | Promise<ExecutionAttemptOperationReceipt>;
+/**
+ * Handlers a runtime installs for the operation kinds it can execute.
+ *
+ * Partial by design: a delivery whose kind has no handler is answered
+ * `refused` / `unknown-kind`, which is the honest report of a runtime that
+ * does not know the instruction.
+ */
+type OperationDeliveryHandlers = Partial<Record<DeliverableOperationKind, OperationDeliveryHandler>>;
+/** Identity the delivery endpoint is installed for. */
+interface OperationDeliveryEndpointIdentity {
+  /** Attempt this runtime owns; the first half of the delivery filter. */
+  readonly executionAttemptId: string;
+  /** This runtime incarnation; the second half of the delivery filter. */
+  readonly runtimeIncarnationId: string;
+  /**
+   * Generation this incarnation was accepted with, when already known.
+   *
+   * Set when the endpoint is re-installed on another bus after registration
+   * (the pre-composition → runtime bus handoff). A fresh endpoint installed
+   * before registration leaves it out and learns the generation through
+   * {@link OperationDeliveryEndpoint.bindGeneration}.
+   */
+  readonly runtimeGeneration?: number;
+}
+/** The installed delivery endpoint of one runtime incarnation. */
+interface OperationDeliveryEndpoint {
+  /**
+   * Fence later deliveries against the generation the authority accepted.
+   *
+   * Called once registration returned. The probe needs no fence — it is
+   * addressed to this incarnation and arrives before the generation exists —
+   * but every other delivery is refused `stale-generation` unless it carries
+   * exactly this generation.
+   * @param runtimeGeneration - Generation returned by registration.
+   */
+  bindGeneration(runtimeGeneration: number): void;
+  /** Remove the endpoint from its bus. Idempotent. */
+  cleanup(): void;
+}
+/**
+ * Install this runtime's responder for `execution-attempt.operation.deliver`.
+ *
+ * The subject is static and every live Worker Runtime subscribes to it, so the
+ * addressing is a payload filter on the runtime's own attempt and incarnation
+ * (`bus.withFilter({ executionAttemptId, runtimeIncarnationId })`, the same
+ * move the adapter session endpoints make in `adapters/core`). A delivery for
+ * another attempt — or for a newer incarnation of this attempt while this one
+ * is still connected — is a filter miss that returns undefined and
+ * auto-advances the dispatch chain to the next responder; it is not an error
+ * and this endpoint never sees it.
+ *
+ * The endpoint must exist before the runtime registers: the authority delivers
+ * the bounded probe inside the registration request, and an unsubscribed
+ * runtime fails its own registration with `probe-failed`. The returned
+ * propagation await is what makes "before" true across a transport — the
+ * subscription is visible to the authority when this resolves.
+ * @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, signal?: AbortSignal): Promise<OperationDeliveryEndpoint>;
+/**
+ * Error thrown when the authority refuses a runtime registration.
+ *
+ * A refusal hands out no generation, so there is nothing for the caller to
+ * fence with and no partial success to report: the runtime cannot proceed.
+ */
+declare class RuntimeRegistrationRefusedError extends Error {
+  readonly executionAttemptId: string;
+  readonly refusalReason: ExecutionAttemptRuntimeRegisterRefusalReason | undefined;
+  /**
+   * @param executionAttemptId - Attempt whose registration was refused.
+   * @param refusalReason - Authority's reason, absent only if it reported none.
+   */
+  constructor(executionAttemptId: string, refusalReason: ExecutionAttemptRuntimeRegisterRefusalReason | undefined);
+}
+/**
+ * Error thrown when the authority refuses an operation admission.
+ *
+ * A refused admission means the operation never passed the attempt's start
+ * gate, so the caller must not run it.
+ */
+declare class OperationAdmissionRefusedError extends Error {
+  readonly executionAttemptId: string;
+  readonly admissionKey: string;
+  readonly refusalReason: ExecutionAttemptOperationAdmitRefusalReason | undefined;
+  /**
+   * @param executionAttemptId - Attempt the admission was requested against.
+   * @param admissionKey - Idempotency key the caller admitted under.
+   * @param refusalReason - Authority's reason, absent only if it reported none.
+   */
+  constructor(executionAttemptId: string, admissionKey: string, refusalReason: ExecutionAttemptOperationAdmitRefusalReason | undefined);
+}
+/** Parameters for registering this runtime incarnation with the authority. */
+interface RegisterWorkerRuntimeOptions {
+  /** Authority-created attempt identifier this runtime claims. */
+  readonly executionAttemptId: string;
+  /** Identifier of this concrete runtime incarnation, unique per boot. */
+  readonly runtimeIncarnationId: string;
+  /** Cancellation signal for the registration request. */
+  readonly signal?: AbortSignal;
+}
+/**
+ * Register this runtime incarnation as the endpoint of its ExecutionAttempt.
+ *
+ * One request that returns only after the authority made readiness durable:
+ * 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. 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
+ * generation that incarnation was registered with.
+ * @param bus - Connected runtime bus authenticated as the attempt peer.
+ * @param options - Attempt identity, incarnation identity, cancellation.
+ * @returns The generation this runtime must fence all later traffic with.
+ * @throws {@link RuntimeRegistrationRefusedError} When the authority refuses.
+ */
+declare function registerWorkerRuntime(bus: IMakaioBus, options: RegisterWorkerRuntimeOptions): Promise<number>;
+/** Parameters for admitting this runtime's workflow run through the start gate. */
+interface AdmitWorkflowRunOperationOptions {
+  /** Authority-created attempt identifier the operation runs under. */
+  readonly executionAttemptId: string;
+  /** Generation this runtime was registered with. */
+  readonly runtimeGeneration: number;
+  /** Caller-chosen idempotency key for this admission. */
+  readonly admissionKey: string;
+  /** Cancellation signal for the admission request. */
+  readonly signal?: AbortSignal;
+}
+/**
+ * Admit this runtime's workflow run through the attempt's start gate.
+ *
+ * The legacy run passes the gate as one admitted operation: materialize, load,
+ * compose, execute, and the outcome all stay inside it, and the outcome commit
+ * settles the attempt rather than a separate completion call.
+ *
+ * A `duplicate` decision is the retry of an admission whose first pass already
+ * succeeded, so it yields the existing operation identifier.
+ * @param bus - Connected runtime bus authenticated as the attempt peer.
+ * @param options - Attempt identity, fence, idempotency key, cancellation.
+ * @returns The identifier of the admitted operation.
+ * @throws {@link OperationAdmissionRefusedError} When the authority refuses.
+ * @throws When the authority admits without naming an operation.
+ */
+declare function admitWorkflowRunOperation(bus: IMakaioBus, options: AdmitWorkflowRunOperationOptions): Promise<string>;
+/** Parameters for proving this runtime and admitting its workflow run. */
+interface RegisterAndAdmitWorkflowRunOptions {
+  /** Authority-created attempt identifier this runtime claims. */
+  readonly executionAttemptId: string;
+  /** Identifier of this concrete runtime incarnation, unique per boot. */
+  readonly runtimeIncarnationId: string;
+  /** The delivery endpoint installed for this incarnation, bound to the accepted generation here. */
+  readonly endpoint: OperationDeliveryEndpoint;
+  /** Cancellation signal for both requests. */
+  readonly signal?: AbortSignal;
+}
+/** What a runtime holds once its workflow run passed the start gate. */
+interface AdmittedWorkflowRun {
+  /** Generation this runtime was accepted with. */
+  readonly runtimeGeneration: number;
+  /** Identifier of the admitted workflow-run operation. */
+  readonly operationId: string;
+}
+/**
+ * Prove this runtime to the authority and admit its workflow run, in order.
+ *
+ * The one sequence every workflow runtime performs before it pulls work:
+ * register (the probe arrives at `options.endpoint` meanwhile), bind the
+ * accepted generation onto that endpoint, then admit the run under the
+ * incarnation's own key `workflow-run:<runtimeIncarnationId>`, so a retried
+ * admission is answered `duplicate` with the same operation.
+ * @param bus - Connected runtime bus authenticated as the attempt peer.
+ * @param options - Attempt identity, incarnation identity, endpoint, cancellation.
+ * @returns The accepted generation and the admitted operation.
+ * @throws {@link RuntimeRegistrationRefusedError} When the authority refuses the runtime.
+ * @throws {@link OperationAdmissionRefusedError} When the authority refuses the run.
+ */
+declare function registerAndAdmitWorkflowRun(bus: IMakaioBus, options: RegisterAndAdmitWorkflowRunOptions): Promise<AdmittedWorkflowRun>;
+//#endregion
+//#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 };