@zlink-systems/framework 0.21.0 → 0.22.0

package/src/runtime/protocol/service_wire_codec.generated.ts

@@ -1,19 +1,23 @@
 /* This file is generated by render-service-wire-typescript.mjs. */
 /* eslint-disable */
 
-export type ServiceWireRuntimePredicate = (terminalResult: number, failureCode: number) => boolean;
-export type ServiceWireDecoderContext = Readonly<{ originalOperationKind?: MeshOperationKind; durableRelocationPresent?: boolean; applicationSnapshotPresent?: boolean; readonly effectiveCompleteMessageBytesMinusActualEnvelopeOverhead?: number | bigint; readonly effectiveCompleteMessageBytes?: number | bigint; runtimePredicates: Readonly<Record<string, ServiceWireRuntimePredicate>> }>;
-function fail(message: string): never { throw new RangeError(message); }
+export type ServiceWireDecoderContext = Readonly<{ originalOperationKind?: MeshOperationKind; durableRelocationPresent?: boolean; applicationSnapshotPresent?: boolean; runtimePredicates?: Readonly<Record<string, unknown>>; readonly effectiveCompleteMessageBytesMinusActualEnvelopeOverhead?: number | bigint; readonly effectiveCompleteMessageBytes?: number | bigint; }>;
+class ServiceWireProtocolError extends RangeError { constructor(message: string) { super(message); this.name = "ServiceWireProtocolError"; } }
+function fail(message: string): never { throw new ServiceWireProtocolError(message); }
 class ServiceWireCapacityError extends RangeError { constructor(message: string) { super(message); this.name = "ServiceWireCapacityError"; } }
 function capacityFail(message: string): never { throw new ServiceWireCapacityError(message); }
 function numeric(value: unknown): bigint { return typeof value === "bigint" ? value : BigInt(value as number); }
 function same(left: unknown, right: unknown): boolean { return typeof left === "bigint" || typeof right === "bigint" ? numeric(left) === numeric(right) : left === right; }
 function requireContext(context: ServiceWireDecoderContext, name: string): unknown { const value = (context as any)[name]; if (value === undefined) fail("missing decoder context " + name); return value; }
-function runtimePredicate(context: ServiceWireDecoderContext, name: string, terminal: number, failure: number): boolean { const predicate = context.runtimePredicates[name]; if (!predicate) fail("missing runtime predicate " + name); return predicate(terminal, failure); }
+function validTerminalFailure(terminal: number, failure: number): boolean { 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: unknown): Uint8Array { const text = value as string; for (let index = 0; index < text.length; ++index) { const unit = text.charCodeAt(index); if (unit >= 0xd800 && unit <= 0xdbff) { const next = text.charCodeAt(++index); if (!(next >= 0xdc00 && next <= 0xdfff)) fail("lone UTF-16 surrogate"); } else if (unit >= 0xdc00 && unit <= 0xdfff) fail("lone UTF-16 surrogate"); } return encoder.encode(text); }
 function decodeUtf8(bytes: Uint8Array, label: string): string { try { return decoder.decode(bytes); } catch { return fail(label + " UTF-8"); } }
 class Reader { offset = 0; constructor(readonly bytes: Uint8Array, readonly end = bytes.length) {} get remaining(): number { return this.end - this.offset; } take(length: number): Uint8Array { if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining) fail("truncated service-wire value"); const value = this.bytes.subarray(this.offset, this.offset + length); this.offset += length; return value; } bounded(length: number): Reader { return new Reader(this.take(length)); } u(width: number): bigint { let value = 0n; for (const byte of this.take(width)) value = (value << 8n) | BigInt(byte); return value; } i64(): bigint { const value = this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); } done(label: string): void { if (this.remaining) fail(label + " trailing bytes"); } }
+interface IncrementalInput { readonly offset: number; readonly remaining: number; take(length: number): Generator<void, Uint8Array, void>; bytes(length: number): Generator<void, Uint8Array, void>; text(length: number, forbidNul: boolean, label: string): Generator<void, string, void>; bounded(length: number): IncrementalInput; u(width: number): Generator<void, bigint, void>; i64(): Generator<void, bigint, void>; done(label: string): void; }
+class IncrementalReader implements IncrementalInput { offset = 0; private chunk: Uint8Array = new Uint8Array(); private chunkOffset = 0; bufferedInputByteCount = 0; get remaining(): number { return this.chunk.length - this.chunkOffset; } supply(chunk: Uint8Array): void { if (this.remaining) throw new Error("incremental reader still owns caller input"); this.chunk = chunk; this.chunkOffset = 0; } release(): void { if (this.remaining) throw new Error("incremental reader did not consume caller input"); this.discard(); } discard(): void { this.chunk = new Uint8Array(); this.chunkOffset = 0; } *take(length: number): Generator<void, Uint8Array, void> { 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: number): Generator<void, Uint8Array, void> { if (!Number.isSafeInteger(length) || length < 0) fail("invalid incremental content length"); let value: Uint8Array; 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: number, forbidNul: boolean, label: string): Generator<void, string, void> { 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: number): IncrementalInput { if (!Number.isSafeInteger(length) || length < 0) fail("invalid bounded read length"); return new IncrementalBoundedReader(this, length); } *u(width: number): Generator<void, bigint, void> { let value = 0n; for (const byte of yield* this.take(width)) value = (value << 8n) | BigInt(byte); return value; } *i64(): Generator<void, bigint, void> { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); } done(label: string): void { if (this.remaining) fail(label + " bounded body remainder"); } }
+class IncrementalBoundedReader implements IncrementalInput { offset = 0; constructor(private readonly source: IncrementalReader, public remaining: number) {} private check(length: number): void { if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining) fail("bounded service-wire value overflow"); } private consumed(length: number): void { this.remaining -= length; this.offset += length; } *take(length: number): Generator<void, Uint8Array, void> { this.check(length); const value = yield* this.source.take(length); this.consumed(length); return value; } *bytes(length: number): Generator<void, Uint8Array, void> { this.check(length); const value = yield* this.source.bytes(length); this.consumed(length); return value; } *text(length: number, forbidNul: boolean, label: string): Generator<void, string, void> { this.check(length); const value = yield* this.source.text(length, forbidNul, label); this.consumed(length); return value; } bounded(length: number): IncrementalInput { this.check(length); return new IncrementalNestedBoundedReader(this, length); } *u(width: number): Generator<void, bigint, void> { let value = 0n; for (const byte of yield* this.take(width)) value = (value << 8n) | BigInt(byte); return value; } *i64(): Generator<void, bigint, void> { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); } done(label: string): void { if (this.remaining) fail(label + " bounded body remainder"); } }
+class IncrementalNestedBoundedReader implements IncrementalInput { offset = 0; constructor(private readonly parent: IncrementalInput, public remaining: number) {} private check(length: number): void { if (!Number.isSafeInteger(length) || length < 0 || length > this.remaining) fail("bounded service-wire value overflow"); } private consumed(length: number): void { this.remaining -= length; this.offset += length; } *take(length: number): Generator<void, Uint8Array, void> { this.check(length); const value = yield* this.parent.take(length); this.consumed(length); return value; } *bytes(length: number): Generator<void, Uint8Array, void> { this.check(length); const value = yield* this.parent.bytes(length); this.consumed(length); return value; } *text(length: number, forbidNul: boolean, label: string): Generator<void, string, void> { this.check(length); const value = yield* this.parent.text(length, forbidNul, label); this.consumed(length); return value; } bounded(length: number): IncrementalInput { this.check(length); return new IncrementalNestedBoundedReader(this, length); } *u(width: number): Generator<void, bigint, void> { let value = 0n; for (const byte of yield* this.take(width)) value = (value << 8n) | BigInt(byte); return value; } *i64(): Generator<void, bigint, void> { const value = yield* this.u(8); return (value & (1n << 63n)) === 0n ? value : value - (1n << 64n); } done(label: string): void { if (this.remaining) fail(label + " bounded body remainder"); } }
 class Writer { readonly chunks: Uint8Array[] = []; length = 0; put(bytes: Iterable<number>): void { const chunk = bytes instanceof Uint8Array ? bytes : Uint8Array.from(bytes); if (!chunk.length) return; this.chunks.push(chunk); this.length += chunk.length; } u(value: bigint, width: number): void { const bytes = new Uint8Array(width); for (let index = width - 1; index >= 0; --index) { bytes[index] = Number(value & 255n); value >>= 8n; } this.put(bytes); } i64(value: bigint): void { this.u(BigInt.asUintN(64, value), 8); } result(): Uint8Array { if (!this.chunks.length) return new Uint8Array(); if (this.chunks.length === 1) return this.chunks[0]; const result = new Uint8Array(this.length); let offset = 0; for (const chunk of this.chunks) { result.set(chunk, offset); offset += chunk.length; } return result; } }
 function compareBytes(left: Uint8Array, right: Uint8Array): number { const count = Math.min(left.length, right.length); for (let index = 0; index < count; ++index) if (left[index] !== right[index]) return left[index] < right[index] ? -1 : 1; return left.length === right.length ? 0 : left.length < right.length ? -1 : 1; }
 function compareBigint(left: bigint, right: bigint): number { return left < right ? -1 : left > right ? 1 : 0; }
@@ -27,6 +31,10 @@ function readU8(reader: Reader, context: ServiceWireDecoderContext, enclosing: a
   void context; void enclosing; void flags;
   const raw = reader.u(1); if (raw < 0n || raw > 255n) fail("u8 range"); return Number(raw);
 }
+function* readIncrementalU8(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, U8, void> {
+  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: U8, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 255n) fail("u8 range"); writer.u(raw, 1);
@@ -40,6 +48,10 @@ function readU16(reader: Reader, context: ServiceWireDecoderContext, enclosing:
   void context; void enclosing; void flags;
   const raw = reader.u(2); if (raw < 0n || raw > 65535n) fail("u16 range"); return Number(raw);
 }
+function* readIncrementalU16(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, U16, void> {
+  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: U16, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 65535n) fail("u16 range"); writer.u(raw, 2);
@@ -53,6 +65,10 @@ function readU32(reader: Reader, context: ServiceWireDecoderContext, enclosing:
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 0n || raw > 4294967295n) fail("u32 range"); return Number(raw);
 }
+function* readIncrementalU32(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, U32, void> {
+  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: U32, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 4294967295n) fail("u32 range"); writer.u(raw, 4);
@@ -66,6 +82,7 @@ function readNonzeroU32(reader: Reader, context: ServiceWireDecoderContext, encl
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 1n || raw > 4294967295n) fail("nonzero-u32 range"); return Number(raw);
 }
+
 function writeNonzeroU32(input: NonzeroU32, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 1n || raw > 4294967295n) fail("nonzero-u32 range"); writer.u(raw, 4);
@@ -79,6 +96,10 @@ function readU64(reader: Reader, context: ServiceWireDecoderContext, enclosing:
   void context; void enclosing; void flags;
   const raw = reader.u(8); if (raw < 0n || raw > 18446744073709551615n) fail("u64 range"); return raw;
 }
+function* readIncrementalU64(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, U64, void> {
+  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: U64, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 18446744073709551615n) fail("u64 range"); writer.u(raw, 8);
@@ -92,6 +113,10 @@ function readNonzeroU64(reader: Reader, context: ServiceWireDecoderContext, encl
   void context; void enclosing; void flags;
   const raw = reader.u(8); if (raw < 1n || raw > 9223372036854775807n) fail("nonzero-u64 range"); return raw;
 }
+function* readIncrementalNonzeroU64(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, NonzeroU64, void> {
+  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: NonzeroU64, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 1n || raw > 9223372036854775807n) fail("nonzero-u64 range"); writer.u(raw, 8);
@@ -105,6 +130,10 @@ function readOrdinalOrZero(reader: Reader, context: ServiceWireDecoderContext, e
   void context; void enclosing; void flags;
   const raw = reader.u(8); if (raw < 0n || raw > 9223372036854775807n) fail("ordinal-or-zero range"); return raw;
 }
+function* readIncrementalOrdinalOrZero(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, OrdinalOrZero, void> {
+  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: OrdinalOrZero, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 9223372036854775807n) fail("ordinal-or-zero range"); writer.u(raw, 8);
@@ -118,6 +147,7 @@ function readRelocationLogicalLength(reader: Reader, context: ServiceWireDecoder
   void context; void enclosing; void flags;
   const raw = reader.u(8); if (raw < 0n || raw > 274877906944n) fail("relocation-logical-length range"); return raw;
 }
+
 function writeRelocationLogicalLength(input: RelocationLogicalLength, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 274877906944n) fail("relocation-logical-length range"); writer.u(raw, 8);
@@ -131,6 +161,7 @@ function readRelocationChunkCount(reader: Reader, context: ServiceWireDecoderCon
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 0n || raw > 4096n) fail("relocation-chunk-count range"); return Number(raw);
 }
+
 function writeRelocationChunkCount(input: RelocationChunkCount, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 4096n) fail("relocation-chunk-count range"); writer.u(raw, 4);
@@ -144,6 +175,10 @@ function readApplicationVersion(reader: Reader, context: ServiceWireDecoderConte
   void context; void enclosing; void flags;
   const raw = reader.i64(); if (raw < 0n || raw > 9223372036854775807n) fail("application-version range"); return raw;
 }
+function* readIncrementalApplicationVersion(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ApplicationVersion, void> {
+  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: ApplicationVersion, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 9223372036854775807n) fail("application-version range"); writer.i64(raw);
@@ -164,6 +199,14 @@ function readBool8(reader: Reader, context: ServiceWireDecoderContext, enclosing
     default: fail("bool8 enum");
   }
 }
+function* readIncrementalBool8(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, Bool8, void> {
+  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: Bool8, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireBool8(value)), 1);
@@ -175,11 +218,15 @@ export type Rid = Uint8Array;
 
 function readRid(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Rid {
   void context; void enclosing; void flags;
-  const length = Number(readU8(reader, context, enclosing, flags));  if (length > 255) fail("rid length"); if (length > 2147483647) capacityFail("rid capacity"); if (length < 1) fail("rid length");  return reader.take(length);
+  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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, Rid, void> {
+  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 yield* reader.bytes(length);
 }
 function writeRid(input: Rid, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 255) fail("rid length"); if (bytes.length > 2147483647) capacityFail("rid capacity"); if (bytes.length < 1) fail("rid length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeRid(bytes: Uint8Array, context: ServiceWireDecoderContext): Rid { const reader = new Reader(bytes); const value = readRid(reader, context, {}, 0); reader.done("rid"); return value; }
 export function encodeRid(value: Rid, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeRid(value, writer, context, {}, 0); return writer.result(); }
@@ -188,11 +235,12 @@ export type OptionalRid = Uint8Array | null;
 
 function readOptionalRid(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): OptionalRid {
   void context; void enclosing; void 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 < 0) fail("optional-rid length");  return reader.take(length);
+  const length = Number(readU8(reader, context, enclosing, flags)); if (length === 0) return null; 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);
 }
+
 function writeOptionalRid(input: OptionalRid, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-  if (value === null) { writeU8(0, writer, context, enclosing, flags); return; } const bytes = value as Uint8Array;  if (bytes.length > 255) fail("optional-rid length"); if (bytes.length > 2147483647) capacityFail("optional-rid capacity"); if (bytes.length < 0) fail("optional-rid length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+  if (value === null) { writeU8(0, writer, context, enclosing, flags); return; } const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeOptionalRid(bytes: Uint8Array, context: ServiceWireDecoderContext): OptionalRid { const reader = new Reader(bytes); const value = readOptionalRid(reader, context, {}, 0); reader.done("optional-rid"); return value; }
 export function encodeOptionalRid(value: OptionalRid, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeOptionalRid(value, writer, context, {}, 0); return writer.result(); }
@@ -201,11 +249,15 @@ export type Text8 = string;
 
 function readText8(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Text8 {
   void context; 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 < 1) fail("text8 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("text8 NUL"); return decodeUtf8(bytes, "text8");
+  const length = Number(readU8(reader, context, enclosing, flags));  if (length > 2147483647) capacityFail("text8 capacity"); if (length > 255) fail("text8 length"); if (length < 1) fail("text8 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("text8 NUL"); return decodeUtf8(bytes, "text8");
+}
+function* readIncrementalText8(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, Text8, void> {
+  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: Text8, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("text8 length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("text8 NUL"); 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); writer.put(bytes);
 }
 export function decodeText8(bytes: Uint8Array, context: ServiceWireDecoderContext): Text8 { const reader = new Reader(bytes); const value = readText8(reader, context, {}, 0); reader.done("text8"); return value; }
 export function encodeText8(value: Text8, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeText8(value, writer, context, {}, 0); return writer.result(); }
@@ -214,11 +266,12 @@ export type OptionalText8 = string | null;
 
 function readOptionalText8(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): OptionalText8 {
   void context; void enclosing; void 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 < 0) fail("optional-text8 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("optional-text8 NUL"); return decodeUtf8(bytes, "optional-text8");
+  const length = Number(readU8(reader, context, enclosing, flags)); if (length === 0) return null; 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); if (bytes.includes(0)) fail("optional-text8 NUL"); return decodeUtf8(bytes, "optional-text8");
 }
+
 function writeOptionalText8(input: OptionalText8, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-  if (value === null) { writeU8(0, writer, context, enclosing, flags); return; } 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 < 0) fail("optional-text8 length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+  if (value === null) { writeU8(0, writer, context, enclosing, flags); return; } const bytes = utf8(value); if (bytes.includes(0)) fail("optional-text8 NUL"); 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); writer.put(bytes);
 }
 export function decodeOptionalText8(bytes: Uint8Array, context: ServiceWireDecoderContext): OptionalText8 { const reader = new Reader(bytes); const value = readOptionalText8(reader, context, {}, 0); reader.done("optional-text8"); return value; }
 export function encodeOptionalText8(value: OptionalText8, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeOptionalText8(value, writer, context, {}, 0); return writer.result(); }
@@ -227,11 +280,12 @@ export type Sha256Bytes = Uint8Array;
 
 function readSha256Bytes(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Sha256Bytes {
   void context; 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");  return reader.take(length);
+  const length = Number(readU8(reader, context, enclosing, flags));  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);
 }
+
 function writeSha256Bytes(input: Sha256Bytes, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 32) fail("sha256-bytes length"); if (bytes.length > 2147483647) capacityFail("sha256-bytes capacity"); if (bytes.length < 32) fail("sha256-bytes length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeSha256Bytes(bytes: Uint8Array, context: ServiceWireDecoderContext): Sha256Bytes { const reader = new Reader(bytes); const value = readSha256Bytes(reader, context, {}, 0); reader.done("sha256-bytes"); return value; }
 export function encodeSha256Bytes(value: Sha256Bytes, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeSha256Bytes(value, writer, context, {}, 0); return writer.result(); }
@@ -242,6 +296,7 @@ function readCreationRequestSize(reader: Reader, context: ServiceWireDecoderCont
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 0n || raw > 1048576n) fail("creation-request-size range"); return Number(raw);
 }
+
 function writeCreationRequestSize(input: CreationRequestSize, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 1048576n) fail("creation-request-size range"); writer.u(raw, 4);
@@ -253,11 +308,12 @@ export type Text16 = string;
 
 function readText16(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Text16 {
   void context; 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 < 0) fail("text16 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("text16 NUL"); return decodeUtf8(bytes, "text16");
+  const length = Number(readU16(reader, context, enclosing, flags));  if (length > 2147483647) capacityFail("text16 capacity"); if (length > 65535) fail("text16 length"); if (length < 0) fail("text16 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("text16 NUL"); return decodeUtf8(bytes, "text16");
 }
+
 function writeText16(input: Text16, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 0) fail("text16 length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("text16 NUL"); 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); writer.put(bytes);
 }
 export function decodeText16(bytes: Uint8Array, context: ServiceWireDecoderContext): Text16 { const reader = new Reader(bytes); const value = readText16(reader, context, {}, 0); reader.done("text16"); return value; }
 export function encodeText16(value: Text16, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeText16(value, writer, context, {}, 0); return writer.result(); }
@@ -266,11 +322,12 @@ export type NonemptyText16 = string;
 
 function readNonemptyText16(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): NonemptyText16 {
   void context; 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 < 1) fail("nonempty-text16 length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("nonempty-text16 NUL"); return decodeUtf8(bytes, "nonempty-text16");
+  const length = Number(readU16(reader, context, enclosing, flags));  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); if (bytes.includes(0)) fail("nonempty-text16 NUL"); return decodeUtf8(bytes, "nonempty-text16");
 }
+
 function writeNonemptyText16(input: NonemptyText16, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("nonempty-text16 length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("nonempty-text16 NUL"); 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); writer.put(bytes);
 }
 export function decodeNonemptyText16(bytes: Uint8Array, context: ServiceWireDecoderContext): NonemptyText16 { const reader = new Reader(bytes); const value = readNonemptyText16(reader, context, {}, 0); reader.done("nonempty-text16"); return value; }
 export function encodeNonemptyText16(value: NonemptyText16, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeNonemptyText16(value, writer, context, {}, 0); return writer.result(); }
@@ -279,11 +336,12 @@ export type Endpoint = string;
 
 function readEndpoint(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Endpoint {
   void context; 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 < 1) fail("endpoint length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("endpoint NUL"); return decodeUtf8(bytes, "endpoint");
+  const length = Number(readU16(reader, context, enclosing, flags));  if (length > 2147483647) capacityFail("endpoint capacity"); if (length > 4096) fail("endpoint length"); if (length < 1) fail("endpoint length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("endpoint NUL"); return decodeUtf8(bytes, "endpoint");
 }
+
 function writeEndpoint(input: Endpoint, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("endpoint length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("endpoint NUL"); 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); writer.put(bytes);
 }
 export function decodeEndpoint(bytes: Uint8Array, context: ServiceWireDecoderContext): Endpoint { const reader = new Reader(bytes); const value = readEndpoint(reader, context, {}, 0); reader.done("endpoint"); return value; }
 export function encodeEndpoint(value: Endpoint, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeEndpoint(value, writer, context, {}, 0); return writer.result(); }
@@ -292,11 +350,12 @@ export type Blob16 = Uint8Array;
 
 function readBlob16(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): Blob16 {
   void context; 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 < 0) fail("blob16 length");  return reader.take(length);
+  const length = Number(readU16(reader, context, enclosing, flags));  if (length > 2147483647) capacityFail("blob16 capacity"); if (length > 65535) fail("blob16 length"); if (length < 0) fail("blob16 length");  return reader.take(length);
 }
+
 function writeBlob16(input: Blob16, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 65535) fail("blob16 length"); if (bytes.length > 2147483647) capacityFail("blob16 capacity"); if (bytes.length < 0) fail("blob16 length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeBlob16(bytes: Uint8Array, context: ServiceWireDecoderContext): Blob16 { const reader = new Reader(bytes); const value = readBlob16(reader, context, {}, 0); reader.done("blob16"); return value; }
 export function encodeBlob16(value: Blob16, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeBlob16(value, writer, context, {}, 0); return writer.result(); }
@@ -305,11 +364,12 @@ export type NonemptyBlob16 = Uint8Array;
 
 function readNonemptyBlob16(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): NonemptyBlob16 {
   void context; 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 < 1) fail("nonempty-blob16 length");  return reader.take(length);
+  const length = Number(readU16(reader, context, enclosing, flags));  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);
 }
+
 function writeNonemptyBlob16(input: NonemptyBlob16, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 65535) fail("nonempty-blob16 length"); if (bytes.length > 2147483647) capacityFail("nonempty-blob16 capacity"); if (bytes.length < 1) fail("nonempty-blob16 length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeNonemptyBlob16(bytes: Uint8Array, context: ServiceWireDecoderContext): NonemptyBlob16 { const reader = new Reader(bytes); const value = readNonemptyBlob16(reader, context, {}, 0); reader.done("nonempty-blob16"); return value; }
 export function encodeNonemptyBlob16(value: NonemptyBlob16, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeNonemptyBlob16(value, writer, context, {}, 0); return writer.result(); }
@@ -318,11 +378,15 @@ export type PacketName = string;
 
 function readPacketName(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): PacketName {
   void context; 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 < 1) fail("packet-name length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("packet-name NUL"); return decodeUtf8(bytes, "packet-name");
+  const length = Number(readU8(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");  const bytes = reader.take(length); if (bytes.includes(0)) fail("packet-name NUL"); return decodeUtf8(bytes, "packet-name");
+}
+function* readIncrementalPacketName(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, PacketName, void> {
+  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: PacketName, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("packet-name length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("packet-name NUL"); 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); writer.put(bytes);
 }
 export function decodePacketName(bytes: Uint8Array, context: ServiceWireDecoderContext): PacketName { const reader = new Reader(bytes); const value = readPacketName(reader, context, {}, 0); reader.done("packet-name"); return value; }
 export function encodePacketName(value: PacketName, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writePacketName(value, writer, context, {}, 0); return writer.result(); }
@@ -331,11 +395,15 @@ export type ContentType = string;
 
 function readContentType(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): ContentType {
   void context; 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 < 1) fail("content-type length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("content-type NUL"); return decodeUtf8(bytes, "content-type");
+  const length = Number(readU8(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");  const bytes = reader.take(length); if (bytes.includes(0)) fail("content-type NUL"); return decodeUtf8(bytes, "content-type");
+}
+function* readIncrementalContentType(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ContentType, void> {
+  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: ContentType, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("content-type length"); writeU8(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("content-type NUL"); 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); writer.put(bytes);
 }
 export function decodeContentType(bytes: Uint8Array, context: ServiceWireDecoderContext): ContentType { const reader = new Reader(bytes); const value = readContentType(reader, context, {}, 0); reader.done("content-type"); return value; }
 export function encodeContentType(value: ContentType, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeContentType(value, writer, context, {}, 0); return writer.result(); }
@@ -344,11 +412,15 @@ export type ApplicationPayloadBytes = Uint8Array;
 
 function readApplicationPayloadBytes(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): ApplicationPayloadBytes {
   void context; void enclosing; void flags;
-  const length = Number(readU32(reader, context, enclosing, flags));  if (length > 4294966774) fail("application-payload-bytes length"); if (length > 2147483647) capacityFail("application-payload-bytes capacity"); 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);
+  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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ApplicationPayloadBytes, void> {
+  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 yield* reader.bytes(length);
 }
 function writeApplicationPayloadBytes(input: ApplicationPayloadBytes, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 4294966774) fail("application-payload-bytes length"); if (bytes.length > 2147483647) capacityFail("application-payload-bytes capacity"); if (bytes.length < 0) fail("application-payload-bytes length"); writeU32(bytes.length, writer, context, enclosing, flags); writer.put(bytes); const negotiatedMaximum = numeric(requireContext(context, "effectiveCompleteMessageBytesMinusActualEnvelopeOverhead")); if (negotiatedMaximum < 0n || negotiatedMaximum > 4294966774n || BigInt(bytes.length) > negotiatedMaximum) fail("application-payload-bytes negotiated maximum");
+   const bytes = value as Uint8Array;  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); writer.put(bytes); const negotiatedMaximum = numeric(requireContext(context, "effectiveCompleteMessageBytesMinusActualEnvelopeOverhead")); if (negotiatedMaximum < 0n || negotiatedMaximum > 4294966774n || BigInt(bytes.length) > negotiatedMaximum) fail("application-payload-bytes negotiated maximum");
 }
 export function decodeApplicationPayloadBytes(bytes: Uint8Array, context: ServiceWireDecoderContext): ApplicationPayloadBytes { const reader = new Reader(bytes); const value = readApplicationPayloadBytes(reader, context, {}, 0); reader.done("application-payload-bytes"); return value; }
 export function encodeApplicationPayloadBytes(value: ApplicationPayloadBytes, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeApplicationPayloadBytes(value, writer, context, {}, 0); return writer.result(); }
@@ -372,6 +444,28 @@ function readApplicationPayloadEnvelopeV1(reader: Reader, context: ServiceWireDe
     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* readIncrementalApplicationPayloadEnvelopeV1(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ApplicationPayloadEnvelopeV1, void> {
+  void context; void enclosing; void flags;
+  const limitStart = reader.offset; const decoded = yield* (function* (): Generator<void, ApplicationPayloadEnvelopeV1, void> {
+    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: any = {};
+    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");
@@ -407,11 +501,15 @@ export type MetadataValue = string;
 
 function readMetadataValue(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): MetadataValue {
   void context; 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 < 0) fail("metadata-value length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("metadata-value NUL"); return decodeUtf8(bytes, "metadata-value");
+  const length = Number(readU16(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");  const bytes = reader.take(length); if (bytes.includes(0)) fail("metadata-value NUL"); return decodeUtf8(bytes, "metadata-value");
+}
+function* readIncrementalMetadataValue(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MetadataValue, void> {
+  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: MetadataValue, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 0) fail("metadata-value length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("metadata-value NUL"); 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); writer.put(bytes);
 }
 export function decodeMetadataValue(bytes: Uint8Array, context: ServiceWireDecoderContext): MetadataValue { const reader = new Reader(bytes); const value = readMetadataValue(reader, context, {}, 0); reader.done("metadata-value"); return value; }
 export function encodeMetadataValue(value: MetadataValue, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeMetadataValue(value, writer, context, {}, 0); return writer.result(); }
@@ -429,6 +527,19 @@ function readMetadataEntry(reader: Reader, context: ServiceWireDecoderContext, e
 
 
 
+  return value;
+}
+function* readIncrementalMetadataEntry(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MetadataEntry, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["key"] = yield* readIncrementalText8(reader, context, value, flags);
+
+
+  value["value"] = yield* readIncrementalMetadataValue(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeMetadataEntry(input: MetadataEntry, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -456,7 +567,20 @@ function readMetadataFrame(reader: Reader, context: ServiceWireDecoderContext, e
     layout.version = readU8(reader, context, enclosing, flags); if (!same(layout.version, 1)) 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MetadataFrame, void> {
+  void context; void enclosing; void flags;
+  const limitStart = reader.offset; const decoded = yield* (function* (): Generator<void, MetadataFrame, void> {
+    const layout: any = {}; const value: any = {};
+    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) fail("metadata-frame maximum");
@@ -465,7 +589,7 @@ function readMetadataFrame(reader: Reader, context: ServiceWireDecoderContext, e
 function writeMetadataFrame(input: MetadataFrame, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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) writeMetadataEntry(item, writer, context, enclosing, flags);
@@ -493,6 +617,7 @@ function readRuntimeState(reader: Reader, context: ServiceWireDecoderContext, en
     default: fail("runtime-state enum");
   }
 }
+
 function writeRuntimeState(input: RuntimeState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRuntimeState(value)), 1);
@@ -515,6 +640,15 @@ function readStatefulObjectKind(reader: Reader, context: ServiceWireDecoderConte
     default: fail("stateful-object-kind enum");
   }
 }
+function* readIncrementalStatefulObjectKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, StatefulObjectKind, void> {
+  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: StatefulObjectKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireStatefulObjectKind(value)), 1);
@@ -537,6 +671,7 @@ function readObjectRole(reader: Reader, context: ServiceWireDecoderContext, encl
     default: fail("object-role enum");
   }
 }
+
 function writeObjectRole(input: ObjectRole, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireObjectRole(value)), 1);
@@ -550,6 +685,7 @@ function readObjectCapacityLimit(reader: Reader, context: ServiceWireDecoderCont
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 1n || raw > 2147483647n) fail("object-capacity-limit range"); return Number(raw);
 }
+
 function writeObjectCapacityLimit(input: ObjectCapacityLimit, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 1n || raw > 2147483647n) fail("object-capacity-limit range"); writer.u(raw, 4);
@@ -563,6 +699,7 @@ function readObjectPendingCapacityLimit(reader: Reader, context: ServiceWireDeco
   void context; void enclosing; void flags;
   const raw = reader.u(4); if (raw < 0n || raw > 2147483647n) fail("object-pending-capacity-limit range"); return Number(raw);
 }
+
 function writeObjectPendingCapacityLimit(input: ObjectPendingCapacityLimit, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const raw = numeric(value); if (raw < 0n || raw > 2147483647n) fail("object-pending-capacity-limit range"); writer.u(raw, 4);
@@ -583,6 +720,7 @@ function readAuthorityObjectKind(reader: Reader, context: ServiceWireDecoderCont
     default: fail("authority-object-kind enum");
   }
 }
+
 function writeAuthorityObjectKind(input: AuthorityObjectKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireAuthorityObjectKind(value)), 1);
@@ -605,6 +743,7 @@ function readSpotKind(reader: Reader, context: ServiceWireDecoderContext, enclos
     default: fail("spot-kind enum");
   }
 }
+
 function writeSpotKind(input: SpotKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireSpotKind(value)), 1);
@@ -629,6 +768,7 @@ function readEntryUserSpotAuthorityState(reader: Reader, context: ServiceWireDec
     default: fail("entry-user-spot-authority-state enum");
   }
 }
+
 function writeEntryUserSpotAuthorityState(input: EntryUserSpotAuthorityState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireEntryUserSpotAuthorityState(value)), 1);
@@ -649,6 +789,7 @@ function readActorAuthorityState(reader: Reader, context: ServiceWireDecoderCont
     default: fail("actor-authority-state enum");
   }
 }
+
 function writeActorAuthorityState(input: ActorAuthorityState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireActorAuthorityState(value)), 1);
@@ -671,6 +812,7 @@ function readRelocationPolicyKind(reader: Reader, context: ServiceWireDecoderCon
     default: fail("relocation-policy-kind enum");
   }
 }
+
 function writeRelocationPolicyKind(input: RelocationPolicyKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRelocationPolicyKind(value)), 1);
@@ -693,6 +835,15 @@ function readTimerOverrunPolicyKind(reader: Reader, context: ServiceWireDecoderC
     default: fail("timer-overrun-policy-kind enum");
   }
 }
+function* readIncrementalTimerOverrunPolicyKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, TimerOverrunPolicyKind, void> {
+  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: TimerOverrunPolicyKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireTimerOverrunPolicyKind(value)), 1);
@@ -713,6 +864,7 @@ function readActorSpotKind(reader: Reader, context: ServiceWireDecoderContext, e
     default: fail("actor-spot-kind enum");
   }
 }
+
 function writeActorSpotKind(input: ActorSpotKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireActorSpotKind(value)), 1);
@@ -735,6 +887,15 @@ function readRelocationRole(reader: Reader, context: ServiceWireDecoderContext,
     default: fail("relocation-role enum");
   }
 }
+function* readIncrementalRelocationRole(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationRole, void> {
+  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: RelocationRole, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRelocationRole(value)), 1);
@@ -755,6 +916,7 @@ function readActorJoinResult(reader: Reader, context: ServiceWireDecoderContext,
     default: fail("actor-join-result enum");
   }
 }
+
 function writeActorJoinResult(input: ActorJoinResult, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireActorJoinResult(value)), 4);
@@ -788,6 +950,7 @@ function readActorJoinReplyTail(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeActorJoinReplyTail(input: ActorJoinReplyTail, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -856,6 +1019,26 @@ function readMeshRecordKind(reader: Reader, context: ServiceWireDecoderContext,
     default: fail("mesh-record-kind enum");
   }
 }
+function* readIncrementalMeshRecordKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MeshRecordKind, void> {
+  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: MeshRecordKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireMeshRecordKind(value)), 1);
@@ -880,6 +1063,16 @@ function readFrozenSourceKind(reader: Reader, context: ServiceWireDecoderContext
     default: fail("frozen-source-kind enum");
   }
 }
+function* readIncrementalFrozenSourceKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrozenSourceKind, void> {
+  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: FrozenSourceKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireFrozenSourceKind(value)), 1);
@@ -906,6 +1099,17 @@ function readMeshDestinationKind(reader: Reader, context: ServiceWireDecoderCont
     default: fail("mesh-destination-kind enum");
   }
 }
+function* readIncrementalMeshDestinationKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MeshDestinationKind, void> {
+  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: MeshDestinationKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireMeshDestinationKind(value)), 1);
@@ -926,6 +1130,7 @@ function readServiceTopologyKind(reader: Reader, context: ServiceWireDecoderCont
     default: fail("service-topology-kind enum");
   }
 }
+
 function writeServiceTopologyKind(input: ServiceTopologyKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireServiceTopologyKind(value)), 1);
@@ -946,6 +1151,7 @@ function readClientServerRole(reader: Reader, context: ServiceWireDecoderContext
     default: fail("client-server-role enum");
   }
 }
+
 function writeClientServerRole(input: ClientServerRole, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireClientServerRole(value)), 1);
@@ -964,6 +1170,7 @@ function readClientServerDirection(reader: Reader, context: ServiceWireDecoderCo
     default: fail("client-server-direction enum");
   }
 }
+
 function writeClientServerDirection(input: ClientServerDirection, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireClientServerDirection(value)), 1);
@@ -990,6 +1197,17 @@ function readActorLifecycleKind(reader: Reader, context: ServiceWireDecoderConte
     default: fail("actor-lifecycle-kind enum");
   }
 }
+function* readIncrementalActorLifecycleKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ActorLifecycleKind, void> {
+  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: ActorLifecycleKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireActorLifecycleKind(value)), 1);
@@ -1010,6 +1228,7 @@ function readBoundSessionBindingState(reader: Reader, context: ServiceWireDecode
     default: fail("bound-session-binding-state enum");
   }
 }
+
 function writeBoundSessionBindingState(input: BoundSessionBindingState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireBoundSessionBindingState(value)), 1);
@@ -1030,6 +1249,7 @@ function readSessionRelocationRouteAction(reader: Reader, context: ServiceWireDe
     default: fail("session-relocation-route-action enum");
   }
 }
+
 function writeSessionRelocationRouteAction(input: SessionRelocationRouteAction, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireSessionRelocationRouteAction(value)), 1);
@@ -1066,6 +1286,22 @@ function readRelocationPhase(reader: Reader, context: ServiceWireDecoderContext,
     default: fail("relocation-phase enum");
   }
 }
+function* readIncrementalRelocationPhase(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationPhase, void> {
+  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: RelocationPhase, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRelocationPhase(value)), 1);
@@ -1088,6 +1324,7 @@ function readSourceCleanupState(reader: Reader, context: ServiceWireDecoderConte
     default: fail("source-cleanup-state enum");
   }
 }
+
 function writeSourceCleanupState(input: SourceCleanupState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireSourceCleanupState(value)), 1);
@@ -1108,6 +1345,7 @@ function readReplyRelayAckStatus(reader: Reader, context: ServiceWireDecoderCont
     default: fail("reply-relay-ack-status enum");
   }
 }
+
 function writeReplyRelayAckStatus(input: ReplyRelayAckStatus, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireReplyRelayAckStatus(value)), 1);
@@ -1132,6 +1370,7 @@ function readAuthorityOperationKind(reader: Reader, context: ServiceWireDecoderC
     default: fail("authority-operation-kind enum");
   }
 }
+
 function writeAuthorityOperationKind(input: AuthorityOperationKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireAuthorityOperationKind(value)), 1);
@@ -1180,6 +1419,28 @@ function readMeshOperationKind(reader: Reader, context: ServiceWireDecoderContex
     default: fail("mesh-operation-kind enum");
   }
 }
+function* readIncrementalMeshOperationKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, MeshOperationKind, void> {
+  void context; void enclosing; void flags;
+  const raw = yield* 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 writeMeshOperationKind(input: MeshOperationKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireMeshOperationKind(value)), 4);
@@ -1224,6 +1485,26 @@ function readRequestTerminalResult(reader: Reader, context: ServiceWireDecoderCo
     default: fail("request-terminal-result enum");
   }
 }
+function* readIncrementalRequestTerminalResult(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RequestTerminalResult, void> {
+  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: RequestTerminalResult, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRequestTerminalResult(value)), 4);
@@ -1292,6 +1573,38 @@ function readFrameworkErrorCode(reader: Reader, context: ServiceWireDecoderConte
     default: fail("framework-error-code enum");
   }
 }
+function* readIncrementalFrameworkErrorCode(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrameworkErrorCode, void> {
+  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: FrameworkErrorCode, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireFrameworkErrorCode(value)), 4);
@@ -1312,6 +1625,14 @@ function readInstanceOperationKind(reader: Reader, context: ServiceWireDecoderCo
     default: fail("instance-operation-kind enum");
   }
 }
+function* readIncrementalInstanceOperationKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, InstanceOperationKind, void> {
+  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: InstanceOperationKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireInstanceOperationKind(value)), 1);
@@ -1332,6 +1653,14 @@ function readInstanceRouteKind(reader: Reader, context: ServiceWireDecoderContex
     default: fail("instance-route-kind enum");
   }
 }
+function* readIncrementalInstanceRouteKind(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, InstanceRouteKind, void> {
+  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: InstanceRouteKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireInstanceRouteKind(value)), 1);
@@ -1354,6 +1683,7 @@ function readUserSpotCreateResult(reader: Reader, context: ServiceWireDecoderCon
     default: fail("user-spot-create-result enum");
   }
 }
+
 function writeUserSpotCreateResult(input: UserSpotCreateResult, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireUserSpotCreateResult(value)), 1);
@@ -1376,6 +1706,7 @@ function readActorCreateResult(reader: Reader, context: ServiceWireDecoderContex
     default: fail("actor-create-result enum");
   }
 }
+
 function writeActorCreateResult(input: ActorCreateResult, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireActorCreateResult(value)), 1);
@@ -1400,6 +1731,7 @@ function readInstanceAuthorityState(reader: Reader, context: ServiceWireDecoderC
     default: fail("instance-authority-state enum");
   }
 }
+
 function writeInstanceAuthorityState(input: InstanceAuthorityState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireInstanceAuthorityState(value)), 1);
@@ -1420,6 +1752,7 @@ function readReplyRelayContextKind(reader: Reader, context: ServiceWireDecoderCo
     default: fail("reply-relay-context-kind enum");
   }
 }
+
 function writeReplyRelayContextKind(input: ReplyRelayContextKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireReplyRelayContextKind(value)), 1);
@@ -1440,6 +1773,7 @@ function readColdActivationCompletionKind(reader: Reader, context: ServiceWireDe
     default: fail("cold-activation-completion-kind enum");
   }
 }
+
 function writeColdActivationCompletionKind(input: ColdActivationCompletionKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireColdActivationCompletionKind(value)), 1);
@@ -1480,6 +1814,7 @@ function readRejectReason(reader: Reader, context: ServiceWireDecoderContext, en
     default: fail("reject-reason enum");
   }
 }
+
 function writeRejectReason(input: RejectReason, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireRejectReason(value)), 4);
@@ -1500,6 +1835,19 @@ function readActorRef(reader: Reader, context: ServiceWireDecoderContext, enclos
 
 
 
+  return value;
+}
+function* readIncrementalActorRef(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ActorRef, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["actorId"] = yield* readIncrementalText8(reader, context, value, flags);
+
+
+  value["objectGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeActorRef(input: ActorRef, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -1531,6 +1879,19 @@ function readSpotRef(reader: Reader, context: ServiceWireDecoderContext, enclosi
 
 
 
+  return value;
+}
+function* readIncrementalSpotRef(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SpotRef, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["spotId"] = yield* readIncrementalText8(reader, context, value, flags);
+
+
+  value["objectGeneration"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeSpotRef(input: SpotRef, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -1571,6 +1932,7 @@ function readActorCreateTerminal(reader: Reader, context: ServiceWireDecoderCont
 
   return value;
 }
+
 function writeActorCreateTerminal(input: ActorCreateTerminal, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1630,19 +1992,22 @@ function readCreationOperationTerminalV1(reader: Reader, context: ServiceWireDec
     if (same(value["terminalResult"], "ok") && !(same(value["failureCode"], "none") && same(value["hasCreation"], "true"))) fail("creation-operation-terminal-v1 terminal-success-shape");
     if (!same(value["terminalResult"], "ok") && !(same(value["hasCreation"], "false") && same(value["hasApplicationPayload"], "false"))) 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) fail("creation-operation-terminal-v1 maximum");
   return decoded;
 }
+
 function writeCreationOperationTerminalV1(input: CreationOperationTerminalV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
   if (same(value["terminalResult"], "ok") && !(same(value["failureCode"], "none") && same(value["hasCreation"], "true"))) fail("creation-operation-terminal-v1 terminal-success-shape");
   if (!same(value["terminalResult"], "ok") && !(same(value["hasCreation"], "false") && same(value["hasApplicationPayload"], "false"))) 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) fail("terminalResult required");
 
@@ -1697,6 +2062,7 @@ function readOptionalSpotRef(reader: Reader, context: ServiceWireDecoderContext,
 
   return value;
 }
+
 function writeOptionalSpotRef(input: OptionalSpotRef, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1727,6 +2093,16 @@ function readSpotMembership(reader: Reader, context: ServiceWireDecoderContext,
 
 
 
+  return value;
+}
+function* readIncrementalSpotMembership(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SpotMembership, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["spot"] = yield* readIncrementalSpotRef(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeSpotMembership(input: SpotMembership, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -1759,6 +2135,7 @@ function readOptionalSpotMembership(reader: Reader, context: ServiceWireDecoderC
 
   return value;
 }
+
 function writeOptionalSpotMembership(input: OptionalSpotMembership, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1799,6 +2176,7 @@ function readBoundSessionBindingTransition(reader: Reader, context: ServiceWireD
 
   return value;
 }
+
 function writeBoundSessionBindingTransition(input: BoundSessionBindingTransition, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1849,6 +2227,7 @@ function readRetiredBoundSessionRouteFence(reader: Reader, context: ServiceWireD
 
   return value;
 }
+
 function writeRetiredBoundSessionRouteFence(input: RetiredBoundSessionRouteFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1910,6 +2289,7 @@ function readSessionRelocationRouteUpdate(reader: Reader, context: ServiceWireDe
 
   return value;
 }
+
 function writeSessionRelocationRouteUpdate(input: SessionRelocationRouteUpdate, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -1969,6 +2349,7 @@ function readObjectCreationKey(reader: Reader, context: ServiceWireDecoderContex
 
   return value;
 }
+
 function writeObjectCreationKey(input: ObjectCreationKey, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2031,6 +2412,7 @@ function readObjectCreationIntentV1(reader: Reader, context: ServiceWireDecoderC
   if (reader.offset - limitStart > 1048576) fail("object-creation-intent-v1 maximum");
   return decoded;
 }
+
 function writeObjectCreationIntentV1(input: ObjectCreationIntentV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -2089,6 +2471,7 @@ function readPendingObjectCreationV1(reader: Reader, context: ServiceWireDecoder
 
   return value;
 }
+
 function writePendingObjectCreationV1(input: PendingObjectCreationV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2137,6 +2520,7 @@ function readObjectCreationTargetV1(reader: Reader, context: ServiceWireDecoderC
 
   return value;
 }
+
 function writeObjectCreationTargetV1(input: ObjectCreationTargetV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2233,6 +2617,7 @@ function readInstanceActivationRecoveryV1(reader: Reader, context: ServiceWireDe
   if (reader.offset - limitStart > 1048576) fail("instance-activation-recovery-v1 maximum");
   return decoded;
 }
+
 function writeInstanceActivationRecoveryV1(input: InstanceActivationRecoveryV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -2351,6 +2736,7 @@ function readObjectReservationFence(reader: Reader, context: ServiceWireDecoderC
 
   return value;
 }
+
 function writeObjectReservationFence(input: ObjectReservationFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2410,6 +2796,7 @@ function readGenericReservationOperationKind(reader: Reader, context: ServiceWir
     default: fail("generic-reservation-operation-kind enum");
   }
 }
+
 function writeGenericReservationOperationKind(input: GenericReservationOperationKind, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   writer.u(numeric(enumWireGenericReservationOperationKind(value)), 1);
@@ -2460,6 +2847,7 @@ function readGenericObjectReservationV1(reader: Reader, context: ServiceWireDeco
   if (reader.offset - limitStart > 1048576) fail("generic-object-reservation-v1 maximum");
   return decoded;
 }
+
 function writeGenericObjectReservationV1(input: GenericObjectReservationV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -2526,6 +2914,7 @@ function readAggregateId(reader: Reader, context: ServiceWireDecoderContext, enc
 
   return value;
 }
+
 function writeAggregateId(input: AggregateId, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   if (numeric(value["high"]) === 0n && numeric(value["low"]) === 0n) fail("aggregate-id all zero");
@@ -2546,11 +2935,12 @@ export type AggregateParticipantMutationBytes = Uint8Array;
 
 function readAggregateParticipantMutationBytes(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): AggregateParticipantMutationBytes {
   void context; 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 < 1) fail("aggregate-participant-mutation-bytes length");  return reader.take(length);
+  const length = Number(readU32(reader, context, enclosing, flags));  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);
 }
+
 function writeAggregateParticipantMutationBytes(input: AggregateParticipantMutationBytes, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 1048576) fail("aggregate-participant-mutation-bytes length"); if (bytes.length > 2147483647) capacityFail("aggregate-participant-mutation-bytes capacity"); if (bytes.length < 1) fail("aggregate-participant-mutation-bytes length"); writeU32(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeAggregateParticipantMutationBytes(bytes: Uint8Array, context: ServiceWireDecoderContext): AggregateParticipantMutationBytes { const reader = new Reader(bytes); const value = readAggregateParticipantMutationBytes(reader, context, {}, 0); reader.done("aggregate-participant-mutation-bytes"); return value; }
 export function encodeAggregateParticipantMutationBytes(value: AggregateParticipantMutationBytes, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeAggregateParticipantMutationBytes(value, writer, context, {}, 0); return writer.result(); }
@@ -2573,6 +2963,7 @@ function readMaintenanceAggregateParticipantV1(reader: Reader, context: ServiceW
 
   return value;
 }
+
 function writeMaintenanceAggregateParticipantV1(input: MaintenanceAggregateParticipantV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2598,15 +2989,16 @@ export type AggregateParticipantVector = readonly MaintenanceAggregateParticipan
 function readAggregateParticipantVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): AggregateParticipantVector {
   void context; void enclosing; void flags;
   const count = Number(readU16(reader, context, enclosing, flags)); if (count > 1024) fail("aggregate-participant-vector count"); const value: any = 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: AggregateParticipantVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeAggregateParticipantVector(bytes: Uint8Array, context: ServiceWireDecoderContext): AggregateParticipantVector { const reader = new Reader(bytes); const value = readAggregateParticipantVector(reader, context, {}, 0); reader.done("aggregate-participant-vector"); return value; }
@@ -2642,6 +3034,7 @@ function readMaintenanceAggregateV1(reader: Reader, context: ServiceWireDecoderC
   if (reader.offset - limitStart > 1048576) fail("maintenance-aggregate-v1 maximum");
   return decoded;
 }
+
 function writeMaintenanceAggregateV1(input: MaintenanceAggregateV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -2697,6 +3090,28 @@ function readActorRouteFence(reader: Reader, context: ServiceWireDecoderContext,
 
 
 
+  return value;
+}
+function* readIncrementalActorRouteFence(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ActorRouteFence, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: ActorRouteFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -2749,6 +3164,28 @@ function readSpotRouteFence(reader: Reader, context: ServiceWireDecoderContext,
 
 
 
+  return value;
+}
+function* readIncrementalSpotRouteFence(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SpotRouteFence, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: SpotRouteFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -2805,6 +3242,7 @@ function readUserSpotCloseFenceV1(reader: Reader, context: ServiceWireDecoderCon
 
   return value;
 }
+
 function writeUserSpotCloseFenceV1(input: UserSpotCloseFenceV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2856,6 +3294,7 @@ function readMessageFollowRoute(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeMessageFollowRoute(input: MessageFollowRoute, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -2915,6 +3354,7 @@ function readMessageFollowRouteV1(reader: Reader, context: ServiceWireDecoderCon
   if (reader.offset - limitStart > 16777216) fail("message-follow-route-v1 maximum");
   return decoded;
 }
+
 function writeMessageFollowRouteV1(input: MessageFollowRouteV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -2987,6 +3427,40 @@ function readRelocationObjectIdentity(reader: Reader, context: ServiceWireDecode
     value["objectGeneration"] = readNonzeroU64(body, context, value, flags);
 
 
+  } else fail("relocation-object-identity discriminator");
+  body.done("relocation-object-identity");
+
+  return value;
+}
+function* readIncrementalRelocationObjectIdentity(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationObjectIdentity, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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");
 
@@ -3061,6 +3535,7 @@ function readActorAuthorityIdentity(reader: Reader, context: ServiceWireDecoderC
 
   return value;
 }
+
 function writeActorAuthorityIdentity(input: ActorAuthorityIdentity, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3129,6 +3604,7 @@ function readInstanceAuthorityIdentity(reader: Reader, context: ServiceWireDecod
 
   return value;
 }
+
 function writeInstanceAuthorityIdentity(input: InstanceAuthorityIdentity, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3216,6 +3692,7 @@ function readSpotAuthorityIdentity(reader: Reader, context: ServiceWireDecoderCo
 
   return value;
 }
+
 function writeSpotAuthorityIdentity(input: SpotAuthorityIdentity, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3281,6 +3758,7 @@ function readAuthorityObjectIdentity(reader: Reader, context: ServiceWireDecoder
 
   return value;
 }
+
 function writeAuthorityObjectIdentity(input: AuthorityObjectIdentity, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3319,6 +3797,7 @@ function readOperationId(reader: Reader, context: ServiceWireDecoderContext, enc
 
   return value;
 }
+
 function writeOperationId(input: OperationId, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   if (numeric(value["high"]) === 0n && numeric(value["low"]) === 0n) fail("operation-id all zero");
@@ -3348,6 +3827,19 @@ function readOperationIdOrZero(reader: Reader, context: ServiceWireDecoderContex
 
 
 
+  return value;
+}
+function* readIncrementalOperationIdOrZero(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, OperationIdOrZero, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["high"] = yield* readIncrementalU64(reader, context, value, flags);
+
+
+  value["low"] = yield* readIncrementalU64(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeOperationIdOrZero(input: OperationIdOrZero, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -3370,11 +3862,12 @@ export type CreationContentReference = string;
 
 function readCreationContentReference(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): CreationContentReference {
   void context; 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 < 1) fail("creation-content-reference length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("creation-content-reference NUL"); return decodeUtf8(bytes, "creation-content-reference");
+  const length = Number(readU16(reader, context, enclosing, flags));  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); if (bytes.includes(0)) fail("creation-content-reference NUL"); return decodeUtf8(bytes, "creation-content-reference");
 }
+
 function writeCreationContentReference(input: CreationContentReference, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("creation-content-reference length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("creation-content-reference NUL"); 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); writer.put(bytes);
 }
 export function decodeCreationContentReference(bytes: Uint8Array, context: ServiceWireDecoderContext): CreationContentReference { const reader = new Reader(bytes); const value = readCreationContentReference(reader, context, {}, 0); reader.done("creation-content-reference"); return value; }
 export function encodeCreationContentReference(value: CreationContentReference, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeCreationContentReference(value, writer, context, {}, 0); return writer.result(); }
@@ -3383,11 +3876,12 @@ export type RelocationReference = string;
 
 function readRelocationReference(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): RelocationReference {
   void context; 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 < 1) fail("relocation-reference length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("relocation-reference NUL"); return decodeUtf8(bytes, "relocation-reference");
+  const length = Number(readU16(reader, context, enclosing, flags));  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); if (bytes.includes(0)) fail("relocation-reference NUL"); return decodeUtf8(bytes, "relocation-reference");
 }
+
 function writeRelocationReference(input: RelocationReference, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("relocation-reference length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("relocation-reference NUL"); 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); writer.put(bytes);
 }
 export function decodeRelocationReference(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationReference { const reader = new Reader(bytes); const value = readRelocationReference(reader, context, {}, 0); reader.done("relocation-reference"); return value; }
 export function encodeRelocationReference(value: RelocationReference, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeRelocationReference(value, writer, context, {}, 0); return writer.result(); }
@@ -3396,11 +3890,15 @@ export type AuthorityStoreVersion = string;
 
 function readAuthorityStoreVersion(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): AuthorityStoreVersion {
   void context; 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 < 1) fail("authority-store-version length");  const bytes = reader.take(length); if (bytes.includes(0)) fail("authority-store-version NUL"); return decodeUtf8(bytes, "authority-store-version");
+  const length = Number(readU16(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");  const bytes = reader.take(length); if (bytes.includes(0)) fail("authority-store-version NUL"); return decodeUtf8(bytes, "authority-store-version");
+}
+function* readIncrementalAuthorityStoreVersion(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, AuthorityStoreVersion, void> {
+  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: AuthorityStoreVersion, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   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 < 1) fail("authority-store-version length"); writeU16(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = utf8(value); if (bytes.includes(0)) fail("authority-store-version NUL"); 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); writer.put(bytes);
 }
 export function decodeAuthorityStoreVersion(bytes: Uint8Array, context: ServiceWireDecoderContext): AuthorityStoreVersion { const reader = new Reader(bytes); const value = readAuthorityStoreVersion(reader, context, {}, 0); reader.done("authority-store-version"); return value; }
 export function encodeAuthorityStoreVersion(value: AuthorityStoreVersion, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeAuthorityStoreVersion(value, writer, context, {}, 0); return writer.result(); }
@@ -3427,6 +3925,28 @@ function readAuthorityGenerationFence(reader: Reader, context: ServiceWireDecode
 
 
 
+  return value;
+}
+function* readIncrementalAuthorityGenerationFence(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, AuthorityGenerationFence, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: AuthorityGenerationFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -3481,6 +4001,7 @@ function readRelocationCoordinatorFence(reader: Reader, context: ServiceWireDeco
 
   return value;
 }
+
 function writeRelocationCoordinatorFence(input: RelocationCoordinatorFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3530,6 +4051,7 @@ function readRelocationTargetFence(reader: Reader, context: ServiceWireDecoderCo
 
   return value;
 }
+
 function writeRelocationTargetFence(input: RelocationTargetFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3575,6 +4097,7 @@ function readRequestSourceFence(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeRequestSourceFence(input: RequestSourceFence, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3610,6 +4133,19 @@ function readRelocationId(reader: Reader, context: ServiceWireDecoderContext, en
   value["low"] = readU64(reader, context, value, flags);
 
 
+  if (numeric(value["high"]) === 0n && numeric(value["low"]) === 0n) fail("relocation-id all zero");
+
+  return value;
+}
+function* readIncrementalRelocationId(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationId, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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;
@@ -3647,6 +4183,7 @@ function readOptionalActorRef(reader: Reader, context: ServiceWireDecoderContext
 
   return value;
 }
+
 function writeOptionalActorRef(input: OptionalActorRef, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3683,6 +4220,7 @@ function readOptionalBoundSessionTail(reader: Reader, context: ServiceWireDecode
 
   return value;
 }
+
 function writeOptionalBoundSessionTail(input: OptionalBoundSessionTail, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3718,6 +4256,7 @@ function readChannelEntry(reader: Reader, context: ServiceWireDecoderContext, en
 
   return value;
 }
+
 function writeChannelEntry(input: ChannelEntry, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3739,15 +4278,16 @@ export type ChannelVector = readonly ChannelEntry[];
 function readChannelVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): ChannelVector {
   void context; void enclosing; void flags;
   const count = Number(readU16(reader, context, enclosing, flags));  const value: any = 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: ChannelVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeChannelVector(bytes: Uint8Array, context: ServiceWireDecoderContext): ChannelVector { const reader = new Reader(bytes); const value = readChannelVector(reader, context, {}, 0); reader.done("channel-vector"); return value; }
@@ -3758,15 +4298,16 @@ export type SortedText8Vector = readonly Text8[];
 function readSortedText8Vector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): SortedText8Vector {
   void context; void enclosing; void flags;
   const count = Number(readU16(reader, context, enclosing, flags)); if (count > 1024) fail("sorted-text8-vector count"); const value: any = 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: SortedText8Vector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeSortedText8Vector(bytes: Uint8Array, context: ServiceWireDecoderContext): SortedText8Vector { const reader = new Reader(bytes); const value = readSortedText8Vector(reader, context, {}, 0); reader.done("sorted-text8-vector"); return value; }
@@ -3802,6 +4343,7 @@ function readStatefulCapabilityEntry(reader: Reader, context: ServiceWireDecoder
 
   return value;
 }
+
 function writeStatefulCapabilityEntry(input: StatefulCapabilityEntry, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -3843,15 +4385,16 @@ export type StatefulCapabilityVector = readonly StatefulCapabilityEntry[];
 function readStatefulCapabilityVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): StatefulCapabilityVector {
   void context; void enclosing; void flags;
   const count = Number(readU16(reader, context, enclosing, flags)); if (count > 1024) fail("stateful-capability-vector count"); const value: any = 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: StatefulCapabilityVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeStatefulCapabilityVector(bytes: Uint8Array, context: ServiceWireDecoderContext): StatefulCapabilityVector { const reader = new Reader(bytes); const value = readStatefulCapabilityVector(reader, context, {}, 0); reader.done("stateful-capability-vector"); return value; }
@@ -3933,6 +4476,7 @@ function readDescriptorExtension(reader: Reader, context: ServiceWireDecoderCont
   if (reader.offset - limitStart > 1048576) fail("descriptor-extension maximum");
   return decoded;
 }
+
 function writeDescriptorExtension(input: DescriptorExtension, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -4035,6 +4579,7 @@ function readRouteMeshAdmission(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeRouteMeshAdmission(input: RouteMeshAdmission, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4127,6 +4672,7 @@ function readClientServerAdmission(reader: Reader, context: ServiceWireDecoderCo
 
   return value;
 }
+
 function writeClientServerAdmission(input: ClientServerAdmission, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4222,6 +4768,7 @@ function readServiceAdmission(reader: Reader, context: ServiceWireDecoderContext
   if (reader.offset - limitStart > 1048576) fail("service-admission maximum");
   return decoded;
 }
+
 function writeServiceAdmission(input: ServiceAdmission, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -4265,6 +4812,7 @@ function readInstanceReplyRoute(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeInstanceReplyRoute(input: InstanceReplyRoute, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4305,6 +4853,7 @@ function readColdActivationReplyContext(reader: Reader, context: ServiceWireDeco
 
   return value;
 }
+
 function writeColdActivationReplyContext(input: ColdActivationReplyContext, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4360,6 +4909,7 @@ function readReplyRelayContext(reader: Reader, context: ServiceWireDecoderContex
 
   return value;
 }
+
 function writeReplyRelayContext(input: ReplyRelayContext, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4429,6 +4979,39 @@ function readSendReadyDestination(reader: Reader, context: ServiceWireDecoderCon
     value["bindingGeneration"] = readNonzeroU64(body, context, value, flags);
 
 
+  } else fail("send-ready-destination discriminator");
+  body.done("send-ready-destination");
+
+  return value;
+}
+function* readIncrementalSendReadyDestination(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SendReadyDestination, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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");
 
@@ -4492,6 +5075,19 @@ function readActorMembershipSnapshot(reader: Reader, context: ServiceWireDecoder
 
 
 
+  return value;
+}
+function* readIncrementalActorMembershipSnapshot(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ActorMembershipSnapshot, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["actor"] = yield* readIncrementalActorRef(reader, context, value, flags);
+
+
+  value["membership"] = yield* readIncrementalSpotMembership(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeActorMembershipSnapshot(input: ActorMembershipSnapshot, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -4523,6 +5119,22 @@ function readOptionalActorMembershipSnapshot(reader: Reader, context: ServiceWir
     value["snapshot"] = readActorMembershipSnapshot(body, context, value, flags);
 
 
+  } else fail("optional-actor-membership-snapshot discriminator");
+  body.done("optional-actor-membership-snapshot");
+
+  return value;
+}
+function* readIncrementalOptionalActorMembershipSnapshot(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, OptionalActorMembershipSnapshot, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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");
 
@@ -4581,6 +5193,42 @@ function readActorControlData(reader: Reader, context: ServiceWireDecoderContext
     value["previous"] = readActorMembershipSnapshot(body, context, value, flags);
 
 
+  } else fail("actor-control-data discriminator");
+  body.done("actor-control-data");
+
+  return value;
+}
+function* readIncrementalActorControlData(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, ActorControlData, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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"] = yield* readIncrementalActorMembershipSnapshot(body, context, value, flags);
+
+
   } else fail("actor-control-data discriminator");
   body.done("actor-control-data");
 
@@ -4659,13 +5307,41 @@ function readRelocationControlData(reader: Reader, context: ServiceWireDecoderCo
 
 
 
-  if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("relocation-control-data runtime predicate");
+  void context;
+  if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("relocation-control-data runtime predicate");
+  return value;
+}
+function* readIncrementalRelocationControlData(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationControlData, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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;
 }
 function writeRelocationControlData(input: RelocationControlData, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
-  if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("relocation-control-data runtime predicate");
+  void context;
+  if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("relocation-control-data runtime predicate");
   if (value["phase"] === undefined) fail("phase required");
 
 
@@ -4751,6 +5427,7 @@ function readRequestSpecificTail(reader: Reader, context: ServiceWireDecoderCont
 
   return value;
 }
+
 function writeRequestSpecificTail(input: RequestSpecificTail, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -4911,6 +5588,7 @@ function readFrozenRecordBody(reader: Reader, context: ServiceWireDecoderContext
 
 
     }
+    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);
 
@@ -4934,12 +5612,123 @@ function readFrozenRecordBody(reader: Reader, context: ServiceWireDecoderContext
 
   } 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrozenRecordBody, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: FrozenRecordBody, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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")) {
@@ -5054,6 +5843,7 @@ function writeFrozenRecordBody(input: FrozenRecordBody, writer: Writer, context:
 
       writeApplicationPayloadEnvelopeV1(value["payload"], body, context, value, 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) fail("frozen-record-body discriminator agreement");
     if (value["destination"] === undefined) fail("destination required");
@@ -5090,81 +5880,161 @@ function writeFrozenRecordBody(input: FrozenRecordBody, writer: Writer, context:
 export function decodeFrozenRecordBody(bytes: Uint8Array, context: ServiceWireDecoderContext): FrozenRecordBody { const reader = new Reader(bytes); const value = readFrozenRecordBody(reader, context, {}, 0); reader.done("frozen-record-body"); return value; }
 export function encodeFrozenRecordBody(value: FrozenRecordBody, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeFrozenRecordBody(value, writer, context, {}, 0); return writer.result(); }
 
-export type FrozenSourceIdentity = { readonly sourceKind: "node"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64 } | { readonly sourceKind: "spot"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceSpotId: Text8 } | { readonly sourceKind: "actor"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceActor: ActorRef } | { readonly sourceKind: "boundSession"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceActor: ActorRef; readonly sourceSessionRid: Rid; readonly sourceBindingGeneration: NonzeroU64; readonly sourceSessionSequence: NonzeroU64 };
+export type FrozenSourceIdentity = { readonly sourceKind: "node"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64 } | { readonly sourceKind: "spot"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceSpotId: Text8 } | { readonly sourceKind: "actor"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceActor: ActorRef } | { readonly sourceKind: "boundSession"; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly sourceOwnerId: Text8; readonly sourceOwnerLeaseGeneration: NonzeroU64; readonly sourceActor: ActorRef; readonly sourceSessionRid: Rid; readonly sourceBindingGeneration: NonzeroU64; readonly sourceSessionSequence: NonzeroU64 };
+
+function readFrozenSourceIdentity(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): FrozenSourceIdentity {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["sourceKind"] = readFrozenSourceKind(reader, context, enclosing, flags);
+  const body = reader.bounded(Number(readU16(reader, context, enclosing, flags)));
+  if (same(value["sourceKind"], "node")) {
+    value["sourceNodeRid"] = readRid(body, context, value, flags);
+
+
+    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceOwnerId"] = readText8(body, context, value, flags);
+
+
+    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+  } else if (same(value["sourceKind"], "spot")) {
+    value["sourceNodeRid"] = readRid(body, context, value, flags);
+
+
+    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceOwnerId"] = readText8(body, context, value, flags);
+
+
+    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceSpotId"] = readText8(body, context, value, flags);
+
+
+  } else if (same(value["sourceKind"], "actor")) {
+    value["sourceNodeRid"] = readRid(body, context, value, flags);
+
+
+    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceOwnerId"] = readText8(body, context, value, flags);
+
+
+    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceActor"] = readActorRef(body, context, value, flags);
+
+
+  } else if (same(value["sourceKind"], "boundSession")) {
+    value["sourceNodeRid"] = readRid(body, context, value, flags);
+
+
+    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceOwnerId"] = readText8(body, context, value, flags);
+
+
+    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceActor"] = readActorRef(body, context, value, flags);
+
+
+    value["sourceSessionRid"] = readRid(body, context, value, flags);
+
+
+    value["sourceBindingGeneration"] = readNonzeroU64(body, context, value, flags);
+
+
+    value["sourceSessionSequence"] = readNonzeroU64(body, context, value, flags);
+
 
-function readFrozenSourceIdentity(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): FrozenSourceIdentity {
+  } else fail("frozen-source-identity discriminator");
+  body.done("frozen-source-identity");
+
+  return value;
+}
+function* readIncrementalFrozenSourceIdentity(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrozenSourceIdentity, void> {
   void context; void enclosing; void flags;
   const value: any = {};
-  value["sourceKind"] = readFrozenSourceKind(reader, context, enclosing, flags);
-  const body = reader.bounded(Number(readU16(reader, context, enclosing, flags)));
+  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"] = readRid(body, context, value, flags);
+    value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
 
 
-    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceOwnerId"] = readText8(body, context, value, flags);
+    value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
 
 
-    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
   } else if (same(value["sourceKind"], "spot")) {
-    value["sourceNodeRid"] = readRid(body, context, value, flags);
+    value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
 
 
-    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceOwnerId"] = readText8(body, context, value, flags);
+    value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
 
 
-    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceSpotId"] = readText8(body, context, value, flags);
+    value["sourceSpotId"] = yield* readIncrementalText8(body, context, value, flags);
 
 
   } else if (same(value["sourceKind"], "actor")) {
-    value["sourceNodeRid"] = readRid(body, context, value, flags);
+    value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
 
 
-    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceOwnerId"] = readText8(body, context, value, flags);
+    value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
 
 
-    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceActor"] = readActorRef(body, context, value, flags);
+    value["sourceActor"] = yield* readIncrementalActorRef(body, context, value, flags);
 
 
   } else if (same(value["sourceKind"], "boundSession")) {
-    value["sourceNodeRid"] = readRid(body, context, value, flags);
+    value["sourceNodeRid"] = yield* readIncrementalRid(body, context, value, flags);
 
 
-    value["sourceNodeGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceNodeGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceOwnerId"] = readText8(body, context, value, flags);
+    value["sourceOwnerId"] = yield* readIncrementalText8(body, context, value, flags);
 
 
-    value["sourceOwnerLeaseGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceOwnerLeaseGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceActor"] = readActorRef(body, context, value, flags);
+    value["sourceActor"] = yield* readIncrementalActorRef(body, context, value, flags);
 
 
-    value["sourceSessionRid"] = readRid(body, context, value, flags);
+    value["sourceSessionRid"] = yield* readIncrementalRid(body, context, value, flags);
 
 
-    value["sourceBindingGeneration"] = readNonzeroU64(body, context, value, flags);
+    value["sourceBindingGeneration"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
-    value["sourceSessionSequence"] = readNonzeroU64(body, context, value, flags);
+    value["sourceSessionSequence"] = yield* readIncrementalNonzeroU64(body, context, value, flags);
 
 
   } else fail("frozen-source-identity discriminator");
@@ -5306,6 +6176,38 @@ function readFrozenReplyRoute(reader: Reader, context: ServiceWireDecoderContext
     value["replyRouteId"] = readNonzeroU64(body, context, value, flags);
 
 
+  } else {
+
+  }
+  body.done("frozen-reply-route");
+
+  return value;
+}
+function* readIncrementalFrozenReplyRoute(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrozenReplyRoute, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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 {
 
   }
@@ -5390,6 +6292,39 @@ function readFrozenRecord(reader: Reader, context: ServiceWireDecoderContext, en
 
 
 
+  return value;
+}
+function* readIncrementalFrozenRecord(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, FrozenRecord, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: FrozenRecord, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -5476,6 +6411,51 @@ function readInstanceRouteV1(reader: Reader, context: ServiceWireDecoderContext,
     value["deadlineUnixMs"] = readNonzeroU64(body, context, value, flags);
 
 
+  } else fail("instance-route-v1 discriminator");
+  body.done("instance-route-v1");
+
+  return value;
+}
+function* readIncrementalInstanceRouteV1(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, InstanceRouteV1, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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");
 
@@ -5561,6 +6541,7 @@ function readRelocationRootPointer(reader: Reader, context: ServiceWireDecoderCo
 
   return value;
 }
+
 function writeRelocationRootPointer(input: RelocationRootPointer, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -5667,6 +6648,7 @@ function readAuthorityRelocationState(reader: Reader, context: ServiceWireDecode
   if (reader.offset - limitStart > 1048576) fail("authority-relocation-state maximum");
   return decoded;
 }
+
 function writeAuthorityRelocationState(input: AuthorityRelocationState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
   const limitStart = writer.length;
@@ -5800,6 +6782,7 @@ function readAuthorityActivationRecoveryState(reader: Reader, context: ServiceWi
 
   return value;
 }
+
 function writeAuthorityActivationRecoveryState(input: AuthorityActivationRecoveryState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -5873,6 +6856,7 @@ function readAuthorityPayloadV1(reader: Reader, context: ServiceWireDecoderConte
 
   return value;
 }
+
 function writeAuthorityPayloadV1(input: AuthorityPayloadV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -5933,6 +6917,22 @@ function readSavedWorkEntry(reader: Reader, context: ServiceWireDecoderContext,
 
 
 
+  return value;
+}
+function* readIncrementalSavedWorkEntry(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SavedWorkEntry, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: SavedWorkEntry, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -5960,15 +6960,22 @@ export type SavedWorkVector = readonly SavedWorkEntry[];
 function readSavedWorkVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): SavedWorkVector {
   void context; void enclosing; void flags;
   const count = Number(readU32(reader, context, enclosing, flags));  const value: any = 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, SavedWorkVector, void> {
+  void context; void enclosing; void flags;
+  const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));  const value: any[] = []; 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: SavedWorkVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeSavedWorkVector(bytes: Uint8Array, context: ServiceWireDecoderContext): SavedWorkVector { const reader = new Reader(bytes); const value = readSavedWorkVector(reader, context, {}, 0); reader.done("saved-work-vector"); return value; }
@@ -5978,11 +6985,12 @@ export type DurableBlob = Uint8Array;
 
 function readDurableBlob(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): DurableBlob {
   void context; 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 < 0) fail("durable-blob length");  return reader.take(length);
+  const length = Number(readU32(reader, context, enclosing, flags));  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);
 }
+
 function writeDurableBlob(input: DurableBlob, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 67108864) fail("durable-blob length"); if (bytes.length > 2147483647) capacityFail("durable-blob capacity"); if (bytes.length < 0) fail("durable-blob length"); writeU32(bytes.length, writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeDurableBlob(bytes: Uint8Array, context: ServiceWireDecoderContext): DurableBlob { const reader = new Reader(bytes); const value = readDurableBlob(reader, context, {}, 0); reader.done("durable-blob"); return value; }
 export function encodeDurableBlob(value: DurableBlob, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeDurableBlob(value, writer, context, {}, 0); return writer.result(); }
@@ -5991,11 +6999,15 @@ export type DurableStateBlob = Uint8Array;
 
 function readDurableStateBlob(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): DurableStateBlob {
   void context; void enclosing; void flags;
-  const length = Number(readU64(reader, context, enclosing, flags));  if (length > 67108864) fail("durable-state-blob length"); if (length > 2147483647) capacityFail("durable-state-blob capacity"); if (length < 0) fail("durable-state-blob length");  return reader.take(length);
+  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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, DurableStateBlob, void> {
+  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 yield* reader.bytes(length);
 }
 function writeDurableStateBlob(input: DurableStateBlob, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
-   const bytes = value as Uint8Array;  if (bytes.length > 67108864) fail("durable-state-blob length"); if (bytes.length > 2147483647) capacityFail("durable-state-blob capacity"); if (bytes.length < 0) fail("durable-state-blob length"); writeU64(numeric(bytes.length), writer, context, enclosing, flags); writer.put(bytes);
+   const bytes = value as Uint8Array;  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); writer.put(bytes);
 }
 export function decodeDurableStateBlob(bytes: Uint8Array, context: ServiceWireDecoderContext): DurableStateBlob { const reader = new Reader(bytes); const value = readDurableStateBlob(reader, context, {}, 0); reader.done("durable-state-blob"); return value; }
 export function encodeDurableStateBlob(value: DurableStateBlob, context: ServiceWireDecoderContext): Uint8Array { const writer = new Writer(); writeDurableStateBlob(value, writer, context, {}, 0); return writer.result(); }
@@ -6021,6 +7033,7 @@ function readRelocationChunkEntryV1(reader: Reader, context: ServiceWireDecoderC
 
   return value;
 }
+
 function writeRelocationChunkEntryV1(input: RelocationChunkEntryV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -6050,15 +7063,16 @@ export type RelocationChunkVectorV1 = readonly RelocationChunkEntryV1[];
 function readRelocationChunkVectorV1(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): RelocationChunkVectorV1 {
   void context; void enclosing; void flags;
   const count = Number(readU32(reader, context, enclosing, flags)); if (count > 4096) fail("relocation-chunk-vector-v1 count"); const value: any = 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: RelocationChunkVectorV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeRelocationChunkVectorV1(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationChunkVectorV1 { const reader = new Reader(bytes); const value = readRelocationChunkVectorV1(reader, context, {}, 0); reader.done("relocation-chunk-vector-v1"); return value; }
@@ -6088,6 +7102,7 @@ function readRelocationManifestV1(reader: Reader, context: ServiceWireDecoderCon
 
   return value;
 }
+
 function writeRelocationManifestV1(input: RelocationManifestV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -6131,6 +7146,7 @@ function readRelocationDataChunkV1(reader: Reader, context: ServiceWireDecoderCo
 
   return value;
 }
+
 function writeRelocationDataChunkV1(input: RelocationDataChunkV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = input;
 
@@ -6161,6 +7177,26 @@ function readRelocationApplicationState(reader: Reader, context: ServiceWireDeco
       value["payload"] = readDurableStateBlob(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* readIncrementalRelocationApplicationState(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationApplicationState, void> {
+  void context; void enclosing; void flags;
+  const limitStart = reader.offset; const decoded = yield* (function* (): Generator<void, RelocationApplicationState, void> {
+    const value: any = {};
+    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");
 
@@ -6204,6 +7240,19 @@ function readRelocationParticipantApplicationState(reader: Reader, context: Serv
 
 
 
+  return value;
+}
+function* readIncrementalRelocationParticipantApplicationState(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationParticipantApplicationState, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  value["participantId"] = yield* readIncrementalNonzeroU64(reader, context, value, flags);
+
+
+  value["applicationState"] = yield* readIncrementalRelocationApplicationState(reader, context, value, flags);
+
+
+
+
   return value;
 }
 function writeRelocationParticipantApplicationState(input: RelocationParticipantApplicationState, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -6227,15 +7276,22 @@ export type RelocationParticipantApplicationStateVector = readonly RelocationPar
 function readRelocationParticipantApplicationStateVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): RelocationParticipantApplicationStateVector {
   void context; void enclosing; void flags;
   const count = Number(readU32(reader, context, enclosing, flags)); if (count > 1024) fail("relocation-participant-application-state-vector count"); const value: any = 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationParticipantApplicationStateVector, void> {
+  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: any[] = []; 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: RelocationParticipantApplicationStateVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeRelocationParticipantApplicationStateVector(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationParticipantApplicationStateVector { const reader = new Reader(bytes); const value = readRelocationParticipantApplicationStateVector(reader, context, {}, 0); reader.done("relocation-participant-application-state-vector"); return value; }
@@ -6278,6 +7334,43 @@ function readRelocationTimerRegistration(reader: Reader, context: ServiceWireDec
 
 
 
+  return value;
+}
+function* readIncrementalRelocationTimerRegistration(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationTimerRegistration, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: RelocationTimerRegistration, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -6333,15 +7426,22 @@ export type RelocationTimerRegistrationVector = readonly RelocationTimerRegistra
 function readRelocationTimerRegistrationVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): RelocationTimerRegistrationVector {
   void context; void enclosing; void flags;
   const count = Number(readU32(reader, context, enclosing, flags));  const value: any = 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationTimerRegistrationVector, void> {
+  void context; void enclosing; void flags;
+  const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));  const value: any[] = []; 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: RelocationTimerRegistrationVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeRelocationTimerRegistrationVector(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationTimerRegistrationVector { const reader = new Reader(bytes); const value = readRelocationTimerRegistrationVector(reader, context, {}, 0); reader.done("relocation-timer-registration-vector"); return value; }
@@ -6375,6 +7475,34 @@ function readRelocationPendingTimerTick(reader: Reader, context: ServiceWireDeco
 
 
 
+  return value;
+}
+function* readIncrementalRelocationPendingTimerTick(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationPendingTimerTick, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: RelocationPendingTimerTick, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -6418,15 +7546,22 @@ export type RelocationPendingTimerTickVector = readonly RelocationPendingTimerTi
 function readRelocationPendingTimerTickVector(reader: Reader, context: ServiceWireDecoderContext, enclosing: any, flags: number): RelocationPendingTimerTickVector {
   void context; void enclosing; void flags;
   const count = Number(readU32(reader, context, enclosing, flags));  const value: any = 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: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationPendingTimerTickVector, void> {
+  void context; void enclosing; void flags;
+  const count = Number(yield* readIncrementalU32(reader, context, enclosing, flags));  const value: any[] = []; 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: RelocationPendingTimerTickVector, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
   void context; void enclosing; void flags; const value: any = 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);
 }
 export function decodeRelocationPendingTimerTickVector(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationPendingTimerTickVector { const reader = new Reader(bytes); const value = readRelocationPendingTimerTickVector(reader, context, {}, 0); reader.done("relocation-pending-timer-tick-vector"); return value; }
@@ -6460,6 +7595,34 @@ function readRelocationEnvelopeV1(reader: Reader, context: ServiceWireDecoderCon
 
 
 
+  return value;
+}
+function* readIncrementalRelocationEnvelopeV1(reader: IncrementalInput, context: ServiceWireDecoderContext, enclosing: any, flags: number): Generator<void, RelocationEnvelopeV1, void> {
+  void context; void enclosing; void flags;
+  const value: any = {};
+  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: RelocationEnvelopeV1, writer: Writer, context: ServiceWireDecoderContext, enclosing: any, flags: number): void {
@@ -6516,7 +7679,7 @@ export function encodeHelloCommand(value: HelloCommand, context: ServiceWireDeco
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateHelloCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateHelloCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type AdmitCommand = { readonly command: "admit"; readonly flags: number; readonly admission: ServiceAdmission; };
 export function decodeAdmitCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): AdmitCommand { if (!frames.length) fail("admit frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 2) fail("admit header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("admit flags"); const value: any = { command: "admit", flags };
@@ -6536,7 +7699,7 @@ export function encodeAdmitCommand(value: AdmitCommand, context: ServiceWireDeco
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateAdmitCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateAdmitCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RejectCommand = { readonly command: "reject"; readonly flags: number; readonly reason: RejectReason; };
 export function decodeRejectCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RejectCommand { if (!frames.length) fail("reject frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 3) fail("reject header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("reject flags"); const value: any = { command: "reject", flags };
@@ -6556,7 +7719,7 @@ export function encodeRejectCommand(value: RejectCommand, context: ServiceWireDe
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRejectCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRejectCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type UpdateCommand = { readonly command: "update"; readonly flags: number; readonly admission: ServiceAdmission; };
 export function decodeUpdateCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): UpdateCommand { if (!frames.length) fail("update frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 4) fail("update header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("update flags"); const value: any = { command: "update", flags };
@@ -6576,7 +7739,7 @@ export function encodeUpdateCommand(value: UpdateCommand, context: ServiceWireDe
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateUpdateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateUpdateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type LivenessProbeCommand = { readonly command: "livenessProbe"; readonly flags: number; readonly probeId: NonzeroU64; };
 export function decodeLivenessProbeCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): LivenessProbeCommand { if (!frames.length) fail("livenessProbe frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 5) fail("livenessProbe header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("livenessProbe flags"); const value: any = { command: "livenessProbe", flags };
@@ -6596,7 +7759,7 @@ export function encodeLivenessProbeCommand(value: LivenessProbeCommand, context:
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateLivenessProbeCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateLivenessProbeCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type LivenessAckCommand = { readonly command: "livenessAck"; readonly flags: number; readonly probeId: NonzeroU64; };
 export function decodeLivenessAckCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): LivenessAckCommand { if (!frames.length) fail("livenessAck frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 6) fail("livenessAck header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("livenessAck flags"); const value: any = { command: "livenessAck", flags };
@@ -6616,7 +7779,7 @@ export function encodeLivenessAckCommand(value: LivenessAckCommand, context: Ser
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateLivenessAckCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateLivenessAckCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type NodeSendCommand = { readonly command: "nodeSend"; readonly flags: number; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeNodeSendCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): NodeSendCommand { if (!frames.length) fail("nodeSend frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 16) fail("nodeSend header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("nodeSend flags"); const value: any = { command: "nodeSend", flags };
@@ -6633,7 +7796,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("nodeSend metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("nodeSend metadata forbidden");
   if (value.payload === undefined) fail("nodeSend payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateNodeSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateNodeSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type NodeRequestCommand = { readonly command: "nodeRequest"; readonly flags: number; readonly correlation: NonzeroU64; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeNodeRequestCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): NodeRequestCommand { if (!frames.length) fail("nodeRequest frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 17) fail("nodeRequest header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("nodeRequest flags"); const value: any = { command: "nodeRequest", flags };
@@ -6655,7 +7818,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("nodeRequest metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("nodeRequest metadata forbidden");
   if (value.payload === undefined) fail("nodeRequest payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateNodeRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateNodeRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ChannelSendCommand = { readonly command: "channelSend"; readonly flags: number; readonly channelName: Text8; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeChannelSendCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ChannelSendCommand { if (!frames.length) fail("channelSend frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 18) fail("channelSend header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("channelSend flags"); const value: any = { command: "channelSend", flags };
@@ -6677,7 +7840,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("channelSend metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("channelSend metadata forbidden");
   if (value.payload === undefined) fail("channelSend payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateChannelSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateChannelSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ChannelRequestCommand = { readonly command: "channelRequest"; readonly flags: number; readonly correlation: NonzeroU64; readonly channelName: Text8; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeChannelRequestCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ChannelRequestCommand { if (!frames.length) fail("channelRequest frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 19) fail("channelRequest header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("channelRequest flags"); const value: any = { command: "channelRequest", flags };
@@ -6706,7 +7869,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("channelRequest metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("channelRequest metadata forbidden");
   if (value.payload === undefined) fail("channelRequest payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateChannelRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateChannelRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ReplyCommand = { readonly command: "reply"; readonly flags: number; readonly correlation: NonzeroU64; readonly terminalResult: RequestTerminalResult; readonly failureCode: FrameworkErrorCode; readonly tail: RequestSpecificTail; readonly payload?: ApplicationPayloadEnvelopeV1; };
 export function decodeReplyCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ReplyCommand { if (!frames.length) fail("reply frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 20) fail("reply header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("reply flags"); const value: any = { command: "reply", flags };
@@ -6725,9 +7888,11 @@ export function decodeReplyCommand(frames: readonly Uint8Array[], context: Servi
 reader.done("reply"); let frameIndex = 1;
   if (frameIndex < frames.length) 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"])))) fail("reply runtime predicate");
+  void context;
+  if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("reply runtime predicate");
 return value; }
-export function encodeReplyCommand(value: ReplyCommand, context: ServiceWireDecoderContext): readonly Uint8Array[] { 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"])))) fail("reply runtime predicate"); const writer = new Writer(); writer.put([90,77, 1, 20, value.flags]);
+export function encodeReplyCommand(value: ReplyCommand, context: ServiceWireDecoderContext): readonly Uint8Array[] { if ((value.flags & ~0) !== 0 || (value.flags & 0) !== 0) fail("reply flags"); 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]);
   if (value["correlation"] === undefined) fail("correlation required");
 
 
@@ -6747,7 +7912,8 @@ export function encodeReplyCommand(value: ReplyCommand, context: ServiceWireDeco
 const frames: Uint8Array[] = [writer.result()];
   if (value.payload !== undefined) frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateReplyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("reply runtime predicate"); }
+export function validateReplyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; void context;
+if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("reply runtime predicate"); }
 
 export type SpotSendCommand = { readonly command: "spotSend"; readonly flags: number; readonly operation: OperationId; readonly messageFollowHopCount: U8; readonly sourceSpotId: Text8; readonly targetSpot: SpotRouteFence; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeSpotSendCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SpotSendCommand { if (!frames.length) fail("spotSend frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 21) fail("spotSend header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("spotSend flags"); const value: any = { command: "spotSend", flags };
@@ -6790,7 +7956,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("spotSend metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("spotSend metadata forbidden");
   if (value.payload === undefined) fail("spotSend payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateSpotSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateSpotSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type SpotRequestCommand = { readonly command: "spotRequest"; readonly flags: number; readonly correlation: NonzeroU64; readonly operation: OperationId; readonly messageFollowHopCount: U8; readonly sourceSpotId: Text8; readonly targetSpot: SpotRouteFence; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeSpotRequestCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SpotRequestCommand { if (!frames.length) fail("spotRequest frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 22) fail("spotRequest header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("spotRequest flags"); const value: any = { command: "spotRequest", flags };
@@ -6840,7 +8006,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("spotRequest metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("spotRequest metadata forbidden");
   if (value.payload === undefined) fail("spotRequest payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateSpotRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateSpotRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type LogicalMulticastCommand = { readonly command: "logicalMulticast"; readonly flags: number; readonly channelName: Text8; readonly topic: Text8; readonly sourceSpotId: Text8; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeLogicalMulticastCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): LogicalMulticastCommand { if (!frames.length) fail("logicalMulticast frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 23) fail("logicalMulticast header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("logicalMulticast flags"); const value: any = { command: "logicalMulticast", flags };
@@ -6876,7 +8042,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("logicalMulticast metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("logicalMulticast metadata forbidden");
   if (value.payload === undefined) fail("logicalMulticast payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateLogicalMulticastCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateLogicalMulticastCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorSendCommand = { readonly command: "actorSend"; readonly flags: number; readonly operation: OperationId; readonly messageFollowHopCount: U8; readonly sourceActor: OptionalActorRef; readonly targetActor: ActorRouteFence; readonly boundSessionTail?: OptionalBoundSessionTail; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeActorSendCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorSendCommand { if (!frames.length) fail("actorSend frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 24) fail("actorSend header"); const flags = Number(reader.u(1)); if ((flags & ~7) !== 0 || (flags & 0) !== 0) fail("actorSend flags");
@@ -6932,7 +8098,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("actorSend metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("actorSend metadata forbidden");
   if (value.payload === undefined) fail("actorSend payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateActorSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorRequestCommand = { readonly command: "actorRequest"; readonly flags: number; readonly correlation: NonzeroU64; readonly operation: OperationId; readonly messageFollowHopCount: U8; readonly sourceActor: OptionalActorRef; readonly targetActor: ActorRouteFence; readonly boundSessionTail?: OptionalBoundSessionTail; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeActorRequestCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorRequestCommand { if (!frames.length) fail("actorRequest frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 25) fail("actorRequest header"); const flags = Number(reader.u(1)); if ((flags & ~7) !== 0 || (flags & 0) !== 0) fail("actorRequest flags");
@@ -6995,7 +8161,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("actorRequest metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("actorRequest metadata forbidden");
   if (value.payload === undefined) fail("actorRequest payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateActorRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorRequestCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorLookupCommand = { readonly command: "actorLookup"; readonly flags: number; readonly correlation: NonzeroU64; readonly actorId: Text8; };
 export function decodeActorLookupCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorLookupCommand { if (!frames.length) fail("actorLookup frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 26) fail("actorLookup header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorLookup flags"); const value: any = { command: "actorLookup", flags };
@@ -7022,7 +8188,7 @@ export function encodeActorLookupCommand(value: ActorLookupCommand, context: Ser
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateActorLookupCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorLookupCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorDestroyCommand = { readonly command: "actorDestroy"; readonly flags: number; readonly correlation: NonzeroU64; readonly actor: ActorRouteFence; };
 export function decodeActorDestroyCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorDestroyCommand { if (!frames.length) fail("actorDestroy frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 27) fail("actorDestroy header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorDestroy flags"); const value: any = { command: "actorDestroy", flags };
@@ -7049,7 +8215,7 @@ export function encodeActorDestroyCommand(value: ActorDestroyCommand, context: S
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateActorDestroyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorDestroyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorJoinCommand = { readonly command: "actorJoin"; readonly flags: number; readonly correlation: NonzeroU64; readonly actor: ActorRouteFence; readonly entry: Bool8; readonly targetSpot: SpotRouteFence; readonly payload?: ApplicationPayloadEnvelopeV1; };
 export function decodeActorJoinCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorJoinCommand { if (!frames.length) fail("actorJoin frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 28) fail("actorJoin header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorJoin flags"); const value: any = { command: "actorJoin", flags };
@@ -7090,7 +8256,7 @@ export function encodeActorJoinCommand(value: ActorJoinCommand, context: Service
 const frames: Uint8Array[] = [writer.result()];
   if (value.payload !== undefined) frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateActorJoinCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorJoinCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorLeftCommand = { readonly command: "actorLeft"; readonly flags: number; readonly actor: ActorRef; readonly previousMembership: SpotMembership; readonly currentAuthorityOwnerGeneration: NonzeroU64; };
 export function decodeActorLeftCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorLeftCommand { if (!frames.length) fail("actorLeft frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 29) fail("actorLeft header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorLeft flags"); const value: any = { command: "actorLeft", flags };
@@ -7124,7 +8290,7 @@ export function encodeActorLeftCommand(value: ActorLeftCommand, context: Service
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateActorLeftCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorLeftCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RelocationReadyCommand = { readonly command: "relocationReady"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly target: RelocationTargetFence; readonly object: RelocationObjectIdentity; readonly senderRole: RelocationRole; };
 export function decodeRelocationReadyCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationReadyCommand { if (!frames.length) fail("relocationReady frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 30) fail("relocationReady header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationReady flags"); const value: any = { command: "relocationReady", flags };
@@ -7179,7 +8345,7 @@ export function encodeRelocationReadyCommand(value: RelocationReadyCommand, cont
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationReadyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationReadyCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RelocationDataCommand = { readonly command: "relocationData"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly senderRole: RelocationRole; readonly object: RelocationObjectIdentity; readonly record: FrozenRecord; };
 export function decodeRelocationDataCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationDataCommand { if (!frames.length) fail("relocationData frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 31) fail("relocationData header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationData flags"); const value: any = { command: "relocationData", flags };
@@ -7234,7 +8400,7 @@ export function encodeRelocationDataCommand(value: RelocationDataCommand, contex
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationDataCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationDataCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ReplyRelayCommand = { readonly command: "replyRelay"; readonly flags: number; readonly operation: OperationId; readonly replyRouteId: NonzeroU64; readonly context: ReplyRelayContext; readonly terminalResult: RequestTerminalResult; readonly failureCode: FrameworkErrorCode; readonly payload?: ApplicationPayloadEnvelopeV1; };
 export function decodeReplyRelayCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ReplyRelayCommand { if (!frames.length) fail("replyRelay frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 33) fail("replyRelay header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("replyRelay flags"); const value: any = { command: "replyRelay", flags };
@@ -7256,9 +8422,11 @@ export function decodeReplyRelayCommand(frames: readonly Uint8Array[], context:
 reader.done("replyRelay"); let frameIndex = 1;
   if (frameIndex < frames.length) 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"])))) fail("replyRelay runtime predicate");
+  void context;
+  if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("replyRelay runtime predicate");
 return value; }
-export function encodeReplyRelayCommand(value: ReplyRelayCommand, context: ServiceWireDecoderContext): readonly Uint8Array[] { 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"])))) fail("replyRelay runtime predicate"); const writer = new Writer(); writer.put([90,77, 1, 33, value.flags]);
+export function encodeReplyRelayCommand(value: ReplyRelayCommand, context: ServiceWireDecoderContext): readonly Uint8Array[] { if ((value.flags & ~0) !== 0 || (value.flags & 0) !== 0) fail("replyRelay flags"); 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]);
   if (value["operation"] === undefined) fail("operation required");
 
 
@@ -7282,7 +8450,8 @@ export function encodeReplyRelayCommand(value: ReplyRelayCommand, context: Servi
 const frames: Uint8Array[] = [writer.result()];
   if (value.payload !== undefined) frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateReplyRelayCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { if (!(runtimePredicate(context, "service-wire-constants.valid-terminal-failure", enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("replyRelay runtime predicate"); }
+export function validateReplyRelayCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; void context;
+if (!(validTerminalFailure(enumWireRequestTerminalResult(value["terminalResult"]), enumWireFrameworkErrorCode(value["failureCode"])))) fail("replyRelay runtime predicate"); }
 
 export type RelocationCutoverCommand = { readonly command: "relocationCutover"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly senderRole: RelocationRole; readonly object: RelocationObjectIdentity; readonly boundaryRecordCount: OrdinalOrZero; readonly boundaryChecksumCrc32c: U32; };
 export function decodeRelocationCutoverCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationCutoverCommand { if (!frames.length) fail("relocationCutover frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 34) fail("relocationCutover header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationCutover flags"); const value: any = { command: "relocationCutover", flags };
@@ -7344,7 +8513,7 @@ export function encodeRelocationCutoverCommand(value: RelocationCutoverCommand,
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationCutoverCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationCutoverCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type BoundSessionSendCommand = { readonly command: "boundSessionSend"; readonly flags: number; readonly actor: ActorRouteFence; readonly expectedBindingGeneration: NonzeroU64; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeBoundSessionSendCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): BoundSessionSendCommand { if (!frames.length) fail("boundSessionSend frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 36) fail("boundSessionSend header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("boundSessionSend flags"); const value: any = { command: "boundSessionSend", flags };
@@ -7371,7 +8540,7 @@ export function encodeBoundSessionSendCommand(value: BoundSessionSendCommand, co
 const frames: Uint8Array[] = [writer.result()];
   if (value.payload === undefined) fail("boundSessionSend payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateBoundSessionSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateBoundSessionSendCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorJoinedCommand = { readonly command: "actorJoined"; readonly flags: number; readonly actor: ActorRef; readonly previousMembership: OptionalSpotMembership; readonly currentMembership: SpotMembership; readonly currentAuthorityOwnerGeneration: NonzeroU64; };
 export function decodeActorJoinedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorJoinedCommand { if (!frames.length) fail("actorJoined frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 37) fail("actorJoined header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorJoined flags"); const value: any = { command: "actorJoined", flags };
@@ -7412,7 +8581,7 @@ export function encodeActorJoinedCommand(value: ActorJoinedCommand, context: Ser
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateActorJoinedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorJoinedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type BoundSessionBindCommand = { readonly command: "boundSessionBind"; readonly flags: number; readonly correlation: NonzeroU64; readonly actor: ActorRouteFence; readonly sessionRid: Rid; readonly binding: BoundSessionBindingTransition; };
 export function decodeBoundSessionBindCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): BoundSessionBindCommand { if (!frames.length) fail("boundSessionBind frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 38) fail("boundSessionBind header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("boundSessionBind flags"); const value: any = { command: "boundSessionBind", flags };
@@ -7453,7 +8622,7 @@ export function encodeBoundSessionBindCommand(value: BoundSessionBindCommand, co
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateBoundSessionBindCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateBoundSessionBindCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type InstanceSpotCommand = { readonly command: "instanceSpot"; readonly flags: number; readonly route: InstanceRouteV1; readonly sourceNodeGeneration: NonzeroU64; readonly sourceNodeRid: Rid; readonly sourceSpotId: OptionalText8; readonly operationKind: InstanceOperationKind; readonly operation: OperationIdOrZero; readonly replyRoute: InstanceReplyRoute; readonly metadata?: MetadataFrame; readonly payload: ApplicationPayloadEnvelopeV1; };
 export function decodeInstanceSpotCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): InstanceSpotCommand { if (!frames.length) fail("instanceSpot frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 39) fail("instanceSpot header"); const flags = Number(reader.u(1)); if ((flags & ~1) !== 0 || (flags & 0) !== 0) fail("instanceSpot flags"); const value: any = { command: "instanceSpot", flags };
@@ -7517,7 +8686,7 @@ const frames: Uint8Array[] = [writer.result()];
   if ((value.flags & 1) !== 0) { if (value.metadata === undefined) fail("instanceSpot metadata"); frames.push(encodeMetadataFrame(value.metadata, context)); } else if (value.metadata !== undefined) fail("instanceSpot metadata forbidden");
   if (value.payload === undefined) fail("instanceSpot payload"); frames.push(encodeApplicationPayloadEnvelopeV1(value.payload, context));
 return frames; }
-export function validateInstanceSpotCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateInstanceSpotCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RelocationPrepareCommand = { readonly command: "relocationPrepare"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly target: RelocationTargetFence; readonly initiatorRole: RelocationRole; readonly object: RelocationObjectIdentity; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly payloadTotalLength: RelocationLogicalLength; readonly payloadChunkCount: RelocationChunkCount; readonly payloadChecksumCrc32c: U32; readonly applicationVersion: ApplicationVersion; };
 export function decodeRelocationPrepareCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationPrepareCommand { if (!frames.length) fail("relocationPrepare frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 40) fail("relocationPrepare header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationPrepare flags"); const value: any = { command: "relocationPrepare", flags };
@@ -7614,7 +8783,7 @@ export function encodeRelocationPrepareCommand(value: RelocationPrepareCommand,
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationPrepareCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationPrepareCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type SessionRelocationSealCommand = { readonly command: "sessionRelocationSeal"; readonly flags: number; readonly relocation: RelocationId; readonly coordinator: RelocationCoordinatorFence; readonly senderRole: RelocationRole; readonly actor: ActorRouteFence; readonly sessionOwnerNodeRid: Rid; readonly sessionOwnerNodeGeneration: NonzeroU64; readonly sessionOwnerId: Text8; readonly sessionOwnerLeaseGeneration: NonzeroU64; readonly sessionRid: Rid; readonly bindingGeneration: NonzeroU64; };
 export function decodeSessionRelocationSealCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SessionRelocationSealCommand { if (!frames.length) fail("sessionRelocationSeal frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 42) fail("sessionRelocationSeal header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("sessionRelocationSeal flags"); const value: any = { command: "sessionRelocationSeal", flags };
@@ -7697,7 +8866,7 @@ export function encodeSessionRelocationSealCommand(value: SessionRelocationSealC
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateSessionRelocationSealCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateSessionRelocationSealCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type SessionRelocationSealedCommand = { readonly command: "sessionRelocationSealed"; readonly flags: number; readonly relocation: RelocationId; readonly coordinator: RelocationCoordinatorFence; readonly actor: ActorRouteFence; readonly sessionOwnerNodeRid: Rid; readonly sessionOwnerNodeGeneration: NonzeroU64; readonly sessionOwnerId: Text8; readonly sessionOwnerLeaseGeneration: NonzeroU64; readonly sessionRid: Rid; readonly bindingGeneration: NonzeroU64; };
 export function decodeSessionRelocationSealedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SessionRelocationSealedCommand { if (!frames.length) fail("sessionRelocationSealed frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 43) fail("sessionRelocationSealed header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("sessionRelocationSealed flags"); const value: any = { command: "sessionRelocationSealed", flags };
@@ -7773,7 +8942,7 @@ export function encodeSessionRelocationSealedCommand(value: SessionRelocationSea
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateSessionRelocationSealedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateSessionRelocationSealedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type SessionRelocationRouteCommand = { readonly command: "sessionRelocationRoute"; readonly flags: number; readonly relocation: RelocationId; readonly coordinator: RelocationCoordinatorFence; readonly senderRole: RelocationRole; readonly actor: ActorRef; readonly sessionOwnerNodeRid: Rid; readonly sessionOwnerNodeGeneration: NonzeroU64; readonly sessionOwnerId: Text8; readonly sessionOwnerLeaseGeneration: NonzeroU64; readonly sessionRid: Rid; readonly bindingGeneration: NonzeroU64; readonly route: SessionRelocationRouteUpdate; };
 export function decodeSessionRelocationRouteCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): SessionRelocationRouteCommand { if (!frames.length) fail("sessionRelocationRoute frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 44) fail("sessionRelocationRoute header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("sessionRelocationRoute flags"); const value: any = { command: "sessionRelocationRoute", flags };
@@ -7863,7 +9032,7 @@ export function encodeSessionRelocationRouteCommand(value: SessionRelocationRout
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateSessionRelocationRouteCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateSessionRelocationRouteCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ReplyRelayAckCommand = { readonly command: "replyRelayAck"; readonly flags: number; readonly relocation: RelocationId; readonly coordinator: RelocationCoordinatorFence; readonly operation: OperationId; readonly replyRouteId: NonzeroU64; readonly requestSource: RequestSourceFence; readonly status: ReplyRelayAckStatus; };
 export function decodeReplyRelayAckCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ReplyRelayAckCommand { if (!frames.length) fail("replyRelayAck frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 46) fail("replyRelayAck header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("replyRelayAck flags"); const value: any = { command: "replyRelayAck", flags };
@@ -7918,7 +9087,7 @@ export function encodeReplyRelayAckCommand(value: ReplyRelayAckCommand, context:
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateReplyRelayAckCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateReplyRelayAckCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type UserSpotCreateCommand = { readonly command: "userSpotCreate"; readonly flags: number; readonly correlation: NonzeroU64; readonly operation: OperationId; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly spotId: Text8; readonly stableType: Text8; readonly reservation: ObjectReservationFence; readonly deadlineUnixMs: NonzeroU64; };
 export function decodeUserSpotCreateCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): UserSpotCreateCommand { if (!frames.length) fail("userSpotCreate frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 47) fail("userSpotCreate header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("userSpotCreate flags"); const value: any = { command: "userSpotCreate", flags };
@@ -7987,7 +9156,7 @@ export function encodeUserSpotCreateCommand(value: UserSpotCreateCommand, contex
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateUserSpotCreateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateUserSpotCreateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type UserSpotCloseCommand = { readonly command: "userSpotClose"; readonly flags: number; readonly correlation: NonzeroU64; readonly operation: OperationId; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly target: UserSpotCloseFenceV1; readonly deadlineUnixMs: NonzeroU64; };
 export function decodeUserSpotCloseCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): UserSpotCloseCommand { if (!frames.length) fail("userSpotClose frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 48) fail("userSpotClose header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("userSpotClose flags"); const value: any = { command: "userSpotClose", flags };
@@ -8042,7 +9211,7 @@ export function encodeUserSpotCloseCommand(value: UserSpotCloseCommand, context:
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateUserSpotCloseCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateUserSpotCloseCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ActorCreateCommand = { readonly command: "actorCreate"; readonly flags: number; readonly correlation: NonzeroU64; readonly operation: OperationId; readonly sourceNodeRid: Rid; readonly sourceNodeGeneration: NonzeroU64; readonly actorId: Text8; readonly stableType: Text8; readonly reservation: ObjectReservationFence; readonly deadlineUnixMs: NonzeroU64; };
 export function decodeActorCreateCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): ActorCreateCommand { if (!frames.length) fail("actorCreate frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 49) fail("actorCreate header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("actorCreate flags"); const value: any = { command: "actorCreate", flags };
@@ -8111,7 +9280,7 @@ export function encodeActorCreateCommand(value: ActorCreateCommand, context: Ser
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateActorCreateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateActorCreateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type MessageFollowCommand = { readonly command: "messageFollow"; readonly flags: number; readonly route: MessageFollowRouteV1; };
 export function decodeMessageFollowCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): MessageFollowCommand { if (!frames.length) fail("messageFollow frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 50) fail("messageFollow header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("messageFollow flags"); const value: any = { command: "messageFollow", flags };
@@ -8131,7 +9300,7 @@ export function encodeMessageFollowCommand(value: MessageFollowCommand, context:
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateMessageFollowCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateMessageFollowCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type BoundSessionReplacedCommand = { readonly command: "boundSessionReplaced"; readonly flags: number; readonly actorAuthority: ActorRouteFence; readonly retiredSession: RetiredBoundSessionRouteFence; };
 export function decodeBoundSessionReplacedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): BoundSessionReplacedCommand { if (!frames.length) fail("boundSessionReplaced frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 51) fail("boundSessionReplaced header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("boundSessionReplaced flags"); const value: any = { command: "boundSessionReplaced", flags };
@@ -8158,7 +9327,7 @@ export function encodeBoundSessionReplacedCommand(value: BoundSessionReplacedCom
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateBoundSessionReplacedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateBoundSessionReplacedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RelocationStateCommand = { readonly command: "relocationState"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly senderRole: RelocationRole; readonly object: RelocationObjectIdentity; readonly chunkOrdinal: U32; readonly chunkData: DurableBlob; };
 export function decodeRelocationStateCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationStateCommand { if (!frames.length) fail("relocationState frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 52) fail("relocationState header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationState flags"); const value: any = { command: "relocationState", flags };
@@ -8220,7 +9389,7 @@ export function encodeRelocationStateCommand(value: RelocationStateCommand, cont
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationStateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationStateCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type RelocationFailedCommand = { readonly command: "relocationFailed"; readonly flags: number; readonly relocation: RelocationId; readonly targetAttemptGeneration: NonzeroU64; readonly coordinator: RelocationCoordinatorFence; readonly target: RelocationTargetFence; readonly object: RelocationObjectIdentity; readonly senderRole: RelocationRole; readonly failureCode: FrameworkErrorCode; };
 export function decodeRelocationFailedCommand(frames: readonly Uint8Array[], context: ServiceWireDecoderContext): RelocationFailedCommand { if (!frames.length) fail("relocationFailed frames"); const reader = new Reader(frames[0]); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1 || Number(reader.u(1)) !== 53) fail("relocationFailed header"); const flags = Number(reader.u(1)); if ((flags & ~0) !== 0 || (flags & 0) !== 0) fail("relocationFailed flags"); const value: any = { command: "relocationFailed", flags };
@@ -8282,7 +9451,7 @@ export function encodeRelocationFailedCommand(value: RelocationFailedCommand, co
 const frames: Uint8Array[] = [writer.result()];
 
 return frames; }
-export function validateRelocationFailedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context; }
+export function validateRelocationFailedCommandRuntimePredicates(value: any, context: ServiceWireDecoderContext): void { void value; void context;  }
 
 export type ServiceWireCommand = HelloCommand | AdmitCommand | RejectCommand | UpdateCommand | LivenessProbeCommand | LivenessAckCommand | NodeSendCommand | NodeRequestCommand | ChannelSendCommand | ChannelRequestCommand | ReplyCommand | SpotSendCommand | SpotRequestCommand | LogicalMulticastCommand | ActorSendCommand | ActorRequestCommand | ActorLookupCommand | ActorDestroyCommand | ActorJoinCommand | ActorLeftCommand | RelocationReadyCommand | RelocationDataCommand | ReplyRelayCommand | RelocationCutoverCommand | BoundSessionSendCommand | ActorJoinedCommand | BoundSessionBindCommand | InstanceSpotCommand | RelocationPrepareCommand | SessionRelocationSealCommand | SessionRelocationSealedCommand | SessionRelocationRouteCommand | ReplyRelayAckCommand | UserSpotCreateCommand | UserSpotCloseCommand | ActorCreateCommand | MessageFollowCommand | BoundSessionReplacedCommand | RelocationStateCommand | RelocationFailedCommand;
 
@@ -8298,5 +9467,53 @@ export function encodeRelocationDataChunkV1DurableFormat(value: RelocationDataCh
 export function decodeRelocationManifestV1DurableFormat(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationManifestV1 { if (bytes.length > 33554432) fail("relocation-manifest-v1 maximum"); const reader = new Reader(bytes); if (Number(reader.u(1)) !== 90 || Number(reader.u(1)) !== 76 || Number(reader.u(1)) !== 84 || Number(reader.u(1)) !== 77 || Number(reader.u(1)) !== 1) fail("relocation-manifest-v1 header"); const flags = readU16(reader, context, {}, 0); if (!same(flags, 0)) fail("relocation-manifest-v1 flags"); const length = Number(readU32(reader, context, {}, 0)); const body = reader.take(length); const checksumOffset = reader.offset; const declared = Number(reader.u(4)); reader.done("relocation-manifest-v1"); if (crc32c(bytes.slice(0, checksumOffset)) !== declared) fail("relocation-manifest-v1 checksum"); return decodeRelocationManifestV1(body, context); }
 export function encodeRelocationManifestV1DurableFormat(value: RelocationManifestV1, context: ServiceWireDecoderContext): Uint8Array { 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; }
 
-export function decodeRelocationEnvelopeV1LogicalStream(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationEnvelopeV1 { if (bytes.length > 274877906944) fail("relocation-envelope-v1 maximum"); return decodeRelocationEnvelopeV1(bytes, context); }
+export type RelocationEnvelopeV1LogicalDecodeStep =
+  | { readonly state: "needMore"; readonly bufferedInputByteCount: number; readonly consumedByteCount: number; readonly continuationDepth: number }
+  | { readonly state: "complete"; readonly value: RelocationEnvelopeV1; readonly consumedByteCount: number; readonly continuationDepth: number };
+export type LogicalFailureKind = "truncated" | "trailing" | "capacity" | "limit" | "protocol";
+export class LogicalDecodeError extends RangeError { constructor(readonly kind: LogicalFailureKind, readonly offset: number, options?: ErrorOptions) { super(kind + " at byte " + offset, options); this.name = "LogicalDecodeError"; } }
+export class RelocationEnvelopeV1LogicalStreamDecoder {
+  static readonly maximumContinuationDepth = 12;
+  private readonly reader = new IncrementalReader();
+  private readonly machine: Generator<void, RelocationEnvelopeV1, void>;
+  private state: "reading" | "await-final" | "complete" | "failed" = "reading";
+  private pendingValue: RelocationEnvelopeV1 | undefined;
+  private totalInputByteCount = 0;
+  constructor(context: ServiceWireDecoderContext) {
+    this.machine = readIncrementalRelocationEnvelopeV1(this.reader, context, {}, 0);
+  }
+  setSyntheticPriorInputByteCountForTest(value: number): void { if (this.totalInputByteCount !== 0) throw new Error("decoder already used"); this.totalInputByteCount = value; }
+  private logicalFailure(error: unknown, forced?: LogicalFailureKind): LogicalDecodeError { 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: Uint8Array, finalChunk: boolean): RelocationEnvelopeV1LogicalDecodeStep {
+    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 as RelocationEnvelopeV1, 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);
+    }
+  }
+}
+export function decodeRelocationEnvelopeV1LogicalStream(bytes: Uint8Array, context: ServiceWireDecoderContext): RelocationEnvelopeV1 { const step = new RelocationEnvelopeV1LogicalStreamDecoder(context).push(bytes, true); if (step.state !== "complete") fail("relocation-envelope-v1 truncated"); return step.value; }
 export function encodeRelocationEnvelopeV1LogicalStream(value: RelocationEnvelopeV1, context: ServiceWireDecoderContext): Uint8Array { const bytes = encodeRelocationEnvelopeV1(value, context); if (bytes.length > 274877906944) fail("relocation-envelope-v1 maximum"); return bytes; }