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

package/dist/{index-C6aSnO8m.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, 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 { 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";
@@ -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. */
@@ -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.
@@ -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;
   /**
@@ -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: 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 +1774,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 +1831,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 +1846,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
@@ -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, 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.
+ * @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 };

package/dist/{index-DXtQRehh.d.mts → index-BKIxdzIw.d.mts}

@@ -90,8 +90,8 @@ declare const ClientSchemas: {
       projectDir: z.ZodOptional<z.ZodString>;
       configInheritance: z.ZodOptional<z.ZodEnum<{
         empty: "empty";
-        "auth-only": "auth-only";
         full: "full";
+        "auth-only": "auth-only";
       }>>;
     }, z.core.$strip>;
     response: z.ZodObject<{
@@ -507,8 +507,8 @@ declare const ClientSchemas: {
     machineId: z.ZodOptional<z.ZodString>;
     startMode: z.ZodOptional<z.ZodEnum<{
       fork: "fork";
-      resume: "resume";
       fresh: "fresh";
+      resume: "resume";
       clear: "clear";
       compact: "compact";
     }>>;
@@ -1487,8 +1487,8 @@ declare const CLIENT_SESSION_START_MODES: readonly ["fresh", "fork", "resume", "
 /** Zod schema for the client-reported session start mode. */
 declare const ClientSessionStartModeSchema: z.ZodEnum<{
   fork: "fork";
-  resume: "resume";
   fresh: "fresh";
+  resume: "resume";
   clear: "clear";
   compact: "compact";
 }>;
@@ -1506,8 +1506,8 @@ declare const ClientSessionStartedSchema: z.ZodObject<{
   machineId: z.ZodOptional<z.ZodString>;
   startMode: z.ZodOptional<z.ZodEnum<{
     fork: "fork";
-    resume: "resume";
     fresh: "fresh";
+    resume: "resume";
     clear: "clear";
     compact: "compact";
   }>>;
@@ -1676,8 +1676,8 @@ declare const ClientNamespace: _$_makaio_core0.BusNamespaceDefinition<"client",
       projectDir: _$zod.ZodOptional<_$zod.ZodString>;
       configInheritance: _$zod.ZodOptional<_$zod.ZodEnum<{
         empty: "empty";
-        "auth-only": "auth-only";
         full: "full";
+        "auth-only": "auth-only";
       }>>;
     }, _$zod_v4_core0.$strip>;
     response: _$zod.ZodObject<{
@@ -2077,8 +2077,8 @@ declare const ClientNamespace: _$_makaio_core0.BusNamespaceDefinition<"client",
     machineId: _$zod.ZodOptional<_$zod.ZodString>;
     startMode: _$zod.ZodOptional<_$zod.ZodEnum<{
       fork: "fork";
-      resume: "resume";
       fresh: "fresh";
+      resume: "resume";
       clear: "clear";
       compact: "compact";
     }>>;
@@ -2316,8 +2316,8 @@ declare const ClientSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSu
       projectDir: _$zod.ZodOptional<_$zod.ZodString>;
       configInheritance: _$zod.ZodOptional<_$zod.ZodEnum<{
         empty: "empty";
-        "auth-only": "auth-only";
         full: "full";
+        "auth-only": "auth-only";
       }>>;
     }, _$zod_v4_core0.$strip>;
     response: _$zod.ZodObject<{
@@ -2717,8 +2717,8 @@ declare const ClientSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSu
     machineId: _$zod.ZodOptional<_$zod.ZodString>;
     startMode: _$zod.ZodOptional<_$zod.ZodEnum<{
       fork: "fork";
-      resume: "resume";
       fresh: "fresh";
+      resume: "resume";
       clear: "clear";
       compact: "compact";
     }>>;
@@ -2979,8 +2979,8 @@ declare const SessionConfigEnvSchema: z.ZodRecord<z.ZodString, z.ZodString>;
  */
 declare const SessionConfigInheritanceSchema: z.ZodEnum<{
   empty: "empty";
-  "auth-only": "auth-only";
   full: "full";
+  "auth-only": "auth-only";
 }>;
 type SessionConfigInheritance = z.infer<typeof SessionConfigInheritanceSchema>;
 /**
@@ -3137,8 +3137,8 @@ declare const ClientSessionConfigSchemas: {
       projectDir: z.ZodOptional<z.ZodString>;
       configInheritance: z.ZodOptional<z.ZodEnum<{
         empty: "empty";
-        "auth-only": "auth-only";
         full: "full";
+        "auth-only": "auth-only";
       }>>;
     }, z.core.$strip>;
     response: z.ZodObject<{
@@ -3193,8 +3193,8 @@ declare const SessionConfigSetupRequestSchema: z.ZodObject<{
   }>;
   configInheritance: z.ZodEnum<{
     empty: "empty";
-    "auth-only": "auth-only";
     full: "full";
+    "auth-only": "auth-only";
   }>;
 }, z.core.$strip>;
 type SessionConfigSetupRequest = z.infer<typeof SessionConfigSetupRequestSchema>;

package/dist/{index-CmwAJ8-5.d.mts → index-CFI6FxC7.d.mts}

@@ -58,9 +58,9 @@ declare const StructuredOutputValidationErrorSchema: z.ZodObject<{
  * - `enforced` – A structured-output enforcement handler produced conformant output.
  */
 declare const StructuredOutputValidationStatusSchema: z.ZodEnum<{
+  failed: "failed";
   passed: "passed";
   enforced: "enforced";
-  failed: "failed";
 }>;
 /**
  * Full validation result emitted after a turn completes when a

package/dist/{index-DI2lS7VT.d.mts → index-CVcG4Q3X.d.mts}

@@ -1,16 +1,16 @@
-import { G as ArtifactLifecycleHookRegistration$1, N as AnyArtifactKindDefinition, W as ArtifactLifecycleHookEvent } from "./index-DNI6UF9h.mjs";
+import { G as ArtifactLifecycleHookRegistration$1, N as AnyArtifactKindDefinition, W as ArtifactLifecycleHookEvent } from "./index-I5a37JCm.mjs";
 import { s as AdapterProviderAuth$1 } from "./adapter-binding-CATvmGuz.mjs";
 import { i as ExtensionService$1, n as NodeExtensionContext$1, t as ExtensionContext$1 } from "./extension-context-QmFuHdq5.mjs";
 import { t as ExtensionAutomationTriggersContribution } from "./contribution-CUHLVLsT.mjs";
-import { n as ExtensionTransitionRulesContribution, t as ExtensionTransitionActionsContribution, v as WorkflowBlockCollection$1 } from "./transition-D3zUBTPc.mjs";
+import { n as ExtensionTransitionRulesContribution, t as ExtensionTransitionActionsContribution, v as WorkflowBlockCollection$1 } from "./transition-DxsrTsn4.mjs";
 import { E as ClientDefinition$1, Q as VersionLiteral$1, et as VersionRange, f as ExtensionClientHookResponsesContribution } from "./hook-responses-9Ywsqzzq.mjs";
 import { c as ProviderDefinitionInput$1, r as ProtocolId$1 } from "./definition-BrgzUuFk.mjs";
 import { t as RequiredTimeoutConfig } from "./index-l01zsChf.mjs";
-import { Qt as SESSION_EVENT_TYPES, bn as SessionMessage$1, i as MakaioSessionEvent$1 } from "./types-DcxBYlPA.mjs";
-import { D as EntityUIConfig$1, I as FormFieldProps } from "./index-CmwAJ8-5.mjs";
+import { Qt as SESSION_EVENT_TYPES, bn as SessionMessage$1, i as MakaioSessionEvent$1 } from "./types-Czdm5op1.mjs";
+import { D as EntityUIConfig$1, I as FormFieldProps } from "./index-CFI6FxC7.mjs";
 import { l as FacetNamespaceDefinition } from "./index-BuMsrli0.mjs";
 import { t as ExtensionReactionsContribution } from "./index-B0VO0rAl.mjs";
-import { G as SurfaceBindingDefinition, p as ExtensionArtifactViewBuildersContribution } from "./view-builder-B0j9p5C0.mjs";
+import { G as SurfaceBindingDefinition, p as ExtensionArtifactViewBuildersContribution } from "./view-builder-D-Wz_l_B.mjs";
 import { z } from "zod";
 import { MakaioBusLike, PayloadFilter, RegistrableBusNamespaceDefinition, SubjectSchema } from "@makaio/framework/core";
 import * as _$_makaio_contracts0 from "@makaio/framework/contracts";

package/dist/{index-DHH-93YD.d.mts → index-CYjgoYeX.d.mts}

@@ -1,5 +1,5 @@
 import { i as CliContribution } from "./types-tyv0B605.mjs";
-import { c as ExtensionInfo } from "./index-6trZYnUP2.mjs";
+import { c as ExtensionInfo } from "./index-8NdPPzUh2.mjs";
 import { r as WindowRegistry } from "./window-registry-Pcf35cac.mjs";
 import { IMakaioBus } from "@makaio/framework/bus";
 import { ExtensionContributionProcessor, ExtensionService, ExtensionToken, MakaioExtension, NodeExtensionContext, StorageDialect, TrayManifest, VersionLiteral } from "@makaio/framework/contracts";