@agentplat/mesh 0.3.0-alpha.1 → 0.3.0-alpha.3

package/dist/coordination-objective-topic-contracts.d.ts

@@ -0,0 +1,70 @@
+import type { SignedMeshEnvelope } from '@agentplat/mesh-protocol';
+import type { MeshCoordinationTopicAddress, MeshCoordinationTopicLimits, MeshCoordinationTopicTime } from './coordination-topic-contracts.js';
+import type { MeshObjectiveInboundProcessor, MeshObjectiveInboundRuntimeState } from './coordination-inbound-contracts.js';
+import type { MeshObjectivePayload } from './coordination-objective-work-contracts.js';
+/** An Objective topic route is always an exact process-local peer instance. */
+export type MeshCoordinationObjectiveTopicAddress = MeshCoordinationTopicAddress;
+/** One trusted receiver-time sample supplied outside the Objective topic driver. */
+export type MeshCoordinationObjectiveTopicTime = MeshCoordinationTopicTime;
+/** Hard ceilings retained by one independently scoped Objective driver. */
+export interface MeshCoordinationObjectiveTopicLimits extends MeshCoordinationTopicLimits {
+}
+/** Address-aware trusted clock used for Objective selection and delivery. */
+export interface MeshCoordinationObjectiveTopicClock {
+    now(address: MeshCoordinationObjectiveTopicAddress): MeshCoordinationObjectiveTopicTime;
+}
+/** Frozen construction snapshot safe to expose for local inspection. */
+export interface MeshCoordinationObjectiveTopicConfiguration extends MeshCoordinationObjectiveTopicLimits {
+    readonly tenantId: string;
+    readonly meshId: string;
+}
+/** Redacted local-only delivery detail; callback failures are ignored. */
+export interface MeshCoordinationObjectiveTopicDiagnostic {
+    readonly status: 'rejected' | 'unavailable';
+    readonly code: string;
+    readonly messageId: string;
+    readonly target: MeshCoordinationObjectiveTopicAddress;
+}
+/** Construction options for one explicit, process-local Objective topic driver. */
+export interface MeshCoordinationObjectiveTopicDriverOptions {
+    readonly tenantId: string;
+    readonly meshId: string;
+    readonly clock: MeshCoordinationObjectiveTopicClock;
+    readonly maximumEndpoints?: number;
+    readonly maximumQueueDepth?: number;
+    readonly maximumQueuedBytes?: number;
+    readonly maximumDeliveriesPerPublish?: number;
+    readonly maximumInternalStepsPerDrain?: number;
+    readonly onDiagnostic?: (diagnostic: MeshCoordinationObjectiveTopicDiagnostic) => void;
+}
+/** State and authenticated Objective processor installed at one exact endpoint. */
+export interface MeshCoordinationObjectiveTopicRegistration {
+    readonly state: MeshObjectiveInboundRuntimeState;
+    readonly processor: MeshObjectiveInboundProcessor;
+}
+/** One already-signed Objective publication and optional bounded sender fanout. */
+export interface MeshCoordinationObjectiveTopicPublishInput {
+    readonly envelope: SignedMeshEnvelope<MeshObjectivePayload>;
+    readonly fanout?: number;
+}
+/** Public delivery outcome, deliberately excluding exact rejection codes. */
+export interface MeshCoordinationObjectiveTopicReceipt {
+    readonly status: 'accepted' | 'rejected' | 'unavailable';
+    readonly messageId: string;
+    readonly target: MeshCoordinationObjectiveTopicAddress;
+}
+/** Mutable driver-owned endpoint around immutable inbound snapshots. */
+export interface MeshCoordinationObjectiveTopicPeer {
+    readonly address: MeshCoordinationObjectiveTopicAddress;
+    getState(): MeshObjectiveInboundRuntimeState;
+    publish(input: MeshCoordinationObjectiveTopicPublishInput): Promise<readonly MeshCoordinationObjectiveTopicReceipt[]>;
+    unregister(): void;
+}
+/** Bounded sender-view Objective delivery with no process-global routing. */
+export interface MeshCoordinationObjectiveTopicDriver {
+    readonly configuration: MeshCoordinationObjectiveTopicConfiguration;
+    register(registration: MeshCoordinationObjectiveTopicRegistration): MeshCoordinationObjectiveTopicPeer;
+    idle(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=coordination-objective-topic-contracts.d.ts.map

package/dist/coordination-objective-topic-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination-objective-topic-contracts.d.ts","sourceRoot":"","sources":["../src/coordination-objective-topic-contracts.ts"],"names":[],"mappings":"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"}

package/dist/coordination-objective-topic-contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coordination-objective-topic-contracts.js.map

package/dist/coordination-objective-topic-contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination-objective-topic-contracts.js","sourceRoot":"","sources":["../src/coordination-objective-topic-contracts.ts"],"names":[],"mappings":""}

package/dist/coordination-objective-topic.d.ts

@@ -0,0 +1,6 @@
+import type { MeshCoordinationObjectiveTopicDriver, MeshCoordinationObjectiveTopicDriverOptions, MeshCoordinationObjectiveTopicLimits } from './coordination-objective-topic-contracts.js';
+/** Conservative defaults that may only be reduced per driver instance. */
+export declare const DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS: Readonly<MeshCoordinationObjectiveTopicLimits>;
+/** Creates one isolated Objective topic driver with construction-bound trust inputs. */
+export declare function createMeshCoordinationObjectiveTopicDriver(options: MeshCoordinationObjectiveTopicDriverOptions): MeshCoordinationObjectiveTopicDriver;
+//# sourceMappingURL=coordination-objective-topic.d.ts.map

package/dist/coordination-objective-topic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordination-objective-topic.d.ts","sourceRoot":"","sources":["../src/coordination-objective-topic.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAIV,oCAAoC,EACpC,2CAA2C,EAC3C,oCAAoC,EAMrC,MAAM,6CAA6C,CAAC;AAMrD,0EAA0E;AAC1E,eAAO,MAAM,gDAAgD,EAAE,QAAQ,CAAC,oCAAoC,CAOxG,CAAC;AAoBL,wFAAwF;AACxF,wBAAgB,0CAA0C,CACxD,OAAO,EAAE,2CAA2C,GACnD,oCAAoC,CAQtC"}

package/dist/coordination-objective-topic.js

@@ -0,0 +1,561 @@
+import { DEFAULT_MESH_PROTOCOL_LIMITS, canonicalizeMeshJsonBytes, compareMeshTimestamps, validateSignedMeshEnvelope, } from '@agentplat/mesh-protocol';
+import { isTrustedMeshObjectiveInboundDecision } from './coordination-inbound.js';
+import { createMeshObjectiveInboundRuntimeState } from './coordination-inbound-state.js';
+import { assertMeshLogicalTime } from './state.js';
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:@-]*$/;
+const utf8Encoder = new TextEncoder();
+/** Conservative defaults that may only be reduced per driver instance. */
+export const DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS = Object.freeze({
+    maximumEndpoints: 256,
+    maximumQueueDepth: 1_024,
+    maximumQueuedBytes: 16 * 1_024 * 1_024,
+    maximumDeliveriesPerPublish: 32,
+    maximumInternalStepsPerDrain: 1_024,
+});
+/** Creates one isolated Objective topic driver with construction-bound trust inputs. */
+export function createMeshCoordinationObjectiveTopicDriver(options) {
+    const driver = new InMemoryMeshCoordinationObjectiveTopicDriver(options);
+    return Object.freeze({
+        configuration: driver.configuration,
+        register: driver.register.bind(driver),
+        idle: driver.idle.bind(driver),
+        close: driver.close.bind(driver),
+    });
+}
+class InMemoryMeshCoordinationObjectiveTopicDriver {
+    configuration;
+    #now;
+    #onDiagnostic;
+    #endpoints = new Map();
+    #queue = [];
+    #insertionSequence = 0;
+    #queuedBytes = 0;
+    #inFlight = 0;
+    #inFlightBytes = 0;
+    #draining = false;
+    #closed = false;
+    #idlePromise;
+    #resolveIdle;
+    #closePromise;
+    #resolveClose;
+    constructor(options) {
+        assertOptions(options);
+        const limits = resolveLimits(options);
+        this.configuration = Object.freeze({
+            tenantId: options.tenantId,
+            meshId: options.meshId,
+            ...limits,
+        });
+        this.#now = options.clock.now.bind(options.clock);
+        this.#onDiagnostic =
+            options.onDiagnostic === undefined
+                ? undefined
+                : options.onDiagnostic.bind(undefined);
+    }
+    register(registration) {
+        if (this.#closed) {
+            throw new Error('Mesh coordination Objective topic driver is closed');
+        }
+        assertRegistration(registration);
+        if (this.#endpoints.size >= this.configuration.maximumEndpoints) {
+            throw new RangeError('Mesh coordination Objective topic endpoint capacity exceeded');
+        }
+        assertRuntimeState(registration.state);
+        const identity = registration.state.discovery.identity;
+        if (identity.tenantId !== this.configuration.tenantId ||
+            identity.meshId !== this.configuration.meshId) {
+            throw new TypeError('Mesh coordination Objective topic endpoint scope mismatch');
+        }
+        const address = freezeAddress(identity);
+        const key = addressKey(address);
+        if (this.#endpoints.has(key)) {
+            throw new TypeError('Duplicate Mesh coordination Objective topic endpoint');
+        }
+        const endpoint = new RegisteredObjectiveTopicEndpoint(this, address, registration.state, registration.processor.process.bind(registration.processor));
+        this.#endpoints.set(key, endpoint);
+        return endpoint.handle;
+    }
+    idle() {
+        if (this.#isQuiescent())
+            return Promise.resolve();
+        if (!this.#idlePromise) {
+            this.#idlePromise = new Promise((resolve) => {
+                this.#resolveIdle = resolve;
+            });
+        }
+        return this.#idlePromise;
+    }
+    close() {
+        if (this.#closePromise)
+            return this.#closePromise;
+        this.#closed = true;
+        this.#closePromise = new Promise((resolve) => {
+            this.#resolveClose = resolve;
+        }).then(() => {
+            this.#endpoints.clear();
+        });
+        this.#resolveQuiescence();
+        return this.#closePromise;
+    }
+    unregister(endpoint) {
+        const key = addressKey(endpoint.address);
+        if (this.#endpoints.get(key) === endpoint)
+            this.#endpoints.delete(key);
+    }
+    publishFrom(sender, input) {
+        if (this.#closed) {
+            throw new Error('Mesh coordination Objective topic driver is closed');
+        }
+        if (this.#endpoints.get(addressKey(sender.address)) !== sender) {
+            throw new Error('Mesh coordination Objective topic endpoint is unregistered');
+        }
+        assertPublishInput(input);
+        const structural = validateSignedMeshEnvelope(input.envelope);
+        if (!structural.ok) {
+            throw new TypeError('Invalid signed Mesh Objective envelope');
+        }
+        const envelope = structural.value;
+        assertPublicationIdentity(sender, envelope, this.configuration);
+        assertObjectiveTopic(envelope);
+        const time = this.#sampleTime(sender.address);
+        const state = sender.getState();
+        const lastLogicalTime = Math.max(state.coordination.lastLogicalTime, state.discovery.lastLogicalTime, state.objectives.lastLogicalTime, state.inbound.lastLogicalTime);
+        if (time.receivedAt < lastLogicalTime) {
+            throw new RangeError('Mesh coordination Objective topic logical time cannot move backwards');
+        }
+        const maximumFanout = Math.min(this.configuration.maximumDeliveriesPerPublish, state.discovery.limits.maximumFanout);
+        const fanout = input.fanout ?? maximumFanout;
+        if (!Number.isSafeInteger(fanout) || fanout < 1 || fanout > maximumFanout) {
+            throw new RangeError('Invalid Mesh coordination Objective topic fanout');
+        }
+        // Selection begins solely with the sender's own active view. The process
+        // registry only pins an already-selected exact instance; it never expands
+        // the reachable recipient set.
+        const targets = selectTopicTargets(state, sender.address, time, fanout);
+        if (targets.length === 0)
+            return Promise.resolve(Object.freeze([]));
+        const canonical = canonicalizeMeshJsonBytes(envelope);
+        if (!canonical.ok) {
+            throw new TypeError('Invalid canonical Mesh Objective envelope');
+        }
+        const batchBytes = checkedProduct(canonical.value.byteLength, targets.length);
+        if (batchBytes === undefined ||
+            exceedsSum(this.#insertionSequence, targets.length, Number.MAX_SAFE_INTEGER) ||
+            exceedsSum(this.#queue.length + this.#inFlight, targets.length, this.configuration.maximumQueueDepth) ||
+            exceedsSum(this.#queuedBytes + this.#inFlightBytes, batchBytes, this.configuration.maximumQueuedBytes)) {
+            return Promise.resolve(this.#rejectBatch(envelope.messageId, targets, 'queue_capacity_exceeded'));
+        }
+        const promises = targets.map((target) => new Promise((resolve) => {
+            this.#insertionSequence += 1;
+            this.#queue.push({
+                insertionSequence: this.#insertionSequence,
+                envelope,
+                canonicalEnvelope: canonical.value,
+                target,
+                selectedEndpoint: this.#endpoints.get(addressKey(target)),
+                byteLength: canonical.value.byteLength,
+                resolve,
+            });
+        }));
+        this.#queuedBytes += batchBytes;
+        this.#scheduleDrain();
+        return Promise.all(promises).then((receipts) => Object.freeze(receipts));
+    }
+    #rejectBatch(messageId, targets, code) {
+        return Object.freeze(targets.map((target) => {
+            this.#diagnose('rejected', code, messageId, target);
+            return freezeReceipt('rejected', messageId, target);
+        }));
+    }
+    #sampleTime(address) {
+        return freezeTime(this.#now(address));
+    }
+    #scheduleDrain() {
+        if (this.#draining)
+            return;
+        this.#draining = true;
+        void Promise.resolve().then(() => this.#drain());
+    }
+    async #drain() {
+        let steps = 0;
+        try {
+            while (this.#queue.length > 0 &&
+                steps < this.configuration.maximumInternalStepsPerDrain) {
+                const job = this.#queue.shift();
+                if (!job)
+                    break;
+                steps += 1;
+                this.#queuedBytes -= job.byteLength;
+                this.#inFlight = 1;
+                this.#inFlightBytes = job.byteLength;
+                const endpoint = this.#endpoints.get(addressKey(job.target));
+                if (!endpoint || endpoint !== job.selectedEndpoint) {
+                    this.#finishJob(job, freezeReceipt('unavailable', job.envelope.messageId, job.target), 'endpoint_unavailable');
+                    continue;
+                }
+                let receipt;
+                let diagnosticCode;
+                try {
+                    const time = this.#sampleTime(job.target);
+                    const priorState = endpoint.getState();
+                    const request = Object.freeze({
+                        envelope: job.envelope,
+                        verifiedAt: time.verifiedAt,
+                        receivedAt: time.receivedAt,
+                    });
+                    const decision = await endpoint.process(priorState, request);
+                    assertProcessorDecision(decision, priorState, request, job.envelope, job.canonicalEnvelope);
+                    endpoint.setState(decision.state);
+                    if (decision.accepted) {
+                        receipt = freezeReceipt('accepted', job.envelope.messageId, job.target);
+                    }
+                    else {
+                        diagnosticCode = decision.code;
+                        receipt = freezeReceipt('rejected', job.envelope.messageId, job.target);
+                    }
+                }
+                catch {
+                    diagnosticCode = 'endpoint_failed';
+                    receipt = freezeReceipt('rejected', job.envelope.messageId, job.target);
+                }
+                this.#finishJob(job, receipt, diagnosticCode);
+            }
+        }
+        finally {
+            this.#draining = false;
+            if (this.#queue.length > 0) {
+                this.#scheduleDrain();
+            }
+            else {
+                this.#resolveQuiescence();
+            }
+        }
+    }
+    #finishJob(job, receipt, diagnosticCode) {
+        this.#inFlight = 0;
+        this.#inFlightBytes = 0;
+        if (diagnosticCode !== undefined && receipt.status !== 'accepted') {
+            this.#diagnose(receipt.status, diagnosticCode, job.envelope.messageId, job.target);
+        }
+        job.resolve(receipt);
+    }
+    #diagnose(status, code, messageId, target) {
+        try {
+            this.#onDiagnostic?.(Object.freeze({ status, code, messageId, target }));
+        }
+        catch {
+            // Local diagnostics cannot change delivery or committed endpoint state.
+        }
+    }
+    #isQuiescent() {
+        return !this.#draining && this.#inFlight === 0 && this.#queue.length === 0;
+    }
+    #resolveQuiescence() {
+        if (!this.#isQuiescent())
+            return;
+        const resolveIdle = this.#resolveIdle;
+        this.#resolveIdle = undefined;
+        this.#idlePromise = undefined;
+        resolveIdle?.();
+        if (this.#closed) {
+            this.#resolveClose?.();
+            this.#resolveClose = undefined;
+        }
+    }
+}
+class RegisteredObjectiveTopicEndpoint {
+    address;
+    handle;
+    process;
+    #driver;
+    #state;
+    constructor(driver, address, state, process) {
+        this.#driver = driver;
+        this.address = address;
+        this.#state = state;
+        this.process = process;
+        this.handle = Object.freeze({
+            address,
+            getState: this.getState.bind(this),
+            publish: this.publish.bind(this),
+            unregister: this.unregister.bind(this),
+        });
+        Object.freeze(this);
+    }
+    getState() {
+        return this.#state;
+    }
+    setState(state) {
+        this.#state = state;
+    }
+    publish(input) {
+        return this.#driver.publishFrom(this, input);
+    }
+    unregister() {
+        this.#driver.unregister(this);
+    }
+}
+function selectTopicTargets(state, sender, time, fanout) {
+    const targets = [];
+    for (const [peerId, view] of Object.entries(state.discovery.peerViews)) {
+        const card = state.discovery.peerCards[peerId];
+        const admission = state.discovery.admittedPeers[peerId];
+        if (!card ||
+            !admission ||
+            card.status !== 'active' ||
+            view.expiresAt <= time.receivedAt ||
+            card.expiresAt <= time.receivedAt ||
+            view.peerCardId !== card.peerCardId ||
+            view.cardRevision !== card.cardRevision ||
+            !admission.instanceIds.includes(card.instanceId) ||
+            !timestampIsBefore(time.verifiedAt, admission.validUntil) ||
+            (peerId === sender.peerId && card.instanceId === sender.instanceId)) {
+            continue;
+        }
+        targets.push(Object.freeze({
+            tenantId: sender.tenantId,
+            meshId: sender.meshId,
+            peerId,
+            instanceId: card.instanceId,
+        }));
+    }
+    targets.sort(compareAddresses);
+    return Object.freeze(targets.slice(0, fanout));
+}
+function assertPublicationIdentity(sender, envelope, configuration) {
+    const identity = sender.getState().discovery.identity;
+    if (envelope.tenantId !== configuration.tenantId ||
+        envelope.meshId !== configuration.meshId ||
+        envelope.tenantId !== sender.address.tenantId ||
+        envelope.meshId !== sender.address.meshId ||
+        envelope.sender.peerId !== sender.address.peerId ||
+        envelope.sender.instanceId !== sender.address.instanceId ||
+        envelope.proof.keyId !== identity.keyId) {
+        throw new TypeError('Mesh coordination Objective topic sender identity mismatch');
+    }
+    if (envelope.audience.kind !== 'mesh') {
+        throw new TypeError('Mesh coordination Objective topic audience is required');
+    }
+}
+function assertObjectiveTopic(envelope) {
+    if (envelope.audience.kind !== 'mesh' ||
+        envelope.audience.topic !== 'objective' ||
+        (envelope.payload.type !== 'objective.announce' &&
+            envelope.payload.type !== 'objective.revise' &&
+            envelope.payload.type !== 'objective.cancel')) {
+        throw new TypeError('Mesh coordination Objective message family/topic mismatch');
+    }
+}
+function assertProcessorDecision(decision, priorState, request, envelope, canonicalEnvelope) {
+    if (!isPlainDataRecord(decision) ||
+        !Object.isFrozen(decision) ||
+        typeof decision.accepted !== 'boolean' ||
+        !isTrustedMeshObjectiveInboundDecision(decision, priorState, request)) {
+        throw new TypeError('Invalid Mesh coordination Objective topic processor result');
+    }
+    const expectedKeys = decision.accepted
+        ? ['accepted', 'duplicate', 'envelope', 'state']
+        : ['accepted', 'code', 'state'];
+    if (!hasExactDataKeys(decision, expectedKeys, expectedKeys)) {
+        throw new TypeError('Invalid Mesh coordination Objective topic processor result');
+    }
+    assertRuntimeState(decision.state);
+    const expectedIdentity = priorState.discovery.identity;
+    const identity = decision.state.discovery.identity;
+    if (identity.tenantId !== expectedIdentity.tenantId ||
+        identity.meshId !== expectedIdentity.meshId ||
+        identity.peerId !== expectedIdentity.peerId ||
+        identity.instanceId !== expectedIdentity.instanceId ||
+        identity.keyId !== expectedIdentity.keyId) {
+        throw new TypeError('Mesh coordination Objective topic processor changed identity');
+    }
+    if (decision.accepted) {
+        const acceptedEnvelope = validateSignedMeshEnvelope(decision.envelope);
+        const acceptedCanonical = acceptedEnvelope.ok
+            ? canonicalizeMeshJsonBytes(acceptedEnvelope.value)
+            : undefined;
+        if (typeof decision.duplicate !== 'boolean' ||
+            !Object.isFrozen(decision.envelope) ||
+            decision.envelope.messageId !== envelope.messageId ||
+            !acceptedCanonical ||
+            !acceptedCanonical.ok ||
+            !sameBytes(acceptedCanonical.value, canonicalEnvelope)) {
+            throw new TypeError('Invalid Mesh coordination Objective topic acceptance');
+        }
+    }
+    else if (typeof decision.code !== 'string' || decision.code.length < 1) {
+        throw new TypeError('Invalid Mesh coordination Objective topic rejection');
+    }
+}
+function assertRuntimeState(state) {
+    if (!isPlainDataRecord(state) ||
+        !Object.isFrozen(state) ||
+        !hasExactDataKeys(state, ['coordination', 'discovery', 'inbound', 'objectives'], ['coordination', 'discovery', 'inbound', 'objectives'])) {
+        throw new TypeError('Mesh coordination Objective topic state must be an immutable snapshot');
+    }
+    createMeshObjectiveInboundRuntimeState(state.coordination, state.discovery, state.objectives, state.inbound);
+}
+function assertOptions(options) {
+    if (!isPlainDataRecord(options) ||
+        !hasExactDataKeys(options, [
+            'clock',
+            'maximumDeliveriesPerPublish',
+            'maximumEndpoints',
+            'maximumInternalStepsPerDrain',
+            'maximumQueueDepth',
+            'maximumQueuedBytes',
+            'meshId',
+            'onDiagnostic',
+            'tenantId',
+        ], ['clock', 'meshId', 'tenantId'])) {
+        throw new TypeError('Invalid Mesh coordination Objective topic driver options');
+    }
+    assertIdentifier(options.tenantId, 'tenantId');
+    assertIdentifier(options.meshId, 'meshId');
+    if (!options.clock ||
+        typeof options.clock !== 'object' ||
+        typeof options.clock.now !== 'function' ||
+        (options.onDiagnostic !== undefined &&
+            typeof options.onDiagnostic !== 'function')) {
+        throw new TypeError('Invalid Mesh coordination Objective topic trusted dependency');
+    }
+}
+function assertRegistration(registration) {
+    if (!isPlainDataRecord(registration) ||
+        !hasExactDataKeys(registration, ['processor', 'state'], ['processor', 'state']) ||
+        !registration.processor ||
+        typeof registration.processor !== 'object' ||
+        typeof registration.processor.process !== 'function') {
+        throw new TypeError('Invalid Mesh coordination Objective topic registration');
+    }
+}
+function assertPublishInput(input) {
+    if (!isPlainDataRecord(input) ||
+        !hasExactDataKeys(input, ['envelope', 'fanout'], ['envelope'])) {
+        throw new TypeError('Invalid Mesh coordination Objective topic publish input');
+    }
+}
+function resolveLimits(options) {
+    const limits = {
+        maximumEndpoints: options.maximumEndpoints ??
+            DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS.maximumEndpoints,
+        maximumQueueDepth: options.maximumQueueDepth ??
+            DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS.maximumQueueDepth,
+        maximumQueuedBytes: options.maximumQueuedBytes ??
+            DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS.maximumQueuedBytes,
+        maximumDeliveriesPerPublish: options.maximumDeliveriesPerPublish ??
+            DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS.maximumDeliveriesPerPublish,
+        maximumInternalStepsPerDrain: options.maximumInternalStepsPerDrain ??
+            DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS.maximumInternalStepsPerDrain,
+    };
+    for (const [name, value] of Object.entries(limits)) {
+        const ceiling = DEFAULT_MESH_COORDINATION_OBJECTIVE_TOPIC_LIMITS[name];
+        if (!Number.isSafeInteger(value) || value < 1 || value > ceiling) {
+            throw new RangeError(`Mesh coordination Objective topic ${name} must be a positive safe integer no greater than its default`);
+        }
+    }
+    return Object.freeze(limits);
+}
+function freezeAddress(value) {
+    assertIdentifier(value.tenantId, 'tenantId');
+    assertIdentifier(value.meshId, 'meshId');
+    assertIdentifier(value.peerId, 'peerId');
+    assertIdentifier(value.instanceId, 'instanceId');
+    return Object.freeze({
+        tenantId: value.tenantId,
+        meshId: value.meshId,
+        peerId: value.peerId,
+        instanceId: value.instanceId,
+    });
+}
+function freezeTime(value) {
+    if (!isPlainDataRecord(value) ||
+        !hasExactDataKeys(value, ['receivedAt', 'verifiedAt'], ['receivedAt', 'verifiedAt'])) {
+        throw new TypeError('Invalid Mesh coordination Objective topic time sample');
+    }
+    assertMeshLogicalTime(value.receivedAt);
+    if (!compareMeshTimestamps(value.verifiedAt, value.verifiedAt).ok) {
+        throw new TypeError('Invalid Mesh coordination Objective topic verification time');
+    }
+    return Object.freeze({
+        verifiedAt: value.verifiedAt,
+        receivedAt: value.receivedAt,
+    });
+}
+function freezeReceipt(status, messageId, target) {
+    return Object.freeze({ status, messageId, target });
+}
+function timestampIsBefore(left, right) {
+    const compared = compareMeshTimestamps(left, right);
+    return compared.ok && compared.value < 0;
+}
+function checkedProduct(left, right) {
+    if (!Number.isSafeInteger(left) ||
+        left < 0 ||
+        !Number.isSafeInteger(right) ||
+        right < 0 ||
+        (right !== 0 && left > Math.floor(Number.MAX_SAFE_INTEGER / right))) {
+        return undefined;
+    }
+    return left * right;
+}
+function sameBytes(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        if (left[index] !== right[index])
+            return false;
+    }
+    return true;
+}
+function exceedsSum(left, right, maximum) {
+    return (!Number.isSafeInteger(left) ||
+        left < 0 ||
+        !Number.isSafeInteger(right) ||
+        right < 0 ||
+        left > maximum ||
+        right > maximum - left);
+}
+function compareAddresses(left, right) {
+    if (left.peerId !== right.peerId)
+        return left.peerId < right.peerId ? -1 : 1;
+    if (left.instanceId !== right.instanceId) {
+        return left.instanceId < right.instanceId ? -1 : 1;
+    }
+    return 0;
+}
+function addressKey(address) {
+    return JSON.stringify([
+        address.tenantId,
+        address.meshId,
+        address.peerId,
+        address.instanceId,
+    ]);
+}
+function assertIdentifier(value, name) {
+    if (typeof value !== 'string' ||
+        !identifierPattern.test(value) ||
+        utf8Encoder.encode(value).byteLength >
+            DEFAULT_MESH_PROTOCOL_LIMITS.maximumIdBytes) {
+        throw new TypeError(`Invalid Mesh coordination Objective topic ${name}`);
+    }
+}
+function isPlainDataRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return ((prototype === null || prototype === Object.prototype) &&
+        Object.getOwnPropertySymbols(value).length === 0 &&
+        Object.getOwnPropertyNames(value).every((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            return (descriptor !== undefined &&
+                'value' in descriptor &&
+                descriptor.enumerable === true);
+        }));
+}
+function hasExactDataKeys(value, supportedKeys, requiredKeys) {
+    const supported = new Set(supportedKeys);
+    return (Object.getOwnPropertyNames(value).every((key) => supported.has(key)) &&
+        requiredKeys.every((key) => Object.hasOwn(value, key)));
+}
+//# sourceMappingURL=coordination-objective-topic.js.map