@vosjs/cli 0.59.1 → 0.60.1

package/dist/chunk-YMVRTZ4L.js

@@ -0,0 +1,719 @@
+#!/usr/bin/env node
+import {
+  MEDIA_HEAD_BYTES,
+  TAKE_MEDIA_EXTENSIONS,
+  apiJson,
+  extensionFor,
+  hostedAssetId,
+  localFile,
+  manifestRefs,
+  nameForType,
+  resolveMediaType
+} from "./chunk-WCF6KIOK.js";
+
+// src/plugin/assetManifest.ts
+import {
+  existsSync as existsSync3,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { extname, join as join3, relative } from "path";
+
+// src/plugin/media.ts
+import { isKeyedOverlay } from "@vosjs/studio-core";
+import { createHash } from "crypto";
+import { createWriteStream, existsSync as existsSync2 } from "fs";
+import {
+  mkdir as mkdir2,
+  open,
+  readFile as readFile2,
+  readdir,
+  rename as rename2,
+  rm as rm2,
+  stat,
+  writeFile as writeFile2
+} from "fs/promises";
+import { basename as basename2, dirname, join as join2 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// src/plugin/take.ts
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { existsSync, readdirSync, statSync } from "fs";
+import { basename, join } from "path";
+var RECORDING_NAME = "recording.webm";
+function takeMediaFiles(dir, stem) {
+  return TAKE_MEDIA_EXTENSIONS.map((ext) => join(dir, `${stem}${ext}`)).filter(
+    (file) => existsSync(file)
+  );
+}
+function takeMediaFile(dir, stem, fallback) {
+  return takeMediaFiles(dir, stem)[0] ?? join(dir, fallback);
+}
+var PREV_DOC_NAME = "doc.prev.json";
+function takePaths(dir) {
+  const recording = takeMediaFile(dir, "recording", RECORDING_NAME);
+  return {
+    dir,
+    recording,
+    recordingName: basename(recording),
+    framesDir: join(dir, "frames"),
+    framesIndex: join(dir, "frames.json"),
+    cursor: join(dir, "cursor.json"),
+    meta: join(dir, "meta.json"),
+    actions: join(dir, "actions.json"),
+    doc: join(dir, "doc.json")
+  };
+}
+async function ensureTakeDir(dir) {
+  const p = takePaths(dir);
+  await mkdir(p.framesDir, { recursive: true });
+  return p;
+}
+async function dropScreencastFrames(p) {
+  if (!existsSync(p.recording) || statSync(p.recording).size === 0) return 0;
+  if (!existsSync(p.framesDir)) return 0;
+  let freed = 0;
+  for (const name of readdirSync(p.framesDir)) {
+    try {
+      freed += statSync(join(p.framesDir, name)).size;
+    } catch {
+    }
+  }
+  await rm(p.framesDir, { recursive: true, force: true });
+  await rm(p.framesIndex, { force: true });
+  return freed;
+}
+async function prepareReRecord(dir) {
+  const p = takePaths(dir);
+  const kept = [];
+  let prevDoc = false;
+  if (existsSync(p.doc)) {
+    await rename(p.doc, join(dir, PREV_DOC_NAME));
+    prevDoc = true;
+    kept.push(PREV_DOC_NAME);
+  }
+  if (existsSync(p.actions)) kept.push("actions.json");
+  if (existsSync(join(dir, "vos.json"))) kept.push("vos.json");
+  for (const stale of [
+    // Every container, not just the one `record` writes: a pulled take's
+    // footage may be mp4, and a survivor would outrank the new recording.
+    ...takeMediaFiles(dir, "recording"),
+    ...takeMediaFiles(dir, "mic"),
+    ...takeMediaFiles(dir, "cam"),
+    p.cursor,
+    p.meta,
+    p.framesIndex,
+    p.framesDir,
+    join(dir, "stills"),
+    join(dir, "digest")
+  ]) {
+    await rm(stale, { recursive: true, force: true });
+  }
+  return { prevDoc, kept };
+}
+async function readJson(file) {
+  return JSON.parse(await readFile(file, "utf8"));
+}
+async function writeJson(file, value, pretty = false) {
+  await writeFile(
+    file,
+    pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)
+  );
+}
+async function loadTake(dir) {
+  const paths = takePaths(dir);
+  if (!existsSync(paths.meta)) {
+    throw new Error(
+      `${dir} is not a take directory (missing meta.json) \u2014 run record first`
+    );
+  }
+  const meta = await readJson(paths.meta);
+  const cursor = existsSync(paths.cursor) ? await readJson(paths.cursor) : [];
+  const actions = existsSync(paths.actions) ? await readJson(paths.actions) : null;
+  const doc = existsSync(paths.doc) ? await readJson(paths.doc) : null;
+  return { paths, cursor, meta, actions, doc };
+}
+
+// src/plugin/uploadAsset.ts
+var SINGLE_SHOT_MAX_BYTES = 32 * 1024 * 1024;
+var PART_ATTEMPTS = 3;
+function planParts(totalBytes, partBytes) {
+  if (totalBytes <= 0 || partBytes <= 0) return [];
+  const parts = [];
+  for (let start = 0; start < totalBytes; start += partBytes) {
+    parts.push({
+      partNumber: parts.length + 1,
+      start,
+      end: Math.min(start + partBytes, totalBytes)
+    });
+  }
+  return parts;
+}
+function failed(what, r) {
+  const detail = typeof r.body.error === "string" ? r.body.error : "";
+  return new Error(`${what} (${r.status})${detail ? `: ${detail}` : ""}`);
+}
+function asAsset(body) {
+  return {
+    id: String(body.id),
+    url: String(body.url),
+    size: typeof body.size === "number" ? body.size : 0,
+    reused: body.reused === true
+  };
+}
+function transient(status) {
+  return status >= 500 || status === 429;
+}
+var wait = (ms) => new Promise((r) => setTimeout(r, ms));
+async function uploadAsset(target, bytes, opts) {
+  if (bytes.length > SINGLE_SHOT_MAX_BYTES && opts.folderId) {
+    throw new Error(
+      `${opts.filename} is over ${SINGLE_SHOT_MAX_BYTES / 1024 / 1024} MB, and a file that large cannot be filed into a project on upload yet. Push it without --folder and reference it from a document, which keeps it`
+    );
+  }
+  return bytes.length > SINGLE_SHOT_MAX_BYTES ? uploadInParts(target, bytes, opts) : uploadWhole(target, bytes, opts);
+}
+async function uploadWhole(target, bytes, opts) {
+  const res = await apiJson(target.origin, "/api/assets/recording", {
+    method: "POST",
+    key: target.key,
+    headers: {
+      "Content-Type": opts.contentType,
+      "Content-Length": String(bytes.length),
+      "X-Filename": opts.filename,
+      "X-Content-Hash": opts.contentHash,
+      ...opts.durationSeconds && opts.durationSeconds > 0 ? { "X-Content-Duration": opts.durationSeconds.toFixed(3) } : {},
+      ...opts.folderId ? { "X-Folder-Id": opts.folderId } : {}
+    },
+    raw: bytes
+  });
+  if (res.status !== 201 && res.status !== 200)
+    throw failed("upload failed", res);
+  return asAsset(res.body);
+}
+async function uploadInParts(target, bytes, opts) {
+  const begun = await apiJson(
+    target.origin,
+    "/api/assets/recording/multipart",
+    {
+      method: "POST",
+      key: target.key,
+      body: {
+        filename: opts.filename,
+        contentType: opts.contentType,
+        size: bytes.length,
+        contentHash: opts.contentHash,
+        ...opts.durationSeconds && opts.durationSeconds > 0 ? { durationSeconds: opts.durationSeconds } : {}
+      }
+    }
+  );
+  if (begun.status !== 201 && begun.status !== 200) {
+    throw failed("upload failed", begun);
+  }
+  if (begun.body.reused === true || typeof begun.body.url === "string") {
+    return asAsset(begun.body);
+  }
+  const uploadId = String(begun.body.id);
+  const partBytes = Number(begun.body.partBytes);
+  if (!Number.isFinite(partBytes) || partBytes <= 0) {
+    throw new Error("upload failed: the platform returned no part size");
+  }
+  const parts = planParts(bytes.length, partBytes);
+  const etags = [];
+  try {
+    for (const part of parts) {
+      const chunk = bytes.subarray(part.start, part.end);
+      let sent = null;
+      for (let attempt = 1; attempt <= PART_ATTEMPTS; attempt++) {
+        try {
+          sent = await apiJson(
+            target.origin,
+            `/api/assets/recording/multipart/${uploadId}/parts/${part.partNumber}`,
+            {
+              method: "PUT",
+              key: target.key,
+              headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Length": String(chunk.length)
+              },
+              raw: chunk
+            }
+          );
+        } catch (networkError) {
+          if (attempt === PART_ATTEMPTS) throw networkError;
+          await wait(500 * 2 ** (attempt - 1));
+          continue;
+        }
+        if (sent.status === 200) break;
+        if (!transient(sent.status) || attempt === PART_ATTEMPTS) {
+          throw failed(`part ${part.partNumber} failed`, sent);
+        }
+        await wait(500 * 2 ** (attempt - 1));
+      }
+      if (!sent || sent.status !== 200) {
+        throw new Error(`part ${part.partNumber} failed`);
+      }
+      etags.push({
+        partNumber: Number(sent.body.partNumber),
+        etag: String(sent.body.etag)
+      });
+      opts.onPart?.(etags.length, parts.length);
+    }
+    const sealed = await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}/complete`,
+      { method: "POST", key: target.key, body: { parts: etags } }
+    );
+    if (sealed.status !== 201 && sealed.status !== 200) {
+      throw failed("upload failed", sealed);
+    }
+    return asAsset(sealed.body);
+  } catch (err) {
+    await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}`,
+      { method: "DELETE", key: target.key }
+    ).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/plugin/media.ts
+var SOURCE_MEDIA = [
+  { key: "videoKey", stem: "recording", fallbackExt: ".webm" },
+  { key: "micKey", stem: "mic", fallbackExt: ".webm" },
+  { key: "camKey", stem: "cam", fallbackExt: ".webm" }
+];
+function isTakeRelativeKey(key) {
+  return !!key && !/^(https?:|blob:|data:|media:|\/\/)/.test(key) && !key.startsWith("/api/");
+}
+var takeRelativeFile = (key) => key.replace(/^\/+/, "");
+function sourceSidecarRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const [field, where2] of [
+    ["micKey", "mic track"],
+    ["camKey", "cam track"]
+  ]) {
+    const key = doc.source[field];
+    if (!key || !keep(key)) continue;
+    out.push({
+      where: where2,
+      key,
+      set: (next) => {
+        doc.source[field] = next;
+      }
+    });
+  }
+  return out;
+}
+function docObjectRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const clip of doc.objects ?? []) {
+    const asset = clip.asset;
+    if (asset.kind !== "gltf" || !keep(asset.key)) continue;
+    out.push({
+      where: `object ${clip.id}`,
+      key: asset.key,
+      set: (next) => {
+        asset.key = next;
+      }
+    });
+  }
+  return out;
+}
+function docOverlayRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const clip of doc.overlays ?? []) {
+    if (!isKeyedOverlay(clip) || !keep(clip.key)) continue;
+    out.push({
+      where: `overlay ${clip.id}`,
+      key: clip.key,
+      set: (next) => {
+        clip.key = next;
+      }
+    });
+  }
+  return out;
+}
+function docLayerRefs(doc, keep = isTakeRelativeKey) {
+  return [
+    ...docOverlayRefs(doc, keep),
+    ...docObjectRefs(doc, keep),
+    ...docAudioRefs(doc, keep)
+  ];
+}
+function docMediaRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const m of doc.media ?? []) {
+    if (keep(m.videoKey))
+      out.push({
+        where: `media ${m.id}`,
+        key: m.videoKey,
+        set: (next) => {
+          m.videoKey = next;
+        }
+      });
+    const mic = m.micKey;
+    if (mic && keep(mic))
+      out.push({
+        where: `media ${m.id} mic`,
+        key: mic,
+        set: (next) => {
+          m.micKey = next;
+        }
+      });
+    const cam = m.camKey;
+    if (cam && keep(cam))
+      out.push({
+        where: `media ${m.id} cam`,
+        key: cam,
+        set: (next) => {
+          m.camKey = next;
+        }
+      });
+  }
+  out.push(...docOverlayRefs(doc, keep));
+  out.push(...docObjectRefs(doc, keep));
+  const mark = doc.endCard?.mark;
+  if (mark && keep(mark.key))
+    out.push({
+      where: "end card mark",
+      key: mark.key,
+      set: (next) => {
+        mark.key = next;
+      }
+    });
+  const bg = doc.frame.backgroundMedia;
+  if (bg && keep(bg.key))
+    out.push({
+      where: "background",
+      key: bg.key,
+      set: (next) => {
+        bg.key = next;
+      }
+    });
+  out.push(...docAudioRefs(doc, keep));
+  return out;
+}
+function docAudioRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const clip of doc.audio ?? []) {
+    if (!keep(clip.key)) continue;
+    out.push({
+      where: `audio ${clip.id}`,
+      key: clip.key,
+      set: (next) => {
+        clip.key = next;
+      }
+    });
+  }
+  return out;
+}
+async function uploadDocRefs(refs, dir, target, log) {
+  for (const ref of refs) {
+    const file = join2(dir, takeRelativeFile(ref.key));
+    if (!existsSync2(file)) {
+      log(`  ${ref.where}: ${ref.key} is not beside the document \u2014 left as is`);
+      continue;
+    }
+    const media = await readFile2(file);
+    const mediaHash = createHash("sha256").update(media).digest("hex");
+    const { type } = resolveMediaType({
+      head: media.subarray(0, MEDIA_HEAD_BYTES),
+      filename: file
+    });
+    const name = nameForType(basename2(file), type);
+    if (name !== basename2(file)) {
+      log(`  ${ref.where}: ${basename2(file)} holds ${type} \u2014 sent as ${name}`);
+    }
+    let put;
+    try {
+      put = await uploadAsset(target, new Uint8Array(media), {
+        filename: name,
+        contentType: type,
+        contentHash: mediaHash
+      });
+    } catch (e) {
+      throw new Error(
+        `${ref.where} upload failed: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    ref.set(put.url);
+    log(
+      `  ${ref.where}: ${ref.key} \u2192 asset ${put.id}${put.reused ? " (reused)" : ""}`
+    );
+  }
+}
+function assetIdOf(url) {
+  if (!url) return null;
+  const m = /\/api\/assets\/([A-Za-z0-9_-]+)\/file/.exec(url);
+  return m ? m[1] : null;
+}
+async function readMediaHead(file) {
+  const handle = await open(file, "r");
+  try {
+    const buf = Buffer.alloc(MEDIA_HEAD_BYTES);
+    const { bytesRead } = await handle.read(buf, 0, MEDIA_HEAD_BYTES, 0);
+    return new Uint8Array(buf.subarray(0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}
+async function downloadMedia(ctx, url, target) {
+  const abs = /^https?:/.test(url) ? url : `${ctx.origin}${url}`;
+  const res = await fetch(abs, {
+    headers: ctx.key ? { authorization: `Bearer ${ctx.key}` } : {}
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(
+      `download of ${target.describe} failed (${res.status})${res.status === 404 && target.notFoundHint ? ` \u2014 ${target.notFoundHint}` : ""}`
+    );
+  }
+  const into = target.subdir ? join2(target.dir, target.subdir) : target.dir;
+  const partial = join2(into, `${target.stem}.part`);
+  await mkdir2(dirname(partial), { recursive: true });
+  try {
+    await pipeline(
+      Readable.fromWeb(res.body),
+      createWriteStream(partial)
+    );
+    const { type } = resolveMediaType({
+      head: await readMediaHead(partial),
+      declared: res.headers.get("content-type"),
+      filename: `${target.stem}${target.fallbackExt}`
+    });
+    const name = `${target.stem}${extensionFor(type) || target.fallbackExt}`;
+    await rename2(partial, join2(into, name));
+    const file = target.subdir ? `${target.subdir}/${name}` : name;
+    return { file, bytes: (await stat(join2(target.dir, file))).size };
+  } finally {
+    await rm2(partial, { force: true });
+  }
+}
+async function pullMedia(ctx, dir, doc, log) {
+  const result = { downloaded: [], kept: [] };
+  for (const { key, stem, fallbackExt } of SOURCE_MEDIA) {
+    const url = doc.source[key];
+    const assetId = assetIdOf(url);
+    if (!assetId) continue;
+    const present = takeMediaFiles(dir, stem)[0];
+    if (present) {
+      result.kept.push(basename2(present));
+      doc.source[key] = basename2(present);
+      continue;
+    }
+    const got = await downloadMedia(ctx, url, {
+      dir,
+      stem,
+      fallbackExt,
+      describe: stem,
+      notFoundHint: "a private recording needs a content key of its owner"
+    });
+    result.downloaded.push({ file: got.file, assetId, bytes: got.bytes });
+    log(`  ${got.file} \u2190 asset ${assetId} (${Math.round(got.bytes / 1024)} kB)`);
+    doc.source[key] = got.file;
+  }
+  for (const ref of docMediaRefs(doc, (k) => assetIdOf(k) !== null)) {
+    const assetId = assetIdOf(ref.key);
+    const existing = existsSync2(join2(dir, "media")) ? (await readdir(join2(dir, "media"))).find(
+      (f) => f === assetId || f.startsWith(`${assetId}.`)
+    ) : void 0;
+    if (existing) {
+      const file = `media/${existing}`;
+      result.kept.push(file);
+      ref.set(file);
+      continue;
+    }
+    const got = await downloadMedia(ctx, ref.key, {
+      dir,
+      subdir: "media",
+      stem: assetId,
+      // A type with no extension here (an svg served as such) keeps the bare
+      // asset id, exactly as before.
+      fallbackExt: "",
+      describe: `${ref.where} (${ref.key})`
+    });
+    result.downloaded.push({ file: got.file, assetId, bytes: got.bytes });
+    log(
+      `  ${got.file} \u2190 ${ref.where}, asset ${assetId} (${Math.round(got.bytes / 1024)} kB)`
+    );
+    ref.set(got.file);
+  }
+  const metaPath = join2(dir, "meta.json");
+  if (!existsSync2(metaPath)) await writeJson(metaPath, doc.source.meta, true);
+  const cursorPath = join2(dir, "cursor.json");
+  if (!existsSync2(cursorPath)) await writeJson(cursorPath, doc.source.cursor);
+  await writeFile2(join2(dir, "doc.json"), JSON.stringify(doc, null, 2));
+  return result;
+}
+
+// src/plugin/assetManifest.ts
+var isUrl = (ref) => /^(https?:|data:|blob:)/.test(ref);
+var homeOrigins = (origin) => [
+  origin,
+  "https://vos.so",
+  "https://www.vos.so"
+];
+var NOT_UPLOADABLE = {
+  ".woff2": "a font",
+  ".woff": "a font",
+  ".ttf": "a font",
+  ".otf": "a font",
+  ".hdr": "an HDR",
+  ".exr": "an EXR",
+  ".gltf": "a .gltf (export it as one .glb)"
+};
+var HOME_INDEX = ".hosted.json";
+function cloneManifest(config) {
+  return JSON.parse(JSON.stringify(config.assets ?? {}));
+}
+function setRef(manifest, name, index, next) {
+  const decl = manifest[name];
+  if (index === null) decl.ref = next;
+  else decl.ref[index] = next;
+}
+var where = (name, index) => index === null ? `assets.${name}` : `assets.${name}[${index}]`;
+async function uploadManifest(config, dir, target, log) {
+  const refs = manifestRefs(config);
+  if (refs.length === 0) return { uploaded: 0 };
+  const manifest = cloneManifest(config);
+  const local = [];
+  for (const { name, index, ref } of refs) {
+    const hosted = hostedAssetId(ref, homeOrigins(target.origin));
+    if (hosted) {
+      setRef(manifest, name, index, `asset:${hosted}`);
+      continue;
+    }
+    if (isUrl(ref)) continue;
+    const kind = NOT_UPLOADABLE[extname(ref).toLowerCase()];
+    if (kind) {
+      throw new Error(
+        `${where(name, index)} names ${ref}: a push cannot upload ${kind} yet (pictures, video, sound and .glb models go). Host it at a URL and name the URL; the font and HDR catalogs are on assets.vos.so (GET /api/fonts)`
+      );
+    }
+    const found = localFile(ref, dir);
+    if ("refused" in found) {
+      throw new Error(`${where(name, index)} names ${ref}, ${found.refused}`);
+    }
+    local.push({
+      where: where(name, index),
+      // The upload helper reads keys against the directory.
+      key: relative(realpathSync(dir), found.file),
+      set: (url) => {
+        const id = hostedAssetId(url, homeOrigins(target.origin));
+        setRef(manifest, name, index, id ? `asset:${id}` : url);
+      }
+    });
+  }
+  await uploadDocRefs(local, dir, target, log);
+  config.assets = manifest;
+  return { uploaded: local.length };
+}
+function localManifestRefs(config) {
+  return manifestRefs(config).filter(({ ref }) => !isUrl(ref) && !hostedAssetId(ref, homeOrigins(""))).map(({ name, index }) => where(name, index));
+}
+async function pullManifest(ctx, dir, config, log) {
+  const home = homeOrigins(ctx.origin);
+  const hosted = manifestRefs(config).filter(
+    ({ ref }) => hostedAssetId(ref, home)
+  );
+  if (hosted.length === 0) return null;
+  const manifest = cloneManifest(config);
+  const indexPath = join3(dir, "assets", HOME_INDEX);
+  let index = {};
+  try {
+    const parsed = JSON.parse(readFileSync(indexPath, "utf8"));
+    if (parsed && typeof parsed === "object") {
+      index = parsed;
+    }
+  } catch {
+  }
+  const files = [];
+  for (const { name, index: at, ref } of hosted) {
+    const id = hostedAssetId(ref, home);
+    const stem = at === null ? name : `${name}-${at}`;
+    const known = Object.keys(index).find(
+      (f) => f === stem || f.startsWith(`${stem}.`)
+    );
+    let file;
+    if (known && index[known] === id && existsSync3(join3(dir, "assets", known))) {
+      file = `assets/${known}`;
+    } else {
+      if (known) {
+        rmSync(join3(dir, "assets", known), { force: true });
+        delete index[known];
+      }
+      const got = await downloadMedia(ctx, `/api/assets/${id}/file`, {
+        dir,
+        subdir: "assets",
+        stem,
+        fallbackExt: "",
+        describe: `${where(name, at)} (asset ${id})`,
+        notFoundHint: "a private file needs a content key of its owner"
+      });
+      file = got.file;
+      index[file.slice("assets/".length)] = id;
+      log(
+        `  ${file} \u2190 ${where(name, at)}, asset ${id} (${Math.round(got.bytes / 1024)} kB)`
+      );
+    }
+    files.push(file);
+    setRef(manifest, name, at, `./${file}`);
+  }
+  writeFileSync(indexPath, JSON.stringify(index, null, 2) + "\n");
+  return { assets: manifest, files };
+}
+var HOSTED_FILE_LITERAL = /(?:asset:|\/api\/assets\/)([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})/g;
+var FUNCTION_FIELDS = ["setup", "createContent", "createTimeline", "onFrame"];
+function hostedLiteralWarnings(config) {
+  const out = [];
+  const scan = (label, src) => {
+    if (typeof src !== "string") return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const m of src.matchAll(HOSTED_FILE_LITERAL)) {
+      if (seen.has(m[1])) continue;
+      seen.add(m[1]);
+      out.push(
+        `${label} names hosted file ${m[1]} in code. Declare it instead: "assets": { "name": { "ref": "asset:${m[1]}" } }, and read ctx.assets.name, so it loads on every render and follows a remix`
+      );
+    }
+  };
+  for (const field of FUNCTION_FIELDS) scan(field, config[field]);
+  const stack = Array.isArray(config.stack) ? config.stack : [];
+  for (const entry of stack) {
+    for (const field of ["setup", "createContent", "onFrame"]) {
+      scan(`stack.${String(entry.id)}.${field}`, entry[field]);
+    }
+  }
+  return out;
+}
+
+export {
+  RECORDING_NAME,
+  takeMediaFile,
+  PREV_DOC_NAME,
+  takePaths,
+  ensureTakeDir,
+  dropScreencastFrames,
+  prepareReRecord,
+  readJson,
+  writeJson,
+  loadTake,
+  uploadAsset,
+  isTakeRelativeKey,
+  sourceSidecarRefs,
+  docLayerRefs,
+  docMediaRefs,
+  docAudioRefs,
+  uploadDocRefs,
+  readMediaHead,
+  pullMedia,
+  uploadManifest,
+  localManifestRefs,
+  pullManifest,
+  hostedLiteralWarnings
+};
+//# sourceMappingURL=chunk-YMVRTZ4L.js.map