@zlink-systems/framework 0.25.0 → 0.26.0

package/src/runtime/streams/index.ts

@@ -1,3 +1,4 @@
+import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type {
   ActorRef,
   Type,
@@ -167,6 +168,7 @@ export interface ZLinkStreamSessionNodeRuntimeOptions extends Omit<
 }
 
 export interface ZLinkStreamRuntimeManagerOptions {
+  readonly listenerRecords?: ZLinkListenerRecords;
   readonly registration: ZLinkFrameworkRegistration;
   readonly backendAdapterFactory: ZLinkBackendAdapterFactory;
   readonly context: ZLinkBackendContext;
@@ -183,14 +185,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 +219,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 +250,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,11 +271,12 @@ 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),
+            retainOutbound: (actorId, delivery) =>
+              bindingOwner.retainRelocationOutbound(actorId, delivery),
             clearOutbound: (actorId, error) => bindingOwner.clearRelocation(actorId, error)
           });
           nativeSessionRoutes.set(meshName, {
@@ -280,11 +290,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,16 +324,9 @@ 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);
     }
   }
 
@@ -327,15 +334,12 @@ export class ZLinkStreamRuntimeManager {
     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) {
+      await node.runtime?.dispose();
+      for (const service of node.nativeSessionServices) {
         service.shutdown(1000);
         service.close();
       }
-      await node.monitor.dispose();
+      await node.monitor?.dispose();
       await node.socket.dispose();
     }
   }
@@ -344,7 +348,7 @@ export class ZLinkStreamRuntimeManager {
     await Promise.all(
       [...this.nodes.values()]
         .filter((node) => node.meshName === meshName)
-        .map((node) => node.runtime.drainCloseSessions())
+        .map((node) => node.runtime?.drainCloseSessions())
     );
   }
 
@@ -352,7 +356,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())
     );
   }
 }
@@ -453,8 +457,6 @@ export class ZLinkStreamBindingRuntime {
       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),

package/src/runtime/streams/session-serial-executor.ts

@@ -55,8 +55,8 @@ export class ZLinkSessionSerialExecutor {
     }
     const boundWork = bindApplicationJobPermit(work);
     return hasApplicationJobPermit()
-      ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'lifecycle' })
-      : this.scheduler.submit(boundWork, { lane: 'lifecycle' });
+      ? this.scheduler.submitPreAdmitted(boundWork, { lane: 'application' })
+      : this.scheduler.submit(boundWork, { lane: 'application' });
   }
 
   private submit(

package/dist/runtime/actors/deferred-join-accepted-journal.d.ts

@@ -1,47 +0,0 @@
-import type { ActorRef, ZLinkActor, ZLinkActorJoinOperationId, ZLinkBlobReference, ZLinkMessageSerializer, ZLinkRelocationStore } from '../../contracts';
-import type { ZLinkAuthoritySnapshot } from '../locations/internal-location-contracts';
-import type { ZLinkAuthorityStore } from '../locations/internal-store-contracts';
-export type ZLinkDeferredJoinDeliveryCursor = 'prepared' | 'committed' | 'delivered';
-export interface ZLinkDeferredJoinAcceptedRoot {
-    readonly authority: ZLinkAuthoritySnapshot;
-    readonly reference: ZLinkBlobReference;
-    readonly checksumCrc32c: number;
-    readonly operationId: ZLinkActorJoinOperationId;
-    readonly actor: ActorRef;
-    readonly rawReply: Buffer;
-    readonly replyContentType?: string;
-    readonly cursor: ZLinkDeferredJoinDeliveryCursor;
-}
-export interface ZLinkDeferredJoinRootIdentity {
-    readonly authorityKey: string;
-    readonly objectKind: 'actor' | 'user_spot' | 'instance_spot';
-    readonly objectGeneration: bigint;
-    readonly aggregateId: string;
-    readonly aggregateGeneration: bigint;
-}
-/** Identifies whether an authority slot points at a deferred Join journal root. */
-export declare function isDeferredJoinAcceptedRootPublication(relocation: ZLinkRelocationStore, reference: string, checksumCrc32c: number, expected: ZLinkDeferredJoinRootIdentity, signal?: AbortSignal): Promise<boolean>;
-/**
- * Keeps a cross-node Accepted Join completion under the Actor authority.
- * Every cursor transition writes and verifies a new immutable root before the
- * authority CAS. A failed callback leaves the committed root available for the
- * next target Actor mailbox retry.
- */
-export declare class ZLinkDeferredJoinAcceptedJournal {
-    private readonly authority;
-    private readonly relocation;
-    private readonly messageSerializers?;
-    constructor(authority: ZLinkAuthorityStore, relocation: ZLinkRelocationStore, messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer> | undefined);
-    prepare(actorId: string, operationId: ZLinkActorJoinOperationId, actor: ActorRef, rawReply: Uint8Array, replyContentType?: string, signal?: AbortSignal, canonicalInventoryDigest?: string): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    recover(actorId: string, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot | undefined>;
-    markCommitted(root: ZLinkDeferredJoinAcceptedRoot, actor?: ActorRef, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    markDelivered(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    discardPrepared(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<void>;
-    deliver(root: ZLinkDeferredJoinAcceptedRoot, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    private releaseDelivered;
-    private moveCursor;
-    private readPublished;
-    private storeRoot;
-    private storeCanonicalRoot;
-    private deleteBestEffort;
-}