apibara 2.1.0-beta.30 → 2.1.0-beta.31

package/src/cli/commands/dev.ts

@@ -9,8 +9,8 @@ import { blueBright, gray } from "../../create/colors";
 import { checkForUnknownArgs, commonArgs } from "../common";
 
 // Hot module reloading key regex
-// for only runtimeConfig.* keys
-const hmrKeyRe = /^runtimeConfig\./;
+// for only runtimeConfig.*, presets.* keys & preset key
+const hmrKeyRe = /^(runtimeConfig\.|presets\.|preset$)/;
 
 export default defineCommand({
   meta: {
@@ -79,12 +79,12 @@ export default defineCommand({
               }
 
               apibara.logger.info(
-                `Config updated:
-                  ${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`,
+                `Config updated: \n${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`,
               );
 
               await (diff.every((e) => hmrKeyRe.test(e.key))
-                ? apibara.updateConfig(newConfig.config || {}) // Hot reload
+                ? // in hot reload we only update the runtime values & restart indexers,no build step, apibara instance remains the same
+                  apibara.updateConfig(newConfig.config || {}) // Hot reload
                 : reload()); // Full reload
             },
           },
@@ -92,7 +92,9 @@ export default defineCommand({
         true,
       );
 
-      apibara.hooks.hookOnce("restart", reload);
+      apibara.hooks.hookOnce("restart", async () => {
+        await reload();
+      });
 
       apibara.options.entry = join(runtimeDir, "dev.mjs");
 
@@ -110,9 +112,9 @@ export default defineCommand({
 
       apibara.hooks.hook("dev:reload", async () => {
         if (childProcess) {
-          apibara.logger.info("Restarting indexers");
           await killProcess(childProcess);
           childProcess = undefined;
+          apibara.logger.info("Restarting indexers");
         } else {
           apibara.logger.info("Starting indexers");
 
@@ -130,7 +132,6 @@ export default defineCommand({
           resolve(apibara.options.outputDir || "./.apibara/build", "dev.mjs"),
           "start",
           ...(args.indexers ? ["--indexers", args.indexers] : []),
-          ...(args.preset ? ["--preset", args.preset] : []),
         ];
 
         childProcess = spawn("node", childArgs, {
@@ -140,7 +141,7 @@ export default defineCommand({
         childProcess.on("close", (code, signal) => {
           childProcess = undefined;
           console.log();
-          apibara.logger.log(
+          apibara.logger.info(
             `Indexers process exited${
               code !== null ? ` with code ${colors.red(code)}` : ""
             }`,

package/src/cli/commands/start.ts

@@ -50,13 +50,7 @@ export default defineCommand({
 
     await apibara.close();
 
-    const childArgs = [
-      entry,
-      "start",
-      "--indexer",
-      indexer,
-      ...(preset ? ["--preset", preset] : []),
-    ];
+    const childArgs = [entry, "start", "--indexer", indexer];
 
     const childProcess = spawn("node", childArgs, {
       stdio: "inherit",
@@ -64,7 +58,7 @@ export default defineCommand({
 
     childProcess.on("close", (code, signal) => {
       console.log();
-      apibara.logger.log(
+      apibara.logger.info(
         `Indexers process exited${
           code !== null ? ` with code ${colors.red(code)}` : ""
         }`,

package/src/common/constants.ts

@@ -0,0 +1,6 @@
+export const ENV_INTERNAL_APIBARA_RUNTIME = "_APIBARA_RUNTIME";
+export const ENV_INTERNAL_APIBARA_PRESET = "_APIBARA_PRESET";
+export const ENV_INTERNAL_APIBARA_PRESETS = "_APIBARA_PRESETS";
+export const ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME =
+  "_APIBARA_PROCESSED_RUNTIME";
+export const USER_ENV_APIBARA_RUNTIME_CONFIG = "APIBARA_RUNTIME_CONFIG";

package/src/common/helper.ts

@@ -0,0 +1,86 @@
+import defu from "defu";
+import {
+  ENV_INTERNAL_APIBARA_PRESET,
+  ENV_INTERNAL_APIBARA_PRESETS,
+  ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME,
+  ENV_INTERNAL_APIBARA_RUNTIME,
+  USER_ENV_APIBARA_RUNTIME_CONFIG,
+} from "./constants";
+
+export function getRuntimeDataFromEnv() {
+  const processedRuntimeConfig: Record<string, unknown> = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME] ?? "{}",
+  );
+  const preset: string | undefined = process.env[ENV_INTERNAL_APIBARA_PRESET];
+  const presets: Record<string, unknown> | undefined = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_PRESETS] ?? "{}",
+  );
+  const runtimeConfig: Record<string, unknown> | undefined = JSON.parse(
+    process.env[ENV_INTERNAL_APIBARA_RUNTIME] ?? "{}",
+  );
+  const userEnvRuntimeConfig: Record<string, unknown> | undefined = JSON.parse(
+    process.env[USER_ENV_APIBARA_RUNTIME_CONFIG] ?? "{}",
+  );
+
+  return {
+    userEnvRuntimeConfig,
+    processedRuntimeConfig,
+    preset,
+    presets,
+    runtimeConfig,
+  };
+}
+
+/**
+ * Get the merged runtime config from the user env overrided runtime config, presets and defaults.
+ * Priority (Highest to lowest):
+ * 1. User env overrided runtime config
+ * 2. Preset
+ * 3. Defaults
+ */
+export function getProcessedRuntimeConfig({
+  preset,
+  presets,
+  runtimeConfig,
+  userEnvRuntimeConfig,
+}: {
+  preset?: string;
+  presets?: Record<string, unknown>;
+  runtimeConfig?: Record<string, unknown>;
+  userEnvRuntimeConfig?: Record<string, unknown>;
+}) {
+  let _runtimeConfig: Record<string, unknown> = { ...runtimeConfig };
+
+  if (preset) {
+    if (presets === undefined) {
+      throw new Error(
+        `Specified preset "${preset}" but no presets were defined`,
+      );
+    }
+
+    if (presets[preset] === undefined) {
+      throw new Error(`Specified preset "${preset}" but it was not defined`);
+    }
+
+    const presetValue = presets[preset] as {
+      runtimeConfig: Record<string, unknown>;
+    };
+
+    // Preset applied
+    _runtimeConfig = defu(presetValue.runtimeConfig, _runtimeConfig);
+  }
+
+  if (userEnvRuntimeConfig) {
+    try {
+      // Environment runtime config applied
+      _runtimeConfig = defu(userEnvRuntimeConfig, _runtimeConfig);
+    } catch (error) {
+      throw new Error(
+        "Failed to parse runtime config from process.env.APIBARA_RUNTIME_CONFIG. Please ensure it is a valid JSON string.",
+        { cause: error },
+      );
+    }
+  }
+
+  return _runtimeConfig;
+}

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from "./constants";
+export * from "./helper";

package/src/core/apibara.ts

@@ -28,8 +28,8 @@ export async function createApibara(
     hooks: createHooks(),
     close: () => apibara.hooks.callHook("close"),
     logger: consola.withTag("apibara"),
-    async updateConfig(config: ApibaraDynamicConfig) {
-      updateApibaraConfig(apibara, config);
+    async updateConfig(newConfig: ApibaraDynamicConfig) {
+      updateApibaraConfig(apibara, newConfig);
     },
   };
 

package/src/core/build/dev.ts

@@ -102,4 +102,6 @@ const getIgnorePatterns = (apibara: Apibara) => [
   "**/node_modules/**",
   "**/dist/**",
   "**/.turbo/**",
+  // changes to apibara.config is handled by c12 itself so we dont need rolldown to handle this
+  "**/apibara.config?(.ts|.js)",
 ];

package/src/core/config/loader.ts

@@ -7,8 +7,10 @@ import { loadConfig, watchConfig } from "c12";
 import { klona } from "klona/full";
 import { ApibaraDefaults } from "./defaults";
 import { resolvePathOptions } from "./resolvers/paths.resolver";
+import { runtimeConfigResolver } from "./resolvers/runtime.resolver";
 
-const configResolvers = [resolvePathOptions] as const;
+// runtimeConfigResolver handles assigning runtime values to env
+const configResolvers = [resolvePathOptions, runtimeConfigResolver] as const;
 
 export async function loadOptions(
   configOverrides: ApibaraConfig = {},

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

@@ -0,0 +1,44 @@
+import {
+  ENV_INTERNAL_APIBARA_PRESET,
+  ENV_INTERNAL_APIBARA_PRESETS,
+  ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME,
+  ENV_INTERNAL_APIBARA_RUNTIME,
+  USER_ENV_APIBARA_RUNTIME_CONFIG,
+  getProcessedRuntimeConfig,
+} from "apibara/common";
+import type { ApibaraOptions } from "apibara/types";
+
+export function runtimeConfigResolver(options: Partial<ApibaraOptions>) {
+  try {
+    const { runtimeConfig, preset, presets } = options;
+
+    if (runtimeConfig) {
+      process.env[ENV_INTERNAL_APIBARA_RUNTIME] = JSON.stringify(runtimeConfig);
+    }
+    if (preset) {
+      process.env[ENV_INTERNAL_APIBARA_PRESET] = preset;
+    }
+
+    if (presets) {
+      process.env[ENV_INTERNAL_APIBARA_PRESETS] = JSON.stringify(presets);
+    }
+
+    const userEnvRuntimeConfig = JSON.parse(
+      process.env[USER_ENV_APIBARA_RUNTIME_CONFIG] ?? "{}",
+    );
+
+    // This is final processed runtime config that will be used by the indexer and useRuntimeConfig hook
+    process.env[ENV_INTERNAL_APIBARA_PROCESSED_RUNTIME] = JSON.stringify(
+      getProcessedRuntimeConfig({
+        preset,
+        presets,
+        runtimeConfig,
+        userEnvRuntimeConfig,
+      }),
+    );
+  } catch (error) {
+    throw new Error("Failed to process & set runtime environment variables", {
+      cause: error,
+    });
+  }
+}

package/src/core/config/update.ts

@@ -1,9 +1,13 @@
 import type { Apibara, ApibaraDynamicConfig } from "apibara/types";
+import { runtimeConfigResolver } from "./resolvers/runtime.resolver";
 
 export async function updateApibaraConfig(
   apibara: Apibara,
-  _config: ApibaraDynamicConfig,
+  newConfig: ApibaraDynamicConfig,
 ) {
-  await apibara.hooks.callHook("rolldown:reload");
+  // applies new config values to env again during hot reload
+  runtimeConfigResolver(newConfig);
   apibara.logger.success("Apibara config hot reloaded!");
+  // we simply stop indexers and restart them with updated runtime values
+  await apibara.hooks.callHook("dev:reload");
 }

package/src/create/constants.ts

@@ -67,7 +67,6 @@ export const storages: StorageDataType[] = [
 export const packageVersions = {
   // Required Dependencies
   apibara: "next",
-  "@apibara/indexer": "next",
   "@apibara/protocol": "next",
   // Chain Dependencies
   "@apibara/evm": "next",

package/src/create/templates.ts

@@ -22,7 +22,6 @@ export function generatePackageJson(isTypeScript: boolean) {
       ...(isTypeScript && { typecheck: "tsc --noEmit" }),
     },
     dependencies: {
-      "@apibara/indexer": packageVersions["@apibara/indexer"],
       "@apibara/protocol": packageVersions["@apibara/protocol"],
       apibara: packageVersions.apibara,
     },
@@ -70,8 +69,8 @@ export function generateIndexer({
   chain,
   language,
 }: IndexerOptions) {
-  return `import { defineIndexer } from "@apibara/indexer";
-import { useLogger } from "@apibara/indexer/plugins";
+  return `import { defineIndexer } from "apibara/indexer";
+import { useLogger } from "apibara/plugins";
 ${storage === "postgres" ? `import { drizzleStorage } from "@apibara/plugin-drizzle";` : ""}
 ${storage === "postgres" ? `import { drizzle } from "@apibara/plugin-drizzle";` : ""}
 ${

package/src/hooks/useRuntimeConfig.ts

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

package/src/indexer/index.ts

@@ -0,0 +1 @@
+export * from "@apibara/indexer";

package/src/indexer/plugins.ts

@@ -0,0 +1 @@
+export * from "@apibara/indexer/plugins";

package/src/indexer/testing.ts

@@ -0,0 +1 @@
+export * from "@apibara/indexer/testing";

package/src/indexer/vcr.ts

@@ -0,0 +1 @@
+export * from "@apibara/indexer/vcr";

package/src/rolldown/config.ts

@@ -1,6 +1,5 @@
 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";
@@ -9,7 +8,6 @@ import type {
   RolldownOptions,
   RolldownPluginOption,
 } from "rolldown";
-import { appConfig } from "./plugins/config";
 import { indexers } from "./plugins/indexers";
 import { instrumentation } from "./plugins/instrumentation";
 
@@ -79,33 +77,8 @@ export function getRolldownConfig(apibara: Apibara): RolldownOptions {
     },
   );
 
-  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/runtime/dev.ts

@@ -1,4 +1,5 @@
 import { runWithReconnect } from "@apibara/indexer";
+import { getRuntimeDataFromEnv } from "apibara/common";
 import { defineCommand, runMain } from "citty";
 import { blueBright } from "picocolors";
 import {
@@ -17,13 +18,11 @@ const startCommand = defineCommand({
       type: "string",
       description: "Which indexers to run",
     },
-    preset: {
-      type: "string",
-      description: "Preset to use",
-    },
   },
   async run({ args }) {
-    const { indexers: indexersArgs, preset } = args;
+    const { indexers: indexersArgs } = args;
+
+    const { processedRuntimeConfig, preset } = getRuntimeDataFromEnv();
 
     let selectedIndexers = availableIndexers;
     if (indexersArgs) {
@@ -41,7 +40,11 @@ const startCommand = defineCommand({
     await Promise.all(
       selectedIndexers.map(async (indexer) => {
         const { indexer: indexerInstance, logger } =
-          createIndexer(indexer, preset) ?? {};
+          createIndexer({
+            indexerName: indexer,
+            processedRuntimeConfig,
+            preset,
+          }) ?? {};
         if (!indexerInstance) {
           return;
         }
@@ -49,6 +52,7 @@ const startCommand = defineCommand({
         const client = createAuthenticatedClient(
           indexerInstance.streamConfig,
           indexerInstance.options.streamUrl,
+          indexerInstance.options.clientOptions,
         );
 
         if (logger) {

package/src/runtime/internal/app.ts

@@ -15,25 +15,27 @@ import {
   createClient,
 } from "@apibara/protocol";
 import consola from "consola";
-import { config } from "#apibara-internal-virtual/config";
 import { indexers } from "#apibara-internal-virtual/indexers";
 import { logger as instrumentationLogger } from "#apibara-internal-virtual/instrumentation";
-import { getProcessedRuntimeConfig } from "./helper";
 import { createLogger } from "./logger";
 
 export const availableIndexers = indexers.map((i) => i.name);
 
-export function createIndexer(indexerName: string, preset?: string) {
-  // Get merged runtime config from preset and process.env.APIBARA_RUNTIME_CONFIG and defaults.
-  const runtimeConfig = getProcessedRuntimeConfig({
-    preset,
-    presets: config.presets,
-    runtimeConfig: config.runtimeConfig,
-  });
-
-  // Set the runtime config in the environment so that it can be used by the useRuntimeConfig hook.
-  process.env.APIBARA_RUNTIME_CONFIG_HOOK_DATA = JSON.stringify(runtimeConfig);
-
+export function createIndexer({
+  indexerName,
+  processedRuntimeConfig,
+  preset,
+}: {
+  indexerName: string;
+  /**
+   * Final processed runtime config to be used by the indexer
+   */
+  processedRuntimeConfig: Record<string, unknown>;
+  /**
+   * Preset name which was used to generate the runtime config
+   */
+  preset?: string;
+}) {
   const indexerDefinition = indexers.find((i) => i.name === indexerName);
 
   if (indexerDefinition === undefined) {
@@ -52,7 +54,7 @@ export function createIndexer(indexerName: string, preset?: string) {
 
   const definition =
     typeof indexerModule === "function"
-      ? indexerModule(runtimeConfig)
+      ? indexerModule(processedRuntimeConfig)
       : indexerModule;
 
   let reporter: ConsolaReporter = createLogger({
@@ -109,10 +111,13 @@ export function createAuthenticatedClient(
   return createClient(config, streamUrl, {
     ...options,
     defaultCallOptions: {
+      ...(options?.defaultCallOptions ?? {}),
       "*": {
         metadata: Metadata({
           Authorization: `Bearer ${dnaToken}`,
         }),
+        // metadata cant be overrided with spread as its a class so we override it fully if user provided it.
+        ...(options?.defaultCallOptions?.["*"] ?? {}),
       },
     },
   });

package/src/runtime/project-info.ts

@@ -1,7 +1,10 @@
 import { writeFileSync } from "node:fs";
 import { resolve } from "node:path";
+import {
+  getProcessedRuntimeConfig,
+  getRuntimeDataFromEnv,
+} from "apibara/common";
 import { defineCommand, runMain } from "citty";
-import { config } from "#apibara-internal-virtual/config";
 import { availableIndexers, createIndexer } from "./internal/app";
 
 type ProjectInfo = {
@@ -31,10 +34,25 @@ const startCommand = defineCommand({
       indexers: {},
     };
 
-    for (const preset of Object.keys(config.presets ?? {})) {
+    // get all original runtime data from env
+    const { presets, runtimeConfig, userEnvRuntimeConfig } =
+      getRuntimeDataFromEnv();
+
+    for (const preset of Object.keys(presets ?? {})) {
+      // process runtime config for each preset
+      const processedRuntimeConfig = getProcessedRuntimeConfig({
+        preset,
+        presets,
+        runtimeConfig,
+        userEnvRuntimeConfig,
+      });
       for (const indexer of availableIndexers) {
         const { indexer: indexerInstance } =
-          createIndexer(indexer, preset) ?? {};
+          createIndexer({
+            indexerName: indexer,
+            processedRuntimeConfig,
+            preset,
+          }) ?? {};
         if (!indexerInstance) {
           continue;
         }

package/src/runtime/start.ts

@@ -1,4 +1,5 @@
 import { runWithReconnect } from "@apibara/indexer";
+import { getRuntimeDataFromEnv } from "apibara/common";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import { blueBright } from "picocolors";
@@ -16,16 +17,18 @@ const startCommand = defineCommand({
       description: "Indexer name",
       required: true,
     },
-    preset: {
-      type: "string",
-      description: "Preset to use",
-    },
   },
   async run({ args }) {
-    const { indexer, preset } = args;
+    const { indexer } = args;
+
+    const { processedRuntimeConfig, preset } = getRuntimeDataFromEnv();
 
     const { indexer: indexerInstance, logger } =
-      createIndexer(indexer, preset) ?? {};
+      createIndexer({
+        indexerName: indexer,
+        processedRuntimeConfig,
+        preset,
+      }) ?? {};
     if (!indexerInstance) {
       consola.error(`Specified indexer "${indexer}" but it was not defined`);
       process.exit(1);
@@ -34,6 +37,7 @@ const startCommand = defineCommand({
     const client = createAuthenticatedClient(
       indexerInstance.streamConfig,
       indexerInstance.options.streamUrl,
+      indexerInstance.options.clientOptions,
     );
 
     if (register) {

package/src/types/config.ts

@@ -41,7 +41,10 @@ export interface ApibaraConfig<
   preset?: keyof T;
 }
 
-export type ApibaraDynamicConfig = Pick<ApibaraConfig, "runtimeConfig">;
+export type ApibaraDynamicConfig = Pick<
+  ApibaraConfig,
+  "runtimeConfig" | "preset" | "presets"
+>;
 
 /**
  * Config loader options

package/dist/runtime/internal/helper.d.ts

@@ -1,12 +0,0 @@
-/**
- * Get the merged runtime config from the process.env.APIBARA_RUNTIME_CONFIG, presets and defaults.
- * Priority (Highest to lowest):
- * 1. process.env.APIBARA_RUNTIME_CONFIG
- * 2. Preset
- * 3. Defaults
- */
-export declare function getProcessedRuntimeConfig({ preset, presets, runtimeConfig, }: {
-    preset?: string;
-    presets?: Record<string, unknown>;
-    runtimeConfig?: Record<string, unknown>;
-}): Record<string, unknown>;

package/dist/runtime/internal/helper.mjs

@@ -1,33 +0,0 @@
-import defu from "defu";
-export function getProcessedRuntimeConfig({
-  preset,
-  presets,
-  runtimeConfig
-}) {
-  let _runtimeConfig = { ...runtimeConfig };
-  const envRuntimeConfig = process.env.APIBARA_RUNTIME_CONFIG;
-  if (preset) {
-    if (presets === void 0) {
-      throw new Error(
-        `Specified preset "${preset}" but no presets were defined`
-      );
-    }
-    if (presets[preset] === void 0) {
-      throw new Error(`Specified preset "${preset}" but it was not defined`);
-    }
-    const presetValue = presets[preset];
-    _runtimeConfig = defu(presetValue.runtimeConfig, _runtimeConfig);
-  }
-  if (envRuntimeConfig) {
-    try {
-      const envRuntimeConfigValue = JSON.parse(envRuntimeConfig);
-      _runtimeConfig = defu(envRuntimeConfigValue, _runtimeConfig);
-    } catch (error) {
-      throw new Error(
-        "Failed to parse runtime config from process.env.APIBARA_RUNTIME_CONFIG. Please ensure it is a valid JSON string.",
-        { cause: error }
-      );
-    }
-  }
-  return _runtimeConfig;
-}

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

@@ -1,12 +0,0 @@
-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);
-    Object.assign(options, new_options);
-  }
-}

package/src/rolldown/plugins/config.ts

@@ -1,17 +0,0 @@
-import virtual from "@rollup/plugin-virtual";
-import type { Apibara } from "apibara/types";
-import type { RolldownPluginOption } from "rolldown";
-
-export function appConfig(apibara: Apibara) {
-  return virtual({
-    "#apibara-internal-virtual/config": `
-    const serializedConfig = \`process.env.APIBARA_CONFIG\`;
-
-    if (serializedConfig === undefined || serializedConfig === "") {
-      throw new Error("APIBARA_CONFIG is not defined");
-    }
-
-    export const config = JSON.parse(serializedConfig);
-    `,
-  }) as RolldownPluginOption;
-}