@cueframe/kernel 0.2.1 → 0.2.3

package/dist/chunk-5OTQ7M43.js

@@ -1,718 +0,0 @@
-import {
-  cacheDir,
-  componentDir
-} from "./chunk-WB2VFDQZ.js";
-import {
-  COMPONENT_CHROMIUM_OPTIONS
-} from "./chunk-CGHTMZNC.js";
-import {
-  ComponentRuntimeError,
-  ComponentRuntimeErrorCode
-} from "./chunk-LQUWKBST.js";
-
-// ../execution/component-runtime/src/browserFirewall.ts
-function isLoopbackHost(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
-}
-function decideComponentRequest(url, resourceType, documentOrigin, allowedAssetOrigins) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return { allow: false, documentOrigin };
-  }
-  if (parsed.protocol === "data:" || parsed.protocol === "blob:" || parsed.protocol === "about:") {
-    return { allow: true, documentOrigin };
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    return { allow: false, documentOrigin };
-  }
-  if (documentOrigin === null && resourceType === "Document" && isLoopbackHost(parsed.hostname)) {
-    return { allow: true, documentOrigin: parsed.origin };
-  }
-  return {
-    allow: parsed.origin === documentOrigin || allowedAssetOrigins.has(parsed.origin),
-    documentOrigin
-  };
-}
-var PAGE_LOCKDOWN = `
-Object.defineProperties(globalThis, {
-  open: { value: undefined },
-  Worker: { value: undefined },
-  SharedWorker: { value: undefined },
-  RTCPeerConnection: { value: undefined },
-  webkitRTCPeerConnection: { value: undefined },
-  WebSocket: { value: undefined },
-  EventSource: { value: undefined }
-});
-`;
-var COMPONENT_PAGE_LOCKDOWN = PAGE_LOCKDOWN;
-async function installComponentRequestFirewall(browser, allowedAssetOrigins) {
-  let closing = false;
-  const denied = [];
-  const closeBrowser = browser.close.bind(browser);
-  browser.close = async (options) => {
-    closing = true;
-    return await closeBrowser(options);
-  };
-  const configureSession = async (client) => {
-    let documentOrigin = null;
-    client.on("Fetch.requestPaused", (event) => {
-      const decision = decideComponentRequest(
-        event.request.url,
-        event.resourceType,
-        documentOrigin,
-        allowedAssetOrigins
-      );
-      documentOrigin = decision.documentOrigin;
-      if (!decision.allow) denied.push(event.request.url);
-      const action = decision.allow ? client.send("Fetch.continueRequest", { requestId: event.requestId }) : client.send("Fetch.failRequest", { requestId: event.requestId, errorReason: "BlockedByClient" });
-      void action.catch(() => {
-      });
-    });
-    await client.send("Fetch.enable", { patterns: [{ urlPattern: "*" }] });
-    await client.send("Page.addScriptToEvaluateOnNewDocument", { source: PAGE_LOCKDOWN });
-    await client.send("Runtime.runIfWaitingForDebugger");
-  };
-  browser.connection.on("sessionattached", (client) => {
-    void configureSession(client).catch(() => {
-      if (!closing) void browser.close({ silent: true }).catch(() => {
-      });
-    });
-  });
-  await browser.connection.send("Target.setAutoAttach", {
-    autoAttach: true,
-    waitForDebuggerOnStart: true,
-    flatten: true,
-    filter: [{ type: "page", exclude: false }, { exclude: true }]
-  });
-  return { deniedRequests: () => denied };
-}
-
-// ../execution/component-runtime/src/render.ts
-import { mkdirSync, realpathSync, writeFileSync } from "fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
-import { fileURLToPath } from "url";
-
-// ../execution/component-runtime/src/determinism.ts
-function createDeterministicRuntimeScope(target) {
-  const failure = (name) => {
-    throw new Error(`Ambient nondeterministic API is not allowed: ${name}. Use render.frame, render.fps, and render.seed.`);
-  };
-  const deniedFunction = (name) => function deniedAmbientApi() {
-    return failure(name);
-  };
-  const guardedFacade = (value, label, blockedKeys, denyCall = false) => {
-    const blocked = new Set(blockedKeys);
-    const deniedByKey = /* @__PURE__ */ new Map();
-    const denied = (key) => {
-      let fn = deniedByKey.get(key);
-      if (!fn) {
-        fn = deniedFunction(`${label}.${String(key)}`);
-        deniedByKey.set(key, fn);
-      }
-      return fn;
-    };
-    return new Proxy(value, {
-      get(original, key, receiver) {
-        return blocked.has(key) ? denied(key) : Reflect.get(original, key, receiver);
-      },
-      getOwnPropertyDescriptor(original, key) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(original, key);
-        if (!blocked.has(key) || descriptor?.configurable === false) return descriptor;
-        return {
-          configurable: true,
-          enumerable: descriptor?.enumerable ?? false,
-          writable: false,
-          value: denied(key)
-        };
-      },
-      set(original, key, next, receiver) {
-        if (blocked.has(key)) return failure(`${label}.${String(key)} mutation`);
-        return Reflect.set(original, key, next, receiver);
-      },
-      defineProperty(original, key, descriptor) {
-        if (blocked.has(key)) return failure(`${label}.${String(key)} mutation`);
-        return Reflect.defineProperty(original, key, descriptor);
-      },
-      deleteProperty(original, key) {
-        if (blocked.has(key)) return failure(`${label}.${String(key)} mutation`);
-        return Reflect.deleteProperty(original, key);
-      },
-      apply(original, thisArg, args) {
-        if (denyCall) return failure(label);
-        return Reflect.apply(original, thisArg, args);
-      },
-      construct(original, args, newTarget) {
-        if (denyCall) return failure(label);
-        return Reflect.construct(original, args, newTarget);
-      }
-    });
-  };
-  const overrides = /* @__PURE__ */ new Map();
-  const math = target.Math;
-  if (math && (typeof math === "object" || typeof math === "function")) {
-    overrides.set("Math", guardedFacade(math, "Math", ["random"]));
-  }
-  const date = target.Date;
-  if (typeof date === "function") {
-    overrides.set("Date", guardedFacade(date, "Date", ["now"], true));
-  }
-  const performance = target.performance;
-  if (performance && (typeof performance === "object" || typeof performance === "function")) {
-    overrides.set("performance", guardedFacade(performance, "performance", ["now", "timeOrigin"]));
-  }
-  const crypto = target.crypto;
-  if (crypto && (typeof crypto === "object" || typeof crypto === "function")) {
-    overrides.set("crypto", guardedFacade(crypto, "crypto", ["getRandomValues", "randomUUID"]));
-  }
-  for (const name of ["requestAnimationFrame", "setTimeout", "setInterval", "Worker", "SharedWorker"]) {
-    if (name in target) overrides.set(name, deniedFunction(name));
-  }
-  let scope;
-  scope = new Proxy(target, {
-    get(original, key) {
-      if (key === "globalThis" || key === "window" || key === "self") return scope;
-      return overrides.has(key) ? overrides.get(key) : Reflect.get(original, key, original);
-    },
-    getOwnPropertyDescriptor(original, key) {
-      if (key === "globalThis" || key === "window" || key === "self" || overrides.has(key)) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(original, key);
-        if (descriptor?.configurable === false) return descriptor;
-        return {
-          configurable: true,
-          enumerable: descriptor?.enumerable ?? true,
-          writable: false,
-          value: key === "globalThis" || key === "window" || key === "self" ? scope : overrides.get(key)
-        };
-      }
-      return Reflect.getOwnPropertyDescriptor(original, key);
-    },
-    set(original, key, value, receiver) {
-      if (overrides.has(key) || key === "globalThis" || key === "window" || key === "self") {
-        return failure(`${String(key)} mutation`);
-      }
-      return Reflect.set(original, key, value, receiver);
-    },
-    defineProperty(original, key, descriptor) {
-      if (overrides.has(key) || key === "globalThis" || key === "window" || key === "self") {
-        return failure(`${String(key)} mutation`);
-      }
-      return Reflect.defineProperty(original, key, descriptor);
-    },
-    deleteProperty(original, key) {
-      if (overrides.has(key) || key === "globalThis" || key === "window" || key === "self") {
-        return failure(`${String(key)} mutation`);
-      }
-      return Reflect.deleteProperty(original, key);
-    }
-  });
-  return scope;
-}
-function deterministicRuntimeScopeSource() {
-  return createDeterministicRuntimeScope.toString();
-}
-
-// ../execution/component-runtime/src/render.ts
-var LOCAL_ROOT_FILENAME = "Root.local.tsx";
-var LOCAL_ENTRY_FILENAME = "entry.local.tsx";
-var LOCAL_COMPOSITION_ID = "CueFrameLocalStill";
-var GRAPHICS_ATTESTATION_PREFIX = "__cueframe_graphics_v2__:";
-var BROWSER_RUNTIME_ERROR_PREFIX = "__cueframe_component_error_v2__:";
-function componentRuntimeError(error, fallbackCode, retryable = false) {
-  if (error instanceof ComponentRuntimeError) return error;
-  const message = error instanceof Error ? error.message : String(error);
-  const marker = message.lastIndexOf(BROWSER_RUNTIME_ERROR_PREFIX);
-  if (marker >= 0) {
-    const payload = message.slice(marker + BROWSER_RUNTIME_ERROR_PREFIX.length);
-    const separator = payload.indexOf(":");
-    const code = ComponentRuntimeErrorCode.safeParse(separator >= 0 ? payload.slice(0, separator) : payload);
-    if (code.success) {
-      return new ComponentRuntimeError(
-        code.data,
-        separator >= 0 ? payload.slice(separator + 1) : message,
-        { retryable: code.data === "component_device_lost" || code.data === "component_deadline_exceeded", cause: error }
-      );
-    }
-  }
-  return new ComponentRuntimeError(fallbackCode, message, { retryable, cause: error });
-}
-function parseGraphicsAttestationLog(text) {
-  if (!text.startsWith(GRAPHICS_ATTESTATION_PREFIX)) return null;
-  try {
-    const parsed = JSON.parse(text.slice(GRAPHICS_ATTESTATION_PREFIX.length));
-    if (parsed.api !== "canvas2d" && parsed.api !== "webgpu" || parsed.acceleration !== "hardware" && parsed.acceleration !== "software" || parsed.deviceLost !== false) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function graphicsCollector(required) {
-  let attestation = null;
-  return {
-    onBrowserLog(log) {
-      const parsed = parseGraphicsAttestationLog(log.text);
-      if (!parsed) return;
-      if (parsed.api !== required.api) {
-        throw new ComponentRuntimeError(
-          "component_graphics_mismatch",
-          `Renderer reported ${parsed.api} for a ${required.api} component.`
-        );
-      }
-      if (attestation && JSON.stringify(attestation) !== JSON.stringify(parsed)) {
-        throw new ComponentRuntimeError(
-          "component_graphics_mismatch",
-          "Renderer workers reported inconsistent graphics adapters."
-        );
-      }
-      attestation = parsed;
-    },
-    receipt() {
-      if (!attestation) {
-        throw new ComponentRuntimeError(
-          "component_graphics_unavailable",
-          `Renderer produced no trusted ${required.api} attestation.`
-        );
-      }
-      return attestation;
-    }
-  };
-}
-function toImportSpecifier(fromDir, toFile) {
-  const rel = relative(fromDir, toFile).split("\\").join("/");
-  return rel.startsWith(".") ? rel : `./${rel}`;
-}
-function generateLocalRoot(ws, opts) {
-  const dir = cacheDir(ws);
-  mkdirSync(dir, { recursive: true });
-  const componentFile = join(componentDir(ws, opts.id), "index");
-  const componentSpecifier = toImportSpecifier(dir, componentFile);
-  const root = `// GENERATED by @cueframe/component-runtime \u2014 DO NOT EDIT.
-import React from 'react';
-import { useEffect, useState } from 'react';
-import { Composition, cancelRender, continueRender, delayRender, getInputProps, useCurrentFrame } from 'remotion';
-
-const importAuthoredComponent = async () => {
-  return import(${JSON.stringify(componentSpecifier)});
-};
-
-const GuardedAuthoredComponent: React.FC<{
-  Component: React.ComponentType<any>;
-  componentProps: Record<string, unknown>;
-}> = ({Component, componentProps}) => {
-  return <Component {...componentProps} />;
-};
-
-const Resolved: React.FC = () => {
-  const input = getInputProps() as {
-    params: Record<string, unknown>;
-    assets: Record<string, unknown>;
-    seed: string;
-    graphics: {
-      api: 'canvas2d' | 'webgpu';
-      required: true;
-      accelerationPreference: 'hardware-preferred' | 'software-allowed';
-    };
-  };
-  const frame = useCurrentFrame();
-  const [Component, setComponent] = useState<React.ComponentType<any> | null>(null);
-  const [waitHandle] = useState(() => input.graphics.api === 'webgpu'
-    ? delayRender('CueFrame WebGPU admission')
-    : null);
-
-  useEffect(() => {
-    let active = true;
-    let admissionTimer: ReturnType<typeof setTimeout> | undefined;
-    const canvasPrototype = HTMLCanvasElement.prototype as unknown as {
-      getContext: (kind: string, ...args: unknown[]) => unknown;
-    };
-    const originalGetContext = canvasPrototype.getContext;
-
-    void (async () => {
-      try {
-        if (input.graphics.api === 'canvas2d') {
-          const loaded = await importAuthoredComponent();
-          if (!active) return;
-          setComponent(() => loaded.default);
-          console.info(${JSON.stringify(GRAPHICS_ATTESTATION_PREFIX)} + JSON.stringify({
-            api: 'canvas2d', acceleration: 'software', deviceLost: false,
-          }));
-          return;
-        }
-
-        const gpu = (navigator as unknown as { gpu?: { requestAdapter: (options?: unknown) => Promise<unknown> } }).gpu;
-        if (!gpu) throw new Error(${JSON.stringify(BROWSER_RUNTIME_ERROR_PREFIX)} + 'component_graphics_unavailable:The staged browser does not expose WebGPU.');
-        let adapterInfo: { description?: string; architecture?: string; device?: string; vendor?: string; isFallbackAdapter?: boolean } = {};
-        const gpuPrototype = Object.getPrototypeOf(gpu) as { requestAdapter: (options?: unknown) => Promise<any> };
-        const originalRequestAdapter = gpuPrototype.requestAdapter;
-        gpuPrototype.requestAdapter = async function (options?: unknown) {
-          const adapter = await originalRequestAdapter.call(this, options);
-          if (adapter?.info) adapterInfo = adapter.info;
-          return adapter;
-        };
-        canvasPrototype.getContext = function (kind: string, ...args: unknown[]) {
-          if (kind !== 'webgpu') {
-            throw new Error('A WebGPU-required component may only create a WebGPU canvas context.');
-          }
-          const context = originalGetContext.call(this, kind, ...args) as null | { configure: (configuration: any) => void };
-          if (!context) return context;
-          const contextPrototype = Object.getPrototypeOf(context) as { configure: (configuration: any) => void; __cueframePatched?: boolean };
-          if (!contextPrototype.__cueframePatched) {
-            const originalConfigure = contextPrototype.configure;
-            Object.defineProperty(contextPrototype, '__cueframePatched', { value: true });
-            contextPrototype.configure = function (configuration: any) {
-              const result = originalConfigure.call(this, configuration);
-              if (active) {
-                const adapterName = [adapterInfo.vendor, adapterInfo.architecture, adapterInfo.device, adapterInfo.description]
-                  .filter(Boolean)
-                  .join(' ');
-                const softwarePattern = /swiftshader|software|fallback/i;
-                const acceleration = adapterInfo.isFallbackAdapter === true || softwarePattern.test(adapterName)
-                  ? 'software'
-                  : 'hardware';
-                console.info(${JSON.stringify(GRAPHICS_ATTESTATION_PREFIX)} + JSON.stringify({
-                  api: 'webgpu', acceleration, adapterName: adapterName || undefined, deviceLost: false,
-                }));
-                const device = configuration?.device as { lost?: Promise<unknown> } | undefined;
-                void device?.lost?.then(() => {
-                  if (active) cancelRender(new Error(${JSON.stringify(BROWSER_RUNTIME_ERROR_PREFIX)} + 'component_device_lost:WebGPU device was lost during component rendering.'));
-                });
-                active = false;
-                if (admissionTimer) clearTimeout(admissionTimer);
-                continueRender(waitHandle as number);
-              }
-              return result;
-            };
-          }
-          return context;
-        };
-        Object.defineProperty(globalThis, 'OffscreenCanvas', { value: undefined, configurable: true });
-        const loaded = await importAuthoredComponent();
-        if (!active) return;
-        setComponent(() => loaded.default);
-        admissionTimer = setTimeout(() => {
-          if (active) cancelRender(new Error(${JSON.stringify(BROWSER_RUNTIME_ERROR_PREFIX)} + 'component_graphics_mismatch:The component did not configure a WebGPU canvas surface.'));
-        }, 10_000);
-      } catch (error) {
-        cancelRender(error instanceof Error ? error : new Error(String(error)));
-      }
-    })();
-    return () => {
-      active = false;
-      if (admissionTimer) clearTimeout(admissionTimer);
-      canvasPrototype.getContext = originalGetContext;
-    };
-  }, []);
-
-  if (!Component) return null;
-  return <GuardedAuthoredComponent
-    Component={Component}
-    componentProps={{
-      durationInFrames: ${opts.durationInFrames},
-      params: input.params,
-      assets: input.assets,
-      render: {
-        frame,
-        fps: ${opts.fps},
-        width: ${opts.width},
-        height: ${opts.height},
-        seed: input.seed,
-        colorSpace: 'srgb',
-      },
-    }}
-  />;
-};
-
-export const RemotionRoot: React.FC = () => (
-  <Composition
-    id=${JSON.stringify(LOCAL_COMPOSITION_ID)}
-    component={Resolved}
-    durationInFrames={${opts.durationInFrames}}
-    fps={${opts.fps}}
-    width={${opts.width}}
-    height={${opts.height}}
-    defaultProps={{}}
-  />
-);
-`;
-  writeFileSync(join(dir, LOCAL_ROOT_FILENAME), root);
-  const entry = `// GENERATED by @cueframe/component-runtime \u2014 DO NOT EDIT.
-import { registerRoot } from 'remotion';
-import { RemotionRoot } from './${LOCAL_ROOT_FILENAME}';
-registerRoot(RemotionRoot);
-`;
-  const entryPath = join(dir, LOCAL_ENTRY_FILENAME);
-  writeFileSync(entryPath, entry);
-  return entryPath;
-}
-var DeterministicAuthoredModulePlugin = class {
-  #authoredComponentRoot;
-  #scopeSource;
-  constructor(authoredComponentRoot) {
-    this.#authoredComponentRoot = realpathSync(authoredComponentRoot);
-    this.#scopeSource = deterministicRuntimeScopeSource();
-  }
-  apply(compiler) {
-    const pluginName = "CueFrameDeterministicAuthoredModulePlugin";
-    compiler.hooks.compilation.tap(pluginName, (compilation) => {
-      const hooks = compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
-      const { ConcatSource } = compiler.webpack.sources;
-      hooks.renderModuleContent.tap(
-        pluginName,
-        (source, module) => {
-          if (!module.resource) return source;
-          const resource = realpathSync(module.resource.split("?")[0]);
-          const relativeResource = relative(this.#authoredComponentRoot, resource);
-          const belongsToAuthoredComponent = relativeResource === "" || relativeResource !== ".." && !relativeResource.startsWith(`..${sep}`) && !isAbsolute(relativeResource);
-          if (!belongsToAuthoredComponent) return source;
-          return new ConcatSource(
-            "const __cueframeHostGlobal = globalThis;\n{\nconst {globalThis, window, self, Math, Date, performance, crypto, requestAnimationFrame, setTimeout, setInterval, Worker, SharedWorker} = (",
-            this.#scopeSource,
-            ")(__cueframeHostGlobal);\n{\n",
-            source,
-            "\n}\n}\n"
-          );
-        }
-      );
-    });
-  }
-};
-function buildLocalWebpackOverride(renderEntryRoot, authoredComponentRoot) {
-  const animateEntry = join(resolve(renderEntryRoot, ".."), "animate", "src", "index.ts");
-  return (config) => ({
-    ...config,
-    resolve: {
-      ...config.resolve,
-      modules: [
-        ...config.resolve?.modules ?? ["node_modules"],
-        join(renderEntryRoot, "node_modules"),
-        join(resolve(renderEntryRoot, ".."), "animate", "node_modules"),
-        join(resolve(renderEntryRoot, "..", ".."), "node_modules"),
-        join(resolve(renderEntryRoot, "..", "..", ".."), "node_modules")
-      ],
-      alias: {
-        "@cueframe/animate$": animateEntry
-      }
-    },
-    plugins: [
-      ...config.plugins ?? [],
-      new DeterministicAuthoredModulePlugin(authoredComponentRoot)
-    ]
-  });
-}
-async function importFromRenderEntry(renderEntryRoot, spec) {
-  const { createRequire } = await import("module");
-  const { pathToFileURL } = await import("url");
-  const requireFromRenderEntry = createRequire(join(renderEntryRoot, "package.json"));
-  return await import(pathToFileURL(requireFromRenderEntry.resolve(spec)).href);
-}
-function resolveRenderEntryRoot(override) {
-  if (override) return override;
-  if (process.env.RENDER_ENTRY_ROOT) return process.env.RENDER_ENTRY_ROOT;
-  const here = dirname(fileURLToPath(import.meta.url));
-  return join(resolve(here, "..", ".."), "render-entry");
-}
-async function prepareLocalBundle(opts) {
-  const renderEntryRoot = resolveRenderEntryRoot(opts.renderEntryRoot);
-  const browserExecutable = process.env.REMOTION_CHROME_EXECUTABLE || void 0;
-  const entryPoint = generateLocalRoot(opts.ws, {
-    id: opts.id,
-    width: opts.width,
-    height: opts.height,
-    fps: opts.fps,
-    durationInFrames: opts.durationInFrames
-  });
-  const { bundle } = await importFromRenderEntry(
-    renderEntryRoot,
-    "@remotion/bundler"
-  );
-  let serveUrl;
-  try {
-    serveUrl = await bundle({
-      entryPoint,
-      webpackOverride: buildLocalWebpackOverride(renderEntryRoot, componentDir(opts.ws, opts.id))
-    });
-  } catch (error) {
-    throw componentRuntimeError(error, "component_does_not_compile");
-  }
-  return {
-    serveUrl,
-    browserExecutable,
-    inputProps: {
-      params: opts.params,
-      assets: opts.assets ?? {},
-      seed: opts.seed ?? "cueframe",
-      graphics: opts.graphics ?? {
-        api: "canvas2d",
-        required: true,
-        accelerationPreference: "software-allowed"
-      }
-    },
-    renderEntryRoot
-  };
-}
-async function renderComponentStill(opts) {
-  const width = opts.width ?? 1920;
-  const height = opts.height ?? 1080;
-  const fps = opts.fps ?? 30;
-  const durationInFrames = opts.durationInFrames ?? 1;
-  const frame = opts.frame ?? 0;
-  const { serveUrl, browserExecutable, inputProps, renderEntryRoot } = await prepareLocalBundle({
-    ws: opts.ws,
-    id: opts.id,
-    width,
-    height,
-    fps,
-    durationInFrames,
-    params: opts.params,
-    assets: opts.assets,
-    seed: opts.seed,
-    graphics: opts.graphics,
-    renderEntryRoot: opts.renderEntryRoot
-  });
-  const { openBrowser, selectComposition, renderStill } = await importFromRenderEntry(
-    renderEntryRoot,
-    "@remotion/renderer"
-  );
-  const requiredGraphics = opts.graphics ?? {
-    api: "canvas2d",
-    required: true,
-    accelerationPreference: "software-allowed"
-  };
-  const collector = graphicsCollector(requiredGraphics);
-  let browser;
-  try {
-    browser = await openBrowser("chrome", {
-      browserExecutable,
-      chromiumOptions: COMPONENT_CHROMIUM_OPTIONS
-    });
-  } catch (error) {
-    throw componentRuntimeError(error, "component_resource_exhausted", true);
-  }
-  const firewall = await installComponentRequestFirewall(browser, opts.allowedAssetOrigins ?? /* @__PURE__ */ new Set());
-  try {
-    const composition = await selectComposition({
-      serveUrl,
-      id: LOCAL_COMPOSITION_ID,
-      inputProps,
-      puppeteerInstance: browser,
-      onBrowserLog: collector.onBrowserLog
-    });
-    const pngPath = join(cacheDir(opts.ws), `still-${opts.id}.png`);
-    await renderStill({
-      composition,
-      serveUrl,
-      inputProps,
-      output: pngPath,
-      frame,
-      puppeteerInstance: browser,
-      timeoutInMilliseconds: 12e4,
-      onBrowserLog: collector.onBrowserLog
-    });
-    const denied = firewall.deniedRequests();
-    if (denied.length > 0) {
-      throw new ComponentRuntimeError("component_network_denied", `Component attempted ${denied.length} denied network request(s).`);
-    }
-    return { pngPath, actualGraphics: collector.receipt() };
-  } catch (error) {
-    throw componentRuntimeError(error, "component_runtime_error");
-  } finally {
-    await browser.close({ silent: true });
-  }
-}
-function alphaRenderConfig(codec) {
-  return codec === "prores" ? { codec: "prores", proResProfile: "4444", pixelFormat: "yuva444p10le", imageFormat: "png", muted: true } : { codec: "vp9", pixelFormat: "yuva420p", imageFormat: "png", muted: true };
-}
-function alphaExt(codec) {
-  return codec === "prores" ? "mov" : "webm";
-}
-async function renderComponentAlpha(opts) {
-  const width = opts.width ?? 1920;
-  const height = opts.height ?? 1080;
-  const fps = opts.fps ?? 30;
-  const durationInFrames = opts.durationInFrames ?? fps * 3;
-  const codec = opts.codec ?? "prores";
-  const { serveUrl, browserExecutable, inputProps, renderEntryRoot } = await prepareLocalBundle({
-    ws: opts.ws,
-    id: opts.id,
-    width,
-    height,
-    fps,
-    durationInFrames,
-    params: opts.params,
-    assets: opts.assets,
-    seed: opts.seed,
-    graphics: opts.graphics,
-    renderEntryRoot: opts.renderEntryRoot
-  });
-  const { openBrowser, selectComposition, renderMedia } = await importFromRenderEntry(
-    renderEntryRoot,
-    "@remotion/renderer"
-  );
-  const requiredGraphics = opts.graphics ?? {
-    api: "canvas2d",
-    required: true,
-    accelerationPreference: "software-allowed"
-  };
-  const collector = graphicsCollector(requiredGraphics);
-  let browser;
-  try {
-    browser = await openBrowser("chrome", {
-      browserExecutable,
-      chromiumOptions: COMPONENT_CHROMIUM_OPTIONS
-    });
-  } catch (error) {
-    throw componentRuntimeError(error, "component_resource_exhausted", true);
-  }
-  const firewall = await installComponentRequestFirewall(browser, opts.allowedAssetOrigins ?? /* @__PURE__ */ new Set());
-  try {
-    const composition = await selectComposition({
-      serveUrl,
-      id: LOCAL_COMPOSITION_ID,
-      inputProps,
-      puppeteerInstance: browser,
-      onBrowserLog: collector.onBrowserLog
-    });
-    const rangeSuffix = opts.frameRange ? `-${opts.frameRange[0]}-${opts.frameRange[1]}` : "";
-    const videoPath = join(cacheDir(opts.ws), `alpha-${opts.id}${rangeSuffix}.${alphaExt(codec)}`);
-    await renderMedia({
-      composition,
-      serveUrl,
-      inputProps,
-      puppeteerInstance: browser,
-      outputLocation: videoPath,
-      ...alphaRenderConfig(codec),
-      onBrowserLog: collector.onBrowserLog,
-      concurrency: 1,
-      ...opts.frameRange ? { frameRange: opts.frameRange } : {}
-    });
-    const denied = firewall.deniedRequests();
-    if (denied.length > 0) {
-      throw new ComponentRuntimeError("component_network_denied", `Component attempted ${denied.length} denied network request(s).`);
-    }
-    return { videoPath, actualGraphics: collector.receipt() };
-  } catch (error) {
-    throw componentRuntimeError(error, "component_runtime_error");
-  } finally {
-    await browser.close({ silent: true });
-  }
-}
-
-export {
-  decideComponentRequest,
-  COMPONENT_PAGE_LOCKDOWN,
-  installComponentRequestFirewall,
-  LOCAL_ROOT_FILENAME,
-  LOCAL_ENTRY_FILENAME,
-  LOCAL_COMPOSITION_ID,
-  GRAPHICS_ATTESTATION_PREFIX,
-  parseGraphicsAttestationLog,
-  generateLocalRoot,
-  buildLocalWebpackOverride,
-  importFromRenderEntry,
-  resolveRenderEntryRoot,
-  renderComponentStill,
-  alphaRenderConfig,
-  alphaExt,
-  renderComponentAlpha
-};