@volter/world-core 3.0.151 → 3.0.153

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/events.d.ts

@@ -140,11 +140,11 @@ export type EventDelivery = {
 /** The transport a delivery is made over; the World's by default, a test's own when given. */
 export type EventTransport = (url: string, body: string, headers: Record<string, string>) => Promise<number | void>;
 /** A signature scheme's headers for one delivery: deterministic (the id is derived from the delivery itself). */
-/** `seq` tells apart two identical deliveries at one instant (a frozen World clock): the World's count of deliveries
- *  made before this one, so a receiver that deduplicates by id drops neither. */
-export declare function signEvent(scheme: EventScheme, secret: string, body: string, seconds: number, url: string, seq?: number): Record<string, string>;
+/** `seq` tells apart deliveries at one instant; the declared-event path reserves it durably. `identity` supplies that
+ *  occurrence's namespace. Omitted, existing direct callers retain their deterministic signing contract. */
+export declare function signEvent(scheme: EventScheme, secret: string, body: string, seconds: number, url: string, seq?: number, identity?: string): Record<string, string>;
 /** Every scheme's headers for one delivery, merged. */
-export declare function signEventAll(schemes: EventScheme | ReadonlyArray<EventScheme>, secret: string, body: string, seconds: number, url: string, seq?: number): Record<string, string>;
+export declare function signEventAll(schemes: EventScheme | ReadonlyArray<EventScheme>, secret: string, body: string, seconds: number, url: string, seq?: number, identity?: string): Record<string, string>;
 /** A delivery's signature checked as its receiver checks it (a Standard Webhooks verifier, a timestamp-v1 verifier, a plain
  *  HMAC header): true when one of its signatures is the one the secret makes (constant time), and its timestamp,
  *  when the scheme sends one, is within `tolerance` seconds of `now`. */

package/dist/src/events.js

@@ -7,7 +7,7 @@
 // Imports stay free of side effects: the delivery's transport (Node's http, the World's egress policy) is loaded when a
 // delivery is made, never when a browser client imports the kernel.
 import { createHash, createHmac } from 'node:crypto';
-import { applyTwinWrite, twinResources } from "./serve.js";
+import { applyTwinWrite, applyTwinWriteAtomic, twinResources } from "./serve.js";
 import { equalSecrets as same, ksuidFrom } from "./signing.js";
 import { deliveryTraceHeaders } from "./trace-context.js";
 /** Whether an endpoint takes an event by its `match`: every field of one match (any, when several) equal to the event's
@@ -25,16 +25,15 @@ function matches(row, match, filled) {
     });
     return Array.isArray(match) ? match.some(one) : one(match);
 }
-const digest = (s) => createHash('sha256').update(s).digest('hex');
 /** A `webhook-id` scheme's key: the base64 part of the secret, after its prefix when it carries one. */
 const webhookKey = (scheme, secret) => scheme.secretKey === 'utf8' ? Buffer.from(secret, 'utf8') : Buffer.from(scheme.secretPrefix && secret.startsWith(scheme.secretPrefix) ? secret.slice(scheme.secretPrefix.length) : secret, 'base64');
 /** A signature scheme's headers for one delivery: deterministic (the id is derived from the delivery itself). */
-/** `seq` tells apart two identical deliveries at one instant (a frozen World clock): the World's count of deliveries
- *  made before this one, so a receiver that deduplicates by id drops neither. */
-export function signEvent(scheme, secret, body, seconds, url, seq = 0) {
+/** `seq` tells apart deliveries at one instant; the declared-event path reserves it durably. `identity` supplies that
+ *  occurrence's namespace. Omitted, existing direct callers retain their deterministic signing contract. */
+export function signEvent(scheme, secret, body, seconds, url, seq = 0, identity) {
     if (scheme.kind === 'webhook-id') {
         // Svix's `msg_` and a KSUID (its ids' form), derived from the delivery itself
-        const id = `msg_${ksuidFrom(seconds, seq, `${url}|${seconds}|${seq}|${body}`)}`;
+        const id = `msg_${ksuidFrom(seconds, seq, identity ?? `${url}|${seconds}|${seq}|${body}`)}`;
         const p = scheme.prefix.toLowerCase();
         const signature = createHmac('sha256', webhookKey(scheme, secret)).update(`${id}.${seconds}.${body}`, 'utf8').digest('base64');
         return { [`${p}-id`]: id, [`${p}-timestamp`]: String(seconds), [`${p}-signature`]: `v1,${signature}` };
@@ -58,8 +57,24 @@ const hashOf = (scheme, secret, body) => {
 /** What an `hmac` scheme signs: its `signed` template, else `${t}.${body}` with a timestamp header, else the body. */
 const hmacBase = (scheme, seconds, body) => scheme.signed !== undefined ? scheme.signed.replaceAll('{t}', String(seconds)).replaceAll('{body}', body) : scheme.timestampHeader ? `${seconds}.${body}` : body;
 /** Every scheme's headers for one delivery, merged. */
-export function signEventAll(schemes, secret, body, seconds, url, seq = 0) {
-    return Object.assign({}, ...(Array.isArray(schemes) ? schemes : [schemes]).map((scheme) => signEvent(scheme, secret, body, seconds, url, seq)));
+export function signEventAll(schemes, secret, body, seconds, url, seq = 0, identity) {
+    return Object.assign({}, ...(Array.isArray(schemes) ? schemes : [schemes]).map((scheme) => signEvent(scheme, secret, body, seconds, url, seq, identity)));
+}
+/** Reserve occurrences under the same cross-process lock that appends actions. This private retained row is never a
+ *  vendor resource. Deleted event/delivery rows, concurrent renders and restarts cannot give its ordinals back. */
+async function reserveEventOrdinals(service, root, occurredAt, count) {
+    const { value } = await applyTwinWriteAtomic(service, (resources) => {
+        const counter = resources.find((r) => r.type === '_world_event_sequence' && r.id === 'sequence');
+        const last = counter === undefined ? 0 : counter.last_ordinal;
+        if (typeof last !== 'number' || !Number.isSafeInteger(last) || last < 0 || !Number.isSafeInteger(count) || count < 1 || !Number.isSafeInteger(last + count)) {
+            throw new Error('Invalid retained declared-event sequence; occurrence ids cannot be reused.');
+        }
+        return { kind: 'write', value: last + 1, write: {
+                operation: 'world_event_sequence.reserve', subjectType: '_world_event_sequence', subjectId: 'sequence',
+                fields: { last_ordinal: last + count }, input: { clock: true }, occurredAt, actor: { kind: 'system' },
+            } };
+    }, root);
+    return value;
 }
 /** A delivery's signature checked as its receiver checks it (a Standard Webhooks verifier, a timestamp-v1 verifier, a plain
  *  HMAC header): true when one of its signatures is the one the secret makes (constant time), and its timestamp,
@@ -282,11 +297,19 @@ async function deliverEventType(service, decl, write, data, transport, values, t
     const seconds = Math.floor(millis / 1000);
     const eventData = await data(type);
     const extra = values ? await values(type) : {};
-    // the World's count of events kept so far tells apart two identical events at one instant (a frozen clock)
-    const kept = decl.store !== undefined ? all.filter((r) => r.type === decl.store).length : 0;
+    // Reserve one event and at most one delivery per live endpoint before assigning identities. Unused ordinals are
+    // harmless gaps; a failed render/store never gives them back. This is not an atomic originating-write outbox.
+    const ordinal = await reserveEventOrdinals(service, write.root, write.occurredAt, 1 + live.length);
+    // Fresh/forked Worlds can reserve the same ordinal at a pinned clock. Keep
+    // content binding as well as the lineage's occurrence ordinal, so different
+    // event payloads cannot reuse a receiver's event/webhook id across those Worlds.
+    const eventContent = createHash('sha256').update(JSON.stringify({
+        operation: write.operation, type, data: eventData, envelope: decl.envelope,
+        values: extra, request: requestValues(write.request),
+    }), 'utf8').digest('hex');
     const filled = {
         $type: type, $data: eventData,
-        $id: `evt_${ksuidFrom(seconds, kept, `${type}|${write.occurredAt}|${kept}|${JSON.stringify(eventData)}`)}`,
+        $id: `evt_${ksuidFrom(seconds, ordinal, `world-events:v1:${service}:${type}:${ordinal}:${eventContent}`)}`,
         '$time.ms': millis, '$time.s': seconds, '$time.iso': write.occurredAt,
         ...requestValues(write.request),
         ...extra,
@@ -305,18 +328,19 @@ async function deliverEventType(service, decl, write, data, transport, values, t
     const shared = JSON.stringify(envelope);
     const each = perEndpoint(decl.envelope);
     const sent = [];
-    const before = decl.record !== undefined ? all.filter((r) => r.type === decl.record).length : 0;
     for (const [i, { row, kind }] of endpoints.entries()) {
         const body = each ? JSON.stringify(fillEnvelope(decl.envelope, filled, row)) : shared;
         const url = String(at(row, kind.url));
-        const seq = before + i;
+        const seq = ordinal + 1 + i;
+        const deliveryContent = createHash('sha256').update(url, 'utf8').update('\0').update(body, 'utf8').digest('hex');
+        const identity = `world-events:v1:${service}:${seq}:${deliveryContent}`;
         const extraHeaders = decl.headers ? headersFor(decl.headers, filled, row) : {};
-        const headers = { ...extraHeaders, ...signEventAll(decl.scheme, String(at(row, kind.secret)), body, seconds, url, seq) };
+        const headers = { ...extraHeaders, ...signEventAll(decl.scheme, String(at(row, kind.secret)), body, seconds, url, seq, identity) };
         sent.push({ url, body, headers });
         // kept with the write, by an id of the delivery itself (two made at once never take the same one)
         if (decl.record !== undefined) {
             await applyTwinWrite(service, {
-                operation: `${decl.record.slice(1)}.record`, subjectType: decl.record, subjectId: `${decl.record.slice(1)}_${digest(`${url}|${seconds}|${seq}|${body}`).slice(0, 16)}`,
+                operation: `${decl.record.slice(1)}.record`, subjectType: decl.record, subjectId: `${decl.record.slice(1)}_v1_${seq}`,
                 fields: { url, body, headers, event_type: type, sent_at: millis }, occurredAt: write.occurredAt, actor: { kind: 'system' },
             }, write.root);
         }

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;