@volter/world-core 3.0.151 → 3.0.152

package/dist/src/derived-core.d.ts

@@ -2,6 +2,7 @@ import { type TwinResource } from './serve.js';
 import { GitObjectStore } from './git/objects.js';
 import { GitRefs } from './git/refs.js';
 import { type SocketDecl, type SocketSession } from './sockets.js';
+import type { LiveAccess, LiveDecl } from './live/types.js';
 import { type MachinePool } from './machines.js';
 import { type ApplicationAnswer, type ApplicationStandIn, type EventRender, type EventScheme, type EventsDecl, type EventValues } from './events.js';
 import type { RateBudgetDeclaration } from './rateBudget.js';
@@ -766,6 +767,10 @@ export type DerivedManifest = {
     /** The persistent wires the vendor's clients hold open (sockets.ts: Discord's Gateway): each served at its path by
      *  the pack's `semantics/sockets.ts`, which the kernel offers every write after its webhooks. */
     sockets?: ReadonlyArray<SocketDecl>;
+    /** The broadcasts the vendor takes over RTMP (architecture, "Other wires": live media): each ingest's id, which names
+     *  its engine in the pack's `semantics/live.ts`, and the RTMP app it answers. The pack's fetch carries the ingest
+     *  (`fetch.ingest`), which its server serves on a side port. */
+    live?: ReadonlyArray<LiveDecl>;
     /** The vendor speaks gRPC (architecture, "Other wires": gRPC): its server answers HTTP/2 and HTTP/1 on one port, each
      *  rpc (by its proto unit's schema, `src/generated/proto.gen.json`) through the pack's own fetch. */
     grpc?: true;
@@ -949,6 +954,9 @@ export type SemanticsContext = {
     issue(resource: string): Promise<string>;
     /** The vendor's open sessions of one of its sockets in this World (a request answered by a session: sockets.ts). */
     sockets(id: string): SocketSession[];
+    /** The World's recordings of what was broadcast to this twin (live media, live/access.ts): a recording's facts, and its
+     *  playlists, init and segments answered as the vendor's media host answers them. */
+    live: LiveAccess;
     /** Hold this read until the World writes (held-reads.ts: HTTP long polling): true when a write of one of the named
      *  resources lands in this World, false when `ms` pass or the client hangs up; at once false in a read-only World. */
     awaitWrite(resources: ReadonlyArray<string>, ms: number): Promise<boolean>;

package/dist/src/derived-core.js

@@ -15,6 +15,7 @@ import { GitRefs } from "./git/refs.js";
 import { worldNow } from "./world-clock.js";
 import { worldEnvValue } from "./world-env.js";
 import { openSessions, socketWrite } from "./sockets.js";
+import { liveAccess } from "./live/access.js";
 import { awaitWrite, awaitCondition, heldReadsWrite } from "./held-reads.js";
 import { MACHINE_POOL, poolFor, guardedMachinePool } from "./machines.js";
 import { askApplication, deliverEvents } from "./events.js";
@@ -1538,6 +1539,7 @@ export async function contextFor(m, call, scope) {
             ...(options.database === undefined ? {} : { database: options.database }),
             ...(options.transaction === undefined ? {} : { transaction: options.transaction }),
         }),
+        live: liveAccess({ rows: (type) => resourcesOfType(m.service, type, root), blob: (key) => readResourceBlob(m.service, key, root) }, call.request),
         blobs: {
             put: (key, bytes) => writeResourceBlob(m.service, key, bytes, root),
             get: (key) => readResourceBlob(m.service, key, root),

package/dist/src/derived.d.ts

@@ -1,4 +1,5 @@
 import type { WebSocketUpgrade } from './serve-http.js';
+import type { TwinStream } from './twin-fetch.js';
 /** The slice of a generated surface the dispatch reads. */
 export type DerivedOperation = {
     id: string;
@@ -126,6 +127,9 @@ export type DerivedFetch = ((request: Request) => Promise<Response>) & {
     ownersByUnit?(): Record<string, Record<string, DerivedOwner>>;
     /** The vendor's sockets (sockets.ts), for the serve seam to upgrade to, when its manifest declares any. */
     upgrade?: WebSocketUpgrade;
+    /** The vendor's RTMP ingest (live/ingest.ts), for its server to serve on its side port (`serveStream`), when its
+     *  manifest declares `live`. */
+    ingest?: TwinStream;
     maxRequestBodySize?: number;
     /** The workspace screens it draws, its lanes' too (`GET /twin`'s `screens`). */
     workspaces?(): Workspace[];

package/dist/src/index.d.ts

@@ -25,6 +25,7 @@ export { verifyEvent } from './events.js';
 export { deriveStateSystem, deriveVendorStateSystem } from './derived-real.js';
 export type { IngestDecl } from './derived-core.js';
 export type { SocketDecl, SocketEngine, SocketSession } from './sockets.js';
+export type { LiveAccess, LiveAdmission, LiveAudio, LiveDecl, LiveEngine, LivePublish, LiveRecording, LiveRefusal, LiveServeOptions, LiveVideo } from './live/types.js';
 export { machinePool, isMachineCapabilityGap, type ExecSpec, type MachinePool, type MachineProcess, type MachineRun, type MachineSpec, type MachineStatus, type MachineFiles, type MachineFileStat } from './machines.js';
 export type { CorsDecl } from './cors.js';
 export type { Handler, HandlerContext, WriteHookContext } from './derived-core.js';
@@ -39,7 +40,7 @@ export { answerVendorErrors, RefusedWriteError } from './head.js';
 export { GraphqlError, type GraphqlPart, type GraphqlResolver } from './graphql-wire.js';
 export { VendorUnreachableError } from './vendor-call.js';
 export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER } from './request-scope.js';
-export { serveHttp, serveStream, type HttpHandler, type HttpServer, type ServeHttpOptions } from './serve-http.js';
+export { serveHttp, serveStream, StreamListenerUnavailable, type HttpHandler, type HttpServer, type ServeHttpOptions } from './serve-http.js';
 export type { TwinStream, TwinStreamConnection, TwinStreamSink } from './twin-fetch.js';
 export { privateTransportKey } from './private-transport.js';
 export { siteLabel, siteUrlOf, twinSiteUrl, twinVendorUrl } from './twin-fetch.js';
@@ -68,6 +69,7 @@ export { placeholderPng } from './placeholder-image.js';
 export { presignSigV4, signSigV4, verifySigV4, type SigV4Verdict } from './sigv4.js';
 export * as redis from './redis/index.js';
 export * as mysql from './mysql/index.js';
+export * as live from './live/index.js';
 export * as git from './git/index.js';
 export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError } from './scenario.js';
 export type { PackScenarioAdapter, ScenarioDecision, ScenarioDocument, ScenarioExtractorSpec, ScenarioFault, ScenarioFaultResult, ScenarioFeatures, ScenarioHandler, ScenarioMatcher, ScenarioMissRecord, ScenarioStatus } from './scenario.js';

package/dist/src/index.js

@@ -29,7 +29,7 @@ export { GraphqlError } from "./graphql-wire.js";
 export { VendorUnreachableError } from "./vendor-call.js";
 export { isReadOnlyRequest, READ_ONLY_REQUEST_HEADER } from "./request-scope.js";
 // ── the serve factory ──────────────────────────────────────────────────────────────────────────
-export { serveHttp, serveStream } from "./serve-http.js";
+export { serveHttp, serveStream, StreamListenerUnavailable } from "./serve-http.js";
 export { privateTransportKey } from "./private-transport.js";
 // where a page links a hostname its twin answers, inside the World that shows it
 export { siteLabel, siteUrlOf, twinSiteUrl, twinVendorUrl } from "./twin-fetch.js";
@@ -60,6 +60,7 @@ export { placeholderPng } from "./placeholder-image.js";
 export { presignSigV4, signSigV4, verifySigV4 } from "./sigv4.js";
 export * as redis from "./redis/index.js";
 export * as mysql from "./mysql/index.js";
+export * as live from "./live/index.js";
 export * as git from "./git/index.js";
 // ── the scenario grammar (architecture, "Behaviour") ───────────────────────────────────────────
 export { parseScenarioDocument, scenarioFaultResult, ScenarioEngine, ScenarioError } from "./scenario.js";

package/dist/src/live/access.d.ts

@@ -0,0 +1,22 @@
+import { type HlsSegment } from './hls.js';
+import type { LiveAccess, LiveRecording } from './types.js';
+/** The bookkeeping types a recording is kept in. */
+export declare const LIVE = "_live";
+export declare const LIVE_SEGMENT = "_live_segment";
+/** Where a recording's bytes are kept among the pack's resource blobs. */
+export declare const initBlob: (stream: string, init: number) => string;
+export declare const segmentBlob: (stream: string, seq: number) => string;
+type Row = Record<string, unknown>;
+export type LiveReads = {
+    rows(type: string): Row[];
+    blob(key: string): Promise<Uint8Array | null>;
+};
+/** A recording's kept segments, in order. */
+export declare function segmentsOf(reads: LiveReads, stream: string): Array<HlsSegment & {
+    start: number;
+    blob: string;
+}>;
+export declare function recordingOf(row: Row, segments: ReadonlyArray<HlsSegment>): LiveRecording;
+/** `ctx.live` over a request (the one a media host answers, for its Range and its method). */
+export declare function liveAccess(reads: LiveReads, request: Request): LiveAccess;
+export {};

package/dist/src/live/access.js

@@ -0,0 +1,83 @@
+// What a handler and a screen read of the World's recordings (`ctx.live`, architecture "Other wires": live media): a
+// recording's facts from its bookkeeping subjects, and its playlists, init and segments answered as a media host
+// answers them. The recording's rows are the tree's (`_live`, `_live_segment`); the bytes are the pack's resource blobs.
+import { bytesResponse } from "../file-response.js";
+import { masterPlaylist, mediaPlaylist } from "./hls.js";
+/** The bookkeeping types a recording is kept in. */
+export const LIVE = '_live';
+export const LIVE_SEGMENT = '_live_segment';
+/** Where a recording's bytes are kept among the pack's resource blobs. */
+export const initBlob = (stream, init) => `live/${stream}/init-${init}.mp4`;
+export const segmentBlob = (stream, seq) => `live/${stream}/seg-${seq}.m4s`;
+/** A recording's kept segments, in order. */
+export function segmentsOf(reads, stream) {
+    return reads.rows(LIVE_SEGMENT)
+        .filter((r) => r.stream === stream && r.deleted !== true)
+        .map((r) => ({ seq: Number(r.seq), init: Number(r.init), duration: Number(r.duration), size: Number(r.size), start: Number(r.start), blob: String(r.blob) }))
+        .sort((a, b) => a.seq - b.seq);
+}
+export function recordingOf(row, segments) {
+    return {
+        stream: String(row.id),
+        app: String(row.app ?? ''),
+        key: String(row.key ?? ''),
+        state: row.state === 'ended' ? 'ended' : 'publishing',
+        startedAt: String(row.startedAt ?? ''),
+        ...(typeof row.endedAt === 'string' ? { endedAt: row.endedAt } : {}),
+        publishes: Number(row.publishes ?? 1),
+        segments: segments.length,
+        duration: Math.round(segments.reduce((n, s) => n + s.duration, 0) * 1000) / 1000,
+        ...(row.video && typeof row.video === 'object' ? { video: row.video } : {}),
+        ...(row.audio && typeof row.audio === 'object' ? { audio: row.audio } : {}),
+        ...(row.metadata && typeof row.metadata === 'object' ? { metadata: row.metadata } : {}),
+    };
+}
+const CORS = { 'access-control-allow-origin': '*' };
+const missing = () => new Response('Not Found', { status: 404, headers: { 'content-type': 'text/plain; charset=utf-8', ...CORS } });
+/** `ctx.live` over a request (the one a media host answers, for its Range and its method). */
+export function liveAccess(reads, request) {
+    const rowOf = (stream) => reads.rows(LIVE).find((r) => r.id === stream && r.deleted !== true);
+    return {
+        recording(stream) {
+            const row = rowOf(stream);
+            return row ? recordingOf(row, segmentsOf(reads, stream)) : undefined;
+        },
+        recordings() {
+            return reads.rows(LIVE).filter((r) => r.deleted !== true).map((r) => recordingOf(r, segmentsOf(reads, String(r.id))));
+        },
+        async serve(stream, file, options = {}) {
+            const row = rowOf(stream);
+            if (!row)
+                return missing();
+            const segments = segmentsOf(reads, stream);
+            const ended = row.state === 'ended';
+            if (file === 'index.m3u8' || file === 'master.m3u8') {
+                // a recording with nothing playable yet has no playlist: a player waits, as for a stream not yet live
+                if (!segments.length)
+                    return missing();
+                const recording = recordingOf(row, segments);
+                const uri = options.uri ?? ((f) => f);
+                const text = file === 'index.m3u8'
+                    ? mediaPlaylist({ state: recording.state, ...(typeof row.window === 'number' ? { window: row.window } : {}) }, segments, options)
+                    : masterPlaylist(recording, segments, uri('index.m3u8'));
+                return new Response(request.method === 'HEAD' ? null : text, { headers: { 'content-type': 'application/vnd.apple.mpegurl', 'cache-control': ended ? 'public, max-age=3600' : 'no-cache, no-store', ...CORS } });
+            }
+            const init = /^init-(\d{1,9})\.mp4$/.exec(file);
+            const seg = /^seg-(\d{1,12})\.m4s$/.exec(file);
+            let key;
+            if (init && segments.some((s) => s.init === Number(init[1])))
+                key = initBlob(stream, Number(init[1]));
+            else if (seg)
+                key = segments.find((s) => s.seq === Number(seg[1]))?.blob;
+            if (!key)
+                return missing();
+            const bytes = await reads.blob(key);
+            if (!bytes)
+                return missing();
+            const answer = bytesResponse(request, bytes, 'video/mp4');
+            for (const [k, v] of Object.entries(CORS))
+                answer.headers.set(k, v);
+            return answer;
+        },
+    };
+}

package/dist/src/live/amf0.d.ts

@@ -0,0 +1,7 @@
+export type Amf0Value = number | boolean | string | null | undefined | Date | Amf0Value[] | {
+    [key: string]: Amf0Value;
+};
+/** Every value in `bytes`, in order; a value of a type AMF0 commands do not carry ends the read. */
+export declare function decodeAmf0(bytes: Uint8Array): Amf0Value[];
+/** `values` as AMF0, in order. */
+export declare function encodeAmf0(...values: Amf0Value[]): Uint8Array;

package/dist/src/live/amf0.js

@@ -0,0 +1,122 @@
+// AMF0, the encoding of RTMP's commands and data messages (Adobe's AMF0 specification, as RTMP 1.0 §7 uses it): a
+// command is a sequence of values (its name, a transaction id, an object, its arguments). Read: number, boolean,
+// string, object, null, undefined, ECMA array, strict array, date, long string, typed object; a reference (0x07) is read
+// as undefined, never followed, so no value read is cyclic (a publisher's metadata pointing back at itself); anything
+// else stops the read where it is. Written: number, boolean, string, object (and a plain record), null, undefined.
+const utf8 = new TextDecoder();
+const encoder = new TextEncoder();
+/** Every value in `bytes`, in order; a value of a type AMF0 commands do not carry ends the read. */
+export function decodeAmf0(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let at = 0;
+    const str = (length) => { const s = utf8.decode(bytes.subarray(at, at + length)); at += length; return s; };
+    const key = () => { const n = view.getUint16(at); at += 2; return str(n); };
+    const properties = (into) => {
+        for (;;) {
+            if (at + 3 > bytes.length)
+                return into;
+            if (view.getUint16(at) === 0 && bytes[at + 2] === 0x09) {
+                at += 3;
+                return into;
+            }
+            const name = key();
+            into[name] = value();
+        }
+    };
+    const value = () => {
+        const marker = bytes[at++];
+        switch (marker) {
+            case 0x00: {
+                const n = view.getFloat64(at);
+                at += 8;
+                return n;
+            }
+            case 0x01: return bytes[at++] !== 0;
+            case 0x02: return key();
+            case 0x03: return properties({});
+            case 0x05: return null;
+            case 0x06: return undefined;
+            case 0x07:
+                at += 2;
+                return undefined;
+            case 0x08:
+                at += 4;
+                return properties({});
+            case 0x0a: {
+                const n = view.getUint32(at);
+                at += 4;
+                const list = [];
+                for (let i = 0; i < n && at < bytes.length; i++)
+                    list.push(value());
+                return list;
+            }
+            case 0x0b: {
+                const ms = view.getFloat64(at);
+                at += 10;
+                return new Date(ms);
+            }
+            case 0x0c: {
+                const n = view.getUint32(at);
+                at += 4;
+                return str(n);
+            }
+            case 0x10:
+                key();
+                return properties({});
+            default: throw new Amf0End();
+        }
+    };
+    const out = [];
+    while (at < bytes.length) {
+        try {
+            out.push(value());
+        }
+        catch (error) {
+            if (error instanceof Amf0End || error instanceof RangeError)
+                break;
+            throw error;
+        }
+    }
+    return out;
+}
+class Amf0End extends Error {
+}
+/** `values` as AMF0, in order. */
+export function encodeAmf0(...values) {
+    const parts = [];
+    const u16 = (n) => { parts.push((n >> 8) & 0xff, n & 0xff); };
+    const text = (s) => { const b = encoder.encode(s); u16(b.length); for (const x of b)
+        parts.push(x); };
+    const write = (v) => {
+        if (typeof v === 'number') {
+            parts.push(0x00);
+            const b = new Uint8Array(8);
+            new DataView(b.buffer).setFloat64(0, v);
+            for (const x of b)
+                parts.push(x);
+        }
+        else if (typeof v === 'boolean')
+            parts.push(0x01, v ? 1 : 0);
+        else if (typeof v === 'string') {
+            parts.push(0x02);
+            text(v);
+        }
+        else if (v === null)
+            parts.push(0x05);
+        else if (v === undefined)
+            parts.push(0x06);
+        else if (v instanceof Date || Array.isArray(v))
+            throw new Error('amf0: this writer writes no dates or arrays');
+        else {
+            parts.push(0x03);
+            for (const [k, x] of Object.entries(v)) {
+                text(k);
+                write(x);
+            }
+            parts.push(0x00, 0x00, 0x09);
+        }
+    };
+    for (const v of values)
+        write(v);
+    return Uint8Array.from(parts);
+}

package/dist/src/live/flv.d.ts

@@ -0,0 +1,42 @@
+export type AvcConfig = {
+    /** the AVCDecoderConfigurationRecord as sent, which an `avcC` box holds as is (ISO/IEC 14496-15 §5.3.3.1) */
+    record: Uint8Array;
+    /** the RFC 6381 codec string: `avc1.` and the profile, constraint flags and level, in hex */
+    codec: string;
+    width: number;
+    height: number;
+};
+export type AacConfig = {
+    /** the AudioSpecificConfig as sent, which an `esds` box's DecoderSpecificInfo holds as is */
+    asc: Uint8Array;
+    codec: string;
+    objectType: number;
+    sampleRate: number;
+    channels: number;
+};
+export type VideoTag = {
+    kind: 'config';
+    config: AvcConfig;
+} | {
+    kind: 'frame';
+    key: boolean;
+    cts: number;
+    data: Uint8Array;
+} | {
+    kind: 'other';
+} | {
+    kind: 'unsupported';
+    codec: string;
+};
+export type AudioTag = {
+    kind: 'config';
+    config: AacConfig;
+} | {
+    kind: 'frame';
+    data: Uint8Array;
+} | {
+    kind: 'unsupported';
+    codec: string;
+};
+export declare function readVideoTag(p: Uint8Array): VideoTag;
+export declare function readAudioTag(p: Uint8Array): AudioTag;

package/dist/src/live/flv.js

@@ -0,0 +1,148 @@
+// An FLV tag's body as RTMP carries it (FLV 10.1, Annex E.4.2 and E.4.3): video as AVC (codec 7, its packet type 0 the
+// AVCDecoderConfigurationRecord, 1 length-prefixed NAL units with a composition time offset), audio as AAC (format 10, its
+// packet type 0 the AudioSpecificConfig, 1 a raw frame). Anything else is named as the codec it is and not read: other
+// codecs, and Enhanced RTMP's ex-header (its first byte's high bit), which carries HEVC, AV1 and multitrack video.
+const VIDEO_CODECS = { 2: 'Sorenson H.263', 3: 'Screen video', 4: 'On2 VP6', 5: 'On2 VP6 with alpha', 6: 'Screen video 2', 12: 'HEVC', 13: 'AV1' };
+const AUDIO_FORMATS = { 0: 'linear PCM', 1: 'ADPCM', 2: 'MP3', 3: 'linear PCM (little-endian)', 4: 'Nellymoser 16 kHz', 5: 'Nellymoser 8 kHz', 6: 'Nellymoser', 7: 'G.711 A-law', 8: 'G.711 mu-law', 11: 'Speex', 14: 'MP3 8 kHz', 15: 'device-specific' };
+const hex2 = (n) => n.toString(16).padStart(2, '0');
+export function readVideoTag(p) {
+    if (p.length < 1)
+        return { kind: 'other' };
+    if (p[0] & 0x80) {
+        const fourcc = p.length >= 5 ? String.fromCharCode(p[1], p[2], p[3], p[4]) : '?';
+        return { kind: 'unsupported', codec: `Enhanced RTMP ${fourcc}` };
+    }
+    const frameType = p[0] >> 4;
+    const codec = p[0] & 0x0f;
+    if (codec !== 7)
+        return { kind: 'unsupported', codec: VIDEO_CODECS[codec] ?? `video codec ${codec}` };
+    // a video info/command frame (frame type 5) carries no picture
+    if (frameType === 5 || p.length < 5)
+        return { kind: 'other' };
+    const packetType = p[1];
+    const cts = ((p[2] << 16) | (p[3] << 8) | p[4]) << 8 >> 8;
+    const data = p.subarray(5);
+    if (packetType === 0)
+        return { kind: 'config', config: avcConfig(data) };
+    if (packetType === 1)
+        return { kind: 'frame', key: frameType === 1, cts, data };
+    return { kind: 'other' };
+}
+export function readAudioTag(p) {
+    if (p.length < 2)
+        return { kind: 'frame', data: new Uint8Array(0) };
+    const format = p[0] >> 4;
+    if (format !== 10)
+        return { kind: 'unsupported', codec: AUDIO_FORMATS[format] ?? `audio format ${format}` };
+    if (p[1] === 0)
+        return { kind: 'config', config: aacConfig(p.subarray(2)) };
+    return { kind: 'frame', data: p.subarray(2) };
+}
+function avcConfig(record) {
+    const copy = record.slice();
+    const codec = copy.length >= 4 ? `avc1.${hex2(copy[1])}${hex2(copy[2])}${hex2(copy[3])}` : 'avc1.42e01e';
+    let width = 0;
+    let height = 0;
+    // the first SPS: after the version, profile, compatibility, level, length size and SPS count
+    if (copy.length > 8 && (copy[5] & 0x1f) > 0) {
+        const length = (copy[6] << 8) | copy[7];
+        try {
+            ({ width, height } = spsSize(copy.subarray(8, 8 + length)));
+        }
+        catch { /* the metadata's size stands in */ }
+    }
+    return { record: copy, codec, width, height };
+}
+function aacConfig(asc) {
+    const copy = asc.slice();
+    const RATES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
+    const bits = new Bits(copy);
+    let objectType = bits.u(5);
+    if (objectType === 31)
+        objectType = 32 + bits.u(6);
+    const index = bits.u(4);
+    const sampleRate = index === 15 ? bits.u(24) : RATES[index] ?? 44100;
+    const channels = bits.u(4);
+    return { asc: copy, codec: `mp4a.40.${objectType}`, objectType, sampleRate, channels };
+}
+/** A bit reader over bytes, MSB first; a read past the end reads zeros. */
+class Bits {
+    bytes;
+    at = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    bit() { const byte = this.bytes[this.at >> 3] ?? 0; const v = (byte >> (7 - (this.at & 7))) & 1; this.at++; return v; }
+    u(n) { let v = 0; for (let i = 0; i < n; i++)
+        v = v * 2 + this.bit(); return v; }
+    ue() { let zeros = 0; while (this.bit() === 0) {
+        if (++zeros > 31)
+            throw new Error('exp-Golomb code too long');
+    } return 2 ** zeros - 1 + this.u(zeros); }
+    se() { const k = this.ue(); return k % 2 ? (k + 1) / 2 : -(k / 2); }
+}
+/** A sequence parameter set's picture size (H.264 §7.3.2.1.1), its cropping applied. */
+function spsSize(nal) {
+    // the NAL unit's RBSP: its header byte off, each emulation-prevention byte (00 00 03) removed
+    const rbsp = [];
+    for (let i = 1; i < nal.length; i++) {
+        if (i >= 3 && nal[i] === 3 && nal[i - 1] === 0 && nal[i - 2] === 0)
+            continue;
+        rbsp.push(nal[i]);
+    }
+    const b = new Bits(Uint8Array.from(rbsp));
+    const profile = b.u(8);
+    b.u(16);
+    b.ue();
+    let chroma = 1;
+    if ([100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 139, 134, 135].includes(profile)) {
+        chroma = b.ue();
+        if (chroma === 3)
+            b.bit();
+        b.ue();
+        b.ue();
+        b.bit();
+        if (b.bit()) {
+            for (let i = 0; i < (chroma === 3 ? 12 : 8); i++) {
+                if (!b.bit())
+                    continue;
+                let last = 8;
+                let next = 8;
+                for (let j = 0; j < (i < 6 ? 16 : 64); j++) {
+                    if (next !== 0)
+                        next = (last + b.se() + 256) % 256;
+                    last = next === 0 ? last : next;
+                }
+            }
+        }
+    }
+    b.ue();
+    const poc = b.ue();
+    if (poc === 0)
+        b.ue();
+    else if (poc === 1) {
+        b.bit();
+        b.se();
+        b.se();
+        const n = b.ue();
+        for (let i = 0; i < n; i++)
+            b.se();
+    }
+    b.ue();
+    b.bit();
+    const widthMbs = b.ue() + 1;
+    const heightUnits = b.ue() + 1;
+    const frameMbsOnly = b.bit();
+    if (!frameMbsOnly)
+        b.bit();
+    b.bit();
+    let crop = [0, 0, 0, 0];
+    if (b.bit())
+        crop = [b.ue(), b.ue(), b.ue(), b.ue()];
+    const unitX = chroma === 1 || chroma === 2 ? 2 : 1;
+    const unitY = (chroma === 1 ? 2 : 1) * (2 - frameMbsOnly);
+    return {
+        width: widthMbs * 16 - (crop[0] + crop[1]) * unitX,
+        height: (2 - frameMbsOnly) * heightUnits * 16 - (crop[2] + crop[3]) * unitY,
+    };
+}

package/dist/src/live/fmp4.d.ts

@@ -0,0 +1,25 @@
+import type { AacConfig, AvcConfig } from './flv.js';
+export declare const VIDEO_TRACK = 1;
+export declare const AUDIO_TRACK = 2;
+export declare const VIDEO_TIMESCALE = 90000;
+/** The init segment for the tracks a publish carries. */
+export declare function initSegment(tracks: {
+    video?: AvcConfig & {
+        width: number;
+        height: number;
+    };
+    audio?: AacConfig;
+}): Uint8Array;
+export type Sample = {
+    duration: number;
+    data: Uint8Array;
+    key: boolean;
+    cts?: number;
+};
+export type Fragment = {
+    track: number;
+    baseTime: number;
+    samples: Sample[];
+};
+/** A media segment: one `moof` over the fragments, then their samples in one `mdat`, video's first. */
+export declare function mediaSegment(sequence: number, fragments: Fragment[]): Uint8Array;

package/dist/src/live/fmp4.js

@@ -0,0 +1,96 @@
+export const VIDEO_TRACK = 1;
+export const AUDIO_TRACK = 2;
+export const VIDEO_TIMESCALE = 90_000;
+const ascii = (s) => Array.from(s, (c) => c.charCodeAt(0));
+const u16 = (n) => [(n >> 8) & 0xff, n & 0xff];
+const u32 = (n) => [(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff];
+const u64 = (n) => [...u32(Math.floor(n / 2 ** 32)), ...u32(n % 2 ** 32)];
+const zeros = (n) => new Array(n).fill(0);
+function box(type, ...parts) {
+    const size = 8 + parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(size);
+    out.set(u32(size), 0);
+    out.set(ascii(type), 4);
+    let at = 8;
+    for (const p of parts) {
+        out.set(p, at);
+        at += p.length;
+    }
+    return out;
+}
+const full = (type, version, flags, ...parts) => box(type, [version, (flags >> 16) & 0xff, (flags >> 8) & 0xff, flags & 0xff], ...parts);
+const MATRIX = [...u32(0x00010000), ...u32(0), ...u32(0), ...u32(0), ...u32(0x00010000), ...u32(0), ...u32(0), ...u32(0), ...u32(0x40000000)];
+function descriptor(tag, ...parts) {
+    const body = parts.flatMap((p) => Array.from(p));
+    // the size as four bytes of seven bits, as MP4 writers write it
+    const n = body.length;
+    return [tag, 0x80 | ((n >> 21) & 0x7f), 0x80 | ((n >> 14) & 0x7f), 0x80 | ((n >> 7) & 0x7f), n & 0x7f, ...body];
+}
+function trak(id, kind, timescale, width, height, entry) {
+    const tkhd = full('tkhd', 0, 3, u32(0), u32(0), u32(id), u32(0), u32(0), zeros(8), u16(0), u16(0), u16(kind === 'audio' ? 0x0100 : 0), u16(0), MATRIX, u32(width * 65536), u32(height * 65536));
+    const mdhd = full('mdhd', 0, 0, u32(0), u32(0), u32(timescale), u32(0), u16(0x55c4), u16(0));
+    const hdlr = full('hdlr', 0, 0, u32(0), ascii(kind === 'video' ? 'vide' : 'soun'), zeros(12), [...ascii(kind === 'video' ? 'VideoHandler' : 'SoundHandler'), 0]);
+    const header = kind === 'video' ? full('vmhd', 0, 1, u16(0), zeros(6)) : full('smhd', 0, 0, u16(0), u16(0));
+    const dinf = box('dinf', full('dref', 0, 0, u32(1), full('url ', 0, 1)));
+    const stbl = box('stbl', full('stsd', 0, 0, u32(1), entry), full('stts', 0, 0, u32(0)), full('stsc', 0, 0, u32(0)), full('stsz', 0, 0, u32(0), u32(0)), full('stco', 0, 0, u32(0)));
+    return box('trak', tkhd, box('mdia', mdhd, hdlr, box('minf', header, dinf, stbl)));
+}
+/** The init segment for the tracks a publish carries. */
+export function initSegment(tracks) {
+    const traks = [];
+    const trex = [];
+    const brands = ['isom', 'iso6', ...(tracks.video ? ['avc1'] : []), 'mp41'];
+    if (tracks.video) {
+        const v = tracks.video;
+        const avc1 = box('avc1', zeros(6), u16(1), u16(0), u16(0), zeros(12), u16(v.width), u16(v.height), u32(0x00480000), u32(0x00480000), u32(0), u16(1), zeros(32), u16(0x0018), u16(0xffff), box('avcC', v.record));
+        traks.push(trak(VIDEO_TRACK, 'video', VIDEO_TIMESCALE, v.width, v.height, avc1));
+        trex.push(full('trex', 0, 0, u32(VIDEO_TRACK), u32(1), u32(0), u32(0), u32(0)));
+    }
+    if (tracks.audio) {
+        const a = tracks.audio;
+        const esds = full('esds', 0, 0, descriptor(3, u16(0), [0], descriptor(4, [0x40, 0x15], zeros(3), u32(0), u32(0), descriptor(5, a.asc)), descriptor(6, [0x02])));
+        const mp4a = box('mp4a', zeros(6), u16(1), zeros(8), u16(Math.max(1, a.channels)), u16(16), u16(0), u16(0), u32((a.sampleRate > 0xffff ? 0 : a.sampleRate) * 65536), esds);
+        traks.push(trak(AUDIO_TRACK, 'audio', a.sampleRate, 0, 0, mp4a));
+        trex.push(full('trex', 0, 0, u32(AUDIO_TRACK), u32(1), u32(0), u32(0), u32(0)));
+    }
+    const mvhd = full('mvhd', 0, 0, u32(0), u32(0), u32(1000), u32(0), u32(0x00010000), u16(0x0100), u16(0), zeros(8), MATRIX, zeros(24), u32(3));
+    const ftyp = box('ftyp', ascii('isom'), u32(0x200), ...brands.map(ascii));
+    const moov = box('moov', mvhd, ...traks, box('mvex', ...trex));
+    const out = new Uint8Array(ftyp.length + moov.length);
+    out.set(ftyp, 0);
+    out.set(moov, ftyp.length);
+    return out;
+}
+/** A media segment: one `moof` over the fragments, then their samples in one `mdat`, video's first. */
+export function mediaSegment(sequence, fragments) {
+    const present = fragments.filter((f) => f.samples.length > 0);
+    const moofOf = (offsets) => box('moof', full('mfhd', 0, 0, u32(sequence)), ...present.map((f, i) => {
+        const video = f.track === VIDEO_TRACK;
+        // data offset, duration, size, flags and (video) composition offset per sample; version 1 for signed offsets
+        const flags = video ? 0x000f01 : 0x000301;
+        const rows = f.samples.flatMap((s) => [
+            ...u32(s.duration), ...u32(s.data.length),
+            ...(video ? [...u32(s.key ? 0x02000000 : 0x01010000), ...u32((s.cts ?? 0) | 0)] : []),
+        ]);
+        return box('traf', full('tfhd', 0, 0x020000, u32(f.track)), full('tfdt', 1, 0, u64(f.baseTime)), full('trun', video ? 1 : 0, flags, u32(f.samples.length), u32(offsets[i] | 0), rows));
+    }));
+    const sized = moofOf(present.map(() => 0)).length;
+    const offsets = [];
+    let at = sized + 8;
+    for (const f of present) {
+        offsets.push(at);
+        at += f.samples.reduce((n, s) => n + s.data.length, 0);
+    }
+    const moof = moofOf(offsets);
+    // one buffer for the whole segment, the samples written straight into its mdat: a segment's bytes are copied once
+    const out = new Uint8Array(at);
+    out.set(moof, 0);
+    out.set([...u32(at - moof.length), ...ascii('mdat')], moof.length);
+    let to = moof.length + 8;
+    for (const f of present)
+        for (const s of f.samples) {
+            out.set(s.data, to);
+            to += s.data.length;
+        }
+    return out;
+}