apibara 2.1.0-beta.3 → 2.1.0-beta.30

package/src/core/config/loader.ts

@@ -7,14 +7,8 @@ import { loadConfig, watchConfig } from "c12";
 import { klona } from "klona/full";
 import { ApibaraDefaults } from "./defaults";
 import { resolvePathOptions } from "./resolvers/paths.resolver";
-import { presetResolver } from "./resolvers/preset.resolver";
-import { resolveRuntimeConfigOptions } from "./resolvers/runtime-config.resolver";
 
-const configResolvers = [
-  resolvePathOptions,
-  resolveRuntimeConfigOptions,
-  presetResolver,
-] as const;
+const configResolvers = [resolvePathOptions] as const;
 
 export async function loadOptions(
   configOverrides: ApibaraConfig = {},
@@ -22,9 +16,21 @@ export async function loadOptions(
   dev = false,
 ): Promise<ApibaraOptions> {
   const options = await _loadUserConfig(configOverrides, opts, dev);
+
+  // Check if the runtimeConfig is serializable
+  try {
+    JSON.stringify(options.runtimeConfig);
+  } catch (error) {
+    throw new Error(
+      "Non-serializable runtimeConfig. Please ensure the config is serializable.",
+      { cause: error },
+    );
+  }
+
   for (const resolver of configResolvers) {
     await resolver(options);
   }
+
   return options;
 }
 

package/src/core/config/resolvers/preset.resolver.ts

@@ -1,6 +1,9 @@
 import type { ApibaraOptions } from "apibara/types";
 import defu from "defu";
 
+/**
+ * @note This resolver is not in use currently, as we resolve presets in runtime files.
+ */
 export async function presetResolver(options: ApibaraOptions) {
   if (options.preset && options.presets?.[options.preset]) {
     const new_options = defu(options.presets[options.preset], options);

package/src/core/config/update.ts

@@ -4,6 +4,6 @@ export async function updateApibaraConfig(
   apibara: Apibara,
   _config: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rollup:reload");
+  await apibara.hooks.callHook("rolldown:reload");
   apibara.logger.success("Apibara config hot reloaded!");
 }

package/src/create/add.ts

@@ -37,6 +37,7 @@ type Options = {
   argNetwork?: string;
   argStorage?: string;
   argDnaUrl?: string;
+  argRootDir?: string;
 };
 
 export async function addIndexer({
@@ -45,8 +46,10 @@ export async function addIndexer({
   argNetwork,
   argStorage,
   argDnaUrl,
+  argRootDir,
 }: Options) {
-  const configExists = hasApibaraConfig(process.cwd());
+  const cwd = path.join(process.cwd(), argRootDir ?? ".");
+  const configExists = hasApibaraConfig(cwd);
 
   if (!configExists) {
     consola.error("No apibara.config found in the current directory.");
@@ -74,7 +77,7 @@ export async function addIndexer({
     }
   }
 
-  const language = getApibaraConfigLanguage(process.cwd());
+  const language = getApibaraConfigLanguage(cwd);
 
   validateIndexerId(argIndexerId, true);
   validateChain(argChain, true);
@@ -93,7 +96,7 @@ export async function addIndexer({
           validateIndexerId(id)
             ? checkFileExists(
                 path.join(
-                  process.cwd(),
+                  cwd,
                   "indexers",
                   `${id}.indexer.${language === "typescript" ? "ts" : "js"}`,
                 ),
@@ -197,7 +200,7 @@ export async function addIndexer({
   const pkgManager = getPackageManager();
 
   const options: IndexerOptions = {
-    cwd: process.cwd(),
+    cwd: cwd,
     indexerFileId,
     indexerId: convertKebabToCamelCase(indexerFileId),
     chain: (argChain as Chain) ?? prompt_chain?.name!,
@@ -228,11 +231,9 @@ export async function addIndexer({
 
   console.log();
 
+  const baseCommand = `${options.packageManager} install`;
+  const tsCommand = `${baseCommand} && ${options.packageManager} run prepare`;
   consola.info(
-    `Before running the indexer, run ${cyan(`${options.packageManager} run install`)}${
-      language === "typescript"
-        ? " & " + cyan(`${options.packageManager} run prepare`)
-        : ""
-    }`,
+    `Before running the indexer, run ${cyan(language === "typescript" ? tsCommand : baseCommand)}`,
   );
 }

package/src/create/constants.ts

@@ -66,26 +66,25 @@ export const storages: StorageDataType[] = [
 
 export const packageVersions = {
   // Required Dependencies
-  apibara: "^2.1.0-beta.2",
-  "@apibara/indexer": "^2.1.0-beta.2",
-  "@apibara/protocol": "^2.1.0-beta.2",
+  apibara: "next",
+  "@apibara/indexer": "next",
+  "@apibara/protocol": "next",
   // Chain Dependencies
-  "@apibara/evm": "^2.1.0-beta.2",
-  "@apibara/beaconchain": "^2.1.0-beta.2",
-  "@apibara/starknet": "^2.1.0-beta.2",
+  "@apibara/evm": "next",
+  "@apibara/beaconchain": "next",
+  "@apibara/starknet": "next",
   // Storage Dependencies
-  "@apibara/plugin-drizzle": "^2.1.0-beta.2",
-  "@apibara/plugin-mongo": "^2.1.0-beta.2",
-  "@apibara/plugin-sqlite": "^2.1.0-beta.2",
+  "@apibara/plugin-drizzle": "next",
+  "@apibara/plugin-mongo": "next",
+  "@apibara/plugin-sqlite": "next",
   // Postgres Dependencies
   "@electric-sql/pglite": "^0.2.17",
-  "drizzle-orm": "^0.37.0",
+  "drizzle-orm": "^0.40.1",
   pg: "^8.13.1",
   "@types/pg": "^8.11.10",
   "drizzle-kit": "^0.29.0",
   // Typescript Dependencies
   typescript: "^5.6.2",
-  "@rollup/plugin-typescript": "^11.1.6",
   "@types/node": "^20.5.2",
 };
 

package/src/create/init.ts

@@ -5,6 +5,7 @@ import prompts from "prompts";
 import { addIndexer } from "./add";
 import { cyan, green } from "./colors";
 import {
+  createGitIgnoreFile,
   generateApibaraConfig,
   generatePackageJson,
   generateTsConfig,
@@ -129,7 +130,7 @@ export async function initializeProject({
     JSON.stringify(packageJson, null, 2) + "\n",
   );
   await formatFile(packageJsonPath);
-  consola.success("Created ", cyan("package.json"));
+  consola.success("Created", cyan("package.json"));
 
   // Generate tsconfig.json if TypeScript
   if (isTs) {
@@ -137,7 +138,7 @@ export async function initializeProject({
     const tsConfig = generateTsConfig();
     fs.writeFileSync(tsConfigPath, JSON.stringify(tsConfig, null, 2) + "\n");
     await formatFile(tsConfigPath);
-    consola.success("Created ", cyan("tsconfig.json"));
+    consola.success("Created", cyan("tsconfig.json"));
   }
 
   const apibaraConfigPath = path.join(root, `apibara.config.${configExt}`);
@@ -145,7 +146,7 @@ export async function initializeProject({
   const apibaraConfig = generateApibaraConfig(isTs);
   fs.writeFileSync(apibaraConfigPath, apibaraConfig);
   await formatFile(apibaraConfigPath);
-  consola.success("Created ", cyan(`apibara.config.${configExt}`));
+  consola.success("Created", cyan(`apibara.config.${configExt}`));
 
   // Create "indexers" directory if not exists
   const indexersDir = path.join(root, "indexers");
@@ -154,6 +155,8 @@ export async function initializeProject({
     consola.success(`Created ${cyan("indexers")} directory`);
   }
 
+  await createGitIgnoreFile(root);
+
   console.log("\n");
 
   consola.ready(green("Project initialized successfully"));
@@ -163,12 +166,12 @@ export async function initializeProject({
   if (!argNoCreateIndexer) {
     consola.info("Let's create an indexer\n");
 
-    await addIndexer({});
+    await addIndexer({ argRootDir: argTargetDir });
   } else {
     const pkgManager = getPackageManager();
     consola.info(
       "Run ",
-      green(`${pkgManager.name} run install`),
+      green(`${pkgManager.name} install`),
       " to install all dependencies",
     );
   }

package/src/create/templates.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { consola } from "consola";
+import prompts from "prompts";
 import { type ObjectLiteralExpression, Project, SyntaxKind } from "ts-morph";
 import { cyan, green, magenta, yellow } from "./colors";
 import { packageVersions } from "./constants";
@@ -14,7 +15,7 @@ export function generatePackageJson(isTypeScript: boolean) {
     private: true,
     type: "module",
     scripts: {
-      prepare: "apibara prepare",
+      ...(isTypeScript && { prepare: "apibara prepare" }),
       dev: "apibara dev",
       start: "apibara start",
       build: "apibara build",
@@ -27,8 +28,6 @@ export function generatePackageJson(isTypeScript: boolean) {
     },
     devDependencies: {
       ...(isTypeScript && {
-        "@rollup/plugin-typescript":
-          packageVersions["@rollup/plugin-typescript"],
         "@types/node": packageVersions["@types/node"],
         typescript: packageVersions.typescript,
       }),
@@ -58,17 +57,10 @@ export function generateTsConfig() {
 }
 
 export function generateApibaraConfig(isTypeScript: boolean) {
-  return `${isTypeScript ? 'import typescript from "@rollup/plugin-typescript";\nimport type { Plugin } from "apibara/rollup";\n' : ""}import { defineConfig } from "apibara/config";
+  return `import { defineConfig } from "apibara/config";
 
 export default defineConfig({
-  runtimeConfig: {},${
-    isTypeScript
-      ? `
-  rollupConfig: {
-    plugins: [typescript()${isTypeScript ? " as Plugin" : ""}],
-  },`
-      : ""
-  }
+  runtimeConfig: {},
 });\n`;
 }
 
@@ -81,6 +73,7 @@ export function generateIndexer({
   return `import { defineIndexer } from "@apibara/indexer";
 import { useLogger } from "@apibara/indexer/plugins";
 ${storage === "postgres" ? `import { drizzleStorage } from "@apibara/plugin-drizzle";` : ""}
+${storage === "postgres" ? `import { drizzle } from "@apibara/plugin-drizzle";` : ""}
 ${
   chain === "ethereum"
     ? `import { EvmStream } from "@apibara/evm";`
@@ -91,19 +84,17 @@ ${
         : ""
 }
 ${language === "typescript" ? `import type { ApibaraRuntimeConfig } from "apibara/types";` : ""}
-${
-  storage === "postgres"
-    ? `import { getDrizzlePgDatabase } from "../lib/db";`
-    : ""
-}
+${storage === "postgres" ? `import * as schema from "../lib/schema";` : ""}
 
 
 export default function (runtimeConfig${language === "typescript" ? ": ApibaraRuntimeConfig" : ""}) {
   const indexerId = "${indexerId}";
-  const { startingBlock, streamUrl${storage === "postgres" ? ", postgresConnectionString" : ""} } = runtimeConfig[indexerId];
+  const { startingBlock, streamUrl } = runtimeConfig[indexerId];
   ${
     storage === "postgres"
-      ? "const { db } = getDrizzlePgDatabase(postgresConnectionString);"
+      ? `const db = drizzle({
+    schema,
+  });`
       : ""
   }
 
@@ -122,7 +113,7 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
     filter: {
       header: "always",
     },
-    plugins: [${storage === "postgres" ? "drizzleStorage({ db, persistState: true })" : ""}],
+    plugins: [${storage === "postgres" ? "drizzleStorage({ db, migrate: { migrationsFolder: './drizzle' } })" : ""}],
     async transform({ endCursor, finality }) {
       const logger = useLogger();
 
@@ -136,14 +127,12 @@ export default function (runtimeConfig${language === "typescript" ? ": ApibaraRu
       ${
         storage === "postgres"
           ? `// Example snippet to insert data into db using drizzle with postgres
-      //   const { db } = useDrizzleStorage();
-      //   const { logs } = block;
-      //   for (const log of logs) {
-      //     await db.insert(exampleTable).values({
-      //       number: Number(endCursor?.orderKey),
-      //       hash: log.transactionHash,
-      //     });
-      //   }`
+      // const { db: database } = useDrizzleStorage();
+
+      // await database.insert(schema.cursorTable).values({
+      //   endCursor: Number(endCursor?.orderKey),
+      //   uniqueKey: \`\${endCursor?.uniqueKey}\`,
+      // });`
           : ""
       }
     },
@@ -235,12 +224,8 @@ export async function updateApibaraConfigFile({
 
   const runtimeConfigString = `{
   startingBlock: 0,
-  streamUrl: "${dnaUrl ?? getDnaUrl(chain, network)}"${
-    storage === "postgres"
-      ? `,
-  postgresConnectionString: process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://${indexerId}"`
-      : ""
-  }}`;
+  streamUrl: "${dnaUrl ?? getDnaUrl(chain, network)}"  
+}`;
 
   const project = new Project();
   const sourceFile = project.addSourceFileAtPath(pathToConfig);
@@ -284,7 +269,7 @@ export async function updateApibaraConfigFile({
 }
 
 export async function createDrizzleStorageFiles(options: IndexerOptions) {
-  const { cwd, language, storage } = options;
+  const { cwd, language, storage, indexerId } = options;
 
   if (storage !== "postgres") return;
 
@@ -312,11 +297,11 @@ export async function createDrizzleStorageFiles(options: IndexerOptions) {
     const drizzleConfigContent = `${language === "typescript" ? 'import type { Config } from "drizzle-kit";' : ""}
 
 export default {
-  schema: "./lib/schema.ts",
+  schema: "./lib/schema.${fileExtension}",
   out: "./drizzle",
   dialect: "postgresql",
   dbCredentials: {
-    url: process.env["POSTGRES_CONNECTION_STRING"] ?? "",
+    url: process.env["POSTGRES_CONNECTION_STRING"] ?? "memory://${indexerId}",
   },
 }${language === "typescript" ? " satisfies Config" : ""};`;
 
@@ -347,14 +332,14 @@ export default {
     });
 
   if (!schemaExists || schemaOverwrite) {
-    const schemaContent = `//  --- Add your pg table schemas here ---- 
+    const schemaContent = `//  --- Add your pg table schemas here ----
 
 // import { bigint, pgTable, text, uuid } from "drizzle-orm/pg-core";
 
-// export const exampleTable = pgTable("example_table", {
+// export const cursorTable = pgTable("cursor_table", {
 //   id: uuid("id").primaryKey().defaultRandom(),
-//   number: bigint("number", { mode: "number" }),
-//   hash: text("hash"),
+//   endCursor: bigint("end_cursor", { mode: "number" }),
+//   uniqueKey: text("unique_key"),
 // });
 
 export {};
@@ -369,63 +354,6 @@ export {};
     consola.success(`Created ${cyan("lib/schema.ts")}`);
   }
 
-  /**
-   *
-   *
-   * DB File
-   *
-   *
-   */
-  const dbFileName = `db.${fileExtension}`;
-
-  const dbPath = path.join(cwd, "lib", dbFileName);
-
-  const { exists: dbExists, overwrite: dbOverwrite } = await checkFileExists(
-    dbPath,
-    {
-      askPrompt: true,
-      fileName: `lib/${dbFileName}`,
-      allowIgnore: true,
-    },
-  );
-
-  if (!dbExists || dbOverwrite) {
-    const dbContent = `import * as schema from "./schema";
-import { drizzle as nodePgDrizzle } from "drizzle-orm/node-postgres";
-import { drizzle as pgLiteDrizzle } from "drizzle-orm/pglite";
-import pg from "pg";
-
-
-export function getDrizzlePgDatabase(connectionString${language === "typescript" ? ": string" : ""}) {
-  // Create pglite instance
-  if (connectionString.includes("memory")) {
-    return {
-      db: pgLiteDrizzle({
-        schema,
-        connection: {
-          dataDir: connectionString,
-        },
-      }),
-    };
-  }
-
-  // Create node-postgres instance
-  const pool = new pg.Pool({
-    connectionString,
-  });
-
-  return { db: nodePgDrizzle(pool, { schema }) };
-}`;
-
-    // create directory if it doesn't exist
-    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
-    fs.writeFileSync(dbPath, dbContent);
-
-    await formatFile(dbPath);
-
-    consola.success(`Created ${cyan(`lib/${dbFileName}`)}`);
-  }
-
   console.log("\n");
 
   // If schema file is created, show the example
@@ -445,17 +373,17 @@ ${yellow(`
 
 import { bigint, pgTable, text, uuid } from "drizzle-orm/pg-core";
 
-export const exampleTable = pgTable("example_table", {
+export const cursorTable = pgTable("cursor_table", {
   id: uuid("id").primaryKey().defaultRandom(),
-  number: bigint("number", { mode: "number" }),
-  hash: text("hash"),
+  endCursor: bigint("end_cursor", { mode: "number" }),
+  uniqueKey: text("unique_key"),
 });`)}`);
 
     console.log("\n");
   }
 
   consola.info(
-    `Run ${green(`${options.packageManager} run drizzle:generate`)} & ${green(`${options.packageManager} run drizzle:migrate`)} to generate and apply migrations.`,
+    `Run ${green(`${options.packageManager}${options.packageManager === "npm" ? " run" : ""} drizzle:generate`)} & ${green(`${options.packageManager}${options.packageManager === "npm" ? " run" : ""} drizzle:migrate`)} to generate and apply migrations.`,
   );
 }
 
@@ -466,3 +394,103 @@ export async function createStorageRelatedFiles(options: IndexerOptions) {
     await createDrizzleStorageFiles(options);
   }
 }
+
+const gitIgnoreItems: {
+  isRecommended: boolean;
+  description?: string;
+  value: string;
+}[] = [
+  {
+    isRecommended: false,
+    value: "node_modules",
+  },
+  {
+    isRecommended: false,
+    value: "dist",
+  },
+  {
+    isRecommended: true,
+    description: "build and dev files of apibara",
+    value: ".apibara",
+  },
+  {
+    isRecommended: false,
+    value: ".env",
+  },
+  {
+    isRecommended: false,
+    description: "for mac users",
+    value: ".DS_Store",
+  },
+];
+
+export async function createGitIgnoreFile(cwd: string) {
+  const gitIgnorePath = path.join(cwd, ".gitignore");
+
+  if (fs.existsSync(gitIgnorePath)) {
+    const result = await prompts([
+      {
+        type: "select",
+        name: "overwrite",
+        message: `${cyan(".gitignore")} already exists. Please choose how to proceed:`,
+        initial: 0,
+        choices: [
+          {
+            title: "Choose items to append in your .gitignore",
+            value: "append",
+          },
+          {
+            title: "Keep original",
+            value: "ignore",
+          },
+          {
+            title: "Overwrite",
+            value: "overwrite",
+          },
+        ],
+      },
+      {
+        type: (overwrite: "append" | "ignore" | "overwrite") =>
+          overwrite === "append" ? "multiselect" : null,
+        name: "ignoreItems",
+        message: "Choose items to append in your .gitignore",
+        choices: gitIgnoreItems.map((item) => ({
+          title: `${yellow(item.value)}${
+            item.description ? ` - ${item.description}` : ""
+          }${item.isRecommended ? ` ${green("(recommended)")}` : ""}`,
+          value: item.value,
+        })),
+      },
+    ]);
+
+    const { overwrite, ignoreItems } = result as {
+      overwrite: "append" | "ignore" | "overwrite";
+      ignoreItems: string[];
+    };
+
+    if (overwrite === "append" && ignoreItems.length > 0) {
+      const gitIgnoreContent = fs.readFileSync(gitIgnorePath, "utf8");
+      fs.writeFileSync(
+        gitIgnorePath,
+        `${gitIgnoreContent}\n${result.ignoreItems.join("\n")}`,
+      );
+      consola.success(`Updated ${cyan(".gitignore")}`);
+      return;
+    }
+
+    if (overwrite === "overwrite") {
+      fs.writeFileSync(
+        gitIgnorePath,
+        gitIgnoreItems.map((item) => item.value).join("\n"),
+      );
+      consola.success(`Updated ${cyan(".gitignore")}`);
+      return;
+    }
+  }
+
+  fs.writeFileSync(
+    gitIgnorePath,
+    gitIgnoreItems.map((item) => item.value).join("\n"),
+  );
+  consola.success(`Created ${cyan(".gitignore")}`);
+}

package/src/hooks/useRuntimeConfig.ts

@@ -1,5 +1,5 @@
 import type { ApibaraRuntimeConfig } from "apibara/types";
 
 export function useRuntimeConfig(): ApibaraRuntimeConfig {
-  return JSON.parse(process.env.APIBARA_RUNTIME_CONFIG || "{}");
+  return JSON.parse(process.env.APIBARA_RUNTIME_CONFIG_HOOK_DATA || "{}");
 }

package/src/rolldown/config.ts

@@ -0,0 +1,111 @@
+import { existsSync } from "node:fs";
+import { builtinModules } from "node:module";
+import replace from "@rollup/plugin-replace";
+import type { Apibara } from "apibara/types";
+import defu from "defu";
+import { join } from "pathe";
+import type {
+  ConfigExport,
+  RolldownOptions,
+  RolldownPluginOption,
+} from "rolldown";
+import { appConfig } from "./plugins/config";
+import { indexers } from "./plugins/indexers";
+import { instrumentation } from "./plugins/instrumentation";
+
+const runtimeDependencies = [
+  "better-sqlite3",
+  "@electric-sql/pglite",
+  "pg",
+  // https://socket.io/docs/v4/server-installation/#additional-packages
+  "utf-8-validate",
+  "bufferutil",
+  // was giving unresolved import warnings from `node-fetch` library.
+  "encoding",
+];
+
+export function getRolldownConfig(apibara: Apibara): RolldownOptions {
+  const extensions: string[] = [
+    ".ts",
+    ".mjs",
+    ".js",
+    ".json",
+    ".node",
+    ".tsx",
+    ".jsx",
+  ];
+
+  const tsConfigExists = existsSync(
+    join(apibara.options.rootDir, "tsconfig.json"),
+  );
+
+  const rolldownConfig: RolldownOptions & {
+    plugins: RolldownPluginOption[];
+  } = defu(
+    // biome-ignore lint/suspicious/noExplicitAny: apibara.options.rolldownConfig is typed
+    apibara.options.rolldownConfig as any,
+    <ConfigExport>{
+      platform: "node",
+      input: apibara.options.entry,
+      output: {
+        dir: join(apibara.options.outputDir || "./.apibara/build"),
+        format: "esm",
+        entryFileNames: "[name].mjs",
+        chunkFileNames: "chunks/[name]-[hash].mjs",
+        sourcemap: true,
+      },
+      plugins: [],
+      onwarn(warning, rolldownWarn) {
+        if (
+          !["CIRCULAR_DEPENDENCY", "EVAL", "THIS_IS_UNDEFINED"].includes(
+            warning.code || "",
+          ) &&
+          !warning.message.includes("Unsupported source map comment") &&
+          !warning.message.includes("@__PURE__") &&
+          !warning.message.includes("/*#__PURE__*/")
+        ) {
+          rolldownWarn(warning);
+        }
+      },
+      resolve: {
+        extensions,
+        preferBuiltins: !!apibara.options.node,
+        mainFields: ["main"],
+        exportConditions: apibara.options.exportConditions,
+        tsconfigFilename: tsConfigExists ? "tsconfig.json" : undefined,
+      },
+      treeshake: true,
+      external: [...builtinModules, ...runtimeDependencies],
+    },
+  );
+
+  rolldownConfig.plugins?.push(
+    replace({
+      preventAssignment: true,
+      values: {
+        "process.env.APIBARA_CONFIG": getSerializedRuntimeConfig(apibara),
+      },
+    }) as RolldownPluginOption,
+  );
+
+  rolldownConfig.plugins?.push(instrumentation(apibara));
+  rolldownConfig.plugins?.push(indexers(apibara));
+  rolldownConfig.plugins?.push(appConfig(apibara));
+
+  return rolldownConfig;
+}
+
+function getSerializedRuntimeConfig(apibara: Apibara) {
+  try {
+    return JSON.stringify({
+      runtimeConfig: apibara.options.runtimeConfig,
+      preset: apibara.options.preset,
+      presets: apibara.options.presets,
+    });
+  } catch (error) {
+    throw new Error(
+      "Failed to serialize runtime config. Please ensure all values in your runtime configuration are JSON serializable.",
+      { cause: error },
+    );
+  }
+}

package/src/rolldown/index.ts

@@ -0,0 +1,2 @@
+export * from "./config";
+export type { Plugin } from "rolldown";