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

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

@@ -1,7 +1,7 @@
 import { r as ExtensionDiscovery } from "./extension-discovery-Dhu3WplO.mjs";
 import { RegistrableBusNamespaceDefinition } from "@makaio/framework/core";
 import { BusTransport, IMakaioBus, SubjectTelemetryProjectorRegistry } from "@makaio/framework/bus";
-import { ExtensionConfigProvider, IWorkerNodeProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, LoopGateHandler, MakaioNodeExtension, NormalizedWorkerNodeCapabilities, OutcomeAckDecision, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerBootstrapClaimResponse, WorkerContributionManifest, WorkerContributionRef, WorkerMaterializationSpec, WorkerNodeAllocatedOutcome, WorkerNodeCapabilities, WorkerNodeDispatch, WorkerNodeProvisionRequest, WorkerNodeRequirements, WorkerRuntimeContext, WorkflowDefinition, WorkflowRunContext, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerCompletion, WorkflowRunnerCompletion as WorkflowRunnerCompletion$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas } from "@makaio/framework/contracts";
+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 { ContributionProcessor, ExtensionCoordinator, ExtensionRuntimeSurface, KernelExtensionContext, KernelMakaioExtension, RuntimeCapability, TransportProvider, WindowRegistry } from "@makaio/framework/kernel";
 import { StorageEngine } from "@makaio/framework/storage/drizzle";
@@ -747,22 +747,22 @@ type WorkflowRunnerBootOptions = {
   readonly idleTimeoutMs?: number;
 } | {
   /**
-   * Delegate workflow executions to a product-owned WorkerNode dispatch seam.
+   * Delegate workflow executions to a product-owned Worker dispatch seam.
    *
    * The dispatch function is supplied by the host composition root and
    * typically wired to `workerPool.dispatch`. Framework code remains
    * decoupled from any pool implementation details.
    */
-  readonly mode: 'worker-node';
+  readonly mode: 'worker';
   /**
-   * WorkerNode dispatch function injected by the host composition root.
+   * Worker dispatch function injected by the host composition root.
    *
    * Called once per workflow execution with the full worker config and
    * manifest. Product hosts may wire this to `workerPool.dispatch`.
    * When omitted, the Node runtime dispatches through the framework
-   * `worker-node.dispatch` bus subject and requires a bus instance.
+   * `worker.dispatch` bus subject and requires a bus instance.
    */
-  readonly dispatch?: WorkerNodeDispatch;
+  readonly dispatch?: WorkerDispatch;
   /**
    * Contribution manifest forwarded to each dispatch call.
    *
@@ -777,7 +777,7 @@ type WorkflowRunnerBootOptions = {
    * When provided, the pool uses these to select a compatible provider.
    * Omit to accept any available pool with no constraints.
    */
-  readonly requirements?: WorkerNodeRequirements;
+  readonly requirements?: WorkerRequirements;
 };
 /**
  * Bound address info passed to {@link BootMakaioRuntimeOptions.onTransportReady}.
@@ -1055,17 +1055,17 @@ interface CoreBootOptions {
   /** Host-owned resolvers that create portable specs for path-backed workflow starts. */
   readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
   /**
-   * Injected execution attempt persistence port for WorkerNode dispatch.
+   * Injected execution attempt persistence port for Worker dispatch.
    *
-   * Required when `workflowRunner.mode` is `'worker-node'`. The consuming
+   * Required when `workflowRunner.mode` is `'worker'`. The consuming
    * Factory provides the concrete implementation that owns durable attempt
    * records and accept/duplicate/conflict/fence decisions.
    *
    * When omitted, framework-only, in-process, and Piscina modes operate
-   * without attempt tracking. WorkerNode mode fails fast at boot when this
+   * without attempt tracking. Worker mode fails fast at boot when this
    * is not provided.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
   /**
    * Runtime data home for config, database, machine identity, and installed
    * extensions. Defaults to the `MAKAIO_HOME` environment override when set,
@@ -1299,9 +1299,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,11 +1316,16 @@ 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;
+}
 /** Result and readiness promises for one workflow worker dispatch. */
 interface ThinWorkflowPiscinaRunWithReadiness {
   /** Terminal workflow result returned by the worker. */
@@ -1344,7 +1356,7 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
    * Execute a complete workflow in a pooled worker thread.
    *
    * When `manifest` is provided it overrides the runner's construction-time
-   * default, so per-request contribution sets from the WorkerNode pool are
+   * default, so per-request contribution sets from the Worker pool are
    * applied correctly without requiring a new runner instance.
    * @param config - Full workflow worker configuration with source, inputs, and bus info.
    * @param signal - AbortSignal for cooperative cancellation.
@@ -1353,18 +1365,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 +1390,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.
@@ -1398,18 +1420,18 @@ interface CreateNodeWorkflowRunnerPackageOptionsParams {
    * Host-owned bus instance forwarded to in-process runner construction.
    *
    * Required when `workflowRunner.mode` is `'in-process'` or omitted on an
-   * explicit runner object. Also used by WorkerNode mode when no explicit
+   * explicit runner object. Also used by Worker mode when no explicit
    * dispatch function is supplied. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
   /**
    * Injected execution attempt persistence port.
    *
-   * Required when `workflowRunner.mode` is `'worker-node'`. Threaded
+   * Required when `workflowRunner.mode` is `'worker'`. Threaded
    * through to the workflow engine service options so the Authority
    * service can delegate durable decisions.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
   /** Host-owned resolvers for portable path-backed workflow starts. */
   readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
@@ -1431,18 +1453,18 @@ interface NodeWorkflowRunnerPackageOptions {
   /**
    * Injected execution attempt persistence port.
    *
-   * Present only when the workflow runner uses WorkerNode dispatch mode.
+   * Present only when the workflow runner uses Worker dispatch mode.
    * Forwarded to the workflow engine service for Authority construction.
    */
-  readonly executionAttemptRepository?: ExecutionAttemptRepository;
+  readonly executionAttemptRepository?: ExecutionAttemptRepository<WorkflowRunResult>;
   /**
    * Execution attempt Authority constructed from the injected repository.
    *
-   * Present only when the workflow runner uses WorkerNode dispatch mode.
+   * Present only when the workflow runner uses Worker dispatch mode.
    * Shared between the runner (for attempt creation before dispatch) and
    * the workflow engine service (for outcome commitment).
    */
-  readonly executionAttemptAuthority?: ExecutionAttemptAuthority;
+  readonly executionAttemptAuthority?: ExecutionAttemptAuthority<WorkflowRunResult>;
   /** Host-owned resolvers forwarded to the workflow engine service. */
   readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
@@ -1467,17 +1489,17 @@ interface CreateNodeWorkflowRunnerParams {
    * Host-owned bus instance forwarded to {@link InProcessWorkflowRunner}.
    *
    * Required when `runner` is present and its `mode` is `'in-process'` or
-   * omitted. Also required for `'worker-node'` mode when no explicit dispatch
+   * omitted. Also required for `'worker'` mode when no explicit dispatch
    * function is supplied. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
   /**
-   * Execution attempt Authority injected into WorkerNode runners.
+   * Execution attempt Authority injected into Worker runners.
    *
-   * Required when `runner.mode` is `'worker-node'`. The runner uses this
+   * Required when `runner.mode` is `'worker'`. The runner uses this
    * to create attempts before dispatch and wait for committed outcomes.
    */
-  readonly authority?: ExecutionAttemptAuthority;
+  readonly authority?: ExecutionAttemptAuthority<WorkflowRunResult>;
 }
 /**
  * Create a workflow-level runner based on the Node runtime configuration.
@@ -1490,18 +1512,18 @@ interface CreateNodeWorkflowRunnerParams {
  */
 declare function createNodeWorkflowRunner(params: CreateNodeWorkflowRunnerParams): IWorkflowRunner | undefined;
 //#endregion
-//#region runtimes/node/src/workflow-worker/worker-node-runner.d.ts
+//#region runtimes/node/src/workflow-worker/worker-runner.d.ts
 /**
- * Construction options for {@link WorkerNodeRunner}.
+ * Construction options for {@link WorkerRunner}.
  */
-interface WorkerNodeRunnerOptions {
+interface WorkerRunnerOptions {
   /**
    * Dispatch seam injected by the host composition root.
    *
    * Product hosts wire this to `workerPool.dispatch` or another implementation.
    * Framework code calls through this seam without coupling to any pool.
    */
-  readonly dispatch: WorkerNodeDispatch;
+  readonly dispatch: WorkerDispatch;
   /**
    * Execution attempt Authority used to create attempts before dispatch and
    * wait for committed outcomes after dispatch returns.
@@ -1509,7 +1531,7 @@ interface WorkerNodeRunnerOptions {
    * Required for authority-committed completions. When absent, the runner
    * cannot create attempts or wait for durable outcomes.
    */
-  readonly authority: ExecutionAttemptAuthority;
+  readonly authority: ExecutionAttemptAuthority<WorkflowRunResult>;
   /**
    * Extension contribution manifest forwarded to dispatched workers.
    *
@@ -1523,10 +1545,10 @@ interface WorkerNodeRunnerOptions {
    * When provided, the receiving pool uses these to select a compatible
    * provider. Omit to accept any available pool.
    */
-  readonly requirements?: WorkerNodeRequirements;
+  readonly requirements?: WorkerRequirements;
 }
 /**
- * Workflow runner that delegates full workflow execution to a WorkerNode
+ * Workflow runner that delegates full workflow execution to a Worker
  * dispatch seam supplied by the host composition root.
  *
  * This class implements the {@link IWorkflowRunner} contract while remaining
@@ -1537,12 +1559,12 @@ interface WorkerNodeRunnerOptions {
  * The runner creates an execution attempt through the injected Authority
  * before dispatch and waits for the committed outcome after dispatch returns.
  */
-declare class WorkerNodeRunner implements IWorkflowRunner {
+declare class WorkerRunner implements IWorkflowRunner {
   private readonly options;
   /**
    * @param options - Dispatch seam, authority, optional manifest, and optional requirements.
    */
-  constructor(options: WorkerNodeRunnerOptions);
+  constructor(options: WorkerRunnerOptions);
   /**
    * Execute a complete workflow by delegating to the injected dispatch seam.
    *
@@ -1688,9 +1710,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;
   /**
@@ -1711,7 +1734,7 @@ interface PiscinaThinWorkflowProviderOptions {
    * call site instead of having the value silently dropped. See
    * {@link PiscinaThinWorkflowProvider}.
    */
-  readonly baseCapabilities?: Omit<Partial<WorkerNodeCapabilities>, 'supportsRecovery'>;
+  readonly baseCapabilities?: Omit<Partial<WorkerCapabilities>, 'supportsRecovery'>;
   /**
    * Optional retry configuration for outcome submission.
    *
@@ -1731,13 +1754,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: WorkerNodeProvisionRequest['workerConfig'], signal: AbortSignal, manifest?: WorkerNodeProvisionRequest['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
@@ -1747,13 +1771,14 @@ interface ReadinessAwareWorkflowRunner extends IWorkflowRunner {
  * with the framework capability registry and participate in pool-driven
  * dispatch. Each {@link provision} call starts the underlying runner and
  * returns a validated {@link ProviderAllocationRef} together with an
- * infrastructure-only {@link WorkerNodeHandle}.
+ * 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.
@@ -1765,7 +1790,7 @@ interface ReadinessAwareWorkflowRunner extends IWorkflowRunner {
  * recovery capability, and `supportsRecovery` stays `false` regardless of the
  * capability overrides a host supplies.
  */
-declare class PiscinaThinWorkflowProvider implements IWorkerNodeProvider {
+declare class PiscinaThinWorkflowProvider implements IWorkerProvider {
   private readonly options;
   /** Execution environment tag used for pool provider matching. */
   readonly environment: "piscina";
@@ -1777,7 +1802,7 @@ declare class PiscinaThinWorkflowProvider implements IWorkerNodeProvider {
    */
   readonly allocationLifetime: "provisioner-process-bound";
   /** Capabilities advertised to the pool dispatch selector. */
-  readonly baseCapabilities: NormalizedWorkerNodeCapabilities;
+  readonly baseCapabilities: NormalizedWorkerCapabilities;
   /**
    * @param options - Provider identity, runner, and optional capability overrides.
    */
@@ -1801,22 +1826,29 @@ declare class PiscinaThinWorkflowProvider implements IWorkerNodeProvider {
    * runner. Cancellation is never flattened into an outcome, so callers
    * can tell it apart from an ambiguous infrastructure rejection.
    *
-   * The return type is narrower than {@link IWorkerNodeProvider.provision}:
+   * The return type is narrower than {@link IWorkerProvider.provision}:
    * this provider allocates a local worker thread or rejects, and it has no
    * 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: WorkerNodeProvisionRequest, signal: AbortSignal): Promise<WorkerNodeAllocatedOutcome>;
+  provision(request: WorkerProvisionRequest, signal: AbortSignal): Promise<WorkerAllocatedOutcome>;
   /**
    * Submit a workflow outcome through the Authority bus protocol after
    * 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
@@ -1867,7 +1899,7 @@ interface InProcessWorkflowRunnerOptions {
  * In-process implementation of {@link IWorkflowRunner}.
  *
  * Executes a full workflow inside the calling process using the shared host
- * bus. Unlike the Piscina and WorkerNode runners, this runner does not spawn
+ * bus. Unlike the Piscina and Worker runners, this runner does not spawn
  * isolated processes or threads — the workflow orchestrator runs inline on the
  * caller's bus.
  *
@@ -1970,7 +2002,7 @@ type HeadlessWorkerBootstrapCredentials = WorkerBootstrapClaimResponse;
 /**
  * Bootstrap the worker by claiming execution-scoped bus credentials.
  *
- * Implementations issue `WorkerNodeSubjects.control['bootstrap.claim']`
+ * Implementations issue `WorkerSubjects.control['bootstrap.claim']`
  * against an unauthenticated or bootstrap-authenticated bus and return the
  * execution-scoped credentials for the authenticated connection.
  * @param signal - Cancellation signal. Abort rejects the bootstrap.
@@ -2102,12 +2134,18 @@ interface HeadlessWorkflowWorkerResult {
 /**
  * Run a single workflow execution through the portable headless worker harness.
  *
- * Kernel readiness is emitted by `createIsolatedWorkflowRuntime` internally;
- * attempt-ready follows after the runtime cancellation handoff completes.
+ * 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.
  */
 declare function runHeadlessWorkflowWorker(deps: HeadlessWorkflowWorkerDeps, signal: AbortSignal): Promise<HeadlessWorkflowWorkerResult>;
@@ -2174,4 +2212,230 @@ 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, WorkerNodeRunnerOptions 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, WorkerNodeRunner 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.
+ * @returns The installed endpoint: a generation binder and its cleanup.
+ */
+declare function installOperationDeliveryEndpoint(bus: IMakaioBus, identity: OperationDeliveryEndpointIdentity, handlers: OperationDeliveryHandlers): 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);
+}
+/**
+ * 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. */
+  readonly executionAttemptId: string;
+  /** Identifier of this concrete runtime incarnation, unique per boot. */
+  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.
+ *
+ * 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; the only refusal retried here is `not-allocated`, and
+ * only inside the allocation-visibility window described at
+ * {@link ALLOCATION_VISIBILITY_DEADLINE_MS}.
+ *
+ * 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
+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 };