@zlink-systems/framework 0.10.0

package/src/runtime/backend/index.ts

@@ -0,0 +1,9 @@
+export * from './contracts';
+export * from './runtime-message';
+export * from './runtime-values';
+export * from './node/node-dealer-channel-client-transport';
+export * from './mesh-dispatch-pump';
+export * from './mesh-completion-table';
+export * from './mesh-actor-session-node-adapter';
+export * from './mesh-record-dispatcher';
+export * from './node';

package/src/runtime/backend/mesh-actor-session-node-adapter.ts

@@ -0,0 +1,73 @@
+import { SubmitResult } from './runtime-values';
+import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import type {
+  ZLinkBackendActorSessionNode,
+  ZLinkBackendMeshNode
+} from './contracts';
+import {
+  closeMeshCompletion,
+  type ZLinkMeshCompletionTable
+} from './mesh-completion-table';
+import { routingIdsEqual } from '../routing-id';
+
+export function meshActorSessionNodeAdapter(
+  node: ZLinkBackendMeshNode,
+  completions?: ZLinkMeshCompletionTable
+): ZLinkBackendActorSessionNode {
+  return {
+    actorNodeGeneration(actor) {
+      const status = node.status();
+      return routingIdsEqual(status.routingId, actor.nodeRid)
+        ? status.lifecycleGeneration
+        : undefined;
+    },
+    async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence) {
+      const result = await node.sendActorBoundSession(
+        actor,
+        expectedBindingGeneration,
+        parts as never,
+        flags,
+        actorFence
+      );
+      switch (result) {
+        case SubmitResult.Ok:
+          return { status: ZLinkSubmitStatus.Submitted };
+        case SubmitResult.Backpressured:
+        case SubmitResult.NotAdmitted:
+          return { status: ZLinkSubmitStatus.Backpressured };
+        case SubmitResult.NotFound:
+        case SubmitResult.InvalidState:
+          return { status: ZLinkSubmitStatus.TargetNotFound };
+        case SubmitResult.NotConnected:
+          return { status: ZLinkSubmitStatus.RouteNotConnected };
+        case SubmitResult.Terminated:
+          return { status: ZLinkSubmitStatus.Shutdown };
+        default:
+          throw new Error(`Actor bound-session send failed with result '${result}'.`);
+      }
+    },
+    async closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs, signal) {
+      if (completions === undefined) {
+        throw new Error('MeshNode completion runtime is not started.');
+      }
+      const completion = await completions.submit(
+        () => node.closeActorBoundSession(
+          actor,
+          expectedBindingGeneration,
+          timeoutMs
+        ),
+        signal
+      );
+      try {
+        if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
+          throw new Error(
+            `Actor '${actor.actorId}' bound-session close failed with result ` +
+            `'${completion.terminalResult}' and errno '${completion.failureErrno}'.`
+          );
+        }
+      } finally {
+        closeMeshCompletion(completion);
+      }
+    }
+  };
+}

package/src/runtime/backend/mesh-completion-table.ts

@@ -0,0 +1,165 @@
+import { ZLinkBufferMessage as Message } from './runtime-message';
+import type {
+  MeshOperationId,
+  ReceiveKindData,
+  ReceiveRecord
+} from '../foundation/service-runtime-contracts';
+import { operationIdentityKey } from '../foundation/operation-identity';
+import {
+  ZLinkFrameworkErrorKind,
+  ZLinkFrameworkException
+} from '../../contracts';
+
+export const ZLINK_MESH_COMPLETION_CAPACITY = 4_096;
+
+export interface ZLinkMeshCompletionDiagnostic {
+  readonly kind: 'unknownOrLate';
+  readonly operationId: MeshOperationId;
+  readonly terminalResult: number;
+}
+
+export interface ZLinkMeshCompletion {
+  readonly terminalResult: number;
+  readonly failureErrno: number;
+  readonly operationKind: number;
+  readonly kindData: ReceiveKindData | null;
+  readonly parts: Message[];
+}
+
+interface PendingCompletion {
+  readonly resolve: (completion: ZLinkMeshCompletion) => void;
+  readonly reject: (error: unknown) => void;
+  readonly removeAbort?: () => void;
+}
+
+export class ZLinkMeshCompletionTable {
+  private readonly pending = new Map<string, PendingCompletion>();
+  private disposed = false;
+
+  constructor(
+    private readonly maxPendingOperations = ZLINK_MESH_COMPLETION_CAPACITY,
+    private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void
+  ) {
+    if (!Number.isSafeInteger(maxPendingOperations) || maxPendingOperations <= 0) {
+      throw new RangeError('maxPendingOperations must be a positive safe integer.');
+    }
+  }
+
+  /**
+   * Submits and registers without yielding control to the event loop. Mesh
+   * completion dispatch is asynchronous, so a completion cannot overtake the
+   * registration. The table therefore does not need to retain responses that
+   * arrived before their waiter.
+   */
+  submit(
+    operation: () => MeshOperationId,
+    signal?: AbortSignal
+  ): Promise<ZLinkMeshCompletion> {
+    if (this.isDisposed()) {
+      return Promise.reject(new Error('Mesh completion table is disposed.'));
+    }
+    if (signal?.aborted === true) {
+      return Promise.reject(
+        signal.reason ?? new DOMException('The operation was aborted.', 'AbortError')
+      );
+    }
+    if (this.pending.size >= this.maxPendingOperations) {
+      return Promise.reject(new ZLinkFrameworkException(
+        ZLinkFrameworkErrorKind.CapacityExceeded,
+        `Mesh completion capacity ${this.maxPendingOperations} is exhausted.`
+      ));
+    }
+    const operationId = operation();
+    // The backend submission callback can synchronously re-enter `dispose()`.
+    // TypeScript's control-flow analysis cannot observe mutation through it.
+    if (this.disposed) {
+      return Promise.reject(new Error('Mesh completion table is disposed.'));
+    }
+    const key = operationIdentityKey(operationId);
+    if (this.pending.has(key)) {
+      return Promise.reject(new Error(`Mesh operation '${key}' is already pending.`));
+    }
+    return new Promise((resolve, reject) => {
+      const abort = () => {
+        this.pending.delete(key);
+        reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+      };
+      if (signal?.aborted === true) {
+        abort();
+        return;
+      }
+      signal?.addEventListener('abort', abort, { once: true });
+      this.pending.set(key, {
+        resolve,
+        reject,
+        removeAbort: signal === undefined
+          ? undefined
+          : () => signal.removeEventListener('abort', abort)
+      });
+    });
+  }
+
+  private isDisposed(): boolean {
+    return this.disposed;
+  }
+
+  complete(record: ReceiveRecord): void {
+    const key = operationIdentityKey(record.operationId);
+    const pending = this.pending.get(key);
+    if (pending === undefined) {
+      this.onDiagnostic?.({
+        kind: 'unknownOrLate',
+        operationId: Object.freeze({ ...record.operationId }),
+        terminalResult: record.terminalResult
+      });
+      return;
+    }
+    this.pending.delete(key);
+    pending.removeAbort?.();
+    try {
+      pending.resolve(copyCompletion(record));
+    } catch (error) {
+      pending.reject(error);
+    }
+  }
+
+  dispose(reason: unknown = new Error('Mesh completion table is disposed.')): void {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    const pending = [...this.pending.values()];
+    this.pending.clear();
+    for (const entry of pending) {
+      entry.removeAbort?.();
+    }
+    for (const entry of pending) {
+      entry.reject(reason);
+    }
+  }
+
+  get pendingCount(): number {
+    return this.pending.size;
+  }
+
+}
+
+function copyCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
+  return {
+    terminalResult: record.terminalResult,
+    failureErrno: record.failureErrno,
+    operationKind: record.operationKind,
+    kindData: record.kindData,
+    parts: record.parts.map((part) => Message.fromOwned(Buffer.from(part.data())))
+  };
+}
+
+export function closeMeshCompletion(completion: ZLinkMeshCompletion): void {
+  closeParts(completion.parts);
+}
+
+function closeParts(parts: readonly Message[]): void {
+  for (const part of parts) {
+    part.close();
+  }
+}

package/src/runtime/backend/mesh-dispatch-pump.ts

@@ -0,0 +1,363 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+import {
+  ReadyDomain,
+  type ReadyRecord,
+  type ReceiveRecord
+} from '../foundation/service-runtime-contracts';
+import type { ZLinkBackendMeshNode } from './contracts';
+import { runZLinkExecutionArea } from '../execution';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
+import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+
+const MESH_DISPATCH_TIMER_YIELD_BATCHES = 16;
+const MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS = 2;
+const MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET = 4;
+// Captured while the runtime module is loaded, before any application owner
+// exists. A ready callback may run inside a Spot turn; the shared Mesh pump
+// must enter like an independent receive-loop task, without inheriting that
+// owner's AsyncLocalStorage identity.
+const detachedMeshDispatchScope = AsyncLocalStorage.snapshot();
+
+export interface ZLinkMeshDispatchPumpOptions {
+  readonly readyCapacity?: number;
+  readonly messageCapacity?: number;
+  readonly partCapacity?: number;
+  readonly dispatch: (owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
+  readonly applicationJobQueue: ApplicationJobQueuePort;
+  readonly reportError?: (error: unknown, context?: ZLinkMeshDispatchFailureContext) => void;
+  readonly monotonicNowMs?: () => number;
+}
+
+export interface ZLinkMeshDispatchFailureContext {
+  readonly receiveKind: number;
+  readonly operationKind: number;
+  readonly packetName?: string;
+  readonly sourceNodeRid?: string;
+  readonly commandId?: number;
+}
+
+class ZLinkMeshDispatchFailure extends Error {
+  constructor(
+    readonly context: ZLinkMeshDispatchFailureContext,
+    readonly dispatchCause: unknown
+  ) {
+    super('Mesh record dispatch failed.', { cause: dispatchCause });
+    this.name = 'ZLinkMeshDispatchFailure';
+  }
+}
+
+export class ZLinkMeshDispatchPump {
+  private pendingDomains: number = ReadyDomain.None;
+  private scheduled = false;
+  private infrastructureScheduled = false;
+  private disposed = false;
+  private drainPromise?: Promise<void>;
+  private infrastructureDrainPromise?: Promise<void>;
+  private readonly activeDrains = new Set<Promise<void>>();
+  private readonly capacityStop = new AbortController();
+
+  constructor(
+    private readonly node: ZLinkBackendMeshNode,
+    private readonly options: ZLinkMeshDispatchPumpOptions
+  ) {
+  }
+
+  start(): void {
+    this.node.setReadyHandler((domains) => {
+      if (this.disposed) {
+        return ReadyDomain.None;
+      }
+      this.pendingDomains |= domains;
+      this.schedule();
+      return domains;
+    });
+  }
+
+  async dispose(): Promise<void> {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.capacityStop.abort();
+    this.pendingDomains = ReadyDomain.None;
+    while (this.activeDrains.size > 0) {
+      await Promise.all([...this.activeDrains]);
+    }
+  }
+
+  private schedule(): void {
+    if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+      this.scheduleInfrastructure();
+    }
+    if ((this.pendingDomains & ReadyDomain.Application) === 0) {
+      return;
+    }
+    if (this.scheduled) {
+      return;
+    }
+    this.scheduled = true;
+    const drain = yieldToEventLoop()
+      .then(() => detachedMeshDispatchScope(() => this.drain()))
+      .catch((error) => {
+        if (error instanceof ZLinkMeshDispatchFailure) {
+          this.options.reportError?.(error.dispatchCause, error.context);
+          return;
+        }
+        this.options.reportError?.(error);
+      });
+    this.activeDrains.add(drain);
+    this.drainPromise = drain;
+    void drain.finally(() => {
+      this.activeDrains.delete(drain);
+      if (this.drainPromise === drain) {
+        this.drainPromise = undefined;
+        this.scheduled = false;
+        if (!this.disposed && this.pendingDomains !== ReadyDomain.None) {
+          this.schedule();
+        }
+      }
+    });
+  }
+
+  /**
+   * Infrastructure controls must not wait for an application permit. During
+   * source draining an application claim can legitimately remain parked at
+   * `acquirePermit`; sharing that turn would strand Ready/State/Cutover in
+   * the infrastructure mailbox and prevent the relocation coordinator from
+   * completing the drain that releases the application work.
+   */
+  private scheduleInfrastructure(): void {
+    if (this.infrastructureScheduled) {
+      return;
+    }
+    this.infrastructureScheduled = true;
+    const drain = yieldToEventLoop()
+      .then(() => detachedMeshDispatchScope(() => this.drainInfrastructure()))
+      .catch((error) => {
+        if (error instanceof ZLinkMeshDispatchFailure) {
+          this.options.reportError?.(error.dispatchCause, error.context);
+          return;
+        }
+        this.options.reportError?.(error);
+      });
+    this.activeDrains.add(drain);
+    this.infrastructureDrainPromise = drain;
+    void drain.finally(() => {
+      this.activeDrains.delete(drain);
+      if (this.infrastructureDrainPromise === drain) {
+        this.infrastructureDrainPromise = undefined;
+        this.infrastructureScheduled = false;
+        if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+          this.scheduleInfrastructure();
+        }
+      }
+    });
+  }
+
+  private async drain(): Promise<void> {
+    while (!this.disposed) {
+      if ((this.pendingDomains & ReadyDomain.Application) === 0) {
+        return;
+      }
+      this.pendingDomains &= ~ReadyDomain.Application;
+      await this.drainDomain(ReadyDomain.Application);
+    }
+  }
+
+  private async drainInfrastructure(): Promise<void> {
+    while (!this.disposed) {
+      if ((this.pendingDomains & ReadyDomain.Infrastructure) === 0) {
+        return;
+      }
+      this.pendingDomains &= ~ReadyDomain.Infrastructure;
+      const lifecycleBudgetExhausted = await this.drainDomain(
+        ReadyDomain.Infrastructure,
+        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+      );
+      if (lifecycleBudgetExhausted) {
+        this.pendingDomains |= ReadyDomain.Infrastructure;
+      }
+    }
+  }
+
+  private async drainDomain(domain: number, claimBudget?: number): Promise<boolean> {
+    const readyCapacity = domain === ReadyDomain.Application
+      ? 1
+      : claimBudget === undefined
+        ? (this.options.readyCapacity ?? 32)
+        : Math.min(this.options.readyCapacity ?? 32, claimBudget);
+    const readyBatch = this.node.createReadyBatch(readyCapacity);
+    // One record per claim receive keeps one ordinary-ingress permit paired
+    // with exactly one dispatch turn. Terminal completion claims bypass it.
+    const receiveBatch = this.node.createReceiveBatch(1, this.options.partCapacity ?? 256);
+    let receiveBatchesSinceTimerYield = 0;
+    let timerYieldStartedAtMs = this.nowMs();
+    let claimsDrained = 0;
+    try {
+      for (;;) {
+        if (claimBudget !== undefined && claimsDrained >= claimBudget) {
+          // Lifecycle work has priority, but a bounded turn lets application
+          // work make progress when lifecycle records keep arriving.
+          return true;
+        }
+        readyBatch.reset();
+        const drained = this.node.drainReady(domain, readyBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+        if (!drained.ok || drained.records.length === 0) {
+          return false;
+        }
+        if (domain === ReadyDomain.Application && drained.hasResidue) {
+          this.pendingDomains |= ReadyDomain.Application;
+        }
+        for (let index = 0; index < drained.records.length; index += 1) {
+          const claim = readyBatch.takeClaim(index);
+          claimsDrained += 1;
+          try {
+            receiveBatch.reset();
+            for (;;) {
+              const owner = drained.records[index];
+              const claimPermit = owner.terminalCompletion === true
+                || owner.ordinaryIngressPreAdmitted === true
+                || domain === ReadyDomain.Infrastructure
+                ? undefined
+                : await this.acquirePermit();
+              if (claimPermit === undefined
+                  && this.disposed
+                  && owner.terminalCompletion !== true
+                  && owner.ordinaryIngressPreAdmitted !== true) return false;
+              const received = claim.recvBatch(receiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+              if (!received.ok) {
+                claimPermit?.releaseAfterInternalProcessing();
+                break;
+              }
+              if (received.records.length === 0) {
+                claimPermit?.releaseAfterInternalProcessing();
+              }
+              for (const record of received.records) {
+                const permit = record.applicationJobPermit ?? claimPermit;
+                if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                  record.releaseRetainedIngress?.();
+                  throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+                }
+                try {
+                  // A handler may synchronously submit an operation whose
+                  // control/completion is owned by this same MeshNode (e.g. a
+                  // native Completion record fed back through this node's own
+                  // Infrastructure claim). The active lane's scheduling state
+                  // must be released here, or a nested re-entrant drain can
+                  // never start to deliver that completion, and the awaiting
+                  // handler deadlocks against its own claim (spec
+                  // 46-internal-dispatch-loop, receive/dispatch wake/ordering).
+                  this.scheduled = false;
+                  this.drainPromise = undefined;
+                  if (domain === ReadyDomain.Infrastructure) {
+                    this.infrastructureScheduled = false;
+                    this.infrastructureDrainPromise = undefined;
+                  }
+                  if (this.pendingDomains !== ReadyDomain.None) {
+                    this.schedule();
+                  }
+                  const dispatch = () => runZLinkExecutionArea(
+                    domain === ReadyDomain.Infrastructure ? 'infrastructure' : 'application',
+                    async () => {
+                      try {
+                        await this.options.dispatch(drained.records[index], record);
+                      } catch (error) {
+                        throw new ZLinkMeshDispatchFailure(
+                          meshDispatchFailureContext(record),
+                          error
+                        );
+                      }
+                      await record.onTerminalCompletion?.();
+                    }
+                  );
+                  if (permit === undefined) {
+                    await dispatch();
+                  } else {
+                    if (
+                      domain === ReadyDomain.Application
+                      && record.applicationJobPermit === undefined
+                    ) permit.markApplicationQueued();
+                    await runWithApplicationJobPermit(permit, dispatch);
+                  }
+                } finally {
+                  for (const part of record.parts) {
+                    part.close();
+                  }
+                  record.releaseRetainedIngress?.();
+                }
+              }
+              // A continuously readable owner must not keep the timers phase
+              // from running, but a timer turn for every single record adds a
+              // Promise, closure, and timer allocation to the hot path.
+              receiveBatchesSinceTimerYield += 1;
+              if (
+                receiveBatchesSinceTimerYield >= MESH_DISPATCH_TIMER_YIELD_BATCHES
+                || this.nowMs() - timerYieldStartedAtMs >= MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS
+              ) {
+                receiveBatchesSinceTimerYield = 0;
+                await yieldToTimers();
+                timerYieldStartedAtMs = this.nowMs();
+              }
+              receiveBatch.reset();
+            }
+          } finally {
+            claim.release();
+          }
+        }
+        await yieldToTimers();
+        receiveBatchesSinceTimerYield = 0;
+        timerYieldStartedAtMs = this.nowMs();
+        if (!drained.hasResidue) {
+          return false;
+        }
+      }
+    } finally {
+      receiveBatch.close();
+      readyBatch.close();
+    }
+  }
+
+  private nowMs(): number {
+    return this.options.monotonicNowMs?.() ?? performance.now();
+  }
+
+  private async acquirePermit(): Promise<ApplicationJobPermitPort | undefined> {
+    try {
+      return await this.options.applicationJobQueue.acquire(this.capacityStop.signal);
+    } catch (error) {
+      if (this.disposed || this.capacityStop.signal.aborted) return undefined;
+      throw error;
+    }
+  }
+}
+
+function meshDispatchFailureContext(record: ReceiveRecord): ZLinkMeshDispatchFailureContext {
+  const commandId = serviceWireCommand(record);
+  return {
+    receiveKind: record.kind,
+    operationKind: record.operationKind,
+    ...(record.packetName === undefined ? {} : { packetName: record.packetName }),
+    ...(record.sourceNodeRid === null ? {} : { sourceNodeRid: String(record.sourceNodeRid) }),
+    ...(commandId === undefined ? {} : { commandId })
+  };
+}
+
+function serviceWireCommand(record: ReceiveRecord): number | undefined {
+  if (record.parts.length !== 1) return undefined;
+  const bytes = record.parts[0]!.data();
+  return bytes.byteLength >= 5 && bytes[0] === 0x5a && bytes[1] === 0x4d && bytes[2] === 1
+    ? bytes[3]
+    : undefined;
+}
+
+function yieldToEventLoop(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+function yieldToTimers(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}

package/src/runtime/backend/mesh-record-dispatcher.ts

@@ -0,0 +1,65 @@
+import {
+  ReadyOwnerKind,
+  ReceiveKind,
+  type ReadyRecord,
+  type ReceiveRecord
+} from '../foundation/service-runtime-contracts';
+import { requireZLinkInfrastructureExecutionArea } from '../execution';
+
+export interface ZLinkMeshRecordDispatchPorts {
+  readonly node: (record: ReceiveRecord) => void | Promise<void>;
+  readonly spot: (owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
+  readonly actor: (owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
+  readonly completion: (record: ReceiveRecord) => void | Promise<void>;
+  readonly sendReady: (record: ReceiveRecord) => void | Promise<void>;
+  readonly transferControl: (record: ReceiveRecord) => void | Promise<void>;
+}
+
+/**
+ * Routes one pulled Core record to the framework component that owns its
+ * lifecycle. The pump retains the record until the returned promise settles.
+ */
+export class ZLinkMeshRecordDispatcher {
+  constructor(private readonly ports: ZLinkMeshRecordDispatchPorts) {}
+
+  dispatch(owner: ReadyRecord, record: ReceiveRecord): void | Promise<void> {
+    switch (record.kind) {
+      case ReceiveKind.NodeSend:
+      case ReceiveKind.NodeRequest:
+      case ReceiveKind.ChannelSend:
+      case ReceiveKind.ChannelRequest:
+        this.requireOwner(owner, ReadyOwnerKind.Node, record);
+        return this.ports.node(record);
+      case ReceiveKind.SpotSend:
+      case ReceiveKind.SpotRequest:
+      case ReceiveKind.SpotMulticast:
+      case ReceiveKind.SpotControl:
+        this.requireOwner(owner, ReadyOwnerKind.Spot, record);
+        return this.ports.spot(owner, record);
+      case ReceiveKind.ActorSend:
+      case ReceiveKind.ActorRequest:
+      case ReceiveKind.ActorBinding:
+        this.requireOwner(owner, ReadyOwnerKind.Actor, record);
+        return this.ports.actor(owner, record);
+      case ReceiveKind.Completion:
+        requireZLinkInfrastructureExecutionArea();
+        return this.ports.completion(record);
+      case ReceiveKind.SendReady:
+        requireZLinkInfrastructureExecutionArea();
+        return this.ports.sendReady(record);
+      case ReceiveKind.TransferControl:
+        requireZLinkInfrastructureExecutionArea();
+        return this.ports.transferControl(record);
+      default:
+        throw new Error(`Unsupported MeshNode receive kind '${record.kind}'.`);
+    }
+  }
+
+  private requireOwner(owner: ReadyRecord, expected: number, record: ReceiveRecord): void {
+    if (owner.ownerKind !== expected) {
+      throw new Error(
+        `MeshNode receive kind '${record.kind}' requires owner kind '${expected}', got '${owner.ownerKind}'.`
+      );
+    }
+  }
+}

package/src/runtime/backend/node/index.ts

@@ -0,0 +1,4 @@
+export * from './node-backend-adapter-factory';
+export * from './node-mesh-backend-adapter';
+export * from './node-raw-mesh-backend';
+export { getNodeBindingInfo } from '../node-backend-adapter';