@aphrody/shenron-dbxv2 0.0.0-stage → 1.4.7

package/src/plugin.ts

@@ -0,0 +1,204 @@
+/**
+ * Bun plugin for `dbxv2:<cpk>/<path-in-cpk>?<format>` imports (private, development only).
+ *
+ *   import url from "dbxv2:CHARA/chara/001.emb?png";      // signed loopback URL (string)
+ *   import wav from "dbxv2:BGM/bgm/theme.acb?wav";         // idem, audio/wav
+ *   import clip from "dbxv2:MOVIE/op.usm?video";           // idem, mp4/webm/mpeg
+ *   import model from "dbxv2:CHARA/chara/001.emd?model";   // validated model JSON (top-level await)
+ *   import glb from "dbxv2:CHARA/chara/001.emd?glb";       // signed URL of the binary glTF
+ *   import bytes from "dbxv2:CHARA/chara/001.emd?raw";     // ArrayBuffer (top-level await)
+ *
+ * Extra parameters follow the format: `?png&index=2`, `?wav&cue=1`, `?model&emb=...&esk=...`.
+ * Generated modules read the server from the environment at run time: no game byte, URL or token
+ * is ever fixed in a module. `Bun.build` is refused for public/production builds.
+ */
+import { join } from "node:path";
+import { Dbxv2ConfigError, Dbxv2DisabledError } from "./errors";
+import { dbxv2Status, describeDisabledReason, type Dbxv2EnvInput } from "./env";
+import { assertDbxv2BuildAllowed, DBXV2_MARKER, type BuildConfigLike } from "./guard";
+import { parseRef, type Dbxv2Ref, type Dbxv2ResourceKind, type Dbxv2ResourceParams } from "./refs";
+
+export const DBXV2_NAMESPACE = "dbxv2";
+
+export type Dbxv2Format = "png" | "wav" | "video" | "model" | "glb" | "raw";
+
+const FORMATS: readonly Dbxv2Format[] = ["png", "wav", "video", "model", "glb", "raw"];
+
+const KIND_OF: Readonly<Record<Dbxv2Format, Dbxv2ResourceKind>> = {
+  png: "png",
+  wav: "wav",
+  video: "video",
+  model: "model.json",
+  glb: "model.glb",
+  raw: "raw",
+};
+
+export interface ParsedSpecifier {
+  readonly ref: Dbxv2Ref;
+  readonly format: Dbxv2Format;
+  readonly params: Dbxv2ResourceParams;
+}
+
+/** Parses `dbxv2:<cpk>/<path>?<format>[&param=value]`. */
+export function parseSpecifier(specifier: string): ParsedSpecifier {
+  if (!specifier.startsWith("dbxv2:"))
+    throw new Dbxv2ConfigError(`not a dbxv2: specifier: ${specifier}`);
+  const body = specifier.slice("dbxv2:".length);
+  const cut = body.indexOf("?");
+  const refPart = cut < 0 ? body : body.slice(0, cut);
+  const query = new URLSearchParams(cut < 0 ? "" : body.slice(cut + 1));
+  const ref = parseRef(refPart);
+  const formats = FORMATS.filter((f) => query.has(f));
+  if (formats.length !== 1) {
+    throw new Dbxv2ConfigError(
+      `dbxv2:${refPart} needs exactly one format suffix (${FORMATS.map((f) => `?${f}`).join(", ")})`,
+    );
+  }
+  const format = formats[0]!;
+  const int = (name: string): number | undefined => {
+    const raw = query.get(name);
+    if (raw === null) return undefined;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0)
+      throw new Dbxv2ConfigError(`dbxv2: parameter ${name} must be a non-negative integer`);
+    return n;
+  };
+  const params: Dbxv2ResourceParams = {
+    index: int("index"),
+    cue: int("cue"),
+    emb: query.get("emb") ?? undefined,
+    esk: query.get("esk") ?? undefined,
+  };
+  return { ref, format, params };
+}
+
+const defined = <T extends object>(value: T): Partial<T> =>
+  Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined)) as Partial<T>;
+
+const RUNTIME_FILE = join(import.meta.dir, "runtime.ts");
+
+/** Source of the module generated for a specifier (a thin wrapper over the runtime). */
+export function generateModuleSource(parsed: ParsedSpecifier): string {
+  const { ref, format, params } = parsed;
+  const head = [
+    `/*${DBXV2_MARKER}*/`,
+    // Survives bundling (comments do not): the public build guard looks for this literal.
+    `globalThis[Symbol.for(${JSON.stringify(DBXV2_MARKER)})] = true;`,
+    `import { resource } from ${JSON.stringify(RUNTIME_FILE)};`,
+    `const r = resource(${JSON.stringify(ref)}, ${JSON.stringify(KIND_OF[format])}, ${JSON.stringify(defined(params))});`,
+    "export const ref = r.ref;",
+  ];
+  switch (format) {
+    case "model":
+      return [
+        ...head,
+        `const glb = resource(${JSON.stringify(ref)}, "model.glb", ${JSON.stringify(defined(params))});`,
+        "export const jsonUrl = r.url();",
+        "export const glbUrl = glb.url();",
+        "export default await r.model();",
+      ].join("\n");
+    case "raw":
+      return [
+        ...head,
+        "export const url = r.url();",
+        "export const blob = (signal) => r.blob(signal);",
+        "export default await r.arrayBuffer();",
+      ].join("\n");
+    default:
+      return [
+        ...head,
+        "export const url = r.url();",
+        "export const blob = (signal) => r.blob(signal);",
+        "export const arrayBuffer = (signal) => r.arrayBuffer(signal);",
+        "export default url;",
+      ].join("\n");
+  }
+}
+
+export interface Dbxv2PluginOptions {
+  /** Environment (default `process.env`). */
+  readonly env?: Dbxv2EnvInput;
+  /** Explicit publication manifest: immutable approved derivatives only, never private runtime imports. */
+  readonly publicAssets?: Readonly<
+    Record<string, { readonly url: string; readonly sha256: string; readonly provenance: string }>
+  >;
+}
+
+/**
+ * The plugin object. Under `Bun.build` the build config is checked first: public, production and
+ * minified builds are refused. At run time (`Bun.plugin`), a disabled DBXV2 fails the import with
+ * the reason and the variables to set.
+ */
+export function dbxv2Plugin(options: Dbxv2PluginOptions = {}): Bun.BunPlugin {
+  return {
+    name: "shenron-dbxv2",
+    setup(build) {
+      const env = options.env ?? (process.env as Dbxv2EnvInput);
+      const config = (build as { config?: BuildConfigLike }).config;
+      if (config && !options.publicAssets) assertDbxv2BuildAllowed(config, env);
+      build.onResolve({ filter: /^dbxv2:/ }, (args) => ({
+        path: args.path,
+        namespace: DBXV2_NAMESPACE,
+      }));
+      build.onLoad({ filter: /.*/, namespace: DBXV2_NAMESPACE }, (args) => {
+        // Bun hands the namespace load the path without the `dbxv2:` scheme (query kept).
+        const parsed = parseSpecifier(
+          args.path.startsWith("dbxv2:") ? args.path : `dbxv2:${args.path}`,
+        );
+        if (options.publicAssets) {
+          const key = args.path.startsWith("dbxv2:") ? args.path : `dbxv2:${args.path}`;
+          const asset = options.publicAssets[key];
+          const url = asset ? URL.parse(asset.url) : null;
+          if (
+            !asset ||
+            !url ||
+            url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            !/^[a-f0-9]{64}$/.test(asset.sha256) ||
+            !url.pathname.includes(asset.sha256) ||
+            !asset.provenance.trim() ||
+            !["png", "wav", "video", "glb"].includes(parsed.format)
+          ) {
+            throw new Dbxv2ConfigError(
+              "Public imports require an approved immutable derivative with provenance",
+            );
+          }
+          return {
+            contents: `export const url = ${JSON.stringify(url.href)}; export const sha256 = ${JSON.stringify(asset.sha256)}; export default url;`,
+            loader: "js",
+          };
+        }
+        if (config) {
+          // Building (development): re-check at load, nothing is resolved against the server.
+          assertDbxv2BuildAllowed(config, env);
+        } else {
+          const status = dbxv2Status(env);
+          if (status.enabled && status.config.mode === "public") {
+            throw new Dbxv2ConfigError(
+              "Public plugin imports require the publicAssets publication manifest",
+            );
+          }
+          if (!status.enabled) {
+            throw new Dbxv2DisabledError(
+              `cannot import dbxv2:${parsed.ref.cpk}/${parsed.ref.path}: ${describeDisabledReason(status.reason)}. ` +
+                "Set DBXV2_SERVER_URL and DBXV2_TOKEN to enable the private DBXV2 server.",
+            );
+          }
+        }
+        return { contents: generateModuleSource(parsed), loader: "js" };
+      });
+    },
+  };
+}
+
+/** Registers the plugin for the current process (`Bun.plugin`). Idempotent per process. */
+export function registerDbxv2Plugin(options: Dbxv2PluginOptions = {}): void {
+  const flag = Symbol.for("shenron.dbxv2.plugin");
+  const holder = globalThis as unknown as Record<symbol, boolean | undefined>;
+  if (holder[flag]) return;
+  holder[flag] = true;
+  Bun.plugin(dbxv2Plugin(options));
+}

package/src/preload.ts

@@ -0,0 +1,13 @@
+/**
+ * Bunfig preload: registers the `dbxv2:` import plugin.
+ *
+ *   [test]
+ *   preload = ["./packages/dbxv2/src/preload.ts"]
+ *   [run]
+ *   preload = ["./packages/dbxv2/src/preload.ts"]
+ *
+ * Harmless when DBXV2 is disabled: importing a `dbxv2:` module then fails with an explicit message.
+ */
+import { registerDbxv2Plugin } from "./plugin";
+
+registerDbxv2Plugin();

package/src/proxy.ts

@@ -0,0 +1,243 @@
+/**
+ * Loopback proxy that signs short-lived resource URLs, so `<img>`, `<audio>`, `<video>` or a
+ * native engine can load DBXV2 resources without ever seeing the bearer token.
+ *
+ * `proxy.url.png(ref)` returns `http://127.0.0.1:<port>/r/png/<cpk>/<path>?exp=<unix>&sig=<hmac>`.
+ * The signature (HMAC-SHA256 with a per-process random secret) covers kind, entry, parameters and
+ * expiry. The proxy adds `Authorization` itself, forwards `Range`, `If-Range` and
+ * `If-None-Match`, and streams the answer. It binds to loopback only.
+ */
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { Dbxv2ConfigError, Dbxv2DisabledError } from "./errors";
+import {
+  DBXV2_MIN_TOKEN_LENGTH,
+  describeDisabledReason,
+  isPublicContext,
+  normalizeServerUrl,
+  type Dbxv2EnvInput,
+} from "./env";
+import {
+  DBXV2_RESOURCE_KINDS,
+  parseRef,
+  resourcePath,
+  resourceQuery,
+  type Dbxv2RefInput,
+  type Dbxv2ResourceKind,
+  type Dbxv2ResourceParams,
+} from "./refs";
+
+export interface Dbxv2ProxyOptions {
+  readonly upstream: { readonly baseUrl: string; readonly token: string };
+  /** Lifetime of a signed URL in seconds (default 300, maximum 3600). */
+  readonly ttlSeconds?: number;
+  /** Loopback address only (default `127.0.0.1`). */
+  readonly hostname?: "127.0.0.1" | "::1" | "localhost";
+  /** 0 picks a free port. */
+  readonly port?: number;
+  /** Secret of the signatures (default: 32 random bytes per process). */
+  readonly secret?: string | Uint8Array;
+  readonly fetch?: typeof fetch;
+  /** Environment checked for a public render (default `process.env`). */
+  readonly env?: Dbxv2EnvInput;
+  readonly now?: () => number;
+}
+
+export interface Dbxv2UrlBuilders {
+  raw(ref: Dbxv2RefInput): string;
+  png(ref: Dbxv2RefInput, params?: { readonly index?: number }): string;
+  audio(ref: Dbxv2RefInput, params?: { readonly cue?: number }): string;
+  video(ref: Dbxv2RefInput): string;
+  /** Web fragmented MP4 (H.264, no audio) transcoded on demand by the server: the format browsers can play. */
+  mp4(ref: Dbxv2RefInput): string;
+  modelJson(ref: Dbxv2RefInput, params?: { readonly emb?: string; readonly esk?: string }): string;
+  modelGlb(ref: Dbxv2RefInput, params?: { readonly emb?: string; readonly esk?: string }): string;
+}
+
+export interface Dbxv2Proxy {
+  /** `http://127.0.0.1:<port>`. */
+  readonly origin: string;
+  readonly url: Dbxv2UrlBuilders;
+  /** Signs any kind/parameters; `ttlSeconds` overrides the default for this URL. */
+  sign(
+    kind: Dbxv2ResourceKind,
+    ref: Dbxv2RefInput,
+    params?: Dbxv2ResourceParams,
+    ttlSeconds?: number,
+  ): string;
+  stop(): void;
+}
+
+const MAX_TTL = 3600;
+const PASS_REQUEST = ["range", "if-range", "if-none-match"] as const;
+const PASS_RESPONSE = [
+  "content-type",
+  "content-length",
+  "content-range",
+  "accept-ranges",
+  "etag",
+] as const;
+const LOOPBACK = new Set(["127.0.0.1", "::1", "localhost"]);
+
+const encodePath = (path: string): string => path.split("/").map(encodeURIComponent).join("/");
+
+function canonical(kind: string, entry: string, query: URLSearchParams, exp: number): string {
+  const sorted = new URLSearchParams(query);
+  sorted.sort();
+  return `${kind}\n${entry}\n${sorted.toString()}\n${exp}`;
+}
+
+function jsonError(status: number, error: string): Response {
+  return new Response(JSON.stringify({ error }), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" },
+  });
+}
+
+export function createDbxv2Proxy(options: Dbxv2ProxyOptions): Dbxv2Proxy {
+  const env = options.env ?? (process.env as Dbxv2EnvInput);
+  const blocked = isPublicContext(env);
+  if (blocked === "public-render") throw new Dbxv2DisabledError(describeDisabledReason(blocked));
+  const upstream = normalizeServerUrl(options.upstream.baseUrl);
+  if (!upstream) throw new Dbxv2ConfigError("upstream.baseUrl must be a valid http(s) URL");
+  const token = options.upstream.token;
+  if (token.length < DBXV2_MIN_TOKEN_LENGTH)
+    throw new Dbxv2ConfigError(
+      `upstream.token must hold at least ${DBXV2_MIN_TOKEN_LENGTH} characters`,
+    );
+  const hostname = options.hostname ?? "127.0.0.1";
+  if (!LOOPBACK.has(hostname)) throw new Dbxv2ConfigError("the proxy binds to loopback only");
+  const ttlDefault = Math.min(Math.max(options.ttlSeconds ?? 300, 1), MAX_TTL);
+  const secret = options.secret ?? randomBytes(32);
+  if (typeof secret === "string" && secret.length < 16)
+    throw new Dbxv2ConfigError("secret must hold at least 16 characters");
+  const doFetch = options.fetch ?? fetch;
+  const now = options.now ?? Date.now;
+
+  const mac = (message: string): Buffer => createHmac("sha256", secret).update(message).digest();
+
+  const handle = async (req: Request): Promise<Response> => {
+    if (req.method !== "GET" && req.method !== "HEAD") return jsonError(405, "method not allowed");
+    const url = new URL(req.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    if (parts[0] !== "r" || parts.length < 4) return jsonError(404, "not found");
+    const kind = parts[1] as Dbxv2ResourceKind;
+    if (!DBXV2_RESOURCE_KINDS.includes(kind)) return jsonError(404, "not found");
+    let ref;
+    try {
+      ref = parseRef({ cpk: parts[2]!, path: parts.slice(3).map(decodeURIComponent).join("/") });
+    } catch {
+      return jsonError(400, "bad entry reference");
+    }
+    const exp = Number(url.searchParams.get("exp"));
+    const sig = url.searchParams.get("sig") ?? "";
+    const signed = new URLSearchParams(url.searchParams);
+    signed.delete("exp");
+    signed.delete("sig");
+    // Only the parameters the kind understands are forwarded and signed.
+    let allowed: URLSearchParams;
+    try {
+      allowed = resourceQuery(kind, {
+        index: numberOf(signed.get("index")),
+        cue: numberOf(signed.get("cue")),
+        emb: signed.get("emb") ?? undefined,
+        esk: signed.get("esk") ?? undefined,
+      });
+    } catch {
+      return jsonError(400, "bad parameters");
+    }
+    if (allowed.toString() !== sortedString(signed)) return jsonError(400, "unexpected parameters");
+    const expected = mac(canonical(kind, `${ref.cpk}/${ref.path}`, allowed, exp));
+    let given: Buffer;
+    try {
+      given = Buffer.from(sig, "hex");
+    } catch {
+      return jsonError(403, "invalid signature");
+    }
+    if (given.length !== expected.length || !timingSafeEqual(given, expected))
+      return jsonError(403, "invalid signature");
+    if (!Number.isFinite(exp) || exp * 1000 < now()) return jsonError(403, "signed URL expired");
+
+    const headers = new Headers({ Authorization: `Bearer ${token}` });
+    for (const name of PASS_REQUEST) {
+      const value = req.headers.get(name);
+      if (value) headers.set(name, value);
+    }
+    const target = `${upstream}${resourcePath(kind, ref)}${allowed.size > 0 ? `?${allowed}` : ""}`;
+    let res: Response;
+    try {
+      res = await doFetch(target, {
+        method: req.method,
+        headers,
+        redirect: "error",
+        credentials: "omit",
+        signal: req.signal,
+      });
+    } catch {
+      return jsonError(502, "upstream unreachable");
+    }
+    const out = new Headers({
+      "Cache-Control": "private, max-age=60",
+      "X-Content-Type-Options": "nosniff",
+      "Cross-Origin-Resource-Policy": "same-site",
+      "Referrer-Policy": "no-referrer",
+    });
+    for (const name of PASS_RESPONSE) {
+      const value = res.headers.get(name);
+      if (value) out.set(name, value);
+    }
+    if (res.status >= 400)
+      return jsonError(res.status === 401 ? 502 : res.status, "upstream error");
+    return new Response(req.method === "HEAD" ? null : res.body, {
+      status: res.status,
+      headers: out,
+    });
+  };
+
+  const server = Bun.serve({
+    hostname,
+    port: options.port ?? 0,
+    fetch: (req) => handle(req),
+  });
+  const host = hostname === "::1" ? "[::1]" : hostname;
+  const origin = `http://${host}:${server.port}`;
+
+  const sign: Dbxv2Proxy["sign"] = (kind, input, params = {}, ttl) => {
+    const ref = parseRef(input);
+    const query = resourceQuery(kind, params);
+    const exp = Math.floor(now() / 1000) + Math.min(Math.max(ttl ?? ttlDefault, 1), MAX_TTL);
+    const signature = mac(canonical(kind, `${ref.cpk}/${ref.path}`, query, exp)).toString("hex");
+    const search = new URLSearchParams(query);
+    search.set("exp", String(exp));
+    search.set("sig", signature);
+    return `${origin}/r/${kind}/${ref.cpk}/${encodePath(ref.path)}?${search}`;
+  };
+
+  return {
+    origin,
+    sign,
+    url: {
+      raw: (ref) => sign("raw", ref),
+      png: (ref, params) => sign("png", ref, params),
+      audio: (ref, params) => sign("wav", ref, params),
+      video: (ref) => sign("video", ref),
+      mp4: (ref) => sign("mp4", ref),
+      modelJson: (ref, params) => sign("model.json", ref, params),
+      modelGlb: (ref, params) => sign("model.glb", ref, params),
+    },
+    stop: () => {
+      void server.stop(true);
+    },
+  };
+}
+
+function numberOf(value: string | null): number | undefined {
+  if (value === null) return undefined;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= 0 ? n : Number.NaN;
+}
+
+function sortedString(params: URLSearchParams): string {
+  const copy = new URLSearchParams(params);
+  copy.sort();
+  return copy.toString();
+}

package/src/refs.ts

@@ -0,0 +1,126 @@
+/** References to entries of a CPK and the resource kinds served by the private server. */
+import { Dbxv2ConfigError } from "./errors";
+
+export interface Dbxv2Ref {
+  readonly cpk: string;
+  /** Path inside the CPK, forward slashes, no leading slash. */
+  readonly path: string;
+}
+
+export type Dbxv2RefInput = Dbxv2Ref | string;
+
+export type Dbxv2ResourceKind =
+  | "raw"
+  | "png"
+  | "wav"
+  | "video"
+  | "mp4"
+  | "model.json"
+  | "model.glb";
+
+export interface Dbxv2ResourceParams {
+  /** `png`: entry index inside the EMB. */
+  readonly index?: number;
+  /** `wav`: sub-sound index inside the ACB. */
+  readonly cue?: number;
+  /** `mp4`: segment start and length in seconds (server caps the length). */
+  readonly t?: number;
+  readonly d?: number;
+  /** `model.*`: explicit sibling EMB / ESK paths. */
+  readonly emb?: string;
+  readonly esk?: string;
+}
+
+export const DBXV2_RESOURCE_KINDS: readonly Dbxv2ResourceKind[] = [
+  "raw",
+  "png",
+  "wav",
+  "video",
+  "mp4",
+  "model.json",
+  "model.glb",
+];
+
+const CPK_NAME = /^[A-Za-z0-9_]+$/;
+
+/** Parses `"<cpk>/<path>"` or validates an object reference. */
+export function parseRef(input: Dbxv2RefInput): Dbxv2Ref {
+  let cpk: string;
+  let path: string;
+  if (typeof input === "string") {
+    const cut = input.indexOf("/");
+    if (cut < 0)
+      throw new Dbxv2ConfigError(`invalid DBXV2 reference "${input}": expected cpk/path`);
+    cpk = input.slice(0, cut);
+    path = input.slice(cut + 1);
+  } else {
+    cpk = input.cpk;
+    path = input.path;
+  }
+  if (!CPK_NAME.test(cpk)) throw new Dbxv2ConfigError(`invalid CPK name "${cpk}"`);
+  if (!path || path.startsWith("/") || path.includes("\0") || path.split("/").includes(".."))
+    throw new Dbxv2ConfigError(`invalid CPK entry path "${path}"`);
+  return { cpk, path };
+}
+
+export function formatRef(ref: Dbxv2Ref): string {
+  return `${ref.cpk}/${ref.path}`;
+}
+
+const encodePath = (path: string): string => path.split("/").map(encodeURIComponent).join("/");
+
+const secondsParam = (name: string, value: number | undefined, query: URLSearchParams): void => {
+  if (value === undefined) return;
+  if (!Number.isFinite(value) || value < 0)
+    throw new Dbxv2ConfigError(`${name} must be a non-negative number`);
+  query.set(name, String(value));
+};
+
+const intParam = (name: string, value: number | undefined, query: URLSearchParams): void => {
+  if (value === undefined) return;
+  if (!Number.isInteger(value) || value < 0)
+    throw new Dbxv2ConfigError(`${name} must be a non-negative integer`);
+  query.set(name, String(value));
+};
+
+/** Query parameters accepted by each kind (anything else is dropped). Keys are sorted. */
+export function resourceQuery(
+  kind: Dbxv2ResourceKind,
+  params: Dbxv2ResourceParams = {},
+): URLSearchParams {
+  const query = new URLSearchParams();
+  if (kind === "png") intParam("index", params.index, query);
+  if (kind === "wav") intParam("cue", params.cue, query);
+  if (kind === "mp4") {
+    secondsParam("t", params.t, query);
+    secondsParam("d", params.d, query);
+  }
+  if (kind === "model.json" || kind === "model.glb") {
+    if (params.emb !== undefined) query.set("emb", params.emb);
+    if (params.esk !== undefined) query.set("esk", params.esk);
+  }
+  query.sort();
+  return query;
+}
+
+/** Server path (no origin, no query) of a resource, e.g. `/cpk/CHARA/png/a/b.emb`. */
+export function resourcePath(kind: Dbxv2ResourceKind, input: Dbxv2RefInput): string {
+  const { cpk, path } = parseRef(input);
+  const base = `/cpk/${cpk}`;
+  switch (kind) {
+    case "raw":
+      return `${base}/raw/${encodePath(path)}`;
+    case "png":
+      return `${base}/png/${encodePath(path)}`;
+    case "wav":
+      return `${base}/wav/${encodePath(path)}`;
+    case "video":
+      return `${base}/video/${encodePath(path)}`;
+    case "mp4":
+      return `${base}/mp4/${encodePath(path)}`;
+    case "model.json":
+      return `${base}/model/${encodePath(path)}.json`;
+    case "model.glb":
+      return `${base}/model/${encodePath(path)}.glb`;
+  }
+}