@makaio/framework 1.0.0-dev-1784889676396 → 1.0.0-dev-1785344643235

package/dist/{index-pjATMrvJ.d.mts → index-DkiTJM5p.d.mts}

@@ -1,7 +1,7 @@
-import { r as ExtensionDiscovery } from "./extension-discovery-B6p3iZaV.mjs";
+import { r as ExtensionDiscovery } from "./extension-discovery-CQRdbVQ6.mjs";
 import { RegistrableBusNamespaceDefinition } from "@makaio/framework/core";
 import { BusTransport, IMakaioBus, SubjectTelemetryProjectorRegistry } from "@makaio/framework/bus";
-import { ExtensionConfigProvider, IWorkerNodeProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, LoopGateHandler, NormalizedWorkerNodeCapabilities, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerContributionManifest, WorkerNodeCapabilities, WorkerNodeDispatch, WorkerNodeHandle, WorkerNodeProvisionRequest, WorkerNodeRequirements, WorkflowDefinition, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas } from "@makaio/framework/contracts";
+import { ExtensionConfigProvider, IWorkerNodeProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, LoopGateHandler, 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 { DispatchingAuth, TransportAuth } from "@makaio/framework/node/transports";
 import { StorageEngine } from "@makaio/framework/storage/drizzle";
 import { Toolset } from "@makaio/framework/tools";
@@ -13,6 +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 { Server } from "node:http";
 
 //#region runtimes/node/src/compose-adapter-runtime.d.ts
@@ -500,6 +501,190 @@ interface WorkflowWorkerEntryResolverOptions {
  */
 declare function resolveWorkflowWorkerEntry(options: WorkflowWorkerEntryResolverOptions): string;
 //#endregion
+//#region runtimes/node/src/workflow-worker/local-directory-materializer.d.ts
+/**
+ * Host-injected resolver that maps a portable `workspaceId` to an
+ * allowed local root directory.
+ *
+ * The framework never guesses workspace locations. Product code or the
+ * host process supplies a resolver that knows which workspace IDs map
+ * to which filesystem roots. The resolver must return an absolute path
+ * that the caller is allowed to use as a workspace root.
+ *
+ * Returning `undefined` indicates the workspace ID is unknown or not
+ * allowed on this Authority.
+ * @param workspaceId - Portable workspace identifier from the materialization spec.
+ * @returns Absolute path to the allowed workspace root, or `undefined`.
+ */
+type WorkspaceRootResolver = (workspaceId: string) => Promise<string | undefined>;
+/**
+ * Error thrown when local-directory materialization fails a
+ * containment, digest, or contribution verification check.
+ *
+ * All materialization verification failures use this error type
+ * so callers can distinguish verification errors from I/O errors.
+ */
+declare class MaterializationError extends Error {
+  readonly code: 'unknown-workspace' | 'containment-violation' | 'symlink-escape' | 'unsupported-filesystem-entry' | 'digest-mismatch' | 'snapshot-id-mismatch' | 'source-path-mismatch' | 'source-missing' | 'contribution-missing' | 'contribution-integrity-mismatch' | 'contribution-version-mismatch' | 'contribution-entrypoint-mismatch' | 'unsupported-materialization-kind';
+  /**
+   * @param message - Human-readable description of the verification failure.
+   * @param code - Machine-readable failure code for structured handling.
+   */
+  constructor(message: string, code: 'unknown-workspace' | 'containment-violation' | 'symlink-escape' | 'unsupported-filesystem-entry' | 'digest-mismatch' | 'snapshot-id-mismatch' | 'source-path-mismatch' | 'source-missing' | 'contribution-missing' | 'contribution-integrity-mismatch' | 'contribution-version-mismatch' | 'contribution-entrypoint-mismatch' | 'unsupported-materialization-kind');
+}
+/**
+ * Verify that a resolved path stays within the allowed root directory.
+ *
+ * Both `resolvedPath` and `root` are compared after `path.resolve` so
+ * relative segments and trailing separators are normalized.
+ *
+ * Exported for reuse by product materializers (e.g. workspace-snapshot)
+ * that share the same containment invariants.
+ * @param resolvedPath - Absolute path to verify.
+ * @param root - Allowed root directory.
+ * @param label - Human-readable label for error messages.
+ * @throws {@link MaterializationError} with `containment-violation` when the path escapes the root.
+ */
+declare function assertContainedIn(resolvedPath: string, root: string, label: string): void;
+/**
+ * Resolve a path and verify it does not escape the root via symlinks.
+ *
+ * Uses `fs.realpath` to follow all symbolic links, then checks that
+ * the real path is still within the allowed root.
+ *
+ * Exported for reuse by product materializers (e.g. workspace-snapshot)
+ * that share the same symlink-escape invariants.
+ * @param targetPath - Absolute path to verify (may contain symlinks).
+ * @param root - Allowed root directory.
+ * @param label - Human-readable label for error messages.
+ * @param preResolvedRoot - Optional pre-resolved real path of the root
+ *   directory. When provided, skips the `fs.realpath(root)` call — useful
+ *   when the caller already resolved the root once per materialization.
+ * @returns The real (symlink-resolved) absolute path.
+ * @throws {@link MaterializationError} with `symlink-escape` when symlinks lead outside the root.
+ */
+declare function assertNoSymlinkEscape(targetPath: string, root: string, label: string, preResolvedRoot?: string): Promise<string>;
+/**
+ * Parsed SRI integrity string with algorithm and Base64-encoded digest.
+ *
+ * Exported for reuse by product materializers that need to verify
+ * contribution integrity.
+ */
+interface ParsedSriIntegrity {
+  /** Hash algorithm extracted from the SRI prefix (e.g. `sha384`). */
+  readonly algorithm: string;
+  /** Base64-encoded digest extracted from the SRI suffix. */
+  readonly digest: string;
+}
+/**
+ * Parse an SRI integrity string into its hash algorithm and expected digest.
+ *
+ * Exported for reuse by product materializers that need to verify
+ * contribution integrity outside the local-directory materializer.
+ * @param integrity - SRI-format integrity string (e.g. `sha384-abc123`).
+ * @returns Parsed algorithm and Base64-encoded digest.
+ */
+declare function parseSriIntegrity(integrity: string): ParsedSriIntegrity;
+/**
+ * Compute an SRI-format integrity hash of a file's contents.
+ *
+ * Exported for reuse by product materializers and manifest resolvers
+ * that need to compute SRI integrity for contribution entrypoints.
+ * @param filePath - Absolute path to the file.
+ * @param algorithm - Hash algorithm (e.g. `sha384`).
+ * @returns Base64-encoded digest of the file contents.
+ */
+declare function computeFileDigest(filePath: string, algorithm: string): Promise<string>;
+/**
+ * Compute an SRI digest for the complete installed contribution package.
+ *
+ * The digest covers every regular file beneath the package root, including
+ * package.json and transitive helper modules. Paths are sorted and framed
+ * with their contents to make the result deterministic across filesystem
+ * enumeration order. Nested node_modules, Git metadata, and .DS_Store are
+ * explicitly excluded because they are not part of the package artifact.
+ *
+ * Symbolic links are rejected rather than followed: following one could make
+ * the package identity depend on content outside its declared boundary.
+ * @param packageRoot - Absolute installed package directory.
+ * @param algorithm - Hash algorithm named by the SRI reference.
+ * @returns SRI-format digest of the complete contribution package contents.
+ * @throws MaterializationError when the package contains a symbolic link or
+ * unsupported filesystem entry.
+ */
+declare function computeContributionPackageDigest(packageRoot: string, algorithm: string): Promise<string>;
+/**
+ * Compute an SRI-format integrity hash of a directory by hashing a
+ * deterministic representation of its contents.
+ *
+ * Walks the directory recursively, sorts entries by relative path,
+ * and feeds each file's content into the hash. This produces a
+ * stable, reproducible digest regardless of filesystem order. Git metadata
+ * and dependency directories are excluded, but every other entry must be a
+ * regular file or directory so no unverified filesystem object can affect
+ * workflow execution.
+ * @param dirPath - Absolute path to the directory.
+ * @param algorithm - Hash algorithm (e.g. `sha256`).
+ * @returns SRI-format integrity string (e.g. `sha256-abc123`).
+ */
+declare function computeDirectoryDigest(dirPath: string, algorithm?: string): Promise<string>;
+/**
+ * Resolve a contribution package to an absolute entrypoint path within
+ * the workspace root and verify its identity, version, and integrity.
+ *
+ * Reads the contribution's `package.json` to verify package name and
+ * version, then computes the SRI hash of the complete package contents and
+ * compares it to the expected integrity.
+ *
+ * Exported for reuse by product materializers (e.g. workspace-snapshot)
+ * that need the same contribution verification pipeline.
+ * @param ref - Portable contribution reference.
+ * @param workspaceRoot - Absolute workspace root path.
+ * @param preResolvedRoot - Optional pre-resolved real path of the workspace
+ *   root. When provided, skips redundant `fs.realpath` calls on the root —
+ *   useful when the caller already resolved it once per materialization.
+ * @returns Absolute path to the verified entrypoint file.
+ * @throws {@link MaterializationError} on identity, version, entrypoint, or integrity mismatch.
+ */
+declare function verifyContribution(ref: WorkerContributionRef, workspaceRoot: string, preResolvedRoot?: string): Promise<string>;
+/**
+ * Options for creating a local-directory materializer.
+ */
+interface LocalDirectoryMaterializerOptions {
+  /**
+   * Host-injected resolver that maps workspace IDs to allowed local roots.
+   *
+   * Framework code never guesses workspace locations. Product code supplies
+   * a resolver that knows which workspace IDs map to which filesystem
+   * roots for this Authority instance.
+   */
+  readonly resolveWorkspaceRoot: WorkspaceRootResolver;
+}
+/**
+ * Materialize a `local-directory` spec into a verified {@link WorkerRuntimeContext}.
+ *
+ * Performs the following verification steps:
+ * 1. Resolve the workspace ID to an allowed local root via the injected resolver.
+ * 2. Verify the workspace root exists and is a directory.
+ * 3. Check that the source path is contained within the workspace root.
+ * 4. Verify no symlink escapes the workspace root.
+ * 5. Verify the workspace root digest matches the expected value.
+ * 6. Verify the source file exists.
+ * 7. For each contribution: verify package identity, version, entrypoint containment,
+ *    and SRI integrity.
+ *
+ * This function is idempotent: calling it again with the same spec returns an
+ * equivalent context (or an error if the filesystem has changed).
+ * @param spec - Local-directory materialization spec from the run context.
+ * @param contributions - Portable contribution references to verify.
+ * @param options - Materializer options with the injected workspace root resolver.
+ * @returns Verified worker-local runtime context with absolute paths.
+ * @throws {@link MaterializationError} on any verification failure.
+ */
+declare function materializeLocalDirectory(spec: Extract<WorkerMaterializationSpec, {
+  kind: 'local-directory';
+}>, contributions: readonly WorkerContributionRef[], options: LocalDirectoryMaterializerOptions): Promise<WorkerRuntimeContext>;
+//#endregion
 //#region runtimes/node/src/boot-types.d.ts
 /** Dev-mode map from npm package name to absolute workspace package directory. */
 type DevPortalMap = ReadonlyMap<string, string>;
@@ -534,7 +719,8 @@ type WorkflowRunnerBootOptions = {
   /** Use the Node runtime's concrete in-process workflow runner. */readonly mode?: 'in-process';
 } | {
   /** Dispatch full workflow executions to a Piscina worker-thread pool. */readonly mode: 'piscina'; /** Contribution manifest loaded inside isolated workers. */
-  readonly manifest?: WorkerContributionManifest; /** Explicit worker entry path. Overrides workerEntryMode resolution. */
+  readonly manifest?: WorkerContributionManifest; /** Host-owned resolver for portable local-directory workspace IDs. */
+  readonly resolveWorkspaceRoot?: WorkspaceRootResolver; /** Explicit worker entry path. Overrides workerEntryMode resolution. */
   readonly workerEntry?: string; /** Source/dist worker entry mode used when workerEntry is omitted. */
   readonly workerEntryMode?: WorkflowWorkerEntryMode; /** Maximum concurrent worker threads. */
   readonly maxConcurrency?: number; /** Idle timeout before worker threads are reaped. */
@@ -824,6 +1010,28 @@ interface CoreBootOptions {
    * that runs the workflow worker entry end-to-end.
    */
   readonly workflowRunner?: WorkflowRunnerBootOptions;
+  /**
+   * Host-owned allowed-root resolver for local Piscina execution.
+   *
+   * This is intentionally a boot seam rather than persisted workflow state:
+   * it maps the portable workspace ID to a directory that this host is
+   * permitted to realize.
+   */
+  readonly piscinaWorkspaceRootResolver?: WorkspaceRootResolver;
+  /** Host-owned resolvers that create portable specs for path-backed workflow starts. */
+  readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
+  /**
+   * Injected execution attempt persistence port for WorkerNode dispatch.
+   *
+   * Required when `workflowRunner.mode` is `'worker-node'`. 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
+   * is not provided.
+   */
+  readonly executionAttemptRepository?: ExecutionAttemptRepository;
   /**
    * Runtime data home for config, database, machine identity, and installed
    * extensions. Defaults to the `MAKAIO_HOME` environment override when set,
@@ -998,6 +1206,15 @@ interface MakaioRuntime {
   readonly coordinator: ExtensionCoordinator;
   /**
    * Shut down all services in reverse startup order.
+   *
+   * Every step is attempted even when an earlier one fails, and the failures
+   * are then reported together. A host that owns process termination must
+   * treat the rejection as an unclean exit — something the runtime started is
+   * still holding resources it could not release — rather than logging it and
+   * exiting as if the drain had completed.
+   * @returns Promise that settles once every step has been attempted, resolving
+   *   on success and rejecting with an AggregateError when any step fails.
+   * @throws An AggregateError when any shutdown step failed.
    */
   shutdown(): Promise<void>;
 }
@@ -1033,6 +1250,14 @@ interface ThinWorkflowPiscinaRunnerOptions {
   readonly workerEntry: string;
   /** Contribution manifest declaring which extension packages to load in workers. */
   readonly manifest: WorkerContributionManifest;
+  /**
+   * Host-owned resolver for portable local-directory workspace IDs.
+   *
+   * Required when a Piscina task has a path-backed source or declared worker
+   * contributions. The runner realizes those portable references before it
+   * transfers the task to a worker thread.
+   */
+  readonly resolveWorkspaceRoot?: WorkspaceRootResolver;
   /** Maximum concurrent worker threads. @defaultValue 4 */
   readonly maxConcurrency?: number;
   /** Idle timeout before threads are reaped (ms). @defaultValue 30000 */
@@ -1090,9 +1315,9 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
    * @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.
-   * @returns Execution result with terminal status and status-specific result fields.
+   * @returns Uncommitted completion; the host executor owns finalization.
    */
-  run(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest): Promise<WorkflowRunResult$1>;
+  run(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest): Promise<WorkflowRunnerCompletion$1>;
   /**
    * Execute a workflow and expose the worker bus readiness signal separately.
    *
@@ -1110,6 +1335,16 @@ declare class ThinWorkflowPiscinaRunner implements IWorkflowRunner$1 {
    * Destroy the thread pool and release all worker threads.
    */
   dispose(): Promise<void>;
+  /**
+   * 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.
+   * @param config - Portable worker configuration.
+   * @param manifest - Exact contribution identities for this execution.
+   * @param signal - Cancellation signal for the dispatch.
+   * @returns A worker-thread task containing verified local paths.
+   */
+  private materializeTask;
 }
 //#endregion
 //#region runtimes/node/src/workflow-worker/node-workflow-runner-factory.d.ts
@@ -1133,6 +1368,16 @@ interface CreateNodeWorkflowRunnerPackageOptionsParams {
    * dispatch function is supplied. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
+  /**
+   * Injected execution attempt persistence port.
+   *
+   * Required when `workflowRunner.mode` is `'worker-node'`. Threaded
+   * through to the workflow engine service options so the Authority
+   * service can delegate durable decisions.
+   */
+  readonly executionAttemptRepository?: ExecutionAttemptRepository;
+  /** Host-owned resolvers for portable path-backed workflow starts. */
+  readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
 /** Workflow engine package options produced by Node runtime composition. */
 interface NodeWorkflowRunnerPackageOptions {
@@ -1149,6 +1394,23 @@ interface NodeWorkflowRunnerPackageOptions {
     readonly platformDefaults: StepRunnerPlatformDefaults; /** Makaio data-home path forwarded to workflow workers. */
     readonly makaioHome?: string;
   };
+  /**
+   * Injected execution attempt persistence port.
+   *
+   * Present only when the workflow runner uses WorkerNode dispatch mode.
+   * Forwarded to the workflow engine service for Authority construction.
+   */
+  readonly executionAttemptRepository?: ExecutionAttemptRepository;
+  /**
+   * Execution attempt Authority constructed from the injected repository.
+   *
+   * Present only when the workflow runner uses WorkerNode dispatch mode.
+   * Shared between the runner (for attempt creation before dispatch) and
+   * the workflow engine service (for outcome commitment).
+   */
+  readonly executionAttemptAuthority?: ExecutionAttemptAuthority;
+  /** Host-owned resolvers forwarded to the workflow engine service. */
+  readonly workflowMaterializationSpecResolvers?: readonly WorkflowMaterializationSpecResolver[];
 }
 /**
  * Compose workflow engine options for workflow-level execution.
@@ -1175,6 +1437,13 @@ interface CreateNodeWorkflowRunnerParams {
    * function is supplied. Ignored for Piscina mode.
    */
   readonly bus?: IMakaioBus;
+  /**
+   * Execution attempt Authority injected into WorkerNode runners.
+   *
+   * Required when `runner.mode` is `'worker-node'`. The runner uses this
+   * to create attempts before dispatch and wait for committed outcomes.
+   */
+  readonly authority?: ExecutionAttemptAuthority;
 }
 /**
  * Create a workflow-level runner based on the Node runtime configuration.
@@ -1199,6 +1468,14 @@ interface WorkerNodeRunnerOptions {
    * Framework code calls through this seam without coupling to any pool.
    */
   readonly dispatch: WorkerNodeDispatch;
+  /**
+   * Execution attempt Authority used to create attempts before dispatch and
+   * wait for committed outcomes after dispatch returns.
+   *
+   * Required for authority-committed completions. When absent, the runner
+   * cannot create attempts or wait for durable outcomes.
+   */
+  readonly authority: ExecutionAttemptAuthority;
   /**
    * Extension contribution manifest forwarded to dispatched workers.
    *
@@ -1222,27 +1499,144 @@ interface WorkerNodeRunnerOptions {
  * product-agnostic. Concrete dispatch behavior (e.g. pool selection, provider
  * matching, manifest resolution) lives in the product-owned composition root
  * or `workerPool.dispatch` handler, not here.
+ *
+ * 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 {
   private readonly options;
   /**
-   * @param options - Dispatch seam, optional manifest, and optional requirements.
+   * @param options - Dispatch seam, authority, optional manifest, and optional requirements.
    */
   constructor(options: WorkerNodeRunnerOptions);
   /**
    * Execute a complete workflow by delegating to the injected dispatch seam.
    *
+   * Creates an execution attempt through the Authority before dispatch. After
+   * the dispatch completes (allocation acceptance), waits for the committed
+   * outcome through the Authority's in-process waiter. Returns an
+   * `authority-committed` completion so the host executor skips fallback
+   * finalization.
+   *
    * When `manifest` is supplied it takes precedence over the manifest baked into
    * the runner at construction time, enabling per-call contribution sets.
    * @param config - Full workflow worker configuration including source, inputs, and bus info.
    * @param signal - AbortSignal for cooperative cancellation forwarded to the dispatch function.
    * @param manifest - Optional per-call contribution manifest. Overrides the runner's default.
    * @param options - Optional per-run controls forwarded to dispatch-capable providers.
-   * @returns The execution result with terminal status and status-specific result fields.
+   * @returns Authority-committed completion after the outcome RPC converges.
    */
-  run(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest, options?: WorkflowRunnerRunOptions): Promise<WorkflowRunResult>;
+  run(config: WorkflowWorkerConfig, signal: AbortSignal, manifest?: WorkerContributionManifest, options?: WorkflowRunnerRunOptions): Promise<WorkflowRunnerCompletion>;
 }
 //#endregion
+//#region runtimes/node/src/workflow-worker/outcome-submission.d.ts
+/**
+ * Tunable retry parameters for outcome submission.
+ *
+ * All fields are optional; the harness supplies sane defaults when
+ * the caller omits them.
+ */
+interface OutcomeSubmitRetryConfig {
+  /**
+   * Maximum number of retry attempts after the first submission
+   * attempt fails (total attempts = maxRetries + 1).
+   * Defaults to 7.
+   */
+  readonly maxRetries?: number;
+  /**
+   * Base delay in milliseconds for exponential back-off between
+   * retry attempts. The actual delay for attempt N is
+   * `baseDelayMs * 2^(N-1)`, capped at {@link maxDelayMs}.
+   * Defaults to 1000.
+   */
+  readonly baseDelayMs?: number;
+  /**
+   * Maximum delay in milliseconds for any single back-off pause.
+   * Defaults to 30000.
+   */
+  readonly maxDelayMs?: number;
+  /**
+   * Overall deadline in milliseconds from the first attempt.
+   * The helper bounds every retry wait, reconnect, and request to
+   * this deadline, even if maxRetries has not been reached.
+   * Defaults to 120000.
+   */
+  readonly deadlineMs?: number;
+}
+/**
+ * Payload for an outcome submission request.
+ */
+interface OutcomeSubmitPayload {
+  readonly executionAttemptId: string;
+  readonly executionId: string;
+  readonly result: WorkflowRunResult;
+}
+/**
+ * Outcome ACK decisions that confirm durable delivery.
+ *
+ * Only `accepted` and `duplicate` mean the Authority has committed
+ * (or already had) the canonical outcome.
+ */
+declare const DELIVERED_DECISIONS: Set<OutcomeAckDecision>;
+/**
+ * Reason an outcome could not be delivered.
+ */
+type OutcomeDeliveryFailureReason = 'authority-rejected' | 'deadline-exceeded';
+/**
+ * Error thrown when the Authority rejects an outcome with a non-transient
+ * decision (`conflict` or `fenced`), or when its overall delivery deadline
+ * expires.
+ */
+declare class OutcomeDeliveryError extends Error {
+  readonly decision: OutcomeAckDecision | 'deadline-exceeded';
+  readonly result: WorkflowRunResult;
+  readonly reason: OutcomeDeliveryFailureReason;
+  /**
+   * @param decision - The Authority's rejection decision or deadline marker.
+   * @param result - The immutable workflow result that was rejected.
+   * @param reason - Stable classification of the delivery failure.
+   */
+  constructor(decision: OutcomeAckDecision | 'deadline-exceeded', result: WorkflowRunResult, reason?: OutcomeDeliveryFailureReason);
+}
+/**
+ * Optional reconnect callback invoked before each retry when the
+ * previous attempt failed with a transport-level error.
+ *
+ * Implementations should trigger a bus reconnect (e.g.
+ * `bus.reconnect()`) and return once the attempt has been initiated.
+ * Failures from the reconnect attempt are non-fatal; the next retry
+ * will naturally fail again if the transport is still down.
+ */
+type OutcomeReconnect = () => Promise<void>;
+/**
+ * Submit a workflow outcome for durable acknowledgement with
+ * decision-aware, reconnect-capable retry.
+ *
+ * Sends the immutable outcome via `control.outcome.submit` and retries
+ * with exponential back-off on transient failures. Only `accepted` and
+ * `duplicate` decisions count as successful delivery. `conflict` and
+ * `fenced` are non-transient infrastructure rejections that terminate
+ * immediately without further retries.
+ *
+ * On transport-level failures the helper invokes the optional
+ * reconnect callback before the next retry attempt, allowing the
+ * caller to re-establish the bus connection.
+ *
+ * Bounded-ness: a worker cannot wait indefinitely for delivery; if
+ * all retry attempts are exhausted, the helper throws the last transport
+ * error. The overall deadline bounds every wait, reconnect, and in-flight
+ * bus request; expiry throws a deterministic {@link OutcomeDeliveryError}.
+ * @param bus - Worker-local bus connected to the Authority.
+ * @param payload - Attempt identity and terminal result.
+ * @param options - Optional retry configuration and reconnect callback.
+ * @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>;
+//#endregion
 //#region runtimes/node/src/workflow-worker/piscina-thin-workflow-provider.d.ts
 /**
  * Construction options for {@link PiscinaThinWorkflowProvider}.
@@ -1256,33 +1650,98 @@ interface PiscinaThinWorkflowProviderOptions {
    * Underlying workflow runner used to execute incoming provision requests.
    *
    * Typically a {@link ThinWorkflowPiscinaRunner} instance, but any
-   * {@link IWorkflowRunner} implementation is accepted so tests can supply
-   * lightweight fakes without spawning real worker threads.
+   * {@link ReadinessAwareWorkflowRunner} implementation is accepted so tests
+   * 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.
    */
-  readonly runner: IWorkflowRunner;
+  readonly runner: ReadinessAwareWorkflowRunner;
+  /**
+   * Bus instance used to submit workflow outcomes through the Authority's
+   * durable `control.outcome.submit` protocol after the runner settles.
+   */
+  readonly bus: IMakaioBus;
   /**
    * Capabilities advertised when this provider is registered.
    *
    * Overrides are merged onto the built-in local, delegating workflow
    * capability set. The Piscina runner shares the host process filesystem and
    * delegates agent/subagent execution to the host runtime.
+   *
+   * `supportsRecovery` is omitted from this type rather than accepted and
+   * discarded. It is fixed by the allocation lifetime, so a host that sets it
+   * is stating something untrue about this provider and should be told at the
+   * call site instead of having the value silently dropped. See
+   * {@link PiscinaThinWorkflowProvider}.
+   */
+  readonly baseCapabilities?: Omit<Partial<WorkerNodeCapabilities>, 'supportsRecovery'>;
+  /**
+   * Optional retry configuration for outcome submission.
+   *
+   * The Piscina provider runs in-process, so the defaults are shorter
+   * than the headless worker's remote defaults: 3 retries, 200 ms base
+   * delay, 2 s cap, 10 s deadline.
    */
-  readonly baseCapabilities?: Partial<WorkerNodeCapabilities>;
+  readonly outcomeRetry?: OutcomeSubmitRetryConfig;
 }
 /**
- * Built-in thin workflow provider backed by the existing workflow-level Piscina runner.
+ * Runner variant that exposes the worker-thread composition readiness signal.
  *
- * This provider wraps an {@link IWorkflowRunner} so it can be registered with
- * the framework capability registry and participate in pool-driven dispatch.
- * Each {@link provision} call starts the underlying runner and returns a
- * {@link WorkerNodeHandle} that callers use to wait for the result or request
- * cancellation. Pool-level dispatch owns WorkerNode lifecycle events because it
- * also owns cancellation ordering and terminal state emission.
+ * Extends {@link IWorkflowRunner} because a readiness-aware runner is still a
+ * workflow runner; this provider only ever drives it through
+ * {@link runWithReadiness}, which is the sole path that can report an attempt
+ * as ready.
+ */
+interface ReadinessAwareWorkflowRunner extends IWorkflowRunner {
+  /**
+   * Run once and separately expose the worker's post-composition 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.
+   */
+  runWithReadiness(config: WorkerNodeProvisionRequest['workerConfig'], signal: AbortSignal, manifest?: WorkerNodeProvisionRequest['workerManifest']): ThinWorkflowPiscinaRunWithReadiness;
+}
+/**
+ * Built-in thin workflow provider backed by the existing workflow-level
+ * Piscina runner.
+ *
+ * This provider wraps an {@link IWorkflowRunner} so it can be registered
+ * 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}.
+ *
+ * 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.
+ *
+ * Piscina is a local thin workflow runner: it declares that it is NOT
+ * recoverable. Allocation references are process-local and non-durable.
+ *
+ * That declaration is a consequence of the allocation lifetime, not a
+ * configuration choice. Worker threads cannot outlive the process that
+ * provisioned them, so there is no allocation left to discover, attach to, or
+ * converge once that process is gone. The provider therefore implements no
+ * recovery capability, and `supportsRecovery` stays `false` regardless of the
+ * capability overrides a host supplies.
  */
 declare class PiscinaThinWorkflowProvider implements IWorkerNodeProvider {
   private readonly options;
   /** Execution environment tag used for pool provider matching. */
   readonly environment: "piscina";
+  /**
+   * Allocations are worker threads inside the provisioning process.
+   *
+   * When that process is gone the threads are gone with it, so there is
+   * nothing to rediscover or converge in provider infrastructure.
+   */
+  readonly allocationLifetime: "provisioner-process-bound";
   /** Capabilities advertised to the pool dispatch selector. */
   readonly baseCapabilities: NormalizedWorkerNodeCapabilities;
   /**
@@ -1294,16 +1753,66 @@ declare class PiscinaThinWorkflowProvider implements IWorkerNodeProvider {
   /** @returns Human-readable display name for this provider. */
   get displayName(): string;
   /**
-   * Provision a new isolated execution node for the given workflow request.
-   *
-   * Starts the underlying runner and returns a handle that the caller holds
-   * until the execution reaches a terminal state. Cancellation flows through
-   * the handle's `cancel` / `terminate` methods, which abort the internal
-   * `AbortController` wired to the runner's signal.
+   * Provision a new local execution allocation for the given workflow
+   * request.
+   *
+   * Starts the underlying runner and returns a validated allocation
+   * reference together with an infrastructure-only handle. The handle
+   * controls allocation lifecycle (cancel/terminate) via an internal
+   * {@link AbortController} wired to the runner's signal.
+   *
+   * Cooperative cancellation: if the caller's `signal` is already
+   * aborted, or becomes aborted before the runner starts, the provision
+   * rejects with the signal's own abort reason without starting the
+   * 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}:
+   * 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.
    * @param request - Full provision request containing worker config and manifest.
-   * @returns A handle for the provisioned node with wait, cancel, and terminate operations.
-   */
-  provision(request: WorkerNodeProvisionRequest): Promise<WorkerNodeHandle>;
+   * @param signal - AbortSignal for cooperative cancellation of the provision operation.
+   * @returns Allocated outcome with a validated allocation reference and infrastructure handle.
+   */
+  provision(request: WorkerNodeProvisionRequest, signal: AbortSignal): Promise<WorkerNodeAllocatedOutcome>;
+  /**
+   * 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.
+   *
+   * Uses the shared {@link submitOutcomeWithAck} helper for decision-aware
+   * retry with bounded exponential back-off. Since the Piscina provider
+   * runs in-process, a persistently failing local submit means the outcome
+   * handler is unregistered — an infrastructure failure that the host recovery
+   * coordinator reconciles via recovery operations.
+   * @param resultPromise - Promise resolving to the workflow run result.
+   * @param executionId - Workflow execution identifier.
+   * @param executionAttemptId - Authority-created attempt identifier.
+   * @param workflowId - Workflow definition identifier.
+   * @param onInfrastructureConclusion - Reports failed durable outcome delivery as terminal infrastructure evidence.
+   */
+  private submitOutcomeOnSettlement;
+  /**
+   * Build a process-local allocation reference validated by this
+   * provider's codec.
+   *
+   * The `providerData` carries the execution attempt ID and a monotonic
+   * timestamp for correlation/diagnostics. The reference is validated
+   * against {@link ProviderAllocationRefSchema} before return.
+   *
+   * The reference names this provider *instance*, not the built-in identifier
+   * this class is usually registered under. A reference identifies who created
+   * the allocation, and an attempt is bound to the instance that provisioned
+   * it, so a second instance stamping the built-in identifier would describe
+   * its allocations as another provider's.
+   * @param executionAttemptId - Authority-created attempt identifier.
+   * @returns Validated, versioned allocation reference.
+   */
+  private buildAllocationRef;
 }
 //#endregion
 //#region runtimes/node/src/workflow-worker/in-process-workflow-runner.d.ts
@@ -1353,9 +1862,9 @@ declare class InProcessWorkflowRunner implements IWorkflowRunner {
    * @param config - Workflow worker configuration to validate before execution.
    * @param signal - AbortSignal for cooperative cancellation.
    * @param _manifest - Ignored; in-process runners share the host contribution set.
-   * @returns The terminal workflow run result.
+   * @returns Uncommitted completion; the host executor owns finalization.
    */
-  run(config: WorkflowWorkerConfig, signal: AbortSignal, _manifest?: WorkerContributionManifest): Promise<WorkflowRunResult>;
+  run(config: WorkflowWorkerConfig, signal: AbortSignal, _manifest?: WorkerContributionManifest): Promise<WorkflowRunnerCompletion>;
 }
 //#endregion
 //#region runtimes/node/src/workflow-worker/isolated-workflow-runtime.d.ts
@@ -1416,6 +1925,159 @@ interface IsolatedWorkflowRuntime {
  */
 declare function createIsolatedWorkflowRuntime(options: CreateIsolatedWorkflowRuntimeOptions): Promise<IsolatedWorkflowRuntime>;
 //#endregion
+//#region runtimes/node/src/workflow-worker/headless-workflow-worker.d.ts
+/**
+ * Bootstrap credentials returned by a provider-specific claim exchange.
+ *
+ * The harness receives these credentials after a successful bootstrap claim
+ * and uses them to establish the authenticated bus connection.
+ */
+type HeadlessWorkerBootstrapCredentials = WorkerBootstrapClaimResponse;
+/**
+ * Bootstrap the worker by claiming execution-scoped bus credentials.
+ *
+ * Implementations issue `WorkerNodeSubjects.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.
+ * @returns Claimed credentials for the authenticated bus connection.
+ */
+type HeadlessWorkerBootstrap = (signal: AbortSignal) => Promise<HeadlessWorkerBootstrapCredentials>;
+/**
+ * Establish the authenticated bus connection for the worker.
+ *
+ * Called after bootstrap with the claimed credentials. The implementation
+ * registers a transport on the supplied bus and connects it.
+ * @param bus - Worker-local bus instance to connect.
+ * @param credentials - Credentials from the bootstrap claim.
+ * @param signal - Cancellation signal.
+ */
+type HeadlessWorkerBusConnector = (bus: IMakaioBus, credentials: HeadlessWorkerBootstrapCredentials, signal: AbortSignal) => Promise<void>;
+/**
+ * Result of materializing a portable run context into worker-local paths.
+ *
+ * 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.
+ */
+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.
+   */
+  readonly cleanup?: () => Promise<void>;
+}
+/**
+ * Materialize a portable run context into worker-local runtime context.
+ *
+ * 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 signal - Cancellation signal.
+ * @returns Materialized workspace with runtime context and optional cleanup.
+ */
+type HeadlessWorkerMaterializer = (runContext: WorkflowRunContext, signal: AbortSignal) => Promise<MaterializedWorkspace>;
+/**
+ * Load kernel extension packages from resolved contribution entrypoints.
+ *
+ * Called with the materialized runtime context after workspace resolution.
+ * @param runtimeContext - Materialized worker-local runtime context.
+ * @param signal - Cancellation signal.
+ * @returns Extension packages to activate in the isolated runtime.
+ */
+type HeadlessWorkerContributionLoader = (runtimeContext: WorkerRuntimeContext, signal: AbortSignal) => Promise<readonly KernelMakaioExtension[]>;
+/**
+ * Execute the workflow after runtime composition and readiness.
+ *
+ * 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 runtimeContext - Materialized worker-local runtime context.
+ * @param signal - Effective cancellation signal (combines caller + bus cancel).
+ * @returns Immutable terminal workflow run result.
+ */
+type HeadlessWorkerExecutor = (bus: IMakaioBus, runContext: WorkflowRunContext, runtimeContext: WorkerRuntimeContext, signal: AbortSignal) => Promise<WorkflowRunResult>;
+/**
+ * Optional post-commit observation callback.
+ *
+ * Invoked after the Authority durably acknowledges the outcome. Useful for
+ * writing local artifact files or emitting provider-specific completion signals.
+ * Failures are best-effort and must not replace the committed result.
+ * @param result - Immutable workflow result.
+ * @param decision - Durable ACK decision from the Authority.
+ */
+type HeadlessWorkerPostCommitObserver = (result: WorkflowRunResult, decision: OutcomeAckDecision) => Promise<void>;
+/**
+ * Injected dependencies for the headless workflow worker harness.
+ *
+ * Product code and provider wrappers supply implementations of these seams.
+ * The harness orchestrates their lifecycle without knowing about Git, GitHub,
+ * snapshot stores, or any product-specific concepts.
+ */
+interface HeadlessWorkflowWorkerDeps {
+  /** Unique workflow execution identifier. */
+  readonly executionId: string;
+  /** Authority-created attempt identifier. */
+  readonly executionAttemptId: string;
+  /** Claim execution-scoped bus credentials. */
+  readonly bootstrap: HeadlessWorkerBootstrap;
+  /** Establish the authenticated bus connection. */
+  readonly connectBus: HeadlessWorkerBusConnector;
+  /** Materialize the portable spec into worker-local context. */
+  readonly materialize: HeadlessWorkerMaterializer;
+  /** Load contribution packages from materialized entrypoints. */
+  readonly loadContributions: HeadlessWorkerContributionLoader;
+  /** Execute the workflow on the composed runtime. */
+  readonly execute: HeadlessWorkerExecutor;
+  /** Adapter configuration repository for the isolated runtime. */
+  readonly configRepository: PrepareAdapterRuntimeInput['configRepository'];
+  /** Toolsets explicitly authorized for this runtime. */
+  readonly toolsets: readonly Toolset[];
+  /** Optional adapter auth preparation. */
+  readonly prepareAuthRuntime?: PrepareAdapterRuntimeInput['prepareAuthRuntime'];
+  /** Optional post-commit observation (e.g. artifact persistence). */
+  readonly onPostCommit?: HeadlessWorkerPostCommitObserver;
+  /**
+   * Optional retry configuration for outcome submission.
+   *
+   * Controls exponential back-off parameters, overall deadline, and
+   * maximum retry count. When omitted, sane defaults apply (7 retries,
+   * 1 s base delay, 30 s cap, 2 min deadline).
+   */
+  readonly outcomeRetry?: OutcomeSubmitRetryConfig;
+}
+/**
+ * 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.
+ */
+interface HeadlessWorkflowWorkerResult {
+  /** Immutable terminal workflow run result. */
+  readonly result: WorkflowRunResult;
+  /** Durable ACK decision from the Authority. */
+  readonly decision: OutcomeAckDecision;
+}
+/**
+ * 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.
+ * @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.
+ */
+declare function runHeadlessWorkflowWorker(deps: HeadlessWorkflowWorkerDeps, signal: AbortSignal): Promise<HeadlessWorkflowWorkerResult>;
+//#endregion
 //#region runtimes/node/src/workflow-worker/workflow-loader.d.ts
 /**
  * Resolve a {@link RuntimeLoadedWorkflow} from the parsed worker config.
@@ -1478,4 +2140,4 @@ declare function loadWorkflowModules(source: Exclude<WorkflowWorkerSource, {
  */
 declare function loadWorkflowModule(source: WorkflowWorkerSource): Promise<RuntimeLoadedWorkflow>;
 //#endregion
-export { HonoRouteGraph as $, TransportReadyInfo as A, HostCapabilityDeclaration as B, ThinWorkflowPiscinaRunnerOptions as C, CoreBootOptions as D, BootMakaioRuntimeOptions as E, resolveWorkflowWorkerEntry as F, FrameworkModuleResolver as G, selectFrameworkCorePackages as H, DatabaseBootOptions as I, resolveFrameworkSpecifier as J, NodeFrameworkModuleResolver as K, InitializeNodeDatabaseOptions as L, WorkflowRunnerBootOptions as M, WorkflowWorkerEntryMode as N, MakaioRuntime as O, WorkflowWorkerEntryResolverOptions as P, HttpRouteContribution as Q, InitializeNodeDatabaseResult as R, RuntimeLoadedWorkflow as S, BootCoordinatorSetupContext as T, ShutdownStep as U, normalizeNodeHostCapabilities as V, BridgeBrowserOptions as W, createHttpRouteGraphBuilder as X, HttpRouteGraphBuilder as Y, HttpContributionPhase as Z, NodeWorkflowRunnerPackageOptions as _, IsolatedWorkflowRuntime as a, PreparedAdapterRuntime as at, ThinWorkflowPiscinaRunner as b, WorkflowRuntimeContributionLoader as c, InProcessWorkflowRunnerOptions as d, HonoRouteGraphOptions as et, PiscinaThinWorkflowProvider as f, CreateNodeWorkflowRunnerPackageOptionsParams as g, WorkerNodeRunnerOptions as h, CreateIsolatedWorkflowRuntimeOptions as i, PrepareAdapterRuntimeInput as it, UpstreamTelemetryBootOptions as j, ServerTransportProvider as k, createIsolatedWorkflowRuntime as l, WorkerNodeRunner as m, loadWorkflowModules as n, ActivateAdapterRuntimeIdentityInput as nt, IsolatedWorkflowRuntimeContext as o, activateAdapterRuntimeIdentity as ot, PiscinaThinWorkflowProviderOptions as p, NoopFrameworkModuleResolver as q, loadWorkflowFromConfig as r, ActivatedAdapterRuntimeIdentity as rt, WorkflowRuntimeAuthorityConnector as s, prepareAdapterRuntime as st, loadWorkflowModule as t, createHonoRouteGraph as tt, InProcessWorkflowRunner as u, createNodeWorkflowRunner as v, WorkflowRunResult$1 as w, IWorkflowRunner$1 as x, createNodeWorkflowRunnerPackageOptions as y, initializeNodeDatabase as z };
+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 };