@makaio/framework 1.0.0-dev-1789000242829 → 1.0.0-dev-1789056039016

package/dist/{index-DR308wUB2.d.mts → index-H2NL2OwF2.d.mts}

@@ -67,6 +67,56 @@ type WorkerBootstrapCredentials$1 = z.infer<typeof WorkerBootstrapCredentialsSch
 type WorkerBootstrapGrantedClaimResponse = z.infer<typeof WorkerBootstrapGrantedClaimResponseSchema>;
 /** Non-secret remote claim refusal. */
 type WorkerBootstrapClaimRefusalReason = z.infer<typeof WorkerBootstrapClaimRefusalReasonSchema>;
+/**
+ * Why an owner-authorized Cancel is still undelivered after one bounded pass.
+ *
+ * Every member names something a delivery pass observed *instead of* stop
+ * evidence. None of them asserts that the Worker stopped, that it kept
+ * running, or that its compute may be reclaimed.
+ */
+declare const WorkerCancelUndeliveredKindSchema: z.ZodEnum<{
+  refused: "refused";
+  unavailable: "unavailable";
+  "invalid-receipt": "invalid-receipt";
+  "receipt-not-recorded": "receipt-not-recorded";
+}>;
+/**
+ * One bounded cooperative-Cancel pass that produced no stop evidence.
+ *
+ * This is a **control-delivery diagnostic, never a terminal state**. It reports
+ * what one delivery pass did not prove and leaves the Attempt's real outcome to
+ * the canonical lifecycle events. A still-running Worker whose Cancel went
+ * undelivered must remain able to reach `lifecycle.completed`,
+ * `lifecycle.failed` or `lifecycle.terminated` afterwards.
+ *
+ * That is why the subject deliberately lives under `control.`, not under
+ * `lifecycle.`: `lifecycle.*` is the Worker status vocabulary, and any status
+ * consumer may treat `lifecycle.failed` as terminal and ignore later
+ * transitions. Reporting an undelivered Cancel there would terminalize a live
+ * Worker and drop its later canonical outcome. A diagnostic under `control.`
+ * is additive and stays outside the status vocabulary by construction.
+ *
+ * The identity fields are the Worker lifecycle identity on purpose: a consumer
+ * correlates a diagnostic to the same Attempt row a lifecycle event projects.
+ */
+declare const WorkerCancelUndeliveredSchema: z.ZodObject<{
+  executionAttemptId: z.ZodString;
+  executionId: z.ZodString;
+  environment: z.ZodString;
+  metadata: z.ZodOptional<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+  kind: z.ZodEnum<{
+    refused: "refused";
+    unavailable: "unavailable";
+    "invalid-receipt": "invalid-receipt";
+    "receipt-not-recorded": "receipt-not-recorded";
+  }>;
+  detail: z.ZodString;
+  observedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+/** Delivery outcome that left an owner-authorized Cancel undelivered. */
+type WorkerCancelUndeliveredKind = z.infer<typeof WorkerCancelUndeliveredKindSchema>;
+/** One reported cooperative-Cancel pass that produced no stop evidence. */
+type WorkerCancelUndelivered = z.infer<typeof WorkerCancelUndeliveredSchema>;
 /**
  * Framework-level Worker dispatch request.
  *
@@ -302,6 +352,10 @@ declare const WorkerDispatchResponseSchema: z.ZodObject<{
  * - `control.outcome.submit` — worker submits an execution outcome for durable ACK
  * - `control.bootstrap.claim`— worker claims execution-scoped bus credentials
  * - `runtime.inputs.get` — authenticated runtime pulls its selected realization inputs
+ * - `control.cancel-undelivered` — one cooperative Cancel pass produced no stop evidence
+ *
+ * `control.cancel-undelivered` is a delivery diagnostic, not a lifecycle state:
+ * it never terminalizes a Worker and never supersedes a canonical outcome.
  */
 declare const WorkerSchemas$1: {
   /**
@@ -649,9 +703,9 @@ declare const WorkerSchemas$1: {
           confidence: z.ZodOptional<z.ZodObject<{
             level: z.ZodEnum<{
               inferred: "inferred";
+              confirmed: "confirmed";
               assumed: "assumed";
               stated: "stated";
-              confirmed: "confirmed";
               verified: "verified";
             }>;
             basis: z.ZodArray<z.ZodObject<{
@@ -723,8 +777,8 @@ declare const WorkerSchemas$1: {
     }, z.core.$strict>;
     response: z.ZodObject<{
       decision: z.ZodEnum<{
-        accepted: "accepted";
         fenced: "fenced";
+        accepted: "accepted";
         duplicate: "duplicate";
         conflict: "conflict";
       }>;
@@ -770,6 +824,36 @@ declare const WorkerSchemas$1: {
       }>;
     }, z.core.$strict>], "status">;
   };
+  /**
+   * One bounded cooperative-Cancel delivery pass produced no stop evidence.
+   *
+   * Emitted by the party that owns delivery of an owner-authorized Cancel, once
+   * per pass that ended without evidence that the addressed runtime stopped. It
+   * is the only channel that makes that absence visible, and it reports a
+   * delivery fact only: never a Worker state, and never permission to reclaim
+   * the Worker's compute.
+   *
+   * Not a lifecycle subject by design — see
+   * {@link WorkerCancelUndeliveredSchema}. Status projections consume
+   * `lifecycle.*` and must stay unaffected by this diagnostic.
+   *
+   * Subject: `worker.control.cancel-undelivered`
+   * Type: Event (notification; no reply)
+   */
+  'control.cancel-undelivered': z.ZodObject<{
+    executionAttemptId: z.ZodString;
+    executionId: z.ZodString;
+    environment: z.ZodString;
+    metadata: z.ZodOptional<z.ZodType<Record<string, unknown>, Record<string, unknown>, z.core.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+    kind: z.ZodEnum<{
+      refused: "refused";
+      unavailable: "unavailable";
+      "invalid-receipt": "invalid-receipt";
+      "receipt-not-recorded": "receipt-not-recorded";
+    }>;
+    detail: z.ZodString;
+    observedAt: z.ZodISODateTime;
+  }, z.core.$strip>;
   /**
    * Dispatch has selected a provider; Worker allocation is in progress.
    *
@@ -1221,9 +1305,9 @@ declare const WorkerNamespace: _$_makaio_core0.BusNamespaceDefinition<"worker",
           confidence: _$zod.ZodOptional<_$zod.ZodObject<{
             level: _$zod.ZodEnum<{
               inferred: "inferred";
+              confirmed: "confirmed";
               assumed: "assumed";
               stated: "stated";
-              confirmed: "confirmed";
               verified: "verified";
             }>;
             basis: _$zod.ZodArray<_$zod.ZodObject<{
@@ -1295,8 +1379,8 @@ declare const WorkerNamespace: _$_makaio_core0.BusNamespaceDefinition<"worker",
     }, _$zod_v4_core0.$strict>;
     response: _$zod.ZodObject<{
       decision: _$zod.ZodEnum<{
-        accepted: "accepted";
         fenced: "fenced";
+        accepted: "accepted";
         duplicate: "duplicate";
         conflict: "conflict";
       }>;
@@ -1331,6 +1415,20 @@ declare const WorkerNamespace: _$_makaio_core0.BusNamespaceDefinition<"worker",
       }>;
     }, _$zod_v4_core0.$strict>], "status">;
   };
+  'control.cancel-undelivered': _$zod.ZodObject<{
+    executionAttemptId: _$zod.ZodString;
+    executionId: _$zod.ZodString;
+    environment: _$zod.ZodString;
+    metadata: _$zod.ZodOptional<_$zod.ZodType<Record<string, unknown>, Record<string, unknown>, _$zod_v4_core0.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+    kind: _$zod.ZodEnum<{
+      refused: "refused";
+      unavailable: "unavailable";
+      "invalid-receipt": "invalid-receipt";
+      "receipt-not-recorded": "receipt-not-recorded";
+    }>;
+    detail: _$zod.ZodString;
+    observedAt: _$zod.ZodISODateTime;
+  }, _$zod_v4_core0.$strip>;
   'lifecycle.provisioning': _$zod.ZodObject<{
     executionAttemptId: _$zod.ZodString;
     executionId: _$zod.ZodString;
@@ -1716,9 +1814,9 @@ declare const WorkerSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Flat
           confidence: _$zod.ZodOptional<_$zod.ZodObject<{
             level: _$zod.ZodEnum<{
               inferred: "inferred";
+              confirmed: "confirmed";
               assumed: "assumed";
               stated: "stated";
-              confirmed: "confirmed";
               verified: "verified";
             }>;
             basis: _$zod.ZodArray<_$zod.ZodObject<{
@@ -1790,8 +1888,8 @@ declare const WorkerSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Flat
     }, _$zod_v4_core0.$strict>;
     response: _$zod.ZodObject<{
       decision: _$zod.ZodEnum<{
-        accepted: "accepted";
         fenced: "fenced";
+        accepted: "accepted";
         duplicate: "duplicate";
         conflict: "conflict";
       }>;
@@ -1826,6 +1924,20 @@ declare const WorkerSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.Flat
       }>;
     }, _$zod_v4_core0.$strict>], "status">;
   };
+  'control.cancel-undelivered': _$zod.ZodObject<{
+    executionAttemptId: _$zod.ZodString;
+    executionId: _$zod.ZodString;
+    environment: _$zod.ZodString;
+    metadata: _$zod.ZodOptional<_$zod.ZodType<Record<string, unknown>, Record<string, unknown>, _$zod_v4_core0.$ZodTypeInternals<Record<string, unknown>, Record<string, unknown>>>>;
+    kind: _$zod.ZodEnum<{
+      refused: "refused";
+      unavailable: "unavailable";
+      "invalid-receipt": "invalid-receipt";
+      "receipt-not-recorded": "receipt-not-recorded";
+    }>;
+    detail: _$zod.ZodString;
+    observedAt: _$zod.ZodISODateTime;
+  }, _$zod_v4_core0.$strip>;
   'lifecycle.provisioning': _$zod.ZodObject<{
     executionAttemptId: _$zod.ZodString;
     executionId: _$zod.ZodString;
@@ -1899,4 +2011,4 @@ declare const SuspensionStrategySchema: z.ZodEnum<{
 /** Provider suspension behavior selected for a workflow execution. */
 type SuspensionStrategy = z.infer<typeof SuspensionStrategySchema>;
 //#endregion
-export { WorkerDispatchResponseSchema as _, WorkerSubjects$1 as a, WorkerSchemas$1 as b, WorkerBootstrapClaimRequest as c, WorkerBootstrapCredentials$1 as d, WorkerBootstrapCredentialsSchema as f, WorkerDispatchRequestSchema as g, WorkerBootstrapGrantedClaimResponseSchema as h, WorkerNamespace as i, WorkerBootstrapClaimResponse as l, WorkerBootstrapGrantedClaimResponse as m, SuspensionStrategySchema as n, WorkerBootstrapClaimRefusalReason as o, WorkerBootstrapDeadlineAtSchema$1 as p, WORKER_BOOTSTRAP_IDENTITY_ID as r, WorkerBootstrapClaimRefusalReasonSchema as s, SuspensionStrategy as t, WorkerBootstrapClaimResponseSchema as u, WorkerRuntimeInputsGetRequest as v, WorkerRuntimeInputsGetResponse as y };
+export { WorkerRuntimeInputsGetResponse as C, WorkerRuntimeInputsGetRequest as S, WorkerCancelUndeliveredKind as _, WorkerSubjects$1 as a, WorkerDispatchRequestSchema as b, WorkerBootstrapClaimRequest as c, WorkerBootstrapCredentials$1 as d, WorkerBootstrapCredentialsSchema as f, WorkerCancelUndelivered as g, WorkerBootstrapGrantedClaimResponseSchema as h, WorkerNamespace as i, WorkerBootstrapClaimResponse as l, WorkerBootstrapGrantedClaimResponse as m, SuspensionStrategySchema as n, WorkerBootstrapClaimRefusalReason as o, WorkerBootstrapDeadlineAtSchema$1 as p, WORKER_BOOTSTRAP_IDENTITY_ID as r, WorkerBootstrapClaimRefusalReasonSchema as s, SuspensionStrategy as t, WorkerBootstrapClaimResponseSchema as u, WorkerCancelUndeliveredKindSchema as v, WorkerSchemas$1 as w, WorkerDispatchResponseSchema as x, WorkerCancelUndeliveredSchema as y };

package/dist/{index-CjMMvZch.d.mts → index-LRAmVQLj.d.mts}

@@ -1,7 +1,7 @@
-import { r as ExtensionDiscovery } from "./extension-discovery-B0ZL076T.mjs";
+import { r as ExtensionDiscovery } from "./extension-discovery-Dx118u_N.mjs";
 import { RegistrableBusNamespaceDefinition } from "@makaio/framework/core";
-import { ExecutionAttemptBootstrapStartRefusalReason, ExecutionAttemptInstruction, ExecutionAttemptOperationAdmitRefusalReason, ExecutionAttemptOperationDelivery, ExecutionAttemptOperationKind, ExecutionAttemptOperationReceipt, ExecutionAttemptOutcome, ExecutionAttemptRuntimeRegisterRefusalReason, ExecutionAttemptWorkspaceBinding, ExtensionConfigProvider, IWorkerProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, JsonValue, LoopGateHandler, MakaioNodeExtension, NormalizedWorkerCapabilities, OutcomeAckDecision, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerBootstrapCredentials, WorkerCapabilities, WorkerContributionManifest, WorkerContributionRef, WorkerDispatch, WorkerMaterializationSpec, WorkerProvisionOutcome, WorkerProvisionRequest, WorkerRequirements, WorkerRuntimeContext, WorkflowDefinition, WorkflowRunContext, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerCompletion, WorkflowRunnerCompletion as WorkflowRunnerCompletion$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas, WorkspaceRequirement } from "@makaio/framework/contracts";
-import { BusTransport, IMakaioBus, SubjectTelemetryProjectorRegistry } from "@makaio/framework/bus";
+import { ExecutionAttemptBootstrapStartRefusalReason, ExecutionAttemptControlReportResponse, ExecutionAttemptInstruction, ExecutionAttemptOperationAdmitRefusalReason, ExecutionAttemptOperationDelivery, ExecutionAttemptOperationKind, ExecutionAttemptOperationReceipt, ExecutionAttemptOutcome, ExecutionAttemptRuntimeRegisterRefusalReason, ExecutionAttemptWorkspaceBinding, ExtensionConfigProvider, IWorkerProvider, IWorkflowRunner, IWorkflowRunner as IWorkflowRunner$1, JsonValue, LoopGateHandler, MakaioNodeExtension, NormalizedWorkerCapabilities, OutcomeAckDecision, StationHandler, StepRunnerBusAuth, StepRunnerPlatformDefaults, TrayManifest, WorkerBootstrapCredentials, WorkerCapabilities, WorkerContributionManifest, WorkerContributionRef, WorkerDispatch, WorkerMaterializationSpec, WorkerProvisionOutcome, WorkerProvisionRequest, WorkerRequirements, WorkerRuntimeContext, WorkflowDefinition, WorkflowRunContext, WorkflowRunResult, WorkflowRunResult as WorkflowRunResult$1, WorkflowRunnerCompletion, WorkflowRunnerCompletion as WorkflowRunnerCompletion$1, WorkflowRunnerRunOptions, WorkflowWorkerConfig, WorkflowWorkerSource, WorkflowZodSchemas, WorkspaceRequirement } from "@makaio/framework/contracts";
+import { BusTransport, IFilteredBus, IMakaioBus, SubjectTelemetryProjectorRegistry } from "@makaio/framework/bus";
 import { DispatchingAuth, HmacAuth, TransportAuth } from "@makaio/framework/node/transports";
 import { ContributionProcessor, ExtensionCoordinator, ExtensionRuntimeSurface, KernelExtensionContext, KernelMakaioExtension, RuntimeCapability, TransportProvider, WindowRegistry } from "@makaio/framework/kernel";
 import { StorageEngine } from "@makaio/framework/storage/drizzle";
@@ -2150,16 +2150,40 @@ interface IsolatedWorkflowRuntime {
 declare function createIsolatedWorkflowRuntime(options: CreateIsolatedWorkflowRuntimeOptions): Promise<IsolatedWorkflowRuntime>;
 //#endregion
 //#region runtimes/node/src/workspace-preparation/setup-command.d.ts
+/**
+ * Bounded fact about the Setup process group, recorded by the driver itself.
+ * `exited`: the group closed on its own and quiescence of the whole group was proven.
+ * `signalled-and-quiesced`: the driver signalled the group and proved it quiescent afterwards.
+ * `signalled-unconfirmed`: the driver signalled the group but could not prove quiescence
+ *   (poll timed out, `ps` unavailable, or a signal failed) — never treat as a stop proof.
+ * `unsignalled-unconfirmed`: no signal reached the group (all attempts were absent or EPERM)
+ *   and quiescence could not be proven either — the group state is entirely unknown.
+ *
+ * The driver records raw values only. Rendering a human-readable summary and
+ * formatting the instant belong to whoever reports the fact, not to the driver:
+ * one fact can be reported to several boundaries with different wording.
+ */
+type SetupProcessGroupObservation = {
+  readonly pid: number;
+  readonly outcome: 'exited' | 'signalled-and-quiesced' | 'signalled-unconfirmed' | 'unsignalled-unconfirmed'; /** Why quiescence stayed unproven; absent whenever the outcome proves quiescence. */
+  readonly cause?: 'poll-timeout' | 'ps-unavailable' | 'signal-error'; /** Instant the driver recorded this outcome. */
+  readonly observedAt: Date;
+};
 /** Result of one bounded setup command, after its owned process group has stopped. */
 interface SetupCommandResult {
   readonly status: 'completed' | 'failed' | 'cancelled' | 'timed-out' | 'spawn-failed' | 'stop-failed';
   readonly exitCode: number | null;
   /** Generic diagnostics deliberately exclude command arguments and environment values. */
   readonly message?: string;
+  /** Process-group observation, present exactly when a process was spawned. */
+  readonly processGroup?: SetupProcessGroupObservation;
 }
 //#endregion
 //#region runtimes/node/src/workspace-preparation/workspace-preparation.d.ts
-/** First failed setup command, or successful completion of the complete frozen recipe. */
+/**
+ * First failed setup command, or successful completion of the complete frozen recipe.
+ * Inherits `processGroup` from `SetupCommandResult` — present when a process was spawned.
+ */
 interface WorkspaceSetupResult extends SetupCommandResult {
   readonly commandIndex?: number;
 }
@@ -2177,6 +2201,116 @@ interface LocalWorkspaceHandle {
   release(): Promise<void>;
 }
 //#endregion
+//#region runtimes/node/src/workflow-worker/attempt-control-conclusion.d.ts
+/** Operation kinds the control endpoint cares about. */
+type AdmittedOperationKind = Extract<ExecutionAttemptOperationKind, 'workspace-preparation' | 'workload-invocation'>;
+/**
+ * What the runtime knows about the Setup process group of a concluded preparation.
+ *
+ * `'not-started'`: the operation concluded before any setup command ran, so no
+ *   process group ever existed under it.
+ * `'no-spawn'`: setup ran and returned a result without a process group, which
+ *   the driver contract states exactly when no process was ever spawned — so
+ *   the absence of a live group is proven, not unknown.
+ * `'no-observation'`: the driver threw before handing over any result, so it
+ *   supplied no process-group fact either way.
+ */
+type SetupConclusion = 'not-started' | 'no-spawn' | 'no-observation' | SetupProcessGroupObservation;
+/**
+ * The one terminal fact an admitted operation concludes with.
+ *
+ * Preparation carries its Setup process-group fact; a workload invocation has
+ * no equivalent, because the generic adapter observes no process of its own.
+ */
+type ConcludedOperation = {
+  readonly kind: 'workspace-preparation';
+  readonly operationId: string;
+  readonly setup: SetupConclusion;
+} | {
+  readonly kind: 'workload-invocation';
+  readonly operationId: string;
+};
+/** Snapshot of observer state used for conclusion derivation. */
+interface AttemptControlState {
+  /** Whether the authority has delivered a cancel to this endpoint. */
+  readonly cancelReceived: boolean;
+  /**
+   * Whether the runtime is still waiting for an admission response.
+   * While true, `admission-closed` is never a valid conclusion.
+   */
+  readonly admissionPending: boolean;
+  /**
+   * Whether an admission request reached a completed authority response. A
+   * settled admission that admitted nothing closed this runtime out; an
+   * unanswered one stays pending, because it may still occupy the attempt.
+   */
+  readonly admissionSettled: boolean;
+  /** Reason the last settled admission was refused, or null if none was refused. */
+  readonly admissionRefusalReason: ExecutionAttemptOperationAdmitRefusalReason | null;
+  /** Last admitted mutating operation, or null if none. */
+  readonly admittedOperation: {
+    readonly kind: AdmittedOperationKind;
+    readonly operationId: string;
+  } | null;
+  /** Terminal fact of the operation that concluded, or null while none has. */
+  readonly conclusion: ConcludedOperation | null;
+  /** Whether the runtime has signalled that no further transitions will occur. */
+  readonly finished: boolean;
+}
+/**
+ * Records runtime-local operation lifecycle events so the control endpoint
+ * can derive an honest scoped conclusion after a cancel is received.
+ *
+ * The invocation path calls these methods as it moves through admission and
+ * its operations. The observer never throws; it records state and triggers
+ * conclusion derivation.
+ */
+declare class AttemptOperationObserver {
+  private readonly state;
+  private readonly onUpdate;
+  /**
+   * @param onUpdate - Called after every state transition that may change the conclusion.
+   */
+  constructor(onUpdate: () => void);
+  /** Signal that a cancel has been received (called by the delivery handler). */
+  markCancelReceived(): void;
+  /**
+   * The runtime is waiting for an admission response; conclusion is deferred.
+   * Call before sending `operation.admit`, and before {@link admissionSettled}.
+   */
+  admissionPending(): void;
+  /**
+   * An admission request reached a completed authority response.
+   *
+   * Any completed response settles the question of whether this runtime holds
+   * an operation — a refusal for any reason means it does not. A transport
+   * failure is not a settlement and must leave the admission pending.
+   * @param refusalReason - Authority refusal reason, omitted when the operation was admitted.
+   */
+  admissionSettled(refusalReason?: ExecutionAttemptOperationAdmitRefusalReason): void;
+  /**
+   * An operation was admitted by the authority.
+   * @param kind - `'workspace-preparation'` or `'workload-invocation'`.
+   * @param operationId - Authority-assigned stable operation identifier.
+   */
+  operationAdmitted(kind: AdmittedOperationKind, operationId: string): void;
+  /**
+   * The admitted operation concluded, carrying its one terminal fact.
+   * @param concluded - Operation identity and the setup fact it concluded with.
+   */
+  operationConcluded(concluded: ConcludedOperation): void;
+  /**
+   * The runtime has completed; no further transitions will occur.
+   * Enables `admission-closed` when no mutating operation was ever admitted.
+   */
+  finished(): void;
+  /**
+   * Return an immutable snapshot suitable for derivation.
+   * @returns Immutable copy of the current observer state.
+   */
+  snapshot(): AttemptControlState;
+}
+//#endregion
 //#region runtimes/node/src/workflow-worker/workload-invocation.d.ts
 /** One installed, versioned local executor for an opaque workload instruction. */
 interface InstalledWorkloadAdapter {
@@ -2247,6 +2381,11 @@ interface RunWorkloadInvocationOptions {
   readonly retry?: OutcomeSubmitRetryConfig;
   /** Local Workspace realization seam; defaults to the Node bind/create helper. */
   readonly preparation?: WorkloadInvocationPreparation;
+  /**
+   * Optional observer fed by the invocation path so the control endpoint can
+   * derive an honest scoped conclusion after a cancel delivery.
+   */
+  readonly control?: AttemptOperationObserver;
 }
 /** Durable result visible after generic terminal-outcome acknowledgement. */
 interface WorkloadInvocationResult {
@@ -2511,6 +2650,31 @@ declare function loadWorkflowModules(source: Exclude<WorkflowWorkerSource, {
 declare function loadWorkflowModule(source: WorkflowWorkerSource): Promise<RuntimeLoadedWorkflow>;
 //#endregion
 //#region runtimes/node/src/workflow-worker/runtime-registration-client.d.ts
+/** Identity a fenced attempt endpoint filters and fences its deliveries with. */
+interface FencedAttemptEndpointIdentity {
+  /** 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.
+   *
+   * A fresh endpoint installed before registration leaves it out and learns
+   * the generation through {@link FencedAttemptEndpoint.bindGeneration}.
+   */
+  readonly runtimeGeneration?: number;
+}
+/** The installed, generation-fenced endpoint of one runtime incarnation. */
+interface FencedAttemptEndpoint {
+  /**
+   * Fence later deliveries against the generation the authority accepted, and
+   * release any delivery that deferred its answer until this generation existed.
+   * @param runtimeGeneration - Generation returned by registration.
+   */
+  bindGeneration(runtimeGeneration: number): void;
+  /** Remove the endpoint from its bus. Idempotent. */
+  cleanup(): void;
+}
 /**
  * Operation kinds a runtime endpoint may be handed by the authority.
  *
@@ -2539,52 +2703,35 @@ type OperationDeliveryHandler = (delivery: ExecutionAttemptOperationDelivery) =>
  * 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;
-}
+/**
+ * Identity the delivery endpoint is installed for.
+ *
+ * `runtimeGeneration` is set when the endpoint is re-installed on another bus
+ * after registration (the pre-composition → runtime bus handoff).
+ */
+type OperationDeliveryEndpointIdentity = FencedAttemptEndpointIdentity;
+/**
+ * The installed delivery endpoint of one runtime incarnation.
+ *
+ * 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 the bound generation.
+ */
+type OperationDeliveryEndpoint = FencedAttemptEndpoint;
 /**
  * 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.
+ * addressing is the attempt and incarnation payload filter
+ * {@link installFencedAttemptEndpoint} applies (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
+ * runtime fails its own registration with `probe-failed`. The scaffold's
  * 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.
@@ -2757,4 +2904,91 @@ declare class BootstrapStartRefusedError extends Error {
  */
 declare function bootstrapWorkerRuntime(options: BootstrapWorkerRuntimeOptions): Promise<StartedWorkerRuntime>;
 //#endregion
-export { WorkflowAttemptInstructionReader as $, InitializeNodeDatabaseOptions as $t, HeadlessWorkerExecutor as A, BootMakaioRuntimeOptions as At, WorkloadInvocationPreparation as B, WorkspaceRootResolver as Bt, loadWorkflowFromConfig as C, prepareAdapterRuntime as Cn, createWorkerBusAuth as Ct, HeadlessWorkerBootstrapCredentials as D, ThinWorkflowPiscinaRunnerOptions as Dt, HeadlessWorkerBootstrap as E, RuntimeLoadedWorkflow as Et, MaterializedWorkspace as F, UpstreamTelemetryBootOptions as Ft, IsolatedWorkflowRuntimeContext as G, computeFileDigest as Gt, runWorkloadInvocation as H, assertNoSymlinkEscape as Ht, runHeadlessWorkflowWorker as I, WorkflowRunnerBootOptions as It, createIsolatedWorkflowRuntime as J, verifyContribution as Jt, WorkflowRuntimeAuthorityConnector as K, materializeLocalDirectory as Kt, InstalledWorkloadAdapter as L, LocalDirectoryMaterializerOptions as Lt, HeadlessWorkerPostCommitObserver as M, MakaioRuntime as Mt, HeadlessWorkflowWorkerDeps as N, ServerTransportProvider as Nt, HeadlessWorkerBusConnector as O, WorkflowRunResult$1 as Ot, HeadlessWorkflowWorkerResult as P, TransportReadyInfo as Pt, PiscinaThinWorkflowProviderOptions as Q, DatabaseBootOptions as Qt, RunWorkloadInvocationOptions as R, MaterializationError as Rt, loadWorkflowModules as S, activateAdapterRuntimeIdentity as Sn, withWorkerBootstrapDeadline as St, LocalGitSourceOptions as T, IWorkflowRunner$1 as Tt, CreateIsolatedWorkflowRuntimeOptions as U, computeContributionPackageDigest as Ut, WorkloadInvocationResult as V, assertContainedIn as Vt, IsolatedWorkflowRuntime as W, computeDirectoryDigest as Wt, InProcessWorkflowRunnerOptions as X, WorkflowWorkerEntryResolverOptions as Xt, InProcessWorkflowRunner as Y, WorkflowWorkerEntryMode as Yt, PiscinaThinWorkflowProvider as Z, resolveWorkflowWorkerEntry as Zt, admitWorkflowRunOperation as _, createHonoRouteGraph as _n, createNodeWorkflowRunnerPackageOptions as _t, bootstrapWorkerRuntime as a, ShutdownStep as an, DELIVERED_DECISIONS as at, registerWorkerRuntime as b, PrepareAdapterRuntimeInput as bn, runWorkerBootstrapExchange as bt, DeliverableOperationKind as c, NodeFrameworkModuleResolver as cn, OutcomeSubmitPayload as ct, OperationDeliveryEndpointIdentity as d, HttpRouteGraphBuilder as dn, submitOutcomeWithAck as dt, InitializeNodeDatabaseResult as en, WorkflowLaunchResolver as et, OperationDeliveryHandler as f, createHttpRouteGraphBuilder as fn, WorkerRunner as ft, RuntimeRegistrationRefusedError as g, HonoRouteGraphOptions as gn, createNodeWorkflowRunner as gt, RegisterWorkerRuntimeOptions as h, HonoRouteGraph as hn, NodeWorkflowRunnerPackageOptions as ht, StartedWorkerRuntime as i, selectFrameworkCorePackages as in, AuthorityRequestDeliveryError as it, HeadlessWorkerMaterializer as j, CoreBootOptions as jt, HeadlessWorkerContributionLoader as k, BootCoordinatorSetupContext as kt, OperationAdmissionRefusedError as l, NoopFrameworkModuleResolver as ln, OutcomeSubmitRetryConfig as lt, RegisterAndAdmitWorkflowRunOptions as m, HttpRouteContribution as mn, CreateNodeWorkflowRunnerPackageOptionsParams as mt, BootstrapStartRefusedError as n, HostCapabilityDeclaration as nn, AttemptOutcomeDeliveryError as nt, AdmitWorkflowRunOperationOptions as o, BridgeBrowserOptions as on, OutcomeDeliveryError as ot, OperationDeliveryHandlers as p, HttpContributionPhase as pn, WorkerRunnerOptions as pt, WorkflowRuntimeContributionLoader as q, parseSriIntegrity as qt, BootstrapWorkerRuntimeOptions as r, normalizeNodeHostCapabilities as rn, AttemptOutcomeSubmitPayload as rt, AdmittedWorkflowRun as s, FrameworkModuleResolver as sn, OutcomeReconnect as st, BootstrapRuntimeConnection as t, initializeNodeDatabase as tn, createWorkflowLaunchResolver as tt, OperationDeliveryEndpoint as u, resolveFrameworkSpecifier as un, submitAttemptOutcomeWithAck as ut, installOperationDeliveryEndpoint as v, ActivateAdapterRuntimeIdentityInput as vn, BootstrapExchangeResult as vt, createLocalGitWorkspacePreparation as w, ThinWorkflowPiscinaRunner as wt, loadWorkflowModule as x, PreparedAdapterRuntime as xn, BootstrapDeadlineExceededError as xt, registerAndAdmitWorkflowRun as y, ActivatedAdapterRuntimeIdentity as yn, WorkerBootstrapExchangeOptions as yt, WorkloadControlBinding as z, ParsedSriIntegrity as zt };
+//#region runtimes/node/src/workflow-worker/attempt-control-client.d.ts
+/** Options for the report transport retried independently of the cancel signal. */
+type AttemptControlReportOptions = OutcomeSubmitOptions;
+/** Dependencies for the attempt control endpoint installer. */
+interface AttemptControlEndpointDeps {
+  /** Retry and reconnect options for the `control.report` retrying transport. */
+  readonly reportOptions?: AttemptControlReportOptions;
+  /** Outer cancellation signal for endpoint installation only, not for report delivery. */
+  readonly signal?: AbortSignal;
+  /** Wall-clock supplier; defaults to `() => new Date()`. */
+  readonly now?: () => Date;
+}
+/**
+ * Identity the control endpoint is installed for.
+ *
+ * The same attempt, incarnation and optional accepted generation the operation
+ * delivery endpoint is installed with; both are fenced the same way.
+ */
+type AttemptControlEndpointIdentity = FencedAttemptEndpointIdentity;
+/** Last report delivery outcome recorded by the endpoint. */
+interface AttemptControlLastReport {
+  /** Terminal delivery status. */
+  readonly status: 'accepted' | 'duplicate' | 'refused' | 'error';
+  /** Authority response when delivery succeeded or was refused. */
+  readonly response?: ExecutionAttemptControlReportResponse;
+  /** Transport-level error when delivery failed. */
+  readonly error?: unknown;
+}
+/**
+ * Handle returned by {@link installAttemptControlEndpoint} after
+ * `waitForSubscriptionPropagation` confirms the subscription is visible.
+ */
+interface InstalledAttemptControlEndpoint {
+  /**
+   * Bind the accepted runtime generation received from the registration RPC.
+   *
+   * No delivery passes the generation fence before this, and a delivery that
+   * arrives while the registration RPC is still in flight defers its answer
+   * until this is called rather than being refused as stale.
+   * @param runtimeGeneration - Authority-assigned generation number.
+   */
+  bindGeneration(runtimeGeneration: number): void;
+  /**
+   * Remove the bus subscription. A later delivery is a filter miss and is
+   * never answered by this endpoint.
+   */
+  cleanup(): void;
+  /**
+   * Effective cancel signal, aborted once the first delivery passes the fence
+   * and the receipt is stored.
+   */
+  readonly signal: AbortSignal;
+  /**
+   * Observer the invocation path uses to record lifecycle transitions so
+   * the endpoint can derive an honest scoped conclusion.
+   */
+  readonly observer: AttemptOperationObserver;
+  /**
+   * Await any in-flight `control.report` delivery. Resolves without
+   * throwing; transport failure is recorded in {@link lastReport}.
+   */
+  settle(): Promise<void>;
+  /** Last recorded report delivery outcome, useful for tests and logging. */
+  readonly lastReport: AttemptControlLastReport | undefined;
+}
+/**
+ * Install this runtime's responder for `execution-attempt.control.deliver`.
+ *
+ * The subject is static and filtered by `{ executionAttemptId, runtimeIncarnationId }`
+ * on the runtime bus — the same fenced scaffold the operation delivery endpoint
+ * uses. A delivery for another attempt or incarnation is a filter miss, never
+ * seen here. See the trust-boundary note on
+ * {@link installFencedAttemptEndpoint} for the gap that filter leaves open, and
+ * for why it is wider on this subject than on `operation.deliver`.
+ *
+ * The endpoint must exist before the runtime registers so that the authority's
+ * `reconcileAttemptCancellation` call can reach it. The scaffold's
+ * `waitForSubscriptionPropagation` await is what makes "before" true across the
+ * transport.
+ * @param bus - Connected runtime bus authenticated as the attempt peer.
+ * @param identity - Attempt and incarnation this runtime is registered against.
+ * @param deps - Report options, installation signal, and wall-clock supplier.
+ * @returns The installed endpoint with a bound generation, cancel signal, observer,
+ * and `settle()` awaitable.
+ */
+declare function installAttemptControlEndpoint(bus: IMakaioBus, identity: AttemptControlEndpointIdentity, deps?: AttemptControlEndpointDeps): Promise<InstalledAttemptControlEndpoint>;
+//#endregion
+export { WorkflowRuntimeAuthorityConnector as $, materializeLocalDirectory as $t, createLocalGitWorkspacePreparation as A, prepareAdapterRuntime as An, createWorkerBusAuth as At, HeadlessWorkflowWorkerResult as B, ServerTransportProvider as Bt, admitWorkflowRunOperation as C, HonoRouteGraphOptions as Cn, createNodeWorkflowRunner as Ct, loadWorkflowModule as D, PrepareAdapterRuntimeInput as Dn, runWorkerBootstrapExchange as Dt, registerWorkerRuntime as E, ActivatedAdapterRuntimeIdentity as En, WorkerBootstrapExchangeOptions as Et, HeadlessWorkerContributionLoader as F, WorkflowRunResult$1 as Ft, WorkloadControlBinding as G, MaterializationError as Gt, runHeadlessWorkflowWorker as H, UpstreamTelemetryBootOptions as Ht, HeadlessWorkerExecutor as I, BootCoordinatorSetupContext as It, runWorkloadInvocation as J, assertContainedIn as Jt, WorkloadInvocationPreparation as K, ParsedSriIntegrity as Kt, HeadlessWorkerMaterializer as L, BootMakaioRuntimeOptions as Lt, HeadlessWorkerBootstrap as M, IWorkflowRunner$1 as Mt, HeadlessWorkerBootstrapCredentials as N, RuntimeLoadedWorkflow as Nt, loadWorkflowModules as O, PreparedAdapterRuntime as On, BootstrapDeadlineExceededError as Ot, HeadlessWorkerBusConnector as P, ThinWorkflowPiscinaRunnerOptions as Pt, IsolatedWorkflowRuntimeContext as Q, computeFileDigest as Qt, HeadlessWorkerPostCommitObserver as R, CoreBootOptions as Rt, RuntimeRegistrationRefusedError as S, HonoRouteGraph as Sn, NodeWorkflowRunnerPackageOptions as St, registerAndAdmitWorkflowRun as T, ActivateAdapterRuntimeIdentityInput as Tn, BootstrapExchangeResult as Tt, InstalledWorkloadAdapter as U, WorkflowRunnerBootOptions as Ut, MaterializedWorkspace as V, TransportReadyInfo as Vt, RunWorkloadInvocationOptions as W, LocalDirectoryMaterializerOptions as Wt, CreateIsolatedWorkflowRuntimeOptions as X, computeContributionPackageDigest as Xt, SetupProcessGroupObservation as Y, assertNoSymlinkEscape as Yt, IsolatedWorkflowRuntime as Z, computeDirectoryDigest as Zt, OperationDeliveryEndpointIdentity as _, resolveFrameworkSpecifier as _n, submitAttemptOutcomeWithAck as _t, InstalledAttemptControlEndpoint as a, DatabaseBootOptions as an, PiscinaThinWorkflowProviderOptions as at, RegisterAndAdmitWorkflowRunOptions as b, HttpContributionPhase as bn, WorkerRunnerOptions as bt, BootstrapStartRefusedError as c, initializeNodeDatabase as cn, createWorkflowLaunchResolver as ct, bootstrapWorkerRuntime as d, selectFrameworkCorePackages as dn, AuthorityRequestDeliveryError as dt, parseSriIntegrity as en, WorkflowRuntimeContributionLoader as et, AdmitWorkflowRunOperationOptions as f, ShutdownStep as fn, DELIVERED_DECISIONS as ft, OperationDeliveryEndpoint as g, NoopFrameworkModuleResolver as gn, OutcomeSubmitRetryConfig as gt, OperationAdmissionRefusedError as h, NodeFrameworkModuleResolver as hn, OutcomeSubmitPayload as ht, AttemptControlReportOptions as i, resolveWorkflowWorkerEntry as in, PiscinaThinWorkflowProvider as it, LocalGitSourceOptions as j, ThinWorkflowPiscinaRunner as jt, loadWorkflowFromConfig as k, activateAdapterRuntimeIdentity as kn, withWorkerBootstrapDeadline as kt, BootstrapWorkerRuntimeOptions as l, HostCapabilityDeclaration as ln, AttemptOutcomeDeliveryError as lt, DeliverableOperationKind as m, FrameworkModuleResolver as mn, OutcomeReconnect as mt, AttemptControlEndpointIdentity as n, WorkflowWorkerEntryMode as nn, InProcessWorkflowRunner as nt, installAttemptControlEndpoint as o, InitializeNodeDatabaseOptions as on, WorkflowAttemptInstructionReader as ot, AdmittedWorkflowRun as p, BridgeBrowserOptions as pn, OutcomeDeliveryError as pt, WorkloadInvocationResult as q, WorkspaceRootResolver as qt, AttemptControlLastReport as r, WorkflowWorkerEntryResolverOptions as rn, InProcessWorkflowRunnerOptions as rt, BootstrapRuntimeConnection as s, InitializeNodeDatabaseResult as sn, WorkflowLaunchResolver as st, AttemptControlEndpointDeps as t, verifyContribution as tn, createIsolatedWorkflowRuntime as tt, StartedWorkerRuntime as u, normalizeNodeHostCapabilities as un, AttemptOutcomeSubmitPayload as ut, OperationDeliveryHandler as v, HttpRouteGraphBuilder as vn, submitOutcomeWithAck as vt, installOperationDeliveryEndpoint as w, createHonoRouteGraph as wn, createNodeWorkflowRunnerPackageOptions as wt, RegisterWorkerRuntimeOptions as x, HttpRouteContribution as xn, CreateNodeWorkflowRunnerPackageOptionsParams as xt, OperationDeliveryHandlers as y, createHttpRouteGraphBuilder as yn, WorkerRunner as yt, HeadlessWorkflowWorkerDeps as z, MakaioRuntime as zt };

package/dist/kernel/cli/index.d.mts

@@ -1,5 +1,5 @@
-import { a as CliSubcommandDefinition, c as EmbeddedBusHandle, d as ProvideBusContext, f as defineCliSubcommand, i as CliContribution, l as INTERACTIVE_SUBCOMMAND, n as BeforeRunContext, o as CliSubcommandEntry, p as requireBus, r as BeforeRunResult, s as CommandContext, t as ALWAYS_PROCEED, u as OutputWriter } from "../../types-nor1SQLZ.mjs";
-import { n as CliRpcSubjects, t as CliNamespace } from "../../namespace-B3MnuAqp.mjs";
+import { a as CliSubcommandDefinition, c as EmbeddedBusHandle, d as ProvideBusContext, f as defineCliSubcommand, i as CliContribution, l as INTERACTIVE_SUBCOMMAND, n as BeforeRunContext, o as CliSubcommandEntry, p as requireBus, r as BeforeRunResult, s as CommandContext, t as ALWAYS_PROCEED, u as OutputWriter } from "../../types-CbXf822E.mjs";
+import { n as CliRpcSubjects, t as CliNamespace } from "../../namespace-Dwf7aOLt.mjs";
 import { z } from "zod";
 import { CliArgManifest } from "@makaio/framework/contracts/extension";
 

package/dist/kernel/cli/register.d.mts

@@ -1,2 +1,2 @@
-import { n as CliRpcSubjects, t as CliNamespace } from "../../namespace-B3MnuAqp.mjs";
+import { n as CliRpcSubjects, t as CliNamespace } from "../../namespace-Dwf7aOLt.mjs";
 export { CliNamespace, CliRpcSubjects };

package/dist/kernel/extension/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ExtensionCoordinatorOptions, c as KernelMakaioExtension, i as ContributionProcessor, l as RuntimeCapability, n as filterEligibleExtensions, o as ExtensionRuntimeSurface, r as ExtensionCoordinator, s as KernelExtensionContext, t as coalesceExtensionOverrides, u as RuntimeEnvironment } from "../../index-Dzozmb5u.mjs";
+import { a as ExtensionCoordinatorOptions, c as KernelMakaioExtension, i as ContributionProcessor, l as RuntimeCapability, n as filterEligibleExtensions, o as ExtensionRuntimeSurface, r as ExtensionCoordinator, s as KernelExtensionContext, t as coalesceExtensionOverrides, u as RuntimeEnvironment } from "../../index-Ddk-kjif.mjs";
 export { ContributionProcessor, ExtensionCoordinator, ExtensionCoordinatorOptions, ExtensionRuntimeSurface, KernelExtensionContext, KernelMakaioExtension, RuntimeCapability, RuntimeEnvironment, coalesceExtensionOverrides, filterEligibleExtensions };

package/dist/kernel/index.d.mts

@@ -1,8 +1,8 @@
-import { c as ExtensionInfo, f as ServiceInfo, i as ComponentInfo, l as ExtensionInfoSchema, n as ExtensionSubjects, o as ComponentState, p as ServiceInfoSchema, s as ComponentStateSchema, t as ExtensionNamespace } from "../index-Dckvm0Ml2.mjs";
-import { c as KernelMakaioExtension, i as ContributionProcessor, l as RuntimeCapability, n as filterEligibleExtensions, o as ExtensionRuntimeSurface, r as ExtensionCoordinator, s as KernelExtensionContext, t as coalesceExtensionOverrides, u as RuntimeEnvironment } from "../index-Dzozmb5u.mjs";
-import { i as WindowStyle, n as WindowRegistration, r as WindowRegistry, t as STYLE_DEFAULTS } from "../window-registry-DQ7udUzI.mjs";
-import { n as KernelSubjects, r as KernelSchemas, t as KernelNamespace } from "../index-Bk0Xjk-B.mjs";
-import { a as MachineIdentity, c as StorageProvider, i as IdentityProvider, n as NoTransportProvider, o as TransportProvider, r as MemoryStorageProvider, s as StorageCleanup, t as EphemeralIdentityProvider } from "../index-krTCFThl2.mjs";
+import { c as ExtensionInfo, f as ServiceInfo, i as ComponentInfo, l as ExtensionInfoSchema, n as ExtensionSubjects, o as ComponentState, p as ServiceInfoSchema, s as ComponentStateSchema, t as ExtensionNamespace } from "../index-CK5GEXLB2.mjs";
+import { c as KernelMakaioExtension, i as ContributionProcessor, l as RuntimeCapability, n as filterEligibleExtensions, o as ExtensionRuntimeSurface, r as ExtensionCoordinator, s as KernelExtensionContext, t as coalesceExtensionOverrides, u as RuntimeEnvironment } from "../index-Ddk-kjif.mjs";
+import { i as WindowStyle, n as WindowRegistration, r as WindowRegistry, t as STYLE_DEFAULTS } from "../window-registry-Dq5uOWpH.mjs";
+import { n as KernelSubjects, r as KernelSchemas, t as KernelNamespace } from "../index-1AKlC3kZ.mjs";
+import { a as MachineIdentity, c as StorageProvider, i as IdentityProvider, n as NoTransportProvider, o as TransportProvider, r as MemoryStorageProvider, s as StorageCleanup, t as EphemeralIdentityProvider } from "../index-DSRxn5Zr2.mjs";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";