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

package/dist/error.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What can go wrong on the wire.
+ *
+ * The variants of `crates/wire/src/error.rs`, as errors. Every one
+ * names what was expected and where: a reader that returned a zero for
+ * a truncated stream would hand the caller a value that was never
+ * sent, and a writer that clamped an over-wide integer would put a
+ * different number on the wire than the caller asked for.
+ */
+/** Base of every wire failure. */
+export declare class WireError extends Error {
+    constructor(message: string);
+}
+/** The stream ended before the value did. */
+export declare class Truncated extends WireError {
+    readonly at: number;
+    readonly needed: number;
+    readonly available: number;
+    constructor(at: number, needed: number, available: number);
+}
+/**
+ * A length field claims more than the stream holds.
+ *
+ * Separate from {@link Truncated}: a length that cannot be true is a
+ * malformed stream, not a short one, and allocating for it is how a
+ * reader turns a bad message into an out-of-memory.
+ */
+export declare class ImpossibleLength extends WireError {
+    readonly at: number;
+    readonly claimed: number;
+    readonly available: number;
+    constructor(at: number, claimed: number, available: number);
+}
+/** A string held octets that are not UTF-8. */
+export declare class NotUtf8 extends WireError {
+    readonly at: number;
+    constructor(at: number);
+}
+/**
+ * A value outside what its type admits.
+ *
+ * Thrown by the writer as well as the reader, which is where
+ * TypeScript is like Python and unlike Rust: an integer there is `i32`
+ * or `u64` and the compiler has already refused the value, while a
+ * `number` here holds anything a binary64 holds and a `bigint` is
+ * unbounded, so the check has to happen at the point of the write.
+ */
+export declare class OutOfRange extends WireError {
+    readonly at: number;
+    readonly expected: string;
+    constructor(at: number, expected: string);
+}

package/dist/error.js

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * What can go wrong on the wire.
+ *
+ * The variants of `crates/wire/src/error.rs`, as errors. Every one
+ * names what was expected and where: a reader that returned a zero for
+ * a truncated stream would hand the caller a value that was never
+ * sent, and a writer that clamped an over-wide integer would put a
+ * different number on the wire than the caller asked for.
+ */
+/** Base of every wire failure. */
+export class WireError extends Error {
+    constructor(message) {
+        super(message);
+        // `Error` is not a normal base in older targets and the prototype
+        // is otherwise lost, which makes `instanceof` answer false for a
+        // subclass. Set explicitly rather than left to the target.
+        this.name = new.target.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/** The stream ended before the value did. */
+export class Truncated extends WireError {
+    at;
+    needed;
+    available;
+    constructor(at, needed, available) {
+        super(`at ${at}: ${needed} bytes needed, ${available} available`);
+        this.at = at;
+        this.needed = needed;
+        this.available = available;
+    }
+}
+/**
+ * A length field claims more than the stream holds.
+ *
+ * Separate from {@link Truncated}: a length that cannot be true is a
+ * malformed stream, not a short one, and allocating for it is how a
+ * reader turns a bad message into an out-of-memory.
+ */
+export class ImpossibleLength extends WireError {
+    at;
+    claimed;
+    available;
+    constructor(at, claimed, available) {
+        super(`at ${at}: a length of ${claimed} with ${available} bytes left`);
+        this.at = at;
+        this.claimed = claimed;
+        this.available = available;
+    }
+}
+/** A string held octets that are not UTF-8. */
+export class NotUtf8 extends WireError {
+    at;
+    constructor(at) {
+        super(`at ${at}: the string is not UTF-8`);
+        this.at = at;
+    }
+}
+/**
+ * A value outside what its type admits.
+ *
+ * Thrown by the writer as well as the reader, which is where
+ * TypeScript is like Python and unlike Rust: an integer there is `i32`
+ * or `u64` and the compiler has already refused the value, while a
+ * `number` here holds anything a binary64 holds and a `bigint` is
+ * unbounded, so the check has to happen at the point of the write.
+ */
+export class OutOfRange extends WireError {
+    at;
+    expected;
+    constructor(at, expected) {
+        super(`at ${at}: expected ${expected}`);
+        this.at = at;
+        this.expected = expected;
+    }
+}

package/dist/float128.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The sixteen octets a decimal string is, least-significant first.
+ *
+ * Least-significant first because that is the order a little-endian
+ * stream carries them and the order `Float128` is documented in;
+ * `Writer.writeF128` reverses the whole sixteen for a big-endian stream,
+ * which is CORBA Figure 9.2's rule and not two halves swapped in place.
+ *
+ * Accepts what the corpus writes: an optional sign, digits with an
+ * optional point, an optional `e±nn`, and the three names a decimal
+ * cannot spell — `inf`, `-inf`, `nan`. A negative zero keeps its sign,
+ * which is the one thing a value's magnitude cannot carry and is a
+ * different sixteen octets.
+ */
+export declare function float128FromDecimalString(text: string): Uint8Array;

package/dist/float128.js

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * IEEE 754 binary128 — the sixteen octets CDR gives `long double`.
+ *
+ * The TypeScript counterpart of `crates/float128`,
+ * `runtime/c/src/float128.c`, `runtime/cpp`'s and
+ * `runtime/java/.../Float128.java`: a sixth implementation of the same
+ * clauses and not a binding to any of them. CORBA 3.3 part 2 §9.3.1.3
+ * with Figure 9.2 gives the layout — one sign bit, a fifteen-bit
+ * exponent biased by 16383, a 112-bit stored fraction — and DDS-XTypes
+ * 1.3 Table 31 names it: quadruple precision, sixteen octets, aligned to
+ * eight.
+ *
+ * ## Why the decimal is parsed here and not by the generator
+ *
+ * A `number` is a binary64 and drops sixty bits of a binary128's
+ * significand, so a generated file that carried the value as a `number`
+ * would have lost it before any octet was written. The decimal string
+ * from the corpus reaches this file intact and is converted **exactly**:
+ * `BigInt` is arbitrary precision, so `M * 10^D` is a rational this
+ * computes with rather than approximates, and the single rounding is the
+ * one IEEE 754 §4.3.1 requires — to nearest, ties to even.
+ *
+ * A converter in the generator would be the Rust column answering for
+ * this one: the same argument `runtime/cpp/tests/corpus_bytes.cpp`
+ * makes, and the reason five columns each parse the decimal themselves.
+ */
+/** Bits in the stored fraction. IEEE 754-2008 clause 3.6. */
+const FRACTION_BITS = 112n;
+/** What is added to the unbiased exponent to get the stored one. */
+const EXPONENT_BIAS = 16383;
+/** The stored exponent of an infinity or a NaN. */
+const EXPONENT_MAX = 0x7fff;
+/** The unbiased exponent of the smallest normal value. */
+const MIN_NORMAL_EXPONENT = -16382;
+/** `2^112`, the implied leading one in its stored position. */
+const IMPLIED_ONE = 1n << FRACTION_BITS;
+/**
+ * The sixteen octets a decimal string is, least-significant first.
+ *
+ * Least-significant first because that is the order a little-endian
+ * stream carries them and the order `Float128` is documented in;
+ * `Writer.writeF128` reverses the whole sixteen for a big-endian stream,
+ * which is CORBA Figure 9.2's rule and not two halves swapped in place.
+ *
+ * Accepts what the corpus writes: an optional sign, digits with an
+ * optional point, an optional `e±nn`, and the three names a decimal
+ * cannot spell — `inf`, `-inf`, `nan`. A negative zero keeps its sign,
+ * which is the one thing a value's magnitude cannot carry and is a
+ * different sixteen octets.
+ */
+export function float128FromDecimalString(text) {
+    const trimmed = text.trim();
+    const lowered = trimmed.toLowerCase();
+    if (lowered === "inf" || lowered === "+inf" || lowered === "infinity") {
+        return octetsOf(false, EXPONENT_MAX, 0n);
+    }
+    if (lowered === "-inf" || lowered === "-infinity") {
+        return octetsOf(true, EXPONENT_MAX, 0n);
+    }
+    if (lowered === "nan" || lowered === "-nan") {
+        // A quiet NaN with no payload: the leading fraction bit set, which
+        // is IEEE 754 §6.2.1's quiet bit.
+        return octetsOf(lowered.startsWith("-"), EXPONENT_MAX, 1n << (FRACTION_BITS - 1n));
+    }
+    const parsed = decimalParts(trimmed);
+    if (parsed === undefined) {
+        throw new RangeError(`a decimal, not \`${text}\``);
+    }
+    const { negative, digits, exponent } = parsed;
+    if (digits === 0n) {
+        return octetsOf(negative, 0, 0n);
+    }
+    // The value as an exact fraction. Nothing is rounded until the
+    // significand is formed, which is what makes the result correctly
+    // rounded rather than rounded twice.
+    let numerator = digits;
+    let denominator = 1n;
+    if (exponent >= 0) {
+        numerator *= 10n ** BigInt(exponent);
+    }
+    else {
+        denominator = 10n ** BigInt(-exponent);
+    }
+    // The unbiased exponent: the largest `e` with `2^e <= value`.
+    let unbiased = bitLength(numerator) - bitLength(denominator);
+    while (!atLeastPowerOfTwo(numerator, denominator, unbiased)) {
+        unbiased -= 1;
+    }
+    while (atLeastPowerOfTwo(numerator, denominator, unbiased + 1)) {
+        unbiased += 1;
+    }
+    // Below the smallest normal the exponent is fixed and the significand
+    // is what loses bits, which is what a subnormal is. Clamping here
+    // rather than branching keeps one rounding for both cases: at the
+    // boundary the rounded significand comes out as exactly `2^112`,
+    // which is the smallest normal and is read back as one below.
+    let scale = Math.max(unbiased, MIN_NORMAL_EXPONENT);
+    let significand = roundedShiftedQuotient(numerator, denominator, 112 - scale);
+    if (significand >= IMPLIED_ONE << 1n) {
+        // Rounding carried past the top bit — `0x1.ffff…f` became `2`. One
+        // more exponent and one more rounding, which cannot carry again.
+        scale += 1;
+        significand = roundedShiftedQuotient(numerator, denominator, 112 - scale);
+    }
+    if (significand < IMPLIED_ONE) {
+        return octetsOf(negative, 0, significand);
+    }
+    const biased = scale + EXPONENT_BIAS;
+    if (biased >= EXPONENT_MAX) {
+        // Past the largest finite value. An infinity and not a saturated
+        // significand: IEEE 754 §7.4 says an overflow rounds to infinity
+        // under round-to-nearest, and the largest finite value would be a
+        // number the caller did not write.
+        return octetsOf(negative, EXPONENT_MAX, 0n);
+    }
+    return octetsOf(negative, biased, significand - IMPLIED_ONE);
+}
+/** The three parts of a decimal, or `undefined` where there are not three. */
+function decimalParts(text) {
+    const match = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+    if (match === null) {
+        return undefined;
+    }
+    const whole = match[2] ?? "";
+    const fraction = match[3] ?? "";
+    if (whole === "" && fraction === "") {
+        return undefined;
+    }
+    const exponent = Number(match[4] ?? "0") - fraction.length;
+    return {
+        negative: match[1] === "-",
+        digits: BigInt(`${whole}${fraction}` === "" ? "0" : `${whole}${fraction}`),
+        exponent,
+    };
+}
+/** Whether `numerator / denominator >= 2^power`. */
+function atLeastPowerOfTwo(numerator, denominator, power) {
+    if (power >= 0) {
+        return numerator >= denominator << BigInt(power);
+    }
+    return numerator << BigInt(-power) >= denominator;
+}
+/**
+ * `round(numerator * 2^shift / denominator)`, to nearest with ties to
+ * even.
+ *
+ * The one rounding in the whole conversion. Doing it on the exact
+ * rational is what makes it correct: rounding the decimal to a `number`
+ * first and then to a binary128 rounds twice, and two roundings differ
+ * from one in the last place often enough that the corpus's
+ * `needs_all_of_them` is exactly the case that catches it.
+ */
+function roundedShiftedQuotient(numerator, denominator, shift) {
+    const top = shift >= 0 ? numerator << BigInt(shift) : numerator;
+    const bottom = shift >= 0 ? denominator : denominator << BigInt(-shift);
+    const quotient = top / bottom;
+    const remainder = top % bottom;
+    const twice = remainder * 2n;
+    if (twice > bottom || (twice === bottom && (quotient & 1n) === 1n)) {
+        return quotient + 1n;
+    }
+    return quotient;
+}
+/** How many bits a positive `BigInt` occupies. */
+function bitLength(value) {
+    return value === 0n ? 0 : value.toString(2).length;
+}
+/** The sixteen octets of one sign, biased exponent and stored fraction. */
+function octetsOf(negative, biasedExponent, fraction) {
+    let bits = fraction | (BigInt(biasedExponent) << FRACTION_BITS);
+    if (negative) {
+        bits |= 1n << 127n;
+    }
+    const octets = new Uint8Array(16);
+    for (let index = 0; index < 16; index += 1) {
+        octets[index] = Number((bits >> BigInt(index * 8)) & 0xffn);
+    }
+    return octets;
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The TypeScript wire runtime, and the descriptor runtime beside it.
+ *
+ * Two halves under one import path. The first is XCDR itself — the
+ * reader, the writer, the policies the dialects differ on — written
+ * from DDS-XTypes 1.3 §7.4. The second is the DDS-TS 1.0 chapter 8
+ * descriptor runtime: the side-table values the generated code
+ * registers, the reflection functions that read them, and the Annex C
+ * WASM bindings.
+ *
+ * The spec names the descriptor package `@zerodds/types` and says the
+ * import path is implementation-defined while the exported names are
+ * not (§8, Runtime Package Name). Every name chapter 8 defines is
+ * exported here, unprefixed and unrenamed; the path is this one.
+ */
+export * from "./endianness.js";
+export * from "./error.js";
+export * from "./float128.js";
+export * from "./policy.js";
+export * from "./reader.js";
+export * from "./writer.js";
+/** The descriptor runtime — DDS-TS 1.0 chapter 8 and Annex C. */
+export * from "./branded.js";
+export * from "./dds_any.js";
+export * from "./equal.js";
+export * from "./registry.js";
+/** The operations runtime — DDS-TS 1.0 chapter 11. */
+export * from "./operations.js";
+export * from "./test_backend.js";
+export * from "./types.js";
+export * from "./wasm.js";

package/dist/index.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * The TypeScript wire runtime, and the descriptor runtime beside it.
+ *
+ * Two halves under one import path. The first is XCDR itself — the
+ * reader, the writer, the policies the dialects differ on — written
+ * from DDS-XTypes 1.3 §7.4. The second is the DDS-TS 1.0 chapter 8
+ * descriptor runtime: the side-table values the generated code
+ * registers, the reflection functions that read them, and the Annex C
+ * WASM bindings.
+ *
+ * The spec names the descriptor package `@zerodds/types` and says the
+ * import path is implementation-defined while the exported names are
+ * not (§8, Runtime Package Name). Every name chapter 8 defines is
+ * exported here, unprefixed and unrenamed; the path is this one.
+ */
+export * from "./endianness.js";
+export * from "./error.js";
+export * from "./float128.js";
+export * from "./policy.js";
+export * from "./reader.js";
+export * from "./writer.js";
+/** The descriptor runtime — DDS-TS 1.0 chapter 8 and Annex C. */
+export * from "./branded.js";
+export * from "./dds_any.js";
+export * from "./equal.js";
+export * from "./registry.js";
+/** The operations runtime — DDS-TS 1.0 chapter 11. */
+export * from "./operations.js";
+export * from "./test_backend.js";
+export * from "./types.js";
+export * from "./wasm.js";

package/dist/operations.d.ts

@@ -0,0 +1,180 @@
+/**
+ * The Operations-Profile descriptor types — DDS-TS 1.0 §11.5.
+ *
+ * Chapter 8's descriptors describe *data*: a struct, a union, an
+ * enumeration. These describe *calls*: what an IDL `interface` declares,
+ * in the same side-table form and referring to the same
+ * {@link DdsTypeRef} graph, so one walk reads both.
+ *
+ * The generator emits one `ServiceDescriptor` constant per IDL
+ * interface, named `<IfaceName>Service`, beside the `<IfaceName>Client`
+ * and `<IfaceName>Handler` interfaces (§11.1). No class is emitted:
+ * "Concrete client construction is the responsibility of the runtime …
+ * which produces objects satisfying the client interface from the
+ * Service Descriptor."
+ *
+ * ## Why the shapes are not classes here either
+ *
+ * Every member is `readonly` and every collection is a
+ * `ReadonlyArray`. A descriptor is a value the generator writes once and
+ * every consumer reads; a mutable one would let a caller edit the
+ * metadata another caller is dispatching against, and nothing would
+ * report it.
+ *
+ * ## Where the exception narrowing lives
+ *
+ * §11.4 sends a caught rejection to `isOneOf`, which chapter 8 §8.7
+ * defines and `registry.ts` exports. It is not re-exported here: two
+ * modules exporting one name through `export *` is a name the barrel
+ * silently drops, and one definition of a type guard is the point of
+ * having it.
+ */
+import type { DdsTypeDescriptor, DdsTypeRef } from "./types.js";
+/**
+ * How a parameter is passed. DDS-TS 1.0 §11.5.
+ *
+ * The three IDL directions of grammar rule (87), spelled as the IDL
+ * spells them. `in` and `inout` reach the method's parameter list;
+ * `out` and `inout` reach the resolved value (§11.2).
+ */
+export type ParameterMode = "in" | "out" | "inout";
+/**
+ * One parameter of one operation. DDS-TS 1.0 §11.5.
+ */
+export interface OperationParameterDescriptor {
+    /** The IDL parameter name, as declared. */
+    readonly name: string;
+    /** `in`, `out` or `inout`. */
+    readonly mode: ParameterMode;
+    /** What the parameter holds. */
+    readonly type: DdsTypeRef;
+}
+/**
+ * One operation of an interface. DDS-TS 1.0 §11.5.
+ *
+ * `returnType` is a {@link DdsTypeRef} or the marker `{ kind: "void" }`.
+ * A marker and not `undefined`: an absent property and a `void` return
+ * are different facts, and under `exactOptionalPropertyTypes` a consumer
+ * would have to know which one an older generator wrote.
+ *
+ * `parameters` holds **every** parameter in declaration order, including
+ * the `out` ones the client method does not take. The descriptor
+ * describes the IDL operation; the method signature is one projection of
+ * it, and a descriptor that carried only the projection could not
+ * reconstruct the reply.
+ */
+export interface OperationDescriptor {
+    /** The IDL operation name, as declared. */
+    readonly name: string;
+    /** Whether the IDL wrote `oneway`. */
+    readonly oneway: boolean;
+    /** The declared return, or the `void` marker. */
+    readonly returnType: DdsTypeRef | {
+        kind: "void";
+    };
+    /** Every parameter, in declaration order. */
+    readonly parameters: ReadonlyArray<OperationParameterDescriptor>;
+    /** The descriptors of the exceptions the `raises` clause names. */
+    readonly raises: ReadonlyArray<DdsTypeDescriptor>;
+}
+/**
+ * One attribute of an interface. DDS-TS 1.0 §11.5.
+ *
+ * The client and handler interfaces carry `get_<name>` and, unless
+ * `readonly`, `set_<name>` (§11.3). `getRaises` and `setRaises` are the
+ * `getraises` and `setraises` clauses of IDL 4.2 grammar rule (89),
+ * which have nowhere else to go: neither reaches a method signature,
+ * because §11.4 rejects the promise rather than declaring a `throws`.
+ */
+export interface AttributeDescriptor {
+    /** The IDL attribute name, as declared. */
+    readonly name: string;
+    /** Whether the IDL wrote `readonly`. */
+    readonly readonly: boolean;
+    /** What the attribute holds. */
+    readonly type: DdsTypeRef;
+    /** The descriptors of the exceptions `getraises` names. */
+    readonly getRaises: ReadonlyArray<DdsTypeDescriptor>;
+    /** The descriptors of the exceptions `setraises` names. */
+    readonly setRaises: ReadonlyArray<DdsTypeDescriptor>;
+}
+/**
+ * One IDL interface, as the metadata a runtime dispatches on.
+ * DDS-TS 1.0 §11.5.
+ *
+ * `TClient` and `THandler` appear in the type and in neither member.
+ * That is §11.5's shape and it is deliberate: the parameters tie a
+ * descriptor constant to the two interfaces the same generator run
+ * emitted, so a runtime factory typed
+ * `(d: ServiceDescriptor<C, H>) => C` hands back the client of *this*
+ * service rather than an `unknown`.
+ *
+ * `inherits` reflects the IDL inheritance specification (grammar rule
+ * (78)) in declaration order and nothing is flattened into the child:
+ * §11.6 says so outright, and the client interface already `extends` the
+ * parents', so a flattened copy would be a second, divergent statement
+ * of the same operation set.
+ */
+export interface ServiceDescriptor<TClient, THandler> {
+    /** The qualified IDL name — `robot::Counter`, not `Counter`. */
+    readonly name: string;
+    /** The parent services, in declaration order. */
+    readonly inherits: ReadonlyArray<ServiceDescriptor<unknown, unknown>>;
+    /** The operations this interface declares itself. */
+    readonly operations: ReadonlyArray<OperationDescriptor>;
+    /** The attributes this interface declares itself. */
+    readonly attributes: ReadonlyArray<AttributeDescriptor>;
+}
+/**
+ * The two type parameters, kept reachable for a consumer that has a
+ * descriptor and wants the interfaces it was emitted with.
+ *
+ * `ClientOf<typeof CounterService>` is `CounterClient`. Without these a
+ * caller would have to name both halves again at every call site, which
+ * is the drift `ServiceDescriptor`'s parameters exist to prevent.
+ */
+export type ClientOf<D> = D extends ServiceDescriptor<infer TClient, unknown> ? TClient : never;
+/** The handler half of a service descriptor. See {@link ClientOf}. */
+export type HandlerOf<D> = D extends ServiceDescriptor<unknown, infer THandler> ? THandler : never;
+/**
+ * Whether an operation's reply carries more than a single value.
+ *
+ * §11.2: an operation that declares `out` or `inout` parameters resolves
+ * to an object literal carrying the return under `result` and one
+ * property per `out`/`inout` parameter. A runtime building the resolved
+ * value asks this before deciding which shape to construct, and asking
+ * it here rather than at each call site keeps one reading of the rule.
+ */
+export declare function hasAggregatedResult(operation: OperationDescriptor): boolean;
+/**
+ * The parameters a client method takes, in declaration order.
+ *
+ * §11.2: "parameter list is composed of the IDL `in` and `inout`
+ * parameters, in declaration order".
+ */
+export declare function inputParameters(operation: OperationDescriptor): ReadonlyArray<OperationParameterDescriptor>;
+/**
+ * The properties the resolved value carries beside `result`, in
+ * declaration order.
+ *
+ * §11.2: one property per `out`/`inout` parameter, named after the IDL
+ * parameter.
+ */
+export declare function outputParameters(operation: OperationDescriptor): ReadonlyArray<OperationParameterDescriptor>;
+/**
+ * An operation of a service or of any service it inherits from.
+ *
+ * §11.6 keeps the descriptor's `operations` array to what the interface
+ * declares itself, so a lookup by name has to walk `inherits`. Depth
+ * first and in declaration order, which is the order CORBA multiple
+ * inheritance resolves a name in; the first match wins, so a redeclared
+ * operation resolves to the most derived one.
+ *
+ * Returns `undefined` for a name no interface in the chain declares.
+ */
+export declare function findOperation(service: ServiceDescriptor<unknown, unknown>, name: string): OperationDescriptor | undefined;
+/**
+ * An attribute of a service or of any service it inherits from.
+ * See {@link findOperation} for the resolution order.
+ */
+export declare function findAttribute(service: ServiceDescriptor<unknown, unknown>, name: string): AttributeDescriptor | undefined;

package/dist/operations.js

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 ZeroDDS Contributors
+/**
+ * Whether an operation's reply carries more than a single value.
+ *
+ * §11.2: an operation that declares `out` or `inout` parameters resolves
+ * to an object literal carrying the return under `result` and one
+ * property per `out`/`inout` parameter. A runtime building the resolved
+ * value asks this before deciding which shape to construct, and asking
+ * it here rather than at each call site keeps one reading of the rule.
+ */
+export function hasAggregatedResult(operation) {
+    return operation.parameters.some((parameter) => parameter.mode === "out" || parameter.mode === "inout");
+}
+/**
+ * The parameters a client method takes, in declaration order.
+ *
+ * §11.2: "parameter list is composed of the IDL `in` and `inout`
+ * parameters, in declaration order".
+ */
+export function inputParameters(operation) {
+    return operation.parameters.filter((parameter) => parameter.mode === "in" || parameter.mode === "inout");
+}
+/**
+ * The properties the resolved value carries beside `result`, in
+ * declaration order.
+ *
+ * §11.2: one property per `out`/`inout` parameter, named after the IDL
+ * parameter.
+ */
+export function outputParameters(operation) {
+    return operation.parameters.filter((parameter) => parameter.mode === "out" || parameter.mode === "inout");
+}
+/**
+ * An operation of a service or of any service it inherits from.
+ *
+ * §11.6 keeps the descriptor's `operations` array to what the interface
+ * declares itself, so a lookup by name has to walk `inherits`. Depth
+ * first and in declaration order, which is the order CORBA multiple
+ * inheritance resolves a name in; the first match wins, so a redeclared
+ * operation resolves to the most derived one.
+ *
+ * Returns `undefined` for a name no interface in the chain declares.
+ */
+export function findOperation(service, name) {
+    const own = service.operations.find((operation) => operation.name === name);
+    if (own !== undefined) {
+        return own;
+    }
+    for (const base of service.inherits) {
+        const inherited = findOperation(base, name);
+        if (inherited !== undefined) {
+            return inherited;
+        }
+    }
+    return undefined;
+}
+/**
+ * An attribute of a service or of any service it inherits from.
+ * See {@link findOperation} for the resolution order.
+ */
+export function findAttribute(service, name) {
+    const own = service.attributes.find((attribute) => attribute.name === name);
+    if (own !== undefined) {
+        return own;
+    }
+    for (const base of service.inherits) {
+        const inherited = findAttribute(base, name);
+        if (inherited !== undefined) {
+            return inherited;
+        }
+    }
+    return undefined;
+}