@norskvideo/moq-hang 0.1.0

package/catalog/producer.d.ts

@@ -0,0 +1,31 @@
+import * as Json from "@norskvideo/moq-json";
+import type * as z from "zod/mini";
+import { type Root } from "./root";
+/** Options for a catalog {@link Producer}. */
+export interface Config<T extends Root = Root> {
+    /** zod schema validating each catalog before publish. Defaults to {@link RootSchema}. */
+    schema?: z.ZodMiniType<T>;
+    /**
+     * Delta encoding ratio forwarded to the underlying JSON producer.
+     *
+     * Defaults to `0`, which disables deltas: every change publishes a full snapshot in its own
+     * group, keeping the catalog byte-compatible with snapshot-only consumers. Note this overrides
+     * the `@norskvideo/moq-json` producer's own default ratio. Set a positive number to enable JSON Merge Patch
+     * deltas.
+     */
+    deltaRatio?: number;
+}
+/**
+ * Publishes a {@link Root} catalog, fanning it out to every subscriber (including relays that
+ * reconnect).
+ *
+ * A thin wrapper around a track-less `@norskvideo/moq-json` producer, pre-seeded with an empty catalog and
+ * wired to {@link RootSchema}. Edit it at any time with `mutate` and answer subscription requests
+ * with `serve`. Extend the catalog by passing a schema built via `z.extend(RootSchema, ...)` and
+ * writing the extra sections in `mutate`.
+ */
+export declare class Producer<T extends Root = Root> extends Json.Snapshot.Producer<T> {
+    /** Create a track-less catalog producer seeded with an empty catalog. */
+    constructor(config?: Config<T>);
+}
+//# sourceMappingURL=producer.d.ts.map

package/catalog/producer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"producer.d.ts","sourceRoot":"","sources":["../../src/catalog/producer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,KAAK,CAAC,MAAM,UAAU,CAAC;AAEnC,OAAO,EAAE,KAAK,IAAI,EAAc,MAAM,WAAW,CAAC;AAElD,8CAA8C;AAC9C,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI;IAC5C,yFAAyF;IACzF,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAE1B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,CAAE,SAAQ,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC7E,yEAAyE;IACzE,YAAY,MAAM,GAAE,MAAM,CAAC,CAAC,CAAM,EAQjC;CACD"}

package/catalog/producer.js

@@ -0,0 +1,25 @@
+/* @ts-self-types="./producer.d.ts" */
+import * as Json from "@norskvideo/moq-json";
+import { RootSchema } from "./root.js";
+/**
+ * Publishes a {@link Root} catalog, fanning it out to every subscriber (including relays that
+ * reconnect).
+ *
+ * A thin wrapper around a track-less `@norskvideo/moq-json` producer, pre-seeded with an empty catalog and
+ * wired to {@link RootSchema}. Edit it at any time with `mutate` and answer subscription requests
+ * with `serve`. Extend the catalog by passing a schema built via `z.extend(RootSchema, ...)` and
+ * writing the extra sections in `mutate`.
+ */
+export class Producer extends Json.Snapshot.Producer {
+    /** Create a track-less catalog producer seeded with an empty catalog. */
+    constructor(config = {}) {
+        super({
+            initial: {},
+            schema: (config.schema ?? RootSchema),
+            // Pin deltas off by default (the @moq/json default would enable them); pass a positive
+            // ratio to opt in.
+            deltaRatio: config.deltaRatio ?? 0,
+        });
+    }
+}
+//# sourceMappingURL=producer.js.map

package/catalog/producer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"producer.js","sourceRoot":"","sources":["../../src/catalog/producer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAGlC,OAAO,EAAa,UAAU,EAAE,MAAM,WAAW,CAAC;AAkBlD;;;;;;;;GAQG;AACH,MAAM,OAAO,QAAgC,SAAQ,IAAI,CAAC,QAAQ,CAAC,QAAW;IAC7E,yEAAyE;IACzE,YAAY,MAAM,GAAc,EAAE;QACjC,KAAK,CAAC;YACL,OAAO,EAAE,EAAO;YAChB,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,IAAI,UAAU,CAAqB;YACzD,uFAAuF;YACvF,mBAAmB;YACnB,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,CAAC;SAClC,CAAC,CAAC;IACJ,CAAC;CACD","sourcesContent":["import * as Json from \"@moq/json\";\nimport type * as z from \"zod/mini\";\n\nimport { type Root, RootSchema } from \"./root.ts\";\n\n/** Options for a catalog {@link Producer}. */\nexport interface Config<T extends Root = Root> {\n\t/** zod schema validating each catalog before publish. Defaults to {@link RootSchema}. */\n\tschema?: z.ZodMiniType<T>;\n\n\t/**\n\t * Delta encoding ratio forwarded to the underlying JSON producer.\n\t *\n\t * Defaults to `0`, which disables deltas: every change publishes a full snapshot in its own\n\t * group, keeping the catalog byte-compatible with snapshot-only consumers. Note this overrides\n\t * the `@moq/json` producer's own default ratio. Set a positive number to enable JSON Merge Patch\n\t * deltas.\n\t */\n\tdeltaRatio?: number;\n}\n\n/**\n * Publishes a {@link Root} catalog, fanning it out to every subscriber (including relays that\n * reconnect).\n *\n * A thin wrapper around a track-less `@moq/json` producer, pre-seeded with an empty catalog and\n * wired to {@link RootSchema}. Edit it at any time with `mutate` and answer subscription requests\n * with `serve`. Extend the catalog by passing a schema built via `z.extend(RootSchema, ...)` and\n * writing the extra sections in `mutate`.\n */\nexport class Producer<T extends Root = Root> extends Json.Snapshot.Producer<T> {\n\t/** Create a track-less catalog producer seeded with an empty catalog. */\n\tconstructor(config: Config<T> = {}) {\n\t\tsuper({\n\t\t\tinitial: {} as T,\n\t\t\tschema: (config.schema ?? RootSchema) as z.ZodMiniType<T>,\n\t\t\t// Pin deltas off by default (the @moq/json default would enable them); pass a positive\n\t\t\t// ratio to opt in.\n\t\t\tdeltaRatio: config.deltaRatio ?? 0,\n\t\t});\n\t}\n}\n"]}

package/catalog/root.d.ts

@@ -0,0 +1,252 @@
+import * as z from "zod/mini";
+/**
+ * The root catalog: the base media sections every hang broadcast carries.
+ *
+ * This is a *loose* object: unknown root sections pass through validation untouched, so an
+ * application can add its own sections (e.g. `scte35`) without modifying hang. A base consumer
+ * ignores the extra sections; an extended consumer validates them with its own schema, typically
+ * built via `z.extend(RootSchema, { ... })`.
+ */
+export declare const RootSchema: z.ZodMiniObject<{
+    video: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        renditions: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+            codec: z.ZodMiniString<string>;
+            container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"legacy">;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"cmaf">;
+                init: z.ZodMiniBase64;
+                timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"loc">;
+            }, z.core.$strip>], "kind">>;
+            description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            codedWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            codedHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            displayAspectWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            displayAspectHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            framerate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            optimizeForLatency: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+                track: z.ZodMiniString<string>;
+                timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        display: z.ZodMiniOptional<z.ZodMiniObject<{
+            width: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+            height: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+        }, z.core.$strip>>;
+        rotation: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        flip: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strip>, z.ZodMiniPipe<z.ZodMiniArray<z.ZodMiniObject<{
+        track: z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        config: z.ZodMiniObject<{
+            codec: z.ZodMiniString<string>;
+            container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"legacy">;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"cmaf">;
+                init: z.ZodMiniBase64;
+                timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"loc">;
+            }, z.core.$strip>], "kind">>;
+            description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            codedWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            codedHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            displayAspectWidth: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            displayAspectHeight: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            framerate: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            optimizeForLatency: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+            jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+                track: z.ZodMiniString<string>;
+                timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>, z.ZodMiniTransform<{
+        renditions: {
+            [k: string]: {
+                codec: string;
+                container: {
+                    kind: "legacy";
+                } | {
+                    kind: "cmaf";
+                    init: string;
+                    timescale?: (number & z.$brand<"u53">) | undefined;
+                    trackId?: (number & z.$brand<"u53">) | undefined;
+                } | {
+                    kind: "loc";
+                };
+                description?: string | undefined;
+                codedWidth?: (number & z.$brand<"u53">) | undefined;
+                codedHeight?: (number & z.$brand<"u53">) | undefined;
+                displayAspectWidth?: (number & z.$brand<"u53">) | undefined;
+                displayAspectHeight?: (number & z.$brand<"u53">) | undefined;
+                framerate?: number | undefined;
+                bitrate?: (number & z.$brand<"u53">) | undefined;
+                optimizeForLatency?: boolean | undefined;
+                jitter?: (number & z.$brand<"u53">) | undefined;
+                timeline?: {
+                    track: string;
+                    timescale: number & z.$brand<"u53">;
+                    wall?: (number & z.$brand<"u53">) | undefined;
+                } | undefined;
+            };
+        };
+        display: {
+            width: number & z.$brand<"u53">;
+            height: number & z.$brand<"u53">;
+        } | undefined;
+        rotation: undefined;
+        flip: undefined;
+    }, {
+        track: {
+            name: string;
+        };
+        config: {
+            codec: string;
+            container: {
+                kind: "legacy";
+            } | {
+                kind: "cmaf";
+                init: string;
+                timescale?: (number & z.$brand<"u53">) | undefined;
+                trackId?: (number & z.$brand<"u53">) | undefined;
+            } | {
+                kind: "loc";
+            };
+            description?: string | undefined;
+            codedWidth?: (number & z.$brand<"u53">) | undefined;
+            codedHeight?: (number & z.$brand<"u53">) | undefined;
+            displayAspectWidth?: (number & z.$brand<"u53">) | undefined;
+            displayAspectHeight?: (number & z.$brand<"u53">) | undefined;
+            framerate?: number | undefined;
+            bitrate?: (number & z.$brand<"u53">) | undefined;
+            optimizeForLatency?: boolean | undefined;
+            jitter?: (number & z.$brand<"u53">) | undefined;
+            timeline?: {
+                track: string;
+                timescale: number & z.$brand<"u53">;
+                wall?: (number & z.$brand<"u53">) | undefined;
+            } | undefined;
+        };
+    }[]>>]>>;
+    audio: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        renditions: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+            codec: z.ZodMiniString<string>;
+            container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"legacy">;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"cmaf">;
+                init: z.ZodMiniBase64;
+                timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"loc">;
+            }, z.core.$strip>], "kind">>;
+            description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            sampleRate: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+            numberOfChannels: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+            bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+                track: z.ZodMiniString<string>;
+                timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodMiniPipe<z.ZodMiniObject<{
+        track: z.ZodMiniObject<{
+            name: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        config: z.ZodMiniObject<{
+            codec: z.ZodMiniString<string>;
+            container: z.ZodMiniDefault<z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"legacy">;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"cmaf">;
+                init: z.ZodMiniBase64;
+                timescale: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                trackId: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                kind: z.ZodMiniLiteral<"loc">;
+            }, z.core.$strip>], "kind">>;
+            description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            sampleRate: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+            numberOfChannels: z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">;
+            bitrate: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            jitter: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            timeline: z.ZodMiniOptional<z.ZodMiniObject<{
+                track: z.ZodMiniString<string>;
+                timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+                wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodMiniTransform<{
+        renditions: {
+            [x: string]: {
+                codec: string;
+                container: {
+                    kind: "legacy";
+                } | {
+                    kind: "cmaf";
+                    init: string;
+                    timescale?: (number & z.$brand<"u53">) | undefined;
+                    trackId?: (number & z.$brand<"u53">) | undefined;
+                } | {
+                    kind: "loc";
+                };
+                description?: string | undefined;
+                sampleRate: number & z.$brand<"u53">;
+                numberOfChannels: number & z.$brand<"u53">;
+                bitrate?: (number & z.$brand<"u53">) | undefined;
+                jitter?: (number & z.$brand<"u53">) | undefined;
+                timeline?: {
+                    track: string;
+                    timescale: number & z.$brand<"u53">;
+                    wall?: (number & z.$brand<"u53">) | undefined;
+                } | undefined;
+            };
+        };
+    }, {
+        track: {
+            name: string;
+        };
+        config: {
+            codec: string;
+            container: {
+                kind: "legacy";
+            } | {
+                kind: "cmaf";
+                init: string;
+                timescale?: (number & z.$brand<"u53">) | undefined;
+                trackId?: (number & z.$brand<"u53">) | undefined;
+            } | {
+                kind: "loc";
+            };
+            description?: string | undefined;
+            sampleRate: number & z.$brand<"u53">;
+            numberOfChannels: number & z.$brand<"u53">;
+            bitrate?: (number & z.$brand<"u53">) | undefined;
+            jitter?: (number & z.$brand<"u53">) | undefined;
+            timeline?: {
+                track: string;
+                timescale: number & z.$brand<"u53">;
+                wall?: (number & z.$brand<"u53">) | undefined;
+            } | undefined;
+        };
+    }>>]>>;
+}, z.core.$loose>;
+/** The root catalog object, with optional video and audio sections plus any app extensions. */
+export type Root = z.infer<typeof RootSchema>;
+//# sourceMappingURL=root.d.ts.map

package/catalog/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/catalog/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAK9B;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAC;AAEH,+FAA+F;AAC/F,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/catalog/root.js

@@ -0,0 +1,17 @@
+/* @ts-self-types="./root.d.ts" */
+import * as z from "zod/mini";
+import { AudioSchema } from "./audio";
+import { VideoSchema } from "./video";
+/**
+ * The root catalog: the base media sections every hang broadcast carries.
+ *
+ * This is a *loose* object: unknown root sections pass through validation untouched, so an
+ * application can add its own sections (e.g. `scte35`) without modifying hang. A base consumer
+ * ignores the extra sections; an extended consumer validates them with its own schema, typically
+ * built via `z.extend(RootSchema, { ... })`.
+ */
+export const RootSchema = z.looseObject({
+    video: z.optional(VideoSchema),
+    audio: z.optional(AudioSchema),
+});
+//# sourceMappingURL=root.js.map

package/catalog/root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","sourceRoot":"","sources":["../../src/catalog/root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,WAAW,CAAC;IACvC,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;CAC9B,CAAC,CAAC","sourcesContent":["import * as z from \"zod/mini\";\n\nimport { AudioSchema } from \"./audio\";\nimport { VideoSchema } from \"./video\";\n\n/**\n * The root catalog: the base media sections every hang broadcast carries.\n *\n * This is a *loose* object: unknown root sections pass through validation untouched, so an\n * application can add its own sections (e.g. `scte35`) without modifying hang. A base consumer\n * ignores the extra sections; an extended consumer validates them with its own schema, typically\n * built via `z.extend(RootSchema, { ... })`.\n */\nexport const RootSchema = z.looseObject({\n\tvideo: z.optional(VideoSchema),\n\taudio: z.optional(AudioSchema),\n});\n\n/** The root catalog object, with optional video and audio sections plus any app extensions. */\nexport type Root = z.infer<typeof RootSchema>;\n"]}

package/catalog/root.test.d.ts

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

package/catalog/root.test.d.ts.map

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

package/catalog/root.test.js

@@ -0,0 +1,20 @@
+/* @ts-self-types="./root.test.d.ts" */
+import { expect, test } from "bun:test";
+import * as z from "zod/mini";
+import { RootSchema } from "./root.js";
+// The base catalog is generic: only `video`/`audio`. Applications add their own root sections
+// (e.g. `scte35`) without modifying hang, relying on the loose schema to pass them through.
+test("base catalog preserves unknown sections", () => {
+    const extended = { video: { renditions: {} }, scte35: { spliceId: 42 } };
+    const parsed = RootSchema.parse(extended);
+    // A base consumer validates the known fields but keeps the unknown section untouched.
+    expect(parsed.scte35).toEqual({ spliceId: 42 });
+});
+test("extended schema validates app sections", () => {
+    const Scte35Schema = z.object({ spliceId: z.number() });
+    const ExtendedSchema = z.extend(RootSchema, { scte35: z.optional(Scte35Schema) });
+    expect(ExtendedSchema.parse({ scte35: { spliceId: 7 } }).scte35).toEqual({ spliceId: 7 });
+    // The extended schema enforces the app's section type.
+    expect(() => ExtendedSchema.parse({ scte35: { spliceId: "nope" } })).toThrow();
+});
+//# sourceMappingURL=root.test.js.map

package/catalog/root.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.test.js","sourceRoot":"","sources":["../../src/catalog/root.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC,8FAA8F;AAC9F,4FAA4F;AAE5F,IAAI,CAAC,yCAAyC,EAAE,GAAG,EAAE;IACpD,MAAM,QAAQ,GAAG,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,CAAC;IACzE,MAAM,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC,QAAQ,CAA4B,CAAC;IACrE,sFAAsF;IACtF,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC;AACjD,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,wCAAwC,EAAE,GAAG,EAAE;IACnD,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACxD,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IAElF,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;IAE1F,uDAAuD;IACvD,MAAM,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;AAChF,CAAC,CAAC,CAAC","sourcesContent":["import { expect, test } from \"bun:test\";\nimport * as z from \"zod/mini\";\nimport { RootSchema } from \"./root.ts\";\n\n// The base catalog is generic: only `video`/`audio`. Applications add their own root sections\n// (e.g. `scte35`) without modifying hang, relying on the loose schema to pass them through.\n\ntest(\"base catalog preserves unknown sections\", () => {\n\tconst extended = { video: { renditions: {} }, scte35: { spliceId: 42 } };\n\tconst parsed = RootSchema.parse(extended) as Record<string, unknown>;\n\t// A base consumer validates the known fields but keeps the unknown section untouched.\n\texpect(parsed.scte35).toEqual({ spliceId: 42 });\n});\n\ntest(\"extended schema validates app sections\", () => {\n\tconst Scte35Schema = z.object({ spliceId: z.number() });\n\tconst ExtendedSchema = z.extend(RootSchema, { scte35: z.optional(Scte35Schema) });\n\n\texpect(ExtendedSchema.parse({ scte35: { spliceId: 7 } }).scte35).toEqual({ spliceId: 7 });\n\n\t// The extended schema enforces the app's section type.\n\texpect(() => ExtendedSchema.parse({ scte35: { spliceId: \"nope\" } })).toThrow();\n});\n"]}

package/catalog/timeline.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/mini";
+/**
+ * The moq epoch (2020-01-01T00:00:00Z) in Unix-epoch milliseconds.
+ *
+ * Timeline {@link Timeline.wall} values are measured from here rather than the Unix epoch so the
+ * numbers stay small (safely within a 53-bit integer even at fine timescales); a consumer recovers
+ * Unix time by adding this back.
+ */
+export declare const MOQ_EPOCH_UNIX_MILLIS = 1577836800000;
+/**
+ * Describes a media track's companion timeline track: a track mapping each of the media track's
+ * groups to its start timestamp, so a consumer can seek (or build an HLS/DASH playlist) without
+ * downloading the media itself.
+ *
+ * Present on a {@link VideoConfig} / {@link AudioConfig} when the publisher offers one. It is per
+ * media track on purpose: audio and video groups have different durations, so a single
+ * broadcast-wide timeline can't describe them all.
+ */
+export declare const TimelineSchema: z.ZodMiniObject<{
+    track: z.ZodMiniString<string>;
+    timescale: z.ZodMiniDefault<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+    wall: z.ZodMiniOptional<z.core.$ZodBranded<z.ZodMiniNumber<number>, "u53", "out">>;
+}, z.core.$strip>;
+/** A media track's companion timeline description. */
+export type Timeline = z.infer<typeof TimelineSchema>;
+//# sourceMappingURL=timeline.d.ts.map

package/catalog/timeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.d.ts","sourceRoot":"","sources":["../../src/catalog/timeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAG9B;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,gBAAoB,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc;;;;iBAazB,CAAC;AAEH,sDAAsD;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/catalog/timeline.js

@@ -0,0 +1,33 @@
+/* @ts-self-types="./timeline.d.ts" */
+import * as z from "zod/mini";
+import { u53, u53Schema } from "./integers";
+/**
+ * The moq epoch (2020-01-01T00:00:00Z) in Unix-epoch milliseconds.
+ *
+ * Timeline {@link Timeline.wall} values are measured from here rather than the Unix epoch so the
+ * numbers stay small (safely within a 53-bit integer even at fine timescales); a consumer recovers
+ * Unix time by adding this back.
+ */
+export const MOQ_EPOCH_UNIX_MILLIS = 1_577_836_800_000;
+/**
+ * Describes a media track's companion timeline track: a track mapping each of the media track's
+ * groups to its start timestamp, so a consumer can seek (or build an HLS/DASH playlist) without
+ * downloading the media itself.
+ *
+ * Present on a {@link VideoConfig} / {@link AudioConfig} when the publisher offers one. It is per
+ * media track on purpose: audio and video groups have different durations, so a single
+ * broadcast-wide timeline can't describe them all.
+ */
+export const TimelineSchema = z.object({
+    // The name of the companion MoQ track carrying this track's group -> timestamp records.
+    track: z.string(),
+    // Units per second for the records' `pts` (and `wall`). Defaults to 1000 (milliseconds).
+    timescale: z._default(u53Schema, u53(1000)),
+    // The wall-clock time of pts 0, in `timescale` units since the moq epoch
+    // ({@link MOQ_EPOCH_UNIX_MILLIS}, 2020-01-01), if known. A consumer derives any group's
+    // wall-clock time as `wall + pts`, and Unix time by adding the moq epoch back (for HLS
+    // EXT-X-PROGRAM-DATE-TIME / DASH availabilityStartTime). Measured from 2020 rather than 1970 so
+    // the value stays small and safely within a 53-bit integer even at fine timescales.
+    wall: z.optional(u53Schema),
+});
+//# sourceMappingURL=timeline.js.map

package/catalog/timeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline.js","sourceRoot":"","sources":["../../src/catalog/timeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAC9B,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,wFAAwF;IACxF,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IAEjB,yFAAyF;IACzF,SAAS,EAAE,CAAC,CAAC,QAAQ,CAAC,SAAS,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAE3C,yEAAyE;IACzE,wFAAwF;IACxF,uFAAuF;IACvF,gGAAgG;IAChG,oFAAoF;IACpF,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC;CAC3B,CAAC,CAAC","sourcesContent":["import * as z from \"zod/mini\";\nimport { u53, u53Schema } from \"./integers\";\n\n/**\n * The moq epoch (2020-01-01T00:00:00Z) in Unix-epoch milliseconds.\n *\n * Timeline {@link Timeline.wall} values are measured from here rather than the Unix epoch so the\n * numbers stay small (safely within a 53-bit integer even at fine timescales); a consumer recovers\n * Unix time by adding this back.\n */\nexport const MOQ_EPOCH_UNIX_MILLIS = 1_577_836_800_000;\n\n/**\n * Describes a media track's companion timeline track: a track mapping each of the media track's\n * groups to its start timestamp, so a consumer can seek (or build an HLS/DASH playlist) without\n * downloading the media itself.\n *\n * Present on a {@link VideoConfig} / {@link AudioConfig} when the publisher offers one. It is per\n * media track on purpose: audio and video groups have different durations, so a single\n * broadcast-wide timeline can't describe them all.\n */\nexport const TimelineSchema = z.object({\n\t// The name of the companion MoQ track carrying this track's group -> timestamp records.\n\ttrack: z.string(),\n\n\t// Units per second for the records' `pts` (and `wall`). Defaults to 1000 (milliseconds).\n\ttimescale: z._default(u53Schema, u53(1000)),\n\n\t// The wall-clock time of pts 0, in `timescale` units since the moq epoch\n\t// ({@link MOQ_EPOCH_UNIX_MILLIS}, 2020-01-01), if known. A consumer derives any group's\n\t// wall-clock time as `wall + pts`, and Unix time by adding the moq epoch back (for HLS\n\t// EXT-X-PROGRAM-DATE-TIME / DASH availabilityStartTime). Measured from 2020 rather than 1970 so\n\t// the value stays small and safely within a 53-bit integer even at fine timescales.\n\twall: z.optional(u53Schema),\n});\n\n/** A media track's companion timeline description. */\nexport type Timeline = z.infer<typeof TimelineSchema>;\n"]}

package/catalog/track.d.ts

@@ -0,0 +1,8 @@
+import * as z from "zod/mini";
+/** Schema for a catalog track reference, identified by name. */
+export declare const TrackSchema: z.ZodMiniObject<{
+    name: z.ZodMiniString<string>;
+}, z.core.$strip>;
+/** A catalog track reference, identified by name. */
+export type Track = z.infer<typeof TrackSchema>;
+//# sourceMappingURL=track.d.ts.map

package/catalog/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../../src/catalog/track.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,gEAAgE;AAChE,eAAO,MAAM,WAAW;;iBAEtB,CAAC;AACH,qDAAqD;AACrD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/catalog/track.js

@@ -0,0 +1,7 @@
+/* @ts-self-types="./track.d.ts" */
+import * as z from "zod/mini";
+/** Schema for a catalog track reference, identified by name. */
+export const TrackSchema = z.object({
+    name: z.string(),
+});
+//# sourceMappingURL=track.js.map

package/catalog/track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.js","sourceRoot":"","sources":["../../src/catalog/track.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,gEAAgE;AAChE,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;CAChB,CAAC,CAAC","sourcesContent":["import * as z from \"zod/mini\";\n\n/** Schema for a catalog track reference, identified by name. */\nexport const TrackSchema = z.object({\n\tname: z.string(),\n});\n/** A catalog track reference, identified by name. */\nexport type Track = z.infer<typeof TrackSchema>;\n"]}