@moq/lite

Broadcast (e.g., "my-stream")
  └── Track (e.g., "video")
      └── Group (sequence: 0, 1, 2...)
          └── Frame (payload bytes)

import * as Connection from "@moq/lite/Connection";
import { Broadcast, Track } from "@moq/lite";
import * as Path from "@moq/lite/Path";
import * as Time from "@moq/lite/Time";
import * as Signals from "@moq/lite/Signals";

import * as Connection from "@moq/lite/Connection";

const conn = await Connection.connect({
  url: "https://relay.quic.video",
  fingerprint: "https://relay.quic.video/fingerprint",
  token: "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9..." // optional
});

// Subscribe to a broadcast by name
const subscriber = await conn.subscribe("my-broadcast");

// Wait for track announcements
while (true) {
  const announced = await subscriber.announced();
  if (!announced) break; // broadcast closed
  
  console.log("Track announced:", announced.track.name);
  
  // Subscribe to the track
  const track = await subscriber.subscribe(announced.track);
  processTrack(track);
}

// Publish a broadcast
const broadcast = await conn.publish("my-broadcast");

// Create a track
const track = new Track("video");
await broadcast.announce(track);

// Write groups and frames
const group = track.appendGroup();
await group.write(frameData);
await group.close();

import { Broadcast, Track } from "@moq/lite";

const broadcast = new Broadcast();

// Create and announce tracks
const videoTrack = new Track("video");
const audioTrack = new Track("audio");

await broadcast.announce(videoTrack);
await broadcast.announce(audioTrack);

// Handle track requests from subscribers
while (true) {
  const request = await broadcast.requested();
  if (!request) break;
  
  console.log("Track requested:", request.track.name);
  console.log("Priority:", request.priority);
}

import { Track } from "@moq/lite";

const track = new Track("video");

// Append groups sequentially
const group = track.appendGroup();

// Write frames to the group
await group.write(frame1);
await group.write(frame2);

// Close the group when done
await group.close();

// Iterate over groups
for await (const group of track.groups()) {
  console.log("Group sequence:", group.sequence);
  
  // Iterate over frames in the group
  for await (const frame of group.frames()) {
    console.log("Frame:", frame.byteLength, "bytes");
    // Process frame...
  }
}

import { Group } from "@moq/lite";

// Create a group (usually via track.appendGroup())
const group = track.appendGroup();

console.log("Sequence:", group.sequence);

// Write frames
const encoder = new TextEncoder();
await group.write(encoder.encode("Hello"));
await group.write(encoder.encode("World"));

// Close the group
await group.close();

import * as Path from "@moq/lite/Path";
import * as Time from "@moq/lite/Time";

// Path utilities
const trackPath = Path.join("broadcasts", "my-stream", "video");
const parts = Path.split(trackPath);

// Time utilities
const now = Time.now(); // Current timestamp
const offset = Time.offset(timestamp1, timestamp2);

try {
  const conn = await Connection.connect({
    url: "https://relay.quic.video"
  });
  
  const subscriber = await conn.subscribe("my-broadcast");
  // ...
} catch (error) {
  console.error("Connection failed:", error);
}

track.closed.then(error => {
  if (error) {
    console.error("Track closed with error:", error);
  } else {
    console.log("Track closed normally");
  }
});

import { Signal } from "@moq/lite/Signals";

// Tracks have reactive state
const dispose = track.state.groups.subscribe(groups => {
  console.log("Groups changed:", groups.length);
});

// Clean up when done
dispose();

import { WebTransport } from "@fails-components/webtransport";
globalThis.WebTransport = WebTransport as any;

import { schemas } from "@moq/lite/zod";
import { z } from "zod";

const validated = schemas.trackName.parse("video");