@zlink-systems/framework 0.21.0 → 0.22.0

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

@@ -2,6 +2,7 @@
 /* This file is generated by render-service-wire-typescript.mjs. */
 /* eslint-disable */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelocationEnvelopeV1LogicalStreamDecoder = exports.LogicalDecodeError = void 0;
 exports.decodeU8 = decodeU8;
 exports.encodeU8 = encodeU8;
 exports.decodeU16 = decodeU16;
@@ -482,7 +483,10 @@ exports.decodeRelocationManifestV1DurableFormat = decodeRelocationManifestV1Dura
 exports.encodeRelocationManifestV1DurableFormat = encodeRelocationManifestV1DurableFormat;
 exports.decodeRelocationEnvelopeV1LogicalStream = decodeRelocationEnvelopeV1LogicalStream;
 exports.encodeRelocationEnvelopeV1LogicalStream = encodeRelocationEnvelopeV1LogicalStream;
-function fail(message) { throw new RangeError(message); }
+class ServiceWireProtocolError extends RangeError {
+    constructor(message) { super(message); this.name = "ServiceWireProtocolError"; }
+}
+function fail(message) { throw new ServiceWireProtocolError(message); }
 class ServiceWireCapacityError extends RangeError {
     constructor(message) { super(message); this.name = "ServiceWireCapacityError"; }
 }
@@ -491,8 +495,9 @@ function numeric(value) { return typeof value === "bigint" ? value : BigInt(valu
 function same(left, right) { return typeof left === "bigint" || typeof right === "bigint" ? numeric(left) === numeric(right) : left === right; }
 function requireContext(context, name) { const value = context[name]; if (value === undefined)
     fail("missing decoder context " + name); return value; }
-function runtimePredicate(context, name, terminal, failure) { const predicate = context.runtimePredicates[name]; if (!predicate)
-    fail("missing runtime predicate " + name); return predicate(terminal, failure); }
+function validTerminalFailure(terminal, failure) { if (terminal === 0)
+    return failure === 0; if ([101, 103, 108, 109, 110, 111, 112, 113].includes(terminal))
+    return failure === 0; return 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]]).get(failure) === terminal; }
 const encoder = new TextEncoder();
 const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 function utf8(value) { const text = value; for (let index = 0; index < text.length; ++index) {
@@ -529,6 +534,157 @@ class Reader {
     done(label) { if (this.remaining)
         fail(label + " trailing bytes"); }
 }
+class IncrementalReader {
+    offset = 0;
+    chunk = new Uint8Array();
+    chunkOffset = 0;
+    bufferedInputByteCount = 0;
+    get remaining() { return this.chunk.length - this.chunkOffset; }
+    supply(chunk) { if (this.remaining)
+        throw new Error("incremental reader still owns caller input"); this.chunk = chunk; this.chunkOffset = 0; }
+    release() { if (this.remaining)
+        throw new Error("incremental reader did not consume caller input"); this.discard(); }
+    discard() { this.chunk = new Uint8Array(); this.chunkOffset = 0; }
+    *take(length) { if (!Number.isSafeInteger(length) || length < 0 || length > 8)
+        fail("invalid incremental scalar read length"); const value = new Uint8Array(length); let filled = 0; while (filled < length) {
+        const available = this.remaining;
+        if (available === 0) {
+            this.bufferedInputByteCount = filled;
+            yield;
+            continue;
+        }
+        const count = Math.min(length - filled, available);
+        value.set(this.chunk.subarray(this.chunkOffset, this.chunkOffset + count), filled);
+        this.chunkOffset += count;
+        this.offset += count;
+        filled += count;
+    } this.bufferedInputByteCount = 0; return value; }
+    *bytes(length) { if (!Number.isSafeInteger(length) || length < 0)
+        fail("invalid incremental content length"); let value; try {
+        value = new Uint8Array(length);
+    }
+    catch {
+        return capacityFail("incremental content capacity");
+    } let filled = 0; while (filled < length) {
+        const available = this.remaining;
+        if (available === 0) {
+            this.bufferedInputByteCount = 0;
+            yield;
+            continue;
+        }
+        const count = Math.min(length - filled, available);
+        value.set(this.chunk.subarray(this.chunkOffset, this.chunkOffset + count), filled);
+        this.chunkOffset += count;
+        this.offset += count;
+        filled += count;
+    } return value; }
+    *text(length, forbidNul, label) { if (!Number.isSafeInteger(length) || length < 0)
+        fail("invalid incremental text length"); let value = "", remaining = length, codePoint = 0, needed = 0, minimum = 0; while (remaining > 0) {
+        if (this.remaining === 0) {
+            this.bufferedInputByteCount = 0;
+            yield;
+            continue;
+        }
+        const byte = this.chunk[this.chunkOffset++];
+        ++this.offset;
+        --remaining;
+        if (needed === 0) {
+            if (byte <= 0x7f) {
+                if (forbidNul && byte === 0)
+                    fail(label + " NUL");
+                try {
+                    value += String.fromCodePoint(byte);
+                }
+                catch {
+                    return capacityFail(label + " capacity");
+                }
+                continue;
+            }
+            if (byte >= 0xc2 && byte <= 0xdf) {
+                codePoint = byte & 0x1f;
+                needed = 1;
+                minimum = 0x80;
+                continue;
+            }
+            if (byte >= 0xe0 && byte <= 0xef) {
+                codePoint = byte & 0x0f;
+                needed = 2;
+                minimum = 0x800;
+                continue;
+            }
+            if (byte >= 0xf0 && byte <= 0xf4) {
+                codePoint = byte & 0x07;
+                needed = 3;
+                minimum = 0x10000;
+                continue;
+            }
+            fail(label + " UTF-8");
+        }
+        if ((byte & 0xc0) !== 0x80)
+            fail(label + " UTF-8");
+        codePoint = (codePoint << 6) | (byte & 0x3f);
+        if (--needed === 0) {
+            if (codePoint < minimum || codePoint > 0x10ffff || (codePoint >= 0xd800 && codePoint <= 0xdfff) || (forbidNul && codePoint === 0))
+                fail(label + " UTF-8");
+            try {
+                value += String.fromCodePoint(codePoint);
+            }
+            catch {
+                return capacityFail(label + " capacity");
+            }
+        }
+    } if (needed !== 0)
+        fail(label + " UTF-8"); return value; }
+    bounded(length) { if (!Number.isSafeInteger(length) || length < 0)
+        fail("invalid bounded read length"); return new IncrementalBoundedReader(this, length); }
+    *u(width) { let value = 0n; for (const byte of yield* this.take(width))
+        value = (value << 8n) | BigInt(byte); return value; }
+    *i64() { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); }
+    done(label) { if (this.remaining)
+        fail(label + " bounded body remainder"); }
+}
+class IncrementalBoundedReader {
+    source;
+    remaining;
+    offset = 0;
+    constructor(source, remaining) {
+        this.source = source;
+        this.remaining = remaining;
+    }
+    check(length) { if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining)
+        fail("bounded service-wire value overflow"); }
+    consumed(length) { this.remaining -= length; this.offset += length; }
+    *take(length) { this.check(length); const value = yield* this.source.take(length); this.consumed(length); return value; }
+    *bytes(length) { this.check(length); const value = yield* this.source.bytes(length); this.consumed(length); return value; }
+    *text(length, forbidNul, label) { this.check(length); const value = yield* this.source.text(length, forbidNul, label); this.consumed(length); return value; }
+    bounded(length) { this.check(length); return new IncrementalNestedBoundedReader(this, length); }
+    *u(width) { let value = 0n; for (const byte of yield* this.take(width))
+        value = (value << 8n) | BigInt(byte); return value; }
+    *i64() { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); }
+    done(label) { if (this.remaining)
+        fail(label + " bounded body remainder"); }
+}
+class IncrementalNestedBoundedReader {
+    parent;
+    remaining;
+    offset = 0;
+    constructor(parent, remaining) {
+        this.parent = parent;
+        this.remaining = remaining;
+    }
+    check(length) { if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining)
+        fail("bounded service-wire value overflow"); }
+    consumed(length) { this.remaining -= length; this.offset += length; }
+    *take(length) { this.check(length); const value = yield* this.parent.take(length); this.consumed(length); return value; }
+    *bytes(length) { this.check(length); const value = yield* this.parent.bytes(length); this.consumed(length); return value; }
+    *text(length, forbidNul, label) { this.check(length); const value = yield* this.parent.text(length, forbidNul, label); this.consumed(length); return value; }
+    bounded(length) { this.check(length); return new IncrementalNestedBoundedReader(this, length); }
+    *u(width) { let value = 0n; for (const byte of yield* this.take(width))
+        value = (value << 8n) | BigInt(byte); return value; }
+    *i64() { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); }
+    done(label) { if (this.remaining)
+        fail(label + " bounded body remainder"); }
+}
 class Writer {
     chunks = [];
     length = 0;
@@ -576,6 +732,15 @@ function readU8(reader, context, enclosing, flags) {
         fail("u8 range");
     return Number(raw);
 }
+function* readIncrementalU8(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    if (raw < 0n || raw > 255n)
+        fail("u8 range");
+    return Number(raw);
+}
 function writeU8(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -597,6 +762,15 @@ function readU16(reader, context, enclosing, flags) {
         fail("u16 range");
     return Number(raw);
 }
+function* readIncrementalU16(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(2);
+    if (raw < 0n || raw > 65535n)
+        fail("u16 range");
+    return Number(raw);
+}
 function writeU16(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -618,6 +792,15 @@ function readU32(reader, context, enclosing, flags) {
         fail("u32 range");
     return Number(raw);
 }
+function* readIncrementalU32(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(4);
+    if (raw < 0n || raw > 4294967295n)
+        fail("u32 range");
+    return Number(raw);
+}
 function writeU32(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -660,6 +843,15 @@ function readU64(reader, context, enclosing, flags) {
         fail("u64 range");
     return raw;
 }
+function* readIncrementalU64(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(8);
+    if (raw < 0n || raw > 18446744073709551615n)
+        fail("u64 range");
+    return raw;
+}
 function writeU64(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -681,6 +873,15 @@ function readNonzeroU64(reader, context, enclosing, flags) {
         fail("nonzero-u64 range");
     return raw;
 }
+function* readIncrementalNonzeroU64(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(8);
+    if (raw < 1n || raw > 9223372036854775807n)
+        fail("nonzero-u64 range");
+    return raw;
+}
 function writeNonzeroU64(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -702,6 +903,15 @@ function readOrdinalOrZero(reader, context, enclosing, flags) {
         fail("ordinal-or-zero range");
     return raw;
 }
+function* readIncrementalOrdinalOrZero(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(8);
+    if (raw < 0n || raw > 9223372036854775807n)
+        fail("ordinal-or-zero range");
+    return raw;
+}
 function writeOrdinalOrZero(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -765,6 +975,15 @@ function readApplicationVersion(reader, context, enclosing, flags) {
         fail("application-version range");
     return raw;
 }
+function* readIncrementalApplicationVersion(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.i64();
+    if (raw < 0n || raw > 9223372036854775807n)
+        fail("application-version range");
+    return raw;
+}
 function writeApplicationVersion(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -794,6 +1013,17 @@ function readBool8(reader, context, enclosing, flags) {
         default: fail("bool8 enum");
     }
 }
+function* readIncrementalBool8(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 0: return "false";
+        case 1: return "true";
+        default: fail("bool8 enum");
+    }
+}
 function writeBool8(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -808,13 +1038,26 @@ function readRid(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU8(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("rid capacity");
     if (length > 255)
         fail("rid length");
+    if (length < 1)
+        fail("rid length");
+    return reader.take(length);
+}
+function* readIncrementalRid(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU8(reader, context, enclosing, flags));
     if (length > 2147483647)
         capacityFail("rid capacity");
+    if (length > 255)
+        fail("rid length");
     if (length < 1)
         fail("rid length");
-    return reader.take(length);
+    return yield* reader.bytes(length);
 }
 function writeRid(input, writer, context, enclosing, flags) {
     void context;
@@ -822,10 +1065,10 @@ function writeRid(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 255)
-        fail("rid length");
     if (bytes.length > 2147483647)
         capacityFail("rid capacity");
+    if (bytes.length > 255)
+        fail("rid length");
     if (bytes.length < 1)
         fail("rid length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -840,10 +1083,10 @@ function readOptionalRid(reader, context, enclosing, flags) {
     const length = Number(readU8(reader, context, enclosing, flags));
     if (length === 0)
         return null;
-    if (length > 255)
-        fail("optional-rid length");
     if (length > 2147483647)
         capacityFail("optional-rid capacity");
+    if (length > 255)
+        fail("optional-rid length");
     if (length < 0)
         fail("optional-rid length");
     return reader.take(length);
@@ -858,10 +1101,10 @@ function writeOptionalRid(input, writer, context, enclosing, flags) {
         return;
     }
     const bytes = value;
-    if (bytes.length > 255)
-        fail("optional-rid length");
     if (bytes.length > 2147483647)
         capacityFail("optional-rid capacity");
+    if (bytes.length > 255)
+        fail("optional-rid length");
     if (bytes.length < 0)
         fail("optional-rid length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -874,10 +1117,10 @@ function readText8(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU8(reader, context, enclosing, flags));
-    if (length > 255)
-        fail("text8 length");
     if (length > 2147483647)
         capacityFail("text8 capacity");
+    if (length > 255)
+        fail("text8 length");
     if (length < 1)
         fail("text8 length");
     const bytes = reader.take(length);
@@ -885,6 +1128,19 @@ function readText8(reader, context, enclosing, flags) {
         fail("text8 NUL");
     return decodeUtf8(bytes, "text8");
 }
+function* readIncrementalText8(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU8(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("text8 capacity");
+    if (length > 255)
+        fail("text8 length");
+    if (length < 1)
+        fail("text8 length");
+    return yield* reader.text(length, true, "text8");
+}
 function writeText8(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -893,10 +1149,10 @@ function writeText8(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("text8 NUL");
-    if (bytes.length > 255)
-        fail("text8 length");
     if (bytes.length > 2147483647)
         capacityFail("text8 capacity");
+    if (bytes.length > 255)
+        fail("text8 length");
     if (bytes.length < 1)
         fail("text8 length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -911,10 +1167,10 @@ function readOptionalText8(reader, context, enclosing, flags) {
     const length = Number(readU8(reader, context, enclosing, flags));
     if (length === 0)
         return null;
-    if (length > 255)
-        fail("optional-text8 length");
     if (length > 2147483647)
         capacityFail("optional-text8 capacity");
+    if (length > 255)
+        fail("optional-text8 length");
     if (length < 0)
         fail("optional-text8 length");
     const bytes = reader.take(length);
@@ -934,10 +1190,10 @@ function writeOptionalText8(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("optional-text8 NUL");
-    if (bytes.length > 255)
-        fail("optional-text8 length");
     if (bytes.length > 2147483647)
         capacityFail("optional-text8 capacity");
+    if (bytes.length > 255)
+        fail("optional-text8 length");
     if (bytes.length < 0)
         fail("optional-text8 length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -950,10 +1206,10 @@ function readSha256Bytes(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU8(reader, context, enclosing, flags));
-    if (length > 32)
-        fail("sha256-bytes length");
     if (length > 2147483647)
         capacityFail("sha256-bytes capacity");
+    if (length > 32)
+        fail("sha256-bytes length");
     if (length < 32)
         fail("sha256-bytes length");
     return reader.take(length);
@@ -964,10 +1220,10 @@ function writeSha256Bytes(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 32)
-        fail("sha256-bytes length");
     if (bytes.length > 2147483647)
         capacityFail("sha256-bytes capacity");
+    if (bytes.length > 32)
+        fail("sha256-bytes length");
     if (bytes.length < 32)
         fail("sha256-bytes length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -1001,10 +1257,10 @@ function readText16(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 65535)
-        fail("text16 length");
     if (length > 2147483647)
         capacityFail("text16 capacity");
+    if (length > 65535)
+        fail("text16 length");
     if (length < 0)
         fail("text16 length");
     const bytes = reader.take(length);
@@ -1020,10 +1276,10 @@ function writeText16(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("text16 NUL");
-    if (bytes.length > 65535)
-        fail("text16 length");
     if (bytes.length > 2147483647)
         capacityFail("text16 capacity");
+    if (bytes.length > 65535)
+        fail("text16 length");
     if (bytes.length < 0)
         fail("text16 length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1036,10 +1292,10 @@ function readNonemptyText16(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 65535)
-        fail("nonempty-text16 length");
     if (length > 2147483647)
         capacityFail("nonempty-text16 capacity");
+    if (length > 65535)
+        fail("nonempty-text16 length");
     if (length < 1)
         fail("nonempty-text16 length");
     const bytes = reader.take(length);
@@ -1055,10 +1311,10 @@ function writeNonemptyText16(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("nonempty-text16 NUL");
-    if (bytes.length > 65535)
-        fail("nonempty-text16 length");
     if (bytes.length > 2147483647)
         capacityFail("nonempty-text16 capacity");
+    if (bytes.length > 65535)
+        fail("nonempty-text16 length");
     if (bytes.length < 1)
         fail("nonempty-text16 length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1071,10 +1327,10 @@ function readEndpoint(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 4096)
-        fail("endpoint length");
     if (length > 2147483647)
         capacityFail("endpoint capacity");
+    if (length > 4096)
+        fail("endpoint length");
     if (length < 1)
         fail("endpoint length");
     const bytes = reader.take(length);
@@ -1090,10 +1346,10 @@ function writeEndpoint(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("endpoint NUL");
-    if (bytes.length > 4096)
-        fail("endpoint length");
     if (bytes.length > 2147483647)
         capacityFail("endpoint capacity");
+    if (bytes.length > 4096)
+        fail("endpoint length");
     if (bytes.length < 1)
         fail("endpoint length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1106,10 +1362,10 @@ function readBlob16(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 65535)
-        fail("blob16 length");
     if (length > 2147483647)
         capacityFail("blob16 capacity");
+    if (length > 65535)
+        fail("blob16 length");
     if (length < 0)
         fail("blob16 length");
     return reader.take(length);
@@ -1120,10 +1376,10 @@ function writeBlob16(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 65535)
-        fail("blob16 length");
     if (bytes.length > 2147483647)
         capacityFail("blob16 capacity");
+    if (bytes.length > 65535)
+        fail("blob16 length");
     if (bytes.length < 0)
         fail("blob16 length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1136,10 +1392,10 @@ function readNonemptyBlob16(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 65535)
-        fail("nonempty-blob16 length");
     if (length > 2147483647)
         capacityFail("nonempty-blob16 capacity");
+    if (length > 65535)
+        fail("nonempty-blob16 length");
     if (length < 1)
         fail("nonempty-blob16 length");
     return reader.take(length);
@@ -1150,10 +1406,10 @@ function writeNonemptyBlob16(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 65535)
-        fail("nonempty-blob16 length");
     if (bytes.length > 2147483647)
         capacityFail("nonempty-blob16 capacity");
+    if (bytes.length > 65535)
+        fail("nonempty-blob16 length");
     if (bytes.length < 1)
         fail("nonempty-blob16 length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1166,10 +1422,10 @@ function readPacketName(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU8(reader, context, enclosing, flags));
-    if (length > 255)
-        fail("packet-name length");
     if (length > 2147483647)
         capacityFail("packet-name capacity");
+    if (length > 255)
+        fail("packet-name length");
     if (length < 1)
         fail("packet-name length");
     const bytes = reader.take(length);
@@ -1177,6 +1433,19 @@ function readPacketName(reader, context, enclosing, flags) {
         fail("packet-name NUL");
     return decodeUtf8(bytes, "packet-name");
 }
+function* readIncrementalPacketName(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU8(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("packet-name capacity");
+    if (length > 255)
+        fail("packet-name length");
+    if (length < 1)
+        fail("packet-name length");
+    return yield* reader.text(length, true, "packet-name");
+}
 function writePacketName(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1185,10 +1454,10 @@ function writePacketName(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("packet-name NUL");
-    if (bytes.length > 255)
-        fail("packet-name length");
     if (bytes.length > 2147483647)
         capacityFail("packet-name capacity");
+    if (bytes.length > 255)
+        fail("packet-name length");
     if (bytes.length < 1)
         fail("packet-name length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -1201,10 +1470,10 @@ function readContentType(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU8(reader, context, enclosing, flags));
-    if (length > 255)
-        fail("content-type length");
     if (length > 2147483647)
         capacityFail("content-type capacity");
+    if (length > 255)
+        fail("content-type length");
     if (length < 1)
         fail("content-type length");
     const bytes = reader.take(length);
@@ -1212,6 +1481,19 @@ function readContentType(reader, context, enclosing, flags) {
         fail("content-type NUL");
     return decodeUtf8(bytes, "content-type");
 }
+function* readIncrementalContentType(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU8(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("content-type capacity");
+    if (length > 255)
+        fail("content-type length");
+    if (length < 1)
+        fail("content-type length");
+    return yield* reader.text(length, true, "content-type");
+}
 function writeContentType(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1220,10 +1502,10 @@ function writeContentType(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("content-type NUL");
-    if (bytes.length > 255)
-        fail("content-type length");
     if (bytes.length > 2147483647)
         capacityFail("content-type capacity");
+    if (bytes.length > 255)
+        fail("content-type length");
     if (bytes.length < 1)
         fail("content-type length");
     writeU8(bytes.length, writer, context, enclosing, flags);
@@ -1236,16 +1518,32 @@ function readApplicationPayloadBytes(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU32(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("application-payload-bytes capacity");
     if (length > 4294966774)
         fail("application-payload-bytes length");
+    if (length < 0)
+        fail("application-payload-bytes length");
+    const negotiatedMaximum = numeric(requireContext(context, "effectiveCompleteMessageBytesMinusActualEnvelopeOverhead"));
+    if (negotiatedMaximum < 0n || negotiatedMaximum > 4294966774n || BigInt(length) > negotiatedMaximum)
+        fail("application-payload-bytes negotiated maximum");
+    return reader.take(length);
+}
+function* readIncrementalApplicationPayloadBytes(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
     if (length > 2147483647)
         capacityFail("application-payload-bytes capacity");
+    if (length > 4294966774)
+        fail("application-payload-bytes length");
     if (length < 0)
         fail("application-payload-bytes length");
     const negotiatedMaximum = numeric(requireContext(context, "effectiveCompleteMessageBytesMinusActualEnvelopeOverhead"));
     if (negotiatedMaximum < 0n || negotiatedMaximum > 4294966774n || BigInt(length) > negotiatedMaximum)
         fail("application-payload-bytes negotiated maximum");
-    return reader.take(length);
+    return yield* reader.bytes(length);
 }
 function writeApplicationPayloadBytes(input, writer, context, enclosing, flags) {
     void context;
@@ -1253,10 +1551,10 @@ function writeApplicationPayloadBytes(input, writer, context, enclosing, flags)
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 4294966774)
-        fail("application-payload-bytes length");
     if (bytes.length > 2147483647)
         capacityFail("application-payload-bytes capacity");
+    if (bytes.length > 4294966774)
+        fail("application-payload-bytes length");
     if (bytes.length < 0)
         fail("application-payload-bytes length");
     writeU32(bytes.length, writer, context, enclosing, flags);
@@ -1293,6 +1591,32 @@ function readApplicationPayloadEnvelopeV1(reader, context, enclosing, flags) {
         fail("application-payload-envelope-v1 maximum");
     return decoded;
 }
+function* readIncrementalApplicationPayloadEnvelopeV1(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const limitStart = reader.offset;
+    const decoded = yield* (function* () {
+        const encodedStart = reader.offset;
+        const version = yield* readIncrementalU8(reader, context, enclosing, flags);
+        if (!same(version, 1))
+            fail("application-payload-envelope-v1 version");
+        const length = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
+        const body = reader.bounded(length);
+        const value = {};
+        value["packetName"] = yield* readIncrementalPacketName(body, context, value, flags);
+        value["contentType"] = yield* readIncrementalContentType(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadBytes(body, context, value, flags);
+        body.done("application-payload-envelope-v1");
+        const negotiatedMaximum = numeric(requireContext(context, "effectiveCompleteMessageBytes"));
+        if (negotiatedMaximum < 0n || negotiatedMaximum > 4294967295n || BigInt(reader.offset - encodedStart) > negotiatedMaximum)
+            fail("application-payload-envelope-v1 negotiated maximum");
+        return value;
+    })();
+    if (reader.offset - limitStart > 4294967295)
+        fail("application-payload-envelope-v1 maximum");
+    return decoded;
+}
 function writeApplicationPayloadEnvelopeV1(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1327,10 +1651,10 @@ function readMetadataValue(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 1024)
-        fail("metadata-value length");
     if (length > 2147483647)
         capacityFail("metadata-value capacity");
+    if (length > 1024)
+        fail("metadata-value length");
     if (length < 0)
         fail("metadata-value length");
     const bytes = reader.take(length);
@@ -1338,6 +1662,19 @@ function readMetadataValue(reader, context, enclosing, flags) {
         fail("metadata-value NUL");
     return decodeUtf8(bytes, "metadata-value");
 }
+function* readIncrementalMetadataValue(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU16(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("metadata-value capacity");
+    if (length > 1024)
+        fail("metadata-value length");
+    if (length < 0)
+        fail("metadata-value length");
+    return yield* reader.text(length, true, "metadata-value");
+}
 function writeMetadataValue(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1346,10 +1683,10 @@ function writeMetadataValue(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("metadata-value NUL");
-    if (bytes.length > 1024)
-        fail("metadata-value length");
     if (bytes.length > 2147483647)
         capacityFail("metadata-value capacity");
+    if (bytes.length > 1024)
+        fail("metadata-value length");
     if (bytes.length < 0)
         fail("metadata-value length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -1366,6 +1703,15 @@ function readMetadataEntry(reader, context, enclosing, flags) {
     value["value"] = readMetadataValue(reader, context, value, flags);
     return value;
 }
+function* readIncrementalMetadataEntry(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["key"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["value"] = yield* readIncrementalMetadataValue(reader, context, value, flags);
+    return value;
+}
 function writeMetadataEntry(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1393,10 +1739,60 @@ function readMetadataFrame(reader, context, enclosing, flags) {
             fail("metadata-frame constant");
         layout.count = readU8(reader, context, enclosing, flags);
         value.entries = Array.from({ length: Number(layout.count) }, () => readMetadataEntry(reader, context, enclosing, flags));
-        for (let left = 0; left < value.entries.length; ++left)
-            for (let right = left + 1; right < value.entries.length; ++right)
-                if (compareResults([compareBytes(utf8(value.entries[left]["key"]), utf8(value.entries[right]["key"]))]) === 0)
-                    fail("metadata-frame unique");
+        try {
+            for (let left = 0; left < value.entries.length; ++left)
+                for (let right = left + 1; right < value.entries.length; ++right)
+                    if (compareResults([compareBytes(utf8(value.entries[left]["key"]), utf8(value.entries[right]["key"]))]) === 0)
+                        fail("metadata-frame unique");
+        }
+        catch (error) {
+            if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+                throw error;
+            if (error instanceof RangeError)
+                capacityFail("metadata-frame constraint capacity");
+            throw error;
+        }
+        return value;
+    })();
+    if (reader.offset - limitStart > 1024)
+        fail("metadata-frame maximum");
+    return decoded;
+}
+function* readIncrementalMetadataFrame(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const limitStart = reader.offset;
+    const decoded = yield* (function* () {
+        const layout = {};
+        const value = {};
+        layout.version = yield* readIncrementalU8(reader, context, enclosing, flags);
+        if (!same(layout.version, 1))
+            fail("metadata-frame constant");
+        layout.count = yield* readIncrementalU8(reader, context, enclosing, flags);
+        value.entries = [];
+        for (let index = 0; index < Number(layout.count); ++index) {
+            const item = yield* readIncrementalMetadataEntry(reader, context, enclosing, flags);
+            try {
+                value.entries.push(item);
+            }
+            catch {
+                capacityFail("metadata-frame capacity");
+            }
+        }
+        try {
+            for (let left = 0; left < value.entries.length; ++left)
+                for (let right = left + 1; right < value.entries.length; ++right)
+                    if (compareResults([compareBytes(utf8(value.entries[left]["key"]), utf8(value.entries[right]["key"]))]) === 0)
+                        fail("metadata-frame unique");
+        }
+        catch (error) {
+            if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+                throw error;
+            if (error instanceof RangeError)
+                capacityFail("metadata-frame constraint capacity");
+            throw error;
+        }
         return value;
     })();
     if (reader.offset - limitStart > 1024)
@@ -1409,10 +1805,19 @@ function writeMetadataFrame(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const limitStart = writer.length;
-    for (let left = 0; left < value.entries.length; ++left)
-        for (let right = left + 1; right < value.entries.length; ++right)
-            if (compareResults([compareBytes(utf8(value.entries[left]["key"]), utf8(value.entries[right]["key"]))]) === 0)
-                fail("metadata-frame unique");
+    try {
+        for (let left = 0; left < value.entries.length; ++left)
+            for (let right = left + 1; right < value.entries.length; ++right)
+                if (compareResults([compareBytes(utf8(value.entries[left]["key"]), utf8(value.entries[right]["key"]))]) === 0)
+                    fail("metadata-frame unique");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("metadata-frame constraint capacity");
+        throw error;
+    }
     writeU8(1, writer, context, enclosing, flags);
     writeU8(value.entries.length, writer, context, enclosing, flags);
     for (const item of value.entries)
@@ -1473,6 +1878,18 @@ function readStatefulObjectKind(reader, context, enclosing, flags) {
         default: fail("stateful-object-kind enum");
     }
 }
+function* readIncrementalStatefulObjectKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "actor";
+        case 2: return "userSpot";
+        case 3: return "instanceSpot";
+        default: fail("stateful-object-kind enum");
+    }
+}
 function writeStatefulObjectKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1709,6 +2126,18 @@ function readTimerOverrunPolicyKind(reader, context, enclosing, flags) {
         default: fail("timer-overrun-policy-kind enum");
     }
 }
+function* readIncrementalTimerOverrunPolicyKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "skipLateTicks";
+        case 2: return "catchUpBounded";
+        case 3: return "delayNextTick";
+        default: fail("timer-overrun-policy-kind enum");
+    }
+}
 function writeTimerOverrunPolicyKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1763,6 +2192,18 @@ function readRelocationRole(reader, context, enclosing, flags) {
         default: fail("relocation-role enum");
     }
 }
+function* readIncrementalRelocationRole(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "source";
+        case 2: return "target";
+        case 3: return "coordinator";
+        default: fail("relocation-role enum");
+    }
+}
 function writeRelocationRole(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1892,6 +2333,29 @@ function readMeshRecordKind(reader, context, enclosing, flags) {
         default: fail("mesh-record-kind enum");
     }
 }
+function* readIncrementalMeshRecordKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "nodeSend";
+        case 2: return "nodeRequest";
+        case 3: return "channelSend";
+        case 4: return "channelRequest";
+        case 5: return "spotSend";
+        case 6: return "spotRequest";
+        case 7: return "spotMulticast";
+        case 8: return "spotControl";
+        case 9: return "actorSend";
+        case 10: return "actorRequest";
+        case 11: return "completion";
+        case 12: return "sendReady";
+        case 13: return "relocationControl";
+        case 14: return "instanceSpotActivation";
+        default: fail("mesh-record-kind enum");
+    }
+}
 function writeMeshRecordKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1922,6 +2386,19 @@ function readFrozenSourceKind(reader, context, enclosing, flags) {
         default: fail("frozen-source-kind enum");
     }
 }
+function* readIncrementalFrozenSourceKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "node";
+        case 2: return "spot";
+        case 3: return "actor";
+        case 4: return "boundSession";
+        default: fail("frozen-source-kind enum");
+    }
+}
 function writeFrozenSourceKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -1954,6 +2431,20 @@ function readMeshDestinationKind(reader, context, enclosing, flags) {
         default: fail("mesh-destination-kind enum");
     }
 }
+function* readIncrementalMeshDestinationKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "node";
+        case 2: return "channel";
+        case 3: return "spot";
+        case 4: return "actor";
+        case 5: return "boundSession";
+        default: fail("mesh-destination-kind enum");
+    }
+}
 function writeMeshDestinationKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2062,6 +2553,20 @@ function readActorLifecycleKind(reader, context, enclosing, flags) {
         default: fail("actor-lifecycle-kind enum");
     }
 }
+function* readIncrementalActorLifecycleKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "created";
+        case 2: return "joined";
+        case 3: return "left";
+        case 4: return "disconnected";
+        case 5: return "destroyed";
+        default: fail("actor-lifecycle-kind enum");
+    }
+}
 function writeActorLifecycleKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2156,6 +2661,25 @@ function readRelocationPhase(reader, context, enclosing, flags) {
         default: fail("relocation-phase enum");
     }
 }
+function* readIncrementalRelocationPhase(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 0: return "none";
+        case 1: return "preparing";
+        case 2: return "captured";
+        case 3: return "prepared";
+        case 4: return "committed";
+        case 5: return "activating";
+        case 6: return "activated";
+        case 7: return "cleaning";
+        case 8: return "completed";
+        case 9: return "aborted";
+        default: fail("relocation-phase enum");
+    }
+}
 function writeRelocationPhase(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2269,11 +2793,36 @@ function enumWireMeshOperationKind(value) {
         case "actorCreate": return 15;
     }
 }
-function readMeshOperationKind(reader, context, enclosing, flags) {
+function readMeshOperationKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = reader.u(4);
+    switch (Number(raw)) {
+        case 0: return "none";
+        case 1: return "nodeRequest";
+        case 2: return "channelRequest";
+        case 3: return "spotRequest";
+        case 4: return "actorRequest";
+        case 5: return "actorLookup";
+        case 6: return "actorDestroy";
+        case 7: return "actorJoin";
+        case 8: return "actorLeave";
+        case 9: return "streamBind";
+        case 10: return "streamUnbind";
+        case 11: return "streamClose";
+        case 12: return "instanceSpotRequest";
+        case 13: return "userSpotCreate";
+        case 14: return "userSpotClose";
+        case 15: return "actorCreate";
+        default: fail("mesh-operation-kind enum");
+    }
+}
+function* readIncrementalMeshOperationKind(reader, context, enclosing, flags) {
     void context;
     void enclosing;
     void flags;
-    const raw = reader.u(4);
+    const raw = yield* reader.u(4);
     switch (Number(raw)) {
         case 0: return "none";
         case 1: return "nodeRequest";
@@ -2344,6 +2893,29 @@ function readRequestTerminalResult(reader, context, enclosing, flags) {
         default: fail("request-terminal-result enum");
     }
 }
+function* readIncrementalRequestTerminalResult(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(4);
+    switch (Number(raw)) {
+        case 0: return "ok";
+        case 101: return "timedOut";
+        case 102: return "notFound";
+        case 103: return "terminated";
+        case 104: return "protocolError";
+        case 105: return "internalError";
+        case 106: return "rejected";
+        case 107: return "conflict";
+        case 108: return "busy";
+        case 109: return "notConnected";
+        case 110: return "invalidArgument";
+        case 111: return "invalidState";
+        case 112: return "notSupported";
+        case 113: return "backpressured";
+        default: fail("request-terminal-result enum");
+    }
+}
 function writeRequestTerminalResult(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2418,6 +2990,41 @@ function readFrameworkErrorCode(reader, context, enclosing, flags) {
         default: fail("framework-error-code enum");
     }
 }
+function* readIncrementalFrameworkErrorCode(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(4);
+    switch (Number(raw)) {
+        case 0: return "none";
+        case 1: return "actorRouteNotFound";
+        case 2: return "actorCreateFailed";
+        case 3: return "actorAlreadyExists";
+        case 4: return "actorTypeMismatch";
+        case 5: return "spotCreateFailed";
+        case 6: return "spotRouteNotFound";
+        case 7: return "spotTypeMismatch";
+        case 8: return "actorSessionNotBound";
+        case 9: return "handlerNotFound";
+        case 10: return "routeHandlerNotFound";
+        case 11: return "actorDispatchHandlerNotFound";
+        case 12: return "payloadDecodeFailed";
+        case 13: return "routeNotConnected";
+        case 14: return "requestTargetNotFound";
+        case 15: return "requestRejected";
+        case 16: return "requestProtocolError";
+        case 17: return "requestFailed";
+        case 18: return "workerQueueFull";
+        case 19: return "workerTimedOut";
+        case 20: return "workerFailed";
+        case 21: return "actorLocationStale";
+        case 22: return "actorCreateRejected";
+        case 33: return "spotGenerationStale";
+        case 34: return "spotMoving";
+        case 35: return "relocationDataLost";
+        default: fail("framework-error-code enum");
+    }
+}
 function writeFrameworkErrorCode(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2444,6 +3051,17 @@ function readInstanceOperationKind(reader, context, enclosing, flags) {
         default: fail("instance-operation-kind enum");
     }
 }
+function* readIncrementalInstanceOperationKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "send";
+        case 2: return "request";
+        default: fail("instance-operation-kind enum");
+    }
+}
 function writeInstanceOperationKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2470,6 +3088,17 @@ function readInstanceRouteKind(reader, context, enclosing, flags) {
         default: fail("instance-route-kind enum");
     }
 }
+function* readIncrementalInstanceRouteKind(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const raw = yield* reader.u(1);
+    switch (Number(raw)) {
+        case 1: return "ready";
+        case 2: return "coldActivation";
+        default: fail("instance-route-kind enum");
+    }
+}
 function writeInstanceRouteKind(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2672,6 +3301,15 @@ function readActorRef(reader, context, enclosing, flags) {
     value["objectGeneration"] = readNonzeroU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalActorRef(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["actorId"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["objectGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    return value;
+}
 function writeActorRef(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2695,6 +3333,15 @@ function readSpotRef(reader, context, enclosing, flags) {
     value["objectGeneration"] = readNonzeroU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalSpotRef(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["spotId"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["objectGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    return value;
+}
 function writeSpotRef(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -2787,6 +3434,9 @@ function readCreationOperationTerminalV1(reader, context, enclosing, flags) {
             fail("creation-operation-terminal-v1 terminal-failure-shape");
         if (value["creation"] !== undefined && same(value["creation"]["createResult"], "existing") && !(same(value["hasApplicationPayload"], "false")))
             fail("creation-operation-terminal-v1 existing-has-no-application-payload");
+        void context;
+        if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+            fail("creation-operation-terminal-v1 runtime predicate");
         return value;
     })();
     if (reader.offset - limitStart > 1048576)
@@ -2805,6 +3455,9 @@ function writeCreationOperationTerminalV1(input, writer, context, enclosing, fla
         fail("creation-operation-terminal-v1 terminal-failure-shape");
     if (value["creation"] !== undefined && same(value["creation"]["createResult"], "existing") && !(same(value["hasApplicationPayload"], "false")))
         fail("creation-operation-terminal-v1 existing-has-no-application-payload");
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+        fail("creation-operation-terminal-v1 runtime predicate");
     writeU8(1, writer, context, enclosing, flags);
     const body = new Writer();
     if (value["terminalResult"] === undefined)
@@ -2890,6 +3543,14 @@ function readSpotMembership(reader, context, enclosing, flags) {
     value["spot"] = readSpotRef(reader, context, value, flags);
     return value;
 }
+function* readIncrementalSpotMembership(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["spot"] = yield* readIncrementalSpotRef(reader, context, value, flags);
+    return value;
+}
 function writeSpotMembership(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -3570,10 +4231,10 @@ function readAggregateParticipantMutationBytes(reader, context, enclosing, flags
     void enclosing;
     void flags;
     const length = Number(readU32(reader, context, enclosing, flags));
-    if (length > 1048576)
-        fail("aggregate-participant-mutation-bytes length");
     if (length > 2147483647)
         capacityFail("aggregate-participant-mutation-bytes capacity");
+    if (length > 1048576)
+        fail("aggregate-participant-mutation-bytes length");
     if (length < 1)
         fail("aggregate-participant-mutation-bytes length");
     return reader.take(length);
@@ -3584,10 +4245,10 @@ function writeAggregateParticipantMutationBytes(input, writer, context, enclosin
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 1048576)
-        fail("aggregate-participant-mutation-bytes length");
     if (bytes.length > 2147483647)
         capacityFail("aggregate-participant-mutation-bytes capacity");
+    if (bytes.length > 1048576)
+        fail("aggregate-participant-mutation-bytes length");
     if (bytes.length < 1)
         fail("aggregate-participant-mutation-bytes length");
     writeU32(bytes.length, writer, context, enclosing, flags);
@@ -3630,13 +4291,18 @@ function readAggregateParticipantVector(reader, context, enclosing, flags) {
     if (count > 1024)
         fail("aggregate-participant-vector count");
     const value = Array.from({ length: count }, () => readMaintenanceAggregateParticipantV1(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareBytes((same(value[index - 1]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index - 1]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[index]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) >= 0)
-            fail("aggregate-participant-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareBytes((same(value[left]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[left]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[left]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[left]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[left]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[left]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[right]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[right]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[right]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[right]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[right]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[right]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) === 0)
-                fail("aggregate-participant-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareBytes((same(value[index - 1]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index - 1]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[index]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) >= 0)
+                fail("aggregate-participant-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("aggregate-participant-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeAggregateParticipantVector(input, writer, context, enclosing, flags) {
@@ -3646,13 +4312,18 @@ function writeAggregateParticipantVector(input, writer, context, enclosing, flag
     const value = input;
     if (!Array.isArray(value) || value.length > 1024)
         fail("aggregate-participant-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareBytes((same(value[index - 1]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index - 1]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[index]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) >= 0)
-            fail("aggregate-participant-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareBytes((same(value[left]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[left]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[left]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[left]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[left]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[left]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[right]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[right]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[right]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[right]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[right]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[right]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) === 0)
-                fail("aggregate-participant-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareBytes((same(value[index - 1]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index - 1]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index - 1]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index - 1]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant")), (same(value[index]["object"]["objectKind"], "actor") ? canonicalAuthorityKey("zla1", ":", "a", [utf8(value[index]["object"]["actor"]["actorId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "userSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spot"]["spotId"])], 1, 255, 776) : same(value[index]["object"]["objectKind"], "instanceSpot") ? canonicalAuthorityKey("zla1", ":", "s", [utf8(value[index]["object"]["spotId"])], 1, 255, 776) : fail("aggregate-participant-vector authority key variant"))) >= 0)
+                fail("aggregate-participant-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("aggregate-participant-vector constraint capacity");
+        throw error;
+    }
     writeU16(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeMaintenanceAggregateParticipantV1(item, writer, context, enclosing, flags);
@@ -3726,6 +4397,18 @@ function readActorRouteFence(reader, context, enclosing, flags) {
     value["expectedOwnerLeaseGeneration"] = readNonzeroU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalActorRouteFence(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["actor"] = yield* readIncrementalActorRef(reader, context, value, flags);
+    value["targetNodeRid"] = yield* readIncrementalRid(reader, context, value, flags);
+    value["targetNodeGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["expectedAuthorityOwnerGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["expectedOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    return value;
+}
 function writeActorRouteFence(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -3761,6 +4444,18 @@ function readSpotRouteFence(reader, context, enclosing, flags) {
     value["expectedOwnerLeaseGeneration"] = readNonzeroU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalSpotRouteFence(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["spot"] = yield* readIncrementalSpotRef(reader, context, value, flags);
+    value["targetNodeRid"] = yield* readIncrementalRid(reader, context, value, flags);
+    value["targetNodeGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["expectedAuthorityOwnerGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["expectedOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    return value;
+}
 function writeSpotRouteFence(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -3977,6 +4672,31 @@ function readRelocationObjectIdentity(reader, context, enclosing, flags) {
     body.done("relocation-object-identity");
     return value;
 }
+function* readIncrementalRelocationObjectIdentity(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["objectKind"] = yield* readIncrementalStatefulObjectKind(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["objectKind"], "actor")) {
+        value["actor"] = yield* readIncrementalActorRef(body, context, value, flags);
+        value["expectedAuthorityOwnerGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["objectKind"], "userSpot")) {
+        value["spot"] = yield* readIncrementalSpotRef(body, context, value, flags);
+        value["expectedAuthorityOwnerGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["objectKind"], "instanceSpot")) {
+        value["instanceType"] = yield* readIncrementalText8(body, context, value, flags);
+        value["spotId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["objectGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else
+        fail("relocation-object-identity discriminator");
+    body.done("relocation-object-identity");
+    return value;
+}
 function writeRelocationObjectIdentity(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -4291,6 +5011,15 @@ function readOperationIdOrZero(reader, context, enclosing, flags) {
     value["low"] = readU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalOperationIdOrZero(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["high"] = yield* readIncrementalU64(reader, context, value, flags);
+    value["low"] = yield* readIncrementalU64(reader, context, value, flags);
+    return value;
+}
 function writeOperationIdOrZero(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -4310,10 +5039,10 @@ function readCreationContentReference(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 4096)
-        fail("creation-content-reference length");
     if (length > 2147483647)
         capacityFail("creation-content-reference capacity");
+    if (length > 4096)
+        fail("creation-content-reference length");
     if (length < 1)
         fail("creation-content-reference length");
     const bytes = reader.take(length);
@@ -4329,10 +5058,10 @@ function writeCreationContentReference(input, writer, context, enclosing, flags)
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("creation-content-reference NUL");
-    if (bytes.length > 4096)
-        fail("creation-content-reference length");
     if (bytes.length > 2147483647)
         capacityFail("creation-content-reference capacity");
+    if (bytes.length > 4096)
+        fail("creation-content-reference length");
     if (bytes.length < 1)
         fail("creation-content-reference length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -4345,10 +5074,10 @@ function readRelocationReference(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 4096)
-        fail("relocation-reference length");
     if (length > 2147483647)
         capacityFail("relocation-reference capacity");
+    if (length > 4096)
+        fail("relocation-reference length");
     if (length < 1)
         fail("relocation-reference length");
     const bytes = reader.take(length);
@@ -4364,10 +5093,10 @@ function writeRelocationReference(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("relocation-reference NUL");
-    if (bytes.length > 4096)
-        fail("relocation-reference length");
     if (bytes.length > 2147483647)
         capacityFail("relocation-reference capacity");
+    if (bytes.length > 4096)
+        fail("relocation-reference length");
     if (bytes.length < 1)
         fail("relocation-reference length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -4380,10 +5109,10 @@ function readAuthorityStoreVersion(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU16(reader, context, enclosing, flags));
-    if (length > 4096)
-        fail("authority-store-version length");
     if (length > 2147483647)
         capacityFail("authority-store-version capacity");
+    if (length > 4096)
+        fail("authority-store-version length");
     if (length < 1)
         fail("authority-store-version length");
     const bytes = reader.take(length);
@@ -4391,6 +5120,19 @@ function readAuthorityStoreVersion(reader, context, enclosing, flags) {
         fail("authority-store-version NUL");
     return decodeUtf8(bytes, "authority-store-version");
 }
+function* readIncrementalAuthorityStoreVersion(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU16(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("authority-store-version capacity");
+    if (length > 4096)
+        fail("authority-store-version length");
+    if (length < 1)
+        fail("authority-store-version length");
+    return yield* reader.text(length, true, "authority-store-version");
+}
 function writeAuthorityStoreVersion(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -4399,10 +5141,10 @@ function writeAuthorityStoreVersion(input, writer, context, enclosing, flags) {
     const bytes = utf8(value);
     if (bytes.includes(0))
         fail("authority-store-version NUL");
-    if (bytes.length > 4096)
-        fail("authority-store-version length");
     if (bytes.length > 2147483647)
         capacityFail("authority-store-version capacity");
+    if (bytes.length > 4096)
+        fail("authority-store-version length");
     if (bytes.length < 1)
         fail("authority-store-version length");
     writeU16(bytes.length, writer, context, enclosing, flags);
@@ -4422,6 +5164,18 @@ function readAuthorityGenerationFence(reader, context, enclosing, flags) {
     value["storeVersion"] = readAuthorityStoreVersion(reader, context, value, flags);
     return value;
 }
+function* readIncrementalAuthorityGenerationFence(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["objectGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["ownerId"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["authorityOwnerGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["leaseGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["storeVersion"] = yield* readIncrementalAuthorityStoreVersion(reader, context, value, flags);
+    return value;
+}
 function writeAuthorityGenerationFence(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -4553,6 +5307,17 @@ function readRelocationId(reader, context, enclosing, flags) {
         fail("relocation-id all zero");
     return value;
 }
+function* readIncrementalRelocationId(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["high"] = yield* readIncrementalU64(reader, context, value, flags);
+    value["low"] = yield* readIncrementalU64(reader, context, value, flags);
+    if (numeric(value["high"]) === 0n && numeric(value["low"]) === 0n)
+        fail("relocation-id all zero");
+    return value;
+}
 function writeRelocationId(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -4658,13 +5423,18 @@ function readChannelVector(reader, context, enclosing, flags) {
     void flags;
     const count = Number(readU16(reader, context, enclosing, flags));
     const value = Array.from({ length: count }, () => readChannelEntry(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBytes(utf8(value[index - 1]["channelName"]), utf8(value[index]["channelName"]))]) >= 0)
-            fail("channel-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBytes(utf8(value[left]["channelName"]), utf8(value[right]["channelName"]))]) === 0)
-                fail("channel-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBytes(utf8(value[index - 1]["channelName"]), utf8(value[index]["channelName"]))]) >= 0)
+                fail("channel-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("channel-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeChannelVector(input, writer, context, enclosing, flags) {
@@ -4674,13 +5444,18 @@ function writeChannelVector(input, writer, context, enclosing, flags) {
     const value = input;
     if (!Array.isArray(value))
         fail("channel-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBytes(utf8(value[index - 1]["channelName"]), utf8(value[index]["channelName"]))]) >= 0)
-            fail("channel-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBytes(utf8(value[left]["channelName"]), utf8(value[right]["channelName"]))]) === 0)
-                fail("channel-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBytes(utf8(value[index - 1]["channelName"]), utf8(value[index]["channelName"]))]) >= 0)
+                fail("channel-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("channel-vector constraint capacity");
+        throw error;
+    }
     writeU16(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeChannelEntry(item, writer, context, enclosing, flags);
@@ -4695,13 +5470,18 @@ function readSortedText8Vector(reader, context, enclosing, flags) {
     if (count > 1024)
         fail("sorted-text8-vector count");
     const value = Array.from({ length: count }, () => readText8(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBytes(utf8(value[index - 1]), utf8(value[index]))]) >= 0)
-            fail("sorted-text8-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBytes(utf8(value[left]), utf8(value[right]))]) === 0)
-                fail("sorted-text8-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBytes(utf8(value[index - 1]), utf8(value[index]))]) >= 0)
+                fail("sorted-text8-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("sorted-text8-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeSortedText8Vector(input, writer, context, enclosing, flags) {
@@ -4711,13 +5491,18 @@ function writeSortedText8Vector(input, writer, context, enclosing, flags) {
     const value = input;
     if (!Array.isArray(value) || value.length > 1024)
         fail("sorted-text8-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBytes(utf8(value[index - 1]), utf8(value[index]))]) >= 0)
-            fail("sorted-text8-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBytes(utf8(value[left]), utf8(value[right]))]) === 0)
-                fail("sorted-text8-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBytes(utf8(value[index - 1]), utf8(value[index]))]) >= 0)
+                fail("sorted-text8-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("sorted-text8-vector constraint capacity");
+        throw error;
+    }
     writeU16(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeText8(item, writer, context, enclosing, flags);
@@ -4775,13 +5560,18 @@ function readStatefulCapabilityVector(reader, context, enclosing, flags) {
     if (count > 1024)
         fail("stateful-capability-vector count");
     const value = Array.from({ length: count }, () => readStatefulCapabilityEntry(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[index - 1]["objectKind"])), numeric(enumWireStatefulObjectKind(value[index]["objectKind"]))), compareBytes(utf8(value[index - 1]["type"]), utf8(value[index]["type"]))]) >= 0)
-            fail("stateful-capability-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[left]["objectKind"])), numeric(enumWireStatefulObjectKind(value[right]["objectKind"]))), compareBytes(utf8(value[left]["type"]), utf8(value[right]["type"]))]) === 0)
-                fail("stateful-capability-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[index - 1]["objectKind"])), numeric(enumWireStatefulObjectKind(value[index]["objectKind"]))), compareBytes(utf8(value[index - 1]["type"]), utf8(value[index]["type"]))]) >= 0)
+                fail("stateful-capability-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("stateful-capability-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeStatefulCapabilityVector(input, writer, context, enclosing, flags) {
@@ -4791,13 +5581,18 @@ function writeStatefulCapabilityVector(input, writer, context, enclosing, flags)
     const value = input;
     if (!Array.isArray(value) || value.length > 1024)
         fail("stateful-capability-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[index - 1]["objectKind"])), numeric(enumWireStatefulObjectKind(value[index]["objectKind"]))), compareBytes(utf8(value[index - 1]["type"]), utf8(value[index]["type"]))]) >= 0)
-            fail("stateful-capability-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[left]["objectKind"])), numeric(enumWireStatefulObjectKind(value[right]["objectKind"]))), compareBytes(utf8(value[left]["type"]), utf8(value[right]["type"]))]) === 0)
-                fail("stateful-capability-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(enumWireStatefulObjectKind(value[index - 1]["objectKind"])), numeric(enumWireStatefulObjectKind(value[index]["objectKind"]))), compareBytes(utf8(value[index - 1]["type"]), utf8(value[index]["type"]))]) >= 0)
+                fail("stateful-capability-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("stateful-capability-vector constraint capacity");
+        throw error;
+    }
     writeU16(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeStatefulCapabilityEntry(item, writer, context, enclosing, flags);
@@ -5402,6 +6197,34 @@ function readSendReadyDestination(reader, context, enclosing, flags) {
     body.done("send-ready-destination");
     return value;
 }
+function* readIncrementalSendReadyDestination(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["destinationKind"] = yield* readIncrementalMeshDestinationKind(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["destinationKind"], "node")) {
+        value["targetNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+    }
+    else if (same(value["destinationKind"], "channel")) {
+        value["channelName"] = yield* readIncrementalText8(body, context, value, flags);
+    }
+    else if (same(value["destinationKind"], "spot")) {
+        value["targetSpot"] = yield* readIncrementalSpotRouteFence(body, context, value, flags);
+    }
+    else if (same(value["destinationKind"], "actor")) {
+        value["targetActor"] = yield* readIncrementalActorRouteFence(body, context, value, flags);
+    }
+    else if (same(value["destinationKind"], "boundSession")) {
+        value["targetActor"] = yield* readIncrementalActorRouteFence(body, context, value, flags);
+        value["bindingGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else
+        fail("send-ready-destination discriminator");
+    body.done("send-ready-destination");
+    return value;
+}
 function writeSendReadyDestination(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -5464,6 +6287,15 @@ function readActorMembershipSnapshot(reader, context, enclosing, flags) {
     value["membership"] = readSpotMembership(reader, context, value, flags);
     return value;
 }
+function* readIncrementalActorMembershipSnapshot(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["actor"] = yield* readIncrementalActorRef(reader, context, value, flags);
+    value["membership"] = yield* readIncrementalSpotMembership(reader, context, value, flags);
+    return value;
+}
 function writeActorMembershipSnapshot(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -5495,6 +6327,23 @@ function readOptionalActorMembershipSnapshot(reader, context, enclosing, flags)
     body.done("optional-actor-membership-snapshot");
     return value;
 }
+function* readIncrementalOptionalActorMembershipSnapshot(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["hasSnapshot"] = yield* readIncrementalBool8(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["hasSnapshot"], "false")) {
+    }
+    else if (same(value["hasSnapshot"], "true")) {
+        value["snapshot"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+    }
+    else
+        fail("optional-actor-membership-snapshot discriminator");
+    body.done("optional-actor-membership-snapshot");
+    return value;
+}
 function writeOptionalActorMembershipSnapshot(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -5538,10 +6387,39 @@ function readActorControlData(reader, context, enclosing, flags) {
         value["current"] = readActorMembershipSnapshot(body, context, value, flags);
     }
     else if (same(value["lifecycleKind"], "disconnected")) {
-        value["current"] = readActorMembershipSnapshot(body, context, value, flags);
+        value["current"] = readActorMembershipSnapshot(body, context, value, flags);
+    }
+    else if (same(value["lifecycleKind"], "destroyed")) {
+        value["previous"] = readActorMembershipSnapshot(body, context, value, flags);
+    }
+    else
+        fail("actor-control-data discriminator");
+    body.done("actor-control-data");
+    return value;
+}
+function* readIncrementalActorControlData(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["lifecycleKind"] = yield* readIncrementalActorLifecycleKind(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["lifecycleKind"], "created")) {
+        value["current"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+    }
+    else if (same(value["lifecycleKind"], "joined")) {
+        value["previous"] = yield* readIncrementalOptionalActorMembershipSnapshot(body, context, value, flags);
+        value["current"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+    }
+    else if (same(value["lifecycleKind"], "left")) {
+        value["previous"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+        value["current"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+    }
+    else if (same(value["lifecycleKind"], "disconnected")) {
+        value["current"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
     }
     else if (same(value["lifecycleKind"], "destroyed")) {
-        value["previous"] = readActorMembershipSnapshot(body, context, value, flags);
+        value["previous"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
     }
     else
         fail("actor-control-data discriminator");
@@ -5611,7 +6489,24 @@ function readRelocationControlData(reader, context, enclosing, flags) {
     value["object"] = readRelocationObjectIdentity(reader, context, value, flags);
     value["terminalResult"] = readRequestTerminalResult(reader, context, value, flags);
     value["failureCode"] = readFrameworkErrorCode(reader, context, value, flags);
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+        fail("relocation-control-data runtime predicate");
+    return value;
+}
+function* readIncrementalRelocationControlData(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["phase"] = yield* readIncrementalRelocationPhase(reader, context, value, flags);
+    value["role"] = yield* readIncrementalRelocationRole(reader, context, value, flags);
+    value["relocation"] = yield* readIncrementalRelocationId(reader, context, value, flags);
+    value["object"] = yield* readIncrementalRelocationObjectIdentity(reader, context, value, flags);
+    value["terminalResult"] = yield* readIncrementalRequestTerminalResult(reader, context, value, flags);
+    value["failureCode"] = yield* readIncrementalFrameworkErrorCode(reader, context, value, flags);
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("relocation-control-data runtime predicate");
     return value;
 }
@@ -5620,7 +6515,8 @@ function writeRelocationControlData(input, writer, context, enclosing, flags) {
     void enclosing;
     void flags;
     const value = input;
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("relocation-control-data runtime predicate");
     if (value["phase"] === undefined)
         fail("phase required");
@@ -5804,6 +6700,8 @@ function readFrozenRecordBody(reader, context, enclosing, flags) {
         if (same(value["hasPayload"], "true")) {
             value["payload"] = readApplicationPayloadEnvelopeV1(body, context, value, flags);
         }
+        if (!validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))
+            fail("terminal failure predicate");
     }
     else if (same(value["recordKind"], "sendReady")) {
         value["destination"] = readSendReadyDestination(body, context, value, flags);
@@ -5819,8 +6717,77 @@ function readFrozenRecordBody(reader, context, enclosing, flags) {
     }
     else
         fail("frozen-record-body discriminator");
-    if (same(value["recordKind"], "completion") && !(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
-        fail("frozen-record-body runtime predicate");
+    return value;
+}
+function* readIncrementalFrozenRecordBody(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["recordKind"] = enclosing["recordKind"];
+    const body = reader;
+    if (same(value["recordKind"], "nodeSend")) {
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "nodeRequest")) {
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "channelSend")) {
+        value["channelName"] = yield* readIncrementalText8(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "channelRequest")) {
+        value["channelName"] = yield* readIncrementalText8(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "spotSend")) {
+        value["targetSpot"] = yield* readIncrementalSpotRouteFence(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "spotRequest")) {
+        value["targetSpot"] = yield* readIncrementalSpotRouteFence(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "spotMulticast")) {
+        value["channelName"] = yield* readIncrementalText8(body, context, value, flags);
+        value["topic"] = yield* readIncrementalText8(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "spotControl")) {
+        value["control"] = yield* readIncrementalActorControlData(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "actorSend")) {
+        value["targetActor"] = yield* readIncrementalActorRouteFence(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "actorRequest")) {
+        value["targetActor"] = yield* readIncrementalActorRouteFence(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "completion")) {
+        value["terminalResult"] = yield* readIncrementalRequestTerminalResult(body, context, value, flags);
+        value["failureCode"] = yield* readIncrementalFrameworkErrorCode(body, context, value, flags);
+        value["hasPayload"] = yield* readIncrementalBool8(body, context, value, flags);
+        if (same(value["hasPayload"], "true")) {
+            value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+        }
+        if (!validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))
+            fail("terminal failure predicate");
+    }
+    else if (same(value["recordKind"], "sendReady")) {
+        value["destination"] = yield* readIncrementalSendReadyDestination(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "relocationControl")) {
+        value["control"] = yield* readIncrementalRelocationControlData(body, context, value, flags);
+    }
+    else if (same(value["recordKind"], "instanceSpotActivation")) {
+        value["route"] = yield* readIncrementalInstanceRouteV1(body, context, value, flags);
+        value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["operationKind"] = yield* readIncrementalInstanceOperationKind(body, context, value, flags);
+        value["payload"] = yield* readIncrementalApplicationPayloadEnvelopeV1(body, context, value, flags);
+    }
+    else
+        fail("frozen-record-body discriminator");
     return value;
 }
 function writeFrozenRecordBody(input, writer, context, enclosing, flags) {
@@ -5828,8 +6795,6 @@ function writeFrozenRecordBody(input, writer, context, enclosing, flags) {
     void enclosing;
     void flags;
     const value = input;
-    if (same(value["recordKind"], "completion") && !(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
-        fail("frozen-record-body runtime predicate");
     const body = writer;
     if (same(value["recordKind"], "nodeSend")) {
         if (value["channelName"] !== undefined || value["targetSpot"] !== undefined || value["topic"] !== undefined || value["control"] !== undefined || value["targetActor"] !== undefined || value["terminalResult"] !== undefined || value["failureCode"] !== undefined || value["hasPayload"] !== undefined || value["destination"] !== undefined || value["route"] !== undefined || value["sourceNodeGeneration"] !== undefined || value["operationKind"] !== undefined)
@@ -5944,6 +6909,8 @@ function writeFrozenRecordBody(input, writer, context, enclosing, flags) {
         }
         else if (value["payload"] !== undefined)
             fail("payload forbidden");
+        if (!validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))
+            fail("terminal failure predicate");
     }
     else if (same(value["recordKind"], "sendReady")) {
         if (value["payload"] !== undefined || value["channelName"] !== undefined || value["targetSpot"] !== undefined || value["topic"] !== undefined || value["control"] !== undefined || value["targetActor"] !== undefined || value["terminalResult"] !== undefined || value["failureCode"] !== undefined || value["hasPayload"] !== undefined || value["route"] !== undefined || value["sourceNodeGeneration"] !== undefined || value["operationKind"] !== undefined)
@@ -6022,6 +6989,48 @@ function readFrozenSourceIdentity(reader, context, enclosing, flags) {
     body.done("frozen-source-identity");
     return value;
 }
+function* readIncrementalFrozenSourceIdentity(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["sourceKind"] = yield* readIncrementalFrozenSourceKind(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["sourceKind"], "node")) {
+        value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["sourceKind"], "spot")) {
+        value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceSpotId"] = yield* readIncrementalText8(body, context, value, flags);
+    }
+    else if (same(value["sourceKind"], "actor")) {
+        value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceActor"] = yield* readIncrementalActorRef(body, context, value, flags);
+    }
+    else if (same(value["sourceKind"], "boundSession")) {
+        value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceActor"] = yield* readIncrementalActorRef(body, context, value, flags);
+        value["sourceSessionRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["sourceBindingGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["sourceSessionSequence"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else
+        fail("frozen-source-identity discriminator");
+    body.done("frozen-source-identity");
+    return value;
+}
 function writeFrozenSourceIdentity(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6146,6 +7155,33 @@ function readFrozenReplyRoute(reader, context, enclosing, flags) {
     body.done("frozen-reply-route");
     return value;
 }
+function* readIncrementalFrozenReplyRoute(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["originalOperationKind"] = enclosing["operationKind"];
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["originalOperationKind"], "nodeRequest")) {
+        value["replyRouteId"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["originalOperationKind"], "channelRequest")) {
+        value["replyRouteId"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["originalOperationKind"], "spotRequest")) {
+        value["replyRouteId"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["originalOperationKind"], "actorRequest")) {
+        value["replyRouteId"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else if (same(value["originalOperationKind"], "instanceSpotRequest")) {
+        value["replyRouteId"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else {
+    }
+    body.done("frozen-reply-route");
+    return value;
+}
 function writeFrozenReplyRoute(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6204,6 +7240,23 @@ function readFrozenRecord(reader, context, enclosing, flags) {
     value["body"] = readFrozenRecordBody(reader, context, value, flags);
     return value;
 }
+function* readIncrementalFrozenRecord(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["recordKind"] = yield* readIncrementalMeshRecordKind(reader, context, value, flags);
+    value["source"] = yield* readIncrementalFrozenSourceIdentity(reader, context, value, flags);
+    value["hasMetadata"] = yield* readIncrementalBool8(reader, context, value, flags);
+    if (same(value["hasMetadata"], "true")) {
+        value["metadata"] = yield* readIncrementalMetadataFrame(reader, context, value, flags);
+    }
+    value["operationId"] = yield* readIncrementalOperationIdOrZero(reader, context, value, flags);
+    value["operationKind"] = yield* readIncrementalMeshOperationKind(reader, context, value, flags);
+    value["replyRoute"] = yield* readIncrementalFrozenReplyRoute(reader, context, value, flags);
+    value["body"] = yield* readIncrementalFrozenRecordBody(reader, context, value, flags);
+    return value;
+}
 function writeFrozenRecord(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6267,6 +7320,33 @@ function readInstanceRouteV1(reader, context, enclosing, flags) {
     body.done("instance-route-v1");
     return value;
 }
+function* readIncrementalInstanceRouteV1(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["routeKind"] = yield* readIncrementalInstanceRouteKind(reader, context, enclosing, flags);
+    const body = reader.bounded(Number(yield* readIncrementalU16(reader, context, enclosing, flags)));
+    if (same(value["routeKind"], "ready")) {
+        value["targetNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["targetNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["targetSpotId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["authority"] = yield* readIncrementalAuthorityGenerationFence(body, context, value, flags);
+    }
+    else if (same(value["routeKind"], "coldActivation")) {
+        value["targetNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
+        value["targetNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+        value["targetSpotId"] = yield* readIncrementalText8(body, context, value, flags);
+        value["targetMeshName"] = yield* readIncrementalText8(body, context, value, flags);
+        value["stableType"] = yield* readIncrementalText8(body, context, value, flags);
+        value["targetDescriptorVersion"] = yield* readIncrementalText8(body, context, value, flags);
+        value["deadlineUnixMs"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
+    }
+    else
+        fail("instance-route-v1 discriminator");
+    body.done("instance-route-v1");
+    return value;
+}
 function writeInstanceRouteV1(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6624,6 +7704,16 @@ function readSavedWorkEntry(reader, context, enclosing, flags) {
     value["record"] = readFrozenRecord(reader, context, value, flags);
     return value;
 }
+function* readIncrementalSavedWorkEntry(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["participantId"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["order"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["record"] = yield* readIncrementalFrozenRecord(reader, context, value, flags);
+    return value;
+}
 function writeSavedWorkEntry(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6647,13 +7737,47 @@ function readSavedWorkVector(reader, context, enclosing, flags) {
     void flags;
     const count = Number(readU32(reader, context, enclosing, flags));
     const value = Array.from({ length: count }, () => readSavedWorkEntry(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("saved-work-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"])), compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("saved-work-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("saved-work-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("saved-work-vector constraint capacity");
+        throw error;
+    }
+    return value;
+}
+function* readIncrementalSavedWorkVector(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
+    const value = [];
+    for (let index = 0; index < count; ++index) {
+        const item = yield* readIncrementalSavedWorkEntry(reader, context, enclosing, flags);
+        try {
+            value.push(item);
+        }
+        catch {
+            capacityFail("saved-work-vector capacity");
+        }
+    }
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("saved-work-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("saved-work-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeSavedWorkVector(input, writer, context, enclosing, flags) {
@@ -6663,13 +7787,18 @@ function writeSavedWorkVector(input, writer, context, enclosing, flags) {
     const value = input;
     if (!Array.isArray(value))
         fail("saved-work-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("saved-work-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"])), compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("saved-work-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("saved-work-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("saved-work-vector constraint capacity");
+        throw error;
+    }
     writeU32(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeSavedWorkEntry(item, writer, context, enclosing, flags);
@@ -6681,10 +7810,10 @@ function readDurableBlob(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU32(reader, context, enclosing, flags));
-    if (length > 67108864)
-        fail("durable-blob length");
     if (length > 2147483647)
         capacityFail("durable-blob capacity");
+    if (length > 67108864)
+        fail("durable-blob length");
     if (length < 0)
         fail("durable-blob length");
     return reader.take(length);
@@ -6695,10 +7824,10 @@ function writeDurableBlob(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 67108864)
-        fail("durable-blob length");
     if (bytes.length > 2147483647)
         capacityFail("durable-blob capacity");
+    if (bytes.length > 67108864)
+        fail("durable-blob length");
     if (bytes.length < 0)
         fail("durable-blob length");
     writeU32(bytes.length, writer, context, enclosing, flags);
@@ -6711,13 +7840,26 @@ function readDurableStateBlob(reader, context, enclosing, flags) {
     void enclosing;
     void flags;
     const length = Number(readU64(reader, context, enclosing, flags));
+    if (length > 2147483647)
+        capacityFail("durable-state-blob capacity");
     if (length > 67108864)
         fail("durable-state-blob length");
+    if (length < 0)
+        fail("durable-state-blob length");
+    return reader.take(length);
+}
+function* readIncrementalDurableStateBlob(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const length = Number(yield* readIncrementalU64(reader, context, enclosing, flags));
     if (length > 2147483647)
         capacityFail("durable-state-blob capacity");
+    if (length > 67108864)
+        fail("durable-state-blob length");
     if (length < 0)
         fail("durable-state-blob length");
-    return reader.take(length);
+    return yield* reader.bytes(length);
 }
 function writeDurableStateBlob(input, writer, context, enclosing, flags) {
     void context;
@@ -6725,10 +7867,10 @@ function writeDurableStateBlob(input, writer, context, enclosing, flags) {
     void flags;
     const value = input;
     const bytes = value;
-    if (bytes.length > 67108864)
-        fail("durable-state-blob length");
     if (bytes.length > 2147483647)
         capacityFail("durable-state-blob capacity");
+    if (bytes.length > 67108864)
+        fail("durable-state-blob length");
     if (bytes.length < 0)
         fail("durable-state-blob length");
     writeU64(numeric(bytes.length), writer, context, enclosing, flags);
@@ -6775,13 +7917,18 @@ function readRelocationChunkVectorV1(reader, context, enclosing, flags) {
     if (count > 4096)
         fail("relocation-chunk-vector-v1 count");
     const value = Array.from({ length: count }, () => readRelocationChunkEntryV1(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("relocation-chunk-vector-v1 sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("relocation-chunk-vector-v1 unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("relocation-chunk-vector-v1 sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-chunk-vector-v1 constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeRelocationChunkVectorV1(input, writer, context, enclosing, flags) {
@@ -6791,13 +7938,18 @@ function writeRelocationChunkVectorV1(input, writer, context, enclosing, flags)
     const value = input;
     if (!Array.isArray(value) || value.length > 4096)
         fail("relocation-chunk-vector-v1 count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("relocation-chunk-vector-v1 sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("relocation-chunk-vector-v1 unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("relocation-chunk-vector-v1 sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-chunk-vector-v1 constraint capacity");
+        throw error;
+    }
     writeU32(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeRelocationChunkEntryV1(item, writer, context, enclosing, flags);
@@ -6889,6 +8041,29 @@ function readRelocationApplicationState(reader, context, enclosing, flags) {
         fail("relocation-application-state maximum");
     return decoded;
 }
+function* readIncrementalRelocationApplicationState(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const limitStart = reader.offset;
+    const decoded = yield* (function* () {
+        const value = {};
+        value["hasState"] = yield* readIncrementalBool8(reader, context, enclosing, flags);
+        const body = reader.bounded(Number(yield* readIncrementalU64(reader, context, enclosing, flags)));
+        if (same(value["hasState"], "false")) {
+        }
+        else if (same(value["hasState"], "true")) {
+            value["payload"] = yield* readIncrementalDurableStateBlob(body, context, value, flags);
+        }
+        else
+            fail("relocation-application-state discriminator");
+        body.done("relocation-application-state");
+        return value;
+    })();
+    if (reader.offset - limitStart > 274877906944)
+        fail("relocation-application-state maximum");
+    return decoded;
+}
 function writeRelocationApplicationState(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6925,6 +8100,15 @@ function readRelocationParticipantApplicationState(reader, context, enclosing, f
     value["applicationState"] = readRelocationApplicationState(reader, context, value, flags);
     return value;
 }
+function* readIncrementalRelocationParticipantApplicationState(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["participantId"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["applicationState"] = yield* readIncrementalRelocationApplicationState(reader, context, value, flags);
+    return value;
+}
 function writeRelocationParticipantApplicationState(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -6947,13 +8131,49 @@ function readRelocationParticipantApplicationStateVector(reader, context, enclos
     if (count > 1024)
         fail("relocation-participant-application-state-vector count");
     const value = Array.from({ length: count }, () => readRelocationParticipantApplicationState(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"]))]) >= 0)
-            fail("relocation-participant-application-state-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"]))]) === 0)
-                fail("relocation-participant-application-state-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"]))]) >= 0)
+                fail("relocation-participant-application-state-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-participant-application-state-vector constraint capacity");
+        throw error;
+    }
+    return value;
+}
+function* readIncrementalRelocationParticipantApplicationStateVector(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
+    if (count > 1024)
+        fail("relocation-participant-application-state-vector count");
+    const value = [];
+    for (let index = 0; index < count; ++index) {
+        const item = yield* readIncrementalRelocationParticipantApplicationState(reader, context, enclosing, flags);
+        try {
+            value.push(item);
+        }
+        catch {
+            capacityFail("relocation-participant-application-state-vector capacity");
+        }
+    }
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"]))]) >= 0)
+                fail("relocation-participant-application-state-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-participant-application-state-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeRelocationParticipantApplicationStateVector(input, writer, context, enclosing, flags) {
@@ -6963,13 +8183,18 @@ function writeRelocationParticipantApplicationStateVector(input, writer, context
     const value = input;
     if (!Array.isArray(value) || value.length > 1024)
         fail("relocation-participant-application-state-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"]))]) >= 0)
-            fail("relocation-participant-application-state-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"]))]) === 0)
-                fail("relocation-participant-application-state-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"]))]) >= 0)
+                fail("relocation-participant-application-state-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-participant-application-state-vector constraint capacity");
+        throw error;
+    }
     writeU32(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeRelocationParticipantApplicationState(item, writer, context, enclosing, flags);
@@ -6993,6 +8218,23 @@ function readRelocationTimerRegistration(reader, context, enclosing, flags) {
     value["nextScheduledAtUnixMilliseconds"] = readU64(reader, context, value, flags);
     return value;
 }
+function* readIncrementalRelocationTimerRegistration(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["participantId"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["name"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["handlerType"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["periodMilliseconds"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["overrunPolicy"] = yield* readIncrementalTimerOverrunPolicyKind(reader, context, value, flags);
+    value["maxCatchUpTicks"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["stopOnUnhandledException"] = yield* readIncrementalBool8(reader, context, value, flags);
+    value["lastCompletedDeliveryIndex"] = yield* readIncrementalOrdinalOrZero(reader, context, value, flags);
+    value["lastCompletedScheduledIndex"] = yield* readIncrementalOrdinalOrZero(reader, context, value, flags);
+    value["nextScheduledAtUnixMilliseconds"] = yield* readIncrementalU64(reader, context, value, flags);
+    return value;
+}
 function writeRelocationTimerRegistration(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -7037,13 +8279,47 @@ function readRelocationTimerRegistrationVector(reader, context, enclosing, flags
     void flags;
     const count = Number(readU32(reader, context, enclosing, flags));
     const value = Array.from({ length: count }, () => readRelocationTimerRegistration(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(numeric(value[index - 1]["participantId"])), numeric(numeric(value[index]["participantId"]))), compareBytes(utf8(value[index - 1]["name"]), utf8(value[index]["name"]))]) >= 0)
-            fail("relocation-timer-registration-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(numeric(value[left]["participantId"])), numeric(numeric(value[right]["participantId"]))), compareBytes(utf8(value[left]["name"]), utf8(value[right]["name"]))]) === 0)
-                fail("relocation-timer-registration-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(numeric(value[index - 1]["participantId"])), numeric(numeric(value[index]["participantId"]))), compareBytes(utf8(value[index - 1]["name"]), utf8(value[index]["name"]))]) >= 0)
+                fail("relocation-timer-registration-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-timer-registration-vector constraint capacity");
+        throw error;
+    }
+    return value;
+}
+function* readIncrementalRelocationTimerRegistrationVector(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
+    const value = [];
+    for (let index = 0; index < count; ++index) {
+        const item = yield* readIncrementalRelocationTimerRegistration(reader, context, enclosing, flags);
+        try {
+            value.push(item);
+        }
+        catch {
+            capacityFail("relocation-timer-registration-vector capacity");
+        }
+    }
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(numeric(value[index - 1]["participantId"])), numeric(numeric(value[index]["participantId"]))), compareBytes(utf8(value[index - 1]["name"]), utf8(value[index]["name"]))]) >= 0)
+                fail("relocation-timer-registration-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-timer-registration-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeRelocationTimerRegistrationVector(input, writer, context, enclosing, flags) {
@@ -7053,13 +8329,18 @@ function writeRelocationTimerRegistrationVector(input, writer, context, enclosin
     const value = input;
     if (!Array.isArray(value))
         fail("relocation-timer-registration-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(numeric(value[index - 1]["participantId"])), numeric(numeric(value[index]["participantId"]))), compareBytes(utf8(value[index - 1]["name"]), utf8(value[index]["name"]))]) >= 0)
-            fail("relocation-timer-registration-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(numeric(value[left]["participantId"])), numeric(numeric(value[right]["participantId"]))), compareBytes(utf8(value[left]["name"]), utf8(value[right]["name"]))]) === 0)
-                fail("relocation-timer-registration-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(numeric(value[index - 1]["participantId"])), numeric(numeric(value[index]["participantId"]))), compareBytes(utf8(value[index - 1]["name"]), utf8(value[index]["name"]))]) >= 0)
+                fail("relocation-timer-registration-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-timer-registration-vector constraint capacity");
+        throw error;
+    }
     writeU32(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeRelocationTimerRegistration(item, writer, context, enclosing, flags);
@@ -7080,6 +8361,20 @@ function readRelocationPendingTimerTick(reader, context, enclosing, flags) {
     value["skippedTicks"] = readOrdinalOrZero(reader, context, value, flags);
     return value;
 }
+function* readIncrementalRelocationPendingTimerTick(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["participantId"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["order"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["timerName"] = yield* readIncrementalText8(reader, context, value, flags);
+    value["deliveryIndex"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["scheduledIndex"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+    value["scheduledAtUnixMilliseconds"] = yield* readIncrementalU64(reader, context, value, flags);
+    value["skippedTicks"] = yield* readIncrementalOrdinalOrZero(reader, context, value, flags);
+    return value;
+}
 function writeRelocationPendingTimerTick(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -7115,13 +8410,47 @@ function readRelocationPendingTimerTickVector(reader, context, enclosing, flags)
     void flags;
     const count = Number(readU32(reader, context, enclosing, flags));
     const value = Array.from({ length: count }, () => readRelocationPendingTimerTick(reader, context, enclosing, flags));
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("relocation-pending-timer-tick-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"])), compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("relocation-pending-timer-tick-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("relocation-pending-timer-tick-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-pending-timer-tick-vector constraint capacity");
+        throw error;
+    }
+    return value;
+}
+function* readIncrementalRelocationPendingTimerTickVector(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));
+    const value = [];
+    for (let index = 0; index < count; ++index) {
+        const item = yield* readIncrementalRelocationPendingTimerTick(reader, context, enclosing, flags);
+        try {
+            value.push(item);
+        }
+        catch {
+            capacityFail("relocation-pending-timer-tick-vector capacity");
+        }
+    }
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("relocation-pending-timer-tick-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-pending-timer-tick-vector constraint capacity");
+        throw error;
+    }
     return value;
 }
 function writeRelocationPendingTimerTickVector(input, writer, context, enclosing, flags) {
@@ -7131,13 +8460,18 @@ function writeRelocationPendingTimerTickVector(input, writer, context, enclosing
     const value = input;
     if (!Array.isArray(value))
         fail("relocation-pending-timer-tick-vector count");
-    for (let index = 1; index < value.length; ++index)
-        if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
-            fail("relocation-pending-timer-tick-vector sorted");
-    for (let left = 0; left < value.length; ++left)
-        for (let right = left + 1; right < value.length; ++right)
-            if (compareResults([compareBigint(numeric(value[left]["participantId"]), numeric(value[right]["participantId"])), compareBigint(numeric(value[left]["order"]), numeric(value[right]["order"]))]) === 0)
-                fail("relocation-pending-timer-tick-vector unique");
+    try {
+        for (let index = 1; index < value.length; ++index)
+            if (compareResults([compareBigint(numeric(value[index - 1]["participantId"]), numeric(value[index]["participantId"])), compareBigint(numeric(value[index - 1]["order"]), numeric(value[index]["order"]))]) >= 0)
+                fail("relocation-pending-timer-tick-vector sorted");
+    }
+    catch (error) {
+        if (error instanceof ServiceWireProtocolError || error instanceof ServiceWireCapacityError)
+            throw error;
+        if (error instanceof RangeError)
+            capacityFail("relocation-pending-timer-tick-vector constraint capacity");
+        throw error;
+    }
     writeU32(value.length, writer, context, enclosing, flags);
     for (const item of value)
         writeRelocationPendingTimerTick(item, writer, context, enclosing, flags);
@@ -7158,6 +8492,20 @@ function readRelocationEnvelopeV1(reader, context, enclosing, flags) {
     value["pendingTimerTicks"] = readRelocationPendingTimerTickVector(reader, context, value, flags);
     return value;
 }
+function* readIncrementalRelocationEnvelopeV1(reader, context, enclosing, flags) {
+    void context;
+    void enclosing;
+    void flags;
+    const value = {};
+    value["relocation"] = yield* readIncrementalRelocationId(reader, context, value, flags);
+    value["object"] = yield* readIncrementalRelocationObjectIdentity(reader, context, value, flags);
+    value["applicationVersion"] = yield* readIncrementalApplicationVersion(reader, context, value, flags);
+    value["applicationStates"] = yield* readIncrementalRelocationParticipantApplicationStateVector(reader, context, value, flags);
+    value["savedWork"] = yield* readIncrementalSavedWorkVector(reader, context, value, flags);
+    value["timerRegistrations"] = yield* readIncrementalRelocationTimerRegistrationVector(reader, context, value, flags);
+    value["pendingTimerTicks"] = yield* readIncrementalRelocationPendingTimerTickVector(reader, context, value, flags);
+    return value;
+}
 function writeRelocationEnvelopeV1(input, writer, context, enclosing, flags) {
     void context;
     void enclosing;
@@ -7569,14 +8917,16 @@ function decodeReplyCommand(frames, context) {
         value.payload = decodeApplicationPayloadEnvelopeV1(frames[frameIndex++], context);
     if (frameIndex !== frames.length)
         fail("reply frames");
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("reply runtime predicate");
     return value;
 }
 function encodeReplyCommand(value, context) {
     if ((value.flags & ~0) !== 0 || (value.flags & 0) !== 0)
         fail("reply flags");
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("reply runtime predicate");
     const writer = new Writer();
     writer.put([90, 77, 1, 20, value.flags]);
@@ -7597,8 +8947,13 @@ function encodeReplyCommand(value, context) {
         frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
     return frames;
 }
-function validateReplyCommandRuntimePredicates(value, context) { if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
-    fail("reply runtime predicate"); }
+function validateReplyCommandRuntimePredicates(value, context) {
+    void value;
+    void context;
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+        fail("reply runtime predicate");
+}
 function decodeSpotSendCommand(frames, context) {
     if (!frames.length)
         fail("spotSend frames");
@@ -8209,14 +9564,16 @@ function decodeReplyRelayCommand(frames, context) {
         value.payload = decodeApplicationPayloadEnvelopeV1(frames[frameIndex++], context);
     if (frameIndex !== frames.length)
         fail("replyRelay frames");
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("replyRelay runtime predicate");
     return value;
 }
 function encodeReplyRelayCommand(value, context) {
     if ((value.flags & ~0) !== 0 || (value.flags & 0) !== 0)
         fail("replyRelay flags");
-    if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
         fail("replyRelay runtime predicate");
     const writer = new Writer();
     writer.put([90, 77, 1, 33, value.flags]);
@@ -8240,8 +9597,13 @@ function encodeReplyRelayCommand(value, context) {
         frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
     return frames;
 }
-function validateReplyRelayCommandRuntimePredicates(value, context) { if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
-    fail("replyRelay runtime predicate"); }
+function validateReplyRelayCommandRuntimePredicates(value, context) {
+    void value;
+    void context;
+    void context;
+    if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"]))))
+        fail("replyRelay runtime predicate");
+}
 function decodeRelocationCutoverCommand(frames, context) {
     if (!frames.length)
         fail("relocationCutover frames");
@@ -9163,7 +10525,82 @@ function decodeRelocationManifestV1DurableFormat(bytes, context) { if (bytes.len
     fail("relocation-manifest-v1 checksum"); return decodeRelocationManifestV1(body, context); }
 function encodeRelocationManifestV1DurableFormat(value, context) { const body = encodeRelocationManifestV1(value, context); const writer = new Writer(); writer.put([90, 76, 84, 77, 1]); writeU16(0, writer, context, {}, 0); writeU32(body.length, writer, context, {}, 0); writer.put(body); writer.u(BigInt(crc32c(writer.result())), 4); const bytes = writer.result(); if (bytes.length > 33554432)
     fail("relocation-manifest-v1 maximum"); return bytes; }
-function decodeRelocationEnvelopeV1LogicalStream(bytes, context) { if (bytes.length > 274877906944)
-    fail("relocation-envelope-v1 maximum"); return decodeRelocationEnvelopeV1(bytes, context); }
+class LogicalDecodeError extends RangeError {
+    kind;
+    offset;
+    constructor(kind, offset, options) {
+        super(kind + " at byte " + offset, options);
+        this.kind = kind;
+        this.offset = offset;
+        this.name = "LogicalDecodeError";
+    }
+}
+exports.LogicalDecodeError = LogicalDecodeError;
+class RelocationEnvelopeV1LogicalStreamDecoder {
+    static maximumContinuationDepth = 12;
+    reader = new IncrementalReader();
+    machine;
+    state = "reading";
+    pendingValue;
+    totalInputByteCount = 0;
+    constructor(context) {
+        this.machine = readIncrementalRelocationEnvelopeV1(this.reader, context, {}, 0);
+    }
+    setSyntheticPriorInputByteCountForTest(value) { if (this.totalInputByteCount !== 0)
+        throw new Error("decoder already used"); this.totalInputByteCount = value; }
+    logicalFailure(error, forced) { if (error instanceof LogicalDecodeError)
+        return error; const kind = forced ?? (error instanceof ServiceWireCapacityError ? "capacity" : "protocol"); return new LogicalDecodeError(kind, this.reader.offset, { cause: error }); }
+    push(chunk, finalChunk) {
+        if (this.state === "complete" || this.state === "failed")
+            throw new Error("terminal logical decoder push");
+        if (chunk.length > 274877906944 - this.totalInputByteCount) {
+            this.state = "failed";
+            throw this.logicalFailure(new RangeError("relocation-envelope-v1 encoded limit"), "limit");
+        }
+        this.totalInputByteCount += chunk.length;
+        if (this.state === "await-final") {
+            if (chunk.length !== 0) {
+                this.state = "failed";
+                throw this.logicalFailure(new RangeError("relocation-envelope-v1 trailing bytes"), "trailing");
+            }
+            if (!finalChunk)
+                return { state: "needMore", bufferedInputByteCount: 0, consumedByteCount: this.reader.offset, continuationDepth: 12 };
+            this.state = "complete";
+            return { state: "complete", value: this.pendingValue, consumedByteCount: this.reader.offset, continuationDepth: 0 };
+        }
+        try {
+            this.reader.supply(chunk);
+            const result = this.machine.next();
+            if (!result.done) {
+                this.reader.release();
+                if (finalChunk) {
+                    this.state = "failed";
+                    throw this.logicalFailure(new RangeError("relocation-envelope-v1 truncated"), "truncated");
+                }
+                return { state: "needMore", bufferedInputByteCount: this.reader.bufferedInputByteCount, consumedByteCount: this.reader.offset, continuationDepth: 12 };
+            }
+            if (this.reader.remaining !== 0) {
+                this.state = "failed";
+                throw this.logicalFailure(new RangeError("relocation-envelope-v1 trailing bytes"), "trailing");
+            }
+            this.reader.release();
+            if (finalChunk) {
+                this.state = "complete";
+                return { state: "complete", value: result.value, consumedByteCount: this.reader.offset, continuationDepth: 0 };
+            }
+            this.pendingValue = result.value;
+            this.state = "await-final";
+            return { state: "needMore", bufferedInputByteCount: 0, consumedByteCount: this.reader.offset, continuationDepth: 12 };
+        }
+        catch (error) {
+            this.reader.discard();
+            this.state = "failed";
+            throw this.logicalFailure(error);
+        }
+    }
+}
+exports.RelocationEnvelopeV1LogicalStreamDecoder = RelocationEnvelopeV1LogicalStreamDecoder;
+function decodeRelocationEnvelopeV1LogicalStream(bytes, context) { const step = new RelocationEnvelopeV1LogicalStreamDecoder(context).push(bytes, true); if (step.state !== "complete")
+    fail("relocation-envelope-v1 truncated"); return step.value; }
 function encodeRelocationEnvelopeV1LogicalStream(value, context) { const bytes = encodeRelocationEnvelopeV1(value, context); if (bytes.length > 274877906944)
     fail("relocation-envelope-v1 maximum"); return bytes; }