@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/contracts/Actors/ZLinkActorClient.d.ts

@@ -1,4 +1,5 @@
 import type { ActorId } from '../Common';
+import type { ZLinkRequest } from '../Handlers/Attributes';
 export interface ZLinkActorClient {
     sendToActor(actorId: ActorId, message: unknown): ZLinkActorSendCall;
     requestToActor(actorId: ActorId, request: unknown): ZLinkActorRequestCall;
@@ -10,6 +11,6 @@ export interface ZLinkActorSendCall {
 export interface ZLinkActorRequestCall {
     metadata(key: string, value: string): this;
     timeout(timeoutMs: number): this;
-    submit<TReply>(signal?: AbortSignal): Promise<TReply>;
+    submit<TReply>(signal?: AbortSignal): ZLinkRequest<TReply>;
     yield<TReply>(signal?: AbortSignal): Promise<TReply>;
 }

package/dist/contracts/Channels/Calls.d.ts

@@ -1,4 +1,5 @@
 import type { ZLinkMessageMetadata } from '../Common';
+import type { ZLinkRequest } from '../Handlers/Attributes';
 export interface ZLinkSendCall {
     metadata(key: string, value: string): this;
     metadata(metadata: ZLinkMessageMetadata): this;
@@ -8,7 +9,7 @@ export interface ZLinkRequestCall {
     metadata(key: string, value: string): this;
     metadata(metadata: ZLinkMessageMetadata): this;
     timeout(timeoutMs: number): this;
-    submit<TReply>(signal?: AbortSignal): Promise<TReply>;
+    submit<TReply>(signal?: AbortSignal): ZLinkRequest<TReply>;
 }
 export interface ZLinkChannelRequestCall extends ZLinkRequestCall {
     yield<TReply>(signal?: AbortSignal): Promise<TReply>;

package/dist/contracts/Common/ZLinkMessageMetadata.js

@@ -4,7 +4,7 @@ exports.ZLinkMessageMetadataEmpty = void 0;
 exports.zlinkMessageMetadata = zlinkMessageMetadata;
 class ImmutableZLinkMessageMetadata {
     values;
-    constructor(values = new Map()) {
+    constructor(values = []) {
         this.values = Object.freeze(new ImmutableMetadataMap(values));
     }
     find(key) {
@@ -14,9 +14,7 @@ class ImmutableZLinkMessageMetadata {
 class ImmutableMetadataMap {
     #values;
     constructor(values) {
-        this.#values = new Map(typeof values[Symbol.iterator] === 'function'
-            ? values
-            : Object.entries(values));
+        this.#values = new Map(values);
     }
     get size() {
         return this.#values.size;
@@ -45,5 +43,13 @@ class ImmutableMetadataMap {
 }
 exports.ZLinkMessageMetadataEmpty = Object.freeze(new ImmutableZLinkMessageMetadata());
 function zlinkMessageMetadata(values) {
-    return Object.freeze(new ImmutableZLinkMessageMetadata(values));
+    const entries = typeof values[Symbol.iterator] === 'function'
+        ? values
+        : Object.entries(values);
+    const size = Array.isArray(entries)
+        ? entries.length
+        : entries.size;
+    return size === 0
+        ? exports.ZLinkMessageMetadataEmpty
+        : Object.freeze(new ImmutableZLinkMessageMetadata(entries));
 }

package/dist/contracts/Handlers/Attributes.d.ts

@@ -1,16 +1,9 @@
-import { type ZLinkPacketJsonContract } from './JsonContract';
-export declare const ZLINK_DECORATOR_METADATA: unique symbol;
-export interface ZLinkDecoratorMetadata {
-    readonly kind: string;
-    readonly packetName?: string;
-    readonly groupName?: string;
-    readonly methodName?: string;
-    readonly meshName?: string;
-    readonly channelName?: string;
-    readonly topic?: string;
-    readonly jsonContract?: ZLinkPacketJsonContract;
-}
+export { ZLINK_DECORATOR_METADATA, readZLinkDecoratorMetadata } from '@zlink-systems/stream-wire/internal/json';
+export type { ZLinkDecoratorMetadata } from '@zlink-systems/stream-wire/internal/json';
 export declare function ZLinkHandlerGroup(groupName: string): ClassDecorator;
+export interface ZLinkRequest<TReply> extends Promise<TReply> {
+    readonly admitted: Promise<void>;
+}
 export declare function ZLinkRequest(packetName?: string): MethodDecorator;
 export declare function ZLinkSend(packetName?: string): MethodDecorator;
 export declare function ZLinkPublish(packetName?: string): MethodDecorator;
@@ -21,4 +14,3 @@ export declare function ZLinkSpotActorSend(packetName?: string): MethodDecorator
 export declare function ZLinkSpotActorRequest(packetName?: string): MethodDecorator;
 export declare function ZLinkStreamPacket(): MethodDecorator;
 export declare function ZLinkStreamRaw(): MethodDecorator;
-export declare function readZLinkDecoratorMetadata(target: object): readonly ZLinkDecoratorMetadata[];

package/dist/contracts/Handlers/Attributes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLINK_DECORATOR_METADATA = void 0;
+exports.readZLinkDecoratorMetadata = exports.ZLINK_DECORATOR_METADATA = void 0;
 exports.ZLinkHandlerGroup = ZLinkHandlerGroup;
 exports.ZLinkRequest = ZLinkRequest;
 exports.ZLinkSend = ZLinkSend;
@@ -13,9 +13,11 @@ exports.ZLinkSpotActorSend = ZLinkSpotActorSend;
 exports.ZLinkSpotActorRequest = ZLinkSpotActorRequest;
 exports.ZLinkStreamPacket = ZLinkStreamPacket;
 exports.ZLinkStreamRaw = ZLinkStreamRaw;
-exports.readZLinkDecoratorMetadata = readZLinkDecoratorMetadata;
 const JsonContract_1 = require("./JsonContract");
-exports.ZLINK_DECORATOR_METADATA = Symbol.for('@zlink-systems/framework:decorator');
+const json_1 = require("@zlink-systems/stream-wire/internal/json");
+var json_2 = require("@zlink-systems/stream-wire/internal/json");
+Object.defineProperty(exports, "ZLINK_DECORATOR_METADATA", { enumerable: true, get: function () { return json_2.ZLINK_DECORATOR_METADATA; } });
+Object.defineProperty(exports, "readZLinkDecoratorMetadata", { enumerable: true, get: function () { return json_2.readZLinkDecoratorMetadata; } });
 function ZLinkHandlerGroup(groupName) {
     return classDecorator({ kind: 'handlerGroup', groupName });
 }
@@ -68,17 +70,11 @@ function methodDecorator(metadata) {
     });
 }
 function appendMetadata(target, metadata) {
-    const current = readZLinkDecoratorMetadata(target);
-    Object.defineProperty(target, exports.ZLINK_DECORATOR_METADATA, {
+    const current = (0, json_1.readZLinkDecoratorMetadata)(target);
+    Object.defineProperty(target, json_1.ZLINK_DECORATOR_METADATA, {
         configurable: true,
         enumerable: false,
         value: [...current, metadata],
         writable: false
     });
 }
-function readZLinkDecoratorMetadata(target) {
-    if (!Object.prototype.hasOwnProperty.call(target, exports.ZLINK_DECORATOR_METADATA)) {
-        return [];
-    }
-    return target[exports.ZLINK_DECORATOR_METADATA];
-}

package/dist/contracts/Handlers/JsonContract.d.ts

@@ -1,46 +1,2 @@
-/** Describes the fields accepted by the default framework-json-v1 serializer. */
-export type ZLinkJsonSchema = {
-    readonly type: 'boolean';
-} | {
-    readonly type: 'string';
-} | {
-    readonly type: 'number';
-} | {
-    readonly type: 'int32';
-} | {
-    readonly type: 'uint32';
-} | {
-    readonly type: 'int64';
-} | {
-    readonly type: 'uint64';
-} | {
-    readonly type: 'bytes';
-} | {
-    readonly type: 'enum';
-    readonly names: readonly string[];
-} | {
-    readonly type: 'nullable';
-    readonly value: ZLinkJsonSchema;
-} | {
-    readonly type: 'array';
-    readonly items: ZLinkJsonSchema;
-} | {
-    readonly type: 'record';
-    readonly values: ZLinkJsonSchema;
-} | {
-    readonly type: 'object';
-    readonly properties: Readonly<Record<string, ZLinkJsonSchema>>;
-    readonly required: readonly string[];
-    /** Unknown properties are ignored during decoding unless this is false. */
-    readonly additionalProperties?: boolean;
-};
-/**
- * Describes the request and optional reply fields carried under one packet
- * name by the default JSON serializer.
- */
-export interface ZLinkPacketJsonContract {
-    readonly payload: ZLinkJsonSchema;
-    readonly reply?: ZLinkJsonSchema;
-}
-export declare function defineZLinkPacketJsonContract(packetName: string, contract: ZLinkPacketJsonContract): ZLinkPacketJsonContract;
-export declare function readZLinkPacketJsonContract(packetName: string): ZLinkPacketJsonContract | undefined;
+export { defineZLinkPacketJsonContract, readZLinkPacketJsonContract } from '@zlink-systems/stream-wire/internal/json';
+export type { ZLinkJsonSchema, ZLinkPacketJsonContract } from '@zlink-systems/stream-wire/internal/json';

package/dist/contracts/Handlers/JsonContract.js

@@ -1,155 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineZLinkPacketJsonContract = defineZLinkPacketJsonContract;
-exports.readZLinkPacketJsonContract = readZLinkPacketJsonContract;
-const MAX_CONTRACT_SCHEMA_DEPTH = 64;
-const ZLINK_PACKET_JSON_CONTRACTS = Symbol.for('@zlink-systems/framework:packet-json-contracts');
-function defineZLinkPacketJsonContract(packetName, contract) {
-    if (packetName.trim().length === 0) {
-        throw new TypeError('ZLink packet name must not be empty.');
-    }
-    const runtimeContract = contract;
-    if (typeof runtimeContract !== 'object' || runtimeContract === null) {
-        throw new TypeError('ZLink packet JSON contract must be an object.');
-    }
-    const normalizedContract = runtimeContract;
-    const normalized = Object.freeze({
-        payload: normalizeJsonSchema(normalizedContract.payload, new Set(), 0),
-        ...(normalizedContract.reply === undefined
-            ? {}
-            : { reply: normalizeJsonSchema(normalizedContract.reply, new Set(), 0) })
-    });
-    const contracts = packetJsonContracts();
-    const current = contracts.get(packetName);
-    if (current !== undefined && canonicalContract(current) !== canonicalContract(normalized)) {
-        throw new TypeError(`ZLink packet '${packetName}' has conflicting JSON contracts in one process.`);
-    }
-    if (current !== undefined)
-        return current;
-    contracts.set(packetName, normalized);
-    return normalized;
-}
-function readZLinkPacketJsonContract(packetName) {
-    return packetJsonContracts().get(packetName);
-}
-function normalizeJsonSchema(schema, parents, depth) {
-    // Keep the runtime boundary defensive for JavaScript callers even though
-    // the TypeScript signature describes the accepted shape.
-    const runtimeSchema = schema;
-    if (typeof runtimeSchema !== 'object' ||
-        runtimeSchema === null ||
-        depth > MAX_CONTRACT_SCHEMA_DEPTH) {
-        throw new TypeError(`ZLink packet JSON schema must be an acyclic object with at most ${MAX_CONTRACT_SCHEMA_DEPTH} levels.`);
-    }
-    const normalizedSchema = runtimeSchema;
-    if (parents.has(normalizedSchema))
-        throw new TypeError('ZLink packet JSON schema must not contain a cycle.');
-    const nextParents = new Set(parents).add(normalizedSchema);
-    switch (normalizedSchema.type) {
-        case 'boolean':
-        case 'string':
-        case 'number':
-        case 'int32':
-        case 'uint32':
-        case 'int64':
-        case 'uint64':
-        case 'bytes':
-            return Object.freeze({ type: normalizedSchema.type });
-        case 'enum': {
-            if (!Array.isArray(normalizedSchema.names) ||
-                normalizedSchema.names.length === 0 ||
-                normalizedSchema.names.some((name) => typeof name !== 'string' || name.length === 0)) {
-                throw new TypeError('ZLink packet enum schema requires non-empty string names.');
-            }
-            if (new Set(normalizedSchema.names).size !== normalizedSchema.names.length) {
-                throw new TypeError('ZLink packet enum schema names must be unique.');
-            }
-            return Object.freeze({ type: 'enum', names: Object.freeze([...normalizedSchema.names]) });
-        }
-        case 'nullable':
-            return Object.freeze({
-                type: 'nullable',
-                value: normalizeJsonSchema(normalizedSchema.value, nextParents, depth + 1)
-            });
-        case 'array':
-            return Object.freeze({
-                type: 'array',
-                items: normalizeJsonSchema(normalizedSchema.items, nextParents, depth + 1)
-            });
-        case 'record':
-            return Object.freeze({
-                type: 'record',
-                values: normalizeJsonSchema(normalizedSchema.values, nextParents, depth + 1)
-            });
-        case 'object': {
-            const runtimeProperties = normalizedSchema.properties;
-            if (typeof runtimeProperties !== 'object' ||
-                runtimeProperties === null ||
-                Array.isArray(runtimeProperties)) {
-                throw new TypeError('ZLink packet object schema properties must be an object.');
-            }
-            if (!Array.isArray(normalizedSchema.required) ||
-                normalizedSchema.required.some((name) => typeof name !== 'string' || name.length === 0)) {
-                throw new TypeError('ZLink packet object schema required must contain property names.');
-            }
-            if (normalizedSchema.additionalProperties !== undefined &&
-                typeof normalizedSchema.additionalProperties !== 'boolean') {
-                throw new TypeError('ZLink packet object schema additionalProperties must be boolean.');
-            }
-            const properties = {};
-            for (const [name, property] of Object.entries(runtimeProperties)) {
-                if (isPrototypeKey(name)) {
-                    throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
-                }
-                properties[name] = normalizeJsonSchema(property, nextParents, depth + 1);
-            }
-            if (new Set(normalizedSchema.required).size !== normalizedSchema.required.length) {
-                throw new TypeError('ZLink packet JSON required properties must be unique.');
-            }
-            for (const name of normalizedSchema.required) {
-                if (isPrototypeKey(name)) {
-                    throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
-                }
-                if (!Object.prototype.hasOwnProperty.call(properties, name)) {
-                    throw new TypeError(`ZLink packet JSON required property '${name}' has no property schema.`);
-                }
-            }
-            return Object.freeze({
-                type: 'object',
-                properties: Object.freeze(properties),
-                required: Object.freeze([...normalizedSchema.required]),
-                ...(normalizedSchema.additionalProperties === undefined
-                    ? {}
-                    : { additionalProperties: normalizedSchema.additionalProperties })
-            });
-        }
-    }
-    throw new TypeError(`ZLink packet JSON schema type '${String(normalizedSchema.type)}' is not supported.`);
-}
-function packetJsonContracts() {
-    const root = globalThis;
-    let contracts = root[ZLINK_PACKET_JSON_CONTRACTS];
-    if (contracts === undefined) {
-        contracts = new Map();
-        Object.defineProperty(root, ZLINK_PACKET_JSON_CONTRACTS, {
-            configurable: false,
-            enumerable: false,
-            value: contracts,
-            writable: false
-        });
-    }
-    return contracts;
-}
-function canonicalContract(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonicalContract).join(',')}]`;
-    if (typeof value !== 'object' || value === null)
-        return JSON.stringify(value);
-    return `{${Object.entries(value)
-        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-        .map(([key, item]) => `${JSON.stringify(key)}:${canonicalContract(item)}`)
-        .join(',')}}`;
-}
-function isPrototypeKey(name) {
-    return name === '__proto__' || name === 'prototype' || name === 'constructor';
-}
+exports.readZLinkPacketJsonContract = exports.defineZLinkPacketJsonContract = void 0;
+var json_1 = require("@zlink-systems/stream-wire/internal/json");
+Object.defineProperty(exports, "defineZLinkPacketJsonContract", { enumerable: true, get: function () { return json_1.defineZLinkPacketJsonContract; } });
+Object.defineProperty(exports, "readZLinkPacketJsonContract", { enumerable: true, get: function () { return json_1.readZLinkPacketJsonContract; } });

package/dist/contracts/Spots/Contracts.d.ts

@@ -2,6 +2,7 @@ import type { ZLinkActor } from '../Actors';
 import type { ZLinkChannelRequestCall, ZLinkPublishCall, ZLinkSendCall } from '../Channels';
 import type { RoutingId, SpotId, Type, ZLinkMessageMetadata } from '../Common';
 import type { ZLinkSpotTimerHandler } from '../Handlers';
+import type { ZLinkRequest } from '../Handlers/Attributes';
 import type { ZLinkTimer, ZLinkTimerOptions } from '../Timers';
 import type { ZLinkEntrySpot, ZLinkInstanceSpot, ZLinkSpot, ZLinkSpotRelocationReadyCall } from './ZLinkSpot';
 export interface ZLinkActorHandlerRegistry {
@@ -77,7 +78,7 @@ export interface ZLinkSpotRequestCall {
     instanceSpot(instanceSpotType: string): this;
     inMesh(meshName: string): this;
     timeout(timeoutMs: number): this;
-    submit<TReply>(signal?: AbortSignal): Promise<TReply>;
+    submit<TReply>(signal?: AbortSignal): ZLinkRequest<TReply>;
     yield<TReply>(signal?: AbortSignal): Promise<TReply>;
 }
 export declare enum ZLinkSpotCreateState {

package/dist/nest-integration.d.ts

@@ -11,7 +11,7 @@ import type { ZLinkFrameworkRegistration } from './contracts/Configuration/Regis
 import type { ZLinkCodecSerializerRegistration, ZLinkFrameworkRegistrationOptions, ZLinkStreamCodecRegistration } from './contracts/Configuration/RegistrationTypes';
 import { captureZLinkExecutionTurn } from './runtime/execution';
 export { registerHandlerFilterScope as registerIntegrationHandlerFilterScope, type ZLinkHandlerFilterScopeRunner } from './runtime/channels/handler-filter-scope';
-export { disposeOwnedInstance as disposeIntegrationHandler, disposeOwnedInstances as disposeIntegrationHandlers } from './runtime/handlers/handler-instance-scope';
+export { registerHandlerInstanceScopeFactory as registerIntegrationHandlerInstanceScopeFactory, disposeOwnedInstance as disposeIntegrationHandler, disposeOwnedInstances as disposeIntegrationHandlers } from './runtime/handlers/handler-instance-scope';
 export interface ZLinkNestIntegrationRuntimeHost extends Pick<import('./contracts').ZLinkFrameworkRuntime, 'shutdown'> {
     readonly channelRuntimeOptions: unknown;
     readonly routeMeshRuntimeOptions: ZLinkRouteMeshRuntimeOptions;

package/dist/nest-integration.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disposeIntegrationHandlers = exports.disposeIntegrationHandler = exports.registerIntegrationHandlerFilterScope = exports.validateSessionReplacementCallbackTimeout = exports.validateMessageFollowDuration = exports.validateActorTransferTimeout = exports.registerSpotFactory = exports.registerEntrySpot = exports.validateRoutingIdPrefix = exports.registerRelocationStore = exports.registerActorFactory = exports.ZLinkSpotActorRequest = exports.ZLinkSpotActorSend = exports.hasSpotPublisherClient = exports.hasSpotNode = exports.hasActorManager = exports.normalizeFrameworkRegistration = exports.createFrameworkRegistration = exports.ZLinkConfigurationException = void 0;
+exports.disposeIntegrationHandlers = exports.disposeIntegrationHandler = exports.registerIntegrationHandlerInstanceScopeFactory = exports.registerIntegrationHandlerFilterScope = exports.validateSessionReplacementCallbackTimeout = exports.validateMessageFollowDuration = exports.validateActorTransferTimeout = exports.registerSpotFactory = exports.registerEntrySpot = exports.validateRoutingIdPrefix = exports.registerRelocationStore = exports.registerActorFactory = exports.ZLinkSpotActorRequest = exports.ZLinkSpotActorSend = exports.hasSpotPublisherClient = exports.hasSpotNode = exports.hasActorManager = exports.normalizeFrameworkRegistration = exports.createFrameworkRegistration = exports.ZLinkConfigurationException = void 0;
 exports.createIntegrationDispatchOptionsBuilder = createIntegrationDispatchOptionsBuilder;
 exports.createIntegrationInboundDispatchOptionsBuilder = createIntegrationInboundDispatchOptionsBuilder;
 exports.createIntegrationLocationOptionsBuilder = createIntegrationLocationOptionsBuilder;
@@ -46,6 +46,7 @@ const execution_1 = require("./runtime/execution");
 var handler_filter_scope_1 = require("./runtime/channels/handler-filter-scope");
 Object.defineProperty(exports, "registerIntegrationHandlerFilterScope", { enumerable: true, get: function () { return handler_filter_scope_1.registerHandlerFilterScope; } });
 var handler_instance_scope_1 = require("./runtime/handlers/handler-instance-scope");
+Object.defineProperty(exports, "registerIntegrationHandlerInstanceScopeFactory", { enumerable: true, get: function () { return handler_instance_scope_1.registerHandlerInstanceScopeFactory; } });
 Object.defineProperty(exports, "disposeIntegrationHandler", { enumerable: true, get: function () { return handler_instance_scope_1.disposeOwnedInstance; } });
 Object.defineProperty(exports, "disposeIntegrationHandlers", { enumerable: true, get: function () { return handler_instance_scope_1.disposeOwnedInstances; } });
 function createIntegrationDispatchOptionsBuilder(dispatch) {

package/dist/runtime/actors/actor-client.d.ts

@@ -11,7 +11,7 @@ export interface ZLinkActorClientOptions {
     readonly defaultRequestTimeoutMs?: number;
     readonly staleActorRefReporter?: (meshName: string, actorId: string) => void;
     readonly staleActorRefPredicate?: (meshName: string, actor: ActorRef) => boolean;
-    readonly handoffCapture?: (meshName: string, actorId: string, parts: readonly Message[], returnResponse: boolean, actor: ActorRef, deadlineUnixMs?: number) => Promise<unknown> | undefined;
+    readonly handoffCapture?: (meshName: string, actorId: string, parts: readonly Message[], returnResponse: boolean, actor: ActorRef, deadlineUnixMs?: number, onAdmitted?: () => void) => Promise<unknown> | undefined;
     readonly sendErrorReporter?: (error: unknown) => void;
     readonly routeTransport?: ZLinkActorRoutedJoinTransport;
     readonly transportDeliveryGate?: () => {

package/dist/runtime/actors/actor-client.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkActorClient = void 0;
 exports.forwardEncodedActorPacket = forwardEncodedActorPacket;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
+const request_result_1 = require("../messaging/request-result");
 const contracts_1 = require("../../contracts");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const abort_1 = require("../abort");
@@ -32,7 +33,7 @@ class DefaultZLinkActorClient {
     }
     requestToActor(actorId, request) {
         requireActorId(actorId);
-        return new DefaultZLinkActorRequestCall((packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'async'), (packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'yield'), actorId, request, this.options.defaultRequestTimeoutMs);
+        return new DefaultZLinkActorRequestCall((packetName, timeoutMs, metadata, signal, onAdmitted) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'async', onAdmitted), (packetName, timeoutMs, metadata, signal) => this.request(actorId, packetName, request, timeoutMs, metadata, signal, 'yield'), actorId, request, this.options.defaultRequestTimeoutMs);
     }
     async send(actorId, explicitPacketName, message, metadata) {
         const route = await this.resolveActorRoute(actorId);
@@ -82,7 +83,7 @@ class DefaultZLinkActorClient {
             closeMessages(parts);
         }
     }
-    async request(actorId, explicitPacketName, request, timeoutMs, metadata, signal, waitPolicy = 'async') {
+    async request(actorId, explicitPacketName, request, timeoutMs, metadata, signal, waitPolicy = 'async', onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const sourceSpotId = (0, actor_execution_context_1.currentZLinkActorExecution)()?.spotId ?? (0, execution_1.currentZLinkSpotSerialSourceId)();
         const effectiveTimeoutMs = timeoutMs ?? this.options.defaultRequestTimeoutMs;
@@ -109,18 +110,18 @@ class DefaultZLinkActorClient {
             const submissionCopies = delivery === undefined
                 ? 1
                 : ((await (0, actor_request_deadline_1.waitActorReply)(delivery, actorId, deadlineMs, signal)) ?? 1);
-            const handoff = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs);
+            const handoff = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs, onAdmitted);
             if (handoff !== undefined) {
                 const submissions = [handoff];
                 for (let copy = 1; copy < submissionCopies; copy++) {
-                    const duplicate = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs);
+                    const duplicate = this.options.handoffCapture?.(meshName, actor.actorId, parts, true, routedActor, deadlineUnixMs, onAdmitted);
                     if (duplicate !== undefined)
                         submissions.push(duplicate);
                 }
                 const replies = await (0, actor_request_deadline_1.waitActorReply)(Promise.all(submissions), actorId, deadlineMs, signal);
                 return replies[0];
             }
-            return await this.submitActorRequest(meshName, toBackendActorRef(actor), parts, (0, actor_request_deadline_1.remainingActorRequestTimeout)(actorId, deadlineMs), signal, route, messageFollow);
+            return await this.submitActorRequest(meshName, toBackendActorRef(actor), parts, (0, actor_request_deadline_1.remainingActorRequestTimeout)(actorId, deadlineMs), signal, route, messageFollow, onAdmitted);
         }
         catch (error) {
             if (isStaleActorError(error)) {
@@ -204,7 +205,7 @@ class DefaultZLinkActorClient {
             throw mapSubmitError(error, 'Actor send');
         }
     }
-    async submitActorRequest(meshName, actor, parts, timeoutMs, signal, route, messageFollowContext) {
+    async submitActorRequest(meshName, actor, parts, timeoutMs, signal, route, messageFollowContext, onAdmitted) {
         const node = this.requireNode(meshName);
         if (this.options.routeTransport !== undefined &&
             String(node.status().routingId) !== String(actor.nodeRid) &&
@@ -228,7 +229,7 @@ class DefaultZLinkActorClient {
                 returnResponse: true,
                 messageFollowContext
             });
-            const reply = await (0, actor_routed_json_request_1.requestRoutedJsonReply)(this.options.routeTransport, remoteActorRouteTarget(route), relay, { timeoutMs, signal }, `Remote Actor request is not available for '${actor.actorId}'.`, (replyParts) => JSON.parse(replyParts[0]?.getString('utf8') ?? '{}'));
+            const reply = await (0, actor_routed_json_request_1.requestRoutedJsonReply)(this.options.routeTransport, remoteActorRouteTarget(route), relay, { timeoutMs, signal, onAdmitted }, `Remote Actor request is not available for '${actor.actorId}'.`, (replyParts) => JSON.parse(replyParts[0]?.getString('utf8') ?? '{}'));
             if (reply.ok !== true) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(remoteRelayErrorKind(reply.errorKind), typeof reply.error === 'string'
                     ? reply.error
@@ -242,7 +243,8 @@ class DefaultZLinkActorClient {
         }
         const completion = await completions.submit(() => node.requestToActor(actor, toMessageLikeParts(parts), {
             flags: runtime_values_1.ZLINK_BACKEND_SEND_NONE,
-            timeoutMs
+            timeoutMs,
+            onAdmitted
         }), signal);
         if (completion.terminalResult !== runtime_values_1.RequestResult.Ok) {
             (0, backend_1.closeMeshCompletion)(completion);
@@ -405,7 +407,8 @@ class DefaultZLinkActorRequestCall {
         return this;
     }
     submit(signal) {
-        return this.execute('async', signal);
+        this.rejectSelfActorRequest();
+        return (0, request_result_1.createZLinkRequest)((onAdmitted) => this.execute('async', signal, onAdmitted));
     }
     yield(signal) {
         this.rejectSelfActorRequest();
@@ -413,13 +416,12 @@ class DefaultZLinkActorRequestCall {
         const pending = this.execute('yield', signal);
         return turn.yieldPromise(pending);
     }
-    execute(waitPolicy, signal) {
+    execute(waitPolicy, signal, onAdmitted) {
         ensureSingleSubmit(this.executed);
-        this.rejectSelfActorRequest();
         this.executed = true;
         (0, abort_1.throwIfAborted)(signal);
         const submitter = waitPolicy === 'async' ? this.asyncSubmitter : this.yieldSubmitter;
-        return submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.request, undefined, 'Actor'), this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata, signal);
+        return submitter(this.packet ?? (0, packet_name_1.resolveFrameworkPacketName)(this.request, undefined, 'Actor'), this.timeoutMs ?? this.defaultRequestTimeoutMs, this.selectedMetadata, signal, onAdmitted);
     }
     rejectSelfActorRequest() {
         const current = (0, actor_execution_context_1.currentZLinkActorExecution)();

package/dist/runtime/actors/actor-handoff.d.ts

@@ -142,7 +142,7 @@ export declare class ZLinkActorHandoffCoordinator {
      */
     failPending(actorId: string, reason: unknown): void;
     cancel(actorId: string): void;
-    capture(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
+    capture(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch, onAdmitted?: () => void): Promise<unknown> | undefined;
     snapshot(actorId: string): readonly ZLinkActorHandoffPacket[];
     snapshotCoreBacklog(actorId: string): readonly ZLinkActorHandoffPacket[];
     /**

package/dist/runtime/actors/actor-handoff.js

@@ -422,7 +422,7 @@ class ZLinkActorHandoffCoordinator {
             pending.reject?.(error);
         }
     }
-    capture(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay) {
+    capture(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay, onAdmitted) {
         const incomingContext = (0, actor_message_follow_context_1.actorMessageFollowContext)(fallbackActorRef);
         const originalDeadlineUnixMs = deadlineUnixMs ?? incomingContext?.deadlineUnixMs ?? packetDeadlineUnixMs(parts);
         const handoff = this.active.get(actorId);
@@ -502,6 +502,7 @@ class ZLinkActorHandoffCoordinator {
                 });
             });
             (0, application_job_queue_scope_1.releaseApplicationJobPermitForDurableHandoff)();
+            onAdmitted?.();
             if (handoff.prefixRelease !== undefined) {
                 try {
                     this.admitPendingPrefix(actorId, handoff, handoff.prefixRelease);
@@ -535,7 +536,7 @@ class ZLinkActorHandoffCoordinator {
                             return Promise.reject(actorLocationStale(actorId));
                         }
                         const packet = encodePacket(0, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, incomingContext, messageFollowOrigin);
-                        return this.enqueueMessageFollow(followRoute, actorId, packet);
+                        return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
                     }
                     this.options.onMarker?.('message_follow_rejected', actorId);
                     return Promise.reject(actorLocationStale(actorId));
@@ -581,7 +582,7 @@ class ZLinkActorHandoffCoordinator {
             return Promise.reject(error);
         }
         const packet = encodePacket(0, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, context, messageFollowOrigin);
-        return this.enqueueMessageFollow(followRoute, actorId, packet);
+        return this.enqueueMessageFollow(followRoute, actorId, packet, onAdmitted);
     }
     snapshot(actorId) {
         const handoff = this.requireActive(actorId);
@@ -932,7 +933,7 @@ class ZLinkActorHandoffCoordinator {
         }
         return undefined;
     }
-    enqueueMessageFollow(entry, actorId, packet) {
+    enqueueMessageFollow(entry, actorId, packet, onAdmitted) {
         const context = packet.messageFollowContext;
         const duplicate = entry.operations.get(context.operationId);
         if (duplicate !== undefined) {
@@ -942,6 +943,7 @@ class ZLinkActorHandoffCoordinator {
                 this.options.onMarker?.('message_follow_rejected', actorId);
                 return Promise.reject(actorLocationStale(actorId));
             }
+            onAdmitted?.();
             return duplicate.result;
         }
         const bytes = packetBytes(packet);
@@ -963,6 +965,7 @@ class ZLinkActorHandoffCoordinator {
             replyRouteId: context.replyRouteId,
             result
         });
+        onAdmitted?.();
         entry.tail = entry.tail.then(async () => {
             try {
                 resolve(await this.relayMessageFollow(actorId, entry, packet));

package/dist/runtime/actors/actor-join-relocation.d.ts

@@ -29,6 +29,7 @@ export interface ZLinkActorJoinRelocation {
         };
         /** Target's advertised relocation state chunk cap from the accepted admission reply. */
         readonly advertisedReceiveChunkLimitBytes?: number;
+        readonly deadlineAtMs?: number;
         readonly signal?: AbortSignal;
     }): Promise<{
         readonly actorRef: ZLinkBackendActorRef;

package/dist/runtime/actors/actor-local-native-join.js

@@ -68,15 +68,12 @@ class ZLinkLocalNativeActorJoin {
             throw new Error('Local Actor Join requires a valid target generation and stateful membership runtime.');
         }
         const membershipEpoch = location.membershipEpoch + 1n;
+        const currentActor = (0, actor_runtime_state_1.toFrameworkActorRef)(actorRef, meshName);
+        const authorityOwnerGeneration = state.locationGeneration ?? actorRef.generation;
         const commit = async (spot) => {
             (0, abort_1.throwIfAborted)(signal);
-            if (target.spotKind === contracts_1.ZLinkSpotKind.Entry) {
-                await this.options.locationLifecycle?.notifyActorLeftSpot(actorType, actor.context.actorId, storeSpotId, spotGeneration, membershipEpoch, node.status().lifecycleGeneration);
-            }
-            else {
-                await this.options.locationLifecycle?.notifyActorJoinedSpot(actorType, actor.context.actorId, meshName, storeSpotId, spotGeneration, membershipEpoch, node.status().lifecycleGeneration);
-            }
-            const committedActor = node.restoreActorAuthority(actor.context.actorId, actorType, actorRef.generation, state.locationGeneration ?? actorRef.generation, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? undefined : String(target.spotId), spotGeneration, membershipEpoch);
+            await this.options.locationLifecycle?.commitActorMembership(actorType, currentActor, authorityOwnerGeneration, storeSpotId, spotGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? contracts_1.ZLinkSpotKind.Entry : contracts_1.ZLinkSpotKind.User, node.status().lifecycleGeneration);
+            const committedActor = node.restoreActorAuthority(actor.context.actorId, actorType, actorRef.generation, authorityOwnerGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? undefined : String(target.spotId), spotGeneration, membershipEpoch);
             state.setNativeActorRef(committedActor);
             if (target.spotKind === contracts_1.ZLinkSpotKind.Entry)
                 state.clearJoinedSpot();
@@ -120,6 +117,7 @@ class ZLinkLocalNativeActorJoin {
         return submitJoinWhenConnected(() => completions.submit(submit, signal), timeoutMs, signal);
     }
     async relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, entrySpot) {
+        const deadlineAtMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
         const actorType = state.actorType;
         if (actorType === undefined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.context.actorId}' canonical remote Join identity is not configured.`);
@@ -214,6 +212,7 @@ class ZLinkLocalNativeActorJoin {
                 target,
                 relocationId,
                 completionOperationId,
+                deadlineAtMs,
                 ...(control.canonicalHandoffId === undefined || canonicalAdmission === undefined
                     ? {}
                     : {
@@ -227,11 +226,9 @@ class ZLinkLocalNativeActorJoin {
                             },
                             requestContentType: canonicalAdmission.request.contentType,
                             request: Buffer.from(canonicalAdmission.request.payload),
-                            ...(completionOperationId === undefined
+                            ...(completionOperationId === undefined || control.replyContentType === undefined
                                 ? {}
-                                : {
-                                    replyContentType: control.replyContentType ?? stream_wire_1.ZlinkStreamContentType.Raw
-                                }),
+                                : { replyContentType: control.replyContentType }),
                             reply: completionOperationId === undefined
                                 ? Buffer.alloc(0)
                                 : Buffer.from(admission.parts[0]?.data() ?? []),
@@ -239,7 +236,7 @@ class ZLinkLocalNativeActorJoin {
                             expectedOwnerLeaseGeneration: actorAuthorityFence.ownerLeaseGeneration,
                             targetNodeGeneration: target.targetNodeGeneration,
                             targetSpotGeneration: control.location.spotGeneration,
-                            targetAuthorityOwnerGeneration: actorAuthorityFence.authorityOwnerGeneration + 1n,
+                            targetAuthorityOwnerGeneration: actorAuthorityFence.authorityOwnerGeneration,
                             targetSpotAuthorityOwnerGeneration: target.authorityOwnerGeneration ?? 1n
                         }
                     }),