@zlink-systems/framework 0.30.0 → 0.30.2

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/ZLinkEncodedPayload.d.ts

@@ -1,7 +1,13 @@
 export declare class ZLinkEncodedPayload {
     private constructor();
+    /** Copies the supplied bytes. */
     static from(bytes: Uint8Array): ZLinkEncodedPayload;
+    /** Retains the supplied bytes without copying. Do not modify them afterward; mutation changes the payload. */
+    static fromOwned(bytes: Uint8Array): ZLinkEncodedPayload;
+    /** Returns a copy of the stored bytes. */
     data(): Uint8Array;
+    /** Returns the stored bytes without copying. Do not modify this view or its backing buffer. */
+    view(): Readonly<Uint8Array>;
     toBytes(): Uint8Array;
     copy(): ZLinkEncodedPayload;
     size(): number;

package/dist/contracts/Common/ZLinkEncodedPayload.js

@@ -3,15 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkEncodedPayload = void 0;
 const encoded_payload_storage_1 = require("./encoded-payload-storage");
 class ZLinkEncodedPayload {
-    constructor(bytes) {
-        (0, encoded_payload_storage_1.storeEncodedPayload)(this, bytes);
+    constructor(bytes, owned) {
+        if (owned) {
+            (0, encoded_payload_storage_1.adoptEncodedPayload)(this, bytes);
+        }
+        else {
+            (0, encoded_payload_storage_1.storeEncodedPayload)(this, bytes);
+        }
     }
+    /** Copies the supplied bytes. */
     static from(bytes) {
-        return new ZLinkEncodedPayload(bytes);
+        return new ZLinkEncodedPayload(bytes, false);
     }
+    /** Retains the supplied bytes without copying. Do not modify them afterward; mutation changes the payload. */
+    static fromOwned(bytes) {
+        return new ZLinkEncodedPayload(bytes, true);
+    }
+    /** Returns a copy of the stored bytes. */
     data() {
         return new Uint8Array(this.stored());
     }
+    /** Returns the stored bytes without copying. Do not modify this view or its backing buffer. */
+    view() {
+        return this.stored();
+    }
     toBytes() {
         return this.data();
     }

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/Common/encoded-payload-storage.d.ts

@@ -1,3 +1,3 @@
 export declare function storeEncodedPayload(owner: object, bytes: Uint8Array): Buffer;
-export declare function adoptEncodedPayload(owner: object, bytes: Buffer): Buffer;
+export declare function adoptEncodedPayload(owner: object, bytes: Uint8Array): Buffer;
 export declare function borrowEncodedPayload(owner: object): Buffer | undefined;

package/dist/contracts/Common/encoded-payload-storage.js

@@ -10,8 +10,11 @@ function storeEncodedPayload(owner, bytes) {
     return stored;
 }
 function adoptEncodedPayload(owner, bytes) {
-    encodedPayloadStorage.set(owner, bytes);
-    return bytes;
+    const stored = Buffer.isBuffer(bytes)
+        ? bytes
+        : Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    encodedPayloadStorage.set(owner, stored);
+    return stored;
 }
 function borrowEncodedPayload(owner) {
     return encodedPayloadStorage.get(owner);

package/dist/contracts/Configuration/Builders.d.ts

@@ -112,7 +112,7 @@ export interface ZLinkMeshObjectRoleBuilder {
 export interface ZLinkMeshObjectClientBuilder {
 }
 export interface ZLinkMeshObjectServerBuilder {
-    addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>): this;
+    addEntrySpot<TEntrySpot extends ZLinkEntrySpot>(entrySpotType: Type<TEntrySpot>, actorType: string): this;
     addSpotFactory<TSpot extends ZLinkSpot>(spotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkUserSpotFactoryBuilder<TSpot>) => void): this;
     addInstanceSpotFactory<TSpot extends ZLinkInstanceSpot>(instanceSpotType: string, implementation: Type<TSpot>, configure: (builder: ZLinkInstanceSpotFactoryBuilder<TSpot>) => void): this;
     addActorFactory<TActor extends ZLinkActor>(actorType: string, implementation: Type<ZLinkActorFactory<TActor>>, configure: (builder: ZLinkActorFactoryBuilder<TActor>) => void): this;

package/dist/contracts/Configuration/RegistrationBuilderPolicy.d.ts

@@ -16,7 +16,8 @@ export declare function validateActorTransferTimeout(timeoutMs: number): number;
 export declare function validateSessionReplacementCallbackTimeout(timeoutMs: number): number;
 export declare function registerEntrySpot(options: {
     entrySpotType?: Type<ZLinkEntrySpot>;
-}, entrySpotType: Type<ZLinkEntrySpot>): void;
+    entrySpotActorType?: string;
+}, entrySpotType: Type<ZLinkEntrySpot>, actorType: string): void;
 export declare function registerSpotFactory(options: {
     spotFactories?: Type<ZLinkSpot>[];
 }, spotType: Type<ZLinkSpot>): void;

package/dist/contracts/Configuration/RegistrationBuilderPolicy.js

@@ -62,11 +62,15 @@ function validateSessionReplacementCallbackTimeout(timeoutMs) {
     }
     return timeoutMs;
 }
-function registerEntrySpot(options, entrySpotType) {
+function registerEntrySpot(options, entrySpotType, actorType) {
     if (options.entrySpotType !== undefined) {
         throw new ConfigurationException_1.ZLinkConfigurationException('Duplicate Entry Spot registration on SpotNode.');
     }
+    if (typeof actorType !== 'string' || actorType.length === 0) {
+        throw new ConfigurationException_1.ZLinkConfigurationException('Entry Spot Actor type must be a non-empty string.');
+    }
     options.entrySpotType = entrySpotType;
+    options.entrySpotActorType = actorType;
 }
 function registerSpotFactory(options, spotType) {
     options.spotFactories ??= [];

package/dist/contracts/Configuration/RegistrationBuilders.js

@@ -942,8 +942,8 @@ class DefaultMeshObjectServerBuilder {
         this.meshName = meshName;
         this.node = node;
     }
-    addEntrySpot(entrySpotType) {
-        (0, RegistrationBuilderPolicy_1.registerEntrySpot)(this.node, entrySpotType);
+    addEntrySpot(entrySpotType, actorType) {
+        (0, RegistrationBuilderPolicy_1.registerEntrySpot)(this.node, entrySpotType, actorType);
         return this;
     }
     addSpotFactory(spotType, implementation, configure) {

package/dist/contracts/Configuration/RegistrationTypes.d.ts

@@ -233,6 +233,7 @@ export interface ZLinkSpotNodeOptions {
     readonly router?: ZLinkSpotRouterCapabilityOptions;
     readonly pubSub?: ZLinkSpotPubSubCapabilityOptions;
     readonly entrySpotType?: Type<ZLinkEntrySpot>;
+    readonly entrySpotActorType?: string;
     readonly spotFactories?: readonly Type<ZLinkSpot>[];
     readonly spotFactoryRegistrations?: Readonly<Record<string, ZLinkObjectFactoryRegistration<ZLinkSpot, ZLinkSpot, ZLinkUserSpotFactoryConfiguration>>>;
     readonly instanceSpotFactories?: Readonly<Record<string, Type<ZLinkInstanceSpot>>>;

package/dist/contracts/Dispatch/ZLinkDispatchOptions.d.ts

@@ -76,7 +76,7 @@ export interface ZLinkRuntimeMessageFlowEvent {
     readonly commandId?: number;
     readonly messageSize?: number;
     readonly durationSeconds?: number;
-    readonly errorReason?: ZLinkDispatchErrorReason;
+    readonly errorReason?: ZLinkDispatchErrorReason | 'activation_timeout' | 'activation_rejected';
     readonly errorAction?: ZLinkDispatchErrorAction;
     readonly errorType?: string;
     readonly errorMessage?: string;
@@ -162,7 +162,7 @@ export declare enum ZLinkDispatchMessageKind {
     ActorRequest = "actorRequest",
     ActorSend = "actorSend"
 }
-export type ZLinkDispatchErrorReason = 'no_handler' | 'decode_error' | 'handler_exception' | 'invalid_frame' | 'reply_path_missing' | 'unexpected_reply' | 'backpressure' | 'target_closed' | 'stale_target' | 'shutdown';
+export type ZLinkDispatchErrorReason = 'no_handler' | 'decode_error' | 'handler_exception' | 'invalid_frame' | 'reply_path_missing' | 'unexpected_reply' | 'backpressure' | 'target_closed' | 'location_unavailable' | 'stale_target' | 'shutdown';
 export type ZLinkDispatchErrorAction = 'reply_error' | 'fail_caller' | 'drop';
 export declare enum ZLinkRuntimeDispatchErrorReason {
     HandlerMissing = "no_handler",

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/Locations/Rows.d.ts

@@ -22,6 +22,8 @@ export interface ZLinkObjectCapability {
     readonly policy: ZLinkObjectMaintenancePolicyKind;
     readonly hasSnapshotAdapter: boolean;
     readonly limit: number;
+    /** True only for an Actor capability whose node registered an Entry Spot type accepting it. */
+    readonly entryAccepted: boolean;
 }
 export interface ZLinkPopulationCapacity {
     readonly active: number;

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

@@ -2,17 +2,22 @@ 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 {
     addHandler<THandler>(handlerType: Type<THandler>, packetName?: string): this;
 }
 export interface ZLinkSpotHandlerRegistry extends ZLinkActorHandlerRegistry {
+    /** Declares a timer handler constructor for relocation without registering an endpoint. */
+    addTimerHandler<THandler extends ZLinkSpotTimerHandler<ZLinkSpot>>(handlerType: Type<THandler>): this;
     addPacket<THandler>(handlerType: Type<THandler>): this;
     addSubscribe<THandler>(handlerType: Type<THandler>, channelName: string, topic: string): this;
 }
 export interface ZLinkInstanceSpotHandlerRegistry {
     addPacket<THandler>(handlerType: Type<THandler>): this;
+    /** Declares a timer handler constructor for relocation without registering an endpoint. */
+    addTimerHandler<THandler extends ZLinkSpotTimerHandler<ZLinkInstanceSpot>>(handlerType: Type<THandler>): this;
 }
 export interface ZLinkWorkerCall<T> {
     timeoutMs(durationMs: number): ZLinkWorkerCall<T>;
@@ -77,7 +82,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/contracts/Spots/ZLinkSpot.d.ts

@@ -42,15 +42,15 @@ export interface ZLinkUserSpotActorLifecycle<TActor extends ZLinkActor = ZLinkAc
 export interface ZLinkSpot<TActor extends ZLinkActor = ZLinkActor> extends ZLinkUserSpotActorLifecycle<TActor> {
     readonly context: ZLinkSpotContext<TActor>;
     configure?(): void;
-    onCreate?(request: ZLinkMessage): Promise<ZLinkSpotCreateResponse>;
-    onInitialize?(): Promise<void>;
+    onCreate?(request: ZLinkMessage, signal?: AbortSignal): Promise<ZLinkSpotCreateResponse>;
+    onInitialize?(signal?: AbortSignal): Promise<void>;
     onClosing?(context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal): Promise<void>;
     onRelocationReadyCompleted?(completion: ZLinkSpotRelocationReadyCompletion): Promise<void>;
 }
 export interface ZLinkInstanceSpot {
     readonly context: ZLinkInstanceSpotContext;
     configure?(): void;
-    onInitialize?(): Promise<void>;
+    onInitialize?(signal?: AbortSignal): Promise<void>;
     onClosing?(context: ZLinkSpotClosingContext, cleanupSignal: AbortSignal): Promise<void>;
 }
 export interface ZLinkEntrySpot<TActor extends ZLinkActor = ZLinkActor> extends ZLinkSpotActorMembershipLifecycle<TActor> {

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/abort.d.ts

@@ -10,5 +10,10 @@ export declare function isAbortError(error: unknown): boolean;
 export declare function createDeadlineExceededError(message?: string): ZLinkDeadlineExceededError;
 export declare function isDeadlineExceededError(error: unknown): boolean;
 export declare function throwIfAborted(signal: AbortSignal | undefined): void;
+/**
+ * Whether a handler or dispatch result is a thenable the caller must wait
+ * for. Synchronous results, including null and undefined, are not.
+ */
+export declare function isPromiseLike<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function macrotaskBoundary(): Promise<void>;
 export declare function awaitWithAbort<T>(operation: Promise<T>, signal: AbortSignal | undefined, abortOperation?: () => void): Promise<T>;

package/dist/runtime/abort.js

@@ -6,6 +6,7 @@ exports.isAbortError = isAbortError;
 exports.createDeadlineExceededError = createDeadlineExceededError;
 exports.isDeadlineExceededError = isDeadlineExceededError;
 exports.throwIfAborted = throwIfAborted;
+exports.isPromiseLike = isPromiseLike;
 exports.macrotaskBoundary = macrotaskBoundary;
 exports.awaitWithAbort = awaitWithAbort;
 /** The typed cancellation error produced by Framework admission helpers. */
@@ -41,6 +42,15 @@ function throwIfAborted(signal) {
         throw createAbortError();
     }
 }
+/**
+ * Whether a handler or dispatch result is a thenable the caller must wait
+ * for. Synchronous results, including null and undefined, are not.
+ */
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
 function macrotaskBoundary() {
     return new Promise((resolve) => setImmediate(resolve));
 }