@net-mesh/sdk 0.19.0

package/dist/mesh.js

@@ -0,0 +1,433 @@
+"use strict";
+/**
+ * MeshNode — the multi-peer encrypted mesh handle.
+ *
+ * Wraps the NAPI `NetMesh` with ergonomic TypeScript APIs: typed
+ * `StreamConfig`, classed `BackpressureError` / `NotConnectedError`
+ * for `instanceof`-based pattern matching, and the `send_with_retry`
+ * / `send_blocking` helpers from the Rust core.
+ *
+ * @example
+ * ```typescript
+ * import { MeshNode, BackpressureError, Reliability } from '@net-mesh/sdk';
+ *
+ * const node = await MeshNode.create({
+ *   bindAddr: '127.0.0.1:9000',
+ *   psk: '0'.repeat(64),
+ * });
+ *
+ * await node.connect('127.0.0.1:9001', peerPubkey, 0x2222n);
+ * node.start();
+ *
+ * const stream = node.openStream(0x2222n, {
+ *   streamId: 7n,
+ *   reliability: 'reliable',
+ *   windowBytes: 256,
+ * });
+ *
+ * try {
+ *   await node.sendOnStream(stream, [Buffer.from('hello')]);
+ * } catch (e) {
+ *   if (e instanceof BackpressureError) {
+ *     // daemon chose: drop, buffer, or retry
+ *   } else {
+ *     throw e;
+ *   }
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelAuthError = exports.ChannelError = exports.MeshNode = exports.NotConnectedError = exports.BackpressureError = void 0;
+const core_1 = require("@net-mesh/core");
+const _internal_js_1 = require("./_internal.js");
+const capabilities_1 = require("./capabilities");
+/**
+ * Thrown by {@link MeshNode.sendOnStream} / `sendWithRetry` /
+ * `sendBlocking` when the stream's per-stream in-flight window is
+ * full. **The event was NOT sent.** Caller decides whether to drop,
+ * retry, or buffer at the app layer — see the "Back-pressure" section
+ * in `docs/TRANSPORT.md` for the three canonical patterns.
+ */
+class BackpressureError extends Error {
+    constructor(detail) {
+        super(detail ?? 'stream would block (queue full)');
+        this.name = 'BackpressureError';
+        Object.setPrototypeOf(this, BackpressureError.prototype);
+    }
+}
+exports.BackpressureError = BackpressureError;
+/**
+ * Thrown when the stream's peer session is gone (peer never
+ * connected, disconnected, or the stream was closed). Distinct from
+ * {@link BackpressureError} because this is a "connection lost", not
+ * "too fast".
+ */
+class NotConnectedError extends Error {
+    constructor(detail) {
+        super(detail ?? 'stream not connected');
+        this.name = 'NotConnectedError';
+        Object.setPrototypeOf(this, NotConnectedError.prototype);
+    }
+}
+exports.NotConnectedError = NotConnectedError;
+/**
+ * Translate a napi-thrown error into one of the typed stream error
+ * classes if it matches the stable prefix contract from the binding.
+ * Anything else is passed through unchanged.
+ */
+function toStreamError(e) {
+    const msg = e?.message ?? '';
+    // Prefixes are part of the binding's stable contract; see
+    // `bindings/node/src/lib.rs` (`ERR_BACKPRESSURE_PREFIX` /
+    // `ERR_NOT_CONNECTED_PREFIX`).
+    if (msg.startsWith('stream would block')) {
+        throw new BackpressureError(msg);
+    }
+    if (msg.startsWith('stream not connected')) {
+        throw new NotConnectedError(msg);
+    }
+    throw e;
+}
+/**
+ * A node on the Net mesh with full stream multiplexing + backpressure
+ * support.
+ */
+class MeshNode {
+    native;
+    constructor(native) {
+        this.native = native;
+        // Register on the WeakMap so sibling SDK modules can reach
+        // the native pointer without a public escape-hatch method on
+        // the class instance. See `./_internal.ts` for why.
+        (0, _internal_js_1.setNapiMesh)(this, native);
+    }
+    /**
+     * **Test-only.** Inject a synthetic peer entry into the local
+     * capability index so vitest suites can stage multi-candidate
+     * placement for `ReplicaGroup` / `ForkGroup` / `StandbyGroup`
+     * tests without a full 3-node handshake.
+     *
+     * Not part of the stable API; do NOT use in production code —
+     * the real mesh surface is `announceCapabilities`. Gated at the
+     * NAPI layer behind the `test-helpers` cargo feature; release
+     * builds of `@net-mesh/core` do not export `testInjectSyntheticPeer`
+     * and this method will throw if called against such a build.
+     *
+     * @internal
+     */
+    _testInjectSyntheticPeer(nodeId) {
+        const native = this.native;
+        if (typeof native.testInjectSyntheticPeer !== 'function') {
+            throw new Error('testInjectSyntheticPeer: NAPI build missing `test-helpers` feature');
+        }
+        native.testInjectSyntheticPeer(nodeId);
+    }
+    /** Create and configure a new mesh node. */
+    static async create(config) {
+        const native = await core_1.NetMesh.create({
+            bindAddr: config.bindAddr,
+            psk: config.psk,
+            heartbeatIntervalMs: config.heartbeatIntervalMs,
+            sessionTimeoutMs: config.sessionTimeoutMs,
+            numShards: config.numShards,
+            capabilityGcIntervalMs: config.capabilityGcIntervalMs,
+            requireSignedCapabilities: config.requireSignedCapabilities,
+            subnet: config.subnet,
+            subnetPolicy: config.subnetPolicy,
+            identitySeed: config.identitySeed,
+        });
+        return new MeshNode(native);
+    }
+    /** 32-byte ed25519 entity id for this mesh. */
+    entityId() {
+        return this.native.entityId();
+    }
+    /** Hex-encoded Noise static public key. */
+    publicKey() {
+        return this.native.publicKey();
+    }
+    /** This node's id. */
+    nodeId() {
+        return this.native.nodeId();
+    }
+    /** Connect to a peer as initiator. */
+    async connect(peerAddr, peerPublicKey, peerNodeId) {
+        await this.native.connect(peerAddr, peerPublicKey, peerNodeId);
+    }
+    /** Accept an incoming connection as responder. Returns the peer's wire address. */
+    async accept(peerNodeId) {
+        return await this.native.accept(peerNodeId);
+    }
+    /** Start the receive loop / heartbeats / router. */
+    async start() {
+        await this.native.start();
+    }
+    /** Number of connected peers. */
+    peerCount() {
+        return this.native.peerCount();
+    }
+    // ─── Stream API ──────────────────────────────────────────────────
+    /**
+     * Open (or look up) a logical stream to a connected peer. Repeated
+     * calls for the same `(peer, streamId)` are idempotent; the first
+     * open wins and later differing configs are logged and ignored.
+     */
+    openStream(peerNodeId, config) {
+        const native = this.native.openStream(peerNodeId, {
+            streamId: config.streamId,
+            reliability: config.reliability,
+            windowBytes: config.windowBytes,
+            fairnessWeight: config.fairnessWeight,
+        });
+        return {
+            peerNodeId,
+            streamId: config.streamId,
+            _native: native,
+        };
+    }
+    /** Close a stream. Idempotent. */
+    closeStream(peerNodeId, streamId) {
+        this.native.closeStream(peerNodeId, streamId);
+    }
+    /**
+     * Send a batch of events on an explicit stream. Throws
+     * {@link BackpressureError} when the stream's in-flight window is
+     * full (no events sent — caller decides what to do),
+     * {@link NotConnectedError} when the peer session is gone, or a
+     * plain `Error` for underlying transport failures.
+     */
+    async sendOnStream(stream, events) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.native.sendOnStream(stream._native, events);
+        }
+        catch (e) {
+            toStreamError(e);
+        }
+    }
+    /**
+     * Send events, retrying on {@link BackpressureError} with 5 ms → 200 ms
+     * exponential backoff up to `maxRetries` times. Transport errors and
+     * `NotConnectedError` are re-thrown immediately (they're not a
+     * pressure signal).
+     */
+    async sendWithRetry(stream, events, maxRetries = 8) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.native.sendWithRetry(stream._native, events, maxRetries);
+        }
+        catch (e) {
+            toStreamError(e);
+        }
+    }
+    /**
+     * Block the calling task until the send succeeds or a transport
+     * error occurs. Retries {@link BackpressureError} with 5 ms → 200 ms
+     * exponential backoff up to 4096 times (~13 min worst case) —
+     * effectively "block until the network lets up" under practical
+     * workloads, but with a hard upper bound so runaway pressure can't
+     * hang the caller forever. Use {@link sendWithRetry} for a tighter
+     * bound.
+     */
+    async sendBlocking(stream, events) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.native.sendBlocking(stream._native, events);
+        }
+        catch (e) {
+            toStreamError(e);
+        }
+    }
+    /** Snapshot per-stream stats. `null` if the peer or stream isn't open. */
+    streamStats(peerNodeId, streamId) {
+        const raw = this.native.streamStats(peerNodeId, streamId);
+        if (!raw)
+            return null;
+        // The napi binding marshals u64 fields as `BigInt` so values that
+        // exceed `Number.MAX_SAFE_INTEGER` — especially `lastActivityNs`,
+        // Unix-epoch nanoseconds always above 2^53 — survive the boundary
+        // without a precision trap. The u32 fields stay as regular numbers.
+        return {
+            txSeq: raw.txSeq,
+            rxSeq: raw.rxSeq,
+            inboundPending: raw.inboundPending,
+            lastActivityNs: raw.lastActivityNs,
+            active: raw.active,
+            backpressureEvents: raw.backpressureEvents,
+            txCreditRemaining: raw.txCreditRemaining,
+            txWindow: raw.txWindow,
+            creditGrantsReceived: raw.creditGrantsReceived,
+            creditGrantsSent: raw.creditGrantsSent,
+        };
+    }
+    // =========================================================
+    // Channels (distributed pub/sub)
+    // =========================================================
+    /**
+     * Register a channel on this node. Subscribers who ask to join are
+     * validated against `config` before being added to the roster.
+     *
+     * Mirrors the core `ChannelConfig` field-for-field. v1 omits
+     * `publishCaps` / `subscribeCaps` — those land with the security
+     * plan's identity surface.
+     */
+    registerChannel(config) {
+        try {
+            this.native.registerChannel({
+                name: config.name,
+                visibility: config.visibility,
+                reliable: config.reliable,
+                requireToken: config.requireToken,
+                priority: config.priority,
+                maxRatePps: config.maxRatePps,
+                publishCaps: config.publishCaps
+                    ? (0, capabilities_1.capabilityFilterToNapi)(config.publishCaps)
+                    : undefined,
+                subscribeCaps: config.subscribeCaps
+                    ? (0, capabilities_1.capabilityFilterToNapi)(config.subscribeCaps)
+                    : undefined,
+            });
+        }
+        catch (e) {
+            toChannelError(e);
+        }
+    }
+    /**
+     * Ask `publisherNodeId` to add this node to `channel`'s subscriber
+     * set. Blocks until the publisher's `Ack` arrives or the
+     * membership-ack timeout elapses.
+     *
+     * Pass `opts.token` to present a
+     * {@link Token PermissionToken} issued by the publisher — required
+     * when the channel was registered with `requireToken: true` or
+     * when your caps alone don't satisfy `subscribeCaps`. The
+     * publisher verifies the signature, checks `subject ===
+     * thisNode.entityId`, installs it in its local cache, then runs
+     * the ACL check.
+     *
+     * Throws a {@link ChannelAuthError} or {@link ChannelError} on
+     * rejection; network-level failures propagate as plain `Error`.
+     */
+    async subscribeChannel(publisherNodeId, channel, opts) {
+        try {
+            await this.native.subscribeChannel(publisherNodeId, channel, opts?.token?.bytes);
+        }
+        catch (e) {
+            toChannelError(e);
+        }
+    }
+    /** Mirror of {@link subscribeChannel}. Idempotent on the publisher side. */
+    async unsubscribeChannel(publisherNodeId, channel) {
+        try {
+            await this.native.unsubscribeChannel(publisherNodeId, channel);
+        }
+        catch (e) {
+            toChannelError(e);
+        }
+    }
+    /**
+     * Publish one payload to every subscriber of `channel`. Returns a
+     * {@link PublishReport} describing per-peer outcomes.
+     */
+    async publish(channel, payload, config) {
+        try {
+            const raw = await this.native.publish(channel, payload, {
+                reliability: config?.reliability,
+                onFailure: config?.onFailure,
+                maxInflight: config?.maxInflight,
+            });
+            return {
+                attempted: raw.attempted,
+                delivered: raw.delivered,
+                errors: raw.errors.map((e) => ({
+                    nodeId: e.nodeId,
+                    message: e.message,
+                })),
+            };
+        }
+        catch (e) {
+            toChannelError(e);
+        }
+    }
+    /**
+     * Announce this node's capabilities to every directly-connected
+     * peer. Self-indexes too, so `findNodes` on this same node matches
+     * on the announcement. Multi-hop propagation is deferred — peers
+     * more than one hop away will not see the announcement.
+     */
+    async announceCapabilities(caps) {
+        await this.native.announceCapabilities((0, capabilities_1.capabilitySetToNapi)(caps));
+    }
+    /**
+     * Query the local capability index. Returns node ids (including
+     * our own `nodeId()` if self matches) whose latest announcement
+     * matches `filter`.
+     */
+    findNodes(filter) {
+        return this.native.findNodes((0, capabilities_1.capabilityFilterToNapi)(filter));
+    }
+    /**
+     * Scoped variant of {@link findNodes}. Filters candidates through
+     * a {@link ScopeFilter} derived from each peer's `scope:*`
+     * reserved tags (e.g. `scope:tenant:oem-123`,
+     * `scope:region:eu-west`, `scope:subnet-local`).
+     *
+     * Untagged peers stay visible under most filters by design;
+     * peers tagged `scope:subnet-local` only show up under
+     * `{ kind: 'sameSubnet' }`. See `docs/SCOPED_CAPABILITIES_PLAN.md`
+     * for the full table.
+     *
+     * @example
+     * ```typescript
+     * // GPU pool for a specific tenant.
+     * const peers = node.findNodesScoped(
+     *   { requireTags: ['model:llama3-70b'] },
+     *   { kind: 'tenant', tenant: 'oem-123' },
+     * );
+     * ```
+     */
+    findNodesScoped(filter, scope) {
+        return this.native.findNodesScoped((0, capabilities_1.capabilityFilterToNapi)(filter), (0, capabilities_1.scopeFilterToNapi)(scope));
+    }
+    /** Shutdown the mesh node. */
+    async shutdown() {
+        await this.native.shutdown();
+    }
+}
+exports.MeshNode = MeshNode;
+/**
+ * Raised when a channel operation fails for a reason other than
+ * auth. The napi binding emits `"channel: ..."` prefixed errors that
+ * the SDK classifies into {@link ChannelAuthError} (unauthorized) or
+ * this class (everything else).
+ */
+class ChannelError extends Error {
+    constructor(detail) {
+        super(detail ?? 'channel error');
+        this.name = 'ChannelError';
+        Object.setPrototypeOf(this, ChannelError.prototype);
+    }
+}
+exports.ChannelError = ChannelError;
+/**
+ * Raised when a Subscribe / Unsubscribe request is rejected because
+ * the subscriber isn't authorized on the publisher's channel config.
+ */
+class ChannelAuthError extends ChannelError {
+    constructor(detail) {
+        super(detail ?? 'channel: unauthorized');
+        this.name = 'ChannelAuthError';
+        Object.setPrototypeOf(this, ChannelAuthError.prototype);
+    }
+}
+exports.ChannelAuthError = ChannelAuthError;
+function toChannelError(e) {
+    const msg = e?.message ?? '';
+    if (msg.startsWith('channel: unauthorized')) {
+        throw new ChannelAuthError(msg);
+    }
+    if (msg.startsWith('channel:')) {
+        throw new ChannelError(msg);
+    }
+    throw e;
+}

package/dist/meshdb.d.ts

@@ -0,0 +1,87 @@
+/**
+ * MeshDB SDK wrapper.
+ *
+ * Re-exports the MeshDB query layer from `@net-mesh/core` (the napi
+ * binding) so `@net-mesh/sdk` consumers can stay on the
+ * ergonomic SDK module instead of dropping into the napi package.
+ * Also imports the AsyncIterable shim from `@net-mesh/core/meshdb`
+ * once, so `for await (const row of stream)` works without the
+ * consumer having to remember the side-effect import.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   InMemoryChainReader,
+ *   MeshQuery,
+ *   MeshQueryRunner,
+ *   QueryBuilder,
+ * } from '@net-mesh/sdk/meshdb';
+ *
+ * const reader = new InMemoryChainReader();
+ * // …populate reader…
+ * const runner = new MeshQueryRunner(reader);
+ *
+ * const query = new QueryBuilder().fromOrigin(0n).build();
+ * const stream = await runner.execute(query);
+ * for await (const row of stream) {
+ *   console.log(row.seq, row.payload);
+ * }
+ * ```
+ */
+/**
+ * Result of {@link parseMeshDbErrorKind} — the structured error kind
+ * extracted from a MeshDB error envelope, plus the human-readable
+ * message stripped of the `<<meshdb-kind:...>>` prefix.
+ */
+export interface ParsedMeshDbError {
+    kind: string;
+    message: string;
+}
+/**
+ * Pull the structured error kind out of a MeshDB error message.
+ * The substrate wraps every typed error as
+ * `<<meshdb-kind:KIND>>MESSAGE`; this helper splits the two halves so
+ * callers can dispatch programmatically. Returns `null` when the
+ * envelope is absent (forward-compatibility — unknown error shapes
+ * pass through unchanged).
+ *
+ * Mirrors the napi-side helper at `@net-mesh/core/meshdb` so consumers
+ * don't have to reach across packages for the parser.
+ */
+export declare function parseMeshDbErrorKind(raw: string): ParsedMeshDbError | null;
+/**
+ * Note on AsyncIterable: the napi-side `MeshQueryStream` ships with a
+ * separate side-effect module (`@net-mesh/core/meshdb`) that augments
+ * the prototype with `[Symbol.asyncIterator]`. To use
+ * `for await (const row of stream)` syntax, import it once at
+ * startup:
+ *
+ * ```typescript
+ * import '@net-mesh/core/meshdb';
+ * import { MeshQueryRunner } from '@net-mesh/sdk/meshdb';
+ * ```
+ *
+ * Without the side-effect import the stream still works via the
+ * imperative `next()` / `toArray()` methods.
+ */
+export { InMemoryChainReader, MeshQuery, MeshQueryRunner, MeshQueryStream, QueryBuilder, } from '@net-mesh/core';
+export type { AggregateResult, CachePolicy, ExecuteOptions, GroupKey, JoinedRow, LineageEntry, Predicate as MeshDbPredicate, ResultRow, WindowBoundary, } from '@net-mesh/core';
+/**
+ * Disposable-friendly wrapper around `MeshQueryRunner` for callers
+ * who want explicit lifetime management via the TC39
+ * `using`/`Symbol.dispose` protocol. The underlying runner has no
+ * native close; this wrapper exists so consumers can pair it with
+ * other Disposable resources in a single `using` chain.
+ *
+ * @example
+ * ```typescript
+ * using runner = new DisposableMeshQueryRunner(reader);
+ * const stream = await runner.runner.execute(query);
+ * // runner is released when the enclosing scope exits.
+ * ```
+ */
+export declare class DisposableMeshQueryRunner {
+    readonly runner: import('@net-mesh/core').MeshQueryRunner;
+    constructor(reader: import('@net-mesh/core').InMemoryChainReader);
+    [Symbol.dispose](): void;
+}

package/dist/meshdb.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * MeshDB SDK wrapper.
+ *
+ * Re-exports the MeshDB query layer from `@net-mesh/core` (the napi
+ * binding) so `@net-mesh/sdk` consumers can stay on the
+ * ergonomic SDK module instead of dropping into the napi package.
+ * Also imports the AsyncIterable shim from `@net-mesh/core/meshdb`
+ * once, so `for await (const row of stream)` works without the
+ * consumer having to remember the side-effect import.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   InMemoryChainReader,
+ *   MeshQuery,
+ *   MeshQueryRunner,
+ *   QueryBuilder,
+ * } from '@net-mesh/sdk/meshdb';
+ *
+ * const reader = new InMemoryChainReader();
+ * // …populate reader…
+ * const runner = new MeshQueryRunner(reader);
+ *
+ * const query = new QueryBuilder().fromOrigin(0n).build();
+ * const stream = await runner.execute(query);
+ * for await (const row of stream) {
+ *   console.log(row.seq, row.payload);
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisposableMeshQueryRunner = exports.QueryBuilder = exports.MeshQueryStream = exports.MeshQueryRunner = exports.MeshQuery = exports.InMemoryChainReader = void 0;
+exports.parseMeshDbErrorKind = parseMeshDbErrorKind;
+/**
+ * Pull the structured error kind out of a MeshDB error message.
+ * The substrate wraps every typed error as
+ * `<<meshdb-kind:KIND>>MESSAGE`; this helper splits the two halves so
+ * callers can dispatch programmatically. Returns `null` when the
+ * envelope is absent (forward-compatibility — unknown error shapes
+ * pass through unchanged).
+ *
+ * Mirrors the napi-side helper at `@net-mesh/core/meshdb` so consumers
+ * don't have to reach across packages for the parser.
+ */
+function parseMeshDbErrorKind(raw) {
+    const marker = '<<meshdb-kind:';
+    const start = raw.indexOf(marker);
+    if (start === -1)
+        return null;
+    const end = raw.indexOf('>>', start + marker.length);
+    if (end === -1)
+        return null;
+    const kind = raw.slice(start + marker.length, end);
+    const message = raw.slice(end + 2);
+    return { kind, message };
+}
+/**
+ * Note on AsyncIterable: the napi-side `MeshQueryStream` ships with a
+ * separate side-effect module (`@net-mesh/core/meshdb`) that augments
+ * the prototype with `[Symbol.asyncIterator]`. To use
+ * `for await (const row of stream)` syntax, import it once at
+ * startup:
+ *
+ * ```typescript
+ * import '@net-mesh/core/meshdb';
+ * import { MeshQueryRunner } from '@net-mesh/sdk/meshdb';
+ * ```
+ *
+ * Without the side-effect import the stream still works via the
+ * imperative `next()` / `toArray()` methods.
+ */
+// Class re-exports — generated by napi-rs; identity-stable across
+// imports of the same loaded module.
+var core_1 = require("@net-mesh/core");
+Object.defineProperty(exports, "InMemoryChainReader", { enumerable: true, get: function () { return core_1.InMemoryChainReader; } });
+Object.defineProperty(exports, "MeshQuery", { enumerable: true, get: function () { return core_1.MeshQuery; } });
+Object.defineProperty(exports, "MeshQueryRunner", { enumerable: true, get: function () { return core_1.MeshQueryRunner; } });
+Object.defineProperty(exports, "MeshQueryStream", { enumerable: true, get: function () { return core_1.MeshQueryStream; } });
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return core_1.QueryBuilder; } });
+/**
+ * Disposable-friendly wrapper around `MeshQueryRunner` for callers
+ * who want explicit lifetime management via the TC39
+ * `using`/`Symbol.dispose` protocol. The underlying runner has no
+ * native close; this wrapper exists so consumers can pair it with
+ * other Disposable resources in a single `using` chain.
+ *
+ * @example
+ * ```typescript
+ * using runner = new DisposableMeshQueryRunner(reader);
+ * const stream = await runner.runner.execute(query);
+ * // runner is released when the enclosing scope exits.
+ * ```
+ */
+class DisposableMeshQueryRunner {
+    // Lazily-typed because the napi runner has no exported instance shape
+    // we can name without importing the value (and the value import is
+    // already covered above).
+    runner;
+    constructor(reader) {
+        const Runner = require('@net-mesh/core').MeshQueryRunner;
+        this.runner = new Runner(reader);
+    }
+    [Symbol.dispose]() {
+        // Runner has no native close — drop the reference so GC can
+        // collect it deterministically once the using-block exits.
+        // The reader retains its own Arc clone of the chain.
+        this.runner = undefined;
+    }
+}
+exports.DisposableMeshQueryRunner = DisposableMeshQueryRunner;