@twick/vite-plugin 0.14.21 → 0.15.0

package/dist/index.js

@@ -0,0 +1,842 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/main.ts
+import path10 from "path";
+
+// src/partials/assets.ts
+import fs from "fs";
+import path from "path";
+import { Readable } from "stream";
+var AUDIO_EXTENSION_REGEX = /\.(mp3|wav|ogg|aac|flac)(?:$|\?)/;
+var AUDIO_HMR_DELAY = 1e3;
+function assetsPlugin({ bufferedAssets }) {
+  let config;
+  return {
+    name: "twick:assets",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url && bufferedAssets && bufferedAssets.test(req.url)) {
+          const file = fs.readFileSync(
+            path.resolve(config.root, req.url.slice(1))
+          );
+          Readable.from(file).pipe(res);
+          return;
+        }
+        next();
+      });
+    },
+    async handleHotUpdate(ctx) {
+      const urls = [];
+      const modules = [];
+      for (const module of ctx.modules) {
+        urls.push(module.url);
+        if (!AUDIO_EXTENSION_REGEX.test(module.url)) {
+          modules.push(module);
+        } else {
+          await new Promise((resolve) => {
+            setTimeout(resolve, AUDIO_HMR_DELAY);
+          });
+        }
+      }
+      if (urls.length > 0) {
+        ctx.server.ws.send("twick:assets", { urls });
+      }
+      return modules;
+    }
+  };
+}
+
+// src/partials/editor.ts
+import fs2 from "fs";
+import path2 from "path";
+function editorPlugin({ editor, projects }) {
+  const editorPath = path2.dirname(__require.resolve(editor));
+  const editorFile = fs2.readFileSync(path2.resolve(editorPath, "editor.html"));
+  const htmlParts = editorFile.toString().replace("{{style}}", `/@fs/${path2.resolve(editorPath, "style.css")}`).split("{{source}}");
+  const createHtml = (src) => htmlParts[0] + src + htmlParts[1];
+  const resolvedEditorId = "\0virtual:editor";
+  return {
+    name: "twick:editor",
+    async load(id) {
+      const [, query] = id.split("?");
+      if (id.startsWith(resolvedEditorId)) {
+        if (projects.list.length === 1) {
+          return `import {editor} from '${editor}';
+import project from '${projects.list[0].url}';
+import {addEditorToProject} from '@twick/core';
+editor(await addEditorToProject(project));
+`;
+        }
+        if (query) {
+          const params = new URLSearchParams(query);
+          const name = params.get("project");
+          if (name && projects.lookup.has(name)) {
+            return `import {editor} from '${editor}';
+import project from '${projects.lookup.get(name).url}';
+import {addEditorToProject} from '@twick/core';
+editor(await addEditorToProject(project));
+`;
+          }
+        }
+        return `import {index} from '${editor}';
+index(${JSON.stringify(projects.list)});
+`;
+      }
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url) {
+          const url = new URL(req.url, `http://${req.headers.host}`);
+          if (url.pathname === "/") {
+            res.setHeader("Content-Type", "text/html");
+            res.end(createHtml("/@id/__x00__virtual:editor"));
+            return;
+          }
+          const name = url.pathname.slice(1);
+          if (name && projects.lookup.has(name)) {
+            res.setHeader("Content-Type", "text/html");
+            res.end(createHtml(`/@id/__x00__virtual:editor?project=${name}`));
+            return;
+          }
+        }
+        next();
+      });
+    }
+  };
+}
+
+// src/partials/ffmpegBridge.ts
+import {
+  FFmpegExporterServer,
+  VideoFrameExtractor,
+  generateAudio,
+  mergeMedia
+} from "@twick/ffmpeg";
+import { existsSync, unlinkSync } from "fs";
+function ffmpegBridgePlugin({ output }) {
+  return {
+    name: "twick/ffmpeg",
+    configureServer(server) {
+      const ffmpegBridge = new FFmpegBridge(server.ws, { output });
+      const handlePostRequest = async (req, res, handler) => {
+        if (req.method !== "POST") {
+          res.statusCode = 405;
+          res.end("Method Not Allowed");
+          return;
+        }
+        try {
+          const body = await new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => data += chunk);
+            req.on("end", () => resolve(data));
+            req.on("error", reject);
+          });
+          const parsedBody = JSON.parse(body);
+          const result = await handler(parsedBody);
+          if (res.writableEnded) {
+            return;
+          }
+          res.statusCode = 200;
+          if (result) {
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(result));
+            return;
+          }
+          res.end("OK");
+        } catch (error) {
+          console.error("error in request handler", error);
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        }
+      };
+      server.middlewares.use(
+        "/audio-processing/generate-audio",
+        (req, res) => handlePostRequest(
+          req,
+          res,
+          async ({ tempDir, assets, startFrame, endFrame, fps }) => generateAudio({
+            outputDir: output,
+            tempDir,
+            assets,
+            startFrame,
+            endFrame,
+            fps
+          })
+        )
+      );
+      server.middlewares.use(
+        "/audio-processing/merge-media",
+        (req, res) => handlePostRequest(
+          req,
+          res,
+          async ({ outputFilename, tempDir, format }) => mergeMedia(outputFilename, output, tempDir, format)
+        )
+      );
+      server.middlewares.use(
+        "/twick-ffmpeg-decoder/video-frame",
+        (req, res) => handlePostRequest(req, res, async (data) => {
+          const { frame, width, height } = await ffmpegBridge.handleDecodeVideoFrame(data);
+          res.setHeader("X-Frame-Width", width.toString());
+          res.setHeader("X-Frame-Height", height.toString());
+          res.setHeader("Content-Type", "application/octet-stream");
+          res.end(Buffer.from(frame));
+        })
+      );
+      server.middlewares.use("/twick-ffmpeg-decoder/finished", (req, res) => {
+        handlePostRequest(req, res, async () => {
+          await ffmpegBridge.handleRenderFinished();
+        });
+      });
+      server.middlewares.use(
+        "/twick-ffmpeg-decoder/download-video-chunks",
+        (req, res) => handlePostRequest(req, res, async (videoDurations) => {
+          const downloadedPaths = await ffmpegBridge.handleDownloadVideoChunks(videoDurations);
+          return { success: true, paths: downloadedPaths };
+        })
+      );
+    }
+  };
+}
+var FFmpegBridge = class {
+  constructor(ws, config) {
+    this.ws = ws;
+    this.config = config;
+    this.process = null;
+    this.handleMessage = async ({ method, data }) => {
+      if (method === "start") {
+        try {
+          this.process = new FFmpegExporterServer({
+            ...data,
+            ...this.config
+          });
+          this.respondSuccess(method, await this.process.start());
+        } catch (e) {
+          this.respondError(method, e?.message);
+        }
+        return;
+      }
+      if (!this.process) {
+        this.respondError(method, "The exporting process has not been started.");
+        return;
+      }
+      if (!(method in this.process)) {
+        this.respondError(method, `Unknown method: "${method}".`);
+        return;
+      }
+      try {
+        this.respondSuccess(method, await this.process[method](data));
+      } catch (e) {
+        this.respondError(method, e?.message);
+      }
+      if (method === "kill") {
+        this.process = null;
+        return;
+      }
+    };
+    // List of VideoFrameExtractors
+    this.videoFrameExtractors = /* @__PURE__ */ new Map();
+    ws.on("twick:ffmpeg-exporter", this.handleMessage);
+  }
+  respondSuccess(method, data = {}) {
+    this.ws.send("twick:ffmpeg-exporter-ack", {
+      status: "success",
+      method,
+      data
+    });
+  }
+  respondError(method, message = "Unknown error.") {
+    this.ws.send("twick:ffmpeg-exporter-ack", {
+      status: "error",
+      method,
+      message
+    });
+  }
+  async handleDownloadVideoChunks(videoDurations) {
+    const downloadPromises = videoDurations.map(
+      ({ src, startTime, endTime }) => VideoFrameExtractor.downloadVideoChunk(src, startTime, endTime)
+    );
+    await Promise.all(downloadPromises);
+  }
+  async handleDecodeVideoFrame(data) {
+    const typedData = data;
+    const id = typedData.filePath + "-" + typedData.id;
+    let extractor = this.videoFrameExtractors.get(id);
+    const frameDuration = 1 / typedData.fps;
+    const isOldFrame = extractor && Math.abs(typedData.startTime - extractor.getLastTime()) < frameDuration / 2;
+    if (isOldFrame) {
+      const frame2 = extractor.getLastFrame();
+      return {
+        frame: frame2,
+        width: extractor.getWidth(),
+        height: extractor.getHeight()
+      };
+    }
+    if (extractor && typedData.startTime + frameDuration < extractor.getTime()) {
+      extractor.destroy();
+      this.videoFrameExtractors.delete(id);
+      extractor = void 0;
+    }
+    if (extractor && typedData.startTime > extractor.getTime() + frameDuration) {
+      extractor.destroy();
+      this.videoFrameExtractors.delete(id);
+      extractor = void 0;
+    }
+    if (!extractor) {
+      extractor = new VideoFrameExtractor(
+        data.filePath,
+        data.startTime,
+        data.fps,
+        data.duration
+      );
+      this.videoFrameExtractors.set(id, extractor);
+    }
+    const frame = await extractor.popImage();
+    return {
+      frame,
+      width: extractor.getWidth(),
+      height: extractor.getHeight()
+    };
+  }
+  async handleRenderFinished() {
+    this.videoFrameExtractors.forEach((extractor) => {
+      extractor.destroy();
+      const localFile = VideoFrameExtractor.downloadedVideoMap.get(
+        extractor.filePath
+      )?.localPath;
+      if (localFile && existsSync(localFile)) {
+        unlinkSync(localFile);
+      }
+    });
+    this.videoFrameExtractors.clear();
+  }
+};
+
+// src/partials/imageExporter.ts
+import fs3 from "fs";
+import mime from "mime-types";
+import path3 from "path";
+
+// src/openInExplorer.ts
+import { execSync, spawn } from "child_process";
+import { platform } from "os";
+function openInExplorer(file) {
+  let command = null;
+  let args = [file];
+  const os3 = platform();
+  switch (os3) {
+    case "win32":
+      command = "explorer";
+      break;
+    case "linux":
+      if (isRunningOnWSL()) {
+        command = "bash";
+        args = ["-c", `cd ${file} && explorer.exe .`];
+      } else {
+        command = "xdg-open";
+      }
+      break;
+    case "darwin":
+      command = "open";
+      break;
+  }
+  if (command) {
+    spawn(command, args, { detached: true }).unref();
+  } else {
+    console.warn(`Unsupported OS: ${os3}`);
+  }
+}
+function isRunningOnWSL() {
+  try {
+    const uname = execSync("uname -a").toString().toLowerCase();
+    return uname.includes("microsoft");
+  } catch (error) {
+    console.error(`exec error: ${error}`);
+    return false;
+  }
+}
+
+// src/partials/imageExporter.ts
+function exporterPlugin({ outputPath }) {
+  return {
+    name: "twick:exporter",
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url === "/__open-output-path") {
+          if (!fs3.existsSync(outputPath)) {
+            fs3.mkdirSync(outputPath, { recursive: true });
+          }
+          openInExplorer(outputPath);
+          res.end();
+          return;
+        }
+        next();
+      });
+      server.ws.on(
+        "twick:export",
+        async ({ data, frame, sceneFrame, subDirectories, mimeType, groupByScene }, client) => {
+          const name = (groupByScene ? sceneFrame : frame).toString().padStart(6, "0");
+          const extension = mime.extension(mimeType);
+          const outputFilePath = path3.join(
+            outputPath,
+            ...subDirectories,
+            `${name}.${extension}`
+          );
+          const outputDirectory = path3.dirname(outputFilePath);
+          if (!fs3.existsSync(outputDirectory)) {
+            fs3.mkdirSync(outputDirectory, { recursive: true });
+          }
+          const base64Data = data.slice(data.indexOf(",") + 1);
+          await fs3.promises.writeFile(outputFilePath, base64Data, {
+            encoding: "base64"
+          });
+          client.send("twick:export-ack", { frame });
+        }
+      );
+    }
+  };
+}
+
+// src/partials/meta.ts
+import fs4 from "fs";
+import path4 from "path";
+function metaPlugin() {
+  const timeStamps = {};
+  let config;
+  return {
+    name: "twick:meta",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code, id) {
+      const [base] = id.split("?");
+      const { name, ext } = path4.posix.parse(base);
+      if (ext !== ".meta") {
+        return;
+      }
+      const sourceFile = config.command === "build" ? false : JSON.stringify(id);
+      return `import {MetaFile} from '@twick/core';
+let meta;
+if (import.meta.hot) {
+  meta = import.meta.hot.data.meta;
+}
+meta ??= new MetaFile('${name}', ${sourceFile});
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.data.meta = meta;
+}
+meta.loadData(${code});
+export default meta;
+`;
+    },
+    configureServer(server) {
+      server.ws.on("twick:meta", async ({ source, data }, client) => {
+        if (source.startsWith("\0")) {
+          return;
+        }
+        timeStamps[source] = Date.now();
+        if (!process.env.DONT_WRITE_TO_META_FILES) {
+          await fs4.promises.writeFile(
+            source,
+            JSON.stringify(data, void 0, 2),
+            "utf8"
+          );
+        }
+        client.send("twick:meta-ack", { source });
+      });
+    },
+    handleHotUpdate(ctx) {
+      const now = Date.now();
+      const modules = [];
+      for (const module of ctx.modules) {
+        if (module.file !== null && timeStamps[module.file] && timeStamps[module.file] + 1e3 > now) {
+          continue;
+        }
+        modules.push(module);
+      }
+      return modules;
+    }
+  };
+}
+
+// src/partials/metrics.ts
+import { EventName, sendEvent } from "@twick/telemetry";
+function metricsPlugin() {
+  return {
+    name: "twick:metrics",
+    async configResolved() {
+      sendEvent(EventName.ServerStarted);
+    }
+  };
+}
+
+// src/partials/projects.ts
+function projectsPlugin({
+  buildForEditor,
+  projects
+}) {
+  return {
+    name: "twick:project",
+    config(config) {
+      return {
+        build: {
+          target: buildForEditor ? "esnext" : "modules",
+          assetsDir: "./",
+          rollupOptions: {
+            preserveEntrySignatures: "strict",
+            input: Object.fromEntries(
+              projects.list.map((project) => [project.name, project.url])
+            )
+          }
+        },
+        server: {
+          port: config?.server?.port ?? 9e3
+        },
+        esbuild: {
+          jsx: "automatic",
+          jsxImportSource: "@twick/2d/lib"
+        },
+        optimizeDeps: {
+          entries: projects.list.map((project) => project.url),
+          exclude: ["preact", "preact/*", "@preact/signals"]
+        }
+      };
+    }
+  };
+}
+
+// src/partials/rive.ts
+import * as fs5 from "fs";
+import path5 from "path";
+import { Readable as Readable2 } from "stream";
+async function getRiveWasmPath() {
+  try {
+    const packageJsonPath = __require.resolve(
+      "@rive-app/canvas-advanced/package.json"
+    );
+    const packageDir = path5.dirname(packageJsonPath);
+    const wasmPath = path5.join(packageDir, "rive.wasm");
+    await fs5.promises.access(wasmPath, fs5.constants.F_OK);
+    return wasmPath;
+  } catch (error) {
+    console.error("Error finding Rive WASM file:", error);
+    throw new Error("Could not find Rive WASM file");
+  }
+}
+function rivePlugin() {
+  return {
+    name: "twick:rive-wasm",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url && req.url === "/@rive-wasm") {
+          try {
+            const wasmPath = await getRiveWasmPath();
+            const file = await fs5.promises.readFile(wasmPath);
+            res.setHeader("Content-Type", "application/wasm");
+            Readable2.from(file).pipe(res);
+          } catch (error) {
+            console.error("Error serving Rive WASM file:", error);
+            res.statusCode = 500;
+            res.end("Error serving Rive WASM file");
+          }
+          return;
+        }
+        next();
+      });
+    }
+  };
+}
+
+// src/partials/settings.ts
+import fs6 from "fs";
+import os from "os";
+import path6 from "path";
+function settingsPlugin() {
+  const settingsId = "virtual:settings.meta";
+  const resolvedSettingsId = "\0" + settingsId;
+  const settingsPath = path6.resolve(os.homedir(), ".twick/settings.json");
+  const outputDirectory = path6.dirname(settingsPath);
+  return {
+    name: "twick:settings",
+    resolveId(id) {
+      if (id === settingsId) {
+        return resolvedSettingsId;
+      }
+    },
+    async load(id) {
+      if (id === resolvedSettingsId) {
+        let parsed = {};
+        try {
+          parsed = JSON.parse(await fs6.promises.readFile(settingsPath, "utf8"));
+        } catch (_) {
+        }
+        return JSON.stringify(parsed);
+      }
+    },
+    configureServer(server) {
+      server.ws.on("twick:meta", async ({ source, data }, client) => {
+        if (source !== resolvedSettingsId) {
+          return;
+        }
+        await fs6.promises.mkdir(outputDirectory, { recursive: true });
+        const newData = JSON.stringify(data, void 0, 2);
+        let oldData = "";
+        try {
+          oldData = await fs6.promises.readFile(settingsPath, "utf8");
+        } catch (_) {
+        }
+        if (oldData !== newData) {
+          await Promise.all([
+            fs6.promises.writeFile(settingsPath, newData, "utf8"),
+            // Invalidate the module so that the settings are up-to-date next
+            // time the browser is refreshed.
+            server.moduleGraph.getModuleByUrl(source).then((module) => {
+              if (module) {
+                server.moduleGraph.invalidateModule(module);
+              }
+            })
+          ]);
+        }
+        client.send("twick:meta-ack", { source });
+      });
+    }
+  };
+}
+
+// src/partials/wasmExporter.ts
+import { IncomingForm } from "formidable";
+import * as fs7 from "fs";
+import * as os2 from "os";
+import path7 from "path";
+import { Readable as Readable3 } from "stream";
+function wasmExporterPlugin() {
+  return {
+    name: "twick:mp4-wasm",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url && req.url === "/@mp4-wasm") {
+          const pathNew = path7.dirname(__require.resolve("mp4-wasm"));
+          const filePath = path7.resolve(pathNew, "mp4.wasm");
+          const file = await fs7.promises.readFile(filePath);
+          res.setHeader("Content-Type", "application/wasm");
+          Readable3.from(file).pipe(res);
+          return;
+        }
+        next();
+      });
+      server.middlewares.use("/uploadVideoFile", async (req, res) => {
+        if (req.method === "POST") {
+          const form = new IncomingForm({ maxFileSize: 1024 * 1024 * 1024 * 10 });
+          form.parse(req, async (err, fields, files) => {
+            if (err) {
+              console.error("Error parsing form:", err);
+              res.statusCode = 500;
+              res.end();
+              return;
+            }
+            try {
+              const tempDir = fields.tempDir[0];
+              const file = files.file[0];
+              const outputPath = path7.join(os2.tmpdir(), tempDir, "visuals.mp4");
+              const writeStream = fs7.createWriteStream(outputPath);
+              await new Promise((resolve, reject) => {
+                fs7.createReadStream(file.filepath).pipe(writeStream).on("finish", resolve).on("error", reject);
+              });
+              res.statusCode = 200;
+              res.end();
+            } catch (err2) {
+              console.error("Error uploading video:", err2);
+              res.statusCode = 500;
+              res.end();
+            }
+          });
+        }
+      });
+    }
+  };
+}
+
+// src/partials/webgl.ts
+import fs8 from "fs";
+import path8 from "path";
+import { SourceNode } from "source-map";
+import { normalizePath } from "vite";
+var GLSL_EXTENSION_REGEX = /\.glsl(?:$|\?)/;
+var INCLUDE_REGEX = /^#include "([^"]+)"/;
+function webglPlugin() {
+  let config;
+  return {
+    name: "twick:webgl",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    async transform(code, id) {
+      if (!GLSL_EXTENSION_REGEX.test(id)) {
+        return;
+      }
+      const [base, query] = id.split("?");
+      const { dir } = path8.posix.parse(base);
+      const params = new URLSearchParams(query);
+      if (params.has("raw")) {
+        return;
+      }
+      const context = {
+        rootDir: dir,
+        fileStack: [],
+        includeMap: /* @__PURE__ */ new Map(),
+        watchFile: (file) => this.addWatchFile(file),
+        resolve: async (source, importer) => {
+          const resolved = await this.resolve(source, importer);
+          return resolved?.id;
+        }
+      };
+      const glslSource = await resolveGlsl(context, id, code);
+      const sourceUrl = normalizePath(path8.relative(config.root, base));
+      const result = glslSource.toStringWithSourceMap();
+      const map = result.map.toJSON();
+      map.includeMap = Object.fromEntries(context.includeMap);
+      return {
+        map,
+        code: `export default \`${result.code}
+//# sourceURL=${sourceUrl}\`;`
+      };
+    }
+  };
+}
+async function resolveGlsl(context, id, code) {
+  const lines = code.split(/\r?\n/);
+  const source = new SourceNode(1, 0, "", "");
+  if (context.fileStack.includes(id)) {
+    throw new Error(
+      `Circular dependency detected: ${context.fileStack.join(" -> ")}`
+    );
+  }
+  context.fileStack.push(id);
+  const sourceMapId = path8.posix.relative(context.rootDir, id);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(INCLUDE_REGEX);
+    if (match) {
+      const childId = await context.resolve(match[1], id);
+      if (!childId) {
+        continue;
+      }
+      const childSourceMapId = path8.posix.relative(context.rootDir, childId);
+      if (context.includeMap.has(childSourceMapId)) {
+        continue;
+      }
+      context.includeMap.set(childSourceMapId, [sourceMapId, i + 1]);
+      context.watchFile(childId);
+      const childCode = await fs8.promises.readFile(childId, "utf-8");
+      source.add(await resolveGlsl(context, childId, childCode));
+    } else {
+      let j = 0;
+      for (; j < line.length; j++) {
+        source.add(new SourceNode(i + 1, j, sourceMapId, line[j]));
+      }
+      source.add(new SourceNode(i + 1, j, sourceMapId, "\n"));
+    }
+  }
+  context.fileStack.pop();
+  return source;
+}
+
+// src/plugins.ts
+var PLUGIN_OPTIONS = /* @__PURE__ */ Symbol.for("@twick/vite-plugin/PLUGIN_OPTIONS");
+function isPlugin(value) {
+  return value && typeof value === "object" && PLUGIN_OPTIONS in value;
+}
+
+// src/utils.ts
+import fg from "fast-glob";
+import fs9 from "fs";
+import path9 from "path";
+function getProjects(project) {
+  const list = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const projectList = expandFilePaths(project);
+  for (const url of projectList) {
+    const { name, dir } = path9.posix.parse(url);
+    const metaFile = `${name}.meta`;
+    const metaData = getMeta(path9.join(dir, metaFile));
+    const data = { name: metaData?.name ?? name, fileName: name, url };
+    list.push(data);
+    lookup.set(data.name, data);
+  }
+  return { list, lookup };
+}
+function expandFilePaths(filePaths) {
+  const expandedFilePaths = [];
+  for (const filePath of typeof filePaths === "string" ? [filePaths] : filePaths) {
+    if (fg.isDynamicPattern(filePath)) {
+      const matchingFilePaths = fg.sync(filePath, { onlyFiles: true });
+      expandedFilePaths.push(...matchingFilePaths);
+    } else {
+      expandedFilePaths.push(filePath);
+    }
+  }
+  return expandedFilePaths;
+}
+function getMeta(metaPath) {
+  if (fs9.existsSync(metaPath)) {
+    return JSON.parse(fs9.readFileSync(metaPath, "utf8"));
+  }
+}
+
+// src/main.ts
+var main_default = ({
+  project = "./src/project.ts",
+  output = "./output",
+  bufferedAssets = /^$/,
+  editor = "@twick/ui",
+  buildForEditor
+} = {}) => {
+  const plugins = [];
+  const outputPath = path10.resolve(output);
+  const projects = getProjects(project);
+  return [
+    {
+      name: "twick",
+      async configResolved(resolvedConfig) {
+        plugins.push(
+          ...resolvedConfig.plugins.filter(isPlugin).map((plugin) => plugin[PLUGIN_OPTIONS])
+        );
+        await Promise.all(
+          plugins.map(
+            (plugin) => plugin.config?.({
+              output: outputPath,
+              projects: projects.list
+            })
+          )
+        );
+      }
+    },
+    metaPlugin(),
+    settingsPlugin(),
+    exporterPlugin({ outputPath }),
+    ffmpegBridgePlugin({ output: outputPath }),
+    editorPlugin({ editor, projects }),
+    projectsPlugin({ projects, plugins, buildForEditor }),
+    assetsPlugin({ bufferedAssets }),
+    wasmExporterPlugin(),
+    rivePlugin(),
+    webglPlugin(),
+    metricsPlugin()
+  ];
+};
+
+// src/index.ts
+var index_default = main_default;
+export {
+  PLUGIN_OPTIONS,
+  index_default as default,
+  isPlugin
+};
+//# sourceMappingURL=index.js.map