@kieransimkin/dancemoves 3.0.2

package/lib/server.cjs

@@ -0,0 +1,411 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// .build/modules/server.mjs
+var server_exports = {};
+__export(server_exports, {
+  PAGE_META_KEYS: () => PAGE_META_KEYS,
+  ValidationError: () => ValidationError,
+  createCaptureHandler: () => createCaptureHandler,
+  createDownloadService: () => createDownloadService,
+  createMemoryPageStore: () => createMemoryPageStore,
+  createMemoryRateLimiter: () => createMemoryRateLimiter,
+  fromWordPressMeta: () => fromWordPressMeta,
+  normalizeDownloadPath: () => normalizeDownloadPath,
+  validateMotionCapture: () => validateMotionCapture,
+  validatePageConfig: () => validatePageConfig,
+  validateTimingFile: () => validateTimingFile
+});
+module.exports = __toCommonJS(server_exports);
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_stream = require("node:stream");
+
+// .build/modules/config.mjs
+var PAGE_META_KEYS = Object.freeze({
+  bpm: "_dance_moves_bpm",
+  lyric: "_dance_moves_lyric_timing_id",
+  cue: "_dance_moves_cue_timing_id",
+  popups: "_dance_moves_lyric_popups_enabled",
+  duration: "_dance_moves_master_duration_ms",
+  effect: "_dance_moves_effect"
+});
+var object = (value) => value && typeof value === "object" && !Array.isArray(value);
+function finite(value, name, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max)
+    throw new RangeError(`${name} must be a finite number in [${min}, ${max}]`);
+  return value;
+}
+function url(value, name) {
+  if (value === void 0 || value === "") return "";
+  if (typeof value !== "string" || value.length > 4096 || /[\u0000-\u001f]/.test(value)) throw new TypeError(`Invalid ${name}`);
+  const parsed = new URL(value, "https://dancemoves.invalid/");
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password)
+    throw new TypeError(`${name} must be an HTTP(S) or relative URL`);
+  return value;
+}
+function validatePageConfig(input = {}) {
+  if (!object(input)) throw new TypeError("Page configuration must be an object");
+  const explicit = input.bpm !== void 0 && input.bpm !== null && input.bpm !== "";
+  const bpm = explicit ? Math.round(finite(input.bpm, "bpm", 20, 400) * 1e3) / 1e3 : 120;
+  const effect = input.effect ?? "";
+  if (!["", "paper-planes"].includes(effect)) throw new RangeError("effect must be empty or paper-planes");
+  if (input.lyricPopupsEnabled !== void 0 && typeof input.lyricPopupsEnabled !== "boolean") throw new TypeError("lyricPopupsEnabled must be boolean");
+  const duration = finite(input.masterDurationMilliseconds ?? 0, "masterDurationMilliseconds", 0, 864e5);
+  const ticks = finite(input.sharedControlTicks ?? 0, "sharedControlTicks", 0, 65536);
+  const disclosure = finite(input.lyricDisclosureTicks ?? 6, "lyricDisclosureTicks", 1, 65536);
+  const pageId = input.pageId ?? 0;
+  if (!Number.isSafeInteger(pageId) || pageId < 0) throw new RangeError("pageId must be a non-negative safe integer");
+  return Object.freeze({
+    pageId,
+    bpm,
+    bpmSource: explicit && input.bpmSource !== "fallback" ? "explicit" : "fallback",
+    fallbackBpm: 120,
+    ticksPerBeat: 16,
+    tickDefinition: "sixteenth-of-beat",
+    longDurationQuantumTicks: 16,
+    cueTimingUrl: url(input.cueTimingUrl, "cueTimingUrl"),
+    lyricTimingUrl: url(input.lyricTimingUrl, "lyricTimingUrl"),
+    lyricPopupsEnabled: input.lyricPopupsEnabled === true,
+    masterDurationMilliseconds: Math.round(duration * 1e3) / 1e3,
+    sharedControlTicks: ticks,
+    lyricDisclosureTicks: disclosure,
+    effect,
+    diagnostics: input.diagnostics === true
+  });
+}
+async function fromWordPressMeta(meta, resolveAttachment) {
+  if (!object(meta)) throw new TypeError("meta must be an object");
+  const numeric2 = (value) => value !== "" && value !== null && value !== void 0 && Number.isFinite(Number(value));
+  const b = meta[PAGE_META_KEYS.bpm];
+  const bpm = numeric2(b) && Number(b) >= 20 && Number(b) <= 400 ? Number(b) : void 0;
+  const resolve = async (key) => {
+    const value = Number(meta[key] || 0);
+    if (!Number.isSafeInteger(value)) throw new RangeError("Attachment ID must be a safe integer");
+    const id = Math.abs(value);
+    if (!id) return "";
+    if (typeof resolveAttachment !== "function") throw new TypeError("An attachment URL resolver is required for nonzero IDs");
+    return await resolveAttachment(id) || "";
+  };
+  const duration = Number(meta[PAGE_META_KEYS.duration]);
+  return validatePageConfig({
+    bpm,
+    lyricTimingUrl: await resolve(PAGE_META_KEYS.lyric),
+    cueTimingUrl: await resolve(PAGE_META_KEYS.cue),
+    lyricPopupsEnabled: meta[PAGE_META_KEYS.popups] === true || String(meta[PAGE_META_KEYS.popups]) === "1",
+    masterDurationMilliseconds: Number.isFinite(duration) && duration > 0 && duration <= 864e5 ? duration : 0,
+    effect: meta[PAGE_META_KEYS.effect] === "paper-planes" ? "paper-planes" : ""
+  });
+}
+function createMemoryPageStore({ maxPages = 100, maxRevisions = 20 } = {}) {
+  for (const [name, value] of Object.entries({ maxPages, maxRevisions })) if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(name);
+  const pages = /* @__PURE__ */ new Map();
+  const key = (id) => {
+    if (typeof id !== "string" || !id.trim() || id.length > 160) throw new TypeError("Invalid page id");
+    return id;
+  };
+  const clone = (value) => value ? structuredClone(value) : null;
+  return Object.freeze({
+    read(id) {
+      return clone(pages.get(key(id))?.at(-1) || null);
+    },
+    revisions(id) {
+      return clone(pages.get(key(id)) || []);
+    },
+    save(id, input, { expectedRevision } = {}) {
+      key(id);
+      const config = validatePageConfig(input);
+      const history = pages.get(id) || [];
+      const current = history.at(-1)?.revision || 0;
+      if (expectedRevision !== void 0 && expectedRevision !== current) throw new Error("Revision conflict");
+      if (!pages.has(id) && pages.size >= maxPages) throw new Error("Page store capacity reached");
+      const record = { revision: current + 1, config, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      pages.set(id, [...history, record].slice(-maxRevisions));
+      return clone(record);
+    },
+    restore(id, revision, options) {
+      const record = (pages.get(key(id)) || []).find((item) => item.revision === revision);
+      if (!record) throw new RangeError("Revision not found");
+      return this.save(id, record.config, options);
+    },
+    delete(id) {
+      return pages.delete(key(id));
+    }
+  });
+}
+
+// .build/modules/server.mjs
+var ValidationError = class extends Error {
+  constructor(code, message, status = 400) {
+    super(message);
+    this.name = "ValidationError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var fail = (code, message, status) => {
+  throw new ValidationError(code, message, status);
+};
+function validateTimingFile(input, { kind = "cue", filename, maxBytes = 1048576 } = {}) {
+  if (!["cue", "lyric"].includes(kind)) throw new TypeError("kind must be cue or lyric");
+  if (filename) {
+    const ext = import_node_path.default.extname(filename).toLowerCase();
+    if (!(kind === "lyric" ? [".lrc"] : [".lrc", ".cue"]).includes(ext)) fail("timing_extension", "Incorrect timing-file extension");
+  }
+  if (typeof input !== "string" && !(input instanceof Uint8Array)) throw new TypeError("Timing input must be text or bytes");
+  const bytes = typeof input === "string" ? Buffer.from(input, "utf8") : input;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || bytes.byteLength > maxBytes) fail("timing_size", "Timing file exceeds the byte limit", 413);
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    fail("timing_utf8", "Timing file is not valid UTF-8");
+  }
+  if (/[\u0000\uFFFD]/.test(text)) fail("timing_utf8", "Timing file contains a null or replacement character");
+  const stamps = [...text.matchAll(/\[(\d{1,3}):(\d{2})(?:[\.:](\d{1,3}))?\]/g)];
+  if (!stamps.length) fail("timing_timestamps", "Timing file must contain at least one bracketed timestamp");
+  let previous = -1;
+  for (const stamp of stamps) {
+    const time = Number(stamp[1]) * 60 + Number(stamp[2]) + (stamp[3] ? Number("0." + stamp[3]) : 0);
+    if (time < previous) fail("timing_order", "Timing timestamps must be monotonic");
+    previous = time;
+  }
+  return Object.freeze({ text, kind, bytes: bytes.byteLength, timestamps: stamps.length });
+}
+function normalizeDownloadPath(value) {
+  if (typeof value !== "string" || value.length > 4096) return "";
+  let result;
+  try {
+    result = decodeURIComponent(value.trim().replaceAll("\\", "/"));
+  } catch {
+    return "";
+  }
+  if (!result || result.startsWith("/") || /[:\u0000-\u001f\u007f\\]/.test(result) || !/\.mp3$/i.test(result)) return "";
+  if (result.split("/").some((part) => !part || part === "." || part === "..")) return "";
+  return result;
+}
+function asOrigin(value) {
+  const u = new URL(value);
+  if (!["https:", "http:"].includes(u.protocol) || u.username || u.password) throw new TypeError("Invalid HTTP origin");
+  return u.origin;
+}
+function privateHeaders() {
+  return { "Cache-Control": "private, no-store, max-age=0", "X-Content-Type-Options": "nosniff", "X-Robots-Tag": "noindex, nofollow" };
+}
+function json(body, status = 200, extra = {}) {
+  return new Response(JSON.stringify(body), { status, headers: { ...privateHeaders(), "Content-Type": "application/json; charset=utf-8", ...extra } });
+}
+function createDownloadService({ rootDirectory, secret, origin, route = "/api/download" } = {}) {
+  if (typeof rootDirectory !== "string" || !import_node_path.default.isAbsolute(rootDirectory)) throw new TypeError("rootDirectory must be an absolute local directory");
+  if (!(typeof secret === "string" || secret instanceof Uint8Array) || Buffer.byteLength(secret) < 32) throw new TypeError("Use a server-only secret of at least 32 bytes");
+  const baseOrigin = asOrigin(origin);
+  if (typeof route !== "string" || !route.startsWith("/") || route.startsWith("//")) throw new TypeError("route must be a same-origin absolute path");
+  const routeURL = new URL(route, baseOrigin);
+  if (routeURL.origin !== baseOrigin || routeURL.search || routeURL.hash) throw new TypeError("route must not include an origin, query or fragment");
+  const digest = (relative) => (0, import_node_crypto.createHmac)("sha256", secret).update(relative).digest("hex");
+  function sign(relative) {
+    const normal = normalizeDownloadPath(relative);
+    if (!normal) throw new ValidationError("download_path", "A safe relative MP3 path is required");
+    const url2 = new URL(routeURL);
+    url2.searchParams.set("path", normal);
+    url2.searchParams.set("signature", digest(normal));
+    return url2.href;
+  }
+  async function handle(request) {
+    let input;
+    try {
+      input = new URL(request.url);
+    } catch {
+      return new Response(null, { status: 404, headers: privateHeaders() });
+    }
+    if (input.pathname !== routeURL.pathname) return new Response(null, { status: 404, headers: privateHeaders() });
+    const relative = normalizeDownloadPath(input.searchParams.get("path"));
+    const signature = input.searchParams.get("signature") || "";
+    if (!relative || !/^[0-9a-f]{64}$/i.test(signature) || !(0, import_node_crypto.timingSafeEqual)(Buffer.from(signature, "hex"), Buffer.from(digest(relative), "hex")))
+      return new Response(null, { status: 404, headers: privateHeaders() });
+    if (!["GET", "HEAD"].includes(request.method)) return new Response(null, { status: 405, headers: { ...privateHeaders(), Allow: "GET, HEAD" } });
+    let file;
+    try {
+      const base = await (0, import_promises.realpath)(rootDirectory);
+      const resolved = await (0, import_promises.realpath)(import_node_path.default.join(base, ...relative.split("/")));
+      const rel = import_node_path.default.relative(base, resolved);
+      if (!rel || rel === ".." || rel.startsWith(".." + import_node_path.default.sep) || import_node_path.default.isAbsolute(rel) || import_node_path.default.extname(resolved).toLowerCase() !== ".mp3") return new Response(null, { status: 404, headers: privateHeaders() });
+      file = await (0, import_promises.open)(resolved, import_node_fs.constants.O_RDONLY | (import_node_fs.constants.O_NOFOLLOW || 0));
+      const stat = await file.stat();
+      if (!stat.isFile()) {
+        await file.close();
+        return new Response(null, { status: 404, headers: privateHeaders() });
+      }
+      const filename = import_node_path.default.basename(resolved);
+      const ascii = filename.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_") || "audio.mp3";
+      const encoded = encodeURIComponent(filename).replace(/['()*]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+      const headers = {
+        ...privateHeaders(),
+        "Content-Type": "audio/mpeg",
+        "Content-Length": String(stat.size),
+        "Content-Disposition": `attachment; filename="${ascii}"; filename*=UTF-8''${encoded}`
+      };
+      if (request.method === "HEAD") {
+        await file.close();
+        return new Response(null, { status: 200, headers });
+      }
+      const stream = file.createReadStream({ autoClose: true });
+      return new Response(import_node_stream.Readable.toWeb(stream), { status: 200, headers });
+    } catch {
+      if (file) await file.close().catch(() => {
+      });
+      return new Response(null, { status: 404, headers: privateHeaders() });
+    }
+  }
+  return Object.freeze({ sign, handle });
+}
+var numeric = (v, min, max) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max;
+function boundedText(value, max = 500) {
+  return String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, "").slice(0, max);
+}
+function validateMotionCapture(payload) {
+  if (!payload || payload.schema !== "ks-epk-motion-recording/v1") fail("ks_motion_schema", "Unsupported capture schema");
+  if (!Array.isArray(payload.samples) || payload.samples.length < 1 || payload.samples.length > 500) fail("ks_motion_samples", "A capture must contain 1..500 samples");
+  const samples = payload.samples.map((sample) => {
+    if (!sample || !numeric(sample.milliseconds, 0, 12e4) || !numeric(sample.beta, -180, 180) || !numeric(sample.gamma, -90, 90)) fail("ks_motion_invalid_samples", "Invalid motion sample");
+    return {
+      milliseconds: sample.milliseconds,
+      beta: sample.beta,
+      gamma: sample.gamma,
+      alpha: sample.alpha === null || sample.alpha === void 0 ? null : numeric(sample.alpha, 0, 360) ? sample.alpha : null,
+      screenAngle: numeric(sample.screenAngle ?? 0, -360, 360) ? sample.screenAngle || 0 : null,
+      ...Object.fromEntries(["absolute", "nativeTrusted", "simulatedTrusted", "fieldParity", "dispatchParity", "mapperParity"].map((k) => [k, !!sample[k]]))
+    };
+  });
+  const clean = {
+    schema: payload.schema,
+    capturedAt: boundedText(payload.capturedAt, 100),
+    userAgent: boundedText(payload.userAgent),
+    samples,
+    screenAngle: numeric(payload.screenAngle ?? 0, -360, 360) ? payload.screenAngle || 0 : null,
+    storedSampleCount: samples.length,
+    sampleStrategy: boundedText(payload.sampleStrategy || "legacy", 80).toLowerCase().replace(/[^a-z0-9_-]/g, ""),
+    fullWindowObserved: !!payload.fullWindowObserved,
+    expectedDifference: boundedText(payload.expectedDifference),
+    passed: !!payload.passed,
+    failures: (Array.isArray(payload.failures) ? payload.failures : []).slice(0, 100).filter((v) => v && typeof v === "object").map((v) => ({
+      type: boundedText(v.type || "unknown", 80).toLowerCase().replace(/[^a-z0-9_-]/g, ""),
+      sample: Number.isFinite(Number(v.sample)) ? Math.abs(Math.trunc(Number(v.sample))) : null,
+      validPairs: Number.isFinite(Number(v.validPairs)) ? Math.abs(Math.trunc(Number(v.validPairs))) : null
+    }))
+  };
+  for (const key of ["targetDurationMilliseconds", "captureDurationMilliseconds", "sampledDurationMilliseconds", "storageIntervalMilliseconds"]) clean[key] = numeric(payload[key] ?? 0, 0, 12e4) ? payload[key] || 0 : null;
+  for (const key of ["processedPairCount", "failureCount"]) clean[key] = Math.min(1e5, Math.abs(Math.trunc(Number(payload[key]) || (key === "processedPairCount" ? samples.length : clean.failures.length))));
+  if (Buffer.byteLength(JSON.stringify(clean)) > 262144) fail("ks_motion_size", "Capture too large", 413);
+  return clean;
+}
+function createMemoryRateLimiter({ limit = 8, windowMilliseconds = 6e5, maxKeys = 1e4, now = Date.now } = {}) {
+  for (const [key, value] of Object.entries({ limit, windowMilliseconds, maxKeys })) if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(key);
+  const records = /* @__PURE__ */ new Map();
+  return Object.freeze({ consume(key) {
+    if (typeof key !== "string" || !key || key.length > 512) return false;
+    const time = now();
+    for (const [id, r2] of records) if (r2.until <= time) records.delete(id);
+    if (!records.has(key) && records.size >= maxKeys) return false;
+    const r = records.get(key) || { until: time + windowMilliseconds, count: 0 };
+    records.set(key, r);
+    return ++r.count <= limit;
+  } });
+}
+async function boundedBody(request, maxBytes) {
+  const length = request.headers.get("content-length");
+  if (length && (!/^\d+$/.test(length) || Number(length) > maxBytes)) fail("ks_motion_size", "Capture too large", 413);
+  if (!request.body) fail("ks_motion_schema", "Missing JSON body");
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel();
+        fail("ks_motion_size", "Capture too large", 413);
+      }
+      chunks.push(value);
+    }
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
+  } catch (error) {
+    if (error instanceof ValidationError) throw error;
+    fail("ks_motion_schema", "Invalid UTF-8 JSON");
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createCaptureHandler({ authorize, store, rateLimit, allowedOrigin, maxBytes = 262144 } = {}) {
+  for (const [key, fn] of Object.entries({ authorize, store, rateLimit })) if (typeof fn !== "function") throw new TypeError(`${key} callback is required`);
+  const origin = asOrigin(allowedOrigin);
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 262144) throw new RangeError("maxBytes must be 1..262144");
+  return async (request) => {
+    if (request.method !== "POST") return json({ code: "method_not_allowed" }, 405, { Allow: "POST" });
+    try {
+      const source = request.headers.get("origin");
+      if (source) {
+        let sourceOrigin;
+        try {
+          sourceOrigin = asOrigin(source);
+        } catch {
+          return json({ code: "ks_motion_origin" }, 403);
+        }
+        if (sourceOrigin !== origin) return json({ code: "ks_motion_origin" }, 403);
+      }
+      if (!await authorize(request)) return json({ code: "ks_motion_forbidden" }, 403);
+      if (!await rateLimit(request)) return json({ code: "ks_motion_rate" }, 429, { "Retry-After": "600" });
+      if (!/^application\/json(?:\s*;|$)/i.test(request.headers.get("content-type") || "")) return json({ code: "ks_motion_content_type" }, 415);
+      const capture = validateMotionCapture(await boundedBody(request, maxBytes));
+      const stored = await store(capture, { visibility: "private", request });
+      if (!stored || !stored.captureId || stored.storedPrivately !== true) throw new Error("Storage did not confirm private persistence");
+      return json({ captureId: stored.captureId, sampleCount: capture.samples.length, storedPrivately: true });
+    } catch (error) {
+      if (error instanceof ValidationError) return json({ code: error.code, message: error.message }, error.status);
+      return json({ code: "ks_motion_server", message: "Capture could not be stored" }, 500);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PAGE_META_KEYS,
+  ValidationError,
+  createCaptureHandler,
+  createDownloadService,
+  createMemoryPageStore,
+  createMemoryRateLimiter,
+  fromWordPressMeta,
+  normalizeDownloadPath,
+  validateMotionCapture,
+  validatePageConfig,
+  validateTimingFile
+});

package/lib/server.d.ts

@@ -0,0 +1,11 @@
+export {validatePageConfig,fromWordPressMeta,PAGE_META_KEYS,createMemoryPageStore} from './index';
+import type {MotionCapture} from './index';
+export class ValidationError extends Error {code:string;status:number;constructor(code:string,message:string,status?:number)}
+export function validateTimingFile(input:string|Uint8Array,options?:{kind?:'cue'|'lyric';filename?:string;maxBytes?:number}):Readonly<{text:string;kind:string;bytes:number;timestamps:number}>;
+export function normalizeDownloadPath(value:unknown):string;
+export function createDownloadService(options:{rootDirectory:string;secret:string|Uint8Array;origin:string;route?:string}):Readonly<{sign(relative:string):string;handle(request:Request):Promise<Response>}>;
+export function validateMotionCapture(input:unknown):MotionCapture;
+export function createMemoryRateLimiter(options?:{limit?:number;windowMilliseconds?:number;maxKeys?:number;now?:()=>number}):Readonly<{consume(key:string):boolean}>;
+export function createCaptureHandler(options:{authorize:(request:Request)=>boolean|Promise<boolean>;rateLimit:(request:Request)=>boolean|Promise<boolean>;
+ store:(capture:MotionCapture,context:{visibility:'private';request:Request})=>Promise<{captureId:string|number;storedPrivately:true}>;
+ allowedOrigin:string;maxBytes?:number}):(request:Request)=>Promise<Response>;