@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/streams/index.ts

@@ -1,44 +1,45 @@
-import type {
-  ActorRef,
-  Type,
-  ZLinkActor,
-  ZLinkBoundSession,
-  ZLinkSessionActor,
-  ZLinkSessionFactory,
-  ZLinkSession,
-  ZLinkMessageSerializer,
-  ZLinkStreamCompressionCodec,
-  ZLinkStreamCompressionOptions
+import {
+  type ActorRef,
+  type Type,
+  type ZLinkActor,
+  type ZLinkBoundSession,
+  type ZLinkMessageSerializer,
+  type ZLinkSession,
+  type ZLinkSessionActor,
+  type ZLinkSessionFactory,
+  type ZLinkStreamCompressionCodec,
+  type ZLinkStreamCompressionOptions,
+  ZLinkMessage
 } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { ZLinkSubmitResult } from '../messaging/submission-result';
-import { ZLinkMessage } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import {
-  buildAdvertisedEndpoint,
-  ZLinkConfigurationException,
-  type ZLinkFrameworkRegistration
-} from '../configuration';
-import { ZLinkDispatchErrorReporter } from '../channels';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from '../../contracts/Configuration/InternalDefaults';
+import { zlinkDefaultLocationOptions } from '../../contracts/Locations/Options';
 import type {
-  ZLinkBackendAdapterFactory,
   ZLinkBackendActorSessionNode,
+  ZLinkBackendAdapterFactory,
   ZLinkBackendContext,
   ZLinkBackendMeshNode,
   ZLinkBackendSocketMonitor,
   ZLinkBackendStreamSocket
 } from '../backend/contracts';
 import type { ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';
+import { ZLinkDispatchErrorReporter } from '../channels';
+import {
+  buildAdvertisedEndpoint,
+  ZLinkConfigurationException,
+  type ZLinkFrameworkRegistration
+} from '../configuration';
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { StreamSessionService } from '../foundation/service-runtime-contracts';
 import { registerServiceSessionBindingIngressPort } from '../foundation/service-session-binding-ingress-port';
 import {
-  messageToBytes,
-  ZLinkStreamCodec,
-  type ZLinkStreamFrameHeader,
-  ZLinkStreamMessageKind,
-  type ZLinkStreamReplyMessageKind
-} from './protocol';
+  ApplicationJobQueue,
+  resolveApplicationJobQueueConfiguration
+} from '../host/application-job-queue';
+import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import {
+  DEFAULT_TERMINAL_RELOCATION_CAPACITY,
   ZLinkActorSessionBindingRegistry,
   type ZLinkActorSessionAuthorityFence
 } from './actor-session-binding-registry';
@@ -47,38 +48,45 @@ import {
   registerActorSessionBindingRuntimeOwner
 } from './actor-session-binding-runtime-owner';
 import { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
+import { ZLinkBoundActorRelaySender } from './bound-actor-relay-sender';
 import {
-  decompressStreamPayload,
-  resolveStreamCompressionCodec,
-  ZLinkStreamFrameMessageFactory
-} from './stream-frame-factory';
+  DefaultZLinkBoundSessionResponseTarget,
+  type ZLinkBoundSessionResponseTarget
+} from './bound-session-response-target';
+import { ZLinkBoundSessionService, type ZLinkBoundSessionTransport } from './bound-session-service';
+import { ZLinkManagedStream } from './managed-stream';
 import {
-  ApplicationJobQueue,
-  resolveApplicationJobQueueConfiguration
-} from '../host/application-job-queue';
-import { simpleMessage } from './stream-message-utils';
+  messageToBytes,
+  ZLinkStreamCodec,
+  ZLinkStreamMessageKind,
+  type ZLinkStreamFrameHeader,
+  type ZLinkStreamReplyMessageKind
+} from './protocol';
+import { ZLinkSessionActorCoordinator } from './session-actor-coordinator';
 import {
   DefaultZLinkBoundSession,
   DefaultZLinkSessionActor,
   DefaultZLinkSessionContext
 } from './session-context';
-import {
-  DefaultZLinkBoundSessionResponseTarget,
-  type ZLinkBoundSessionResponseTarget
-} from './bound-session-response-target';
-import { ZLinkBoundSessionService, type ZLinkBoundSessionTransport } from './bound-session-service';
-import { ZLinkSessionActorCoordinator } from './session-actor-coordinator';
-import { ZLinkBoundActorRelaySender } from './bound-actor-relay-sender';
-import { ZLinkManagedStream } from './managed-stream';
 import { createStreamSessionInstance } from './session-provider';
-import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from '../../contracts/Configuration/InternalDefaults';
+import type {
+  ZLinkActorRouteCommitOptions,
+  ZLinkSessionBindingConfirmationOptions,
+  ZLinkSessionBindingIdentity
+} from './stream-binding-runtime-ports';
+import {
+  decompressStreamPayload,
+  resolveStreamCompressionCodec,
+  ZLinkStreamFrameMessageFactory
+} from './stream-frame-factory';
+import { simpleMessage } from './stream-message-utils';
 import {
   ZLinkStreamSessionNodeRuntime as ZLinkStreamSessionNodeRuntimeCore,
   ZLinkStreamSessionRuntime as ZLinkStreamSessionRuntimeCore,
   type ZLinkStreamSessionNodeRuntimeOptions as ZLinkStreamSessionNodeRuntimeCoreOptions,
   type ZLinkStreamSessionRuntimeOptions as ZLinkStreamSessionRuntimeCoreOptions
 } from './stream-session-runtime';
-import type { ZLinkActorRouteCommitOptions } from './stream-binding-runtime-ports';
+const DEFAULT_STREAM_SERVICE_SHUTDOWN_TIMEOUT_MS = 1000;
 export { ZLinkPendingSessionRequest } from './session-requests';
 export { ZLinkActorSessionLifecycleCoordinator } from './actor-session-lifecycle-coordinator';
 export { ZLinkActorSessionBindingRegistry } from './actor-session-binding-registry';
@@ -98,6 +106,7 @@ export type {
 } from './bound-session-service';
 
 export interface ZLinkStreamBindingRuntimeOptions {
+  readonly dispatchErrors?: ZLinkDispatchErrorReporter;
   readonly transport?: ZLinkBoundSessionTransport;
   readonly messageFactory?: ZLinkStreamMessageFactory;
   readonly streamPayloadCodec?: ZLinkStreamPayloadCodec;
@@ -120,7 +129,7 @@ export interface ZLinkStreamBindingRuntimeOptions {
     actor: ActorRef,
     sessionRid: ActorRef['nodeRid'],
     signal?: AbortSignal,
-    options?: { readonly waitForAcknowledgement?: boolean }
+    options?: ZLinkSessionBindingConfirmationOptions
   ) => Promise<void>;
   readonly errorSink?: () =>
     | {
@@ -167,6 +176,7 @@ export interface ZLinkStreamSessionNodeRuntimeOptions extends Omit<
 }
 
 export interface ZLinkStreamRuntimeManagerOptions {
+  readonly listenerRecords?: ZLinkListenerRecords;
   readonly registration: ZLinkFrameworkRegistration;
   readonly backendAdapterFactory: ZLinkBackendAdapterFactory;
   readonly context: ZLinkBackendContext;
@@ -183,14 +193,16 @@ export interface ZLinkStreamRuntimeManagerOptions {
   readonly applicationJobQueue?: ApplicationJobQueue;
 }
 
+// A STREAM node's native resources, recorded as each one is created. The
+// manager owns them from creation, so `dispose` releases whatever a failed
+// `start` had already opened; an unreleased socket keeps the context from
+// terminating.
 interface ZLinkStartedStreamNode {
   readonly meshName?: string;
-  readonly advertisedEndpoint: string;
-  readonly runtime: ZLinkStreamSessionNodeRuntimeCore;
   readonly socket: ZLinkBackendStreamSocket;
-  readonly monitor: ZLinkBackendSocketMonitor;
-  readonly nativeSessionService?: StreamSessionService;
-  readonly nativeSessionServices?: readonly StreamSessionService[];
+  readonly nativeSessionServices: StreamSessionService[];
+  monitor?: ZLinkBackendSocketMonitor;
+  runtime?: ZLinkStreamSessionNodeRuntimeCore;
 }
 
 export class ZLinkStreamRuntimeManager {
@@ -215,6 +227,12 @@ export class ZLinkStreamRuntimeManager {
       const nativeMeshNode = actorDispatchEnabled ? this.options.nativeMeshNode : undefined;
       const meshCompletions = actorDispatchEnabled ? this.options.meshCompletions : undefined;
       const socket = streamAdapter.createStreamSocket(this.options.context);
+      const node: ZLinkStartedStreamNode = {
+        meshName: applicationMeshName,
+        socket,
+        nativeSessionServices: []
+      };
+      this.nodes.set(nodeName, node);
       // Core uses -1 as the explicit unlimited value. The Framework value 0
       // means that it adds no separate STREAM cap, so preserve that meaning
       // when applying the socket option.
@@ -240,7 +258,6 @@ export class ZLinkStreamRuntimeManager {
           `STREAM node '${nodeName}' advertised host requires a TCP endpoint, received '${boundEndpoint}'.`
         );
       }
-      const readablePoller = streamAdapter.createReadablePoller(socket);
       const nativeSessionRoutes = new Map<
         string,
         {
@@ -262,12 +279,10 @@ export class ZLinkStreamRuntimeManager {
           const createService = meshNode?.createStreamSessionService;
           if (typeof createService !== 'function' || completions === undefined) continue;
           const service = createService.call(meshNode, socket.nativeInstance as never);
+          node.nativeSessionServices.push(service);
           const bindingOwner = actorSessionBindingRuntimeOwner(this.options.bindingRuntime);
           registerServiceSessionBindingIngressPort(service, {
-            actorSlot: (actorId, sessionRid) => bindingOwner.actorSlot(actorId, sessionRid),
-            retainOutbound: (claim, delivery) =>
-              bindingOwner.admitRelocationOutbound(claim, delivery),
-            clearOutbound: (actorId, error) => bindingOwner.clearRelocation(actorId, error)
+            actorSlot: (actorId, sessionRid) => bindingOwner.actorSlot(actorId, sessionRid)
           });
           nativeSessionRoutes.set(meshName, {
             service,
@@ -280,11 +295,15 @@ export class ZLinkStreamRuntimeManager {
           ? undefined
           : nativeSessionRoutes.get(applicationMeshName)?.service;
       const monitor = monitoringAdapter.openSocketMonitor(socket);
+      node.monitor = monitor;
       const sessionType = streamNode.session!;
       const sessionHandlerTypes =
         (streamNode as unknown as Record<symbol, readonly Type[] | undefined>)[
           Symbol.for('@zlink-systems/framework:session-handler-types')
         ] ?? [];
+      // The runtime disposes the poller, so the poller is created where nothing
+      // can fail before the runtime owns it.
+      const readablePoller = streamAdapter.createReadablePoller(socket);
       const runtime = new ZLinkStreamSessionNodeRuntimeCore({
         nodeName,
         socket,
@@ -310,41 +329,31 @@ export class ZLinkStreamRuntimeManager {
             sessionHandlerTypes
           )
       });
+      node.runtime = runtime;
       runtime.start();
-      this.nodes.set(nodeName, {
-        meshName: applicationMeshName,
-        advertisedEndpoint,
-        runtime,
-        socket,
-        monitor,
-        nativeSessionService,
-        nativeSessionServices: [...nativeSessionRoutes.values()].map((route) => route.service)
-      });
+      this.options.listenerRecords?.record('stream', nodeName, advertisedEndpoint);
     }
   }
 
   async dispose(): Promise<void> {
     const nodes = [...this.nodes.values()];
-    this.nodes.clear();
     for (const node of nodes.reverse()) {
-      await node.runtime.dispose();
-      const nativeServices =
-        node.nativeSessionServices ??
-        (node.nativeSessionService === undefined ? [] : [node.nativeSessionService]);
-      for (const service of nativeServices) {
-        service.shutdown(1000);
+      await node.runtime?.dispose();
+      for (const service of node.nativeSessionServices) {
+        service.shutdown(DEFAULT_STREAM_SERVICE_SHUTDOWN_TIMEOUT_MS);
         service.close();
       }
-      await node.monitor.dispose();
+      await node.monitor?.dispose();
       await node.socket.dispose();
     }
+    this.nodes.clear();
   }
 
   async notifyServerDrain(meshName: string): Promise<void> {
     await Promise.all(
       [...this.nodes.values()]
         .filter((node) => node.meshName === meshName)
-        .map((node) => node.runtime.drainCloseSessions())
+        .map((node) => node.runtime?.drainCloseSessions())
     );
   }
 
@@ -352,7 +361,7 @@ export class ZLinkStreamRuntimeManager {
     await Promise.all(
       [...this.nodes.values()]
         .filter((node) => node.meshName === undefined)
-        .map((node) => node.runtime.drainCloseSessions())
+        .map((node) => node.runtime?.drainCloseSessions())
     );
   }
 }
@@ -369,6 +378,7 @@ export class ZLinkStreamSessionRuntime extends ZLinkStreamSessionRuntimeCore {
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super(
@@ -392,6 +402,7 @@ export class ZLinkStreamSessionNodeRuntime extends ZLinkStreamSessionNodeRuntime
     const bindingRuntime =
       options.bindingRuntime ??
       new ZLinkStreamBindingRuntime({
+        dispatchErrors: options.dispatchErrors,
         flowCreationEnabled: () => options.dispatchErrors?.flow.flowCreationEnabled() ?? true
       });
     super({
@@ -420,7 +431,12 @@ export class ZLinkStreamBindingRuntime {
     this.routes = new ZLinkActorSessionBindingRegistry<
       DefaultZLinkSessionContext,
       DefaultZLinkSessionActor
-    >(4096, 4096, runtimeOptions.sessionRelocationSealTimeoutMs ?? 3_000, runtimeOptions.errorSink);
+    >(
+      DEFAULT_TERMINAL_RELOCATION_CAPACITY,
+      runtimeOptions.sessionRelocationSealTimeoutMs ??
+        zlinkDefaultLocationOptions.sessionRelocationSealTimeoutMs,
+      runtimeOptions.errorSink
+    );
     this.compressionCodec = resolveStreamCompressionCodec(runtimeOptions.streamCompression);
     this.frameMessages = new ZLinkStreamFrameMessageFactory(runtimeOptions);
     this.boundSessions = new ZLinkBoundSessionService(
@@ -442,21 +458,11 @@ export class ZLinkStreamBindingRuntime {
       actorSessionLifecycle
     );
     registerActorSessionBindingRuntimeOwner(this, {
-      actorSlot: async (actorId, sessionRid) => {
-        const route = await this.routes.route(actorId);
-        return route !== undefined && route.sessionIdentity === sessionRid
-          ? route.actorSlot
-          : undefined;
-      },
+      actorSlot: async (actorId, sessionRid) =>
+        (await this.routes.routeForSessionBinding(actorId, sessionRid))?.actorSlot,
       sealRelocation: (claim, expected, signal) =>
         this.routes.sealRelocation(claim, expected, signal),
       relocationSnapshot: (actorId, sealId) => this.routes.relocationSnapshot(actorId, sealId),
-      retainRelocationOutbound: (actorId, operation, sealId) =>
-        this.routes.retainRelocationOutbound(actorId, operation, sealId),
-      admitRelocationOutbound: (claim, operation) =>
-        this.routes.admitRelocationOutbound(claim, operation),
-      discardRelocationOutbound: (actorId, sealId, error) =>
-        this.routes.discardRelocationOutbound(actorId, sealId, error),
       applyRelocation: (...args) => this.routes.applyRelocation(...args),
       observeRelocationTerminal: (...args) => this.routes.observeRelocationTerminal(...args),
       clearRelocation: (actorId, error) => this.routes.clearRelocation(actorId, error),
@@ -741,6 +747,14 @@ export class ZLinkStreamBindingRuntime {
     await this.boundSessions.disconnectBoundSession(actorId, signal);
   }
 
+  async closeSessionBinding(
+    actorId: string,
+    expected: ZLinkSessionBindingIdentity,
+    signal?: AbortSignal
+  ): Promise<void> {
+    await this.boundSessions.closeSessionBinding(actorId, expected, signal);
+  }
+
   async relay(
     actor: DefaultZLinkSessionActor,
     payload: ZLinkMessage,

package/src/runtime/streams/managed-stream.ts

@@ -10,7 +10,11 @@ import type {
   ZLinkMessageSerializer,
   ZLinkStream
 } from '../../contracts';
-import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../messaging/submission-result';
+import {
+  ZLinkSubmitStatus,
+  classifySubmitResult,
+  type ZLinkSubmitResult
+} from '../messaging/submission-result';
 import type { Message } from '../../contracts/Common/Message';
 import { throwIfAborted } from '../abort';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
@@ -19,14 +23,16 @@ import type {
   ZLinkBackendSendFlags,
   ZLinkBackendStreamSocket
 } from '../backend/contracts';
-import { RequestResult, isBackendNotConnectedError } from '../backend/runtime-values';
+import { RequestResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import { ZLinkBufferMessage as NativeMessage } from '../backend/runtime-message';
+import { diagnosticTextOrAbsent } from '../diagnostics/diagnostic-text';
 import type {
   StreamSessionActorAuthorityFence,
   StreamSessionService
 } from '../foundation/service-runtime-contracts';
 import type { ServiceRetiredBoundSessionRouteFence } from '../foundation/service-stateful-wire-codec';
 import type { ServiceActorRef } from '../foundation/service-stateful-registry';
+import type { ServiceStreamSessionBinding } from '../foundation/service-runtime-contracts';
 import {
   closeMeshCompletion,
   type ZLinkMeshCompletion,
@@ -55,7 +61,8 @@ export interface ZLinkNativeSessionRoute {
 
 interface ZLinkManagedActorBinding {
   readonly actor: ZLinkBackendActorRef;
-  readonly bindingGeneration?: bigint;
+  /** The Session owner's registry snapshot of this binding (Session–Actor binding §5-2). */
+  readonly binding?: ServiceStreamSessionBinding;
   readonly route?: ZLinkNativeSessionRoute;
 }
 
@@ -90,7 +97,12 @@ export class ZLinkManagedStream implements ZLinkStream {
   }
 
   actorBindingGeneration(actorId: string): bigint | undefined {
-    return this.nativeActorBindings.get(actorId)?.bindingGeneration;
+    return this.nativeActorBindings.get(actorId)?.binding?.bindingGeneration;
+  }
+
+  /** The Session owner's registry snapshot of the Actor's current native binding. */
+  actorBinding(actorId: string): ServiceStreamSessionBinding | undefined {
+    return this.nativeActorBindings.get(actorId)?.binding;
   }
 
   private isTransportClosed(): boolean {
@@ -128,7 +140,9 @@ export class ZLinkManagedStream implements ZLinkStream {
       await this.socket.submit(this.backendRoutingId(), payload, timeoutMs);
       return { status: ZLinkSubmitStatus.Submitted };
     } catch (error) {
-      if (isBackendNotConnectedError(error)) return { status: ZLinkSubmitStatus.Backpressured };
+      if (isZLinkBackendResultError(error) && error.operation === 'submit') {
+        return classifySubmitResult(error.result, 'STREAM submit', error.phase);
+      }
       throw error;
     }
   }
@@ -268,7 +282,7 @@ export class ZLinkManagedStream implements ZLinkStream {
       }
       this.nativeActorBindings.set(actor.actorId, {
         actor: nativeActor,
-        bindingGeneration: binding.bindingGeneration,
+        binding,
         route
       });
       return;
@@ -309,7 +323,11 @@ export class ZLinkManagedStream implements ZLinkStream {
           ZLinkFrameworkInternalErrorKind.ActorRouteNotFound,
           `Actor '${actor.actorId}' native route fence does not match its ActorRef ` +
             `(expected ${String(actor.nodeRid)}/${actor.objectGeneration}, ` +
-            `resolved ${resolved === undefined ? 'none' : `${String(resolved.nodeRid)}/${resolved.generation}`}, ` +
+            `resolved ${diagnosticTextOrAbsent(
+              resolved === undefined
+                ? undefined
+                : `${String(resolved.nodeRid)}/${resolved.generation}`
+            )}, ` +
             `terminal=${completion.terminalResult}, failure=${completion.failureErrno}).`
         );
       }
@@ -329,7 +347,8 @@ export class ZLinkManagedStream implements ZLinkStream {
     const binding = this.nativeActorBindings.get(actorId);
     if (binding?.route !== undefined) {
       const route = binding.route;
-      if (!this.hasNativeBinding(route, actorId, binding.bindingGeneration!)) {
+      const bindingGeneration = binding.binding!.bindingGeneration;
+      if (!this.hasNativeBinding(route, actorId, bindingGeneration)) {
         this.nativeActorBindings.delete(actorId);
         return;
       }
@@ -340,7 +359,7 @@ export class ZLinkManagedStream implements ZLinkStream {
               route.service.unbindActor(
                 this.backendRoutingId(),
                 binding.actor as never,
-                binding.bindingGeneration!,
+                bindingGeneration,
                 timeoutMs
               ),
             signal
@@ -356,7 +375,7 @@ export class ZLinkManagedStream implements ZLinkStream {
         // tombstone. A transport teardown can therefore report an internal
         // completion after the exact binding is already gone. Treat only that
         // exact missing binding as stale cleanup; preserve other failures.
-        if (this.hasNativeBinding(route, actorId, binding.bindingGeneration!)) {
+        if (this.hasNativeBinding(route, actorId, bindingGeneration)) {
           throw error;
         }
       }

package/src/runtime/streams/native-fallback-bound-session.ts

@@ -160,9 +160,8 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
   ): Promise<ZLinkSubmitResult> {
     const localActor = this.options.localActorProvider?.() === true;
     const remoteTarget = this.options.remoteBoundSessionTargetProvider();
-    const sealedRemoteTarget = remoteTarget?.relocationSealId !== undefined;
     let nativeAttempted = false;
-    if (localActor && !sealedRemoteTarget) {
+    if (localActor) {
       const result = await this.options.runtime.submitLocalBoundSession(
         this.options.actorId,
         this.message,
@@ -213,7 +212,6 @@ class ZLinkNativeFallbackBoundSessionSendCall implements ZLinkBoundSessionSendCa
         actorNodeRidHex: (actorRef?.nodeRid as { toHex?: () => string } | undefined)?.toHex?.(),
         actorGeneration: actorRef?.objectGeneration.toString(),
         actorOwnershipGeneration: ownershipGeneration?.toString(),
-        relocationSealId: remoteTarget.relocationSealId,
         message: this.message,
         boundPacketName: packetName,
         metadata: this.selectedMetadata,

package/src/runtime/streams/protocol.ts

@@ -1,90 +1,52 @@
-import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkFlowOrigin } from '../../contracts';
-import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import {
+  ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode,
+  ZlinkStreamCodec as ZLinkStreamCodec,
+  ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags,
+  ZlinkStreamMessageKind as ZLinkStreamMessageKind,
+  ZlinkStreamControlPacket,
   decodeStreamWireFrame,
   decodeStreamWireHeader,
+  defaultMaxDecompressedPayloadSize,
+  encodeStreamWireActorBoundPayload,
+  encodeStreamWireActorUnboundPayload,
   encodeStreamWireFrame,
   encodeStreamWireHeader,
+  encodeStreamWireSessionClosingPayload,
   lz4PickleUncompressed,
   lz4UnpicklePayload,
   tryDecodeStreamWireFrame,
-  utf8Encode
+  streamCodecContentType as wireCodecContentType,
+  streamCodecForContentType as wireCodecForContentType
 } from '@zlink-systems/stream-wire';
+import type { ZLinkFlowOrigin } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import { resolveFrameworkPacketName } from '../messaging/packet-name';
 import { throwAlreadySubmitted } from '../messaging/submission-result';
+export {
+  ZlinkStreamMessageKind as ZLinkStreamMessageKind,
+  ZlinkStreamHeaderFlags as ZLinkStreamHeaderFlags,
+  ZlinkStreamCloseReasonCode as ZLinkStreamCloseReasonCode
+} from '@zlink-systems/stream-wire';
 
 export { utf8Decode, utf8Encode } from '@zlink-systems/stream-wire';
 
-const defaultMaxDecompressedPayloadSize = 64 * 1024;
 const actorRequestDeadlineMetadataKey = '$zlink.actor-request-deadline-unix-ms';
 //  Shared empty metadata for the dominant no-metadata frame; ReadonlyMap
 //  keeps every consumer from mutating it.
 const EMPTY_STREAM_METADATA: ReadonlyMap<string, string> = new Map();
 
-export enum ZLinkStreamCodec {
-  Raw = 0,
-  Json = 1,
-  MessagePack = 2,
-  Protobuf = 3
-}
+export { ZlinkStreamCodec as ZLinkStreamCodec } from '@zlink-systems/stream-wire';
 
 export function streamCodecContentType(codec: ZLinkStreamCodec): string {
-  switch (codec) {
-    case ZLinkStreamCodec.Json:
-      return 'application/json';
-    case ZLinkStreamCodec.MessagePack:
-      return 'application/x-msgpack';
-    case ZLinkStreamCodec.Protobuf:
-      return 'application/x-protobuf';
-    case ZLinkStreamCodec.Raw:
-      return 'application/octet-stream';
-  }
-  throw new TypeError(`Unsupported STREAM codec '${codec}'.`);
+  return wireCodecContentType(codec);
 }
 
 export function streamCodecForContentType(contentType: string): ZLinkStreamCodec {
-  switch (contentType) {
-    case 'application/json':
-      return ZLinkStreamCodec.Json;
-    case 'application/x-msgpack':
-      return ZLinkStreamCodec.MessagePack;
-    case 'application/x-protobuf':
-      return ZLinkStreamCodec.Protobuf;
-    case 'application/octet-stream':
-      return ZLinkStreamCodec.Raw;
-  }
-  throw new TypeError(`Unsupported STREAM content type '${contentType}'.`);
+  return wireCodecForContentType(contentType);
 }
 
-export enum ZLinkStreamMessageKind {
-  Send = 1,
-  Request = 2,
-  Response = 3,
-  Error = 4,
-  Control = 5
-}
-
-export enum ZLinkStreamHeaderFlags {
-  None = 0,
-  HasRequestSeq = 0x01,
-  HasMetadata = 0x02,
-  PayloadCompressed = 0x04,
-  HasCorrelationId = 0x08,
-  HasFlowId = 0x10,
-  HasActorSlot = 0x20
-}
-
-export enum ZLinkStreamCloseReasonCode {
-  ClientClose = 1,
-  IdleTimeout = 2,
-  HeartbeatTimeout = 3,
-  ServerDrain = 4,
-  ProtocolError = 5,
-  TransportError = 6
-}
-
-export const ZLINK_STREAM_HEARTBEAT_PING = '$zlink.heartbeat.ping';
-export const ZLINK_STREAM_HEARTBEAT_PONG = '$zlink.heartbeat.pong';
+export const ZLINK_STREAM_HEARTBEAT_PING = ZlinkStreamControlPacket.HeartbeatPing;
+export const ZLINK_STREAM_HEARTBEAT_PONG = ZlinkStreamControlPacket.HeartbeatPong;
 
 export interface ZLinkStreamFrameHeader {
   readonly kind: ZLinkStreamMessageKind;
@@ -142,48 +104,32 @@ export function encodeStreamControlFrame(name: string): Uint8Array {
 }
 
 export function encodeActorBoundFrame(actorSlot: number, actorId: string): Uint8Array {
-  const actorIdBytes = utf8Encode(actorId);
-  if (actorIdBytes.length < 1 || actorIdBytes.length > 0xff) {
-    throw new Error('Actor id length is invalid for a STREAM binding control packet.');
-  }
-  const payload = new Uint8Array(4 + actorIdBytes.length);
-  payload[0] = 1;
-  payload[1] = actorSlot >>> 8;
-  payload[2] = actorSlot & 0xff;
-  payload[3] = actorIdBytes.length;
-  payload.set(actorIdBytes, 4);
-  return encodeStreamFrame(controlHeader('$zlink.actor.bound'), payload);
+  return encodeStreamFrame(
+    controlHeader(ZlinkStreamControlPacket.ActorBound),
+    encodeStreamWireActorBoundPayload(actorSlot, actorId)
+  );
 }
 
 export function encodeActorUnboundFrame(actorSlot: number): Uint8Array {
-  const payload = new Uint8Array(3);
-  payload[0] = 1;
-  payload[1] = actorSlot >>> 8;
-  payload[2] = actorSlot & 0xff;
-  return encodeStreamFrame(controlHeader('$zlink.actor.unbound'), payload);
+  return encodeStreamFrame(
+    controlHeader(ZlinkStreamControlPacket.ActorUnbound),
+    encodeStreamWireActorUnboundPayload(actorSlot)
+  );
 }
 
 export function encodeSessionClosingFrame(
   diagnostic = '',
   reason = ZLinkStreamCloseReasonCode.ServerDrain
 ): Uint8Array {
-  const diagnosticBytes = utf8Encode(diagnostic);
-  if (diagnosticBytes.length > 512) throw new Error('Session-closing diagnostic is too large.');
-  const payload = new Uint8Array(4 + diagnosticBytes.length);
-  payload[0] = 1;
-  payload[1] = reason;
-  payload[2] = diagnosticBytes.length >>> 8;
-  payload[3] = diagnosticBytes.length & 0xff;
-  payload.set(diagnosticBytes, 4);
   return encodeStreamFrame(
     {
       kind: ZLinkStreamMessageKind.Control,
       codec: ZLinkStreamCodec.Raw,
       flags: ZLinkStreamHeaderFlags.None,
-      name: 'session-closing',
+      name: ZlinkStreamControlPacket.SessionClosing,
       metadata: new Map()
     },
-    payload
+    encodeStreamWireSessionClosingPayload(reason, diagnostic)
   );
 }