@zlink-systems/framework 0.10.0

package/dist/runtime/protocol/service_wire_pilot_codec.generated.js

@@ -0,0 +1,645 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeActorJoin28 = encodeActorJoin28;
+exports.decodeActorJoin28 = decodeActorJoin28;
+exports.encodeRelocationEnvelopeV1 = encodeRelocationEnvelopeV1;
+exports.decodeRelocationEnvelopeV1 = decodeRelocationEnvelopeV1;
+exports.encodeRelocationDataChunkV1 = encodeRelocationDataChunkV1;
+exports.decodeRelocationDataChunkV1 = decodeRelocationDataChunkV1;
+exports.encodeRelocationManifestV1 = encodeRelocationManifestV1;
+exports.decodeRelocationManifestV1 = decodeRelocationManifestV1;
+exports.encodeLivenessProbe5 = encodeLivenessProbe5;
+exports.decodeLivenessProbe5 = decodeLivenessProbe5;
+exports.encodeLivenessAck6 = encodeLivenessAck6;
+exports.decodeLivenessAck6 = decodeLivenessAck6;
+exports.encodeNodeSend16 = encodeNodeSend16;
+exports.decodeNodeSend16 = decodeNodeSend16;
+exports.encodeNodeRequest17 = encodeNodeRequest17;
+exports.decodeNodeRequest17 = decodeNodeRequest17;
+exports.encodeChannelSend18 = encodeChannelSend18;
+exports.decodeChannelSend18 = decodeChannelSend18;
+exports.encodeChannelRequest19 = encodeChannelRequest19;
+exports.decodeChannelRequest19 = decodeChannelRequest19;
+exports.encodeLogicalMulticast23 = encodeLogicalMulticast23;
+exports.decodeLogicalMulticast23 = decodeLogicalMulticast23;
+exports.encodeActorLookup26 = encodeActorLookup26;
+exports.decodeActorLookup26 = decodeActorLookup26;
+exports.encodeActorDestroy27 = encodeActorDestroy27;
+exports.decodeActorDestroy27 = decodeActorDestroy27;
+exports.encodeReplyRelay33 = encodeReplyRelay33;
+exports.decodeReplyRelay33 = decodeReplyRelay33;
+exports.encodeReplyRelayAck46 = encodeReplyRelayAck46;
+exports.decodeReplyRelayAck46 = decodeReplyRelayAck46;
+exports.encodeRelocationReady30 = encodeRelocationReady30;
+exports.decodeRelocationReady30 = decodeRelocationReady30;
+exports.encodeRelocationFailed53 = encodeRelocationFailed53;
+exports.decodeRelocationFailed53 = decodeRelocationFailed53;
+exports.encodeRelocationData31 = encodeRelocationData31;
+exports.decodeRelocationData31 = decodeRelocationData31;
+exports.encodeRelocationCutover34 = encodeRelocationCutover34;
+exports.decodeRelocationCutover34 = decodeRelocationCutover34;
+exports.encodeRelocationState52 = encodeRelocationState52;
+exports.decodeRelocationState52 = decodeRelocationState52;
+exports.encodeRelocationPrepare40 = encodeRelocationPrepare40;
+exports.decodeRelocationPrepare40 = decodeRelocationPrepare40;
+exports.encodeSessionRelocationSeal42 = encodeSessionRelocationSeal42;
+exports.decodeSessionRelocationSeal42 = decodeSessionRelocationSeal42;
+exports.encodeSessionRelocationSealed43 = encodeSessionRelocationSealed43;
+exports.decodeSessionRelocationSealed43 = decodeSessionRelocationSealed43;
+exports.encodeSessionRelocationRoute44 = encodeSessionRelocationRoute44;
+exports.decodeSessionRelocationRoute44 = decodeSessionRelocationRoute44;
+exports.encodeUserSpotCreate47 = encodeUserSpotCreate47;
+exports.decodeUserSpotCreate47 = decodeUserSpotCreate47;
+exports.encodeUserSpotClose48 = encodeUserSpotClose48;
+exports.decodeUserSpotClose48 = decodeUserSpotClose48;
+exports.encodeActorCreate49 = encodeActorCreate49;
+exports.decodeActorCreate49 = decodeActorCreate49;
+exports.encodeZljrRecordV1 = encodeZljrRecordV1;
+exports.decodeZljrRecordV1 = decodeZljrRecordV1;
+const text = new TextEncoder();
+const decodeText = new TextDecoder("utf-8", { fatal: true });
+function u64(out, value) { if (value < 0n || value > 0xffffffffffffffffn)
+    throw new RangeError("u64"); for (let i = 7; i >= 0; i--)
+    out.push(Number((value >> BigInt(i * 8)) & 255n)); }
+function read64(bytes, at) { if (at.value + 8 > bytes.length)
+    throw new RangeError("truncated u64"); let r = 0n; for (let i = 0; i < 8; i++)
+    r = (r << 8n) | BigInt(bytes[at.value++]); return r; }
+function u32(out, value) { if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
+    throw new RangeError("u32"); out.push(value >>> 24, (value >>> 16) & 255, (value >>> 8) & 255, value & 255); }
+function read32(bytes, at) { if (at.value + 4 > bytes.length)
+    throw new RangeError("truncated u32"); return ((bytes[at.value++] << 24) | (bytes[at.value++] << 16) | (bytes[at.value++] << 8) | bytes[at.value++]) >>> 0; }
+function text8(out, value) { const b = text.encode(value); if (b.length === 0 || b.length > 255 || b.includes(0))
+    throw new RangeError("text8"); out.push(b.length, ...b); }
+function readText8(bytes, at) { const n = bytes[at.value++]; if (n === 0 || at.value + n > bytes.length)
+    throw new RangeError("truncated text8"); const b = bytes.slice(at.value, at.value + n); at.value += n; if (b.includes(0))
+    throw new RangeError("text8 NUL"); return decodeText.decode(b); }
+function rid(out, value) { if (value.length === 0 || value.length > 255)
+    throw new RangeError("rid"); out.push(value.length, ...value); }
+function readRid(bytes, at) { const n = bytes[at.value++]; if (n === 0 || at.value + n > bytes.length)
+    throw new RangeError("truncated rid"); const r = bytes.slice(at.value, at.value + n); at.value += n; return r; }
+function fence(out, value) { if (value.generation === 0n || value.targetNodeGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n || value.expectedOwnerLeaseGeneration === 0n)
+    throw new RangeError("invalid fence"); text8(out, value.id); u64(out, value.generation); rid(out, value.targetNodeRid); u64(out, value.targetNodeGeneration); u64(out, value.expectedAuthorityOwnerGeneration); u64(out, value.expectedOwnerLeaseGeneration); }
+function readFence(bytes, at) { const value = { id: readText8(bytes, at), generation: read64(bytes, at), targetNodeRid: readRid(bytes, at), targetNodeGeneration: read64(bytes, at), expectedAuthorityOwnerGeneration: read64(bytes, at), expectedOwnerLeaseGeneration: read64(bytes, at) }; if (value.generation === 0n || value.targetNodeGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n || value.expectedOwnerLeaseGeneration === 0n)
+    throw new RangeError("invalid fence"); return value; }
+function encodePayload(value) { const body = []; text8(body, value.packetName); text8(body, value.contentType); u32(body, value.payload.length); body.push(...value.payload); const out = [1]; u32(out, body.length); out.push(...body); return Uint8Array.from(out); }
+function decodePayload(bytes) { const at = { value: 0 }; if (bytes[at.value++] !== 1)
+    throw new RangeError("payload version"); const length = read32(bytes, at); if (length !== bytes.length - at.value)
+    throw new RangeError("payload length"); const end = bytes.length; const packetName = readText8(bytes, at); const contentType = readText8(bytes, at); const length2 = read32(bytes, at); if (length2 !== end - at.value)
+    throw new RangeError("payload bytes"); const payload = bytes.slice(at.value); at.value = end; if (at.value !== end)
+    throw new RangeError("payload trailing"); return { packetName, contentType, payload }; }
+function encodeActorJoin28(value) { const out = [90, 77, 1, 28, 0]; if (value.correlation === 0n)
+    throw new RangeError("correlation"); u64(out, value.correlation); fence(out, value.actor); out.push(value.entry ? 1 : 0); fence(out, value.targetSpot); return value.payload === undefined ? [Uint8Array.from(out)] : [Uint8Array.from(out), encodePayload(value.payload)]; }
+function decodeActorJoin28(frames) { if (frames.length < 1 || frames.length > 2)
+    throw new RangeError("actorJoin frames"); const bytes = frames[0]; const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 28 || bytes[at.value++] !== 0)
+    throw new RangeError("actorJoin header"); const correlation = read64(bytes, at); const actor = readFence(bytes, at); const entry = bytes[at.value++]; const targetSpot = readFence(bytes, at); if (correlation === 0n || entry > 1 || at.value !== bytes.length)
+    throw new RangeError("actorJoin body"); const payload = frames.length === 2 ? decodePayload(frames[1]) : undefined; return payload === undefined ? { correlation, actor, entry: entry === 1, targetSpot } : { correlation, actor, entry: entry === 1, targetSpot, payload }; }
+function bytes64(out, v) { u64(out, BigInt(v.length)); out.push(...v); }
+function body16(out, write) { const b = []; write(b); if (b.length > 65535)
+    throw new RangeError("body16"); out.push(b.length >>> 8, b.length & 255, ...b); }
+function body64(out, write) { const b = []; write(b); u64(out, BigInt(b.length)); out.push(...b); }
+function sorted(v, compare, name) { for (let i = 1; i < v.length; i++)
+    if (compare(v[i - 1], v[i]) >= 0)
+        throw new RangeError(name); }
+function read8(bytes, at) { if (at.value >= bytes.length)
+    throw new RangeError("truncated u8"); return bytes[at.value++]; }
+function read16(bytes, at) { if (at.value + 2 > bytes.length)
+    throw new RangeError("truncated u16"); return (bytes[at.value++] << 8) | bytes[at.value++]; }
+function take(bytes, at, n, name) { if (!Number.isSafeInteger(n) || n < 0 || at.value + n > bytes.length)
+    throw new RangeError("truncated " + name); const v = Uint8Array.from(bytes.subarray(at.value, at.value + n)); at.value += n; return v; }
+function nonzero64(bytes, at, name) { const v = read64(bytes, at); if (v === 0n)
+    throw new RangeError(name); return v; }
+function readText16(bytes, at, minimum, maximum, name) { const n = read16(bytes, at); if (n < minimum || n > maximum)
+    throw new RangeError(name); const b = take(bytes, at, n, name); if (b.includes(0))
+    throw new RangeError(name + " NUL"); return decodeText.decode(b); }
+function writeText16(out, value, minimum, maximum, name) { const b = text.encode(value); if (b.length < minimum || b.length > maximum || b.includes(0))
+    throw new RangeError(name); out.push(b.length >>> 8, b.length & 255, ...b); }
+function boundedEnd(bytes, at, length, name) { if (at.value + length > bytes.length)
+    throw new RangeError("truncated " + name); return at.value + length; }
+function exactEnd(at, end, name) { if (at.value !== end)
+    throw new RangeError(name + " trailing"); }
+function skipRid(bytes, at) { const n = read8(bytes, at); if (n === 0)
+    throw new RangeError("rid minimumBytes"); take(bytes, at, n, "rid"); }
+function skipFence(bytes, at) { readText8(bytes, at); nonzero64(bytes, at, "objectGeneration"); skipRid(bytes, at); nonzero64(bytes, at, "targetNodeGeneration"); nonzero64(bytes, at, "authorityOwnerGeneration"); nonzero64(bytes, at, "ownerLeaseGeneration"); }
+function skipPayload(bytes, at) { if (read8(bytes, at) !== 1)
+    throw new RangeError("payload version"); const end = boundedEnd(bytes, at, read32(bytes, at), "payload"); readText8(bytes, at); readText8(bytes, at); take(bytes, at, read32(bytes, at), "payload bytes"); exactEnd(at, end, "payload"); }
+function skipMembership(bytes, at) { readText8(bytes, at); nonzero64(bytes, at, "actor generation"); readText8(bytes, at); nonzero64(bytes, at, "spot generation"); }
+function skipActorControl(bytes, at) { const kind = read8(bytes, at); const end = boundedEnd(bytes, at, read16(bytes, at), "actor control"); if (kind === 1 || kind === 4)
+    skipMembership(bytes, at);
+else if (kind === 2) {
+    const has = read8(bytes, at);
+    const previousEnd = boundedEnd(bytes, at, read16(bytes, at), "optional membership");
+    if (has === 1)
+        skipMembership(bytes, at);
+    else if (has !== 0)
+        throw new RangeError("optional membership");
+    exactEnd(at, previousEnd, "optional membership");
+    skipMembership(bytes, at);
+}
+else if (kind === 3) {
+    skipMembership(bytes, at);
+    skipMembership(bytes, at);
+}
+else if (kind === 5)
+    skipMembership(bytes, at);
+else
+    throw new RangeError("actor lifecycle kind"); exactEnd(at, end, "actor control"); }
+function skipRelocationObject(bytes, at) { const kind = read8(bytes, at); const end = boundedEnd(bytes, at, read16(bytes, at), "relocation object"); if (kind === 1 || kind === 2) {
+    readText8(bytes, at);
+    nonzero64(bytes, at, "object generation");
+    nonzero64(bytes, at, "authority generation");
+}
+else if (kind === 3) {
+    readText8(bytes, at);
+    readText8(bytes, at);
+    nonzero64(bytes, at, "object generation");
+}
+else
+    throw new RangeError("object kind"); exactEnd(at, end, "relocation object"); }
+function skipSendReady(bytes, at) { const kind = read8(bytes, at); const end = boundedEnd(bytes, at, read16(bytes, at), "send-ready destination"); if (kind === 1)
+    skipRid(bytes, at);
+else if (kind === 2)
+    readText8(bytes, at);
+else if (kind === 3 || kind === 4)
+    skipFence(bytes, at);
+else if (kind === 5) {
+    skipFence(bytes, at);
+    nonzero64(bytes, at, "binding generation");
+}
+else
+    throw new RangeError("destination kind"); exactEnd(at, end, "send-ready destination"); }
+function skipRelocationControl(bytes, at) { if (read8(bytes, at) > 9 || ![1, 2, 3].includes(read8(bytes, at)))
+    throw new RangeError("relocation control"); read64(bytes, at); read64(bytes, at); skipRelocationObject(bytes, at); read32(bytes, at); read32(bytes, at); }
+function skipInstanceRoute(bytes, at) { const kind = read8(bytes, at); const end = boundedEnd(bytes, at, read16(bytes, at), "instance route"); skipRid(bytes, at); nonzero64(bytes, at, "node generation"); readText8(bytes, at); if (kind === 1) {
+    nonzero64(bytes, at, "object generation");
+    readText8(bytes, at);
+    nonzero64(bytes, at, "authority generation");
+    nonzero64(bytes, at, "lease generation");
+    readText16(bytes, at, 1, 4096, "store version");
+}
+else if (kind === 2) {
+    readText8(bytes, at);
+    readText8(bytes, at);
+    readText8(bytes, at);
+    nonzero64(bytes, at, "deadline");
+}
+else
+    throw new RangeError("instance route kind"); exactEnd(at, end, "instance route"); }
+function skipFrozenSource(bytes, at) { const kind = read8(bytes, at); const end = boundedEnd(bytes, at, read16(bytes, at), "frozen source"); skipRid(bytes, at); nonzero64(bytes, at, "source node generation"); readText8(bytes, at); nonzero64(bytes, at, "source owner lease"); if (kind === 2)
+    readText8(bytes, at);
+else if (kind === 3 || kind === 4) {
+    readText8(bytes, at);
+    nonzero64(bytes, at, "source actor generation");
+    if (kind === 4) {
+        skipRid(bytes, at);
+        nonzero64(bytes, at, "binding generation");
+        nonzero64(bytes, at, "session sequence");
+    }
+}
+else if (kind !== 1)
+    throw new RangeError("source kind"); exactEnd(at, end, "frozen source"); }
+function skipMetadata(bytes, at) { const start = at.value; if (read8(bytes, at) !== 1)
+    throw new RangeError("metadata version"); const count = read8(bytes, at); const keys = []; for (let i = 0; i < count; i++) {
+    keys.push(readText8(bytes, at));
+    readText16(bytes, at, 0, 1024, "metadata value");
+} if (at.value - start > 1024 || new Set(keys).size !== keys.length)
+    throw new RangeError("metadata"); }
+function skipFrozenBody(bytes, at, kind) { if (kind === 1 || kind === 2)
+    skipPayload(bytes, at);
+else if (kind === 3 || kind === 4) {
+    readText8(bytes, at);
+    skipPayload(bytes, at);
+}
+else if (kind === 5 || kind === 6) {
+    skipFence(bytes, at);
+    skipPayload(bytes, at);
+}
+else if (kind === 7) {
+    readText8(bytes, at);
+    readText8(bytes, at);
+    skipPayload(bytes, at);
+}
+else if (kind === 8)
+    skipActorControl(bytes, at);
+else if (kind === 9 || kind === 10) {
+    skipFence(bytes, at);
+    skipPayload(bytes, at);
+}
+else if (kind === 11) {
+    read32(bytes, at);
+    read32(bytes, at);
+    const has = read8(bytes, at);
+    if (has === 1)
+        skipPayload(bytes, at);
+    else if (has !== 0)
+        throw new RangeError("completion payload");
+}
+else if (kind === 12)
+    skipSendReady(bytes, at);
+else if (kind === 13)
+    skipRelocationControl(bytes, at);
+else if (kind === 14) {
+    skipInstanceRoute(bytes, at);
+    nonzero64(bytes, at, "source node generation");
+    if (![1, 2].includes(read8(bytes, at)))
+        throw new RangeError("instance operation");
+    skipPayload(bytes, at);
+}
+else
+    throw new RangeError("record kind"); }
+function skipFrozenRecord(bytes, at) { const kind = read8(bytes, at); if (kind < 1 || kind > 14)
+    throw new RangeError("record kind"); skipFrozenSource(bytes, at); const hasMetadata = read8(bytes, at); if (hasMetadata === 1)
+    skipMetadata(bytes, at);
+else if (hasMetadata !== 0)
+    throw new RangeError("metadata flag"); read64(bytes, at); read64(bytes, at); const operationKind = read32(bytes, at); if (operationKind > 15)
+    throw new RangeError("operation kind"); const replyEnd = boundedEnd(bytes, at, read16(bytes, at), "reply route"); if ([1, 2, 3, 4, 12].includes(operationKind))
+    nonzero64(bytes, at, "reply route"); exactEnd(at, replyEnd, "reply route"); skipFrozenBody(bytes, at, kind); }
+function compareUtf8(a, b) { const x = text.encode(a), y = text.encode(b), n = Math.min(x.length, y.length); for (let i = 0; i < n; i++)
+    if (x[i] !== y[i])
+        return x[i] - y[i]; return x.length - y.length; }
+function writeRelocationObject(out, value) { const kind = value.objectKind === "actor" ? 1 : value.objectKind === "userSpot" ? 2 : 3; out.push(kind); body16(out, b => { if (value.objectKind === "actor") {
+    text8(b, value.actorId);
+    if (value.objectGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n)
+        throw new RangeError("object");
+    u64(b, value.objectGeneration);
+    u64(b, value.expectedAuthorityOwnerGeneration);
+}
+else if (value.objectKind === "userSpot") {
+    text8(b, value.spotId);
+    if (value.objectGeneration === 0n || value.expectedAuthorityOwnerGeneration === 0n)
+        throw new RangeError("object");
+    u64(b, value.objectGeneration);
+    u64(b, value.expectedAuthorityOwnerGeneration);
+}
+else {
+    text8(b, value.instanceType);
+    text8(b, value.spotId);
+    if (value.objectGeneration === 0n)
+        throw new RangeError("object");
+    u64(b, value.objectGeneration);
+} }); }
+function readRelocationObject(bytes, at) { const kind = read8(bytes, at), end = boundedEnd(bytes, at, read16(bytes, at), "relocation object"); let value; if (kind === 1)
+    value = { objectKind: "actor", actorId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "object generation"), expectedAuthorityOwnerGeneration: nonzero64(bytes, at, "authority generation") };
+else if (kind === 2)
+    value = { objectKind: "userSpot", spotId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "object generation"), expectedAuthorityOwnerGeneration: nonzero64(bytes, at, "authority generation") };
+else if (kind === 3)
+    value = { objectKind: "instanceSpot", instanceType: readText8(bytes, at), spotId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "object generation") };
+else
+    throw new RangeError("object kind"); exactEnd(at, end, "relocation object"); return value; }
+function encodeRelocationEnvelopeV1(value) { const out = []; if (value.relocationHigh === 0n && value.relocationLow === 0n)
+    throw new RangeError("relocation"); u64(out, value.relocationHigh); u64(out, value.relocationLow); writeRelocationObject(out, value.object); if (value.applicationVersion < 0n || value.applicationVersion > 9223372036854775807n)
+    throw new RangeError("application version"); u64(out, value.applicationVersion); sorted(value.applicationStates, (a, b) => a.participantId < b.participantId ? -1 : a.participantId > b.participantId ? 1 : 0, "applicationStates"); if (value.applicationStates.length === 0)
+    throw new RangeError("applicationStates"); u32(out, value.applicationStates.length); for (const s of value.applicationStates) {
+    if (s.participantId === 0n)
+        throw new RangeError("participant");
+    u64(out, s.participantId);
+    out.push(s.hasState ? 1 : 0);
+    body64(out, b => { if (s.hasState)
+        bytes64(b, s.payload);
+    else if (s.payload.length !== 0)
+        throw new RangeError("absent state payload"); });
+} sorted(value.savedWork, (a, b) => a.participantId === b.participantId ? (a.order < b.order ? -1 : a.order > b.order ? 1 : 0) : (a.participantId < b.participantId ? -1 : 1), "savedWork"); u32(out, value.savedWork.length); for (const w of value.savedWork) {
+    if (w.participantId === 0n || w.order === 0n)
+        throw new RangeError("saved work");
+    const at = { value: 0 };
+    skipFrozenRecord(w.frozenRecord, at);
+    exactEnd(at, w.frozenRecord.length, "frozen record");
+    u64(out, w.participantId);
+    u64(out, w.order);
+    out.push(...w.frozenRecord);
+} sorted(value.timerRegistrations, (a, b) => a.participantId === b.participantId ? compareUtf8(a.name, b.name) : a.participantId < b.participantId ? -1 : 1, "timerRegistrations"); u32(out, value.timerRegistrations.length); for (const t of value.timerRegistrations) {
+    if (t.participantId === 0n || t.periodMilliseconds === 0n || t.maxCatchUpTicks === 0n || t.overrunPolicy < 1 || t.overrunPolicy > 3)
+        throw new RangeError("timer");
+    u64(out, t.participantId);
+    text8(out, t.name);
+    text8(out, t.handlerType);
+    u64(out, t.periodMilliseconds);
+    out.push(t.overrunPolicy);
+    u64(out, t.maxCatchUpTicks);
+    out.push(t.stopOnUnhandledException ? 1 : 0);
+    u64(out, t.lastCompletedDeliveryIndex);
+    u64(out, t.lastCompletedScheduledIndex);
+    u64(out, t.nextScheduledAtUnixMilliseconds);
+} sorted(value.pendingTimerTicks, (a, b) => a.participantId === b.participantId ? (a.order < b.order ? -1 : a.order > b.order ? 1 : 0) : (a.participantId < b.participantId ? -1 : 1), "pendingTimerTicks"); u32(out, value.pendingTimerTicks.length); for (const p of value.pendingTimerTicks) {
+    if (p.participantId === 0n || p.order === 0n || p.deliveryIndex === 0n || p.scheduledIndex === 0n)
+        throw new RangeError("pending timer");
+    u64(out, p.participantId);
+    u64(out, p.order);
+    text8(out, p.timerName);
+    u64(out, p.deliveryIndex);
+    u64(out, p.scheduledIndex);
+    u64(out, p.scheduledAtUnixMilliseconds);
+    u64(out, p.skippedTicks);
+} if (out.length > 274877906944)
+    throw new RangeError("relocation logical bytes"); return Uint8Array.from(out); }
+function decodeRelocationEnvelopeV1(chunks) { const n = chunks.reduce((s, c) => s + c.length, 0); if (n > 274877906944)
+    throw new RangeError("relocation logical bytes"); const bytes = new Uint8Array(n); let offset = 0; for (const c of chunks) {
+    bytes.set(c, offset);
+    offset += c.length;
+} const at = { value: 0 }, relocationHigh = read64(bytes, at), relocationLow = read64(bytes, at); if (relocationHigh === 0n && relocationLow === 0n)
+    throw new RangeError("relocation"); const object = readRelocationObject(bytes, at), applicationVersion = read64(bytes, at); if (applicationVersion > 9223372036854775807n)
+    throw new RangeError("application version"); const applicationStates = []; const stateCount = read32(bytes, at); if (stateCount === 0)
+    throw new RangeError("applicationStates"); for (let i = 0, count = stateCount; i < count; i++) {
+    const participantId = nonzero64(bytes, at, "participant"), has = read8(bytes, at), end = boundedEnd(bytes, at, Number(read64(bytes, at)), "application state");
+    if (has > 1)
+        throw new RangeError("application state");
+    let payload = new Uint8Array();
+    if (has === 1)
+        payload = take(bytes, at, Number(read64(bytes, at)), "state payload");
+    exactEnd(at, end, "application state");
+    applicationStates.push({ participantId, hasState: has === 1, payload });
+} const participants = new Set(applicationStates.map((s) => s.participantId)); const savedWork = []; for (let i = 0, count = read32(bytes, at); i < count; i++) {
+    const participantId = nonzero64(bytes, at, "participant");
+    if (!participants.has(participantId))
+        throw new RangeError("saved work participant");
+    const order = nonzero64(bytes, at, "order"), start = at.value;
+    skipFrozenRecord(bytes, at);
+    savedWork.push({ participantId, order, frozenRecord: bytes.slice(start, at.value) });
+} const timerRegistrations = [], registeredTimerNames = new Map(); for (let i = 0, count = read32(bytes, at); i < count; i++) {
+    const participantId = nonzero64(bytes, at, "participant");
+    if (!participants.has(participantId))
+        throw new RangeError("timer participant");
+    const name = readText8(bytes, at), handlerType = readText8(bytes, at), periodMilliseconds = nonzero64(bytes, at, "period"), overrunPolicy = read8(bytes, at);
+    if (overrunPolicy < 1 || overrunPolicy > 3)
+        throw new RangeError("overrun policy");
+    const maxCatchUpTicks = nonzero64(bytes, at, "catch-up"), stop = read8(bytes, at);
+    if (stop > 1)
+        throw new RangeError("stop flag");
+    let names = registeredTimerNames.get(participantId);
+    if (names === undefined) {
+        names = new Set();
+        registeredTimerNames.set(participantId, names);
+    }
+    names.add(name);
+    timerRegistrations.push({ participantId, name, handlerType, periodMilliseconds, overrunPolicy: overrunPolicy, maxCatchUpTicks, stopOnUnhandledException: stop === 1, lastCompletedDeliveryIndex: read64(bytes, at), lastCompletedScheduledIndex: read64(bytes, at), nextScheduledAtUnixMilliseconds: read64(bytes, at) });
+} const pendingTimerTicks = []; for (let i = 0, count = read32(bytes, at); i < count; i++) {
+    const participantId = nonzero64(bytes, at, "participant");
+    if (!participants.has(participantId))
+        throw new RangeError("pending timer participant");
+    const order = nonzero64(bytes, at, "order"), timerName = readText8(bytes, at);
+    if (registeredTimerNames.get(participantId)?.has(timerName) !== true)
+        throw new RangeError("pending timer registration");
+    pendingTimerTicks.push({ participantId, order, timerName, deliveryIndex: nonzero64(bytes, at, "delivery"), scheduledIndex: nonzero64(bytes, at, "scheduled"), scheduledAtUnixMilliseconds: read64(bytes, at), skippedTicks: read64(bytes, at) });
+} exactEnd(at, bytes.length, "relocation envelope"); sorted(applicationStates, (a, b) => a.participantId < b.participantId ? -1 : a.participantId > b.participantId ? 1 : 0, "applicationStates"); sorted(savedWork, (a, b) => a.participantId === b.participantId ? (a.order < b.order ? -1 : a.order > b.order ? 1 : 0) : (a.participantId < b.participantId ? -1 : 1), "savedWork"); sorted(timerRegistrations, (a, b) => a.participantId === b.participantId ? compareUtf8(a.name, b.name) : a.participantId < b.participantId ? -1 : 1, "timerRegistrations"); sorted(pendingTimerTicks, (a, b) => a.participantId === b.participantId ? (a.order < b.order ? -1 : a.order > b.order ? 1 : 0) : (a.participantId < b.participantId ? -1 : 1), "pendingTimerTicks"); return { relocationHigh, relocationLow, object, applicationVersion, applicationStates, savedWork, timerRegistrations, pendingTimerTicks }; }
+function crc32c(bytes) { let crc = 0xffffffff; for (const octet of bytes) {
+    crc ^= octet;
+    for (let bit = 0; bit < 8; bit++)
+        crc = (crc >>> 1) ^ ((crc & 1) !== 0 ? 0x82f63b78 : 0);
+} return (~crc) >>> 0; }
+function encodeDurable(magic, body, maximum) { const out = [...magic, 1, 0, 0]; u32(out, body.length); out.push(...body); if (out.length + 4 > maximum)
+    throw new RangeError("durable format bytes"); u32(out, crc32c(Uint8Array.from(out))); return Uint8Array.from(out); }
+function decodeDurable(bytes, magic, maximum) { if (bytes.length > maximum || bytes.length < 15 || magic.some((v, i) => bytes[i] !== v) || bytes[4] !== 1 || bytes[5] !== 0 || bytes[6] !== 0)
+    throw new RangeError("durable header"); const at = { value: 7 }, length = read32(bytes, at), end = boundedEnd(bytes, at, length, "durable body"); if (end + 4 !== bytes.length)
+    throw new RangeError("durable length"); const body = bytes.slice(at.value, end); at.value = end; const expected = read32(bytes, at); if (crc32c(bytes.slice(0, end)) !== expected)
+    throw new RangeError("durable checksum"); return body; }
+function encodeRelocationDataChunkV1(value) { const body = []; u32(body, value.order); if (value.data.length > 67108864)
+    throw new RangeError("chunk data"); u32(body, value.data.length); body.push(...value.data); return encodeDurable([90, 76, 84, 67], body, 67108886); }
+function decodeRelocationDataChunkV1(bytes) { const body = decodeDurable(bytes, [90, 76, 84, 67], 67108886), at = { value: 0 }, order = read32(body, at), data = take(body, at, read32(body, at), "chunk data"); exactEnd(at, body.length, "chunk"); return { order, data }; }
+function encodeRelocationManifestV1(value) { if (Number(value.logicalFormatVersion) !== 1 || value.totalLength > 274877906944n || value.inventoryDigestSha256.length !== 32 || value.chunks.length > 4096)
+    throw new RangeError("manifest"); sorted(value.chunks, (a, b) => a.order - b.order, "manifest chunks"); const body = [1]; u64(body, value.totalLength); u32(body, value.totalChecksumCrc32c); body.push(32, ...value.inventoryDigestSha256); u32(body, value.chunks.length); for (const chunk of value.chunks) {
+    if (chunk.length === 0n)
+        throw new RangeError("chunk length");
+    u32(body, chunk.order);
+    writeText16(body, chunk.reference, 1, 4096, "chunk reference");
+    u64(body, chunk.length);
+    u32(body, chunk.checksumCrc32c);
+} return encodeDurable([90, 76, 84, 77], body, 33554432); }
+function decodeRelocationManifestV1(bytes) { const body = decodeDurable(bytes, [90, 76, 84, 77], 33554432), at = { value: 0 }; if (read8(body, at) !== 1)
+    throw new RangeError("logical format version"); const totalLength = read64(body, at); if (totalLength > 274877906944n)
+    throw new RangeError("logical length"); const totalChecksumCrc32c = read32(body, at), digestLength = read8(body, at); if (digestLength !== 32)
+    throw new RangeError("inventory digest minimumBytes"); const inventoryDigestSha256 = take(body, at, digestLength, "inventory digest"), count = read32(body, at); if (count > 4096)
+    throw new RangeError("chunk count"); const chunks = []; for (let i = 0; i < count; i++)
+    chunks.push({ order: read32(body, at), reference: readText16(body, at, 1, 4096, "chunk reference"), length: nonzero64(body, at, "chunk length"), checksumCrc32c: read32(body, at) }); exactEnd(at, body.length, "manifest"); sorted(chunks, (a, b) => a.order - b.order, "manifest chunks"); return { logicalFormatVersion: 1, totalLength, totalChecksumCrc32c, inventoryDigestSha256, chunks }; }
+function encodeLivenessProbe5(value) { const out = [90, 77, 1, 5, 0]; if (value.probeId === 0n)
+    throw new RangeError("probeId"); u64(out, value.probeId); return Uint8Array.from(out); }
+function decodeLivenessProbe5(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 5 || bytes[at.value++] !== 0)
+    throw new RangeError("livenessProbe header"); const probeId = read64(bytes, at); if (probeId === 0n)
+    throw new RangeError("probeId"); if (at.value !== bytes.length)
+    throw new RangeError("livenessProbe trailing"); return { probeId }; }
+function encodeLivenessAck6(value) { const out = [90, 77, 1, 6, 0]; if (value.probeId === 0n)
+    throw new RangeError("probeId"); u64(out, value.probeId); return Uint8Array.from(out); }
+function decodeLivenessAck6(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 6 || bytes[at.value++] !== 0)
+    throw new RangeError("livenessAck header"); const probeId = read64(bytes, at); if (probeId === 0n)
+    throw new RangeError("probeId"); if (at.value !== bytes.length)
+    throw new RangeError("livenessAck trailing"); return { probeId }; }
+function encodeNodeSend16() { const out = [90, 77, 1, 16, 0]; return Uint8Array.from(out); }
+function decodeNodeSend16(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 16 || bytes[at.value++] !== 0)
+    throw new RangeError("nodeSend header"); if (at.value !== bytes.length)
+    throw new RangeError("nodeSend trailing"); return undefined; }
+function encodeNodeRequest17(value) { const out = [90, 77, 1, 17, 0]; if (value.correlation === 0n)
+    throw new RangeError("correlation"); u64(out, value.correlation); return Uint8Array.from(out); }
+function decodeNodeRequest17(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 17 || bytes[at.value++] !== 0)
+    throw new RangeError("nodeRequest header"); const correlation = read64(bytes, at); if (correlation === 0n)
+    throw new RangeError("correlation"); if (at.value !== bytes.length)
+    throw new RangeError("nodeRequest trailing"); return { correlation }; }
+function encodeChannelSend18(value) { const out = [90, 77, 1, 18, 0]; text8(out, value.channelName); return Uint8Array.from(out); }
+function decodeChannelSend18(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 18 || bytes[at.value++] !== 0)
+    throw new RangeError("channelSend header"); const channelName = readText8(bytes, at); if (at.value !== bytes.length)
+    throw new RangeError("channelSend trailing"); return { channelName }; }
+function encodeChannelRequest19(value) { const out = [90, 77, 1, 19, 0]; if (value.correlation === 0n)
+    throw new RangeError("correlation"); u64(out, value.correlation); text8(out, value.channelName); return Uint8Array.from(out); }
+function decodeChannelRequest19(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 19 || bytes[at.value++] !== 0)
+    throw new RangeError("channelRequest header"); const correlation = read64(bytes, at); if (correlation === 0n)
+    throw new RangeError("correlation"); const channelName = readText8(bytes, at); if (at.value !== bytes.length)
+    throw new RangeError("channelRequest trailing"); return { correlation, channelName }; }
+function encodeLogicalMulticast23(value) { const out = [90, 77, 1, 23, 0]; text8(out, value.channelName); text8(out, value.topic); text8(out, value.sourceSpotId); return Uint8Array.from(out); }
+function decodeLogicalMulticast23(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 23 || bytes[at.value++] !== 0)
+    throw new RangeError("logicalMulticast header"); const channelName = readText8(bytes, at); const topic = readText8(bytes, at); const sourceSpotId = readText8(bytes, at); if (at.value !== bytes.length)
+    throw new RangeError("logicalMulticast trailing"); return { channelName, topic, sourceSpotId }; }
+function encodeActorLookup26(value) { const out = [90, 77, 1, 26, 0]; if (value.correlation === 0n)
+    throw new RangeError("correlation"); u64(out, value.correlation); text8(out, value.actorId); return Uint8Array.from(out); }
+function decodeActorLookup26(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 26 || bytes[at.value++] !== 0)
+    throw new RangeError("actorLookup header"); const correlation = read64(bytes, at); if (correlation === 0n)
+    throw new RangeError("correlation"); const actorId = readText8(bytes, at); if (at.value !== bytes.length)
+    throw new RangeError("actorLookup trailing"); return { correlation, actorId }; }
+function encodeActorDestroy27(value) { const out = [90, 77, 1, 27, 0]; if (value.correlation === 0n)
+    throw new RangeError("correlation"); u64(out, value.correlation); fence(out, value.actor); return Uint8Array.from(out); }
+function decodeActorDestroy27(bytes) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== 27 || bytes[at.value++] !== 0)
+    throw new RangeError("actorDestroy header"); const correlation = read64(bytes, at); if (correlation === 0n)
+    throw new RangeError("correlation"); const actor = readFence(bytes, at); if (at.value !== bytes.length)
+    throw new RangeError("actorDestroy trailing"); return { correlation, actor }; }
+function b3Header(id) { return [90, 77, 1, id, 0]; }
+function b3ReadHeader(bytes, id, name) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== id || bytes[at.value++] !== 0)
+    throw new RangeError(name + " header"); return at; }
+function b3WriteId(out, v, name) { if (v.high === 0n && v.low === 0n)
+    throw new RangeError(name); u64(out, v.high); u64(out, v.low); }
+function b3ReadId(bytes, at, name) { const high = read64(bytes, at), low = read64(bytes, at); if (high === 0n && low === 0n)
+    throw new RangeError(name); return { high, low }; }
+function b3WriteCoordinator(out, v) { text8(out, v.coordinatorOwnerId); if (v.coordinatorLeaseGeneration === 0n || v.coordinatorNodeGeneration === 0n)
+    throw new RangeError("coordinator"); u64(out, v.coordinatorLeaseGeneration); rid(out, v.coordinatorNodeRid); u64(out, v.coordinatorNodeGeneration); writeText16(out, v.expectedAuthorityStoreVersion, 1, 4096, "store version"); }
+function b3ReadCoordinator(bytes, at) { return { coordinatorOwnerId: readText8(bytes, at), coordinatorLeaseGeneration: nonzero64(bytes, at, "coordinator lease"), coordinatorNodeRid: readRid(bytes, at), coordinatorNodeGeneration: nonzero64(bytes, at, "coordinator node"), expectedAuthorityStoreVersion: readText16(bytes, at, 1, 4096, "store version") }; }
+function b3WriteTarget(out, v) { rid(out, v.targetNodeRid); if (v.targetNodeGeneration === 0n || v.targetOwnerLeaseGeneration === 0n)
+    throw new RangeError("target"); u64(out, v.targetNodeGeneration); text8(out, v.targetOwnerId); u64(out, v.targetOwnerLeaseGeneration); }
+function b3ReadTarget(bytes, at) { return { targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node"), targetOwnerId: readText8(bytes, at), targetOwnerLeaseGeneration: nonzero64(bytes, at, "target lease") }; }
+function b3WriteRole(out, v) { out.push({ source: 1, target: 2, coordinator: 3 }[v]); }
+function b3ReadRole(bytes, at) { const v = read8(bytes, at); if (v < 1 || v > 3)
+    throw new RangeError("role"); return v === 1 ? "source" : v === 2 ? "target" : "coordinator"; }
+function b3WriteActorRef(out, v) { text8(out, v.actorId); if (v.objectGeneration === 0n)
+    throw new RangeError("actor generation"); u64(out, v.objectGeneration); }
+function b3ReadActorRef(bytes, at) { return { actorId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "actor generation") }; }
+function b3WriteRequestSource(out, v) { text8(out, v.sourceOwnerId); if (v.sourceOwnerLeaseGeneration === 0n || v.sourceNodeGeneration === 0n)
+    throw new RangeError("request source"); u64(out, v.sourceOwnerLeaseGeneration); rid(out, v.sourceNodeRid); u64(out, v.sourceNodeGeneration); }
+function b3ReadRequestSource(bytes, at) { return { sourceOwnerId: readText8(bytes, at), sourceOwnerLeaseGeneration: nonzero64(bytes, at, "source lease"), sourceNodeRid: readRid(bytes, at), sourceNodeGeneration: nonzero64(bytes, at, "source node") }; }
+function b3WriteAuthority(out, v) { if (v.objectGeneration === 0n || v.authorityOwnerGeneration === 0n || v.leaseGeneration === 0n)
+    throw new RangeError("authority"); u64(out, v.objectGeneration); text8(out, v.ownerId); u64(out, v.authorityOwnerGeneration); u64(out, v.leaseGeneration); writeText16(out, v.storeVersion, 1, 4096, "store version"); }
+function b3ReadAuthority(bytes, at) { return { objectGeneration: nonzero64(bytes, at, "object generation"), ownerId: readText8(bytes, at), authorityOwnerGeneration: nonzero64(bytes, at, "authority generation"), leaseGeneration: nonzero64(bytes, at, "lease generation"), storeVersion: readText16(bytes, at, 1, 4096, "store version") }; }
+function b3WriteContext(out, v) { out.push(v.contextKind === "coldActivation" ? 1 : 2); body16(out, b => { if (v.contextKind === "coldActivation") {
+    b.push(v.completionKind === "readyBarrier" ? 1 : 2);
+    body16(b, x => b3WriteAuthority(x, v.authority));
+}
+else {
+    b3WriteId(b, v.relocation, "relocation");
+    if (v.targetAttemptGeneration === 0n || v.participantId === 0n || v.sequence === 0n)
+        throw new RangeError("reply context");
+    u64(b, v.targetAttemptGeneration);
+    b3WriteCoordinator(b, v.coordinator);
+    u64(b, v.participantId);
+    u64(b, v.sequence);
+} }); }
+function b3ReadContext(bytes, at) { const kind = read8(bytes, at), end = boundedEnd(bytes, at, read16(bytes, at), "reply context"); let value; if (kind === 1) {
+    const completion = read8(bytes, at), inner = boundedEnd(bytes, at, read16(bytes, at), "cold activation");
+    if (completion < 1 || completion > 2)
+        throw new RangeError("completion kind");
+    const authority = b3ReadAuthority(bytes, at);
+    exactEnd(at, inner, "cold activation");
+    value = { contextKind: "coldActivation", completionKind: completion === 1 ? "readyBarrier" : "activationFailure", authority };
+}
+else if (kind === 2)
+    value = { contextKind: "maintenanceRelocation", relocation: b3ReadId(bytes, at, "relocation"), targetAttemptGeneration: nonzero64(bytes, at, "target attempt"), coordinator: b3ReadCoordinator(bytes, at), participantId: nonzero64(bytes, at, "participant"), sequence: nonzero64(bytes, at, "sequence") };
+else
+    throw new RangeError("reply context kind"); exactEnd(at, end, "reply context"); return value; }
+const b3FailureResults = new Map([[1, 102], [2, 105], [3, 107], [4, 107], [5, 105], [6, 102], [7, 107], [8, 102], [9, 102], [10, 102], [11, 102], [12, 104], [13, 105], [14, 102], [15, 106], [16, 104], [17, 105], [18, 106], [19, 105], [20, 105], [21, 107], [22, 106], [33, 107], [34, 107], [35, 105]]);
+function b3ValidTerminal(result, failure, payload) { const boundary = [101, 103, 108, 109, 110, 111, 112, 113]; if (result === 0) {
+    if (failure !== 0)
+        throw new RangeError("terminal failure");
+    return;
+} if (payload)
+    throw new RangeError("failure payload"); if (boundary.includes(result)) {
+    if (failure !== 0)
+        throw new RangeError("boundary failure");
+    return;
+} if (b3FailureResults.get(failure) !== result)
+    throw new RangeError("typed failure"); }
+function b3WriteRoute(out, v) { out.push(v.action === "commit" ? 1 : 2); body16(out, b => { if (v.action === "commit") {
+    if (v.previousAuthorityOwnerGeneration === 0n || v.targetAuthorityOwnerGeneration === 0n || v.targetNodeGeneration === 0n)
+        throw new RangeError("route commit");
+    u64(b, v.previousAuthorityOwnerGeneration);
+    u64(b, v.targetAuthorityOwnerGeneration);
+    rid(b, v.targetNodeRid);
+    u64(b, v.targetNodeGeneration);
+}
+else {
+    if (v.currentAuthorityOwnerGeneration === 0n)
+        throw new RangeError("route abort");
+    u64(b, v.currentAuthorityOwnerGeneration);
+} }); }
+function b3ReadRoute(bytes, at) { const action = read8(bytes, at), end = boundedEnd(bytes, at, read16(bytes, at), "session route"); let value; if (action === 1)
+    value = { action: "commit", previousAuthorityOwnerGeneration: nonzero64(bytes, at, "previous authority"), targetAuthorityOwnerGeneration: nonzero64(bytes, at, "target authority"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node") };
+else if (action === 2)
+    value = { action: "abort", currentAuthorityOwnerGeneration: nonzero64(bytes, at, "current authority") };
+else
+    throw new RangeError("route action"); exactEnd(at, end, "session route"); return value; }
+function b3WriteSession(out, v) { rid(out, v.sessionOwnerNodeRid); if (v.sessionOwnerNodeGeneration === 0n || v.sessionOwnerLeaseGeneration === 0n || v.bindingGeneration === 0n)
+    throw new RangeError("session"); u64(out, v.sessionOwnerNodeGeneration); text8(out, v.sessionOwnerId); u64(out, v.sessionOwnerLeaseGeneration); rid(out, v.sessionRid); u64(out, v.bindingGeneration); }
+function b3ReadSession(bytes, at) { return { sessionOwnerNodeRid: readRid(bytes, at), sessionOwnerNodeGeneration: nonzero64(bytes, at, "session owner node"), sessionOwnerId: readText8(bytes, at), sessionOwnerLeaseGeneration: nonzero64(bytes, at, "session owner lease"), sessionRid: readRid(bytes, at), bindingGeneration: nonzero64(bytes, at, "binding generation") }; }
+function b3Finish(at, bytes, name) { exactEnd(at, bytes.length, name); }
+function encodeReplyRelay33(v) { const o = b3Header(33); b3WriteId(o, v.operation, "operation"); if (v.replyRouteId === 0n)
+    throw new RangeError("reply route"); u64(o, v.replyRouteId); b3WriteContext(o, v.context); b3ValidTerminal(v.terminalResult, v.failureCode, v.payload !== undefined); if (v.context.contextKind === "coldActivation" && v.context.completionKind === "activationFailure" && v.terminalResult === 0)
+    throw new RangeError("activation failure terminal"); u32(o, v.terminalResult); u32(o, v.failureCode); return v.payload === undefined ? [Uint8Array.from(o)] : [Uint8Array.from(o), encodePayload(v.payload)]; }
+function decodeReplyRelay33(frames) { if (frames.length < 1 || frames.length > 2)
+    throw new RangeError("replyRelay frames"); const bytes = frames[0], at = b3ReadHeader(bytes, 33, "replyRelay"), operation = b3ReadId(bytes, at, "operation"), replyRouteId = nonzero64(bytes, at, "reply route"), context = b3ReadContext(bytes, at), terminalResult = read32(bytes, at), failureCode = read32(bytes, at); b3Finish(at, bytes, "replyRelay"); const payload = frames.length === 2 ? decodePayload(frames[1]) : undefined; b3ValidTerminal(terminalResult, failureCode, payload !== undefined); if (context.contextKind === "coldActivation" && context.completionKind === "activationFailure" && terminalResult === 0)
+    throw new RangeError("activation failure terminal"); return payload === undefined ? { operation, replyRouteId, context, terminalResult, failureCode } : { operation, replyRouteId, context, terminalResult, failureCode, payload }; }
+function encodeReplyRelayAck46(v) { const o = b3Header(46); b3WriteId(o, v.relocation, "relocation"); b3WriteCoordinator(o, v.coordinator); b3WriteId(o, v.operation, "operation"); if (v.replyRouteId === 0n)
+    throw new RangeError("reply route"); u64(o, v.replyRouteId); b3WriteRequestSource(o, v.requestSource); o.push(v.status === "terminalReceived" ? 1 : 2); return Uint8Array.from(o); }
+function decodeReplyRelayAck46(bytes) { const at = b3ReadHeader(bytes, 46, "replyRelayAck"), relocation = b3ReadId(bytes, at, "relocation"), coordinator = b3ReadCoordinator(bytes, at), operation = b3ReadId(bytes, at, "operation"), replyRouteId = nonzero64(bytes, at, "reply route"), requestSource = b3ReadRequestSource(bytes, at), status = read8(bytes, at); if (status < 1 || status > 2)
+    throw new RangeError("ack status"); b3Finish(at, bytes, "replyRelayAck"); return { relocation, coordinator, operation, replyRouteId, requestSource, status: status === 1 ? "terminalReceived" : "alreadyTerminal" }; }
+function b3WriteReadyBase(o, v) { b3WriteId(o, v.relocation, "relocation"); if (v.targetAttemptGeneration === 0n)
+    throw new RangeError("target attempt"); u64(o, v.targetAttemptGeneration); b3WriteCoordinator(o, v.coordinator); b3WriteTarget(o, v.target); writeRelocationObject(o, v.object); b3WriteRole(o, v.senderRole); if (v.senderRole !== "target")
+    throw new RangeError("sender role"); }
+function b3ReadReadyBase(bytes, at) { const relocation = b3ReadId(bytes, at, "relocation"), targetAttemptGeneration = nonzero64(bytes, at, "target attempt"), coordinator = b3ReadCoordinator(bytes, at), target = b3ReadTarget(bytes, at), object = readRelocationObject(bytes, at), senderRole = b3ReadRole(bytes, at); if (senderRole !== "target")
+    throw new RangeError("sender role"); return { relocation, targetAttemptGeneration, coordinator, target, object, senderRole }; }
+function encodeRelocationReady30(v) { const o = b3Header(30); b3WriteReadyBase(o, v); return Uint8Array.from(o); }
+function decodeRelocationReady30(bytes) { const at = b3ReadHeader(bytes, 30, "relocationReady"), v = b3ReadReadyBase(bytes, at); b3Finish(at, bytes, "relocationReady"); return v; }
+function encodeRelocationFailed53(v) { const o = b3Header(53); b3WriteReadyBase(o, v); if (!b3FailureResults.has(v.failureCode))
+    throw new RangeError("failure code"); u32(o, v.failureCode); return Uint8Array.from(o); }
+function decodeRelocationFailed53(bytes) { const at = b3ReadHeader(bytes, 53, "relocationFailed"), v = b3ReadReadyBase(bytes, at), failureCode = read32(bytes, at); if (!b3FailureResults.has(failureCode))
+    throw new RangeError("failure code"); b3Finish(at, bytes, "relocationFailed"); return { ...v, failureCode }; }
+function b3WriteSourceBase(o, v) { b3WriteId(o, v.relocation, "relocation"); if (v.targetAttemptGeneration === 0n)
+    throw new RangeError("target attempt"); u64(o, v.targetAttemptGeneration); b3WriteCoordinator(o, v.coordinator); b3WriteRole(o, v.senderRole); if (v.senderRole !== "source")
+    throw new RangeError("sender role"); writeRelocationObject(o, v.object); }
+function b3ReadSourceBase(bytes, at) { const relocation = b3ReadId(bytes, at, "relocation"), targetAttemptGeneration = nonzero64(bytes, at, "target attempt"), coordinator = b3ReadCoordinator(bytes, at), senderRole = b3ReadRole(bytes, at); if (senderRole !== "source")
+    throw new RangeError("sender role"); return { relocation, targetAttemptGeneration, coordinator, senderRole, object: readRelocationObject(bytes, at) }; }
+function encodeRelocationData31(v) { const o = b3Header(31); b3WriteSourceBase(o, v); const at = { value: 0 }; skipFrozenRecord(v.record, at); exactEnd(at, v.record.length, "frozen record"); o.push(...v.record); return Uint8Array.from(o); }
+function decodeRelocationData31(bytes) { const at = b3ReadHeader(bytes, 31, "relocationData"), v = b3ReadSourceBase(bytes, at), start = at.value; skipFrozenRecord(bytes, at); const record = bytes.slice(start, at.value); b3Finish(at, bytes, "relocationData"); return { ...v, record }; }
+function encodeRelocationCutover34(v) { const o = b3Header(34); b3WriteSourceBase(o, v); if (v.boundaryRecordCount < 0n || v.boundaryRecordCount > 9223372036854775807n)
+    throw new RangeError("boundary count"); u64(o, v.boundaryRecordCount); u32(o, v.boundaryChecksumCrc32c); return Uint8Array.from(o); }
+function decodeRelocationCutover34(bytes) { const at = b3ReadHeader(bytes, 34, "relocationCutover"), v = b3ReadSourceBase(bytes, at), boundaryRecordCount = read64(bytes, at); if (boundaryRecordCount > 9223372036854775807n)
+    throw new RangeError("boundary count"); const boundaryChecksumCrc32c = read32(bytes, at); b3Finish(at, bytes, "relocationCutover"); return { ...v, boundaryRecordCount, boundaryChecksumCrc32c }; }
+function encodeRelocationState52(v) { const o = b3Header(52); b3WriteSourceBase(o, v); if (v.chunkData.length > 67108864)
+    throw new RangeError("chunk data"); u32(o, v.chunkOrdinal); u32(o, v.chunkData.length); o.push(...v.chunkData); return Uint8Array.from(o); }
+function decodeRelocationState52(bytes) { const at = b3ReadHeader(bytes, 52, "relocationState"), v = b3ReadSourceBase(bytes, at), chunkOrdinal = read32(bytes, at), length = read32(bytes, at); if (length > 67108864)
+    throw new RangeError("chunk data"); const chunkData = take(bytes, at, length, "chunk data"); b3Finish(at, bytes, "relocationState"); return { ...v, chunkOrdinal, chunkData }; }
+function encodeRelocationPrepare40(v) { const o = b3Header(40); b3WriteId(o, v.relocation, "relocation"); if (v.targetAttemptGeneration === 0n || v.sourceNodeGeneration === 0n)
+    throw new RangeError("prepare"); u64(o, v.targetAttemptGeneration); b3WriteCoordinator(o, v.coordinator); b3WriteTarget(o, v.target); b3WriteRole(o, v.initiatorRole); if (v.initiatorRole !== "source")
+    throw new RangeError("initiator role"); writeRelocationObject(o, v.object); rid(o, v.sourceNodeRid); u64(o, v.sourceNodeGeneration); if (v.payloadTotalLength < 0n || v.payloadTotalLength > 274877906944n || v.payloadChunkCount > 4096 || v.applicationVersion < 0n || v.applicationVersion > 9223372036854775807n)
+    throw new RangeError("prepare bounds"); u64(o, v.payloadTotalLength); u32(o, v.payloadChunkCount); u32(o, v.payloadChecksumCrc32c); u64(o, v.applicationVersion); return Uint8Array.from(o); }
+function decodeRelocationPrepare40(bytes) { const at = b3ReadHeader(bytes, 40, "relocationPrepare"), relocation = b3ReadId(bytes, at, "relocation"), targetAttemptGeneration = nonzero64(bytes, at, "target attempt"), coordinator = b3ReadCoordinator(bytes, at), target = b3ReadTarget(bytes, at), initiatorRole = b3ReadRole(bytes, at); if (initiatorRole !== "source")
+    throw new RangeError("initiator role"); const object = readRelocationObject(bytes, at), sourceNodeRid = readRid(bytes, at), sourceNodeGeneration = nonzero64(bytes, at, "source node"), payloadTotalLength = read64(bytes, at), payloadChunkCount = read32(bytes, at), payloadChecksumCrc32c = read32(bytes, at), applicationVersion = read64(bytes, at); if (payloadTotalLength > 274877906944n || payloadChunkCount > 4096 || applicationVersion > 9223372036854775807n)
+    throw new RangeError("prepare bounds"); b3Finish(at, bytes, "relocationPrepare"); return { relocation, targetAttemptGeneration, coordinator, target, initiatorRole, object, sourceNodeRid, sourceNodeGeneration, payloadTotalLength, payloadChunkCount, payloadChecksumCrc32c, applicationVersion }; }
+function b3WriteSealBase(o, v, includeRole) { b3WriteId(o, v.relocation, "relocation"); b3WriteCoordinator(o, v.coordinator); if (includeRole) {
+    const role = v.senderRole;
+    b3WriteRole(o, role);
+    if (role !== "source")
+        throw new RangeError("sender role");
+} fence(o, v.actor); b3WriteSession(o, v); }
+function b3ReadSealBase(bytes, at, includeRole) { const relocation = b3ReadId(bytes, at, "relocation"), coordinator = b3ReadCoordinator(bytes, at); let senderRole; if (includeRole) {
+    senderRole = b3ReadRole(bytes, at);
+    if (senderRole !== "source")
+        throw new RangeError("sender role");
+} const actor = readFence(bytes, at), session = b3ReadSession(bytes, at); return senderRole === undefined ? { relocation, coordinator, actor, ...session } : { relocation, coordinator, senderRole, actor, ...session }; }
+function encodeSessionRelocationSeal42(v) { const o = b3Header(42); b3WriteSealBase(o, v, true); return Uint8Array.from(o); }
+function decodeSessionRelocationSeal42(bytes) { const at = b3ReadHeader(bytes, 42, "sessionRelocationSeal"), v = b3ReadSealBase(bytes, at, true); b3Finish(at, bytes, "sessionRelocationSeal"); return v; }
+function encodeSessionRelocationSealed43(v) { const o = b3Header(43); b3WriteSealBase(o, v, false); return Uint8Array.from(o); }
+function decodeSessionRelocationSealed43(bytes) { const at = b3ReadHeader(bytes, 43, "sessionRelocationSealed"), v = b3ReadSealBase(bytes, at, false); b3Finish(at, bytes, "sessionRelocationSealed"); return v; }
+function encodeSessionRelocationRoute44(v) { const o = b3Header(44); b3WriteId(o, v.relocation, "relocation"); b3WriteCoordinator(o, v.coordinator); b3WriteRole(o, v.senderRole); if ((v.route.action === "commit" && v.senderRole !== "target") || (v.route.action === "abort" && v.senderRole !== "source"))
+    throw new RangeError("route sender"); b3WriteActorRef(o, v.actor); b3WriteSession(o, v); b3WriteRoute(o, v.route); return Uint8Array.from(o); }
+function decodeSessionRelocationRoute44(bytes) { const at = b3ReadHeader(bytes, 44, "sessionRelocationRoute"), relocation = b3ReadId(bytes, at, "relocation"), coordinator = b3ReadCoordinator(bytes, at), senderRole = b3ReadRole(bytes, at), actor = b3ReadActorRef(bytes, at), session = b3ReadSession(bytes, at), route = b3ReadRoute(bytes, at); if ((route.action === "commit" && senderRole !== "target") || (route.action === "abort" && senderRole !== "source"))
+    throw new RangeError("route sender"); b3Finish(at, bytes, "sessionRelocationRoute"); return { relocation, coordinator, senderRole, actor, ...session, route }; }
+function b4Header(id) { return [90, 77, 1, id, 0]; }
+function b4ReadHeader(bytes, id, name) { const at = { value: 0 }; if (bytes.length < 5 || bytes[at.value++] !== 90 || bytes[at.value++] !== 77 || bytes[at.value++] !== 1 || bytes[at.value++] !== id || bytes[at.value++] !== 0)
+    throw new RangeError(name + " header"); return at; }
+function b4Finish(at, bytes, name) { if (at.value !== bytes.length)
+    throw new RangeError(name + " trailing"); }
+function b4Reservation(out, v) { text8(out, v.reservationId); writeText16(out, v.expectedStoreVersion, 1, 4096, "store version"); if (v.objectGeneration === 0n || v.authorityOwnerGeneration === 0n || v.targetNodeGeneration === 0n || v.targetOwnerLeaseGeneration === 0n || !Number.isInteger(v.pendingCapacityDelta) || v.pendingCapacityDelta < 1 || v.pendingCapacityDelta > 0xffffffff)
+    throw new RangeError("reservation"); u64(out, v.objectGeneration); u64(out, v.authorityOwnerGeneration); rid(out, v.targetNodeRid); u64(out, v.targetNodeGeneration); text8(out, v.targetOwnerId); u64(out, v.targetOwnerLeaseGeneration); u32(out, v.pendingCapacityDelta); }
+function b4ReadReservation(bytes, at) { return { reservationId: readText8(bytes, at), expectedStoreVersion: readText16(bytes, at, 1, 4096, "store version"), objectGeneration: nonzero64(bytes, at, "object generation"), authorityOwnerGeneration: nonzero64(bytes, at, "authority generation"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node generation"), targetOwnerId: readText8(bytes, at), targetOwnerLeaseGeneration: nonzero64(bytes, at, "target lease generation"), pendingCapacityDelta: (() => { const v = read32(bytes, at); if (v === 0)
+        throw new RangeError("pending capacity"); return v; })() }; }
+function b4Close(out, v) { const body = []; text8(body, v.spotId); if (v.objectGeneration === 0n || v.targetNodeGeneration === 0n || v.expectedAuthorityOwnerGeneration === 0n)
+    throw new RangeError("close fence"); u64(body, v.objectGeneration); rid(body, v.targetNodeRid); u64(body, v.targetNodeGeneration); u64(body, v.expectedAuthorityOwnerGeneration); writeText16(body, v.expectedStoreVersion, 1, 4096, "store version"); out.push(1); if (body.length > 65535)
+    throw new RangeError("close fence"); out.push(body.length >>> 8, body.length & 255, ...body); }
+function b4ReadClose(bytes, at) { if (read8(bytes, at) !== 1)
+    throw new RangeError("close fence version"); const end = boundedEnd(bytes, at, read16(bytes, at), "close fence"); const value = { spotId: readText8(bytes, at), objectGeneration: nonzero64(bytes, at, "object generation"), targetNodeRid: readRid(bytes, at), targetNodeGeneration: nonzero64(bytes, at, "target node generation"), expectedAuthorityOwnerGeneration: nonzero64(bytes, at, "authority generation"), expectedStoreVersion: readText16(bytes, at, 1, 4096, "store version") }; exactEnd(at, end, "close fence"); return value; }
+function b4CommandBase(out, v) { if (v.correlation === 0n || v.sourceNodeGeneration === 0n)
+    throw new RangeError("command base"); u64(out, v.correlation); b3WriteId(out, v.operation, "operation"); rid(out, v.sourceNodeRid); u64(out, v.sourceNodeGeneration); }
+function b4ReadCommandBase(bytes, at) { return { correlation: nonzero64(bytes, at, "correlation"), operation: b3ReadId(bytes, at, "operation"), sourceNodeRid: readRid(bytes, at), sourceNodeGeneration: nonzero64(bytes, at, "source node generation") }; }
+function encodeUserSpotCreate47(v) { const out = b4Header(47); b4CommandBase(out, v); text8(out, v.spotId); text8(out, v.stableType); b4Reservation(out, v.reservation); if (v.deadlineUnixMs === 0n)
+    throw new RangeError("deadline"); u64(out, v.deadlineUnixMs); return Uint8Array.from(out); }
+function decodeUserSpotCreate47(bytes) { const at = b4ReadHeader(bytes, 47, "userSpotCreate"), base = b4ReadCommandBase(bytes, at), spotId = readText8(bytes, at), stableType = readText8(bytes, at), reservation = b4ReadReservation(bytes, at), deadlineUnixMs = nonzero64(bytes, at, "deadline"); b4Finish(at, bytes, "userSpotCreate"); return { ...base, spotId, stableType, reservation, deadlineUnixMs }; }
+function encodeUserSpotClose48(v) { const out = b4Header(48); b4CommandBase(out, v); b4Close(out, v.target); if (v.deadlineUnixMs === 0n)
+    throw new RangeError("deadline"); u64(out, v.deadlineUnixMs); return Uint8Array.from(out); }
+function decodeUserSpotClose48(bytes) { const at = b4ReadHeader(bytes, 48, "userSpotClose"), base = b4ReadCommandBase(bytes, at), target = b4ReadClose(bytes, at), deadlineUnixMs = nonzero64(bytes, at, "deadline"); b4Finish(at, bytes, "userSpotClose"); return { ...base, target, deadlineUnixMs }; }
+function encodeActorCreate49(v) { const out = b4Header(49); b4CommandBase(out, v); text8(out, v.actorId); text8(out, v.stableType); b4Reservation(out, v.reservation); if (v.deadlineUnixMs === 0n)
+    throw new RangeError("deadline"); u64(out, v.deadlineUnixMs); return Uint8Array.from(out); }
+function decodeActorCreate49(bytes) { const at = b4ReadHeader(bytes, 49, "actorCreate"), base = b4ReadCommandBase(bytes, at), actorId = readText8(bytes, at), stableType = readText8(bytes, at), reservation = b4ReadReservation(bytes, at), deadlineUnixMs = nonzero64(bytes, at, "deadline"); b4Finish(at, bytes, "actorCreate"); return { ...base, actorId, stableType, reservation, deadlineUnixMs }; }
+function b4ZljrPayload(v) { if (v.metadata.length > 262144 || v.request.length > 1048576 || v.reply.length > 1048576)
+    throw new RangeError("ZLJR length"); const out = [90, 76, 74, 82, 1]; u32(out, v.metadata.length); u32(out, v.request.length); u32(out, v.reply.length); out.push(...v.metadata, ...v.request, ...v.reply); return Uint8Array.from(out); }
+function b4ReadZljrPayload(bytes) { const at = { value: 0 }; if (read32(bytes, at) !== 0x5a4c4a52 || read8(bytes, at) !== 1)
+    throw new RangeError("ZLJR header"); const metadataLength = read32(bytes, at), requestLength = read32(bytes, at), replyLength = read32(bytes, at); if (metadataLength > 262144 || requestLength > 1048576 || replyLength > 1048576)
+    throw new RangeError("ZLJR length"); const metadata = take(bytes, at, metadataLength, "ZLJR metadata"), request = take(bytes, at, requestLength, "ZLJR request"), reply = take(bytes, at, replyLength, "ZLJR reply"); b4Finish(at, bytes, "ZLJR"); return { metadata, request, reply }; }
+function encodeZljrRecordV1(v) { if (v.source.nodeGeneration === 0n || v.source.ownerLeaseGeneration === 0n)
+    throw new RangeError("ZLJR record"); const source = []; rid(source, v.source.nodeRid); u64(source, v.source.nodeGeneration); text8(source, v.source.ownerId); u64(source, v.source.ownerLeaseGeneration); if (source.length > 65535)
+    throw new RangeError("ZLJR source"); const payload = b4ZljrPayload(v), body = []; text8(body, "__zlink.actor.routed_join.recovery"); text8(body, "application/x-zlink-actor-routed-join-recovery-v1"); u32(body, payload.length); body.push(...payload); const out = [1, 1, source.length >>> 8, source.length & 255, ...source, 0]; u64(out, v.operation.high); u64(out, v.operation.low); u32(out, 0); out.push(0, 0, 1); u32(out, body.length); out.push(...body); return Uint8Array.from(out); }
+function decodeZljrRecordV1(bytes) { const at = { value: 0 }; if (read8(bytes, at) !== 1 || read8(bytes, at) !== 1)
+    throw new RangeError("ZLJR frozen record"); const sourceEnd = boundedEnd(bytes, at, read16(bytes, at), "ZLJR source"), nodeRid = readRid(bytes, at), nodeGeneration = nonzero64(bytes, at, "source node generation"), ownerId = readText8(bytes, at), ownerLeaseGeneration = nonzero64(bytes, at, "source owner lease"); exactEnd(at, sourceEnd, "ZLJR source"); if (read8(bytes, at) !== 0)
+    throw new RangeError("ZLJR metadata flag"); const operation = { high: read64(bytes, at), low: read64(bytes, at) }; if (read32(bytes, at) !== 0 || read16(bytes, at) !== 0 || read8(bytes, at) !== 1)
+    throw new RangeError("ZLJR frozen record"); const payloadEnd = boundedEnd(bytes, at, read32(bytes, at), "ZLJR payload"), packetName = readText8(bytes, at), contentType = readText8(bytes, at), payloadLength = read32(bytes, at); if (packetName !== "__zlink.actor.routed_join.recovery" || contentType !== "application/x-zlink-actor-routed-join-recovery-v1" || payloadLength !== payloadEnd - at.value)
+    throw new RangeError("ZLJR payload"); const payload = take(bytes, at, payloadLength, "ZLJR payload"); exactEnd(at, payloadEnd, "ZLJR payload"); b4Finish(at, bytes, "ZLJR record"); return { source: { nodeRid, nodeGeneration, ownerId, ownerLeaseGeneration }, operation, ...b4ReadZljrPayload(payload) }; }