@zerodds/wire 0.0.0-stage → 1.0.0-rc.7

package/README.md

@@ -1,3 +1,14 @@
-# Temporary Holding Version
+# @zerodds/wire
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The canonical TypeScript XCDR and descriptor runtime imported by generated
+ZeroDDS modules. Consumers declare `@zerodds/wire` at the same version as
+their compiler, currently `1.0.0-rc.7`. It is independent of the optional
+`@zerodds/node` native DDS binding.
+
+`npm pack` builds and packages JavaScript and declaration files from `src`
+into `dist`. Install the resulting tarball in a separate consumer project
+to verify package resolution. No repository path mapping is required.
+
+The package manifest prepares publication but does not assert registry
+availability. Package ownership and Trusted Publishing for `@zerodds/wire`
+must be established before a separately authorized upload.

package/dist/branded.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The IDL types TypeScript has no structural form for.
+ *
+ * DDS-TS 1.0 §7.3.2, §7.3.3, §8.5 and §8.6. Three of them:
+ * a `char` holding exactly one ISO 8859-1 character, a `wchar` holding
+ * exactly one Unicode scalar, and a `long double` holding sixteen octets
+ * of binary128.
+ *
+ * # Why the brands are string literals
+ *
+ * A brand made from a module-local `unique symbol` is nominal across
+ * module boundaries: a `Char` produced by one vendor's runtime would not
+ * satisfy another vendor's `Char` parameter even though both hold the
+ * same character. The tags below — `"char"`, `"wchar"`, `"long_double"`
+ * — and the property name `__dds_brand` are normative for exactly that
+ * reason, and two conformant runtimes produce assignment-compatible
+ * types without importing each other.
+ *
+ * The brand is a compile-time marker with no run-time effect: a `Char`
+ * *is* a string at run time. What the factories below add is the check
+ * the type cannot make.
+ */
+/**
+ * An IDL `char`: one ISO 8859-1 character.
+ *
+ * DDS-TS 1.0 §7.3.2. Construct with {@link makeChar}.
+ */
+export type Char = string & {
+    readonly __dds_brand: "char";
+};
+/**
+ * An IDL `wchar`: one Unicode scalar.
+ *
+ * DDS-TS 1.0 §7.3.2. Construct with {@link makeWChar}.
+ */
+export type WChar = string & {
+    readonly __dds_brand: "wchar";
+};
+/**
+ * One ISO 8859-1 character, or a `RangeError`.
+ *
+ * OMG IDL 4.2 §7.2.6.2 makes `char` an 8-bit quantity holding a single
+ * ISO 8859-1 character, so the value space is `U+0000`..`U+00FF` and
+ * nothing above it. A string of length one whose code point is
+ * `U+20AC` (the euro sign) is a perfectly good JavaScript string and is
+ * not a `char`: it needs three octets in UTF-8 and there is no octet
+ * that means it.
+ *
+ * The length check is on UTF-16 code units, which for this range is the
+ * same as on code points — every scalar at or below `U+00FF` is one code
+ * unit. {@link makeWChar} cannot use the same check, and that difference
+ * is the whole reason these are two functions.
+ */
+export declare function makeChar(s: string): Char;
+/**
+ * One Unicode scalar, or a `RangeError`.
+ *
+ * OMG IDL 4.2 §7.2.6.2 makes `wchar` a full Unicode scalar:
+ * `U+0000`..`U+10FFFF` less the surrogate range
+ * `U+D800`..`U+DFFF`, which is not a scalar value but half of one.
+ *
+ * A JavaScript string is a sequence of UTF-16 **code units**, so every
+ * scalar above the BMP is two of them: `"\u{1F600}".length` is 2. A
+ * length check on `s.length === 1` would therefore reject every
+ * astral-plane character, which is why this counts code points — the
+ * string iterator yields those — and not units. DDS-TS 1.0 §7.3.2 states
+ * that as a MUST NOT.
+ */
+export declare function makeWChar(s: string): WChar;
+/**
+ * An IDL `long double`, as the sixteen octets it is.
+ *
+ * DDS-TS 1.0 §7.3.3 and §8.6. A TypeScript `number` is an IEEE 754
+ * binary64 (ECMA-262 §6.1.6.1) and drops sixty bits of a binary128's
+ * significand, so a `number`-typed member would have lost the value
+ * before any octet was written. The octets are the one form that carries
+ * it without deciding what it means.
+ *
+ * The byte order *within* `bytes` is implementation-defined; what
+ * crosses a DDS boundary is governed by OMG X-Types 1.3 §7.4.3 and is
+ * decided by the codec, not here. `runtime/typescript/src/float128.ts`
+ * holds the conversion from a decimal string to those sixteen octets,
+ * least-significant first.
+ */
+export interface LongDouble {
+    readonly __dds_brand: "long_double";
+    /** Sixteen octets. Any other length is a `RangeError`. */
+    readonly bytes: Uint8Array;
+}
+/**
+ * Sixteen octets as a {@link LongDouble}, or a `RangeError`.
+ *
+ * The length is the whole check: a binary128 has no invalid bit pattern
+ * — every one of the 2^128 is a number, an infinity or a NaN — so a
+ * factory that inspected the exponent would refuse values IEEE 754
+ * defines.
+ */
+export declare function makeLongDouble(bytes: Uint8Array): LongDouble;

package/dist/branded.js

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * One ISO 8859-1 character, or a `RangeError`.
+ *
+ * OMG IDL 4.2 §7.2.6.2 makes `char` an 8-bit quantity holding a single
+ * ISO 8859-1 character, so the value space is `U+0000`..`U+00FF` and
+ * nothing above it. A string of length one whose code point is
+ * `U+20AC` (the euro sign) is a perfectly good JavaScript string and is
+ * not a `char`: it needs three octets in UTF-8 and there is no octet
+ * that means it.
+ *
+ * The length check is on UTF-16 code units, which for this range is the
+ * same as on code points — every scalar at or below `U+00FF` is one code
+ * unit. {@link makeWChar} cannot use the same check, and that difference
+ * is the whole reason these are two functions.
+ */
+export function makeChar(s) {
+    const first = s.codePointAt(0);
+    if (s.length !== 1 || first === undefined || first > 0xff) {
+        throw new RangeError("Char requires single ISO 8859-1 code point");
+    }
+    return s;
+}
+/**
+ * One Unicode scalar, or a `RangeError`.
+ *
+ * OMG IDL 4.2 §7.2.6.2 makes `wchar` a full Unicode scalar:
+ * `U+0000`..`U+10FFFF` less the surrogate range
+ * `U+D800`..`U+DFFF`, which is not a scalar value but half of one.
+ *
+ * A JavaScript string is a sequence of UTF-16 **code units**, so every
+ * scalar above the BMP is two of them: `"\u{1F600}".length` is 2. A
+ * length check on `s.length === 1` would therefore reject every
+ * astral-plane character, which is why this counts code points — the
+ * string iterator yields those — and not units. DDS-TS 1.0 §7.3.2 states
+ * that as a MUST NOT.
+ */
+export function makeWChar(s) {
+    // The iterator yields code points, so a surrogate pair counts once.
+    const points = [...s];
+    if (points.length !== 1) {
+        throw new RangeError("WChar requires exactly one Unicode scalar");
+    }
+    const point = s.codePointAt(0);
+    if (point === undefined || (point >= 0xd800 && point <= 0xdfff)) {
+        throw new RangeError("WChar must not be an unpaired surrogate");
+    }
+    return s;
+}
+/**
+ * Sixteen octets as a {@link LongDouble}, or a `RangeError`.
+ *
+ * The length is the whole check: a binary128 has no invalid bit pattern
+ * — every one of the 2^128 is a number, an infinity or a NaN — so a
+ * factory that inspected the exponent would refuse values IEEE 754
+ * defines.
+ */
+export function makeLongDouble(bytes) {
+    if (bytes.length !== 16) {
+        throw new RangeError("LongDouble requires 16 bytes");
+    }
+    return { __dds_brand: "long_double", bytes };
+}

package/dist/dds_any.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The boxed IDL `any`, and the two functions that open and close it.
+ *
+ * DDS-TS 1.0 §7.3.4 and §8.4. An IDL `any` carries a value together with
+ * an explicit run-time type identity (OMG IDL 4.2 §7.4.14). TypeScript
+ * `interface` declarations have none — they are erased — so an unwrapped
+ * payload gives a consumer nothing to discover the type from. The
+ * mapping therefore boxes: `{ typeId, value }`, where `typeId` is the
+ * qualified IDL name and indexes the registry.
+ *
+ * Mapping `any` to TypeScript `any` or `unknown` is forbidden by the
+ * spec, and the reason is the same one: `unknown` says the type is not
+ * known, where the IDL construct says the type is carried.
+ *
+ * Both functions check the descriptor's type guard, and that check is
+ * what makes the box worth having. A producer that boxed the wrong value
+ * and a consumer that read a box it did not expect fail here, naming the
+ * two type ids, rather than at whatever line first reads a property that
+ * is not there.
+ */
+import type { DdsAny, DdsTypeDescriptor } from "./types.js";
+/**
+ * Box a value with the identity of its type.
+ *
+ * DDS-TS 1.0 §8.7 (`boxAny`). The guard is checked first: a box whose
+ * `typeId` does not describe its `value` is worse than no box, because
+ * every consumer downstream trusts it.
+ *
+ * @throws TypeError when `descriptor.typeGuard(value)` is false.
+ */
+export declare function boxAny<T>(descriptor: DdsTypeDescriptor<T>, value: T): DdsAny;
+/**
+ * Narrow a box to the type a descriptor describes.
+ *
+ * DDS-TS 1.0 §8.7 (`unboxAny`). Two conditions, both required: the
+ * box's `typeId` is the descriptor's name, and the descriptor's guard
+ * accepts the payload. The second is not redundant — a box built by hand
+ * or arriving from another process carries whatever `typeId` its
+ * producer wrote.
+ *
+ * The spec spells the first parameter `any`; it is named `boxed` here
+ * because the identifier `any` beside a type annotation reads as the
+ * TypeScript keyword. The shape is unchanged.
+ *
+ * @throws TypeError when either condition fails, naming which.
+ */
+export declare function unboxAny<T>(boxed: DdsAny, descriptor: DdsTypeDescriptor<T>): T;

package/dist/dds_any.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * Box a value with the identity of its type.
+ *
+ * DDS-TS 1.0 §8.7 (`boxAny`). The guard is checked first: a box whose
+ * `typeId` does not describe its `value` is worse than no box, because
+ * every consumer downstream trusts it.
+ *
+ * @throws TypeError when `descriptor.typeGuard(value)` is false.
+ */
+export function boxAny(descriptor, value) {
+    if (!descriptor.typeGuard(value)) {
+        throw new TypeError(`boxAny: the value is not a \`${descriptor.name}\``);
+    }
+    return { typeId: descriptor.name, value };
+}
+/**
+ * Narrow a box to the type a descriptor describes.
+ *
+ * DDS-TS 1.0 §8.7 (`unboxAny`). Two conditions, both required: the
+ * box's `typeId` is the descriptor's name, and the descriptor's guard
+ * accepts the payload. The second is not redundant — a box built by hand
+ * or arriving from another process carries whatever `typeId` its
+ * producer wrote.
+ *
+ * The spec spells the first parameter `any`; it is named `boxed` here
+ * because the identifier `any` beside a type annotation reads as the
+ * TypeScript keyword. The shape is unchanged.
+ *
+ * @throws TypeError when either condition fails, naming which.
+ */
+export function unboxAny(boxed, descriptor) {
+    if (boxed.typeId !== descriptor.name) {
+        throw new TypeError(`unboxAny: the box holds a \`${boxed.typeId}\`, not a \`${descriptor.name}\``);
+    }
+    if (!descriptor.typeGuard(boxed.value)) {
+        throw new TypeError(`unboxAny: the box says \`${descriptor.name}\` and the value is not one`);
+    }
+    return boxed.value;
+}

package/dist/endianness.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Byte order.
+ *
+ * The counterpart of `crates/wire/src/endianness.rs` and of
+ * `runtime/python/zerodds_wire/endianness.py`. A module of its own
+ * because the writer and the reader both need it and neither should
+ * own it.
+ */
+/** Which end of a multi-byte value goes out first. */
+export declare enum Endianness {
+    Little = "le",
+    Big = "be"
+}
+/** Whether the low octet goes out first. */
+export declare function isLittle(order: Endianness): boolean;
+/**
+ * The command line's spelling, or `undefined` for anything else.
+ *
+ * `undefined` and not a default: a typo in a wire-affecting flag has to
+ * be loud, because the octets it produces look plausible.
+ */
+export declare function parseEndianness(name: string): Endianness | undefined;

package/dist/endianness.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * Byte order.
+ *
+ * The counterpart of `crates/wire/src/endianness.rs` and of
+ * `runtime/python/zerodds_wire/endianness.py`. A module of its own
+ * because the writer and the reader both need it and neither should
+ * own it.
+ */
+/** Which end of a multi-byte value goes out first. */
+export var Endianness;
+(function (Endianness) {
+    Endianness["Little"] = "le";
+    Endianness["Big"] = "be";
+})(Endianness || (Endianness = {}));
+/** Whether the low octet goes out first. */
+export function isLittle(order) {
+    return order === Endianness.Little;
+}
+/**
+ * The command line's spelling, or `undefined` for anything else.
+ *
+ * `undefined` and not a default: a typo in a wire-affecting flag has to
+ * be loud, because the octets it produces look plausible.
+ */
+export function parseEndianness(name) {
+    if (name === "le" || name === "little") {
+        return Endianness.Little;
+    }
+    if (name === "be" || name === "big") {
+        return Endianness.Big;
+    }
+    return undefined;
+}

package/dist/equal.d.ts

@@ -0,0 +1,46 @@
+import type { DdsTypeDescriptor, DdsTypeRef } from "./types.js";
+/**
+ * Whether two key values described by `keyType` are the same key.
+ *
+ * DDS-TS 1.0 §8.7 (`equalKey`). The rules, in the order they apply:
+ *
+ * - Primitives, strings, `bigint`s and branded characters compare by
+ *   **value**, with two departures from `===` that are both normative.
+ *   `NaN` equals itself, because a key that never matches itself would
+ *   make every sample its own instance; and `+0` equals `-0`, because
+ *   `Object.is` separates them and nothing on the wire does.
+ * - A `ref` resolves through `lookupType` and compares member by
+ *   member. This is the case that overrides JavaScript's default: two
+ *   distinct objects holding the same members are one key.
+ * - An `any` compares its `typeId` and then its payload through the
+ *   descriptor that `typeId` names.
+ * - A map, a sequence and an array are **not** IDL key types
+ *   (X-Types 1.3 §7.2.2.4.5); reaching one is a malformed descriptor
+ *   and throws rather than answering.
+ *
+ * Floating-point keys are allowed here and are a poor idea in a topic
+ * design: two writers that computed the same value by different routes
+ * can differ in the last place, and then they are two instances.
+ *
+ * @throws TypeError for a key type IDL does not permit, for a `ref` the
+ * registry does not answer for, and for a value graph deeper than
+ * {@link MAX_DEPTH}.
+ *
+ * zerodds-lint: recursion-depth 64 (key nesting; bounded by `MAX_DEPTH`)
+ */
+export declare function equalKey(a: unknown, b: unknown, keyType: DdsTypeRef): boolean;
+/**
+ * Whether two descriptors describe the same type.
+ *
+ * DDS-TS 1.0 §8.7 (`registerType`). Deep value equality over every
+ * field, with `typeGuard` compared by reference identity — a function is
+ * not deep-equals comparable, and two closures that behave identically
+ * are still two closures.
+ *
+ * What this is for: a module imported twice in one bundle runs its
+ * `registerType` call twice with the same descriptor object, and that
+ * has to be silent. Two different IDL types compiled to one qualified
+ * name is the case that must not be, and it is the one this separates
+ * out.
+ */
+export declare function descriptorsEqual(a: DdsTypeDescriptor, b: DdsTypeDescriptor): boolean;

package/dist/equal.js

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * Equality, twice: over a key value and over a descriptor.
+ *
+ * DDS-TS 1.0 §8.7. Two different questions that JavaScript answers the
+ * same wrong way.
+ *
+ * `a === b` on two objects is reference equality, so two samples with
+ * identical key members compare unequal and a DDS instance would split
+ * in two. {@link equalKey} walks the key's {@link DdsTypeRef} instead
+ * and compares the values the type describes.
+ *
+ * {@link descriptorsEqual} answers the other one: whether a second
+ * `registerType` call carries the same type as the first. The registry
+ * needs it to tell a harmless double-import from two different types
+ * sharing a name, and the second has to throw.
+ */
+import { lookupType } from "./registry.js";
+/**
+ * How deep a value graph is walked before it is taken to be malformed.
+ *
+ * A descriptor graph has no cycles — `DdsTypeRef.kind === "ref"` carries
+ * a name and not a reference, which is what §8.2 says it is for — so a
+ * chain longer than this is a value that was built by hand and is
+ * pointing at itself. Recursing into one would end the process rather
+ * than report anything.
+ */
+const MAX_DEPTH = 64;
+/** The synthetic member id a union's discriminator carries (§7.5.1). */
+const DISCRIMINATOR_ID = 0xffffffff;
+/**
+ * Whether two key values described by `keyType` are the same key.
+ *
+ * DDS-TS 1.0 §8.7 (`equalKey`). The rules, in the order they apply:
+ *
+ * - Primitives, strings, `bigint`s and branded characters compare by
+ *   **value**, with two departures from `===` that are both normative.
+ *   `NaN` equals itself, because a key that never matches itself would
+ *   make every sample its own instance; and `+0` equals `-0`, because
+ *   `Object.is` separates them and nothing on the wire does.
+ * - A `ref` resolves through `lookupType` and compares member by
+ *   member. This is the case that overrides JavaScript's default: two
+ *   distinct objects holding the same members are one key.
+ * - An `any` compares its `typeId` and then its payload through the
+ *   descriptor that `typeId` names.
+ * - A map, a sequence and an array are **not** IDL key types
+ *   (X-Types 1.3 §7.2.2.4.5); reaching one is a malformed descriptor
+ *   and throws rather than answering.
+ *
+ * Floating-point keys are allowed here and are a poor idea in a topic
+ * design: two writers that computed the same value by different routes
+ * can differ in the last place, and then they are two instances.
+ *
+ * @throws TypeError for a key type IDL does not permit, for a `ref` the
+ * registry does not answer for, and for a value graph deeper than
+ * {@link MAX_DEPTH}.
+ *
+ * zerodds-lint: recursion-depth 64 (key nesting; bounded by `MAX_DEPTH`)
+ */
+export function equalKey(a, b, keyType) {
+    return equalKeyAt(a, b, keyType, 0);
+}
+/** {@link equalKey}, carrying the depth it has reached. */
+function equalKeyAt(a, b, keyType, depth) {
+    if (depth > MAX_DEPTH) {
+        throw new TypeError(`equalKey: the key nests past ${MAX_DEPTH}`);
+    }
+    switch (keyType.kind) {
+        case "primitive":
+        case "bitfield":
+        case "string":
+            return sameValue(a, b);
+        case "ref":
+            return equalRef(a, b, keyType.name, depth);
+        case "any":
+            return equalBoxed(a, b, depth);
+        case "sequence":
+        case "array":
+        case "map":
+            throw new TypeError(`equalKey: a \`${keyType.kind}\` is not an IDL key type`);
+    }
+}
+/**
+ * Value equality with the two departures §8.7 requires.
+ *
+ * `===` for everything, then `NaN` against itself. `+0 === -0` is
+ * already true, so the second departure needs no code — it needs
+ * `Object.is` **not** to be used, which is what this comment records.
+ */
+function sameValue(a, b) {
+    if (a === b) {
+        return true;
+    }
+    return (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b));
+}
+/**
+ * Two values of a named type, compared through its descriptor.
+ *
+ * The descriptor's `kind` decides how, because the TypeScript surface of
+ * a named IDL type is not always an object: an enumeration is a string
+ * literal, an alias is whatever it aliases, and only a struct, an
+ * exception, a bitset or a union is a property bag.
+ */
+function equalRef(a, b, name, depth) {
+    const descriptor = lookupType(name);
+    if (descriptor === undefined) {
+        throw new TypeError(`equalKey: no descriptor is registered for \`${name}\``);
+    }
+    switch (descriptor.kind) {
+        // A string-literal union or a number at the TypeScript surface.
+        case "enum":
+        case "bitmask":
+            return sameValue(a, b);
+        // One member named `value`, carrying the aliased type.
+        case "alias": {
+            const aliased = descriptor.fields[0];
+            if (aliased === undefined) {
+                throw new TypeError(`equalKey: the alias \`${name}\` describes no type`);
+            }
+            return equalKeyAt(a, b, aliased.type, depth + 1);
+        }
+        case "union":
+            return equalUnion(a, b, descriptor, depth);
+        case "struct":
+        case "exception":
+        case "bitset":
+            return equalMembers(a, b, descriptor.fields, depth);
+        // An interface has no data form, so no value of one can be a key.
+        case "interface":
+            throw new TypeError(`equalKey: \`${name}\` is an interface and has no value`);
+    }
+}
+/**
+ * Two property bags, compared over the members a descriptor lists.
+ *
+ * A member absent from both is equal — that is what `@optional` means —
+ * and a member absent from one only is not. Comparing with `in` rather
+ * than against `undefined` keeps those two apart: a member explicitly
+ * set to `undefined` is present, and a `@optional` member that is not
+ * set is not.
+ */
+function equalMembers(a, b, members, depth) {
+    if (!isRecord(a) || !isRecord(b)) {
+        return false;
+    }
+    for (const member of members) {
+        const inA = member.name in a;
+        const inB = member.name in b;
+        if (inA !== inB) {
+            return false;
+        }
+        if (!inA) {
+            continue;
+        }
+        if (!equalKeyAt(a[member.name], b[member.name], member.type, depth + 1)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Two union values: the discriminator first, then the selected case.
+ *
+ * The discriminator's **property name** comes out of the descriptor
+ * rather than being written in here. It is the member carrying the
+ * synthetic id `0xFFFFFFFF` (§7.5.1), and reading it from the side-table
+ * is what keeps this function agreeing with whatever the generator
+ * spelled it.
+ */
+function equalUnion(a, b, descriptor, depth) {
+    const discriminator = descriptor.fields.find((field) => field.id === DISCRIMINATOR_ID);
+    if (discriminator === undefined) {
+        throw new TypeError(`equalKey: the union \`${descriptor.name}\` has no discriminator member`);
+    }
+    if (!isRecord(a) || !isRecord(b)) {
+        return false;
+    }
+    if (!sameValue(a[discriminator.name], b[discriminator.name])) {
+        return false;
+    }
+    // Whichever case the discriminator selected is the one present; the
+    // others are absent in both and `equalMembers` passes over them.
+    const cases = descriptor.fields.filter((field) => field.id !== DISCRIMINATOR_ID);
+    return equalMembers(a, b, cases, depth);
+}
+/**
+ * Two boxed `any` values: the identity first, then the payload.
+ *
+ * The payload is compared through the descriptor `typeId` names, which
+ * is the whole reason the box carries one.
+ */
+function equalBoxed(a, b, depth) {
+    if (!isRecord(a) || !isRecord(b)) {
+        return false;
+    }
+    const typeId = a["typeId"];
+    if (typeof typeId !== "string" || typeId !== b["typeId"]) {
+        return false;
+    }
+    return equalRef(a["value"], b["value"], typeId, depth + 1);
+}
+/** Whether a value can be indexed by a member name. */
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Whether two descriptors describe the same type.
+ *
+ * DDS-TS 1.0 §8.7 (`registerType`). Deep value equality over every
+ * field, with `typeGuard` compared by reference identity — a function is
+ * not deep-equals comparable, and two closures that behave identically
+ * are still two closures.
+ *
+ * What this is for: a module imported twice in one bundle runs its
+ * `registerType` call twice with the same descriptor object, and that
+ * has to be silent. Two different IDL types compiled to one qualified
+ * name is the case that must not be, and it is the one this separates
+ * out.
+ */
+export function descriptorsEqual(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.typeGuard !== b.typeGuard) {
+        return false;
+    }
+    return deepEqual(withoutGuard(a), withoutGuard(b), 0);
+}
+/** A descriptor's data, without the one member that is not data. */
+function withoutGuard(descriptor) {
+    const { typeGuard: _guard, ...data } = descriptor;
+    return data;
+}
+/**
+ * Deep value equality over the JSON-shaped half of a descriptor.
+ *
+ * Arrays, plain objects, and the primitives — plus `Uint8Array`, which a
+ * `@default` on a `long double` member carries and which is an object
+ * whose `===` is reference equality.
+ *
+ * A property present with the value `undefined` and a property that is
+ * absent compare equal here: `exactOptionalPropertyTypes` keeps the two
+ * apart in the type system, and a generator that wrote `topic: undefined`
+ * where another omitted `topic` did not emit a different type.
+ *
+ * zerodds-lint: recursion-depth 64 (descriptor nesting; bounded by `MAX_DEPTH`)
+ */
+function deepEqual(a, b, depth) {
+    if (depth > MAX_DEPTH) {
+        throw new TypeError(`registerType: the descriptor nests past ${MAX_DEPTH}`);
+    }
+    if (sameValue(a, b)) {
+        return true;
+    }
+    if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        return a.length === b.length && a.every((octet, at) => octet === b[at]);
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return (a.length === b.length &&
+            a.every((element, at) => deepEqual(element, b[at], depth + 1)));
+    }
+    if (isRecord(a) && isRecord(b) && !Array.isArray(a) && !Array.isArray(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        for (const key of keys) {
+            if (!deepEqual(a[key], b[key], depth + 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}