@norskvideo/moq-net 0.1.2 → 0.1.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@norskvideo/moq-net",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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",
@@ -17,11 +17,13 @@
     }
   },
   "dependencies": {
-    "@moq/qmux": "^0.1.3",
+    "@moq/qmux": "^0.3.3",
     "async-mutex": "^0.5.0",
-    "@norskvideo/moq-signals": "^0.1.2"
+    "bowser": "^2.14.1",
+    "@norskvideo/moq-signals": "^0.1.4"
   },
   "peerDependencies": {
-    "zod": "^4.0.0"
+    "@zod/mini": "^4.5.0",
+    "zod": "^4.5.0"
   }
 }

package/path.d.ts

@@ -108,4 +108,71 @@ export declare function stripPrefix(prefix: Valid, path: Valid): Valid | null;
 export declare function join(path: Valid, other: Valid): Valid;
 /** The empty path, which is a prefix of every path. */
 export declare function empty(): Valid;
+/**
+ * Normalize a relative path reference: trim leading/trailing slashes, drop empty
+ * segments, and drop redundant `.` segments. A reference made only of `.` segments
+ * normalizes to `.` because it names the base's parent, while empty names the base.
+ * `..` is preserved and only interpreted by {@link resolve}.
+ *
+ * Mirrors the Rust `PathRelative::new` normalization, so JS and Rust agree
+ * byte-for-byte on the stored form. Two callers comparing normalized strings can
+ * detect equivalent references while preserving the distinction between `""` and `"."`.
+ */
+export declare function normalizeRelative(rel: string): string;
+/**
+ * Resolve a relative path reference against a base path.
+ *
+ * A non-empty reference replaces the last segment of the base, matching relative URL
+ * resolution. `..` segments then pop another segment; other segments are appended.
+ * `.` and empty segments are no-ops. Excess `..` once the base is empty is also a no-op
+ * (subsequent named segments still append). An empty `rel` returns the base unchanged.
+ *
+ * Mirrors the Rust `Path::resolve`, used by hang catalogs to express
+ * cross-broadcast track references (a rendition's `broadcast` field).
+ *
+ * @example
+ * ```typescript
+ * Path.resolve(Path.from("a/b/c"), "./source");  // "a/b/source"
+ * Path.resolve(Path.from("a/b"), ".");           // "a"
+ * Path.resolve(Path.from("a/b/c"), "../source"); // "a/source"
+ * ```
+ */
+export declare function resolve(base: Valid, rel: string): Valid;
+/**
+ * Resolve a relative path, returning `undefined` if it escapes above the root.
+ *
+ * Unlike {@link resolve}, this distinguishes a valid reference to the empty root
+ * path from excess `..` segments. Use it for untrusted catalog references that
+ * must not be clamped to the root.
+ */
+export declare function tryResolve(base: Valid, rel: string): Valid | undefined;
+/**
+ * Express `target` relative to `base`: the inverse of {@link resolve}.
+ *
+ * The result round-trips (`resolve(base, relative(target, base)) === target`) and never
+ * walks above the root, so {@link tryResolve} accepts it too.
+ *
+ * A relative reference replaces the last segment of the base, matching relative URL
+ * resolution, so a target nested under the base repeats the base's own last segment.
+ *
+ * The empty reference names the base itself, so that is what a self-reference returns.
+ *
+ * Returns `undefined` for a target no reference can name: a path segment may literally be
+ * `.` or `..`, which resolution reads as navigation instead of as a name. Only the segments
+ * past the shared prefix matter, since the rest are never emitted.
+ *
+ * Mirrors the Rust `Path::relative`, used to author the cross-broadcast track
+ * references a hang catalog carries. Note the argument order: the target comes first,
+ * the opposite of Node's `path.relative(from, to)`.
+ *
+ * @example
+ * ```typescript
+ * Path.relative(Path.from("a/b/c"), Path.from("a/b")); // "b/c"
+ * Path.relative(Path.from("a/c"), Path.from("a/b"));   // "c"
+ * Path.relative(Path.from("a"), Path.from("a/b"));     // "."
+ * Path.relative(Path.from("a/b"), Path.from("a/b"));   // ""
+ * Path.relative(Path.from("a/.."), Path.from("a/b"));  // undefined
+ * ```
+ */
+export declare function relative(target: Valid, base: Valid): string | undefined;
 //# sourceMappingURL=path.d.ts.map

package/path.d.ts.map

@@ -1 +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"}
+{"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;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,CAkBvD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAkBtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,CA0BvE"}

package/path.js

@@ -130,4 +130,132 @@ export function join(path, other) {
 export function empty() {
     return "";
 }
+/**
+ * Normalize a relative path reference: trim leading/trailing slashes, drop empty
+ * segments, and drop redundant `.` segments. A reference made only of `.` segments
+ * normalizes to `.` because it names the base's parent, while empty names the base.
+ * `..` is preserved and only interpreted by {@link resolve}.
+ *
+ * Mirrors the Rust `PathRelative::new` normalization, so JS and Rust agree
+ * byte-for-byte on the stored form. Two callers comparing normalized strings can
+ * detect equivalent references while preserving the distinction between `""` and `"."`.
+ */
+export function normalizeRelative(rel) {
+    const raw = rel.split("/");
+    const normalized = raw.filter((s) => s !== "" && s !== ".").join("/");
+    return normalized === "" && raw.includes(".") ? "." : normalized;
+}
+/**
+ * Resolve a relative path reference against a base path.
+ *
+ * A non-empty reference replaces the last segment of the base, matching relative URL
+ * resolution. `..` segments then pop another segment; other segments are appended.
+ * `.` and empty segments are no-ops. Excess `..` once the base is empty is also a no-op
+ * (subsequent named segments still append). An empty `rel` returns the base unchanged.
+ *
+ * Mirrors the Rust `Path::resolve`, used by hang catalogs to express
+ * cross-broadcast track references (a rendition's `broadcast` field).
+ *
+ * @example
+ * ```typescript
+ * Path.resolve(Path.from("a/b/c"), "./source");  // "a/b/source"
+ * Path.resolve(Path.from("a/b"), ".");           // "a"
+ * Path.resolve(Path.from("a/b/c"), "../source"); // "a/source"
+ * ```
+ */
+export function resolve(base, rel) {
+    if (rel === "")
+        return base;
+    const segments = base === "" ? [] : base.split("/");
+    segments.pop();
+    for (const seg of rel.split("/")) {
+        if (seg === "" || seg === ".") {
+            continue;
+        }
+        if (seg === "..") {
+            segments.pop();
+        }
+        else {
+            segments.push(seg);
+        }
+    }
+    return segments.join("/");
+}
+/**
+ * Resolve a relative path, returning `undefined` if it escapes above the root.
+ *
+ * Unlike {@link resolve}, this distinguishes a valid reference to the empty root
+ * path from excess `..` segments. Use it for untrusted catalog references that
+ * must not be clamped to the root.
+ */
+export function tryResolve(base, rel) {
+    if (rel === "")
+        return base;
+    const segments = base === "" ? [] : base.split("/");
+    segments.pop();
+    for (const seg of rel.split("/")) {
+        if (seg === "" || seg === ".") {
+            continue;
+        }
+        if (seg === "..") {
+            if (segments.pop() === undefined)
+                return undefined;
+        }
+        else {
+            segments.push(seg);
+        }
+    }
+    return segments.join("/");
+}
+/**
+ * Express `target` relative to `base`: the inverse of {@link resolve}.
+ *
+ * The result round-trips (`resolve(base, relative(target, base)) === target`) and never
+ * walks above the root, so {@link tryResolve} accepts it too.
+ *
+ * A relative reference replaces the last segment of the base, matching relative URL
+ * resolution, so a target nested under the base repeats the base's own last segment.
+ *
+ * The empty reference names the base itself, so that is what a self-reference returns.
+ *
+ * Returns `undefined` for a target no reference can name: a path segment may literally be
+ * `.` or `..`, which resolution reads as navigation instead of as a name. Only the segments
+ * past the shared prefix matter, since the rest are never emitted.
+ *
+ * Mirrors the Rust `Path::relative`, used to author the cross-broadcast track
+ * references a hang catalog carries. Note the argument order: the target comes first,
+ * the opposite of Node's `path.relative(from, to)`.
+ *
+ * @example
+ * ```typescript
+ * Path.relative(Path.from("a/b/c"), Path.from("a/b")); // "b/c"
+ * Path.relative(Path.from("a/c"), Path.from("a/b"));   // "c"
+ * Path.relative(Path.from("a"), Path.from("a/b"));     // "."
+ * Path.relative(Path.from("a/b"), Path.from("a/b"));   // ""
+ * Path.relative(Path.from("a/.."), Path.from("a/b"));  // undefined
+ * ```
+ */
+export function relative(target, base) {
+    // Only the empty reference can name a base whose last segment is itself `.` or `..`,
+    // since resolution replaces that segment rather than emitting it.
+    if (target === base)
+        return "";
+    // Resolution replaces the base's last segment, so walk from its parent.
+    const dir = base === "" ? [] : base.split("/");
+    dir.pop();
+    const parts = target === "" ? [] : target.split("/");
+    let common = 0;
+    while (common < dir.length && common < parts.length && dir[common] === parts[common]) {
+        common += 1;
+    }
+    const down = parts.slice(common);
+    // Resolution would walk on these instead of naming them.
+    if (down.some((part) => part === "." || part === ".."))
+        return undefined;
+    const rel = Array(dir.length - common)
+        .fill("..")
+        .concat(down);
+    // An empty reference resolves to the base itself, so name the parent explicitly.
+    return rel.length === 0 ? "." : rel.join("/");
+}
 //# sourceMappingURL=path.js.map

package/path.js.map

@@ -1 +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"]}
+{"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;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAW;IAC5C,MAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEtE,OAAO,UAAU,KAAK,EAAE,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,OAAO,CAAC,IAAW,EAAE,GAAW;IAC/C,IAAI,GAAG,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAE5B,MAAM,QAAQ,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACpD,QAAQ,CAAC,GAAG,EAAE,CAAC;IAEf,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAClC,IAAI,GAAG,KAAK,EAAE,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;YAC/B,SAAS;QACV,CAAC;QACD,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAClB,QAAQ,CAAC,GAAG,EAAE,CAAC;QAChB,CAAC;aAAM,CAAC;YACP,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAU,CAAC;AACpC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,IAAW,EAAE,GAAW;IAClD,IAAI,GAAG,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAE5B,MAAM,QAAQ,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACpD,QAAQ,CAAC,GAAG,EAAE,CAAC;IAEf,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAClC,IAAI,GAAG,KAAK,EAAE,IAAI,GAAG,KAAK,GAAG,EAAE,CAAC;YAC/B,SAAS;QACV,CAAC;QACD,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAClB,IAAI,QAAQ,CAAC,GAAG,EAAE,KAAK,SAAS;gBAAE,OAAO,SAAS,CAAC;QACpD,CAAC;aAAM,CAAC;YACP,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAU,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAa,EAAE,IAAW;IAClD,qFAAqF;IACrF,kEAAkE;IAClE,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IAE/B,wEAAwE;IACxE,MAAM,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/C,GAAG,CAAC,GAAG,EAAE,CAAC;IAEV,MAAM,KAAK,GAAG,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAErD,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,OAAO,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACtF,MAAM,IAAI,CAAC,CAAC;IACb,CAAC;IAED,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC,yDAAyD;IACzD,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,IAAI,CAAC;QAAE,OAAO,SAAS,CAAC;IAEzE,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;SACpC,IAAI,CAAC,IAAI,CAAC;SACV,MAAM,CAAC,IAAI,CAAC,CAAC;IAEf,iFAAiF;IACjF,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,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\n/**\n * Normalize a relative path reference: trim leading/trailing slashes, drop empty\n * segments, and drop redundant `.` segments. A reference made only of `.` segments\n * normalizes to `.` because it names the base's parent, while empty names the base.\n * `..` is preserved and only interpreted by {@link resolve}.\n *\n * Mirrors the Rust `PathRelative::new` normalization, so JS and Rust agree\n * byte-for-byte on the stored form. Two callers comparing normalized strings can\n * detect equivalent references while preserving the distinction between `\"\"` and `\".\"`.\n */\nexport function normalizeRelative(rel: string): string {\n\tconst raw = rel.split(\"/\");\n\tconst normalized = raw.filter((s) => s !== \"\" && s !== \".\").join(\"/\");\n\n\treturn normalized === \"\" && raw.includes(\".\") ? \".\" : normalized;\n}\n\n/**\n * Resolve a relative path reference against a base path.\n *\n * A non-empty reference replaces the last segment of the base, matching relative URL\n * resolution. `..` segments then pop another segment; other segments are appended.\n * `.` and empty segments are no-ops. Excess `..` once the base is empty is also a no-op\n * (subsequent named segments still append). An empty `rel` returns the base unchanged.\n *\n * Mirrors the Rust `Path::resolve`, used by hang catalogs to express\n * cross-broadcast track references (a rendition's `broadcast` field).\n *\n * @example\n * ```typescript\n * Path.resolve(Path.from(\"a/b/c\"), \"./source\");  // \"a/b/source\"\n * Path.resolve(Path.from(\"a/b\"), \".\");           // \"a\"\n * Path.resolve(Path.from(\"a/b/c\"), \"../source\"); // \"a/source\"\n * ```\n */\nexport function resolve(base: Valid, rel: string): Valid {\n\tif (rel === \"\") return base;\n\n\tconst segments = base === \"\" ? [] : base.split(\"/\");\n\tsegments.pop();\n\n\tfor (const seg of rel.split(\"/\")) {\n\t\tif (seg === \"\" || seg === \".\") {\n\t\t\tcontinue;\n\t\t}\n\t\tif (seg === \"..\") {\n\t\t\tsegments.pop();\n\t\t} else {\n\t\t\tsegments.push(seg);\n\t\t}\n\t}\n\n\treturn segments.join(\"/\") as Valid;\n}\n\n/**\n * Resolve a relative path, returning `undefined` if it escapes above the root.\n *\n * Unlike {@link resolve}, this distinguishes a valid reference to the empty root\n * path from excess `..` segments. Use it for untrusted catalog references that\n * must not be clamped to the root.\n */\nexport function tryResolve(base: Valid, rel: string): Valid | undefined {\n\tif (rel === \"\") return base;\n\n\tconst segments = base === \"\" ? [] : base.split(\"/\");\n\tsegments.pop();\n\n\tfor (const seg of rel.split(\"/\")) {\n\t\tif (seg === \"\" || seg === \".\") {\n\t\t\tcontinue;\n\t\t}\n\t\tif (seg === \"..\") {\n\t\t\tif (segments.pop() === undefined) return undefined;\n\t\t} else {\n\t\t\tsegments.push(seg);\n\t\t}\n\t}\n\n\treturn segments.join(\"/\") as Valid;\n}\n\n/**\n * Express `target` relative to `base`: the inverse of {@link resolve}.\n *\n * The result round-trips (`resolve(base, relative(target, base)) === target`) and never\n * walks above the root, so {@link tryResolve} accepts it too.\n *\n * A relative reference replaces the last segment of the base, matching relative URL\n * resolution, so a target nested under the base repeats the base's own last segment.\n *\n * The empty reference names the base itself, so that is what a self-reference returns.\n *\n * Returns `undefined` for a target no reference can name: a path segment may literally be\n * `.` or `..`, which resolution reads as navigation instead of as a name. Only the segments\n * past the shared prefix matter, since the rest are never emitted.\n *\n * Mirrors the Rust `Path::relative`, used to author the cross-broadcast track\n * references a hang catalog carries. Note the argument order: the target comes first,\n * the opposite of Node's `path.relative(from, to)`.\n *\n * @example\n * ```typescript\n * Path.relative(Path.from(\"a/b/c\"), Path.from(\"a/b\")); // \"b/c\"\n * Path.relative(Path.from(\"a/c\"), Path.from(\"a/b\"));   // \"c\"\n * Path.relative(Path.from(\"a\"), Path.from(\"a/b\"));     // \".\"\n * Path.relative(Path.from(\"a/b\"), Path.from(\"a/b\"));   // \"\"\n * Path.relative(Path.from(\"a/..\"), Path.from(\"a/b\"));  // undefined\n * ```\n */\nexport function relative(target: Valid, base: Valid): string | undefined {\n\t// Only the empty reference can name a base whose last segment is itself `.` or `..`,\n\t// since resolution replaces that segment rather than emitting it.\n\tif (target === base) return \"\";\n\n\t// Resolution replaces the base's last segment, so walk from its parent.\n\tconst dir = base === \"\" ? [] : base.split(\"/\");\n\tdir.pop();\n\n\tconst parts = target === \"\" ? [] : target.split(\"/\");\n\n\tlet common = 0;\n\twhile (common < dir.length && common < parts.length && dir[common] === parts[common]) {\n\t\tcommon += 1;\n\t}\n\n\tconst down = parts.slice(common);\n\t// Resolution would walk on these instead of naming them.\n\tif (down.some((part) => part === \".\" || part === \"..\")) return undefined;\n\n\tconst rel = Array(dir.length - common)\n\t\t.fill(\"..\")\n\t\t.concat(down);\n\n\t// An empty reference resolves to the base itself, so name the parent explicitly.\n\treturn rel.length === 0 ? \".\" : rel.join(\"/\");\n}\n"]}

package/stream.d.ts

@@ -1,16 +1,80 @@
 import type { IetfVersion } from "./ietf/version";
+/**
+ * Options handed to the transport for one outgoing stream.
+ *
+ * `waitUntilAvailable` waits for the peer's concurrent stream limit to free a slot instead
+ * of rejecting with a `QuotaExceededError`, which is what we want for the streams a session
+ * opens occasionally. `@types/web` doesn't declare it yet, hence the intersection.
+ */
+export declare function sendOptions(options?: OpenOptions): WebTransportSendStreamOptions & {
+    waitUntilAvailable?: boolean;
+};
+/**
+ * The `WebTransportSendStream` that every outgoing stream is, narrowed to the one attribute
+ * this package uses. The DOM types available here still describe them as plain
+ * `WritableStream`s, so the interface has to be named structurally.
+ *
+ * `sendOrder` is optional because it is absent until set, and stays absent on an
+ * implementation that doesn't carry the interface at all.
+ *
+ * @see https://www.w3.org/TR/webtransport/#webtransportsendstream
+ */
+export type SendStream = WritableStream<Uint8Array> & {
+    sendOrder?: number;
+};
+/** Options for opening an outgoing stream. */
+export interface OpenOptions {
+    /** The negotiated IETF version, which selects the varint encoding. */
+    version?: IetfVersion;
+    /**
+     * The transport send order, where HIGHER values are transmitted first.
+     * Left to the transport's default when unset.
+     */
+    sendOrder?: number;
+    /**
+     * Reject if the peer hasn't freed a stream slot within this many milliseconds. Defaults
+     * to 10s. There is no way to wait indefinitely: a peer can advertise a stream limit of
+     * zero and never raise it, so every open needs a way out.
+     */
+    timeout?: number;
+    /**
+     * Ask the transport to wait for a stream slot rather than failing when the peer's
+     * concurrent stream limit is exhausted. Defaults to true.
+     *
+     * Set it false on a path that opens streams faster than the peer can retire them. The
+     * transport queues the opens it can't satisfy and serves them in order, with no way to
+     * cancel one, so waiting there spends returning credit on whatever was requested first
+     * rather than on what matters now.
+     */
+    waitUntilAvailable?: boolean;
+}
+/** Options for {@link Writer.tryOpen}. */
+export interface TryOpenOptions extends OpenOptions {
+    /** Give up once this settles, however it settles. */
+    cancel: Promise<unknown>;
+}
 export declare class Stream {
     reader: Reader;
     writer: Writer;
+    /** Wrap the two halves of a transport stream. */
     constructor(props: {
         writable: WritableStream<Uint8Array>;
         readable: ReadableStream<Uint8Array>;
-        writer?: Writer;
-        reader?: Reader;
         version?: IetfVersion;
     });
+    /** Pair halves that were opened separately, as the SETUP exchange does. */
+    constructor(props: {
+        writer: Writer;
+        reader: Reader;
+    });
     static accept(quic: WebTransport, version?: IetfVersion): Promise<Stream | undefined>;
-    static open(quic: WebTransport, version?: IetfVersion, priority?: number): Promise<Stream>;
+    /**
+     * Open an outgoing bidirectional stream.
+     * @param quic - The session to open it on
+     * @param options - The version its varints encode with, and the send order ranking it
+     *   against the session's other streams
+     */
+    static open(quic: WebTransport, options?: OpenOptions): Promise<Stream>;
     close(): void;
     abort(reason: Error): void;
 }
@@ -35,6 +99,17 @@ export declare class Writer {
     #private;
     version?: IetfVersion;
     constructor(stream: WritableStream<Uint8Array>, version?: IetfVersion);
+    /**
+     * Rank this stream against the session's others, where HIGHER values are sent first.
+     *
+     * A send order only schedules the local end, so a stream the peer opened has to be ranked
+     * here rather than at the peer's {@link open}.
+     *
+     * The spec makes `sendOrder` a settable attribute on every {@link SendStream}. Where the
+     * interface isn't implemented (Chrome as of writing, a mock, a polyfill) this just sets an
+     * ignored property, the same way an ignored `sendOrder` option does at {@link open}.
+     */
+    setPriority(sendOrder: number): void;
     bool(v: boolean): Promise<void>;
     u8(v: number): Promise<void>;
     u16(v: number): Promise<void>;
@@ -46,7 +121,22 @@ export declare class Writer {
     close(): void;
     get closed(): Promise<void>;
     reset(reason: unknown): void;
-    static open(quic: WebTransport, version?: IetfVersion): Promise<Writer>;
+    /**
+     * Open an outgoing unidirectional stream.
+     * @param quic - The session to open it on
+     * @param options - The version its varints encode with, and the send order ranking it
+     *   against the session's other streams
+     */
+    static open(quic: WebTransport, options?: OpenOptions): Promise<Writer>;
+    /**
+     * Like {@link Writer.open}, but gives up when `cancel` settles or `timeout` elapses,
+     * returning undefined so the caller can drop whatever it meant to send. A stream that
+     * opens after that is reset rather than leaked. A real transport failure still throws.
+     *
+     * Worth using even with `waitUntilAvailable: false`, since an implementation may park
+     * an over-limit open instead of rejecting it.
+     */
+    static tryOpen(quic: WebTransport, options: TryOpenOptions): Promise<Writer | undefined>;
 }
 export declare class Readers {
     #private;

package/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}