@fibril/can-core 0.0.0

package/dist/index.js

@@ -0,0 +1,3077 @@
+//#region src/ack-tracker.ts
+var AckTracker = class {
+	#pending = /* @__PURE__ */ new Map();
+	#now;
+	constructor(now = () => Date.now()) {
+		this.#now = now;
+	}
+	get pendingCount() {
+		return this.#pending.size;
+	}
+	/** Returns false if `seq` is already tracked; the existing entry is kept. */
+	track(seq, deadlineMs, cb) {
+		const key = seq & 255;
+		if (this.#pending.has(key)) return false;
+		this.#pending.set(key, {
+			deadlineMs,
+			cb
+		});
+		return true;
+	}
+	/** Idempotent — fires `acked` if `seq` is pending. */
+	onAck(seq) {
+		const key = seq & 255;
+		const e = this.#pending.get(key);
+		if (!e) return;
+		this.#pending.delete(key);
+		e.cb({ kind: "acked" });
+	}
+	/** Idempotent — fires `naked` with the reason if `seq` is pending. */
+	onNak(seq, reason) {
+		const key = seq & 255;
+		const e = this.#pending.get(key);
+		if (!e) return;
+		this.#pending.delete(key);
+		e.cb({
+			kind: "naked",
+			reason
+		});
+	}
+	/** Fire `timed-out` for every entry whose deadline elapsed by `nowMs`. */
+	sweep(nowMs = this.#now()) {
+		for (const [seq, entry] of this.#pending) if (entry.deadlineMs <= nowMs) {
+			this.#pending.delete(seq);
+			entry.cb({ kind: "timed-out" });
+		}
+	}
+	/** Drop every entry without firing callbacks. Test-only. */
+	clear() {
+		this.#pending.clear();
+	}
+};
+//#endregion
+//#region src/can-id.ts
+/**
+* CAN ID layout (Extended) and config-plane / NAK / svc-status / node-state
+* constants. Mirrors SPEC §3, §5, §7 and `fibril_can_runtime/include/fibril_can/fcan_protocol.h`
+* / `fibril_can_bridge/include/fibril_can_bridge/can_id.hpp`.
+*
+* Extended ID layout (29 bit, §3.2):
+*   [28:26] channel    (3 bit)
+*   [25:19] node_id    (7 bit, 0x7F = broadcast)
+*   [18:11] index      (8 bit, service_index / cmd_code)
+*   [10:3]  seq        (8 bit, call_id / seq_num)
+*   [2]     seg        (1 bit, 0=SINGLE, 1=SEGMENT)
+*   [1:0]   reserved   (2 bit, 0)
+*
+* Standard ID (11 bit, §3.1) is dynamically allocated by the master and
+* has no fixed bitfield meaning — kept here only as the wire mask.
+*/
+const PROTOCOL_VERSION = 1;
+const MAX_FRAME_PAYLOAD = 64;
+const CHAN_CONFIG = 0;
+const CHAN_SVC_REQUEST = 1;
+const CHAN_SVC_RESPONSE = 2;
+const NODE_ID_BROADCAST = 127;
+const STD_ID_MASK = 2047;
+const SVC_PARAM_SET = 253;
+const SVC_CANCEL = 255;
+const SVC_MAX_FIRST_CLASS = 252;
+const CMD_DISCOVER = 1;
+const CMD_ANNOUNCE = 2;
+const CMD_SCHEMA_READ = 3;
+const CMD_SCHEMA_DATA = 4;
+const CMD_HEARTBEAT = 5;
+const CMD_MASTER_HEARTBEAT = 7;
+const CMD_FRAME_DEFINE = 16;
+const CMD_HB_PERIOD = 19;
+const CMD_START = 32;
+const CMD_STOP = 33;
+const CMD_ACK = 126;
+const CMD_NAK = 127;
+const NAK_UNKNOWN_CMD = 1;
+const NAK_BAD_LENGTH = 2;
+const NAK_BAD_PARAM = 3;
+const NAK_NO_RESOURCE = 4;
+const NAK_BAD_STATE = 5;
+const NAK_ID_CONFLICT = 6;
+const NAK_INDEX_RANGE = 7;
+const NAK_DIR_MISMATCH = 8;
+const NAK_SIZE_OVERFLOW = 9;
+const STATE_UNPROVISIONED = 0;
+const STATE_PROVISIONED = 1;
+const STATE_RUNNING = 2;
+const STATE_FAULT = 3;
+const FAULT_NONE = 0;
+const FAULT_NOMEM = 1;
+const FAULT_INDEX_OVERFLOW = 2;
+const FAULT_ID_CONFLICT = 3;
+const DIR_TX_S2M = 0;
+const DIR_RX_M2S = 1;
+const SVC_OK = 0;
+const SVC_ACCEPTED = 1;
+const SVC_APP_ERROR = 2;
+const SVC_BUSY = 3;
+const SVC_UNAVAIL = 4;
+const SVC_BAD_INDEX = 5;
+const SVC_BAD_VALUE = 6;
+const SVC_BAD_LENGTH = 8;
+const SEG_FIRST_DATA = 61;
+const SEG_REST_DATA = 63;
+const SEG_MAX_TOTAL = 1024;
+const SEG_MAX_SEQ = 31;
+/** Byte offset of segment `seq` within the reassembled buffer (§7.4). */
+function segOffset(seq) {
+	return seq === 0 ? 0 : 61 + (seq - 1) * 63;
+}
+/**
+* Build a 29-bit Extended ID from its bitfields (§3.2). Inputs are masked
+* down to their respective field widths.
+*/
+function makeExtId(channel, nodeId, index, seq, seg = 0) {
+	return ((channel & 7) << 26 | (nodeId & 127) << 19 | (index & 255) << 11 | (seq & 255) << 3 | (seg & 1) << 2) >>> 0;
+}
+function extChannel(id) {
+	return id >>> 26 & 7;
+}
+function extNodeId(id) {
+	return id >>> 19 & 127;
+}
+function extIndex(id) {
+	return id >>> 11 & 255;
+}
+function extSeq(id) {
+	return id >>> 3 & 255;
+}
+function extSeg(id) {
+	return id >>> 2 & 1;
+}
+//#endregion
+//#region src/dlc.ts
+/**
+* CAN FD valid payload sizes in ascending order (§4.3).
+* Mirrors `fibril_can_core/include/fibril_can_core/packing.hpp::kCanFdDlcSteps`
+* and `fibril_can_runtime/src/fcan_wire.c::fcan_quantize_dlc`.
+*/
+const FD_DLC_STEPS = Object.freeze([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	12,
+	16,
+	20,
+	24,
+	32,
+	48,
+	64
+]);
+/**
+* Round `bytes` up to the next valid CAN FD payload step. Returns 64 for any
+* input ≥ 64.
+*/
+function quantizeDlc(bytes) {
+	if (bytes >= 64) return 64;
+	for (const step of FD_DLC_STEPS) if (step >= bytes) return step;
+	return 64;
+}
+/**
+* Grow `data` to the next DLC step by appending zero bytes. Returns a new
+* Uint8Array. Never shrinks: if `data` already exceeds 64 bytes (which is
+* a self-inconsistent frame the slave would misparse), the original is
+* returned unchanged so the backend rejects it loudly (parity with
+* `pad_to_dlc` in `fibril_can_bridge/src/config_plane_codec.cpp`).
+*/
+function padToDlc(data) {
+	if (data.length >= 64) return data;
+	const padded = new Uint8Array(quantizeDlc(data.length));
+	padded.set(data);
+	return padded;
+}
+//#endregion
+//#region src/config-plane.ts
+function readU32Le(p, off) {
+	return ((p[off] ?? 0) | (p[off + 1] ?? 0) << 8 | (p[off + 2] ?? 0) << 16 | (p[off + 3] ?? 0) << 24) >>> 0;
+}
+function readU64Le$1(p, off) {
+	let r = 0n;
+	for (let i = 0; i < 8; i++) r |= BigInt(p[off + i] ?? 0) << BigInt(i * 8);
+	return r;
+}
+function pushU16(buf, x) {
+	buf.push(x & 255, x >>> 8 & 255);
+}
+function pushU32(buf, x) {
+	buf.push(x & 255, x >>> 8 & 255, x >>> 16 & 255, x >>> 24 & 255);
+}
+function decodeAnnounce(data) {
+	if (data.length < 18) return null;
+	const k = data[17] ?? 0;
+	if (data.length < 18 + k) return null;
+	return {
+		schemaHash: readU64Le$1(data, 0),
+		protocolVersion: data[8] ?? 0,
+		bootId: readU32Le(data, 9),
+		blobLen: readU32Le(data, 13),
+		instanceCounts: data.slice(18, 18 + k)
+	};
+}
+function decodeHeartbeat(data) {
+	if (data.length < 6) return null;
+	return {
+		bootId: readU32Le(data, 0),
+		state: data[4] ?? 0,
+		faultSummary: data[5] ?? 0
+	};
+}
+function decodeSchemaData(data) {
+	if (data.length < 4) return null;
+	return {
+		offset: readU32Le(data, 0),
+		bytes: data.slice(4)
+	};
+}
+function decodeNak(data) {
+	if (data.length < 2) return null;
+	return {
+		cmd: data[0] ?? 0,
+		reason: data[1] ?? 0
+	};
+}
+function configFrame(nodeId, cmd, seq, data) {
+	return {
+		id: makeExtId(0, nodeId, cmd, seq, 0),
+		extended: true,
+		fd: true,
+		data
+	};
+}
+/** Broadcast DISCOVER — all nodes re-announce and clear their frame tables. */
+function encodeDiscover() {
+	return configFrame(127, 1, 0, /* @__PURE__ */ new Uint8Array(0));
+}
+/** Targeted DISCOVER for a single node (§5.11 reprovisioning). */
+function encodeDiscoverTo(nodeId) {
+	return configFrame(nodeId, 1, 0, /* @__PURE__ */ new Uint8Array(0));
+}
+/** Broadcast MASTER_HEARTBEAT (§5.11). Refreshes slave master-lost watchdogs. */
+function encodeMasterHeartbeat() {
+	return configFrame(127, 7, 0, /* @__PURE__ */ new Uint8Array(0));
+}
+function encodeSchemaRead(nodeId, offset, length, seq) {
+	const buf = [];
+	pushU32(buf, offset);
+	buf.push(length & 255);
+	return configFrame(nodeId, 3, seq, padToDlc(new Uint8Array(buf)));
+}
+function encodeFrameDefine(nodeId, seq, stdId, periodUs, dir, entries) {
+	const buf = [];
+	pushU16(buf, stdId);
+	pushU32(buf, periodUs);
+	buf.push(dir & 255);
+	buf.push(entries.length & 255);
+	for (const e of entries) {
+		pushU16(buf, e.topicIndex);
+		pushU16(buf, e.fieldBitmask);
+	}
+	return configFrame(nodeId, 16, seq, padToDlc(new Uint8Array(buf)));
+}
+function encodeStart(nodeId, seq) {
+	return configFrame(nodeId, 32, seq, /* @__PURE__ */ new Uint8Array(0));
+}
+function encodeStop(nodeId, seq) {
+	return configFrame(nodeId, 33, seq, /* @__PURE__ */ new Uint8Array(0));
+}
+/**
+* Accumulator for SCHEMA_DATA chunks. The slave DLC-pads each response (§4.3)
+* so `chunk.bytes.length` is typically larger than what the master requested;
+* the accumulator clips against `expectedChunkLen` and the remaining blob
+* length to drop those padding bytes (parity with
+* `append_schema_chunk` in `fibril_can_bridge/src/config_plane_codec.cpp`).
+*
+* Out-of-order chunks are rejected (returns 0 from {@link append}).
+*/
+var SchemaAccumulator = class {
+	#buf = [];
+	#blobTotalLen;
+	constructor(blobTotalLen) {
+		this.#blobTotalLen = blobTotalLen;
+	}
+	get length() {
+		return this.#buf.length;
+	}
+	get blobTotalLen() {
+		return this.#blobTotalLen;
+	}
+	get complete() {
+		return this.#buf.length >= this.#blobTotalLen;
+	}
+	bytes() {
+		return new Uint8Array(this.#buf);
+	}
+	/**
+	* Append `chunk` if its offset matches the current accumulator length.
+	* Returns the number of bytes actually appended (0 on rejection).
+	*/
+	append(chunk, expectedChunkLen) {
+		if (chunk.offset !== this.#buf.length) return 0;
+		const remaining = Math.max(0, this.#blobTotalLen - chunk.offset);
+		const cap = Math.min(expectedChunkLen, remaining);
+		const take = Math.min(chunk.bytes.length, cap);
+		for (let i = 0; i < take; i++) this.#buf.push(chunk.bytes[i] ?? 0);
+		return take;
+	}
+};
+//#endregion
+//#region src/scalar-codec.ts
+/**
+* Scalar type enumeration and little-endian wire codecs. Mirrors
+* `fibril_can_core/include/fibril_can_core/scalar_type.hpp` and
+* `fibril_can_core/src/scalar_type.cpp`.
+*
+* Type ordinal values are part of the protobuf schema blob's enum, so they
+* must not be renumbered.
+*/
+let ScalarType = /* @__PURE__ */ function(ScalarType) {
+	ScalarType[ScalarType["Bool"] = 0] = "Bool";
+	ScalarType[ScalarType["U8"] = 1] = "U8";
+	ScalarType[ScalarType["I8"] = 2] = "I8";
+	ScalarType[ScalarType["U16"] = 3] = "U16";
+	ScalarType[ScalarType["I16"] = 4] = "I16";
+	ScalarType[ScalarType["U32"] = 5] = "U32";
+	ScalarType[ScalarType["I32"] = 6] = "I32";
+	ScalarType[ScalarType["U64"] = 7] = "U64";
+	ScalarType[ScalarType["I64"] = 8] = "I64";
+	ScalarType[ScalarType["F32"] = 9] = "F32";
+	ScalarType[ScalarType["F64"] = 10] = "F64";
+	return ScalarType;
+}({});
+const SCALAR_NAMES = Object.freeze([
+	"bool",
+	"u8",
+	"i8",
+	"u16",
+	"i16",
+	"u32",
+	"i32",
+	"u64",
+	"i64",
+	"f32",
+	"f64"
+]);
+/** Wire size in bytes of one scalar element. bool is 1 byte. */
+function scalarSize(type) {
+	switch (type) {
+		case 0:
+		case 1:
+		case 2: return 1;
+		case 3:
+		case 4: return 2;
+		case 5:
+		case 6:
+		case 9: return 4;
+		case 7:
+		case 8:
+		case 10: return 8;
+	}
+}
+function scalarName(type) {
+	return SCALAR_NAMES[type];
+}
+function scalarFromName(name) {
+	const idx = SCALAR_NAMES.indexOf(name);
+	return idx >= 0 ? idx : void 0;
+}
+/**
+* Pack an integer / bool value as little-endian bytes into `out` at `offset`.
+* Writes scalarSize(type) bytes — pass a wide-enough `out`.
+*
+* Pass `bigint` for 64-bit types (U64/I64). `number` is accepted for
+* everything (it is internally widened to bigint so signed callers get the
+* same sign-extension semantics as the C++ `pack_scalar_int_le(uint64_t)`).
+* Signed callers pass the negative number directly; the function performs the
+* 64-bit two's-complement cast.
+*/
+function packScalarIntLe(type, value, out, offset = 0) {
+	const bytes = scalarSize(type);
+	const mask = (1n << 64n) - 1n;
+	const bits = (typeof value === "bigint" ? value : BigInt(value)) & mask;
+	for (let i = 0; i < bytes; i++) out[offset + i] = Number(bits >> BigInt(i * 8) & 255n);
+}
+/** Bit-cast a float32 to its IEEE-754 little-endian representation. */
+function packScalarF32Le(value, out, offset = 0) {
+	new DataView(out.buffer, out.byteOffset, out.byteLength).setFloat32(offset, value, true);
+}
+/** Bit-cast a float64 to its IEEE-754 little-endian representation. */
+function packScalarF64Le(value, out, offset = 0) {
+	new DataView(out.buffer, out.byteOffset, out.byteLength).setFloat64(offset, value, true);
+}
+/**
+* Inverse of {@link packScalarIntLe}. Returns the raw bit pattern as bigint;
+* caller interprets sign via {@link sign-extend} helpers below.
+*/
+function unpackScalarIntLe(type, src, offset = 0) {
+	const bytes = scalarSize(type);
+	let bits = 0n;
+	for (let i = 0; i < bytes; i++) bits |= BigInt(src[offset + i] ?? 0) << BigInt(i * 8);
+	return bits;
+}
+function unpackScalarF32Le(src, offset = 0) {
+	return new DataView(src.buffer, src.byteOffset, src.byteLength).getFloat32(offset, true);
+}
+function unpackScalarF64Le(src, offset = 0) {
+	return new DataView(src.buffer, src.byteOffset, src.byteLength).getFloat64(offset, true);
+}
+/**
+* Sign-extend a bigint that was read as an unsigned `bytes`-byte field to a
+* signed bigint. Useful for I8/I16/I32/I64 after {@link unpackScalarIntLe}.
+*/
+function signExtend(bits, bytes) {
+	const width = BigInt(bytes * 8);
+	return (bits & 1n << width - 1n) === 0n ? bits : bits - (1n << width);
+}
+const WIRE_FIXED64 = 1;
+const WIRE_FIXED32 = 5;
+var ProtoReader = class ProtoReader {
+	buf;
+	end;
+	pos = 0;
+	constructor(buf, end = buf.length) {
+		this.buf = buf;
+		this.end = end;
+	}
+	get done() {
+		return this.pos >= this.end;
+	}
+	get position() {
+		return this.pos;
+	}
+	/** Read a base-128 varint as a JS number (overflows ≥ 2^53 wrap silently). */
+	readVarint() {
+		let result = 0;
+		let shift = 0;
+		while (this.pos < this.end) {
+			const b = this.buf[this.pos++];
+			if (b === void 0) throw new ProtoError("truncated varint");
+			result |= (b & 127) << shift;
+			if ((b & 128) === 0) return result >>> 0;
+			shift += 7;
+			if (shift >= 32) {
+				while (this.pos < this.end) {
+					const c = this.buf[this.pos++];
+					if (c === void 0) throw new ProtoError("truncated varint");
+					if ((c & 128) === 0) break;
+				}
+				return result >>> 0;
+			}
+		}
+		throw new ProtoError("truncated varint");
+	}
+	/** Read a length-delimited byte slice (no copy). */
+	readBytes() {
+		const len = this.readVarint();
+		if (this.pos + len > this.end) throw new ProtoError("truncated length-delimited field");
+		const slice = this.buf.subarray(this.pos, this.pos + len);
+		this.pos += len;
+		return slice;
+	}
+	/** Read a length-delimited UTF-8 string. */
+	readString() {
+		const bytes = this.readBytes();
+		return new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+	}
+	/** Read a length-delimited sub-message and return a new reader scoped to it. */
+	readMessage() {
+		return new ProtoReader(this.readBytes());
+	}
+	/**
+	* Read the next tag and return both the field number and wire type. The
+	* caller is expected to dispatch on field number; unknown fields can be
+	* passed to {@link skipValue}.
+	*/
+	readTag() {
+		const tag = this.readVarint();
+		return {
+			field: tag >>> 3,
+			wire: tag & 7
+		};
+	}
+	/** Discard the value associated with `wire`. Used to tolerate unknown fields. */
+	skipValue(wire) {
+		switch (wire) {
+			case 0:
+				this.readVarint();
+				return;
+			case 2:
+				this.readBytes();
+				return;
+			case WIRE_FIXED32:
+				if (this.pos + 4 > this.end) throw new ProtoError("truncated fixed32");
+				this.pos += 4;
+				return;
+			case WIRE_FIXED64:
+				if (this.pos + 8 > this.end) throw new ProtoError("truncated fixed64");
+				this.pos += 8;
+				return;
+			default: throw new ProtoError(`unsupported wire type ${wire}`);
+		}
+	}
+};
+var ProtoError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ProtoError";
+	}
+};
+//#endregion
+//#region src/schema.ts
+/**
+* NodeSchema IR + protobuf decoder for the schema blob (§9).
+*
+* Mirrors `fibril_can_core/include/fibril_can_core/ir.hpp` and
+* `fibril_can_core/src/schema_blob.cpp::parse_schema`. Field IDs come from
+* `fibril_can_core/proto/fibril_can.proto`.
+*
+* Master-side notes:
+*   - The proto carries `topic_id` / `service_id` / `param_id` / BlockType
+*     `type_id` for codegen stability; the master derives equivalent indices
+*     from {@link computeNumbering} instead, so these are accepted but
+*     discarded on parse.
+*   - The proto wire field is `tx_disabled` while the IR holds `tx_enabled`
+*     (inverted, matches the C++ side).
+*   - `BlockArray.type_id` (proto) → `BlockArray.blockTypeIndex` (IR).
+*
+* The reader skips unknown fields silently so future schema additions do
+* not break old masters.
+*/
+const FIELD = {
+	Field: {
+		name: 1,
+		type: 2,
+		arrayLen: 3,
+		periodUsOverride: 4,
+		txDisabled: 5
+	},
+	RosMapping: {
+		rosType: 1,
+		rosName: 2,
+		fieldMap: 3
+	},
+	Topic: {
+		name: 2,
+		dir: 3,
+		fields: 4,
+		defaultPeriodUs: 5,
+		ros: 6
+	},
+	Service: {
+		name: 2,
+		request: 3,
+		response: 4,
+		ros: 5
+	},
+	Param: {
+		name: 2,
+		type: 3,
+		arrayLen: 4,
+		defaultValue: 5,
+		minValue: 6,
+		maxValue: 7
+	},
+	BlockType: {
+		name: 2,
+		topics: 3,
+		services: 4,
+		params: 5
+	},
+	BlockArray: {
+		typeId: 1,
+		rosNamespace: 2
+	},
+	Limits: { paramSetBatchBytes: 1 },
+	NodeSchema: {
+		protocolVersion: 1,
+		nodeName: 2,
+		types: 3,
+		instances: 4,
+		limits: 5
+	}
+};
+let Direction = /* @__PURE__ */ function(Direction) {
+	Direction[Direction["M2S"] = 0] = "M2S";
+	Direction[Direction["S2M"] = 1] = "S2M";
+	return Direction;
+}({});
+function decodeField(r) {
+	const f = {
+		name: "",
+		type: 0,
+		arrayLen: 0,
+		txEnabled: true
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.Field.name:
+				f.name = r.readString();
+				break;
+			case FIELD.Field.type: {
+				const v = r.readVarint();
+				if (v > 10) throw new ProtoError(`Field.type out of range: ${v}`);
+				f.type = v;
+				break;
+			}
+			case FIELD.Field.arrayLen:
+				f.arrayLen = r.readVarint();
+				break;
+			case FIELD.Field.periodUsOverride: {
+				const v = r.readVarint();
+				if (v !== 0) f.periodUsOverride = v;
+				break;
+			}
+			case FIELD.Field.txDisabled:
+				f.txEnabled = r.readVarint() === 0;
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return f;
+}
+function decodeRos(r) {
+	const ros = {
+		rosType: "",
+		rosName: "",
+		fieldMap: []
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.RosMapping.rosType:
+				ros.rosType = r.readString();
+				break;
+			case FIELD.RosMapping.rosName:
+				ros.rosName = r.readString();
+				break;
+			case FIELD.RosMapping.fieldMap:
+				ros.fieldMap.push(r.readString());
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return ros;
+}
+function decodeTopic(r) {
+	const t = {
+		name: "",
+		dir: 0,
+		fields: [],
+		defaultPeriodUs: 0,
+		ros: {
+			rosType: "",
+			rosName: "",
+			fieldMap: []
+		}
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.Topic.name:
+				t.name = r.readString();
+				break;
+			case FIELD.Topic.dir: {
+				const v = r.readVarint();
+				if (v !== 0 && v !== 1) throw new ProtoError(`Topic.dir out of range: ${v}`);
+				t.dir = v;
+				break;
+			}
+			case FIELD.Topic.fields:
+				t.fields.push(decodeField(r.readMessage()));
+				break;
+			case FIELD.Topic.defaultPeriodUs:
+				t.defaultPeriodUs = r.readVarint();
+				break;
+			case FIELD.Topic.ros:
+				t.ros = decodeRos(r.readMessage());
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return t;
+}
+function decodeService(r) {
+	const s = {
+		name: "",
+		request: [],
+		response: [],
+		ros: {
+			rosType: "",
+			rosName: "",
+			fieldMap: []
+		}
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.Service.name:
+				s.name = r.readString();
+				break;
+			case FIELD.Service.request:
+				s.request.push(decodeField(r.readMessage()));
+				break;
+			case FIELD.Service.response:
+				s.response.push(decodeField(r.readMessage()));
+				break;
+			case FIELD.Service.ros:
+				s.ros = decodeRos(r.readMessage());
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return s;
+}
+function decodeParam(r) {
+	const p = {
+		name: "",
+		type: 0,
+		arrayLen: 0,
+		defaultValue: /* @__PURE__ */ new Uint8Array(0),
+		minValue: /* @__PURE__ */ new Uint8Array(0),
+		maxValue: /* @__PURE__ */ new Uint8Array(0)
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.Param.name:
+				p.name = r.readString();
+				break;
+			case FIELD.Param.type: {
+				const v = r.readVarint();
+				if (v > 10) throw new ProtoError(`Param.type out of range: ${v}`);
+				p.type = v;
+				break;
+			}
+			case FIELD.Param.arrayLen:
+				p.arrayLen = r.readVarint();
+				break;
+			case FIELD.Param.defaultValue:
+				p.defaultValue = new Uint8Array(r.readBytes());
+				break;
+			case FIELD.Param.minValue:
+				p.minValue = new Uint8Array(r.readBytes());
+				break;
+			case FIELD.Param.maxValue:
+				p.maxValue = new Uint8Array(r.readBytes());
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return p;
+}
+function decodeBlockType(r) {
+	const b = {
+		name: "",
+		topics: [],
+		services: [],
+		params: []
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.BlockType.name:
+				b.name = r.readString();
+				break;
+			case FIELD.BlockType.topics:
+				b.topics.push(decodeTopic(r.readMessage()));
+				break;
+			case FIELD.BlockType.services:
+				b.services.push(decodeService(r.readMessage()));
+				break;
+			case FIELD.BlockType.params:
+				b.params.push(decodeParam(r.readMessage()));
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return b;
+}
+function decodeBlockArray(r) {
+	const a = {
+		blockTypeIndex: 0,
+		rosNamespace: ""
+	};
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.BlockArray.typeId:
+				a.blockTypeIndex = r.readVarint();
+				break;
+			case FIELD.BlockArray.rosNamespace:
+				a.rosNamespace = r.readString();
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return a;
+}
+function decodeLimits(r) {
+	const l = { paramSetBatchBytes: 0 };
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.Limits.paramSetBatchBytes:
+				l.paramSetBatchBytes = r.readVarint();
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	return l;
+}
+/**
+* Parse a schema blob (proto3 binary) into the master-side IR.
+*
+* Throws {@link ProtoError} on malformed input or on
+* `protocolVersion !== 1` (the only version this codec understands —
+* mirrors C++ side's UnsupportedProtocolVersion behaviour).
+*/
+function decodeSchema(blob) {
+	const schema = {
+		protocolVersion: 0,
+		nodeName: "",
+		types: [],
+		instances: [],
+		limits: { paramSetBatchBytes: 0 }
+	};
+	const r = new ProtoReader(blob);
+	while (!r.done) {
+		const { field, wire } = r.readTag();
+		switch (field) {
+			case FIELD.NodeSchema.protocolVersion:
+				schema.protocolVersion = r.readVarint();
+				break;
+			case FIELD.NodeSchema.nodeName:
+				schema.nodeName = r.readString();
+				break;
+			case FIELD.NodeSchema.types:
+				schema.types.push(decodeBlockType(r.readMessage()));
+				break;
+			case FIELD.NodeSchema.instances:
+				schema.instances.push(decodeBlockArray(r.readMessage()));
+				break;
+			case FIELD.NodeSchema.limits:
+				schema.limits = decodeLimits(r.readMessage());
+				break;
+			default: r.skipValue(wire);
+		}
+	}
+	if (schema.protocolVersion !== 1) throw new ProtoError(`unsupported schema protocol_version: ${schema.protocolVersion}`);
+	for (const arr of schema.instances) if (arr.blockTypeIndex >= schema.types.length) throw new ProtoError(`BlockArray.type_id ${arr.blockTypeIndex} out of range (#types=${schema.types.length})`);
+	return schema;
+}
+/** Wire size in bytes for a single field (scalar or fixed array). */
+function fieldWireSize(field) {
+	return scalarSize(field.type) * (field.arrayLen === 0 ? 1 : field.arrayLen);
+}
+//#endregion
+//#region src/dynamic-codec.ts
+/**
+* Field-driven dict ⇄ Uint8Array codec. The runtime equivalent of what
+* codegen would otherwise emit per message — encode/decode is a pure
+* function of the field list ({@link SchemaField}[]) and the JS dict.
+*
+* Conventions (matches CLAUDE.md "値の表現規約"):
+* - dict keys are the schema field name verbatim
+* - scalar ↔ JS `number`, except U64/I64 ↔ `bigint`
+* - bool ↔ JS `boolean`
+* - fixed-length array (`arrayLen > 0`) ↔ regular JS array
+*   (`number[]` / `bigint[]` / `boolean[]`) of exactly `arrayLen` elements
+*
+* Throws on missing / wrong-shape inputs. Decode tolerates extra trailing
+* bytes (mirrors C++ side: the master ignores trailing slop so that future
+* schema additions don't break older decoders).
+*/
+var DynamicCodecError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DynamicCodecError";
+	}
+};
+function isInt64(type) {
+	return type === 7 || type === 8;
+}
+function packOneScalar$1(type, value, out, offset, fieldName) {
+	switch (type) {
+		case 0:
+			if (typeof value !== "boolean") throw new DynamicCodecError(`field '${fieldName}': expected boolean for bool, got ${typeof value}`);
+			out[offset] = value ? 1 : 0;
+			return;
+		case 9:
+			if (typeof value !== "number") throw new DynamicCodecError(`field '${fieldName}': expected number for f32, got ${typeof value}`);
+			packScalarF32Le(value, out, offset);
+			return;
+		case 10:
+			if (typeof value !== "number") throw new DynamicCodecError(`field '${fieldName}': expected number for f64, got ${typeof value}`);
+			packScalarF64Le(value, out, offset);
+			return;
+		default:
+			if (isInt64(type)) {
+				if (typeof value !== "bigint") throw new DynamicCodecError(`field '${fieldName}': expected bigint for ${scalarName(type)}, got ${typeof value}`);
+			} else if (typeof value !== "number") throw new DynamicCodecError(`field '${fieldName}': expected number for ${scalarName(type)}, got ${typeof value}`);
+			packScalarIntLe(type, value, out, offset);
+			return;
+	}
+}
+function unpackOneScalar(type, src, offset) {
+	switch (type) {
+		case 0: return (src[offset] ?? 0) !== 0;
+		case 9: return unpackScalarF32Le(src, offset);
+		case 10: return unpackScalarF64Le(src, offset);
+		case 2:
+		case 4:
+		case 6: {
+			const bits = unpackScalarIntLe(type, src, offset);
+			return Number(signExtend(bits, scalarSize(type)));
+		}
+		case 1:
+		case 3:
+		case 5: return Number(unpackScalarIntLe(type, src, offset));
+		case 8: return signExtend(unpackScalarIntLe(type, src, offset), 8);
+		case 7: return unpackScalarIntLe(type, src, offset);
+	}
+}
+/**
+* Sum the wire size of a field list. The result is the byte count that
+* {@link encodeFields} will produce.
+*/
+function fieldsWireSize(fields) {
+	let n = 0;
+	for (const f of fields) n += fieldWireSize(f);
+	return n;
+}
+/**
+* Encode a dict into the canonical little-endian wire bytes for `fields`.
+* Returns a fresh `Uint8Array`. Throws {@link DynamicCodecError} on a
+* missing or wrong-shape field.
+*/
+function encodeFields(fields, value) {
+	const totalSize = fieldsWireSize(fields);
+	const out = new Uint8Array(totalSize);
+	let off = 0;
+	for (const f of fields) {
+		if (!f.txEnabled) {
+			off += fieldWireSize(f);
+			continue;
+		}
+		const v = value[f.name];
+		if (v === void 0) throw new DynamicCodecError(`encodeFields: missing field '${f.name}'`);
+		if (f.arrayLen === 0) {
+			packOneScalar$1(f.type, v, out, off, f.name);
+			off += scalarSize(f.type);
+		} else {
+			if (!Array.isArray(v)) throw new DynamicCodecError(`field '${f.name}': expected array of length ${f.arrayLen}, got ${typeof v}`);
+			if (v.length !== f.arrayLen) throw new DynamicCodecError(`field '${f.name}': expected array length ${f.arrayLen}, got ${v.length}`);
+			const stride = scalarSize(f.type);
+			for (let i = 0; i < f.arrayLen; i++) {
+				packOneScalar$1(f.type, v[i], out, off, f.name);
+				off += stride;
+			}
+		}
+	}
+	return out;
+}
+/**
+* Decode wire bytes into a dict keyed by field name. Extra trailing bytes
+* are ignored. Throws {@link DynamicCodecError} only if the payload is
+* shorter than the field list demands.
+*/
+function decodeFields(fields, bytes) {
+	const expected = fieldsWireSize(fields);
+	if (bytes.length < expected) throw new DynamicCodecError(`decodeFields: payload too short — need ${expected} bytes, got ${bytes.length}`);
+	const out = {};
+	let off = 0;
+	for (const f of fields) if (f.arrayLen === 0) {
+		out[f.name] = unpackOneScalar(f.type, bytes, off);
+		off += scalarSize(f.type);
+	} else {
+		const stride = scalarSize(f.type);
+		if (f.type === 0) {
+			const arr = [];
+			for (let i = 0; i < f.arrayLen; i++) {
+				arr.push(unpackOneScalar(f.type, bytes, off));
+				off += stride;
+			}
+			out[f.name] = arr;
+		} else if (isInt64(f.type)) {
+			const arr = [];
+			for (let i = 0; i < f.arrayLen; i++) {
+				arr.push(unpackOneScalar(f.type, bytes, off));
+				off += stride;
+			}
+			out[f.name] = arr;
+		} else {
+			const arr = [];
+			for (let i = 0; i < f.arrayLen; i++) {
+				arr.push(unpackOneScalar(f.type, bytes, off));
+				off += stride;
+			}
+			out[f.name] = arr;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/data-plane.ts
+const RATE_WINDOW = 16;
+function maskedFieldsList(fields, mask) {
+	const out = [];
+	for (let i = 0; i < fields.length; i++) {
+		const f = fields[i];
+		if (f === void 0) continue;
+		if ((mask & 1 << i) !== 0) out.push(f);
+	}
+	return out;
+}
+function sumWireSize(fields) {
+	let s = 0;
+	for (const f of fields) s += fieldWireSize(f);
+	return s;
+}
+function buildBucket(framePlan, index, nodeId) {
+	let offset = 0;
+	const entries = [];
+	for (const e of framePlan.entries) {
+		const desc = index.topicByIndex(e.topicIndex);
+		if (desc === void 0) continue;
+		const fields = maskedFieldsList(desc.fields, e.fieldBitmask);
+		const size = sumWireSize(fields);
+		entries.push({
+			path: desc.path,
+			fields,
+			offset,
+			size
+		});
+		offset += size;
+	}
+	return {
+		nodeId,
+		stdId: framePlan.stdId,
+		dir: framePlan.dir,
+		entries
+	};
+}
+function topicKey(nodeId, path) {
+	return `${nodeId}/${path}`;
+}
+var DataPlaneReceiver = class {
+	#onError;
+	#now;
+	#unsubFrame;
+	#buckets = /* @__PURE__ */ new Map();
+	#ownedByNode = /* @__PURE__ */ new Map();
+	#latest = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Map();
+	#version = 0;
+	constructor(opts) {
+		this.#onError = opts.onError;
+		this.#now = opts.now ?? (() => Date.now());
+		this.#unsubFrame = opts.transport.onFrame((f) => this.#onFrame(f));
+	}
+	/**
+	* Claim a slave's S→M std_ids. Re-attaching the same nodeId atomically
+	* detaches the prior plan first (re-provisioning case).
+	*/
+	attachSlave(nodeId, framePlan, index) {
+		this.detachSlave(nodeId);
+		const owned = /* @__PURE__ */ new Set();
+		for (const fp of framePlan) {
+			if (fp.dir !== 1) continue;
+			if (this.#buckets.has(fp.stdId)) {
+				const other = this.#buckets.get(fp.stdId);
+				throw new Error(`DataPlaneReceiver: std_id 0x${fp.stdId.toString(16)} claimed by slave 0x${other?.nodeId.toString(16) ?? "??"}, cannot also attach slave 0x${nodeId.toString(16)}`);
+			}
+			this.#buckets.set(fp.stdId, buildBucket(fp, index, nodeId));
+			owned.add(fp.stdId);
+		}
+		this.#ownedByNode.set(nodeId, owned);
+	}
+	/** Release a slave's std_ids and drop its cached topic samples. */
+	detachSlave(nodeId) {
+		const owned = this.#ownedByNode.get(nodeId);
+		if (!owned) return;
+		for (const id of owned) this.#buckets.delete(id);
+		this.#ownedByNode.delete(nodeId);
+		const prefix = `${nodeId}/`;
+		for (const k of [...this.#latest.keys()]) if (k.startsWith(prefix)) this.#latest.delete(k);
+	}
+	onTopic(nodeId, path, listener) {
+		const key = topicKey(nodeId, path);
+		let set = this.#listeners.get(key);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(key, set);
+		}
+		set.add(listener);
+		return () => {
+			const s = this.#listeners.get(key);
+			if (!s) return;
+			s.delete(listener);
+			if (s.size === 0) this.#listeners.delete(key);
+		};
+	}
+	latest(nodeId, path) {
+		const c = this.#latest.get(topicKey(nodeId, path));
+		return c === void 0 ? null : {
+			value: c.value,
+			tsMs: c.tsMs
+		};
+	}
+	stats(nodeId, path) {
+		const c = this.#latest.get(topicKey(nodeId, path));
+		if (!c) return null;
+		let rate = 0;
+		if (c.ts.length >= 2) {
+			const dt = (c.ts[c.ts.length - 1] ?? 0) - (c.ts[0] ?? 0);
+			if (dt > 0) rate = 1e3 * (c.ts.length - 1) / dt;
+		}
+		return {
+			count: c.count,
+			lastRxMs: c.tsMs,
+			ratePerSec: rate
+		};
+	}
+	/** Paths attached for this slave (in plan order). */
+	topicPathsFor(nodeId) {
+		const owned = this.#ownedByNode.get(nodeId);
+		if (!owned) return [];
+		const out = [];
+		for (const id of owned) {
+			const b = this.#buckets.get(id);
+			if (b) for (const e of b.entries) out.push(e.path);
+		}
+		return out;
+	}
+	/** Bumps on every successfully decoded entry — cheap change detector. */
+	get version() {
+		return this.#version;
+	}
+	dispose() {
+		this.#unsubFrame();
+		this.#buckets.clear();
+		this.#ownedByNode.clear();
+		this.#latest.clear();
+		this.#listeners.clear();
+	}
+	#onFrame(f) {
+		if (f.extended) return;
+		if (f.rtr) return;
+		const bucket = this.#buckets.get(f.id);
+		if (bucket === void 0) return;
+		const tsMs = this.#now();
+		for (const e of bucket.entries) {
+			if (e.offset + e.size > f.data.length) continue;
+			const slice = f.data.subarray(e.offset, e.offset + e.size);
+			let dict;
+			try {
+				dict = decodeFields(e.fields, slice);
+			} catch (err) {
+				this.#err(err);
+				continue;
+			}
+			this.#publish(bucket.nodeId, e.path, dict, tsMs);
+		}
+	}
+	#publish(nodeId, path, value, tsMs) {
+		const key = topicKey(nodeId, path);
+		let c = this.#latest.get(key);
+		if (c === void 0) {
+			c = {
+				value,
+				tsMs,
+				count: 0,
+				ts: []
+			};
+			this.#latest.set(key, c);
+		} else {
+			c.value = value;
+			c.tsMs = tsMs;
+		}
+		c.count++;
+		c.ts.push(tsMs);
+		if (c.ts.length > RATE_WINDOW) c.ts.shift();
+		this.#version++;
+		const set = this.#listeners.get(key);
+		if (set !== void 0) for (const l of set) try {
+			l(value, tsMs);
+		} catch (err) {
+			this.#err(err);
+		}
+	}
+	#err(e) {
+		if (this.#onError === void 0) return;
+		this.#onError(e instanceof Error ? e : new Error(String(e)));
+	}
+};
+//#endregion
+//#region src/frame-planner.ts
+/**
+* 11-bit Standard ID allocator with a free pool for IDs released after a
+* grace window (§11.4.1). `next()` returns `null` on exhaustion rather
+* than wrapping — wrapping past 0x7FF would alias on the wire.
+*/
+var StdIdAllocator = class {
+	#next = 256;
+	#freePool = [];
+	next(nowMs = Date.now()) {
+		if (this.#freePool.length > 0) {
+			const head = this.#freePool[0];
+			if (head !== void 0 && head.availableAtMs <= nowMs) {
+				this.#freePool.shift();
+				return head.id;
+			}
+		}
+		if (this.#next > 2047) return null;
+		const id = this.#next;
+		this.#next += 1;
+		return id;
+	}
+	release(id, availableAtMs) {
+		let lo = 0;
+		let hi = this.#freePool.length;
+		while (lo < hi) {
+			const mid = lo + hi >>> 1;
+			const entry = this.#freePool[mid];
+			if (entry !== void 0 && entry.availableAtMs < availableAtMs) lo = mid + 1;
+			else hi = mid;
+		}
+		this.#freePool.splice(lo, 0, {
+			availableAtMs,
+			id
+		});
+	}
+	reset(start = 256) {
+		this.#next = start;
+		this.#freePool.length = 0;
+	}
+};
+function makeFrame(input) {
+	const id = input.alloc.next();
+	if (id === null) return null;
+	const entries = [];
+	let bytes = 0;
+	for (const topicIndex of [...input.topics.keys()].sort((a, b) => a - b)) {
+		const fields = input.topics.get(topicIndex);
+		if (!fields) continue;
+		let mask = 0;
+		for (const r of fields) {
+			mask |= 1 << r.fieldId;
+			bytes += r.sizeBytes;
+		}
+		entries.push({
+			topicIndex,
+			fieldBitmask: mask
+		});
+	}
+	return {
+		stdCanId: id,
+		periodUs: input.periodUs,
+		dir: input.dir,
+		logicalBytes: Math.min(bytes, 64),
+		entries
+	};
+}
+function emitOversizedTopic(fields, dir, periodUs, alloc, out) {
+	const sorted = [...fields].sort((a, b) => a.fieldId - b.fieldId);
+	let bin = [];
+	let binBytes = 0;
+	const topicIndex = sorted[0]?.topicIndex ?? 0;
+	const flush = () => {
+		if (bin.length === 0) return true;
+		const f = makeFrame({
+			topics: /* @__PURE__ */ new Map([[topicIndex, bin]]),
+			dir,
+			periodUs,
+			alloc
+		});
+		if (!f) return false;
+		out.push(f);
+		bin = [];
+		binBytes = 0;
+		return true;
+	};
+	for (const r of sorted) {
+		if (binBytes + r.sizeBytes > 64) {
+			if (!flush()) return false;
+		}
+		bin.push(r);
+		binBytes += r.sizeBytes;
+	}
+	return flush();
+}
+/**
+* Plan a slave's frame layout. Returns `null` if the StdIdAllocator runs
+* out of 11-bit IDs mid-plan — the caller MUST surface that; a partial
+* plan would silently drop fields.
+*/
+function planFrames(requests, alloc) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const r of requests) {
+		const key = `${r.dir}/${r.periodUs}`;
+		let bucket = buckets.get(key);
+		if (!bucket) {
+			bucket = [];
+			buckets.set(key, bucket);
+		}
+		bucket.push(r);
+	}
+	const sortedKeys = [...buckets.keys()].sort((a, b) => {
+		const [aDir, aPeriod] = a.split("/").map(Number);
+		const [bDir, bPeriod] = b.split("/").map(Number);
+		if (aDir !== bDir) return aDir - bDir;
+		return aPeriod - bPeriod;
+	});
+	const out = [];
+	for (const key of sortedKeys) {
+		const requestsInBucket = buckets.get(key);
+		if (!requestsInBucket) continue;
+		const [dir, periodUs] = key.split("/").map(Number);
+		const byTopic = /* @__PURE__ */ new Map();
+		for (const r of requestsInBucket) {
+			let arr = byTopic.get(r.topicIndex);
+			if (!arr) {
+				arr = [];
+				byTopic.set(r.topicIndex, arr);
+			}
+			arr.push(r);
+		}
+		const topicBytes = /* @__PURE__ */ new Map();
+		for (const [topicIndex, fields] of byTopic) {
+			let sum = 0;
+			for (const r of fields) sum += r.sizeBytes;
+			topicBytes.set(topicIndex, sum);
+		}
+		let currentBin = /* @__PURE__ */ new Map();
+		let currentBytes = 0;
+		const flush = () => {
+			if (currentBin.size === 0) return true;
+			const f = makeFrame({
+				topics: currentBin,
+				dir,
+				periodUs,
+				alloc
+			});
+			if (!f) return false;
+			out.push(f);
+			currentBin = /* @__PURE__ */ new Map();
+			currentBytes = 0;
+			return true;
+		};
+		const sortedTopics = [...byTopic.keys()].sort((a, b) => a - b);
+		for (const topicIndex of sortedTopics) {
+			const fields = byTopic.get(topicIndex);
+			if (!fields) continue;
+			const sz = topicBytes.get(topicIndex) ?? 0;
+			if (sz > 64) {
+				if (!flush()) return null;
+				if (!emitOversizedTopic(fields, dir, periodUs, alloc, out)) return null;
+				continue;
+			}
+			if (currentBytes + sz > 64) {
+				if (!flush()) return null;
+			}
+			currentBin.set(topicIndex, fields);
+			currentBytes += sz;
+		}
+		if (!flush()) return null;
+	}
+	return out;
+}
+//#endregion
+//#region src/default-plan.ts
+const I_TOKEN$1 = "{i}";
+function expandIToken$1(s, value) {
+	if (!s.includes(I_TOKEN$1)) return s;
+	return s.split(I_TOKEN$1).join(String(value));
+}
+function joinPath$1(ns, name) {
+	if (ns.length === 0) return name;
+	if (name.length === 0) return ns;
+	return `${ns}/${name}`;
+}
+/**
+* Synthesize the default {@link FieldRequest} list from a decoded schema +
+* numbering table — every S2M topic field at its declared period
+* (`field.periodUsOverride` if present, else the owning topic's
+* `defaultPeriodUs`), skipping `txEnabled === false` fields.
+*
+* Pass `filter` to layer a runtime per-field mask on top (UI toggles,
+* per-slave overrides). Schema-disabled fields are unconditionally
+* dropped before `filter` is consulted, so callers don't have to repeat
+* the `txEnabled` check.
+*
+* This is the natural input to {@link planFrames} when the master just
+* wants to "observe everything the slave publishes" — i.e. the
+* sniffer-style auto-provision path.
+*/
+function buildDefaultS2MRequests(schema, numbering, filter) {
+	const out = [];
+	numbering.topics.byIndex.forEach((endpoint, flatIndex) => {
+		const block = schema.instances[endpoint.blockArray];
+		if (!block) return;
+		const type = schema.types[block.blockTypeIndex];
+		if (!type) return;
+		const topic = type.topics[endpoint.endpoint];
+		if (!topic) return;
+		if (topic.dir !== 1) return;
+		let topicPath = null;
+		topic.fields.forEach((field, fieldId) => {
+			if (!field.txEnabled) return;
+			if (filter !== void 0) {
+				if (topicPath === null) topicPath = joinPath$1(expandIToken$1(block.rosNamespace, endpoint.instance), topic.name);
+				if (!filter({
+					topicPath,
+					topicIndex: flatIndex,
+					fieldId,
+					fieldName: field.name,
+					field
+				})) return;
+			}
+			out.push({
+				topicIndex: flatIndex,
+				fieldId,
+				sizeBytes: fieldWireSize(field),
+				periodUs: field.periodUsOverride ?? topic.defaultPeriodUs,
+				dir: topic.dir
+			});
+		});
+	});
+	return out;
+}
+/**
+* One-line FramePlanFactory that subscribes to every S2M field at its
+* declared period using a freshly-allocated {@link StdIdAllocator}.
+*
+* Pass `filter` to apply a runtime per-field mask (e.g. a UI-controlled
+* field-tx-enable map). With no filter, every schema-enabled S→M field is
+* subscribed.
+*
+* Returns `[]` when planning fails (e.g. std_id exhaustion); the caller's
+* NodeAgent will then leave the slave in `provisioning` → `awaiting-announce`
+* with no frames defined, which is the right outcome — partial plans would
+* silently drop fields.
+*/
+function defaultS2MFramePlan(schema, numbering, filter) {
+	const planned = planFrames(buildDefaultS2MRequests(schema, numbering, filter), new StdIdAllocator());
+	if (planned === null) return [];
+	return planned.map((s) => ({
+		stdId: s.stdCanId,
+		periodUs: s.periodUs,
+		dir: s.dir,
+		entries: s.entries
+	}));
+}
+//#endregion
+//#region src/master-heartbeat.ts
+/**
+* Broadcasts CMD_MASTER_HEARTBEAT (§5.11) on a fixed period so slaves with
+* a `master_lost_us` watchdog configured do not silence their S→M traffic.
+*
+* Independent of any single {@link NodeAgent} — the heartbeat is a single
+* bus-wide broadcast that refreshes every slave's watchdog. Construct one
+* per transport.
+*/
+var MasterHeartbeatBroadcaster = class {
+	transport;
+	periodMs;
+	#handle = null;
+	constructor(transport, periodMs = 100) {
+		this.transport = transport;
+		this.periodMs = periodMs;
+	}
+	start() {
+		if (this.#handle !== null) return;
+		const tick = () => {
+			if (!this.transport.isOpen) return;
+			this.transport.send(encodeMasterHeartbeat()).catch(() => {});
+		};
+		tick();
+		this.#handle = setInterval(tick, this.periodMs);
+	}
+	stop() {
+		if (this.#handle === null) return;
+		clearInterval(this.#handle);
+		this.#handle = null;
+	}
+	get running() {
+		return this.#handle !== null;
+	}
+};
+//#endregion
+//#region src/numbering.ts
+/**
+* Flat-numbering tables for topics, services, and parameters (§4.2).
+*
+* Port of `fibril_can_core/src/numbering.cpp`. Numbering is a pure function
+* of (schema, instance-count-vector). The same tables are derived
+* independently by codegen (with max_count for static checks), the slave
+* runtime (with actual counts at boot) and the master (with counts from the
+* ANNOUNCE frame) — keeping this in one place is what guarantees they agree.
+*/
+const SERVICE_INDEX_CANCEL = 255;
+const SERVICE_INDEX_PARAM_SET = 253;
+/** Maximum first-class service_index produced by numbering (inclusive). */
+const SERVICE_INDEX_MAX = 252;
+/** Number of available first-class service slots. */
+const SERVICE_INDEX_CAPACITY = 253;
+let NumberingError = /* @__PURE__ */ function(NumberingError) {
+	NumberingError["Ok"] = "ok";
+	NumberingError["ServiceIndexOverflow"] = "service_index overflow (>253)";
+	NumberingError["TopicIndexOverflow"] = "topic_index overflow (>65535)";
+	NumberingError["ParamIndexOverflow"] = "param_index overflow (>65535)";
+	NumberingError["InstanceCountMismatch"] = "actual_counts length != #instances";
+	NumberingError["BlockTypeOutOfRange"] = "BlockArray::blockTypeIndex out of range";
+	return NumberingError;
+}({});
+const N_TOPICS = (bt) => bt.topics.length;
+const N_SERVICES = (bt) => bt.services.length;
+const N_PARAMS = (bt) => bt.params.length;
+function buildTable(schema, counts, pick) {
+	const byIndex = [];
+	const bases = [];
+	let base = 0;
+	bases.push(base);
+	for (let b = 0; b < schema.instances.length; b++) {
+		const arr = schema.instances[b];
+		if (!arr) continue;
+		const type = schema.types[arr.blockTypeIndex];
+		if (!type) continue;
+		const n = pick(type);
+		const count = counts[b] ?? 0;
+		for (let inst = 0; inst < count; inst++) for (let ep = 0; ep < n; ep++) byIndex.push({
+			blockArray: b,
+			instance: inst,
+			endpoint: ep
+		});
+		base += n * count;
+		bases.push(base);
+	}
+	return {
+		byIndex,
+		bases
+	};
+}
+/**
+* Compute the three numbering tables. `actualCounts` must have the same
+* length as `schema.instances`. The result has `status !== Ok` if input is
+* malformed or service_index would overflow into the reserved range
+* (§4.2 §9.4).
+*
+* On error the returned tables are empty but still safe to inspect.
+*/
+function computeNumbering(schema, actualCounts) {
+	const empty = {
+		byIndex: [],
+		bases: []
+	};
+	const fail = (status) => ({
+		topics: empty,
+		services: empty,
+		params: empty,
+		status
+	});
+	if (actualCounts.length !== schema.instances.length) return fail("actual_counts length != #instances");
+	for (const arr of schema.instances) if (arr.blockTypeIndex >= schema.types.length) return fail("BlockArray::blockTypeIndex out of range");
+	const topics = buildTable(schema, actualCounts, N_TOPICS);
+	const services = buildTable(schema, actualCounts, N_SERVICES);
+	const params = buildTable(schema, actualCounts, N_PARAMS);
+	if (topics.byIndex.length > 65535) return {
+		topics: empty,
+		services: empty,
+		params: empty,
+		status: "topic_index overflow (>65535)"
+	};
+	if (params.byIndex.length > 65535) return {
+		topics: empty,
+		services: empty,
+		params: empty,
+		status: "param_index overflow (>65535)"
+	};
+	if (services.byIndex.length > 253) return {
+		topics: empty,
+		services: empty,
+		params: empty,
+		status: "service_index overflow (>253)"
+	};
+	return {
+		topics,
+		services,
+		params,
+		status: "ok"
+	};
+}
+//#endregion
+//#region src/schema-hash.ts
+/**
+* SHA-256 helpers for the schema blob (§5.4, §9.3).
+*
+* Both codegen (C++) and the bridge (C++) hash the entire schema blob with
+* SHA-256 and pack the first 8 bytes as little-endian u64 into the ANNOUNCE
+* frame. This module is the master-side equivalent: hash the blob we
+* received over SCHEMA_DATA and compare with the schema_hash the slave
+* advertised in ANNOUNCE.
+*
+* Uses Web Crypto (`crypto.subtle`) — available in modern browsers and Node
+* ≥ 19 / Deno / Bun, no polyfill needed for our target environments.
+*/
+async function sha256(bytes) {
+	if (typeof crypto === "undefined" || !crypto.subtle) throw new Error("crypto.subtle is not available in this environment");
+	const owned = new Uint8Array(bytes);
+	const digest = await crypto.subtle.digest("SHA-256", owned);
+	return new Uint8Array(digest);
+}
+/**
+* Compute the ANNOUNCE-shape schema hash: the first 8 bytes of SHA-256(blob),
+* interpreted as a little-endian u64. Mirrors
+* `fibril_can_core/sha256::hash_prefix_u64`.
+*/
+async function schemaHashPrefix(blob) {
+	const digest = await sha256(blob);
+	let result = 0n;
+	for (let i = 0; i < 8; i++) result |= BigInt(digest[i] ?? 0) << BigInt(i * 8);
+	return result;
+}
+//#endregion
+//#region src/schema-index.ts
+/**
+* Schema-driven path lookup. Resolves `'<expanded_ns>/<endpoint_name>'`
+* style paths to the flat (topic|service|param) index plus the field IR
+* needed to drive {@link ./dynamic-codec.ts}.
+*
+* Paths are local to a single slave (one {@link NodeAgent}). The block-array
+* `ros_namespace` is expanded by substituting `{i}` with the instance index
+* (mirrors `expand_i_token` in `fibril_can_bridge::node_agent_internal.hpp`).
+*
+* Two endpoints of the same kind sharing a path is a schema error — the
+* index throws on construction. Same path across different kinds (e.g. a
+* topic and a service named `motor0/foo`) is allowed because the caller
+* selects the kind explicitly via `topic()` / `service()` / `param()`.
+*/
+const I_TOKEN = "{i}";
+function expandIToken(s, value) {
+	if (!s.includes(I_TOKEN)) return s;
+	return s.split(I_TOKEN).join(String(value));
+}
+function joinPath(ns, name) {
+	if (ns.length === 0) return name;
+	if (name.length === 0) return ns;
+	return `${ns}/${name}`;
+}
+function sumFieldsWireSize(fields) {
+	let n = 0;
+	for (const f of fields) n += fieldWireSize(f);
+	return n;
+}
+/**
+* Path → descriptor index for one slave. Built once from
+* (schema, numbering) and reused for the lifetime of a snapshot.
+*/
+var SchemaIndex = class {
+	#topicsByPath = /* @__PURE__ */ new Map();
+	#servicesByPath = /* @__PURE__ */ new Map();
+	#paramsByPath = /* @__PURE__ */ new Map();
+	#topicsByIndex = /* @__PURE__ */ new Map();
+	#servicesByIndex = /* @__PURE__ */ new Map();
+	#paramsByIndex = /* @__PURE__ */ new Map();
+	constructor(schema, numbering, instanceCounts) {
+		if (instanceCounts.length !== schema.instances.length) throw new RangeError(`SchemaIndex: instanceCounts.length (${instanceCounts.length}) != schema.instances.length (${schema.instances.length})`);
+		for (let arrIdx = 0; arrIdx < schema.instances.length; arrIdx++) {
+			const arr = schema.instances[arrIdx];
+			if (!arr) continue;
+			const block = schema.types[arr.blockTypeIndex];
+			if (!block) continue;
+			const topicBase = numbering.topics.bases[arrIdx];
+			const serviceBase = numbering.services.bases[arrIdx];
+			const paramBase = numbering.params.bases[arrIdx];
+			if (topicBase === void 0 || serviceBase === void 0 || paramBase === void 0) continue;
+			const instCount = instanceCounts[arrIdx] ?? 0;
+			for (let inst = 0; inst < instCount; inst++) {
+				const ns = expandIToken(arr.rosNamespace, inst);
+				for (let ep = 0; ep < block.topics.length; ep++) {
+					const t = block.topics[ep];
+					if (!t) continue;
+					const path = joinPath(ns, t.name);
+					const idx = topicBase + inst * block.topics.length + ep;
+					const desc = {
+						kind: "topic",
+						path,
+						topicIndex: idx,
+						dir: t.dir,
+						fields: t.fields,
+						defaultPeriodUs: t.defaultPeriodUs,
+						wireSize: sumFieldsWireSize(t.fields)
+					};
+					if (this.#topicsByPath.has(path)) throw new Error(`SchemaIndex: duplicate topic path '${path}'`);
+					this.#topicsByPath.set(path, desc);
+					this.#topicsByIndex.set(idx, desc);
+				}
+				for (let ep = 0; ep < block.services.length; ep++) {
+					const s = block.services[ep];
+					if (!s) continue;
+					const path = joinPath(ns, s.name);
+					const idx = serviceBase + inst * block.services.length + ep;
+					const desc = {
+						kind: "service",
+						path,
+						serviceIndex: idx,
+						requestFields: s.request,
+						responseFields: s.response,
+						requestWireSize: sumFieldsWireSize(s.request),
+						responseWireSize: sumFieldsWireSize(s.response)
+					};
+					if (this.#servicesByPath.has(path)) throw new Error(`SchemaIndex: duplicate service path '${path}'`);
+					this.#servicesByPath.set(path, desc);
+					this.#servicesByIndex.set(idx, desc);
+				}
+				for (let ep = 0; ep < block.params.length; ep++) {
+					const p = block.params[ep];
+					if (!p) continue;
+					const path = joinPath(ns, p.name);
+					const idx = paramBase + inst * block.params.length + ep;
+					const wireSize = fieldWireSize({
+						name: p.name,
+						type: p.type,
+						arrayLen: p.arrayLen,
+						txEnabled: true
+					});
+					const desc = {
+						kind: "param",
+						path,
+						paramIndex: idx,
+						type: p.type,
+						arrayLen: p.arrayLen,
+						wireSize,
+						defaultValue: p.defaultValue,
+						minValue: p.minValue,
+						maxValue: p.maxValue
+					};
+					if (this.#paramsByPath.has(path)) throw new Error(`SchemaIndex: duplicate param path '${path}'`);
+					this.#paramsByPath.set(path, desc);
+					this.#paramsByIndex.set(idx, desc);
+				}
+			}
+		}
+	}
+	topic(path) {
+		return this.#topicsByPath.get(path);
+	}
+	service(path) {
+		return this.#servicesByPath.get(path);
+	}
+	param(path) {
+		return this.#paramsByPath.get(path);
+	}
+	topicByIndex(idx) {
+		return this.#topicsByIndex.get(idx);
+	}
+	serviceByIndex(idx) {
+		return this.#servicesByIndex.get(idx);
+	}
+	paramByIndex(idx) {
+		return this.#paramsByIndex.get(idx);
+	}
+	/** All topic paths in numbering order. Useful for debugging / sniffer UI. */
+	topicPaths() {
+		return [...this.#topicsByPath.keys()];
+	}
+	servicePaths() {
+		return [...this.#servicesByPath.keys()];
+	}
+	paramPaths() {
+		return [...this.#paramsByPath.keys()];
+	}
+};
+//#endregion
+//#region src/seq-allocator.ts
+/**
+* Sequential u8 allocator used for the config-plane `seq` field shared by
+* every command this master has issued to a given slave. Wraps at 256,
+* matching `BridgeNode::alloc_seq` in
+* `fibril_can_bridge/src/bridge_node.cpp` (the bridge wraps on the same
+* boundary; the AckTracker indexes by the wrapped value).
+*/
+var SeqAllocator = class {
+	#next = 0;
+	next() {
+		const v = this.#next & 255;
+		this.#next = this.#next + 1 & 255;
+		return v;
+	}
+	reset() {
+		this.#next = 0;
+	}
+};
+//#endregion
+//#region src/segmented-transfer.ts
+/**
+* Build the §7.4 SVC_REQUEST frame stream for a master→slave call. Mirrors
+* `make_svc_request_frames` in
+* `fibril_can_bridge/include/fibril_can_bridge/svc_request.hpp`.
+*
+* - ≤64 byte payload → one SINGLE frame (seg=0).
+* - Larger → seq=0 carries `[0]=0 [1..2]=total_len + ≤61B data`, subsequent
+*   seqs carry `[0]=seq + ≤63B data`. Throws on payloads >1024B.
+*/
+function makeSvcRequestFrames(nodeId, svcIdx, callId, payload) {
+	if (payload.length > 1024) throw new RangeError(`service request payload ${payload.length} exceeds SEG_MAX_TOTAL (${SEG_MAX_TOTAL})`);
+	if (payload.length <= 64) return [{
+		id: makeExtId(1, nodeId, svcIdx, callId, 0),
+		extended: true,
+		fd: true,
+		data: payload
+	}];
+	const total = payload.length;
+	const rest = total - 61;
+	const nSegs = 1 + Math.ceil(rest / 63);
+	if (nSegs - 1 > 31) throw new RangeError(`segmented request would need ${nSegs} segments (cap 32)`);
+	const out = [];
+	for (let seq = 0; seq < nSegs; seq++) {
+		let body;
+		if (seq === 0) {
+			const take = Math.min(total, 61);
+			body = new Uint8Array(3 + take);
+			body[0] = 0;
+			body[1] = total & 255;
+			body[2] = total >>> 8 & 255;
+			body.set(payload.subarray(0, take), 3);
+		} else {
+			const off = segOffset(seq);
+			const take = Math.min(63, total - off);
+			body = new Uint8Array(1 + take);
+			body[0] = seq;
+			body.set(payload.subarray(off, off + take), 1);
+		}
+		out.push({
+			id: makeExtId(1, nodeId, svcIdx, callId, 1),
+			extended: true,
+			fd: true,
+			data: body
+		});
+	}
+	return out;
+}
+/**
+* Build §7.4 response segments. Used by mock slaves and any TS slave runtime.
+* `channel` is the channel field (typically `CHAN_SVC_RESPONSE`); the payload
+* is `[status, ...response]` so the caller bakes status into the buffer.
+*/
+function makeSvcSegmentedFrames(channel, nodeId, svcIdx, callId, payload) {
+	if (payload.length > 1024) throw new RangeError(`service response payload ${payload.length} exceeds SEG_MAX_TOTAL (${SEG_MAX_TOTAL})`);
+	if (payload.length <= 64) return [{
+		id: makeExtId(channel, nodeId, svcIdx, callId, 0),
+		extended: true,
+		fd: true,
+		data: payload
+	}];
+	const total = payload.length;
+	const rest = total - 61;
+	const nSegs = 1 + Math.ceil(rest / 63);
+	if (nSegs - 1 > 31) throw new RangeError(`segmented response would need ${nSegs} segments (cap 32)`);
+	const out = [];
+	for (let seq = 0; seq < nSegs; seq++) {
+		let body;
+		if (seq === 0) {
+			const take = Math.min(total, 61);
+			body = new Uint8Array(3 + take);
+			body[0] = 0;
+			body[1] = total & 255;
+			body[2] = total >>> 8 & 255;
+			body.set(payload.subarray(0, take), 3);
+		} else {
+			const off = segOffset(seq);
+			const take = Math.min(63, total - off);
+			body = new Uint8Array(1 + take);
+			body[0] = seq;
+			body.set(payload.subarray(off, off + take), 1);
+		}
+		out.push({
+			id: makeExtId(channel, nodeId, svcIdx, callId, 1),
+			extended: true,
+			fd: true,
+			data: body
+		});
+	}
+	return out;
+}
+/**
+* Bitmask of segment seqs required to reassemble a `totalLen`-byte payload.
+* Identical formula to `expected_mask` in
+* `fibril_can_bridge/src/node_agent.cpp` and the slave's `seg_expected_mask`.
+*/
+function segExpectedMask(totalLen) {
+	if (totalLen <= 0) return 0;
+	if (totalLen <= 61) return 1;
+	const rest = totalLen - 61;
+	const nSegs = 1 + Math.ceil(rest / 63);
+	if (nSegs >= 32) return 4294967295;
+	return (1 << nSegs) - 1;
+}
+/**
+* Per-(svc, call_id) reassembly slot. The caller drives one of these per
+* outstanding incoming segmented transfer.
+*/
+var SegmentReassembler = class {
+	totalLen = 0;
+	rxBitmap = 0;
+	lastRxMs = 0;
+	#buffer = /* @__PURE__ */ new Uint8Array(0);
+	/**
+	* Ingest one seg=1 frame. `data` is the frame payload (with the seq /
+	* total_len header still attached). Returns the fully-assembled payload
+	* once every required segment has arrived; otherwise null. Returns null
+	* on protocol violations and resets the slot.
+	*/
+	ingest(data, nowMs) {
+		if (data.length === 0) return this.#reset();
+		const seq = data[0] ?? 0;
+		if (seq > 31) return this.#reset();
+		this.lastRxMs = nowMs;
+		if (seq === 0) {
+			if (data.length < 3) return this.#reset();
+			const total = ((data[1] ?? 0) | (data[2] ?? 0) << 8) & 65535;
+			if (total === 0 || total > 1024) return this.#reset();
+			if (this.totalLen !== 0 && this.totalLen !== total) {
+				this.totalLen = total;
+				this.rxBitmap = 0;
+				this.#buffer = new Uint8Array(total);
+			} else {
+				this.totalLen = total;
+				if (this.#buffer.length < total) {
+					const grown = new Uint8Array(total);
+					grown.set(this.#buffer.subarray(0, Math.min(this.#buffer.length, total)));
+					this.#buffer = grown;
+				}
+			}
+			const segDataLen = Math.min(data.length - 3, 61, total);
+			if (segDataLen > 0) this.#buffer.set(data.subarray(3, 3 + segDataLen), 0);
+		} else {
+			const off = segOffset(seq);
+			const segDataLen = Math.min(data.length - 1, 63);
+			if (off + segDataLen > 1024) return this.#reset();
+			if (this.totalLen !== 0 && off + segDataLen > this.totalLen) return this.#reset();
+			if (this.#buffer.length < off + segDataLen) {
+				const grown = new Uint8Array(off + segDataLen);
+				grown.set(this.#buffer);
+				this.#buffer = grown;
+			}
+			if (segDataLen > 0) this.#buffer.set(data.subarray(1, 1 + segDataLen), off);
+		}
+		this.rxBitmap |= 1 << seq;
+		if (this.totalLen === 0) return null;
+		const need = segExpectedMask(this.totalLen);
+		if ((this.rxBitmap & ~need) !== 0) return this.#reset();
+		if ((this.rxBitmap & need) !== need) return null;
+		const out = this.#buffer.slice(0, this.totalLen);
+		this.#reset();
+		return out;
+	}
+	#reset() {
+		this.totalLen = 0;
+		this.rxBitmap = 0;
+		this.#buffer = /* @__PURE__ */ new Uint8Array(0);
+		return null;
+	}
+};
+//#endregion
+//#region src/service-client.ts
+/** Throwable error union for `ServiceClient.call`. */
+var ServiceCallError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var ServiceTimeoutError = class extends ServiceCallError {
+	constructor(message = "service call timed out") {
+		super(message);
+	}
+};
+var ServiceUnavailableError = class extends ServiceCallError {
+	constructor(message = "service unavailable (slave lost or reprovisioned)") {
+		super(message);
+	}
+};
+var ServiceCancelledError = class extends ServiceCallError {
+	constructor(message = "service call cancelled") {
+		super(message);
+	}
+};
+var NoCallSlotError = class extends ServiceCallError {
+	constructor(serviceIndex) {
+		super(`no free call_id slot for service_index ${serviceIndex}`);
+	}
+};
+/** Cap on simultaneous in-flight segmented transfers. Matches bridge. */
+const REASM_MAX_CONCURRENT = 16;
+/** §7.4 reassembly TTL. */
+const SEG_TIMEOUT_MS = 100;
+/**
+* Single-slave master service-call client. Port of NodeAgent's
+* begin_service_call / on_service_response / on_service_segment flow but
+* Promise-based and AbortSignal-aware.
+*
+* One {@link ServiceClient} attaches to the transport and demuxes incoming
+* SVC_RESPONSE frames for a single `nodeId`. NodeAgent owns one per slave
+* and exposes it on the running snapshot.
+*/
+var ServiceClient = class {
+	nodeId;
+	#transport;
+	#defaultTimeoutMs;
+	#now;
+	#unsub = null;
+	#nextCallId = /* @__PURE__ */ new Map();
+	#pending = /* @__PURE__ */ new Map();
+	constructor(opts) {
+		this.nodeId = opts.nodeId;
+		this.#transport = opts.transport;
+		this.#defaultTimeoutMs = opts.defaultTimeoutMs ?? 250;
+		this.#now = opts.now ?? (() => Date.now());
+	}
+	attach() {
+		if (this.#unsub !== null) return;
+		this.#unsub = this.#transport.onFrame((f) => this.#onFrame(f));
+	}
+	detach() {
+		if (this.#unsub === null) return;
+		this.#unsub();
+		this.#unsub = null;
+	}
+	/** Number of in-flight calls. Testing / introspection. */
+	get pendingCount() {
+		return this.#pending.size;
+	}
+	/**
+	* Sweep call deadlines and segment-reassembly TTLs. The owning agent
+	* should call this from its periodic sweep loop.
+	*/
+	sweep(nowMs = this.#now()) {
+		for (const [key, call] of this.#pending) {
+			if (call.deadlineMs <= nowMs) {
+				this.#pending.delete(key);
+				this.#detachAbort(call);
+				call.reject(new ServiceTimeoutError());
+				continue;
+			}
+			if (call.reassembler.totalLen !== 0 && nowMs - call.reassembler.lastRxMs > SEG_TIMEOUT_MS) {
+				call.reassembler.totalLen = 0;
+				call.reassembler.rxBitmap = 0;
+			}
+		}
+	}
+	/** Reject every in-flight call as Unavailable. NodeAgent calls this on lost / reprovision. */
+	failAll(reason = "slave reprovisioning") {
+		const pending = [...this.#pending.values()];
+		this.#pending.clear();
+		for (const c of pending) {
+			this.#detachAbort(c);
+			c.reject(new ServiceUnavailableError(reason));
+		}
+	}
+	async call(serviceIndex, opts) {
+		if (serviceIndex < 0 || serviceIndex > 255) throw new RangeError(`serviceIndex out of range: ${serviceIndex}`);
+		const callId = this.#allocCallId(serviceIndex);
+		if (callId === 255) throw new NoCallSlotError(serviceIndex);
+		const timeoutMs = opts.timeoutMs ?? this.#defaultTimeoutMs;
+		const key = serviceIndex << 8 | callId;
+		if (this.#pending.size >= REASM_MAX_CONCURRENT * 4) throw new NoCallSlotError(serviceIndex);
+		return new Promise((resolve, reject) => {
+			const call = {
+				serviceIndex,
+				callId,
+				deadlineMs: this.#now() + timeoutMs,
+				timeoutMs,
+				resolve,
+				reject,
+				reassembler: new SegmentReassembler(),
+				acceptedSeen: false
+			};
+			if (opts.signal) {
+				call.signal = opts.signal;
+				if (opts.signal.aborted) {
+					reject(new ServiceCancelledError());
+					return;
+				}
+				call.abortListener = () => {
+					if (!this.#pending.has(key)) return;
+					this.#pending.delete(key);
+					this.#detachAbort(call);
+					this.#sendCancel(call.serviceIndex, call.callId).catch(() => {});
+					reject(new ServiceCancelledError());
+				};
+				opts.signal.addEventListener("abort", call.abortListener, { once: true });
+			}
+			this.#pending.set(key, call);
+			const frames = makeSvcRequestFrames(this.nodeId, serviceIndex, callId, opts.request);
+			for (const f of frames) this.#transport.send(f).catch(() => {});
+		});
+	}
+	#onFrame(f) {
+		if (!f.extended) return;
+		if (extNodeId(f.id) !== this.nodeId) return;
+		if (extChannel(f.id) !== 2) return;
+		const svcIdx = extIndex(f.id);
+		const callId = extSeq(f.id);
+		const seg = extSeg(f.id);
+		const key = svcIdx << 8 | callId;
+		const call = this.#pending.get(key);
+		if (!call) return;
+		if (seg === 0) {
+			if (f.data.length === 0) return;
+			const status = f.data[0] ?? 0;
+			const data = f.data.slice(1);
+			this.#finishMaybeAccepted(key, call, status, data);
+			return;
+		}
+		const assembled = call.reassembler.ingest(f.data, this.#now());
+		if (assembled === null) return;
+		if (assembled.length === 0) return;
+		const status = assembled[0] ?? 0;
+		const data = assembled.slice(1);
+		this.#finishMaybeAccepted(key, call, status, data);
+	}
+	#finishMaybeAccepted(key, call, status, data) {
+		if (status === 1) {
+			if (!call.acceptedSeen) {
+				call.acceptedSeen = true;
+				call.deadlineMs = this.#now() + call.timeoutMs;
+			}
+			return;
+		}
+		this.#pending.delete(key);
+		this.#detachAbort(call);
+		call.resolve({
+			status,
+			data
+		});
+	}
+	#allocCallId(svcIdx) {
+		let next = this.#nextCallId.get(svcIdx) ?? 0;
+		for (let i = 0; i < 255; i++) {
+			if (next === 255) next = 0;
+			const key = svcIdx << 8 | next;
+			if (!this.#pending.has(key)) {
+				this.#nextCallId.set(svcIdx, next + 1 & 255);
+				return next;
+			}
+			next = next + 1 & 255;
+		}
+		return 255;
+	}
+	async #sendCancel(svcIdx, callId) {
+		const payload = padToDlc(new Uint8Array([svcIdx & 255, callId & 255]));
+		await this.#transport.send({
+			id: makeExtId(1, this.nodeId, 255, 0, 0),
+			extended: true,
+			fd: true,
+			data: payload
+		});
+	}
+	#detachAbort(call) {
+		if (call.signal && call.abortListener) {
+			call.signal.removeEventListener("abort", call.abortListener);
+			call.abortListener = void 0;
+		}
+	}
+};
+//#endregion
+//#region src/typed-param.ts
+/**
+* Schema-driven typed wrapper around PARAM_SET (SPEC §8.2, reserved
+* service_index 0xFD).
+*
+* Per SPEC §8.1 PARAM is M→S one-way: the master holds the source of truth
+* and re-injects defaults at provisioning time, so this wrapper exposes
+* `.set()` only — there's no `.get()` that queries the slave. The
+* descriptor's decoded default is available via `defaultValue()` for
+* reference / hydration of master-side state.
+*
+* The wire shape for one PARAM_SET request is:
+*   [0] count = 1
+*   [1..2] u16 param_index (LE)
+*   [3..]  value (scalar little-endian or fixed-array contiguous)
+*
+* Response is `[0] status [1..2] failed_param_index (when status != OK)`.
+* `set()` resolves with the status code; non-OK includes `failedIndex` so
+* the caller can correlate with a multi-param batch (single-param sets
+* always blame this param).
+*/
+var ParamCodecError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ParamCodecError";
+	}
+};
+function packValueInto(desc, value, out, offset) {
+	if (desc.arrayLen === 0) {
+		packOneScalar(desc.type, value, out, offset, desc.path);
+		return;
+	}
+	if (!Array.isArray(value)) throw new ParamCodecError(`param '${desc.path}': expected array of length ${desc.arrayLen}, got ${typeof value}`);
+	if (value.length !== desc.arrayLen) throw new ParamCodecError(`param '${desc.path}': expected array length ${desc.arrayLen}, got ${value.length}`);
+	const stride = scalarSize(desc.type);
+	for (let i = 0; i < desc.arrayLen; i++) packOneScalar(desc.type, value[i], out, offset + i * stride, desc.path);
+}
+function packOneScalar(type, value, out, offset, pathForErr) {
+	switch (type) {
+		case 0:
+			if (typeof value !== "boolean") throw new ParamCodecError(`param '${pathForErr}': expected boolean for bool, got ${typeof value}`);
+			out[offset] = value ? 1 : 0;
+			return;
+		case 9:
+			if (typeof value !== "number") throw new ParamCodecError(`param '${pathForErr}': expected number for f32, got ${typeof value}`);
+			packScalarF32Le(value, out, offset);
+			return;
+		case 10:
+			if (typeof value !== "number") throw new ParamCodecError(`param '${pathForErr}': expected number for f64, got ${typeof value}`);
+			packScalarF64Le(value, out, offset);
+			return;
+		default:
+			if (type === 7 || type === 8) {
+				if (typeof value !== "bigint") throw new ParamCodecError(`param '${pathForErr}': expected bigint for ${scalarName(type)}, got ${typeof value}`);
+			} else if (typeof value !== "number") throw new ParamCodecError(`param '${pathForErr}': expected number for ${scalarName(type)}, got ${typeof value}`);
+			packScalarIntLe(type, value, out, offset);
+	}
+}
+function unpackScalar(type, src, offset) {
+	switch (type) {
+		case 0: return (src[offset] ?? 0) !== 0;
+		case 9: return unpackScalarF32Le(src, offset);
+		case 10: return unpackScalarF64Le(src, offset);
+		case 2:
+		case 4:
+		case 6: {
+			const bits = unpackScalarIntLe(type, src, offset);
+			return Number(signExtend(bits, scalarSize(type)));
+		}
+		case 1:
+		case 3:
+		case 5: return Number(unpackScalarIntLe(type, src, offset));
+		case 8: return signExtend(unpackScalarIntLe(type, src, offset), 8);
+		case 7: return unpackScalarIntLe(type, src, offset);
+	}
+}
+function unpackValue(desc, src) {
+	if (src.length < desc.wireSize) return null;
+	if (desc.arrayLen === 0) return unpackScalar(desc.type, src, 0);
+	const stride = scalarSize(desc.type);
+	const out = [];
+	for (let i = 0; i < desc.arrayLen; i++) out.push(unpackScalar(desc.type, src, i * stride));
+	return out;
+}
+/** Build a PARAM_SET request payload for a single (descriptor, value) pair. */
+function encodeParamSetSingle(desc, value) {
+	const out = new Uint8Array(3 + desc.wireSize);
+	out[0] = 1;
+	out[1] = desc.paramIndex & 255;
+	out[2] = desc.paramIndex >>> 8 & 255;
+	packValueInto(desc, value, out, 3);
+	return out;
+}
+var TypedParam = class {
+	path;
+	descriptor;
+	#client;
+	constructor(client, descriptor) {
+		this.#client = client;
+		this.descriptor = descriptor;
+		this.path = descriptor.path;
+	}
+	/**
+	* Decode the schema-embedded default value (SPEC §9.1 `default`). Useful
+	* to seed the master-side persistence store. Returns `null` if the
+	* descriptor carries no default payload.
+	*/
+	defaultValue() {
+		if (this.descriptor.defaultValue.length === 0) return null;
+		return unpackValue(this.descriptor, this.descriptor.defaultValue);
+	}
+	/** Send a PARAM_SET with a single entry for this param. */
+	async set(value, opts = {}) {
+		const request = encodeParamSetSingle(this.descriptor, value);
+		const result = await this.#client.call(253, {
+			request,
+			timeoutMs: opts.timeoutMs,
+			signal: opts.signal
+		});
+		let failedIndex = null;
+		if (result.status !== 0 && result.data.length >= 2) failedIndex = (result.data[0] ?? 0) | (result.data[1] ?? 0) << 8;
+		return {
+			status: result.status,
+			failedIndex
+		};
+	}
+};
+//#endregion
+//#region src/typed-service.ts
+var TypedService = class {
+	path;
+	descriptor;
+	#client;
+	constructor(client, descriptor) {
+		this.#client = client;
+		this.descriptor = descriptor;
+		this.path = descriptor.path;
+	}
+	/** Encode `request`, dispatch via the service plane, decode the response. */
+	async call(request, opts = {}) {
+		const encoded = encodeFields(this.descriptor.requestFields, request);
+		const result = await this.#client.call(this.descriptor.serviceIndex, {
+			request: encoded,
+			timeoutMs: opts.timeoutMs,
+			signal: opts.signal
+		});
+		let data = null;
+		if (this.descriptor.responseFields.length === 0) data = Object.freeze({});
+		else if (result.data.length >= this.descriptor.responseWireSize) data = decodeFields(this.descriptor.responseFields, result.data);
+		return {
+			status: result.status,
+			data
+		};
+	}
+};
+//#endregion
+//#region src/node-agent.ts
+const DEFAULT_OPTS = {
+	ackTimeoutMs: 250,
+	schemaChunkSize: 59,
+	schemaReadRetries: 3,
+	heartbeatTimeoutMs: 350
+};
+/**
+* Per-slave provisioning state machine. Mirrors
+* `fibril_can_bridge::NodeAgent` lifecycle entry points but trimmed for the
+* single-threaded TS master — no ROS entity creation, no PARAM_SET
+* re-injection (P5), no plan computation (P6).
+*
+* Lifecycle: `idle` → `awaiting-announce` → `schema-reading` (skipped if
+* blob already cached on this agent instance) → `numbering` →
+* `provisioning` → `running`. HEARTBEAT loss drops to `lost`; the next
+* ANNOUNCE restarts the flow.
+*/
+var NodeAgent = class {
+	nodeId;
+	#transport;
+	#framePlan;
+	#ackTimeoutMs;
+	#schemaChunkSize;
+	#schemaReadRetries;
+	#heartbeatTimeoutMs;
+	#autoStart;
+	#onState;
+	#onError;
+	#now;
+	#seq = new SeqAllocator();
+	#acks;
+	#services;
+	#unsubFrame = null;
+	#sweepHandle = null;
+	#stopped = false;
+	#state = { kind: "idle" };
+	#announce = null;
+	#schemaRead = null;
+	#provisioning = null;
+	#pendingStart = null;
+	#snapshot = null;
+	#generation = 0;
+	#blobCache = /* @__PURE__ */ new Map();
+	#lastHeartbeatMs = null;
+	constructor(opts) {
+		if (opts.nodeId < 1 || opts.nodeId > 126) throw new RangeError(`nodeId must be 1..0x7E, got ${opts.nodeId}`);
+		this.nodeId = opts.nodeId;
+		this.#transport = opts.transport;
+		this.#framePlan = opts.framePlan;
+		this.#ackTimeoutMs = opts.ackTimeoutMs ?? DEFAULT_OPTS.ackTimeoutMs;
+		this.#schemaChunkSize = opts.schemaChunkSize ?? DEFAULT_OPTS.schemaChunkSize;
+		this.#schemaReadRetries = opts.schemaReadRetries ?? DEFAULT_OPTS.schemaReadRetries;
+		this.#heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? DEFAULT_OPTS.heartbeatTimeoutMs;
+		this.#autoStart = opts.autoStart ?? (() => true);
+		this.#onState = opts.onState;
+		this.#onError = opts.onError;
+		this.#now = opts.now ?? (() => Date.now());
+		this.#acks = new AckTracker(this.#now);
+		this.#services = new ServiceClient({
+			nodeId: this.nodeId,
+			transport: this.#transport,
+			defaultTimeoutMs: opts.serviceTimeoutMs ?? this.#ackTimeoutMs,
+			now: this.#now
+		});
+	}
+	/** Service-plane RPC client for this slave. Always available. */
+	get services() {
+		return this.#services;
+	}
+	get state() {
+		return this.#state;
+	}
+	get snapshot() {
+		return this.#snapshot;
+	}
+	/**
+	* Attach to the transport and wait for ANNOUNCE. Resolves immediately —
+	* progress flows via {@link state} / {@link snapshot} / `onState`. Call
+	* `stop()` to detach.
+	*/
+	async start() {
+		if (this.#stopped) throw new Error("NodeAgent.start() after stop() is not supported — construct a new agent");
+		if (this.#unsubFrame !== null) return;
+		this.#unsubFrame = this.#transport.onFrame((f) => this.#onFrame(f));
+		this.#services.attach();
+		this.#sweepHandle = setInterval(() => this.#sweep(), 50);
+		this.#setState({ kind: "awaiting-announce" });
+	}
+	/**
+	* Re-run the FRAME_DEFINE / START handshake against the live slave using
+	* the most recent ANNOUNCE + cached schema. The {@link FramePlanFactory}
+	* is invoked again — callers that key off an external mutable state
+	* (e.g. per-field TX-enable overrides) will see the latest values.
+	*
+	* The agent must have observed an ANNOUNCE already; `reprovision()`
+	* before that throws. RUNNING is required so that the slave is known to
+	* be reachable — calling during `lost` would race the heartbeat
+	* watchdog. Pending service calls are failed and the current snapshot is
+	* torn down before the new bring-up begins, mirroring what happens on a
+	* boot_id change.
+	*/
+	async reprovision() {
+		if (this.#stopped) throw new Error("NodeAgent.reprovision() after stop()");
+		const a = this.#announce;
+		if (a === null) throw new Error("NodeAgent.reprovision() called before ANNOUNCE");
+		const cached = this.#blobCache.get(a.schemaHash);
+		if (!cached) throw new Error("NodeAgent.reprovision(): no cached schema for current ANNOUNCE");
+		this.#reprovisionState();
+		await this.#beginBringUp({
+			schemaHash: a.schemaHash,
+			bootId: a.bootId,
+			blobLen: a.blobLen,
+			protocolVersion: a.protocolVersion,
+			instanceCounts: a.instanceCounts
+		}, cached.schema, cached.blob);
+	}
+	/** Detach, send STOP if currently RUNNING, clear all in-flight state. */
+	async stop() {
+		if (this.#stopped) return;
+		this.#stopped = true;
+		if (this.#sweepHandle !== null) {
+			clearInterval(this.#sweepHandle);
+			this.#sweepHandle = null;
+		}
+		if (this.#unsubFrame !== null) {
+			this.#unsubFrame();
+			this.#unsubFrame = null;
+		}
+		this.#services.detach();
+		this.#services.failAll("NodeAgent.stop()");
+		if (this.#state.kind === "running" && this.#transport.isOpen) try {
+			await this.#transport.send(encodeStop(this.nodeId, this.#seq.next()));
+		} catch (e) {
+			this.#error(e);
+		}
+		this.#acks.clear();
+		this.#schemaRead = null;
+		this.#provisioning = null;
+		this.#pendingStart = null;
+		this.#snapshot = null;
+		this.#setState({ kind: "idle" });
+	}
+	#onFrame(f) {
+		if (!f.extended) return;
+		if (extNodeId(f.id) !== this.nodeId) return;
+		if (extChannel(f.id) !== 0) return;
+		const cmd = extIndex(f.id);
+		const seq = extSeq(f.id);
+		switch (cmd) {
+			case 2:
+				this.#handleAnnounce(f.data);
+				break;
+			case 5:
+				this.#handleHeartbeat(f.data);
+				break;
+			case 4:
+				this.#handleSchemaData(seq, f.data);
+				break;
+			case 126:
+				this.#acks.onAck(seq);
+				break;
+			case 127: {
+				const m = decodeNak(f.data);
+				if (m) this.#acks.onNak(seq, m.reason);
+				break;
+			}
+			default: break;
+		}
+	}
+	#sweep() {
+		const now = this.#now();
+		this.#acks.sweep(now);
+		this.#services.sweep(now);
+		if (this.#lastHeartbeatMs !== null && this.#state.kind !== "lost") {
+			if (now - this.#lastHeartbeatMs > this.#heartbeatTimeoutMs) this.#enterLost("heartbeat timeout");
+		}
+		if (this.#schemaRead && this.#schemaRead.inflightDeadlineMs <= now) this.#onSchemaReadStall();
+	}
+	#handleAnnounce(data) {
+		const a = decodeAnnounce(data);
+		if (!a) {
+			this.#error(/* @__PURE__ */ new Error("malformed ANNOUNCE"));
+			return;
+		}
+		const prev = this.#announce;
+		const isReboot = prev !== null && prev.bootId !== a.bootId;
+		const isHashChange = prev !== null && prev.schemaHash !== a.schemaHash;
+		this.#announce = {
+			schemaHash: a.schemaHash,
+			bootId: a.bootId,
+			blobLen: a.blobLen,
+			protocolVersion: a.protocolVersion,
+			instanceCounts: a.instanceCounts
+		};
+		if (this.#state.kind === "running" && !isReboot && !isHashChange) return;
+		if (this.#state.kind === "provisioning" && !isReboot && !isHashChange) return;
+		if (this.#state.kind === "awaiting-start" && !isReboot && !isHashChange) return;
+		if (this.#state.kind === "schema-reading" && !isReboot && !isHashChange) return;
+		this.#reprovisionState();
+		const cached = this.#blobCache.get(a.schemaHash);
+		if (cached) {
+			this.#beginBringUp(a, cached.schema, cached.blob);
+			return;
+		}
+		this.#startSchemaRead(a);
+	}
+	#handleHeartbeat(data) {
+		const h = decodeHeartbeat(data);
+		if (!h) {
+			this.#error(/* @__PURE__ */ new Error("malformed HEARTBEAT"));
+			return;
+		}
+		this.#lastHeartbeatMs = this.#now();
+		if (this.#announce && this.#announce.bootId !== h.bootId) {
+			this.#announce = null;
+			this.#reprovisionState();
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		if (this.#state.kind === "lost") {
+			if (this.#snapshot !== null) this.#setState({ kind: "running" });
+			else if (this.#pendingStart !== null) this.#setState({ kind: "awaiting-start" });
+		}
+	}
+	#startSchemaRead(a) {
+		const progress = {
+			expectedTotal: a.blobLen,
+			acc: new SchemaAccumulator(a.blobLen),
+			inflightSeq: 0,
+			inflightLen: 0,
+			retriesLeft: this.#schemaReadRetries,
+			inflightDeadlineMs: 0
+		};
+		this.#schemaRead = progress;
+		this.#setState({
+			kind: "schema-reading",
+			received: 0,
+			total: a.blobLen
+		});
+		this.#issueSchemaReadChunk(progress, false);
+	}
+	#issueSchemaReadChunk(p, retry) {
+		const remaining = Math.max(0, p.expectedTotal - p.acc.length);
+		if (remaining === 0) return;
+		const len = Math.min(remaining, this.#schemaChunkSize);
+		const seq = retry ? p.inflightSeq : this.#seq.next();
+		p.inflightSeq = seq;
+		p.inflightLen = len;
+		p.inflightDeadlineMs = this.#now() + this.#ackTimeoutMs;
+		this.#transport.send(encodeSchemaRead(this.nodeId, p.acc.length, len, seq)).catch((e) => this.#error(e));
+	}
+	#onSchemaReadStall() {
+		const p = this.#schemaRead;
+		if (!p) return;
+		if (p.retriesLeft <= 0) {
+			this.#error(/* @__PURE__ */ new Error(`schema-read stalled (offset ${p.acc.length} of ${p.expectedTotal})`));
+			this.#schemaRead = null;
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		p.retriesLeft -= 1;
+		this.#issueSchemaReadChunk(p, true);
+	}
+	#handleSchemaData(seq, data) {
+		const p = this.#schemaRead;
+		if (!p) return;
+		const m = decodeSchemaData(data);
+		if (!m) {
+			this.#error(/* @__PURE__ */ new Error("malformed SCHEMA_DATA"));
+			return;
+		}
+		if (m.offset !== p.acc.length) return;
+		if (p.acc.append(m, p.inflightLen) === 0) return;
+		p.retriesLeft = this.#schemaReadRetries;
+		if (!p.acc.complete) {
+			this.#setState({
+				kind: "schema-reading",
+				received: p.acc.length,
+				total: p.expectedTotal
+			});
+			this.#issueSchemaReadChunk(p, false);
+			return;
+		}
+		const blob = p.acc.bytes();
+		this.#schemaRead = null;
+		this.#finishSchemaRead(blob);
+	}
+	async #finishSchemaRead(blob) {
+		const a = this.#announce;
+		if (!a) return;
+		let actualHash;
+		try {
+			actualHash = await schemaHashPrefix(blob);
+		} catch (e) {
+			this.#error(e);
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		if (actualHash !== a.schemaHash) {
+			this.#error(/* @__PURE__ */ new Error(`schema hash mismatch: announced ${a.schemaHash.toString(16)}, actual ${actualHash.toString(16)}`));
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		let schema;
+		try {
+			schema = decodeSchema(blob);
+		} catch (e) {
+			this.#error(e);
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		this.#blobCache.set(a.schemaHash, {
+			blob,
+			schema
+		});
+		await this.#beginBringUp(a, schema, blob);
+	}
+	async #beginBringUp(a, schema, blob) {
+		this.#setState({ kind: "numbering" });
+		const numbering = computeNumbering(schema, Array.from(a.instanceCounts));
+		if (numbering.status !== "ok") {
+			this.#error(/* @__PURE__ */ new Error(`numbering failed: ${numbering.status}`));
+			this.#setState({
+				kind: "blocked",
+				reason: `numbering: ${numbering.status}`
+			});
+			return;
+		}
+		const plan = typeof this.#framePlan === "function" ? this.#framePlan(schema, numbering, { nodeId: this.nodeId }) : this.#framePlan;
+		try {
+			await this.#transport.send(encodeDiscoverTo(this.nodeId));
+		} catch (e) {
+			this.#error(e);
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		const gen = ++this.#generation;
+		const stdIdToTopicIndex = /* @__PURE__ */ new Map();
+		for (const fp of plan) for (const entry of fp.entries) if (!stdIdToTopicIndex.has(fp.stdId)) stdIdToTopicIndex.set(fp.stdId, entry.topicIndex);
+		const progress = {
+			generation: gen,
+			pendingDefines: plan.length,
+			anyFailure: false,
+			firstNakReason: 0,
+			plan,
+			stdIdToTopicIndex
+		};
+		this.#provisioning = progress;
+		if (plan.length === 0) {
+			this.#provisioning.pendingDefines = 0;
+			this.#setState({
+				kind: "provisioning",
+				pendingDefines: 0
+			});
+			this.#maybeIssueStart(a, schema, blob, numbering, gen, progress);
+			return;
+		}
+		this.#setState({
+			kind: "provisioning",
+			pendingDefines: plan.length
+		});
+		const deadline = this.#now() + this.#ackTimeoutMs;
+		for (const fp of plan) {
+			const seq = this.#seq.next();
+			this.#acks.track(seq, deadline, (outcome) => this.#onFrameDefineOutcome(a, schema, blob, numbering, gen, outcome));
+			const wireDir = fp.dir === 1 ? 0 : 1;
+			this.#transport.send(encodeFrameDefine(this.nodeId, seq, fp.stdId, fp.periodUs, wireDir, fp.entries)).catch((e) => this.#error(e));
+		}
+	}
+	#onFrameDefineOutcome(a, schema, blob, numbering, gen, outcome) {
+		const p = this.#provisioning;
+		if (!p || p.generation !== gen) return;
+		if (outcome.kind !== "acked") {
+			if (!p.anyFailure) {
+				p.anyFailure = true;
+				p.firstNakReason = outcome.kind === "naked" ? outcome.reason : 0;
+			}
+		}
+		if (p.pendingDefines === 0) return;
+		p.pendingDefines -= 1;
+		this.#setState({
+			kind: "provisioning",
+			pendingDefines: p.pendingDefines
+		});
+		if (p.pendingDefines > 0) return;
+		if (p.anyFailure) {
+			this.#error(/* @__PURE__ */ new Error(`FRAME_DEFINE failed (first NAK reason ${p.firstNakReason})`));
+			this.#provisioning = null;
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		this.#maybeIssueStart(a, schema, blob, numbering, gen, p);
+	}
+	/**
+	* FRAME_DEFINE has succeeded (or been skipped). Consult the autoStart
+	* gate and either fire START immediately or park in `awaiting-start`,
+	* remembering enough context that `startNow()` can resume without
+	* re-running FRAME_DEFINE.
+	*/
+	#maybeIssueStart(a, schema, blob, numbering, gen, progress) {
+		if (this.#autoStart()) {
+			this.#issueStart(a, schema, blob, numbering, gen);
+			return;
+		}
+		this.#pendingStart = {
+			a,
+			schema,
+			blob,
+			numbering,
+			generation: gen,
+			progress
+		};
+		this.#setState({ kind: "awaiting-start" });
+	}
+	/**
+	* Commit the deferred START when {@link NodeAgentOptions.autoStart}
+	* gated the previous bring-up. Only legal in `awaiting-start`; any
+	* other state throws so callers spot logic bugs instead of racing
+	* with a fresh ANNOUNCE.
+	*/
+	async startNow() {
+		if (this.#stopped) throw new Error("NodeAgent.startNow() after stop()");
+		if (this.#state.kind !== "awaiting-start" || this.#pendingStart === null) throw new Error(`NodeAgent.startNow() called in state '${this.#state.kind}'`);
+		const p = this.#pendingStart;
+		this.#pendingStart = null;
+		this.#setState({
+			kind: "provisioning",
+			pendingDefines: 0
+		});
+		this.#issueStart(p.a, p.schema, p.blob, p.numbering, p.generation);
+	}
+	#issueStart(a, schema, blob, numbering, gen) {
+		const seq = this.#seq.next();
+		const deadline = this.#now() + this.#ackTimeoutMs;
+		this.#acks.track(seq, deadline, (outcome) => this.#onStartOutcome(a, schema, blob, numbering, gen, outcome));
+		this.#transport.send(encodeStart(this.nodeId, seq)).catch((e) => this.#error(e));
+	}
+	#onStartOutcome(a, schema, blob, numbering, gen, outcome) {
+		const p = this.#provisioning;
+		if (!p || p.generation !== gen) return;
+		if (outcome.kind !== "acked") {
+			this.#error(/* @__PURE__ */ new Error(`START ${outcome.kind === "naked" ? `NAKed reason=${outcome.reason}` : "timed out"}`));
+			this.#provisioning = null;
+			this.#setState({ kind: "awaiting-announce" });
+			return;
+		}
+		const index = new SchemaIndex(schema, numbering, Array.from(a.instanceCounts));
+		const client = this.#services;
+		this.#snapshot = {
+			nodeId: this.nodeId,
+			schemaHash: a.schemaHash,
+			bootId: a.bootId,
+			instanceCounts: a.instanceCounts,
+			blob,
+			schema,
+			numbering,
+			framePlan: p.plan,
+			stdIdToTopicIndex: p.stdIdToTopicIndex,
+			services: client,
+			index,
+			service(path) {
+				const desc = index.service(path);
+				if (!desc) throw new Error(`unknown service path '${path}'`);
+				return new TypedService(client, desc);
+			},
+			param(path) {
+				const desc = index.param(path);
+				if (!desc) throw new Error(`unknown param path '${path}'`);
+				return new TypedParam(client, desc);
+			}
+		};
+		this.#provisioning = null;
+		this.#setState({ kind: "running" });
+	}
+	#reprovisionState() {
+		this.#acks.clear();
+		this.#services.failAll("NodeAgent reprovision");
+		this.#schemaRead = null;
+		this.#provisioning = null;
+		this.#pendingStart = null;
+		this.#snapshot = null;
+	}
+	#enterLost(reason) {
+		if (this.#state.kind === "lost") return;
+		this.#setState({
+			kind: "lost",
+			reason
+		});
+	}
+	#setState(s) {
+		this.#state = s;
+		this.#onState?.(s);
+	}
+	#error(e) {
+		const err = e instanceof Error ? e : new Error(String(e));
+		this.#onError?.(err);
+	}
+};
+//#endregion
+//#region src/master-controller.ts
+function readU64Le(p, off) {
+	let r = 0n;
+	for (let i = 0; i < 8; i++) r |= BigInt(p[off + i] ?? 0) << BigInt(i * 8);
+	return r;
+}
+var MasterController = class {
+	#transport;
+	#framePlan;
+	#heartbeatBroadcaster;
+	#dataPlane;
+	#discoverPeriodMs;
+	#initialDiscover;
+	#ackTimeoutMs;
+	#heartbeatTimeoutMs;
+	#serviceTimeoutMs;
+	#autoStart;
+	#now;
+	#onError;
+	#slaves = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Set();
+	#unsubFrame = null;
+	#discoverHandle = null;
+	#started = false;
+	constructor(opts) {
+		this.#transport = opts.transport;
+		this.#framePlan = opts.framePlan;
+		this.#heartbeatBroadcaster = new MasterHeartbeatBroadcaster(opts.transport, opts.heartbeatPeriodMs ?? 100);
+		this.#dataPlane = new DataPlaneReceiver({
+			transport: opts.transport,
+			...opts.onError !== void 0 ? { onError: opts.onError } : {},
+			...opts.now !== void 0 ? { now: opts.now } : {}
+		});
+		this.#discoverPeriodMs = opts.discoverPeriodMs ?? 0;
+		this.#initialDiscover = opts.initialDiscover ?? true;
+		this.#ackTimeoutMs = opts.ackTimeoutMs ?? 250;
+		this.#heartbeatTimeoutMs = opts.heartbeatTimeoutMs ?? 350;
+		this.#serviceTimeoutMs = opts.serviceTimeoutMs;
+		this.#autoStart = opts.autoStart ?? (() => true);
+		this.#now = opts.now ?? (() => Date.now());
+		this.#onError = opts.onError;
+	}
+	/**
+	* Master-side decoder for S→M topic frames. Auto-attached / detached as
+	* each slave transitions in and out of `running`. Subscribe with
+	* `dataPlane.onTopic(nodeId, path, listener)`; read latest values with
+	* `dataPlane.latest(nodeId, path)`.
+	*/
+	get dataPlane() {
+		return this.#dataPlane;
+	}
+	/**
+	* Attach to the transport, start MASTER_HEARTBEAT, fire one initial
+	* broadcast DISCOVER to flush stale slave state from a previous master
+	* session. New slaves auto-spawn a NodeAgent on first sight.
+	*/
+	start() {
+		if (this.#started) return;
+		this.#started = true;
+		this.#heartbeatBroadcaster.start();
+		this.#unsubFrame = this.#transport.onFrame((f) => this.#onFrame(f));
+		if (this.#initialDiscover) this.#transport.send(encodeDiscover()).catch((e) => this.#error(e));
+		if (this.#discoverPeriodMs > 0) this.#discoverHandle = setInterval(() => {
+			this.#transport.send(encodeDiscover()).catch((e) => this.#error(e));
+		}, this.#discoverPeriodMs);
+	}
+	/** Stop all internals, stop every NodeAgent, detach from the transport. */
+	async stop() {
+		if (!this.#started) return;
+		this.#started = false;
+		if (this.#discoverHandle !== null) {
+			clearInterval(this.#discoverHandle);
+			this.#discoverHandle = null;
+		}
+		this.#heartbeatBroadcaster.stop();
+		if (this.#unsubFrame) {
+			this.#unsubFrame();
+			this.#unsubFrame = null;
+		}
+		const stops = [...this.#slaves.values()].map((r) => r.agent.stop().catch(() => {}));
+		this.#slaves.clear();
+		this.#dataPlane.dispose();
+		await Promise.all(stops);
+		this.#emit();
+	}
+	/** Snapshot of all known slaves. Stable identity per call. */
+	snapshots() {
+		return [...this.#slaves.values()].map((r) => ({
+			nodeId: r.agent.nodeId,
+			state: r.state,
+			running: r.agent.snapshot,
+			lastHeartbeatMs: r.lastHeartbeatMs,
+			bootId: r.bootId,
+			schemaHash: r.schemaHash
+		})).sort((a, b) => a.nodeId - b.nodeId);
+	}
+	/** Subscribe to slave-set / state-change updates. Fires on every change. */
+	onChange(cb) {
+		this.#listeners.add(cb);
+		cb(this.snapshots());
+		return () => {
+			this.#listeners.delete(cb);
+		};
+	}
+	/**
+	* Access the NodeAgent for one slave, if it exists. Returns null until
+	* the slave has been observed. Useful for service / param calls from
+	* code that already knows the nodeId.
+	*/
+	agent(nodeId) {
+		return this.#slaves.get(nodeId)?.agent ?? null;
+	}
+	/** Issue an ad-hoc broadcast DISCOVER (between periodic firings). */
+	async discoverNow() {
+		await this.#transport.send(encodeDiscover());
+	}
+	/**
+	* Commit the deferred START on one slave that is parked in
+	* `awaiting-start` because the autoStart gate blocked its bring-up.
+	* Returns `false` if the slave is unknown or not currently waiting
+	* for a manual start; otherwise resolves once START has been queued
+	* on the wire (the RUNNING transition arrives later via `onChange`).
+	*/
+	async startNode(nodeId) {
+		const rec = this.#slaves.get(nodeId);
+		if (!rec) return false;
+		if (rec.state.kind !== "awaiting-start") return false;
+		try {
+			await rec.agent.startNow();
+			return true;
+		} catch (e) {
+			this.#error(e);
+			return false;
+		}
+	}
+	/**
+	* Re-run the FRAME_DEFINE / START handshake for one slave so the
+	* {@link FramePlanFactory} is consulted again. Use when external state
+	* the factory closes over has changed (e.g. per-field TX-enable
+	* toggles). Returns `false` when the slave is unknown or has never
+	* ANNOUNCEd; otherwise resolves once the new bring-up has been kicked
+	* off (it does not await the next RUNNING transition — listen via
+	* {@link onChange} instead).
+	*/
+	async reprovision(nodeId) {
+		const rec = this.#slaves.get(nodeId);
+		if (!rec) return false;
+		try {
+			await rec.agent.reprovision();
+			return true;
+		} catch (e) {
+			this.#error(e);
+			return false;
+		}
+	}
+	#onFrame(f) {
+		if (!f.extended) return;
+		if (extChannel(f.id) !== 0) return;
+		const nodeId = extNodeId(f.id);
+		if (nodeId === 0 || nodeId === 127) return;
+		const cmd = extIndex(f.id);
+		if (cmd === 2) {
+			const rec = this.#ensureSlave(nodeId);
+			if (f.data.length >= 14) {
+				rec.schemaHash = readU64Le(f.data, 0);
+				rec.bootId = f.data[9] ?? rec.bootId ?? null;
+			}
+			this.#emit();
+			return;
+		}
+		if (cmd === 5) {
+			const rec = this.#ensureSlave(nodeId);
+			rec.lastHeartbeatMs = this.#now();
+			if (f.data.length >= 1) rec.bootId = f.data[0] ?? rec.bootId ?? null;
+			this.#emit();
+		}
+	}
+	#ensureSlave(nodeId) {
+		let rec = this.#slaves.get(nodeId);
+		if (rec) return rec;
+		const agent = new NodeAgent({
+			nodeId,
+			transport: this.#transport,
+			framePlan: this.#framePlan,
+			ackTimeoutMs: this.#ackTimeoutMs,
+			heartbeatTimeoutMs: this.#heartbeatTimeoutMs,
+			...this.#serviceTimeoutMs !== void 0 ? { serviceTimeoutMs: this.#serviceTimeoutMs } : {},
+			autoStart: this.#autoStart,
+			now: this.#now,
+			onState: (s) => {
+				const r = this.#slaves.get(nodeId);
+				if (!r) return;
+				r.state = s;
+				if (s.kind === "running" && r.agent.snapshot !== null) try {
+					this.#dataPlane.attachSlave(nodeId, r.agent.snapshot.framePlan, r.agent.snapshot.index);
+				} catch (e) {
+					this.#error(e);
+				}
+				else this.#dataPlane.detachSlave(nodeId);
+				this.#emit();
+			},
+			onError: (e) => this.#error(e)
+		});
+		rec = {
+			agent,
+			state: { kind: "idle" },
+			lastHeartbeatMs: null,
+			bootId: null,
+			schemaHash: null
+		};
+		this.#slaves.set(nodeId, rec);
+		agent.start();
+		this.#emit();
+		return rec;
+	}
+	#emit() {
+		const snap = this.snapshots();
+		for (const cb of this.#listeners) try {
+			cb(snap);
+		} catch (e) {
+			this.#error(e);
+		}
+	}
+	#error(e) {
+		if (!this.#onError) return;
+		this.#onError(e instanceof Error ? e : new Error(String(e)));
+	}
+};
+//#endregion
+export { AckTracker, CHAN_CONFIG, CHAN_SVC_REQUEST, CHAN_SVC_RESPONSE, CMD_ACK, CMD_ANNOUNCE, CMD_DISCOVER, CMD_FRAME_DEFINE, CMD_HB_PERIOD, CMD_HEARTBEAT, CMD_MASTER_HEARTBEAT, CMD_NAK, CMD_SCHEMA_DATA, CMD_SCHEMA_READ, CMD_START, CMD_STOP, DIR_RX_M2S, DIR_TX_S2M, DataPlaneReceiver, Direction, DynamicCodecError, FAULT_ID_CONFLICT, FAULT_INDEX_OVERFLOW, FAULT_NOMEM, FAULT_NONE, FD_DLC_STEPS, MAX_FRAME_PAYLOAD, MasterController, MasterHeartbeatBroadcaster, NAK_BAD_LENGTH, NAK_BAD_PARAM, NAK_BAD_STATE, NAK_DIR_MISMATCH, NAK_ID_CONFLICT, NAK_INDEX_RANGE, NAK_NO_RESOURCE, NAK_SIZE_OVERFLOW, NAK_UNKNOWN_CMD, NODE_ID_BROADCAST, NoCallSlotError, NodeAgent, NumberingError, PROTOCOL_VERSION, ParamCodecError, ProtoError, ProtoReader, SCALAR_NAMES, SEG_FIRST_DATA, SEG_MAX_SEQ, SEG_MAX_TOTAL, SEG_REST_DATA, SERVICE_INDEX_CANCEL, SERVICE_INDEX_CAPACITY, SERVICE_INDEX_MAX, SERVICE_INDEX_PARAM_SET, STATE_FAULT, STATE_PROVISIONED, STATE_RUNNING, STATE_UNPROVISIONED, STD_ID_MASK, SVC_ACCEPTED, SVC_APP_ERROR, SVC_BAD_INDEX, SVC_BAD_LENGTH, SVC_BAD_VALUE, SVC_BUSY, SVC_CANCEL, SVC_MAX_FIRST_CLASS, SVC_OK, SVC_PARAM_SET, SVC_UNAVAIL, ScalarType, SchemaAccumulator, SchemaIndex, SegmentReassembler, SeqAllocator, ServiceCallError, ServiceCancelledError, ServiceClient, ServiceTimeoutError, ServiceUnavailableError, StdIdAllocator, TypedParam, TypedService, buildDefaultS2MRequests, computeNumbering, decodeAnnounce, decodeFields, decodeHeartbeat, decodeNak, decodeSchema, decodeSchemaData, defaultS2MFramePlan, encodeDiscover, encodeDiscoverTo, encodeFields, encodeFrameDefine, encodeMasterHeartbeat, encodeParamSetSingle, encodeSchemaRead, encodeStart, encodeStop, extChannel, extIndex, extNodeId, extSeg, extSeq, fieldWireSize, fieldsWireSize, makeExtId, makeSvcRequestFrames, makeSvcSegmentedFrames, packScalarF32Le, packScalarF64Le, packScalarIntLe, padToDlc, planFrames, quantizeDlc, scalarFromName, scalarName, scalarSize, schemaHashPrefix, segExpectedMask, segOffset, sha256, signExtend, unpackScalarF32Le, unpackScalarF64Le, unpackScalarIntLe };
+
+//# sourceMappingURL=index.js.map