@norskvideo/moq-json 0.1.0

package/snapshot/snapshot.test.js

@@ -0,0 +1,185 @@
+/* @ts-self-types="./snapshot.test.d.ts" */
+import { expect, test } from "bun:test";
+import { Track } from "@norskvideo/moq-net";
+import { Consumer } from "./consumer.js";
+import { Producer } from "./producer.js";
+// Reconstruct every value a consumer yields, in order.
+async function drain(track) {
+    const out = [];
+    for await (const value of new Consumer(track))
+        out.push(value);
+    return out;
+}
+// Inspect the published layout via the public API: the frame count of each group, in order.
+// The track must be finished first so group/frame reads terminate.
+async function structure(track) {
+    const counts = [];
+    for (;;) {
+        const group = await track.nextGroupOrdered();
+        if (!group)
+            break;
+        let frames = 0;
+        while ((await group.readFrame()) !== undefined)
+            frames++;
+        counts.push(frames);
+    }
+    return counts;
+}
+test("deltas off: a snapshot group per change", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 0 });
+    producer.update({ a: 1 });
+    producer.update({ a: 2 });
+    producer.finish();
+    // Two changes => two single-frame snapshot groups, reconstructed in order.
+    expect(await drain(track)).toEqual([{ a: 1 }, { a: 2 }]);
+});
+test("deltaRatio 0 disables deltas, like off", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 0 });
+    producer.update({ a: 1 });
+    producer.update({ a: 2 });
+    producer.finish();
+    // `0` is treated as off, not a degenerate "enabled" value that keeps the group open: each change
+    // is its own single-frame snapshot group.
+    expect(await structure(track)).toEqual([1, 1]);
+});
+test("live consumer sees each update", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track);
+    const consumer = new Consumer(track);
+    for (let n = 1; n <= 3; n++) {
+        producer.update({ a: n });
+        expect(await consumer.next()).toEqual({ a: n });
+    }
+});
+test("unchanged value writes nothing", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track);
+    producer.update({ a: 1 });
+    producer.update({ a: 1 });
+    producer.finish();
+    expect(await structure(track)).toEqual([1]);
+});
+test("deltas share one group", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 100 });
+    producer.update({ a: 1, b: 1 });
+    producer.update({ a: 1, b: 2 });
+    producer.update({ a: 1, b: 3 });
+    producer.finish();
+    // All updates fit in a single group as snapshot + two deltas.
+    expect(await structure(track)).toEqual([3]);
+});
+test("deltas reconstruct to the final value", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 100 });
+    producer.update({ a: 1, b: 1 });
+    producer.update({ a: 1, b: 2 });
+    producer.update({ a: 5, b: 2 });
+    producer.finish();
+    expect((await drain(track)).at(-1)).toEqual({ a: 5, b: 2 });
+});
+// `mutate()` edits the shared document: multiple owners edit one producer, each touching its own
+// keys, and each call publishes. This is how the catalog producer is extended (e.g. an scte35
+// section) without a single owner having to rebuild the whole document.
+test("mutate composes independent owners", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { initial: {} });
+    const consumer = new Consumer(track);
+    producer.mutate((v) => {
+        v.video = "v1";
+    });
+    expect(await consumer.next()).toEqual({ video: "v1" });
+    // A second owner starts from the latest value and adds its own key without clobbering the first.
+    producer.mutate((v) => {
+        v.scte35 = { id: 1 };
+    });
+    expect(await consumer.next()).toEqual({ video: "v1", scte35: { id: 1 } });
+});
+test("mutate starts from the configured initial value", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { initial: {} });
+    const consumer = new Consumer(track);
+    producer.mutate((v) => {
+        v.a = 1;
+    });
+    expect(await consumer.next()).toEqual({ a: 1 });
+});
+test("mutate without a prior value or initial throws", () => {
+    const producer = new Producer(new Track("test"));
+    expect(() => producer.mutate(() => { })).toThrow();
+});
+// Removing a section drops it from the reconstructed value, so a consumer detects the removal.
+// Exercised with deltas on to cover the merge-patch null-deletion path.
+test("mutate removes a section", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 100, initial: {} });
+    const consumer = new Consumer(track);
+    producer.mutate((v) => {
+        v.a = 1;
+        v.scte35 = { id: 1 };
+    });
+    expect(await consumer.next()).toEqual({ a: 1, scte35: { id: 1 } });
+    producer.mutate((v) => {
+        delete v.scte35;
+    });
+    expect(await consumer.next()).toEqual({ a: 1 });
+});
+test("tight ratio rolls snapshots", async () => {
+    const track = new Track("test");
+    // A ratio of 1 budgets deltas up to one snapshot (equal 7-byte frames => 7 bytes). The gate checks
+    // the deltas already written, so the delta that tips the group over budget still lands (a one-frame
+    // overshoot): group 0 takes two deltas (14 bytes) before the fourth update rolls group 1.
+    const producer = new Producer(track, { deltaRatio: 1 });
+    producer.update({ a: 1 }); // snapshot, group 0
+    producer.update({ a: 2 }); // delta, group 0 (deltas = 7)
+    producer.update({ a: 3 }); // delta, group 0 (deltas = 14, now over budget)
+    producer.update({ a: 4 }); // budget already exceeded, rolls group 1
+    producer.finish();
+    expect(await structure(track)).toEqual([3, 1]);
+});
+test("deltas stay within ratio times snapshot", async () => {
+    const track = new Track("test");
+    // The budget covers only the deltas, not the snapshot frame, measured against the group's snapshot
+    // size. Single-digit values keep every frame at a constant 7 bytes (`{"n":N}`), so a ratio of 8
+    // budgets 56 bytes of deltas. The gate checks the deltas already written, so the group keeps filling
+    // until they first exceed 56 (nine deltas = 63 bytes) and the next update rolls (a one-frame
+    // overshoot past the 56-byte budget).
+    const producer = new Producer(track, { deltaRatio: 8 });
+    for (let n = 0; n <= 10; n++)
+        producer.update({ n });
+    producer.finish();
+    expect(await structure(track)).toEqual([10, 1]);
+});
+test("array change is a wholesale delta", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 100 });
+    producer.update({ list: [1, 2] });
+    producer.update({ list: [1, 2, 3] });
+    producer.finish();
+    // The array is replaced wholesale in a delta, so it stays in the same group.
+    expect(await structure(track)).toEqual([2]);
+});
+test("late joiner collapses a buffered backlog to the latest value", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 100 });
+    for (let n = 0; n <= 20; n++) {
+        producer.update({ n });
+    }
+    producer.finish();
+    // A whole group's worth of snapshot + deltas is buffered before the consumer reads, so it applies
+    // them all but yields only the latest value once, not every superseded state.
+    expect(await drain(track)).toEqual([{ n: 20 }]);
+});
+test("frame cap rolls snapshot", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { deltaRatio: 1_000_000 });
+    // First update is the snapshot; deltas fill the group until the frame cap forces a roll.
+    for (let i = 0; i <= 256; i++) {
+        producer.update({ n: i });
+    }
+    producer.finish();
+    expect(await structure(track)).toEqual([256, 1]);
+});
+//# sourceMappingURL=snapshot.test.js.map

package/snapshot/snapshot.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.test.js","sourceRoot":"","sources":["../../src/snapshot/snapshot.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, test } from \"bun:test\";\nimport { Track } from \"@moq/net\";\nimport { Consumer } from \"./consumer.ts\";\nimport { Producer } from \"./producer.ts\";\n\ntype Value = Record<string, unknown>;\n\n// Reconstruct every value a consumer yields, in order.\nasync function drain(track: Track): Promise<Value[]> {\n\tconst out: Value[] = [];\n\tfor await (const value of new Consumer<Value>(track)) out.push(value);\n\treturn out;\n}\n\n// Inspect the published layout via the public API: the frame count of each group, in order.\n// The track must be finished first so group/frame reads terminate.\nasync function structure(track: Track): Promise<number[]> {\n\tconst counts: number[] = [];\n\tfor (;;) {\n\t\tconst group = await track.nextGroupOrdered();\n\t\tif (!group) break;\n\n\t\tlet frames = 0;\n\t\twhile ((await group.readFrame()) !== undefined) frames++;\n\t\tcounts.push(frames);\n\t}\n\treturn counts;\n}\n\ntest(\"deltas off: a snapshot group per change\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 0 });\n\tproducer.update({ a: 1 });\n\tproducer.update({ a: 2 });\n\tproducer.finish();\n\n\t// Two changes => two single-frame snapshot groups, reconstructed in order.\n\texpect(await drain(track)).toEqual([{ a: 1 }, { a: 2 }]);\n});\n\ntest(\"deltaRatio 0 disables deltas, like off\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 0 });\n\tproducer.update({ a: 1 });\n\tproducer.update({ a: 2 });\n\tproducer.finish();\n\n\t// `0` is treated as off, not a degenerate \"enabled\" value that keeps the group open: each change\n\t// is its own single-frame snapshot group.\n\texpect(await structure(track)).toEqual([1, 1]);\n});\n\ntest(\"live consumer sees each update\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track);\n\tconst consumer = new Consumer<Value>(track);\n\n\tfor (let n = 1; n <= 3; n++) {\n\t\tproducer.update({ a: n });\n\t\texpect(await consumer.next()).toEqual({ a: n });\n\t}\n});\n\ntest(\"unchanged value writes nothing\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track);\n\tproducer.update({ a: 1 });\n\tproducer.update({ a: 1 });\n\tproducer.finish();\n\n\texpect(await structure(track)).toEqual([1]);\n});\n\ntest(\"deltas share one group\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 100 });\n\tproducer.update({ a: 1, b: 1 });\n\tproducer.update({ a: 1, b: 2 });\n\tproducer.update({ a: 1, b: 3 });\n\tproducer.finish();\n\n\t// All updates fit in a single group as snapshot + two deltas.\n\texpect(await structure(track)).toEqual([3]);\n});\n\ntest(\"deltas reconstruct to the final value\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 100 });\n\tproducer.update({ a: 1, b: 1 });\n\tproducer.update({ a: 1, b: 2 });\n\tproducer.update({ a: 5, b: 2 });\n\tproducer.finish();\n\n\texpect((await drain(track)).at(-1)).toEqual({ a: 5, b: 2 });\n});\n\n// `mutate()` edits the shared document: multiple owners edit one producer, each touching its own\n// keys, and each call publishes. This is how the catalog producer is extended (e.g. an scte35\n// section) without a single owner having to rebuild the whole document.\ntest(\"mutate composes independent owners\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { initial: {} });\n\tconst consumer = new Consumer<Value>(track);\n\n\tproducer.mutate((v) => {\n\t\tv.video = \"v1\";\n\t});\n\texpect(await consumer.next()).toEqual({ video: \"v1\" });\n\n\t// A second owner starts from the latest value and adds its own key without clobbering the first.\n\tproducer.mutate((v) => {\n\t\tv.scte35 = { id: 1 };\n\t});\n\texpect(await consumer.next()).toEqual({ video: \"v1\", scte35: { id: 1 } });\n});\n\ntest(\"mutate starts from the configured initial value\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { initial: {} });\n\tconst consumer = new Consumer<Value>(track);\n\n\tproducer.mutate((v) => {\n\t\tv.a = 1;\n\t});\n\texpect(await consumer.next()).toEqual({ a: 1 });\n});\n\ntest(\"mutate without a prior value or initial throws\", () => {\n\tconst producer = new Producer<Value>(new Track(\"test\"));\n\texpect(() => producer.mutate(() => {})).toThrow();\n});\n\n// Removing a section drops it from the reconstructed value, so a consumer detects the removal.\n// Exercised with deltas on to cover the merge-patch null-deletion path.\ntest(\"mutate removes a section\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 100, initial: {} });\n\tconst consumer = new Consumer<Value>(track);\n\n\tproducer.mutate((v) => {\n\t\tv.a = 1;\n\t\tv.scte35 = { id: 1 };\n\t});\n\texpect(await consumer.next()).toEqual({ a: 1, scte35: { id: 1 } });\n\n\tproducer.mutate((v) => {\n\t\tdelete v.scte35;\n\t});\n\texpect(await consumer.next()).toEqual({ a: 1 });\n});\n\ntest(\"tight ratio rolls snapshots\", async () => {\n\tconst track = new Track(\"test\");\n\t// A ratio of 1 budgets deltas up to one snapshot (equal 7-byte frames => 7 bytes). The gate checks\n\t// the deltas already written, so the delta that tips the group over budget still lands (a one-frame\n\t// overshoot): group 0 takes two deltas (14 bytes) before the fourth update rolls group 1.\n\tconst producer = new Producer<Value>(track, { deltaRatio: 1 });\n\tproducer.update({ a: 1 }); // snapshot, group 0\n\tproducer.update({ a: 2 }); // delta, group 0 (deltas = 7)\n\tproducer.update({ a: 3 }); // delta, group 0 (deltas = 14, now over budget)\n\tproducer.update({ a: 4 }); // budget already exceeded, rolls group 1\n\tproducer.finish();\n\n\texpect(await structure(track)).toEqual([3, 1]);\n});\n\ntest(\"deltas stay within ratio times snapshot\", async () => {\n\tconst track = new Track(\"test\");\n\t// The budget covers only the deltas, not the snapshot frame, measured against the group's snapshot\n\t// size. Single-digit values keep every frame at a constant 7 bytes (`{\"n\":N}`), so a ratio of 8\n\t// budgets 56 bytes of deltas. The gate checks the deltas already written, so the group keeps filling\n\t// until they first exceed 56 (nine deltas = 63 bytes) and the next update rolls (a one-frame\n\t// overshoot past the 56-byte budget).\n\tconst producer = new Producer<Value>(track, { deltaRatio: 8 });\n\tfor (let n = 0; n <= 10; n++) producer.update({ n });\n\tproducer.finish();\n\n\texpect(await structure(track)).toEqual([10, 1]);\n});\n\ntest(\"array change is a wholesale delta\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 100 });\n\tproducer.update({ list: [1, 2] });\n\tproducer.update({ list: [1, 2, 3] });\n\tproducer.finish();\n\n\t// The array is replaced wholesale in a delta, so it stays in the same group.\n\texpect(await structure(track)).toEqual([2]);\n});\n\ntest(\"late joiner collapses a buffered backlog to the latest value\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 100 });\n\tfor (let n = 0; n <= 20; n++) {\n\t\tproducer.update({ n });\n\t}\n\tproducer.finish();\n\n\t// A whole group's worth of snapshot + deltas is buffered before the consumer reads, so it applies\n\t// them all but yields only the latest value once, not every superseded state.\n\texpect(await drain(track)).toEqual([{ n: 20 }]);\n});\n\ntest(\"frame cap rolls snapshot\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Value>(track, { deltaRatio: 1_000_000 });\n\t// First update is the snapshot; deltas fill the group until the frame cap forces a roll.\n\tfor (let i = 0; i <= 256; i++) {\n\t\tproducer.update({ n: i });\n\t}\n\tproducer.finish();\n\n\texpect(await structure(track)).toEqual([256, 1]);\n});\n"]}

package/stream.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Lossless append-log JSON publishing over MoQ tracks: the counterpart to the lossy `Snapshot`
+ * module. Instead of one value updated over time, a stream is an ordered log of self-contained
+ * records that preserves everything; every {@link Producer.append} writes one JSON object as one
+ * frame, nothing is ever superseded, and a {@link Consumer} yields every record in order.
+ *
+ * The whole log rides a **single group** that is never rolled: with {@link ProducerConfig.compression}
+ * on, that one group is one DEFLATE window, so every record compresses against the earlier ones.
+ * There is deliberately no group rolling (and so no catch-up machinery); a caller that wants to
+ * bound the record rate throttles at the source. Interoperable on the wire with the Rust
+ * `moq_json::stream`.
+ *
+ * @module
+ */
+import type * as Moq from "@norskvideo/moq-net";
+/** Options for a stream {@link Producer}. */
+export interface ProducerConfig {
+    /**
+     * Compress the group as one sync-flushed `deflate-raw` stream, so each record reuses the earlier
+     * ones as context and shrinks sharply. A {@link Consumer} reading the track must set the same
+     * flag. Defaults to `false`.
+     */
+    compression?: boolean;
+}
+/** Options for a stream {@link Consumer}. */
+export interface ConsumerConfig {
+    /** Whether the track's frames are `deflate-raw` compressed. Must match the producer. Defaults to `false`. */
+    compression?: boolean;
+}
+/**
+ * Publishes an ordered log of JSON records to a track, one record per frame in a single group.
+ */
+export declare class Producer<T> {
+    #private;
+    /** Wrap a track to publish a record log into it. */
+    constructor(track: Moq.Track, config?: ProducerConfig);
+    /** Append one record to the log. */
+    append(value: T): void;
+    /** Finish the track, closing the group. */
+    finish(): void;
+}
+/**
+ * Consumes an ordered log of JSON records from a track, yielding every record in order.
+ *
+ * The log rides a single group, so this reads that group's frames in order; one record per frame.
+ */
+export declare class Consumer<T> {
+    #private;
+    constructor(track: Moq.Track, config?: ConsumerConfig);
+    /** Get the next record, or `undefined` once the track ends. */
+    next(): Promise<T | undefined>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=stream.d.ts.map

package/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,KAAK,GAAG,MAAM,UAAU,CAAC;AAErC,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC9B;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,6CAA6C;AAC7C,MAAM,WAAW,cAAc;IAC9B,6GAA6G;IAC7G,WAAW,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,QAAQ,CAAC,CAAC;;IAStB,oDAAoD;IACpD,YAAY,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,GAAE,cAAmB,EAGxD;IAED,oCAAoC;IACpC,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CASrB;IAED,2CAA2C;IAC3C,MAAM,IAAI,IAAI,CAIb;CACD;AAED;;;;GAIG;AACH,qBAAa,QAAQ,CAAC,CAAC;;IAQtB,YAAY,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE,MAAM,GAAE,cAAmB,EAGxD;IAED,+DAA+D;IACzD,IAAI,IAAI,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAmBnC;IAEM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAMhD;CACD"}

package/stream.js

@@ -0,0 +1,92 @@
+/* @ts-self-types="./stream.d.ts" */
+/**
+ * Lossless append-log JSON publishing over MoQ tracks: the counterpart to the lossy `Snapshot`
+ * module. Instead of one value updated over time, a stream is an ordered log of self-contained
+ * records that preserves everything; every {@link Producer.append} writes one JSON object as one
+ * frame, nothing is ever superseded, and a {@link Consumer} yields every record in order.
+ *
+ * The whole log rides a **single group** that is never rolled: with {@link ProducerConfig.compression}
+ * on, that one group is one DEFLATE window, so every record compresses against the earlier ones.
+ * There is deliberately no group rolling (and so no catch-up machinery); a caller that wants to
+ * bound the record rate throttles at the source. Interoperable on the wire with the Rust
+ * `moq_json::stream`.
+ *
+ * @module
+ */
+import { Decoder, Encoder } from "@norskvideo/moq-flate";
+/**
+ * Publishes an ordered log of JSON records to a track, one record per frame in a single group.
+ */
+export class Producer {
+    #track;
+    #compress;
+    // The single group carrying the whole log, opened on the first append.
+    #group;
+    // The group's DEFLATE encoder (one window for the whole log), present while compressing.
+    #encoder;
+    /** Wrap a track to publish a record log into it. */
+    constructor(track, config = {}) {
+        this.#track = track;
+        this.#compress = config.compression ?? false;
+    }
+    /** Append one record to the log. */
+    append(value) {
+        const payload = new TextEncoder().encode(JSON.stringify(value));
+        if (!this.#group) {
+            this.#group = this.#track.appendGroup();
+            this.#encoder = this.#compress ? new Encoder() : undefined;
+        }
+        this.#group.writeFrame(this.#encoder ? this.#encoder.frame(payload) : payload);
+    }
+    /** Finish the track, closing the group. */
+    finish() {
+        this.#group?.close();
+        this.#group = undefined;
+        this.#track.close();
+    }
+}
+/**
+ * Consumes an ordered log of JSON records from a track, yielding every record in order.
+ *
+ * The log rides a single group, so this reads that group's frames in order; one record per frame.
+ */
+export class Consumer {
+    #track;
+    #decompress;
+    #group;
+    // The group's DEFLATE decoder (one window for the whole log), built on the first frame.
+    #decoder;
+    constructor(track, config = {}) {
+        this.#track = track;
+        this.#decompress = config.compression ?? false;
+    }
+    /** Get the next record, or `undefined` once the track ends. */
+    async next() {
+        for (;;) {
+            if (!this.#group) {
+                this.#group = await this.#track.nextGroupOrdered();
+                if (!this.#group)
+                    return undefined;
+                this.#decoder = this.#decompress ? new Decoder() : undefined;
+            }
+            const frame = await this.#group.readFrame();
+            if (frame === undefined) {
+                // The group is finished; the log rides just this one, so the stream ends.
+                this.#group = undefined;
+                this.#decoder = undefined;
+                continue;
+            }
+            const plain = this.#decoder ? this.#decoder.frame(frame) : frame;
+            return JSON.parse(new TextDecoder().decode(plain));
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for (;;) {
+            const value = await this.next();
+            if (value === undefined)
+                return;
+            yield value;
+        }
+    }
+}
+//# sourceMappingURL=stream.js.map

package/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lossless append-log JSON publishing over MoQ tracks: the counterpart to the lossy `Snapshot`\n * module. Instead of one value updated over time, a stream is an ordered log of self-contained\n * records that preserves everything; every {@link Producer.append} writes one JSON object as one\n * frame, nothing is ever superseded, and a {@link Consumer} yields every record in order.\n *\n * The whole log rides a **single group** that is never rolled: with {@link ProducerConfig.compression}\n * on, that one group is one DEFLATE window, so every record compresses against the earlier ones.\n * There is deliberately no group rolling (and so no catch-up machinery); a caller that wants to\n * bound the record rate throttles at the source. Interoperable on the wire with the Rust\n * `moq_json::stream`.\n *\n * @module\n */\n\nimport { Decoder, Encoder } from \"@moq/flate\";\nimport type * as Moq from \"@moq/net\";\n\n/** Options for a stream {@link Producer}. */\nexport interface ProducerConfig {\n\t/**\n\t * Compress the group as one sync-flushed `deflate-raw` stream, so each record reuses the earlier\n\t * ones as context and shrinks sharply. A {@link Consumer} reading the track must set the same\n\t * flag. Defaults to `false`.\n\t */\n\tcompression?: boolean;\n}\n\n/** Options for a stream {@link Consumer}. */\nexport interface ConsumerConfig {\n\t/** Whether the track's frames are `deflate-raw` compressed. Must match the producer. Defaults to `false`. */\n\tcompression?: boolean;\n}\n\n/**\n * Publishes an ordered log of JSON records to a track, one record per frame in a single group.\n */\nexport class Producer<T> {\n\t#track: Moq.Track;\n\t#compress: boolean;\n\n\t// The single group carrying the whole log, opened on the first append.\n\t#group?: Moq.Group;\n\t// The group's DEFLATE encoder (one window for the whole log), present while compressing.\n\t#encoder?: Encoder;\n\n\t/** Wrap a track to publish a record log into it. */\n\tconstructor(track: Moq.Track, config: ProducerConfig = {}) {\n\t\tthis.#track = track;\n\t\tthis.#compress = config.compression ?? false;\n\t}\n\n\t/** Append one record to the log. */\n\tappend(value: T): void {\n\t\tconst payload = new TextEncoder().encode(JSON.stringify(value));\n\n\t\tif (!this.#group) {\n\t\t\tthis.#group = this.#track.appendGroup();\n\t\t\tthis.#encoder = this.#compress ? new Encoder() : undefined;\n\t\t}\n\n\t\tthis.#group.writeFrame(this.#encoder ? this.#encoder.frame(payload) : payload);\n\t}\n\n\t/** Finish the track, closing the group. */\n\tfinish(): void {\n\t\tthis.#group?.close();\n\t\tthis.#group = undefined;\n\t\tthis.#track.close();\n\t}\n}\n\n/**\n * Consumes an ordered log of JSON records from a track, yielding every record in order.\n *\n * The log rides a single group, so this reads that group's frames in order; one record per frame.\n */\nexport class Consumer<T> {\n\t#track: Moq.Track;\n\t#decompress: boolean;\n\n\t#group?: Moq.Group;\n\t// The group's DEFLATE decoder (one window for the whole log), built on the first frame.\n\t#decoder?: Decoder;\n\n\tconstructor(track: Moq.Track, config: ConsumerConfig = {}) {\n\t\tthis.#track = track;\n\t\tthis.#decompress = config.compression ?? false;\n\t}\n\n\t/** Get the next record, or `undefined` once the track ends. */\n\tasync next(): Promise<T | undefined> {\n\t\tfor (;;) {\n\t\t\tif (!this.#group) {\n\t\t\t\tthis.#group = await this.#track.nextGroupOrdered();\n\t\t\t\tif (!this.#group) return undefined;\n\t\t\t\tthis.#decoder = this.#decompress ? new Decoder() : undefined;\n\t\t\t}\n\n\t\t\tconst frame = await this.#group.readFrame();\n\t\t\tif (frame === undefined) {\n\t\t\t\t// The group is finished; the log rides just this one, so the stream ends.\n\t\t\t\tthis.#group = undefined;\n\t\t\t\tthis.#decoder = undefined;\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst plain = this.#decoder ? this.#decoder.frame(frame) : frame;\n\t\t\treturn JSON.parse(new TextDecoder().decode(plain));\n\t\t}\n\t}\n\n\tasync *[Symbol.asyncIterator](): AsyncIterator<T> {\n\t\tfor (;;) {\n\t\t\tconst value = await this.next();\n\t\t\tif (value === undefined) return;\n\t\t\tyield value;\n\t\t}\n\t}\n}\n"]}

package/stream.test.d.ts

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

package/stream.test.d.ts.map

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

package/stream.test.js

@@ -0,0 +1,64 @@
+/* @ts-self-types="./stream.test.d.ts" */
+import { expect, test } from "bun:test";
+import { Track } from "@norskvideo/moq-net";
+import { Consumer, Producer } from "./stream.js";
+// Drain every record currently available from a fresh consumer over the (finished) track.
+async function drain(track, compression) {
+    const consumer = new Consumer(track, { compression });
+    const out = [];
+    for (;;) {
+        const record = await consumer.next();
+        if (record === undefined)
+            break;
+        out.push(record.n);
+    }
+    return out;
+}
+test("plaintext roundtrip in order", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track);
+    for (let n = 0; n < 5; n++)
+        producer.append({ n });
+    producer.finish();
+    expect(await drain(track, false)).toEqual([0, 1, 2, 3, 4]);
+});
+test("compressed roundtrip in order", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { compression: true });
+    for (let n = 0; n < 20; n++)
+        producer.append({ n });
+    producer.finish();
+    expect(await drain(track, true)).toEqual(Array.from({ length: 20 }, (_, n) => n));
+});
+test("the whole log rides one group, never rolled", async () => {
+    const track = new Track("test");
+    const producer = new Producer(track, { compression: true });
+    for (let n = 0; n < 50; n++)
+        producer.append({ n });
+    producer.finish();
+    // A single group holds everything, and the consumer reads it all in order.
+    const group0 = await track.nextGroupOrdered();
+    expect(group0?.sequence).toBe(0);
+    const group1 = await track.nextGroupOrdered();
+    expect(group1).toBeUndefined();
+});
+test("records with embedded newlines round-trip (JSON escapes the newline)", async () => {
+    // Each record is its own frame (one JSON object), and JSON.stringify escapes control characters,
+    // so a string value containing a newline round-trips cleanly.
+    const track = new Track("test");
+    const producer = new Producer(track, { compression: true });
+    const value = { s: "line1\nline2\ttab" };
+    for (let i = 0; i < 4; i++)
+        producer.append(value);
+    producer.finish();
+    const consumer = new Consumer(track, { compression: true });
+    const out = [];
+    for (;;) {
+        const record = await consumer.next();
+        if (record === undefined)
+            break;
+        out.push(record);
+    }
+    expect(out).toEqual([value, value, value, value]);
+});
+//# sourceMappingURL=stream.test.js.map

package/stream.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.test.js","sourceRoot":"","sources":["../src/stream.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, test } from \"bun:test\";\nimport { Track } from \"@moq/net\";\nimport { Consumer, Producer } from \"./stream.ts\";\n\ntype Rec = { n: number };\n\n// Drain every record currently available from a fresh consumer over the (finished) track.\nasync function drain(track: Track, compression: boolean): Promise<number[]> {\n\tconst consumer = new Consumer<Rec>(track, { compression });\n\tconst out: number[] = [];\n\tfor (;;) {\n\t\tconst record = await consumer.next();\n\t\tif (record === undefined) break;\n\t\tout.push(record.n);\n\t}\n\treturn out;\n}\n\ntest(\"plaintext roundtrip in order\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Rec>(track);\n\tfor (let n = 0; n < 5; n++) producer.append({ n });\n\tproducer.finish();\n\n\texpect(await drain(track, false)).toEqual([0, 1, 2, 3, 4]);\n});\n\ntest(\"compressed roundtrip in order\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Rec>(track, { compression: true });\n\tfor (let n = 0; n < 20; n++) producer.append({ n });\n\tproducer.finish();\n\n\texpect(await drain(track, true)).toEqual(Array.from({ length: 20 }, (_, n) => n));\n});\n\ntest(\"the whole log rides one group, never rolled\", async () => {\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<Rec>(track, { compression: true });\n\tfor (let n = 0; n < 50; n++) producer.append({ n });\n\tproducer.finish();\n\n\t// A single group holds everything, and the consumer reads it all in order.\n\tconst group0 = await track.nextGroupOrdered();\n\texpect(group0?.sequence).toBe(0);\n\tconst group1 = await track.nextGroupOrdered();\n\texpect(group1).toBeUndefined();\n});\n\ntest(\"records with embedded newlines round-trip (JSON escapes the newline)\", async () => {\n\t// Each record is its own frame (one JSON object), and JSON.stringify escapes control characters,\n\t// so a string value containing a newline round-trips cleanly.\n\tconst track = new Track(\"test\");\n\tconst producer = new Producer<{ s: string }>(track, { compression: true });\n\tconst value = { s: \"line1\\nline2\\ttab\" };\n\tfor (let i = 0; i < 4; i++) producer.append(value);\n\tproducer.finish();\n\n\tconst consumer = new Consumer<{ s: string }>(track, { compression: true });\n\tconst out: { s: string }[] = [];\n\tfor (;;) {\n\t\tconst record = await consumer.next();\n\t\tif (record === undefined) break;\n\t\tout.push(record);\n\t}\n\texpect(out).toEqual([value, value, value, value]);\n});\n"]}

package/vectors.test.d.ts

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

package/vectors.test.d.ts.map

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

package/vectors.test.js

@@ -0,0 +1,18 @@
+/* @ts-self-types="./vectors.test.d.ts" */
+import { expect, test } from "bun:test";
+import { diff, merge } from "./diff.js";
+// Shared cross-impl fixture, owned by the reference Rust crate. Both suites assert the same
+// vectors so the two implementations agree on every snapshot/delta decision and patch shape.
+const url = new URL("../../../rs/moq-json/tests/vectors.json", import.meta.url);
+const vectors = (await Bun.file(url).json());
+for (const vector of vectors) {
+    test(`vector: ${vector.name}`, () => {
+        const result = diff(vector.old, vector.new);
+        expect(result.forcedSnapshot).toBe(vector.forced);
+        if (!vector.forced) {
+            expect(result.patch).toEqual(vector.patch);
+            expect(merge(vector.old, result.patch)).toEqual(vector.new);
+        }
+    });
+}
+//# sourceMappingURL=vectors.test.js.map

package/vectors.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectors.test.js","sourceRoot":"","sources":["../src/vectors.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAExC,4FAA4F;AAC5F,6FAA6F;AAC7F,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,yCAAyC,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;AAChF,MAAM,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAMzC,CAAC;AAEH,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;IAC9B,IAAI,CAAC,WAAW,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,EAAE;QACnC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;QAC5C,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAElD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,KAAe,CAAC,CAAC;YACrD,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,GAAa,CAAC,CAAC;QACvE,CAAC;IACF,CAAC,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { expect, test } from \"bun:test\";\nimport { diff, merge } from \"./diff.ts\";\n\n// Shared cross-impl fixture, owned by the reference Rust crate. Both suites assert the same\n// vectors so the two implementations agree on every snapshot/delta decision and patch shape.\nconst url = new URL(\"../../../rs/moq-json/tests/vectors.json\", import.meta.url);\nconst vectors = (await Bun.file(url).json()) as Array<{\n\tname: string;\n\told: unknown;\n\tnew: unknown;\n\tforced: boolean;\n\tpatch?: unknown;\n}>;\n\nfor (const vector of vectors) {\n\ttest(`vector: ${vector.name}`, () => {\n\t\tconst result = diff(vector.old, vector.new);\n\t\texpect(result.forcedSnapshot).toBe(vector.forced);\n\n\t\tif (!vector.forced) {\n\t\t\texpect(result.patch).toEqual(vector.patch as object);\n\t\t\texpect(merge(vector.old, result.patch)).toEqual(vector.new as object);\n\t\t}\n\t});\n}\n"]}