@norskvideo/moq-net 0.1.0

package/mock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mock WebTransport implementation for in-process testing.
+ *
+ * Creates paired client/server transports connected via TransformStreams.
+ */
+/**
+ * Creates a pair of connected MockTransport instances.
+ *
+ * @param protocol - The WebTransport protocol identifier (e.g. "moqt-17", "moql", "")
+ * @returns An object containing `client` and `server` transports
+ */
+export declare function createMockTransportPair(protocol?: string): {
+    client: WebTransport;
+    server: WebTransport;
+};
+//# sourceMappingURL=mock.d.ts.map

package/mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../src/mock.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAiKH;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,SAAK,GAAG;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAMrG"}

package/mock.js

@@ -0,0 +1,154 @@
+/* @ts-self-types="./mock.d.ts" */
+/**
+ * Mock WebTransport implementation for in-process testing.
+ *
+ * Creates paired client/server transports connected via TransformStreams.
+ */
+// High watermark to prevent writes from blocking on backpressure.
+// Real WebTransport has kernel buffers; we simulate this with a large queue.
+const WRITABLE_STRATEGY = { highWaterMark: 256 };
+const READABLE_STRATEGY = { highWaterMark: 256 };
+function newStream() {
+    return new TransformStream({
+        // Copy each chunk to simulate real WebTransport's kernel-boundary copy.
+        // Without this, Writer's scratch buffer reuse corrupts queued data.
+        transform(chunk, controller) {
+            controller.enqueue(new Uint8Array(chunk));
+        },
+    }, WRITABLE_STRATEGY, READABLE_STRATEGY);
+}
+class MockTransport {
+    protocol;
+    ready;
+    closed;
+    incomingBidirectionalStreams;
+    incomingUnidirectionalStreams;
+    datagrams;
+    congestionControl;
+    reliability;
+    #closeResolve;
+    #bidiController;
+    #uniController;
+    // Reference to the peer so we can enqueue streams to them
+    #peer;
+    constructor(protocol) {
+        this.protocol = protocol;
+        this.ready = Promise.resolve(undefined);
+        this.closed = new Promise((resolve) => {
+            this.#closeResolve = resolve;
+        });
+        this.incomingBidirectionalStreams = new ReadableStream({
+            start: (controller) => {
+                this.#bidiController = controller;
+            },
+        });
+        this.incomingUnidirectionalStreams = new ReadableStream({
+            start: (controller) => {
+                this.#uniController = controller;
+            },
+        });
+        this.congestionControl = "default";
+        this.reliability = "supports-unreliable";
+        // Stub datagrams
+        this.datagrams = {
+            readable: new ReadableStream(),
+            writable: new WritableStream(),
+            incomingHighWaterMark: 0,
+            outgoingHighWaterMark: 0,
+            incomingMaxAge: null,
+            outgoingMaxAge: null,
+            maxDatagramSize: 0,
+        };
+    }
+    setPeer(peer) {
+        this.#peer = peer;
+    }
+    async createBidirectionalStream(_options) {
+        const peer = this.#peer;
+        if (!peer)
+            throw new Error("no peer");
+        // Create two TransformStreams for the two directions
+        const c2s = newStream();
+        const s2c = newStream();
+        // Local side: writes to c2s, reads from s2c
+        const local = {
+            readable: s2c.readable,
+            writable: c2s.writable,
+        };
+        // Peer side: writes to s2c, reads from c2s
+        const remote = {
+            readable: c2s.readable,
+            writable: s2c.writable,
+        };
+        try {
+            peer.#bidiController.enqueue(remote);
+        }
+        catch {
+            // Peer closed
+        }
+        return local;
+    }
+    async createUnidirectionalStream(_options) {
+        const peer = this.#peer;
+        if (!peer)
+            throw new Error("no peer");
+        const c2s = newStream();
+        try {
+            peer.#uniController.enqueue(c2s.readable);
+        }
+        catch {
+            // Peer closed
+        }
+        return c2s.writable;
+    }
+    close(_closeInfo) {
+        const info = _closeInfo ?? { closeCode: 0, reason: "" };
+        this.#closeResolve(info);
+        try {
+            this.#bidiController.close();
+        }
+        catch {
+            // Already closed
+        }
+        try {
+            this.#uniController.close();
+        }
+        catch {
+            // Already closed
+        }
+        // Also close peer's incoming streams
+        if (this.#peer) {
+            try {
+                this.#peer.#bidiController.close();
+            }
+            catch {
+                // Already closed
+            }
+            try {
+                this.#peer.#uniController.close();
+            }
+            catch {
+                // Already closed
+            }
+            this.#peer.#closeResolve(info);
+        }
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: WebTransportStats type not available in all TS libs
+    async getStats() {
+        return {};
+    }
+}
+/**
+ * Creates a pair of connected MockTransport instances.
+ *
+ * @param protocol - The WebTransport protocol identifier (e.g. "moqt-17", "moql", "")
+ * @returns An object containing `client` and `server` transports
+ */
+export function createMockTransportPair(protocol = "") {
+    const client = new MockTransport(protocol);
+    const server = new MockTransport(protocol);
+    client.setPeer(server);
+    server.setPeer(client);
+    return { client, server };
+}
+//# sourceMappingURL=mock.js.map

package/mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock.js","sourceRoot":"","sources":["../src/mock.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Mock WebTransport implementation for in-process testing.\n *\n * Creates paired client/server transports connected via TransformStreams.\n */\n\n// High watermark to prevent writes from blocking on backpressure.\n// Real WebTransport has kernel buffers; we simulate this with a large queue.\nconst WRITABLE_STRATEGY: QueuingStrategy<Uint8Array> = { highWaterMark: 256 };\nconst READABLE_STRATEGY: QueuingStrategy<Uint8Array> = { highWaterMark: 256 };\n\nfunction newStream(): TransformStream<Uint8Array, Uint8Array> {\n\treturn new TransformStream(\n\t\t{\n\t\t\t// Copy each chunk to simulate real WebTransport's kernel-boundary copy.\n\t\t\t// Without this, Writer's scratch buffer reuse corrupts queued data.\n\t\t\ttransform(chunk, controller) {\n\t\t\t\tcontroller.enqueue(new Uint8Array(chunk));\n\t\t\t},\n\t\t},\n\t\tWRITABLE_STRATEGY,\n\t\tREADABLE_STRATEGY,\n\t);\n}\n\nclass MockTransport implements WebTransport {\n\treadonly protocol: string;\n\treadonly ready: Promise<undefined>;\n\treadonly closed: Promise<WebTransportCloseInfo>;\n\n\treadonly incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalStream>;\n\treadonly incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>>;\n\n\treadonly datagrams: WebTransportDatagramDuplexStream;\n\treadonly congestionControl: WebTransportCongestionControl;\n\treadonly reliability: string;\n\n\t#closeResolve!: (info: WebTransportCloseInfo) => void;\n\t#bidiController!: ReadableStreamDefaultController<WebTransportBidirectionalStream>;\n\t#uniController!: ReadableStreamDefaultController<ReadableStream<Uint8Array>>;\n\n\t// Reference to the peer so we can enqueue streams to them\n\t#peer?: MockTransport;\n\n\tconstructor(protocol: string) {\n\t\tthis.protocol = protocol;\n\t\tthis.ready = Promise.resolve(undefined);\n\t\tthis.closed = new Promise((resolve) => {\n\t\t\tthis.#closeResolve = resolve;\n\t\t});\n\n\t\tthis.incomingBidirectionalStreams = new ReadableStream({\n\t\t\tstart: (controller) => {\n\t\t\t\tthis.#bidiController = controller;\n\t\t\t},\n\t\t});\n\n\t\tthis.incomingUnidirectionalStreams = new ReadableStream({\n\t\t\tstart: (controller) => {\n\t\t\t\tthis.#uniController = controller;\n\t\t\t},\n\t\t});\n\n\t\tthis.congestionControl = \"default\";\n\t\tthis.reliability = \"supports-unreliable\";\n\n\t\t// Stub datagrams\n\t\tthis.datagrams = {\n\t\t\treadable: new ReadableStream(),\n\t\t\twritable: new WritableStream(),\n\t\t\tincomingHighWaterMark: 0,\n\t\t\toutgoingHighWaterMark: 0,\n\t\t\tincomingMaxAge: null,\n\t\t\toutgoingMaxAge: null,\n\t\t\tmaxDatagramSize: 0,\n\t\t};\n\t}\n\n\tsetPeer(peer: MockTransport) {\n\t\tthis.#peer = peer;\n\t}\n\n\tasync createBidirectionalStream(\n\t\t_options?: WebTransportSendStreamOptions,\n\t): Promise<WebTransportBidirectionalStream> {\n\t\tconst peer = this.#peer;\n\t\tif (!peer) throw new Error(\"no peer\");\n\n\t\t// Create two TransformStreams for the two directions\n\t\tconst c2s = newStream();\n\t\tconst s2c = newStream();\n\n\t\t// Local side: writes to c2s, reads from s2c\n\t\tconst local = {\n\t\t\treadable: s2c.readable,\n\t\t\twritable: c2s.writable,\n\t\t} as WebTransportBidirectionalStream;\n\n\t\t// Peer side: writes to s2c, reads from c2s\n\t\tconst remote = {\n\t\t\treadable: c2s.readable,\n\t\t\twritable: s2c.writable,\n\t\t} as WebTransportBidirectionalStream;\n\n\t\ttry {\n\t\t\tpeer.#bidiController.enqueue(remote);\n\t\t} catch {\n\t\t\t// Peer closed\n\t\t}\n\n\t\treturn local;\n\t}\n\n\tasync createUnidirectionalStream(_options?: WebTransportSendStreamOptions): Promise<WritableStream<Uint8Array>> {\n\t\tconst peer = this.#peer;\n\t\tif (!peer) throw new Error(\"no peer\");\n\n\t\tconst c2s = newStream();\n\n\t\ttry {\n\t\t\tpeer.#uniController.enqueue(c2s.readable);\n\t\t} catch {\n\t\t\t// Peer closed\n\t\t}\n\n\t\treturn c2s.writable;\n\t}\n\n\tclose(_closeInfo?: WebTransportCloseInfo): void {\n\t\tconst info = _closeInfo ?? { closeCode: 0, reason: \"\" };\n\t\tthis.#closeResolve(info);\n\n\t\ttry {\n\t\t\tthis.#bidiController.close();\n\t\t} catch {\n\t\t\t// Already closed\n\t\t}\n\t\ttry {\n\t\t\tthis.#uniController.close();\n\t\t} catch {\n\t\t\t// Already closed\n\t\t}\n\n\t\t// Also close peer's incoming streams\n\t\tif (this.#peer) {\n\t\t\ttry {\n\t\t\t\tthis.#peer.#bidiController.close();\n\t\t\t} catch {\n\t\t\t\t// Already closed\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tthis.#peer.#uniController.close();\n\t\t\t} catch {\n\t\t\t\t// Already closed\n\t\t\t}\n\t\t\tthis.#peer.#closeResolve(info);\n\t\t}\n\t}\n\n\t// biome-ignore lint/suspicious/noExplicitAny: WebTransportStats type not available in all TS libs\n\tasync getStats(): Promise<any> {\n\t\treturn {};\n\t}\n}\n\n/**\n * Creates a pair of connected MockTransport instances.\n *\n * @param protocol - The WebTransport protocol identifier (e.g. \"moqt-17\", \"moql\", \"\")\n * @returns An object containing `client` and `server` transports\n */\nexport function createMockTransportPair(protocol = \"\"): { client: WebTransport; server: WebTransport } {\n\tconst client = new MockTransport(protocol);\n\tconst server = new MockTransport(protocol);\n\tclient.setPeer(server);\n\tserver.setPeer(client);\n\treturn { client, server };\n}\n"]}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@norskvideo/moq-net",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "The networking layer for Media over QUIC: real-time pub/sub with built-in caching, fan-out, and prioritization.",
+  "license": "(MIT OR Apache-2.0)",
+  "repository": "github:moq-dev/moq",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./zod": {
+      "types": "./zod.d.ts",
+      "default": "./zod.js"
+    }
+  },
+  "dependencies": {
+    "@moq/qmux": "^0.1.3",
+    "async-mutex": "^0.5.0",
+    "@norskvideo/moq-signals": "^0.1.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.0.0"
+  }
+}

package/path.d.ts

@@ -0,0 +1,111 @@
+/**
+ * A broadcast path that provides safe prefix matching operations.
+ *
+ * This module provides path-aware operations that respect delimiter boundaries,
+ * preventing issues like "foo" matching "foobar".
+ *
+ * Paths are automatically trimmed of leading and trailing slashes on creation,
+ * making all slashes implicit at boundaries.
+ * All paths are RELATIVE; you cannot join with a leading slash to make an absolute path.
+ *
+ * @example
+ * ```typescript
+ * // Creation automatically trims slashes
+ * const path1 = Path.from("/foo/bar/");
+ * const path2 = Path.from("foo/bar");
+ * console.log(path1 === path2); // true
+ *
+ * // Multiple arguments are joined with "/"
+ * const path3 = Path.from("api", "v1", "users");
+ * console.log(path3); // "api/v1/users"
+ *
+ * // Safe prefix matching
+ * const base = Path.from("api/v1");
+ * console.log(Path.hasPrefix(Path.from("api"), base)); // true
+ * console.log(Path.hasPrefix(Path.from("api/v1"), base)); // true
+ *
+ * const joined = Path.join(base, Path.from("users"));
+ * console.log(joined); // "api/v1/users"
+ * ```
+ */
+export type Valid = string & {
+    __brand: "Name";
+};
+/**
+ * Maximum number of slash-separated parts in a path.
+ *
+ * Matches the IETF moq-transport limit of 32 fields in a namespace tuple.
+ * moq-lite enforces the same bound when decoding paths off the wire.
+ */
+export declare const MAX_PARTS = 32;
+/** Build a path from one or more components, joining with "/" and trimming redundant slashes. */
+export declare function from(...paths: string[]): Valid;
+/** Split a path into its slash-separated parts. The empty path has no parts. */
+export declare function parts(path: Valid): string[];
+/**
+ * Validate an untrusted wire string as a path, enforcing {@link MAX_PARTS}.
+ *
+ * Throws when the path has too many parts; use at wire decode sites.
+ */
+export declare function decode(raw: string): Valid;
+/**
+ * Validate a path before writing it to the wire, enforcing {@link MAX_PARTS}.
+ *
+ * Throws when the path has too many parts; use at wire encode sites so we never
+ * emit a path the remote side is required to reject.
+ */
+export declare function encode(path: Valid): Valid;
+/**
+ * Check if a path has the given prefix, respecting path boundaries.
+ *
+ * Unlike String.startsWith, this ensures that "foo" does not match "foobar".
+ * The prefix must either:
+ * - Be exactly equal to the path
+ * - Be followed by a '/' delimiter in the original path
+ * - Be empty (matches everything)
+ *
+ * @example
+ * ```typescript
+ * const path = Path.from("foo/bar");
+ * console.log(Path.hasPrefix(Path.from("foo"), path)); // true
+ * console.log(Path.hasPrefix(Path.from("foo/"), path)); // true (trailing slash ignored)
+ * console.log(Path.hasPrefix(Path.from("fo"), path)); // false
+ *
+ * const path2 = Path.from("foobar");
+ * console.log(Path.hasPrefix(Path.from("foo"), path2)); // false
+ * ```
+ */
+export declare function hasPrefix(prefix: Valid, path: Valid): boolean;
+/**
+ * Strip the given prefix from a path, returning the suffix.
+ *
+ * Returns null if the prefix doesn't match according to hasPrefix rules.
+ *
+ * @example
+ * ```typescript
+ * const path = Path.from("foo/bar/baz");
+ * const suffix = Path.stripPrefix(Path.from("foo"), path);
+ * console.log(suffix); // "bar/baz"
+ *
+ * const suffix2 = Path.stripPrefix(Path.from("foo/"), path);
+ * console.log(suffix2); // "bar/baz"
+ *
+ * const noMatch = Path.stripPrefix(Path.from("notfound"), path);
+ * console.log(noMatch); // null
+ * ```
+ */
+export declare function stripPrefix(prefix: Valid, path: Valid): Valid | null;
+/**
+ * Join two path components together.
+ *
+ * @example
+ * ```typescript
+ * const base = Path.from("foo");
+ * const joined = Path.join(base, Path.from("bar"));
+ * console.log(joined); // "foo/bar"
+ * ```
+ */
+export declare function join(path: Valid, other: Valid): Valid;
+/** The empty path, which is a prefix of every path. */
+export declare function empty(): Valid;
+//# sourceMappingURL=path.d.ts.map

package/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../src/path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,KAAK,GAAG,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,KAAK,CAAC;AAE5B,iGAAiG;AACjG,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAI9C;AAED,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,EAAE,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAGzC;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,KAAK,GAAG,KAAK,CAKzC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAgB7D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAiBpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,CASrD;AAED,uDAAuD;AACvD,wBAAgB,KAAK,IAAI,KAAK,CAE7B"}

package/path.js

@@ -0,0 +1,133 @@
+/* @ts-self-types="./path.d.ts" */
+/**
+ * Maximum number of slash-separated parts in a path.
+ *
+ * Matches the IETF moq-transport limit of 32 fields in a namespace tuple.
+ * moq-lite enforces the same bound when decoding paths off the wire.
+ */
+export const MAX_PARTS = 32;
+/** Build a path from one or more components, joining with "/" and trimming redundant slashes. */
+export function from(...paths) {
+    // Join paths with "/" and then remove leading and trailing slashes, and collapse multiple slashes into one.
+    const joined = paths.join("/");
+    return joined.replace(/\/+/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
+}
+/** Split a path into its slash-separated parts. The empty path has no parts. */
+export function parts(path) {
+    return path === "" ? [] : path.split("/");
+}
+/**
+ * Validate an untrusted wire string as a path, enforcing {@link MAX_PARTS}.
+ *
+ * Throws when the path has too many parts; use at wire decode sites.
+ */
+export function decode(raw) {
+    const path = from(raw);
+    return encode(path);
+}
+/**
+ * Validate a path before writing it to the wire, enforcing {@link MAX_PARTS}.
+ *
+ * Throws when the path has too many parts; use at wire encode sites so we never
+ * emit a path the remote side is required to reject.
+ */
+export function encode(path) {
+    if (parts(path).length > MAX_PARTS) {
+        throw new Error(`path exceeds ${MAX_PARTS} parts`);
+    }
+    return path;
+}
+/**
+ * Check if a path has the given prefix, respecting path boundaries.
+ *
+ * Unlike String.startsWith, this ensures that "foo" does not match "foobar".
+ * The prefix must either:
+ * - Be exactly equal to the path
+ * - Be followed by a '/' delimiter in the original path
+ * - Be empty (matches everything)
+ *
+ * @example
+ * ```typescript
+ * const path = Path.from("foo/bar");
+ * console.log(Path.hasPrefix(Path.from("foo"), path)); // true
+ * console.log(Path.hasPrefix(Path.from("foo/"), path)); // true (trailing slash ignored)
+ * console.log(Path.hasPrefix(Path.from("fo"), path)); // false
+ *
+ * const path2 = Path.from("foobar");
+ * console.log(Path.hasPrefix(Path.from("foo"), path2)); // false
+ * ```
+ */
+export function hasPrefix(prefix, path) {
+    if (prefix === "") {
+        return true;
+    }
+    if (!path.startsWith(prefix)) {
+        return false;
+    }
+    // Check if the prefix is the exact match
+    if (path.length === prefix.length) {
+        return true;
+    }
+    // Otherwise, ensure the character after the prefix is a delimiter
+    return path[prefix.length] === "/";
+}
+/**
+ * Strip the given prefix from a path, returning the suffix.
+ *
+ * Returns null if the prefix doesn't match according to hasPrefix rules.
+ *
+ * @example
+ * ```typescript
+ * const path = Path.from("foo/bar/baz");
+ * const suffix = Path.stripPrefix(Path.from("foo"), path);
+ * console.log(suffix); // "bar/baz"
+ *
+ * const suffix2 = Path.stripPrefix(Path.from("foo/"), path);
+ * console.log(suffix2); // "bar/baz"
+ *
+ * const noMatch = Path.stripPrefix(Path.from("notfound"), path);
+ * console.log(noMatch); // null
+ * ```
+ */
+export function stripPrefix(prefix, path) {
+    if (!hasPrefix(prefix, path)) {
+        return null;
+    }
+    // Handle empty prefix case
+    if (prefix === "") {
+        return path;
+    }
+    // If prefix matches exactly, return empty
+    if (path.length === prefix.length) {
+        return "";
+    }
+    // For non-empty prefix that's shorter, skip the prefix and the following slash
+    return path.slice(prefix.length + 1);
+}
+/**
+ * Join two path components together.
+ *
+ * @example
+ * ```typescript
+ * const base = Path.from("foo");
+ * const joined = Path.join(base, Path.from("bar"));
+ * console.log(joined); // "foo/bar"
+ * ```
+ */
+export function join(path, other) {
+    if (path === "") {
+        return other;
+    }
+    else if (other === "") {
+        return path;
+    }
+    else {
+        // Since paths are trimmed, we always need to add a slash
+        return `${path}/${other}`;
+    }
+}
+/** The empty path, which is a prefix of every path. */
+export function empty() {
+    return "";
+}
+//# sourceMappingURL=path.js.map

package/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../src/path.ts"],"names":[],"mappings":"AAgCA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAE5B,iGAAiG;AACjG,MAAM,UAAU,IAAI,CAAC,GAAG,KAAe;IACtC,4GAA4G;IAC5G,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAU,CAAC;AACrF,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,KAAK,CAAC,IAAW;IAChC,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAC3C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,MAAM,CAAC,GAAW;IACjC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;IACvB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,IAAW;IACjC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,gBAAgB,SAAS,QAAQ,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CAAC,MAAa,EAAE,IAAW;IACnD,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACd,CAAC;IAED,yCAAyC;IACzC,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,kEAAkE;IAClE,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,WAAW,CAAC,MAAa,EAAE,IAAW;IACrD,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,2BAA2B;IAC3B,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,0CAA0C;IAC1C,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,CAAC;QACnC,OAAO,EAAW,CAAC;IACpB,CAAC;IAED,+EAA+E;IAC/E,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAU,CAAC;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,IAAI,CAAC,IAAW,EAAE,KAAY;IAC7C,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACjB,OAAO,KAAK,CAAC;IACd,CAAC;SAAM,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACb,CAAC;SAAM,CAAC;QACP,yDAAyD;QACzD,OAAO,GAAG,IAAI,IAAI,KAAK,EAAW,CAAC;IACpC,CAAC;AACF,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,KAAK;IACpB,OAAO,EAAW,CAAC;AACpB,CAAC","sourcesContent":["/**\n * A broadcast path that provides safe prefix matching operations.\n *\n * This module provides path-aware operations that respect delimiter boundaries,\n * preventing issues like \"foo\" matching \"foobar\".\n *\n * Paths are automatically trimmed of leading and trailing slashes on creation,\n * making all slashes implicit at boundaries.\n * All paths are RELATIVE; you cannot join with a leading slash to make an absolute path.\n *\n * @example\n * ```typescript\n * // Creation automatically trims slashes\n * const path1 = Path.from(\"/foo/bar/\");\n * const path2 = Path.from(\"foo/bar\");\n * console.log(path1 === path2); // true\n *\n * // Multiple arguments are joined with \"/\"\n * const path3 = Path.from(\"api\", \"v1\", \"users\");\n * console.log(path3); // \"api/v1/users\"\n *\n * // Safe prefix matching\n * const base = Path.from(\"api/v1\");\n * console.log(Path.hasPrefix(Path.from(\"api\"), base)); // true\n * console.log(Path.hasPrefix(Path.from(\"api/v1\"), base)); // true\n *\n * const joined = Path.join(base, Path.from(\"users\"));\n * console.log(joined); // \"api/v1/users\"\n * ```\n */\nexport type Valid = string & { __brand: \"Name\" };\n\n/**\n * Maximum number of slash-separated parts in a path.\n *\n * Matches the IETF moq-transport limit of 32 fields in a namespace tuple.\n * moq-lite enforces the same bound when decoding paths off the wire.\n */\nexport const MAX_PARTS = 32;\n\n/** Build a path from one or more components, joining with \"/\" and trimming redundant slashes. */\nexport function from(...paths: string[]): Valid {\n\t// Join paths with \"/\" and then remove leading and trailing slashes, and collapse multiple slashes into one.\n\tconst joined = paths.join(\"/\");\n\treturn joined.replace(/\\/+/g, \"/\").replace(/^\\/+/, \"\").replace(/\\/+$/, \"\") as Valid;\n}\n\n/** Split a path into its slash-separated parts. The empty path has no parts. */\nexport function parts(path: Valid): string[] {\n\treturn path === \"\" ? [] : path.split(\"/\");\n}\n\n/**\n * Validate an untrusted wire string as a path, enforcing {@link MAX_PARTS}.\n *\n * Throws when the path has too many parts; use at wire decode sites.\n */\nexport function decode(raw: string): Valid {\n\tconst path = from(raw);\n\treturn encode(path);\n}\n\n/**\n * Validate a path before writing it to the wire, enforcing {@link MAX_PARTS}.\n *\n * Throws when the path has too many parts; use at wire encode sites so we never\n * emit a path the remote side is required to reject.\n */\nexport function encode(path: Valid): Valid {\n\tif (parts(path).length > MAX_PARTS) {\n\t\tthrow new Error(`path exceeds ${MAX_PARTS} parts`);\n\t}\n\treturn path;\n}\n\n/**\n * Check if a path has the given prefix, respecting path boundaries.\n *\n * Unlike String.startsWith, this ensures that \"foo\" does not match \"foobar\".\n * The prefix must either:\n * - Be exactly equal to the path\n * - Be followed by a '/' delimiter in the original path\n * - Be empty (matches everything)\n *\n * @example\n * ```typescript\n * const path = Path.from(\"foo/bar\");\n * console.log(Path.hasPrefix(Path.from(\"foo\"), path)); // true\n * console.log(Path.hasPrefix(Path.from(\"foo/\"), path)); // true (trailing slash ignored)\n * console.log(Path.hasPrefix(Path.from(\"fo\"), path)); // false\n *\n * const path2 = Path.from(\"foobar\");\n * console.log(Path.hasPrefix(Path.from(\"foo\"), path2)); // false\n * ```\n */\nexport function hasPrefix(prefix: Valid, path: Valid): boolean {\n\tif (prefix === \"\") {\n\t\treturn true;\n\t}\n\n\tif (!path.startsWith(prefix)) {\n\t\treturn false;\n\t}\n\n\t// Check if the prefix is the exact match\n\tif (path.length === prefix.length) {\n\t\treturn true;\n\t}\n\n\t// Otherwise, ensure the character after the prefix is a delimiter\n\treturn path[prefix.length] === \"/\";\n}\n\n/**\n * Strip the given prefix from a path, returning the suffix.\n *\n * Returns null if the prefix doesn't match according to hasPrefix rules.\n *\n * @example\n * ```typescript\n * const path = Path.from(\"foo/bar/baz\");\n * const suffix = Path.stripPrefix(Path.from(\"foo\"), path);\n * console.log(suffix); // \"bar/baz\"\n *\n * const suffix2 = Path.stripPrefix(Path.from(\"foo/\"), path);\n * console.log(suffix2); // \"bar/baz\"\n *\n * const noMatch = Path.stripPrefix(Path.from(\"notfound\"), path);\n * console.log(noMatch); // null\n * ```\n */\nexport function stripPrefix(prefix: Valid, path: Valid): Valid | null {\n\tif (!hasPrefix(prefix, path)) {\n\t\treturn null;\n\t}\n\n\t// Handle empty prefix case\n\tif (prefix === \"\") {\n\t\treturn path;\n\t}\n\n\t// If prefix matches exactly, return empty\n\tif (path.length === prefix.length) {\n\t\treturn \"\" as Valid;\n\t}\n\n\t// For non-empty prefix that's shorter, skip the prefix and the following slash\n\treturn path.slice(prefix.length + 1) as Valid;\n}\n\n/**\n * Join two path components together.\n *\n * @example\n * ```typescript\n * const base = Path.from(\"foo\");\n * const joined = Path.join(base, Path.from(\"bar\"));\n * console.log(joined); // \"foo/bar\"\n * ```\n */\nexport function join(path: Valid, other: Valid): Valid {\n\tif (path === \"\") {\n\t\treturn other;\n\t} else if (other === \"\") {\n\t\treturn path;\n\t} else {\n\t\t// Since paths are trimmed, we always need to add a slash\n\t\treturn `${path}/${other}` as Valid;\n\t}\n}\n\n/** The empty path, which is a prefix of every path. */\nexport function empty(): Valid {\n\treturn \"\" as Valid;\n}\n"]}

package/path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path.test.d.ts.map

package/path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.test.d.ts","sourceRoot":"","sources":["../src/path.test.ts"],"names":[],"mappings":""}

package/path.test.js

@@ -0,0 +1,169 @@
+/* @ts-self-types="./path.test.d.ts" */
+import { expect, test } from "bun:test";
+import * as Path from "./path.js";
+test("Path constructor trims leading and trailing slashes", () => {
+    expect(Path.from("/foo/bar/")).toBe("foo/bar");
+    expect(Path.from("///foo/bar///")).toBe("foo/bar");
+    expect(Path.from("foo/bar")).toBe("foo/bar");
+});
+test("Path constructor handles empty paths", () => {
+    expect(Path.from("")).toBe("");
+    expect(Path.from("/")).toBe("");
+    expect(Path.from("///")).toBe("");
+});
+test("hasPrefix matches exact paths", () => {
+    const path = Path.from("foo/bar");
+    expect(Path.hasPrefix(Path.from("foo/bar"), path)).toBe(true);
+});
+test("hasPrefix matches proper prefixes", () => {
+    const path = Path.from("foo/bar/baz");
+    expect(Path.hasPrefix(Path.from("foo"), path)).toBe(true);
+    expect(Path.hasPrefix(Path.from("foo/bar"), path)).toBe(true);
+});
+test("hasPrefix does not match partial segment prefixes", () => {
+    const path = Path.from("foobar");
+    expect(Path.hasPrefix(Path.from("foo"), path)).toBe(false);
+    const path2 = Path.from("foo/bar");
+    expect(Path.hasPrefix(Path.from("fo"), path2)).toBe(false);
+});
+test("hasPrefix handles empty prefix", () => {
+    const path = Path.from("foo/bar");
+    expect(Path.hasPrefix(Path.empty(), path)).toBe(true);
+});
+test("hasPrefix ignores trailing slashes in prefix", () => {
+    const path = Path.from("foo/bar");
+    expect(Path.hasPrefix(Path.from("foo/"), path)).toBe(true);
+    expect(Path.hasPrefix(Path.from("foo/bar/"), path)).toBe(true);
+});
+test("stripPrefix strips valid prefixes", () => {
+    const path = Path.from("foo/bar/baz");
+    const suffix1 = Path.stripPrefix(Path.from("foo"), path);
+    expect(suffix1).toBe("bar/baz");
+    const suffix2 = Path.stripPrefix(Path.from("foo/bar"), path);
+    expect(suffix2).toBe("baz");
+    const suffix3 = Path.stripPrefix(Path.from("foo/bar/baz"), path);
+    expect(suffix3).toBe("");
+});
+test("stripPrefix returns null for invalid prefixes", () => {
+    const path = Path.from("foo/bar");
+    expect(Path.stripPrefix(Path.from("notfound"), path)).toBe(null);
+    expect(Path.stripPrefix(Path.from("fo"), path)).toBe(null);
+});
+test("stripPrefix handles empty prefix", () => {
+    const path = Path.from("foo/bar");
+    const result = Path.stripPrefix(Path.empty(), path);
+    expect(result).toBe("foo/bar");
+});
+test("stripPrefix accepts Path instances", () => {
+    const path = Path.from("foo/bar/baz");
+    const prefix = Path.from("foo/bar");
+    const result = Path.stripPrefix(prefix, path);
+    expect(result).toBe("baz");
+});
+test("join paths with slashes", () => {
+    const base = Path.from("foo");
+    const joined = Path.join(base, Path.from("bar"));
+    expect(joined).toBe("foo/bar");
+});
+test("join handles empty base", () => {
+    const base = Path.empty();
+    const joined = Path.join(base, Path.from("bar"));
+    expect(joined).toBe("bar");
+});
+test("join handles empty suffix", () => {
+    const base = Path.from("foo");
+    const joined = Path.join(base, Path.empty());
+    expect(joined).toBe("foo");
+});
+test("join accepts Path instances", () => {
+    const base = Path.from("foo");
+    const suffix = Path.from("bar");
+    const joined = Path.join(base, suffix);
+    expect(joined).toBe("foo/bar");
+});
+test("join handles multiple joins", () => {
+    const path = Path.join(Path.join(Path.join(Path.from("api"), Path.from("v1")), Path.from("users")), Path.from("123"));
+    expect(path).toBe("api/v1/users/123");
+});
+test("isEmpty checks correctly", () => {
+    expect(Path.from("") === "").toBe(true);
+    expect(Path.from("foo") === "").toBe(false);
+    expect(Path.empty() === "").toBe(true);
+});
+test("length property works correctly", () => {
+    expect(Path.from("foo").length).toBe(3);
+    expect(Path.from("foo/bar").length).toBe(7);
+    expect(Path.empty().length).toBe(0);
+});
+test("equals checks correctly", () => {
+    const path1 = Path.from("foo/bar");
+    const path2 = Path.from("/foo/bar/");
+    const path3 = Path.from("foo/baz");
+    expect(path1 === path2).toBe(true);
+    expect(path1 === path3).toBe(false);
+});
+test("JSON serialization works", () => {
+    const path = Path.from("foo/bar");
+    expect(JSON.stringify(path)).toBe('"foo/bar"');
+});
+test("handles paths with multiple consecutive slashes", () => {
+    const path = Path.from("foo//bar///baz");
+    // Multiple consecutive slashes are collapsed to single slashes
+    expect(path).toBe("foo/bar/baz");
+});
+test("removes multiple slashes comprehensively", () => {
+    // Test various multiple slash scenarios
+    expect(Path.from("foo//bar")).toBe("foo/bar");
+    expect(Path.from("foo///bar")).toBe("foo/bar");
+    expect(Path.from("foo////bar")).toBe("foo/bar");
+    // Multiple occurrences of double slashes
+    expect(Path.from("foo//bar//baz")).toBe("foo/bar/baz");
+    expect(Path.from("a//b//c//d")).toBe("a/b/c/d");
+    // Mixed slash counts
+    expect(Path.from("foo//bar///baz////qux")).toBe("foo/bar/baz/qux");
+    // With leading and trailing slashes
+    expect(Path.from("//foo//bar//")).toBe("foo/bar");
+    expect(Path.from("///foo///bar///")).toBe("foo/bar");
+    // Edge case: only slashes
+    expect(Path.from("//")).toBe("");
+    expect(Path.from("////")).toBe("");
+    // Test that operations work correctly with normalized paths
+    const pathWithSlashes = Path.from("foo//bar///baz");
+    expect(Path.hasPrefix(Path.from("foo/bar"), pathWithSlashes)).toBe(true);
+    expect(Path.stripPrefix(Path.from("foo"), pathWithSlashes)).toBe("bar/baz");
+    expect(Path.join(pathWithSlashes, Path.from("qux"))).toBe("foo/bar/baz/qux");
+});
+test("handles special characters", () => {
+    const path = Path.from("foo-bar_baz.txt");
+    expect(path).toBe("foo-bar_baz.txt");
+    expect(Path.hasPrefix(Path.from("foo-bar"), path)).toBe(false);
+    expect(Path.hasPrefix(Path.from("foo-bar_baz.txt"), path)).toBe(true);
+});
+test("from accepts multiple arguments", () => {
+    expect(Path.from("foo", "bar", "baz")).toBe("foo/bar/baz");
+    expect(Path.from("api", "v1", "users")).toBe("api/v1/users");
+});
+test("from handles empty strings in arguments", () => {
+    expect(Path.from("foo", "", "bar")).toBe("foo/bar");
+    expect(Path.from("", "foo", "bar", "")).toBe("foo/bar");
+});
+test("from sanitizes multiple arguments with slashes", () => {
+    expect(Path.from("/foo/", "/bar/", "/baz/")).toBe("foo/bar/baz");
+    expect(Path.from("foo//", "//bar", "baz")).toBe("foo/bar/baz");
+});
+test("parts splits a path into its components", () => {
+    expect(Path.parts(Path.from(""))).toEqual([]);
+    expect(Path.parts(Path.from("foo"))).toEqual(["foo"]);
+    expect(Path.parts(Path.from("/foo//bar/"))).toEqual(["foo", "bar"]);
+});
+test("decode enforces the max part count", () => {
+    const atLimit = Array.from({ length: Path.MAX_PARTS }, (_, i) => `${i}`).join("/");
+    expect(Path.decode(atLimit)).toBe(atLimit);
+    expect(() => Path.decode(`${atLimit}/extra`)).toThrow();
+});
+test("encode enforces the max part count", () => {
+    const atLimit = Array.from({ length: Path.MAX_PARTS }, (_, i) => `${i}`).join("/");
+    expect(Path.encode(atLimit)).toBe(atLimit);
+    expect(() => Path.encode(`${atLimit}/extra`)).toThrow();
+});
+//# sourceMappingURL=path.test.js.map