@zlink-systems/framework 0.13.0 → 0.15.0

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

@@ -138,7 +138,9 @@ export interface ZLinkFanoutChannelBuilder {
     setAdvertiseHost(advertiseHost: string): this;
     routingId(routingId: string): this;
     setRoutingIdPrefix(prefix: string): this;
+    setNoDrop(noDrop?: boolean): this;
     enableSubscriber(): this;
+    subscribe(topic: string): this;
     connect(endpoint: string): this;
     subscriberConnections(): ZLinkEndpointConnections;
 }

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

@@ -71,8 +71,8 @@ export declare function parseEndpointHostPort(endpoint: string, expectedScheme:
  * endpoint, or (when `restrictToScheme` is given) when its scheme doesn't
  * match after lowercasing -- callers translate that into their own
  * capability-specific `ZLinkConfigurationException` message. Returns
- * `boundEndpoint` normalized (unrestricted) when `advertiseHost` is
- * undefined -- the common case, and the actual bound endpoint that ends up
- * on the wire and in descriptors compared elsewhere.
+ * `boundEndpoint` normalized when `advertiseHost` is undefined, except that
+ * wildcard TCP hosts use the same-family loopback address. This keeps the
+ * bind-only default connectable without advertising a wildcard address.
  */
 export declare function buildAdvertisedEndpoint(boundEndpoint: string, advertiseHost: string | undefined, restrictToScheme?: string): string | undefined;

package/dist/contracts/Configuration/EndpointNotation.js

@@ -173,7 +173,7 @@ function parseEndpointHostPort(endpoint, expectedScheme) {
         port: /^\d+$/.test(port) ? Number(port) : 0
     };
 }
-const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(?:\[[^\]]+\]|[^:]+):(\d+)$/;
+const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(\[[^\]]+\]|[^:]+):(\d+)$/;
 /**
  * Builds a normalized `scheme://advertiseHost:port` endpoint from a bound
  * endpoint, replacing only the host. Consolidates what used to be three
@@ -186,13 +186,27 @@ const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(?:\[[^\]]+\]|[
  * endpoint, or (when `restrictToScheme` is given) when its scheme doesn't
  * match after lowercasing -- callers translate that into their own
  * capability-specific `ZLinkConfigurationException` message. Returns
- * `boundEndpoint` normalized (unrestricted) when `advertiseHost` is
- * undefined -- the common case, and the actual bound endpoint that ends up
- * on the wire and in descriptors compared elsewhere.
+ * `boundEndpoint` normalized when `advertiseHost` is undefined, except that
+ * wildcard TCP hosts use the same-family loopback address. This keeps the
+ * bind-only default connectable without advertising a wildcard address.
  */
 function buildAdvertisedEndpoint(boundEndpoint, advertiseHost, restrictToScheme) {
-    if (advertiseHost === undefined)
-        return normalizeEndpoint(boundEndpoint);
+    if (advertiseHost === undefined) {
+        const normalized = normalizeEndpoint(boundEndpoint);
+        const match = ADVERTISE_SOURCE_PATTERN.exec(normalized);
+        if (match === null)
+            return normalized;
+        const boundHost = unbracketHost(match[2]);
+        const defaultHost = boundHost === '0.0.0.0'
+            ? '127.0.0.1'
+            : boundHost === '::'
+                ? '::1'
+                : undefined;
+        if (defaultHost === undefined)
+            return normalized;
+        const host = defaultHost.includes(':') ? `[${defaultHost}]` : defaultHost;
+        return normalizeEndpoint(`${match[1].toLowerCase()}://${host}:${match[3]}`);
+    }
     const match = ADVERTISE_SOURCE_PATTERN.exec(boundEndpoint);
     if (match === null)
         return undefined;
@@ -202,7 +216,10 @@ function buildAdvertisedEndpoint(boundEndpoint, advertiseHost, restrictToScheme)
     const host = advertiseHost.includes(':') && !advertiseHost.startsWith('[')
         ? `[${advertiseHost}]`
         : advertiseHost;
-    return normalizeEndpoint(`${scheme}://${host}:${match[2]}`);
+    return normalizeEndpoint(`${scheme}://${host}:${match[3]}`);
+}
+function unbracketHost(host) {
+    return host.startsWith('[') && host.endsWith(']') ? host.slice(1, -1) : host;
 }
 function normalizeSuffix(suffix) {
     if (suffix.length === 0) {

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

@@ -0,0 +1,2 @@
+export declare const FANOUT_LIVENESS_TOPIC = "\u0001ZLF1";
+export declare function requirePublicFanoutTopic(topic: string): void;

package/dist/contracts/Configuration/FanoutTopic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FANOUT_LIVENESS_TOPIC = void 0;
+exports.requirePublicFanoutTopic = requirePublicFanoutTopic;
+const ConfigurationException_1 = require("./ConfigurationException");
+exports.FANOUT_LIVENESS_TOPIC = '\x01ZLF1';
+function requirePublicFanoutTopic(topic) {
+    if (typeof topic !== 'string') {
+        throw new ConfigurationException_1.ZLinkConfigurationException('Fanout topic must be a string.');
+    }
+    if (topic.startsWith(exports.FANOUT_LIVENESS_TOPIC)) {
+        throw new ConfigurationException_1.ZLinkConfigurationException('Fanout topic is reserved for framework liveness.');
+    }
+}

package/dist/contracts/Configuration/RegistrationBuilders.js

@@ -14,6 +14,7 @@ const EndpointNotation_1 = require("./EndpointNotation");
 const InternalDefaults_1 = require("./InternalDefaults");
 const RegistrationBuilderPolicy_1 = require("./RegistrationBuilderPolicy");
 const DiagnosticsValidation_1 = require("./DiagnosticsValidation");
+const FanoutTopic_1 = require("./FanoutTopic");
 function createFrameworkOptions(configure) {
     const builder = new ZLinkFrameworkOptionsBuilder();
     configure(builder);
@@ -362,6 +363,10 @@ class DefaultFanoutChannelBuilder {
         this.channel.routingIdPrefix = (0, RegistrationBuilderPolicy_1.validateRoutingIdPrefix)(prefix);
         return this;
     }
+    setNoDrop(noDrop = true) {
+        this.channel.noDrop = noDrop;
+        return this;
+    }
     enableSubscriber(endpoint) {
         this.selectSubscriberMode(endpoint === undefined ? 'automatic' : 'manual');
         this.channel.subscriber ??= { manualConnections: [] };
@@ -373,6 +378,14 @@ class DefaultFanoutChannelBuilder {
         }
         return this;
     }
+    subscribe(topic) {
+        (0, FanoutTopic_1.requirePublicFanoutTopic)(topic);
+        this.channel.subscriptions ??= [];
+        if (!this.channel.subscriptions.includes(topic)) {
+            this.channel.subscriptions.push(topic);
+        }
+        return this;
+    }
     connect(endpoint) {
         requireRegistrationName(endpoint, `Fanout channel '${this.name}' subscriber endpoint`);
         this.selectSubscriberMode('manual');

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

@@ -138,11 +138,13 @@ export interface ZLinkFrameworkRegistrationOptions {
 export interface ZLinkChannelOptions {
     readonly routingId?: string;
     readonly routingIdPrefix?: string;
+    readonly noDrop?: boolean;
     readonly requestTimeoutMs?: number;
     readonly client?: ZLinkClientCapabilityOptions;
     readonly publisher?: ZLinkPublisherCapabilityOptions;
     readonly routeMesh?: ZLinkRouteMeshChannelOptions;
     readonly publishHandlers?: readonly ZLinkChannelPublishHandlerRegistration[];
+    readonly subscriptions?: readonly string[];
     readonly requestHandlers?: readonly ZLinkChannelRequestHandlerRegistration[];
     readonly sendHandlers?: readonly ZLinkChannelSendHandlerRegistration[];
     readonly server?: {

package/dist/contracts/Configuration/RegistrationValidators.js

@@ -7,8 +7,9 @@ const RouteChannelInternalState_1 = require("./RouteChannelInternalState");
 const TimerRegistrationValidator_1 = require("./TimerRegistrationValidator");
 const Locations_1 = require("../Locations");
 const SendTimeoutValidation_1 = require("./SendTimeoutValidation");
+const FanoutTopic_1 = require("./FanoutTopic");
 function validateFrameworkRegistration(registration, _options = {}) {
-    validateListenerNetworkIdentity('process network', undefined, registration.network.bindHost, registration.network.advertiseHost);
+    validateListenerNetworkIdentity('process network', registration.network.bindHost, registration.network.advertiseHost);
     const actorCapableSpotNodes = [...registration.spotNodes.values()]
         .filter((spotNode) => toActorFactoryCount(spotNode.actorFactories) > 0);
     if (actorCapableSpotNodes.length > 1) {
@@ -143,9 +144,21 @@ function requireNonNegativeSafeInteger(label, value) {
 }
 function validateChannelCapabilities(channels, peerLocationConfigured) {
     for (const [channelName, channel] of Object.entries(channels ?? {})) {
+        for (const topic of channel.subscriptions ?? []) {
+            (0, FanoutTopic_1.requirePublicFanoutTopic)(topic);
+        }
+        if ((channel.subscriptions ?? []).length > 0 && channel.subscriber === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}' fanout subscriptions require a subscriber capability.`);
+        }
+        if (channel.noDrop !== undefined && typeof channel.noDrop !== 'boolean') {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}' NoDrop must be a boolean.`);
+        }
+        if (channel.noDrop !== undefined && channel.publisher === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}' NoDrop requires a publisher role.`);
+        }
         if (channel.server !== undefined) {
             requireEndpoint(`channel '${channelName}' server`, channel.server.bind);
-            validateListenerNetworkIdentity(`channel '${channelName}' server`, channel.server.bind, channel.server.bindHost, channel.server.advertiseHost);
+            validateListenerNetworkIdentity(`channel '${channelName}' server`, channel.server.bindHost, channel.server.advertiseHost);
             if (channel.server.routingId !== undefined) {
                 requireName(`channel '${channelName}' server routingId`, channel.server.routingId);
             }
@@ -154,7 +167,7 @@ function validateChannelCapabilities(channels, peerLocationConfigured) {
         }
         if (channel.publisher !== undefined) {
             requireEndpoint(`channel '${channelName}' publisher`, channel.publisher.bind);
-            validateListenerNetworkIdentity(`channel '${channelName}' publisher`, channel.publisher.bind, channel.publisher.bindHost, channel.publisher.advertiseHost);
+            validateListenerNetworkIdentity(`channel '${channelName}' publisher`, channel.publisher.bindHost, channel.publisher.advertiseHost);
             validateFanoutPublisherIdentity(channelName, channel.routingId, channel.routingIdPrefix, peerLocationConfigured);
         }
         if (channel.client !== undefined) {
@@ -199,7 +212,7 @@ function validateSpotNodes(registration) {
         validateSpotNodeCapability(`SpotNode '${spotNodeName}' router`, spotNode.router);
         validateMeshChannels(spotNodeName, spotNode.meshChannels);
         if (spotNode.router !== undefined) {
-            validateListenerNetworkIdentity(`SpotNode '${spotNodeName}' router`, spotNode.router.bind, spotNode.router.bindHost, spotNode.router.advertiseHost);
+            validateListenerNetworkIdentity(`SpotNode '${spotNodeName}' router`, spotNode.router.bindHost, spotNode.router.advertiseHost);
         }
         validateSpotNodeCapability(`SpotNode '${spotNodeName}' pubSub`, spotNode.pubSub);
         requireNonNegativeSafeInteger(`SpotNode '${spotNodeName}' instanceSpotIdleTimeoutMs`, spotNode.instanceSpotIdleTimeoutMs);
@@ -264,8 +277,7 @@ function validateSpotNodeCapability(capabilityName, capability) {
         throw new ConfigurationException_1.ZLinkConfigurationException(`${capabilityName} routingId must not be empty or padded.`);
     }
 }
-function validateListenerNetworkIdentity(capabilityName, bindEndpoint, configuredBindHost, advertiseHost) {
-    const bindHost = configuredBindHost ?? tcpEndpointHost(bindEndpoint);
+function validateListenerNetworkIdentity(capabilityName, configuredBindHost, advertiseHost) {
     if (configuredBindHost !== undefined) {
         requireName(`${capabilityName} bind host`, configuredBindHost);
     }
@@ -275,13 +287,6 @@ function validateListenerNetworkIdentity(capabilityName, bindEndpoint, configure
             throw new ConfigurationException_1.ZLinkConfigurationException(`${capabilityName} advertise host must identify a connectable host, not a wildcard address.`);
         }
     }
-    if (bindHost !== undefined && isWildcardHost(bindHost) && advertiseHost === undefined) {
-        throw new ConfigurationException_1.ZLinkConfigurationException(`${capabilityName} must define an advertise host when its bind host is a wildcard address.`);
-    }
-}
-function tcpEndpointHost(endpoint) {
-    const match = /^tcp:\/\/(\[[^\]]+\]|[^:]+):\d+$/.exec(endpoint ?? '');
-    return match?.[1];
 }
 function isWildcardHost(host) {
     const normalized = host.startsWith('[') && host.endsWith(']')
@@ -359,7 +364,7 @@ function validateStreamNodes(registration) {
     for (const [streamNodeName, streamNode] of registration.streamNodes.entries()) {
         requireNonNegativeInteger(`STREAM node '${streamNodeName}' maxMessageSize`, streamNode.maxMessageSize);
         requireEndpoint(`STREAM node '${streamNodeName}'`, streamNode.bind);
-        validateListenerNetworkIdentity(`STREAM node '${streamNodeName}'`, streamNode.bind, streamNode.bindHost, streamNode.advertiseHost);
+        validateListenerNetworkIdentity(`STREAM node '${streamNodeName}'`, streamNode.bindHost, streamNode.advertiseHost);
         if (streamNode.tlsServer !== undefined) {
             requireFilePath(`STREAM node '${streamNodeName}' TLS certificate`, streamNode.tlsServer.certificatePath);
             requireFilePath(`STREAM node '${streamNodeName}' TLS key`, streamNode.tlsServer.keyPath);

package/dist/runtime/backend/contracts/index.d.ts

@@ -351,6 +351,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
 }
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
     sendHighWaterMark: number;
+    noDrop: boolean;
     publish(topic: string, message: Message | readonly Message[]): void;
 }
 export interface ZLinkBackendSubscriberSocket extends ZLinkBackendConnectableSocket {

package/dist/runtime/backend/node/node-backend-adapter-support.js

@@ -17,6 +17,7 @@ exports.translateBindingResultError = translateBindingResultError;
 exports.toNativeActorRef = toNativeActorRef;
 const node_backend_adapter_1 = require("../node-backend-adapter");
 const runtime_values_1 = require("../runtime-values");
+const submission_result_1 = require("../../messaging/submission-result");
 exports.zlink = (0, node_backend_adapter_1.loadBinding)();
 function isBindingNotFound(error) {
     return error instanceof exports.zlink.ConfigError && error.result === exports.zlink.ConfigResult.NotFound;
@@ -47,7 +48,14 @@ function submitBindingPublish(operation, payload) {
         current.submit();
     }
     catch (error) {
-        throw translateBindingResultError(error);
+        const translated = translateBindingResultError(error);
+        if (translated instanceof runtime_values_1.ZLinkBackendResultError
+            && translated.operation === 'submit'
+            && (translated.result === runtime_values_1.SubmitResult.Backpressured
+                || translated.result === runtime_values_1.SubmitResult.NotAdmitted)) {
+            (0, submission_result_1.requireOneWayCompletion)({ status: submission_result_1.ZLinkSubmitStatus.Backpressured }, 'Classic fanout publish');
+        }
+        throw translated;
     }
 }
 function submitBindingReply(operation, payload) {

package/dist/runtime/backend/node/node-socket-backend-adapter.js

@@ -80,6 +80,12 @@ function wrapSocket(nativeInstance, pollCompletion) {
         set sendHighWaterMark(value) {
             requireSocketOptions(socket).sendHwm = value;
         },
+        get noDrop() {
+            return socket.options?.noDrop ?? false;
+        },
+        set noDrop(value) {
+            requireSocketOptions(socket).noDrop = value;
+        },
         get receiveHighWaterMark() {
             return Number(socket.options?.recvHwm ?? 0n);
         },

package/dist/runtime/channels/channel-clients.js

@@ -6,6 +6,7 @@ const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const abort_1 = require("../abort");
 const execution_1 = require("../execution");
+const fanout_service_wire_1 = require("./fanout-service-wire");
 const spot_outbound_1 = require("../spots/spot-outbound");
 const packet_name_1 = require("../messaging/packet-name");
 class DefaultZLinkChannelClient {
@@ -59,6 +60,7 @@ class DefaultZLinkFanoutClient {
         const topic = hasExplicitTopic
             ? topicOrEvent
             : (0, packet_name_1.resolveFrameworkPacketName)(event, undefined, 'Fanout');
+        (0, fanout_service_wire_1.requirePublicFanoutTopic)(topic);
         const packetName = (0, packet_name_1.resolveFrameworkPacketName)(event, undefined, 'Fanout');
         return new DefaultZLinkFanoutPublishCall(() => this.requirePublisherChannel(channelName), async (signal) => ({
             status: (await this.requireTransport().publish(channelName, topic, packetName, event, signal)).status

package/dist/runtime/channels/channel-socket-registry.js

@@ -730,8 +730,7 @@ class ZLinkChannelSocketRegistry {
         }
         const subscriber = this.adapter.createSubscriberSocket(this.context);
         subscriber.setChannelName(channelName);
-        subscriber.setSubscription('');
-        subscriber.setSubscription(fanout_service_wire_1.FANOUT_LIVENESS_TOPIC);
+        setFanoutSubscriptions(subscriber, channel.subscriptions);
         const monitor = this.monitoringAdapter.openSocketMonitor(subscriber);
         const connection = {
             channelName,
@@ -913,6 +912,9 @@ class ZLinkChannelSocketRegistry {
             try {
                 publisher.publish(fanout_service_wire_1.FANOUT_LIVENESS_TOPIC, payload);
             }
+            catch (error) {
+                this.oneWayFailureSink?.(error);
+            }
             finally {
                 payload.close();
             }
@@ -1216,6 +1218,7 @@ class ZLinkChannelSocketRegistry {
         }
         const publisher = this.adapter.createPublisherSocket(this.context);
         publisher.setChannelName(channelName);
+        applyFanoutPublisherSocketOptions(publisher, channel);
         publisher.bind(channel.publisher.bind);
         this.publishers.set(channelName, publisher);
         this.fanoutPublisherNextBeacon.set(channelName, performance.now() + CLIENT_SERVER_PROBE_INTERVAL_MS);
@@ -1386,6 +1389,14 @@ function closeMessages(parts) {
     for (const part of parts)
         part.close();
 }
+function setFanoutSubscriptions(subscriber, applicationTopics) {
+    const topics = new Set(applicationTopics);
+    if (topics.size === 0)
+        topics.add('');
+    topics.add(fanout_service_wire_1.FANOUT_LIVENESS_TOPIC);
+    for (const topic of topics)
+        subscriber.setSubscription(topic);
+}
 function deriveRoutingId(baseRoutingId, suffix) {
     const derived = `${baseRoutingId}\0${suffix}`;
     if (Buffer.byteLength(derived, 'utf8') > 255) {
@@ -1393,6 +1404,9 @@ function deriveRoutingId(baseRoutingId, suffix) {
     }
     return derived;
 }
+function applyFanoutPublisherSocketOptions(publisher, channel) {
+    publisher.noDrop = channel.noDrop ?? false;
+}
 function fanoutDiscoveryConnectionId(connectionId) {
     return `fanout:${connectionId.replaceAll('\0', '/')}`;
 }

package/dist/runtime/channels/fanout-service-wire.d.ts

@@ -1,5 +1,6 @@
+import { FANOUT_LIVENESS_TOPIC, requirePublicFanoutTopic } from '../../contracts/Configuration/FanoutTopic';
 import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
-export declare const FANOUT_LIVENESS_TOPIC = "\u0001ZLF1";
+export { FANOUT_LIVENESS_TOPIC, requirePublicFanoutTopic };
 export declare const FANOUT_LIVENESS_PAYLOAD: Uint8Array<ArrayBuffer>;
 export type ZLinkFanoutInboundKind = 'application' | 'beacon' | 'protocolError';
 export interface ZLinkFanoutInboundClassification {
@@ -9,4 +10,3 @@ export interface ZLinkFanoutInboundClassification {
 export declare function inspectFanoutInbound(topic: string, parts: readonly {
     data(): Uint8Array;
 }[]): ZLinkFanoutInboundClassification;
-export declare function requirePublicFanoutTopic(topic: string): void;

package/dist/runtime/channels/fanout-service-wire.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FANOUT_LIVENESS_PAYLOAD = exports.FANOUT_LIVENESS_TOPIC = void 0;
+exports.FANOUT_LIVENESS_PAYLOAD = exports.requirePublicFanoutTopic = exports.FANOUT_LIVENESS_TOPIC = void 0;
 exports.inspectFanoutInbound = inspectFanoutInbound;
-exports.requirePublicFanoutTopic = requirePublicFanoutTopic;
-const configuration_1 = require("../configuration");
+const FanoutTopic_1 = require("../../contracts/Configuration/FanoutTopic");
+Object.defineProperty(exports, "FANOUT_LIVENESS_TOPIC", { enumerable: true, get: function () { return FanoutTopic_1.FANOUT_LIVENESS_TOPIC; } });
+Object.defineProperty(exports, "requirePublicFanoutTopic", { enumerable: true, get: function () { return FanoutTopic_1.requirePublicFanoutTopic; } });
 const channel_envelope_inspection_1 = require("./channel-envelope-inspection");
-exports.FANOUT_LIVENESS_TOPIC = '\x01ZLF1';
 exports.FANOUT_LIVENESS_PAYLOAD = Uint8Array.from([0x5a, 0x46, 0x01, 0x01]);
 function inspectFanoutInbound(topic, parts) {
-    if (topic !== exports.FANOUT_LIVENESS_TOPIC) {
+    if (topic !== FanoutTopic_1.FANOUT_LIVENESS_TOPIC) {
         const header = (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(parts);
         return header === undefined
             ? { kind: 'protocolError' }
@@ -22,8 +22,3 @@ function inspectFanoutInbound(topic, parts) {
         ? { kind: 'beacon' }
         : { kind: 'protocolError' };
 }
-function requirePublicFanoutTopic(topic) {
-    if (topic === exports.FANOUT_LIVENESS_TOPIC) {
-        throw new configuration_1.ZLinkConfigurationException('Fanout topic is reserved for framework liveness.');
-    }
-}

package/dist/runtime/locations/in-memory-authority-store.js

@@ -174,7 +174,15 @@ class ZLinkInMemoryAuthorityStore {
             if (current.snapshot.allocation.state === 'active') {
                 return { kind: 'alreadyExists', current: this.snapshot(current.snapshot) };
             }
-            return { kind: 'conflict', current: this.read(key) };
+            // An unfinished creation whose owner lease ended is cancellable.
+            // Reclaim it so the key does not stay blocked forever.
+            if (this.isOwnerLive(current.snapshot) || current.creation === undefined) {
+                return { kind: 'conflict', current: this.read(key) };
+            }
+            this.adjustCapacity(this.pendingCapacity, current.snapshot.allocation, -1);
+            this.rows.delete(key);
+            this.creationTerminals.set(current.creation.reservationId, 'aborted');
+            this.scanRevision++;
         }
         const target = creationTarget(request);
         if (!this.validation.isTargetLive(target.descriptor, target.lifecycleGeneration, target.owner)) {

package/dist/runtime/locations/location-store-repository.js

@@ -758,9 +758,56 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     || snapshot.allocation.stableType !== request.intent.stableType) {
                     return { kind: 'typeMismatch', current: snapshot };
                 }
-                return snapshot.allocation.state === 'active'
-                    ? { kind: 'alreadyExists', current: snapshot }
-                    : { kind: 'conflict', current: snapshot };
+                if (snapshot.allocation.state === 'active') {
+                    return { kind: 'alreadyExists', current: snapshot };
+                }
+                if (record.aggregate !== undefined
+                    || isCanonicalAuthorityPayload(record.snapshot.payload)) {
+                    // A relocation record carries its own recovery protocol. Reserve
+                    // may reclaim only an unfinished plain creation.
+                    return { kind: 'conflict', current: snapshot };
+                }
+                // The row is Reserved by another owner. An unfinished creation
+                // whose owner lease ended is cancellable, so reclaim it and retry
+                // instead of blocking the key forever.
+                const staleOwnerKey = ownerKey(snapshot.ownerId);
+                const staleCapacityKey = capacityKey(snapshot.allocation.descriptor.meshName, String(snapshot.allocation.descriptor.rid));
+                const [staleOwnerRead, staleCapacityRead] = await Promise.all([
+                    this.provider.read(staleOwnerKey, signal),
+                    this.provider.read(staleCapacityKey, signal)
+                ]);
+                if (staleOwnerRead.kind === 'found'
+                    && staleOwnerRead.value.expiresAt === undefined) {
+                    // A lease is always written with a positive TTL, so a missing
+                    // expiry is a corrupt record. Reclaiming deletes authority state,
+                    // so refuse rather than read the absence as expiry.
+                    throw new Error('Location Store owner lease record is invalid.');
+                }
+                if (sameLiveOwner(staleOwnerRead, record.snapshot)) {
+                    return { kind: 'conflict', current: snapshot };
+                }
+                const staleCapacity = staleCapacityRead.kind === 'missing'
+                    ? emptyCapacityRecord()
+                    : decodeJson(staleCapacityRead.value.bytes);
+                await this.provider.write({
+                    conditions: [
+                        { kind: 'version', key: rowKey, expected: current.value.version },
+                        versionCondition(staleOwnerKey, staleOwnerRead),
+                        conditionFor(staleCapacityKey, staleCapacityRead)
+                    ],
+                    mutations: [
+                        { kind: 'delete', key: rowKey },
+                        {
+                            kind: 'put',
+                            key: staleCapacityKey,
+                            bytes: encodeJson({
+                                active: staleCapacity.active,
+                                pending: subtractCapacity(staleCapacity.pending, record.snapshot.allocation.capacity)
+                            })
+                        }
+                    ]
+                }, signal);
+                continue;
             }
             const descriptor = liveTargetDescriptor(descriptorRead, leaseRead, request.target);
             if (descriptor === undefined) {
@@ -950,6 +997,12 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 this.provider.read(leaseKey, signal),
                 this.provider.read(capacityRowKey, signal)
             ]);
+            if (leaseRead.kind === 'found' && leaseRead.value.expiresAt === undefined) {
+                // A lease is always written with a positive TTL, so a missing expiry
+                // is a corrupt record. Abort deletes authority state, so refuse
+                // rather than read the absence as expiry.
+                throw new Error('Location Store owner lease record is invalid.');
+            }
             if (!sameLiveOwner(leaseRead, record.snapshot))
                 return { kind: 'stale' };
             const capacity = capacityRead.kind === 'missing'
@@ -2896,6 +2949,11 @@ function sameCreationTarget(snapshot, target) {
         && snapshot.ownerId === target.owner.ownerId
         && snapshot.ownerLeaseGeneration === target.owner.leaseGeneration;
 }
+const CANONICAL_AUTHORITY_MAGIC = Buffer.from('ZLAU');
+function isCanonicalAuthorityPayload(payload) {
+    return payload.byteLength >= CANONICAL_AUTHORITY_MAGIC.byteLength
+        && Buffer.from(payload.buffer, payload.byteOffset, CANONICAL_AUTHORITY_MAGIC.byteLength).equals(CANONICAL_AUTHORITY_MAGIC);
+}
 function sameLiveOwner(lease, snapshot) {
     if (lease.kind === 'missing')
         return false;

package/dist/runtime/streams/index.d.ts

@@ -3,7 +3,7 @@ import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProvider
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import { ZLinkMessage } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkFrameworkRegistration } from '../configuration';
+import { type ZLinkFrameworkRegistration } from '../configuration';
 import { ZLinkDispatchErrorReporter } from '../channels';
 import type { ZLinkBackendAdapterFactory, ZLinkBackendActorSessionNode, ZLinkBackendContext, ZLinkBackendMeshNode } from '../backend/contracts';
 import type { ZLinkMeshCompletionTable } from '../backend/mesh-completion-table';

package/dist/runtime/streams/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStreamBindingRuntime = exports.ZLinkStreamSessionNodeRuntime = exports.ZLinkStreamSessionRuntime = exports.ZLinkStreamRuntimeManager = exports.DefaultZLinkSessionContext = exports.DefaultZLinkSessionActor = exports.DefaultZLinkBoundSessionFactory = exports.DefaultZLinkBoundSession = exports.ZLinkManagedStream = exports.zlinkStreamLz4CompressionCodec = exports.ZLinkActorSessionBindingRegistry = exports.ZLinkActorSessionLifecycleCoordinator = exports.ZLinkPendingSessionRequest = void 0;
+const configuration_1 = require("../configuration");
 const service_session_binding_ingress_port_1 = require("../foundation/service-session-binding-ingress-port");
 const protocol_1 = require("./protocol");
 const actor_session_binding_registry_1 = require("./actor-session-binding-registry");
@@ -64,6 +65,11 @@ class ZLinkStreamRuntimeManager {
                 socket.setTlsServer(tlsServer.certificatePath, tlsServer.keyPath, tlsServer.requireClientCertificate ?? false);
             }
             socket.bind(streamNode.bind);
+            const boundEndpoint = socket.lastEndpoint ?? streamNode.bind;
+            const advertisedEndpoint = (0, configuration_1.buildAdvertisedEndpoint)(boundEndpoint, streamNode.advertiseHost, 'tcp');
+            if (advertisedEndpoint === undefined) {
+                throw new configuration_1.ZLinkConfigurationException(`STREAM node '${nodeName}' advertised host requires a TCP endpoint, received '${boundEndpoint}'.`);
+            }
             const readablePoller = streamAdapter.createReadablePoller(socket);
             const nativeSessionRoutes = new Map();
             if (actorDispatchEnabled) {
@@ -120,6 +126,7 @@ class ZLinkStreamRuntimeManager {
             runtime.start();
             this.nodes.set(nodeName, {
                 meshName: applicationMeshName,
+                advertisedEndpoint,
                 runtime,
                 socket,
                 monitor,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.13.0",
-    "@zlink-systems/zlink": "1.1.0"
+    "@zlink-systems/stream-wire": "0.15.0",
+    "@zlink-systems/zlink": "1.2.0"
   }
 }

package/src/contracts/Configuration/Builders.ts

@@ -184,7 +184,9 @@ export interface ZLinkFanoutChannelBuilder {
   setAdvertiseHost(advertiseHost: string): this;
   routingId(routingId: string): this;
   setRoutingIdPrefix(prefix: string): this;
+  setNoDrop(noDrop?: boolean): this;
   enableSubscriber(): this;
+  subscribe(topic: string): this;
   connect(endpoint: string): this;
   subscriberConnections(): ZLinkEndpointConnections;
 }

package/src/contracts/Configuration/EndpointNotation.ts

@@ -184,7 +184,7 @@ export function parseEndpointHostPort(
   };
 }
 
-const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(?:\[[^\]]+\]|[^:]+):(\d+)$/;
+const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(\[[^\]]+\]|[^:]+):(\d+)$/;
 
 /**
  * Builds a normalized `scheme://advertiseHost:port` endpoint from a bound
@@ -198,16 +198,29 @@ const ADVERTISE_SOURCE_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(?:\[[^\]]+\]|[
  * endpoint, or (when `restrictToScheme` is given) when its scheme doesn't
  * match after lowercasing -- callers translate that into their own
  * capability-specific `ZLinkConfigurationException` message. Returns
- * `boundEndpoint` normalized (unrestricted) when `advertiseHost` is
- * undefined -- the common case, and the actual bound endpoint that ends up
- * on the wire and in descriptors compared elsewhere.
+ * `boundEndpoint` normalized when `advertiseHost` is undefined, except that
+ * wildcard TCP hosts use the same-family loopback address. This keeps the
+ * bind-only default connectable without advertising a wildcard address.
  */
 export function buildAdvertisedEndpoint(
   boundEndpoint: string,
   advertiseHost: string | undefined,
   restrictToScheme?: string
 ): string | undefined {
-  if (advertiseHost === undefined) return normalizeEndpoint(boundEndpoint);
+  if (advertiseHost === undefined) {
+    const normalized = normalizeEndpoint(boundEndpoint);
+    const match = ADVERTISE_SOURCE_PATTERN.exec(normalized);
+    if (match === null) return normalized;
+    const boundHost = unbracketHost(match[2]);
+    const defaultHost = boundHost === '0.0.0.0'
+      ? '127.0.0.1'
+      : boundHost === '::'
+        ? '::1'
+        : undefined;
+    if (defaultHost === undefined) return normalized;
+    const host = defaultHost.includes(':') ? `[${defaultHost}]` : defaultHost;
+    return normalizeEndpoint(`${match[1].toLowerCase()}://${host}:${match[3]}`);
+  }
   const match = ADVERTISE_SOURCE_PATTERN.exec(boundEndpoint);
   if (match === null) return undefined;
   const scheme = match[1].toLowerCase();
@@ -215,7 +228,11 @@ export function buildAdvertisedEndpoint(
   const host = advertiseHost.includes(':') && !advertiseHost.startsWith('[')
     ? `[${advertiseHost}]`
     : advertiseHost;
-  return normalizeEndpoint(`${scheme}://${host}:${match[2]}`);
+  return normalizeEndpoint(`${scheme}://${host}:${match[3]}`);
+}
+
+function unbracketHost(host: string): string {
+  return host.startsWith('[') && host.endsWith(']') ? host.slice(1, -1) : host;
 }
 
 function normalizeSuffix(suffix: string): string {

package/src/contracts/Configuration/FanoutTopic.ts

@@ -0,0 +1,12 @@
+import { ZLinkConfigurationException } from './ConfigurationException';
+
+export const FANOUT_LIVENESS_TOPIC = '\x01ZLF1';
+
+export function requirePublicFanoutTopic(topic: string): void {
+  if (typeof topic !== 'string') {
+    throw new ZLinkConfigurationException('Fanout topic must be a string.');
+  }
+  if (topic.startsWith(FANOUT_LIVENESS_TOPIC)) {
+    throw new ZLinkConfigurationException('Fanout topic is reserved for framework liveness.');
+  }
+}