@volter/world-core 3.0.163 → 3.0.164

package/src/derived-core.ts

@@ -11,7 +11,7 @@ import { parseExactJson, compareExactNumbers, exactInteger, isExactIntegerValue
 import { applyTwinWrite, applyTwinWriteAtomic, applyTwinWrites, twinResources, type TwinResource } from './serve.ts';
 import { copyResource, foldLocalWrite, heldSubject, ownFields, parentStamp, subjectHistory, treeChangesSince, treeResources, treeStamp, type Subject } from './log.ts';
 import { performsAtHeadNow } from './head.ts';
-import { getActiveWorldStore } from './world-store.ts';
+import { getActiveWorldStore, type WorldStore } from './world-store.ts';
 import { getActiveBlobStore } from './blob-store.ts';
 import { worldPaths } from './storage.ts';
 import { GitObjectStore } from './git/objects.ts';
@@ -937,7 +937,7 @@ export type CoreScope = {
   root?: string; clock?: () => string; database?: string; readOnly?: boolean;
   /** `semantics/tenant.ts`: the tenant the caller acts in (the manifest's `tenant`), or undefined for none */
   tenant?: (ctx: HandlerContext) => string | undefined | Promise<string | undefined>;
-  /** the application a walk stands in for: what the vendor asks it (`ctx.ask`) is answered by it (events.ts) */
+  /** the application a walk stands in for: vendor requests and declared events are answered by it (events.ts) */
   application?: ApplicationStandIn;
 };
 
@@ -1138,9 +1138,9 @@ function mintId(m: DerivedManifest, resource: string, root: string | undefined,
  *  increment. One space over every snowflake resource of the vendor, as its one generator's: the instant's first, or one
  *  past the greatest the World holds when that is later (a frozen clock, or several ids in one millisecond), so ids
  *  rise with time and never repeat. */
-/** The last snowflake minted per vendor and World in this process: two mints before the first is written (a message
+/** The last snowflake minted per store, vendor and World: two mints before the first is written (a message
  *  and its attachment) must not meet. */
-const lastSnowflake = new Map<string, bigint>();
+const lastSnowflake = new WeakMap<WorldStore, Map<string, bigint>>();
 function mintSnowflake(m: DerivedManifest, epoch: bigint, root: string | undefined, at: string, snapshot?: readonly TwinResource[]): string {
   const ms = BigInt(Date.parse(at) || 0);
   const base = ms > epoch ? (ms - epoch) << 22n : 0n;
@@ -1149,11 +1149,13 @@ function mintSnowflake(m: DerivedManifest, epoch: bigint, root: string | undefin
     if (!/^\{snowflake:\d+\}$/.test(decl.ids ?? m.ids.template)) continue;
     for (const r of mintRows(m, name, root, snapshot)) if (/^\d+$/.test(r.id)) { const v = BigInt(r.id); if (v > max) max = v; }
   }
+  const store = getActiveWorldStore();
+  const reservations = lastSnowflake.get(store) ?? lastSnowflake.set(store, new Map()).get(store)!;
   const key = `${m.service}\0${root ?? ''}`;
-  const last = lastSnowflake.get(key) ?? -1n;
+  const last = reservations.get(key) ?? -1n;
   const floor = max > last ? max : last;
   const id = base > floor ? base : floor + 1n;
-  lastSnowflake.set(key, id);
+  reservations.set(key, id);
   return String(id);
 }
 
@@ -1452,7 +1454,7 @@ async function finishWrite(m: DerivedManifest, call: DerivedCall, resource: stri
     const endpoint = (kind: import('./events.ts').EndpointsDecl): import('./events.ts').EndpointsDecl => ({ ...kind, storedAs: storedType(m, kind.storedAs), ...(kind.joins ? { joins: Object.fromEntries(Object.entries(kind.joins).map(([name, join]) => [name, { ...join, storedAs: storedType(m, join.storedAs) }])) } : {}) });
     const events = { ...m.events, ...(m.events.store ? { store: storedType(m, m.events.store) } : {}), endpoints: 'storedAs' in m.events.endpoints ? endpoint(m.events.endpoints) : m.events.endpoints.map(endpoint) };
     const write = { operation, storedType: m.resources[resource]?.storedAs ?? resource, body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() };
-    await deliverEvents(m.service, events, write, async (type) => (events.render ? events.render(await context(), write, type) : body), undefined, events.values ? async (type) => events.values!(await context(), write, type) : undefined);
+    await deliverEvents(m.service, events, write, async (type) => (events.render ? events.render(await context(), write, type) : body), undefined, events.values ? async (type) => events.values!(await context(), write, type) : undefined, scopeOfCall.get(call)?.application);
   }
   if (m.sockets?.length) socketWrite(m.service, root, { operation, storedType: m.resources[resource]?.storedAs ?? resource, body, ...(root !== undefined ? { root } : {}), occurredAt, request: request.clone() });
   // a read held until the World writes (held-reads.ts) hears it

package/src/derived-real.ts

@@ -583,8 +583,8 @@ function refreshOf(units: Unit[], service: string): NonNullable<StateSystemAdapt
             const sent = asked.length ? `${target}${target.includes('?') ? '&' : '?'}${new URLSearchParams(asked)}` : target;
             const answer = await execute({ method: op.method.toUpperCase(), path: sentTo(m, sent, subject), ...onLane, headers: fixedHeaders(op) });
             // a door's subject the vendor does not show the root (another bot's private chat) stays as the World holds it
-            if (!rooted.has(key) && answer.status >= 400 && answer.status !== 429) continue;
             if (answer.status === 401) throw new Error(`401: the vendor refused the root's credential (${op.method.toUpperCase()} ${path}); nothing folded`);
+            if (!rooted.has(key) && answer.status >= 400 && answer.status !== 429) continue;
             if (answer.status === 403) { unread.push({ type, path, status: 403 }); refused = true; break; }
             if (answer.status === 429) throw new Error(`429: rate limited${answer.headers['retry-after'] ? `, retry after ${answer.headers['retry-after']}s` : ''}`);
             read.push(String(subject.id));
@@ -592,7 +592,15 @@ function refreshOf(units: Unit[], service: string): NonNullable<StateSystemAdapt
             // the vendor's answer for a subject it no longer has: a 404, or the scope's `gone` (Telegram's 400 `chat not found`)
             if (answer.status === 404 || (scope.gone && answer.status === scope.gone.status && refusalWords(m, parse(answer)).includes(scope.gone.says))) continue;
             if (answer.status >= 400 || refusedIn(m, parse(answer))) throw new Error(`${m.vendor}: ${resource} refresh ${op.id} (${op.method.toUpperCase()} ${op.path}): ${answer.status}: ${refusalWords(m, parse(answer))}`);
-            const full = object(op.answers?.key ? at(parse(answer), op.answers.key) : parse(answer)) ?? {};
+            const parsed = parse(answer);
+            let full: Row;
+            if (op.answers?.list) {
+              const items = itemsOf(op, parsed);
+              const matching = items.find((item) => (scopeIdOf(scope, item) ?? storedIdOf(decl, item)) === vendorId);
+              if (!matching && items.length) throw new Error(`${m.vendor}: ${resource} refresh ${op.id} omitted the requested subject; nothing folded`);
+              if (!matching) continue;
+              full = matching;
+            } else full = object(op.answers?.key ? at(parsed, op.answers.key) : parsed) ?? {};
             const local = (m as { worldFields?: Record<string, Record<string, unknown>> }).worldFields?.[resource] ?? {};
             const fields = Object.fromEntries(Object.entries(full).filter(([k]) => !(k in local)));
             if (decl.parent) {

package/src/events.ts

@@ -7,11 +7,12 @@
 // 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 { resolve } from 'node:path';
 import { applyTwinWrite, applyTwinWriteAtomic, twinResources } from './serve.ts';
 import { equalSecrets as same, ksuidFrom } from './signing.ts';
 import { deliveryTraceHeaders } from './trace-context.ts';
 import { sendRecordedEvent } from './event-delivery.ts';
-import { getActiveWorldStore, withWorldStore } from './world-store.ts';
+import { getActiveWorldStore, withWorldStore, type WorldStore } from './world-store.ts';
 import { worldPaths } from './storage.ts';
 
 /** How the vendor signs a delivery. */
@@ -306,6 +307,26 @@ const worldTransport: EventTransport = async (url, body, headers) => {
   try { return ((await appFetch(url, { method: 'POST', headers: { 'content-type': 'application/json', ...headers }, body })) as { status: number }).status; } catch { return 0; }
 };
 
+const pendingDeliveries = new WeakMap<WorldStore, Map<string, Set<Promise<void>>>>();
+
+function forgetDeliveries(store: WorldStore, root: string, deliveries: Iterable<Promise<void>>): void {
+  const roots = pendingDeliveries.get(store), pending = roots?.get(root);
+  if (!pending) return;
+  for (const delivery of deliveries) pending.delete(delivery);
+  if (!pending.size) roots!.delete(root);
+  if (!roots!.size) pendingDeliveries.delete(store);
+}
+
+/** Await already-scheduled first dispatches and consume their retained persistence failures. */
+export async function settleEventDeliveries(root: string): Promise<void> {
+  const store = getActiveWorldStore(), path = resolve(root);
+  const deliveries = [...(pendingDeliveries.get(store)?.get(path) ?? [])];
+  const outcomes = await Promise.allSettled(deliveries);
+  forgetDeliveries(store, path, deliveries);
+  const failures = outcomes.flatMap((outcome) => outcome.status === 'rejected' ? [outcome.reason] : []);
+  if (failures.length) throw new AggregateError(failures, 'Declared-event dispatch failed');
+}
+
 /** Who watches signed packets before dispatch (a walk reading each as its receiver would). This is not evidence of
  *  transport or acceptance. Set and restored by the walk, as its World store is; unset, nothing watches. */
 export type DeliveryObserver = (delivery: EventDelivery & { service: string }) => void;
@@ -321,13 +342,14 @@ export function setDeliveryObserver(observer: DeliveryObserver | undefined): Del
  *  (`unreachable`), or it did not answer in time (`timeout`). */
 export type ApplicationAnswer = { status: number; headers: Record<string, string>; body: string; missed?: 'timeout' | 'unreachable' };
 
-/** Who answers what the vendor asks the application (`ctx.ask`) before the World's application route does, given to a
+/** Who answers a vendor's requests to the application before the World's application route does, given to a
  *  pack's fetch (`PackFetchOptions.application`) and belonging to that fetch alone: an answer it gives is the
  *  application's; `'unreachable'` is a question nobody answers (a walk's life, a sealed World, takes no other); undefined
  *  is a question it does not take, which goes on as any other does: the application route, the World's egress rule, the
  *  network. A walk's stand-in answers every question (its life's answers, else unreachable); a hosted World's router
  *  answers only what it can answer truthfully (WorldDoors.askInWorld) and leaves the rest. `bodyError` models a
- *  disconnect after the response headers; a caller needing the complete body receives no complete answer. */
+ *  disconnect after the response headers; a caller needing the complete body receives no complete answer, while an
+ *  event dispatch acknowledges the response status without reading its body. */
 export type ApplicationStandIn = (url: string, init: RequestInit) => Promise<{ status: number; headers?: Record<string, string>; body: string; bodyError?: string } | 'unreachable' | undefined>;
 
 /** A message the vendor sends the application's server and decides by its answer (Stripe's real-time authorization
@@ -367,10 +389,15 @@ export async function deliverEvents(
   data: (type: string) => Promise<Record<string, unknown>>,
   transport: EventTransport = worldTransport,
   values?: (type: string) => Promise<Record<string, unknown>>,
+  application?: ApplicationStandIn,
 ): Promise<EventDelivery[]> {
   if (write.storedType === decl.store) return [];
+  const dispatch: EventTransport = application ? async (url, body, headers) => {
+    const answer = await application(url, { method: 'POST', headers: { 'content-type': 'application/json', ...headers }, body });
+    return answer === undefined ? transport(url, body, headers) : answer === 'unreachable' ? 0 : answer.status;
+  } : transport;
   const sent: EventDelivery[] = [];
-  for (const type of eventTypesOf(decl, write.operation)) sent.push(...(await deliverEventType(service, decl, write, data, transport, values, type)));
+  for (const type of eventTypesOf(decl, write.operation)) sent.push(...(await deliverEventType(service, decl, write, data, dispatch, values, type)));
   return sent;
 }
 
@@ -466,10 +493,28 @@ async function deliverEventType(
   // active before it runs. Transport completion writes to the same retained state.
   const store = getActiveWorldStore(), deliveryRoot = worldPaths(service, write.root).root;
   for (const d of sent) deliveryObserver?.({ ...d, service });
-  for (const packet of recorded) setTimeout(() => {
-    // Persistence failure leaves a queued/sending claim for explicit recovery;
-    // it must not fail the already-committed vendor write or cause a blind resend.
-    void withWorldStore(store, () => sendRecordedEvent(service, packet.type, packet.id, deliveryRoot, transport, trace)).catch(() => {});
-  }, 0);
+  const roots = pendingDeliveries.get(store) ?? new Map<string, Set<Promise<void>>>();
+  pendingDeliveries.set(store, roots);
+  const pending = roots.get(deliveryRoot) ?? new Set<Promise<void>>();
+  roots.set(deliveryRoot, pending);
+  for (const packet of recorded) {
+    let finish!: () => void;
+    let fail!: (reason: unknown) => void;
+    const dispatched = new Promise<void>((done, reject) => { finish = done; fail = reject; });
+    // Live writes return before dispatch; an explicit settlement reports persistence failures.
+    void dispatched.catch(() => {});
+    pending.add(dispatched);
+    setTimeout(async () => {
+      try {
+        await withWorldStore(store, () => sendRecordedEvent(service, packet.type, packet.id, deliveryRoot, transport, trace));
+        finish();
+        forgetDeliveries(store, deliveryRoot, [dispatched]);
+      } catch (error) {
+        // Keep the rejection until explicit settlement consumes it. The queued/sending claim remains for
+        // native recovery; this must not fail the already-committed vendor write or cause a blind resend.
+        fail(error);
+      }
+    }, 0);
+  }
   return sent;
 }

package/src/file-response.ts

@@ -25,10 +25,16 @@ export function fileResponse(path: string, init?: ResponseInit): Response {
  * Stored bytes as a response, honouring a single `Range: bytes=` as RFC 9110 §14 has it: every satisfiable range is a
  * 206 with its Content-Range, `bytes=0-` (the whole body) included; a range that does not parse, a first-byte-pos past
  * its last-byte-pos (`bytes=5-2`) included, is ignored and the whole body is a 200; a well-formed range that starts past
- * the end (any range of an empty body) is a 416. `nosniff` stops a browser second-guessing the content type the vendor gave.
+ * the end (any range of an empty body) is a 416. Lazy sources supply inclusive ranges and stream in bounded reads.
+ * `nosniff` stops a browser second-guessing the content type the vendor gave.
  */
-export function bytesResponse(request: Request, bytes: Uint8Array, contentType: string, cacheControl = 'public, max-age=604800, immutable'): Response {
-  const total = bytes.length;
+export function bytesResponse(
+  request: Request,
+  bytes: Uint8Array | { size: number; range(start: number, end: number): Promise<Uint8Array | null> },
+  contentType: string,
+  cacheControl = 'public, max-age=604800, immutable',
+): Response {
+  const total = bytes instanceof Uint8Array ? bytes.length : bytes.size;
   const base = { 'content-type': contentType, 'x-content-type-options': 'nosniff', 'accept-ranges': 'bytes', 'cache-control': cacheControl };
   const range = /^bytes=(\d*)-(\d*)$/.exec((request.headers.get('range') ?? '').trim());
   let start = 0;
@@ -44,9 +50,25 @@ export function bytesResponse(request: Request, bytes: Uint8Array, contentType:
   // every satisfiable range is answered as one, the whole body's `bytes=0-` included: a media player (Safari's) reads a
   // 206 with its Content-Range as the server taking ranges, and a 200 as one it cannot seek in
   const partial = valid;
-  const body = bytes.slice(start, end + 1);
-  return new Response(request.method === 'HEAD' ? null : new Blob([body]), {
+  let body: BodyInit | null = null;
+  if (request.method !== 'HEAD') {
+    if (bytes instanceof Uint8Array) body = new Blob([bytes.slice(start, end + 1)]);
+    else {
+      let at = start;
+      body = new ReadableStream<Uint8Array>({
+        async pull(controller) {
+          if (at > end) { controller.close(); return; }
+          const last = Math.min(at + 8 * 1024 * 1024 - 1, end);
+          const chunk = await bytes.range(at, last);
+          if (!chunk) { controller.error(new Error('stored bytes are gone')); return; }
+          controller.enqueue(chunk);
+          at = last + 1;
+        },
+      });
+    }
+  }
+  return new Response(body, {
     status: partial ? 206 : 200,
-    headers: { ...base, 'content-length': String(body.length), ...(partial ? { 'content-range': `bytes ${start}-${end}/${total}` } : {}) },
+    headers: { ...base, 'content-length': String(end + 1 - start), ...(partial ? { 'content-range': `bytes ${start}-${end}/${total}` } : {}) },
   });
 }

package/src/index.ts

@@ -89,6 +89,7 @@ export * as protobuf from './protobuf.ts';
 export * as grpc from './grpc-wire.ts';
 export { acceptH2Connection, type H2Handler, type Http1Handler } from './h2.ts';
 export { placeholderPng } from './placeholder-image.ts';
+export { imageDimensions, readImageHeader, readMp4Header } from './media-header.ts';
 export { presignSigV4, signSigV4, verifySigV4, type SigV4Verdict } from './sigv4.ts';
 export * as redis from './redis/index.ts';
 export * as mysql from './mysql/index.ts';
@@ -102,7 +103,7 @@ export type { PackScenarioAdapter, ScenarioDecision, ScenarioDocument, ScenarioE
 
 export { verifyAttestationBundle } from './attestation.ts';
 
-export { browserSessionToken, startBrowserSession, endBrowserSession } from './browser-session.ts';
+export { cookieOf, signedIn, browserSessionToken, startBrowserSession, endBrowserSession } from './browser-session.ts';
 
 export { readHostPort } from './host-port.ts';
 export { assertBrowserName, browserOrigin, validateBrowserState, validateBrowserStorageState, validateBrowserContext, browserAcceptLanguage, cookieMatchesHost, type BrowserCookie, type BrowserState, type BrowserStorageState, type BrowserContext, type BrowserIndexedDB } from './browser-state.ts';

package/src/managed-database.ts

@@ -254,10 +254,10 @@ export function managedDatabase(url: string, options: { readOnly?: boolean } = {
  *  walk/journey-kit.ts), its statements sent as its client sends them: a text alone as one simple Query (a migration
  *  file, a `BEGIN`), a text with values as one extended-protocol statement, the values bind parameters. A transaction it
  *  opens stays open across its statements until it ends it, as on the application's own connection. Each statement's
- *  answer is its results in Postgres's text format, untyped. */
-export type DatabaseSession = { query(text: string, values?: ReadonlyArray<string | null>): Promise<StatementResult[]>; end(): Promise<void> };
+ *  answer is its results in Postgres's text format, with native column type OIDs retained beside the values. */
+export type DatabaseSession = { query(text: string, values?: ReadonlyArray<string | null>): Promise<Array<StatementResult & { fieldTypes: number[] }>>; end(): Promise<void> };
 
-type PgResult = { command?: string | null; rowCount?: number | null; fields?: Array<{ name: string }>; rows?: Array<Array<string | null>> };
+type PgResult = { command?: string | null; rowCount?: number | null; fields?: Array<{ name: string; dataTypeID: number }>; rows?: Array<Array<string | null>> };
 
 /** The World's Postgres at `url` as one connection held until `end()`. */
 export async function databaseSession(url: string): Promise<DatabaseSession> {
@@ -277,6 +277,7 @@ export async function databaseSession(url: string): Promise<DatabaseSession> {
         const answer = (await (client.query({ text, ...(values === undefined ? {} : { values }), rowMode: 'array', types: raw }) as Promise<PgResult | PgResult[]>));
         return (Array.isArray(answer) ? answer : [answer]).map((r) => ({
           fields: (r.fields ?? []).map((f) => f.name),
+          fieldTypes: (r.fields ?? []).map((f) => f.dataTypeID),
           rows: r.rows ?? [],
           command: [r.command ?? '', r.command === 'INSERT' ? '0' : '', r.rowCount ?? ''].filter((part) => part !== '').join(' '),
         }));

package/src/media-header.ts

@@ -0,0 +1,108 @@
+// File-format headers only: no decoding, vendor limits, processing or rendition policy.
+type ImageType = 'image/png' | 'image/gif' | 'image/jpeg' | 'image/webp';
+type Dimensions = { width: number; height: number };
+type ImageHeader = Dimensions & { jpeg?: { frameEnd: number; nonMarkerBytes: boolean; standaloneMarkers: boolean; fillBytes: boolean; shortSegments: boolean } };
+
+const tag = (bytes: Uint8Array, at: number): string => String.fromCharCode(...bytes.subarray(at, at + 4));
+
+/** Dimensions in a caller-declared image format, or undefined for an incomplete header. */
+export function imageDimensions(bytes: Uint8Array, type: ImageType): ImageHeader | undefined {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (type === 'image/png') return bytes.length >= 24 ? { width: view.getUint32(16), height: view.getUint32(20) } : undefined;
+  if (type === 'image/gif') return bytes.length >= 10 ? { width: view.getUint16(6, true), height: view.getUint16(8, true) } : undefined;
+  if (type === 'image/webp') {
+    if (bytes.length < 30) return undefined;
+    const chunk = tag(bytes, 12);
+    if (chunk === 'VP8 ') return { width: view.getUint16(26, true) & 0x3fff, height: view.getUint16(28, true) & 0x3fff };
+    if (chunk === 'VP8L') {
+      const bits = view.getUint32(21, true);
+      return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >>> 14) & 0x3fff) };
+    }
+    if (chunk === 'VP8X') {
+      const u24 = (at: number): number => bytes[at]! | (bytes[at + 1]! << 8) | (bytes[at + 2]! << 16);
+      return { width: 1 + u24(24), height: 1 + u24(27) };
+    }
+    return undefined;
+  }
+  let at = 2;
+  const jpeg = { frameEnd: 0, nonMarkerBytes: false, standaloneMarkers: false, fillBytes: false, shortSegments: false };
+  while (at + 4 <= bytes.length) {
+    if (bytes[at] !== 0xff) { jpeg.nonMarkerBytes = true; at += 1; continue; }
+    const marker = bytes[at + 1]!;
+    if (marker === 0xff) { jpeg.fillBytes = true; at += 1; continue; }
+    if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) { jpeg.standaloneMarkers = true; at += 2; continue; }
+    const length = view.getUint16(at + 2);
+    if (length < 2) jpeg.shortSegments = true;
+    if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+      return at + 9 <= bytes.length ? { width: view.getUint16(at + 7), height: view.getUint16(at + 5), jpeg: { ...jpeg, frameEnd: at + 9 } } : undefined;
+    }
+    if (marker === 0xda) return undefined;
+    at += 2 + length;
+  }
+  return undefined;
+}
+
+/** An image's signature and dimensions, without deciding whether a vendor accepts that format or size. */
+export function readImageHeader(bytes: Uint8Array): (ImageHeader & { type: ImageType }) | undefined {
+  let type: ImageType;
+  if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) type = 'image/png';
+  else if (tag(bytes, 0).startsWith('GIF')) type = 'image/gif';
+  else if (bytes[0] === 0xff && bytes[1] === 0xd8) type = 'image/jpeg';
+  else if (tag(bytes, 0) === 'RIFF' && tag(bytes, 8) === 'WEBP') type = 'image/webp';
+  else return undefined;
+  const dimensions = imageDimensions(bytes, type);
+  return dimensions ? { type, ...dimensions } : undefined;
+}
+
+/** ISO BMFF's bounded top-level boxes and movie headers, with raw duration and 16.16 track dimensions. */
+export function readMp4Header(bytes: Uint8Array): {
+  fileType: boolean;
+  hasMediaData: boolean;
+  movies: Array<{ headers: Array<{ timescale: number; duration: number; payloadSize: number }>; tracks: Dimensions[] }>;
+} {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  function* boxes(from: number, to: number): Generator<{ type: string; start: number; end: number }> {
+    let at = from;
+    while (at + 8 <= to) {
+      let size = view.getUint32(at);
+      const type = tag(bytes, at + 4);
+      let header = 8;
+      if (size === 1) {
+        if (at + 16 > to) return;
+        size = Number(view.getBigUint64(at + 8));
+        header = 16;
+      }
+      if (size === 0) size = to - at;
+      if (!Number.isSafeInteger(size) || size < header || size > to - at) return;
+      yield { type, start: at + header, end: at + size };
+      at += size;
+    }
+  }
+  const result: ReturnType<typeof readMp4Header> = { fileType: bytes.length >= 8 && tag(bytes, 4) === 'ftyp', hasMediaData: false, movies: [] };
+  for (const box of boxes(0, bytes.length)) {
+    if (box.type === 'mdat' && box.end > box.start) result.hasMediaData = true;
+    if (box.type !== 'moov') continue;
+    const movie: (typeof result.movies)[number] = { headers: [], tracks: [] };
+    result.movies.push(movie);
+    for (const child of boxes(box.start, box.end)) {
+      const { type, start, end } = child;
+      if (type === 'mvhd' && start < end) {
+        const version = bytes[start];
+        const payloadSize = end - start;
+        if (version === 0 && payloadSize >= 20) movie.headers.push({ timescale: view.getUint32(start + 12), duration: view.getUint32(start + 16), payloadSize });
+        if (version === 1 && payloadSize >= 32) movie.headers.push({ timescale: view.getUint32(start + 20), duration: Number(view.getBigUint64(start + 24)), payloadSize });
+      }
+      if (type !== 'trak') continue;
+      for (const track of boxes(start, end)) {
+        if (track.type !== 'tkhd' || track.start >= track.end) continue;
+        const version = bytes[track.start];
+        const at = version === 1 ? track.start + 88 : version === 0 ? track.start + 76 : track.end;
+        if (at + 8 > track.end) continue;
+        const width = view.getUint32(at) / 65536;
+        const height = view.getUint32(at + 4) / 65536;
+        movie.tracks.push({ width, height });
+      }
+    }
+  }
+  return result;
+}