devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/{index-z14anrqp.js → index-aqrwyy57.js}

@@ -1,6 +1,26 @@
 // src/transform/worker-entrypoint.ts
 import ts from "typescript";
 import MagicString from "magic-string";
+
+// src/worker-entry/extensions.ts
+var SUPPORTED_WORKER_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".mjs",
+  ".cts",
+  ".cjs",
+  ".js",
+  ".jsx"
+];
+var TS_WORKER_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts"
+];
+
+// src/transform/worker-entrypoint.ts
 function findExportedFunctions(code) {
   const functions = [];
   const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
@@ -79,8 +99,14 @@ function findExportedFunctions(code) {
   visit(sourceFile);
   return functions;
 }
+function shouldEmitTsSyntax(filename) {
+  const lower = filename.toLowerCase();
+  return TS_WORKER_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
 function shouldTransformWorker(code, filePath) {
-  if (!filePath.endsWith("worker.ts") && !filePath.endsWith("worker.js")) {
+  const lower = filePath.toLowerCase();
+  const isWorkerFile = SUPPORTED_WORKER_EXTENSIONS.some((ext) => lower.endsWith(`worker${ext}`));
+  if (!isWorkerFile) {
     return false;
   }
   const functions = findExportedFunctions(code);
@@ -89,63 +115,98 @@ function shouldTransformWorker(code, filePath) {
 function transformWorkerEntrypoint(code, id, options = {}) {
   const className = options.className ?? "Worker";
   const injectContext = options.injectContext ?? true;
+  const emitTs = shouldEmitTsSyntax(id);
   const functions = findExportedFunctions(code);
   if (functions.length === 0) {
     return null;
   }
   const fetchFn = functions.find((f) => f.name === "fetch");
   const rpcMethods = functions.filter((f) => f.name !== "fetch");
+  const needsFetchHelpers = Boolean(fetchFn);
   const s = new MagicString(code);
   const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
 `;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } from 'devflare/runtime'
+  if (needsFetchHelpers) {
+    const runtimeImports = ["createFetchEvent", "invokeFetchHandler"];
+    if (injectContext) {
+      runtimeImports.push("runWithEventContext");
+    }
+    s.prepend(`import { ${runtimeImports.join(", ")} } from 'devflare/runtime'
 `);
   }
   s.prepend(importStatement);
-  for (const fn of functions) {
-    const fnCode = code.substring(fn.start, fn.end);
-    const internalName = fn.name === "fetch" ? "__originalFetch" : `__original_${fn.name}`;
-    if (fn.isDefault) {
-      const replacement = fnCode.replace(/^export\s+default\s+(async\s+)?function\s*/, (_, asyncKw) => `const ${internalName} = ${asyncKw || ""}function `);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export function") || fnCode.startsWith("export async function")) {
-      const replacement = fnCode.replace(/^export\s+(async\s+)?function\s+\w+/, (_, asyncKw) => `${asyncKw || ""}function ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export const")) {
-      const replacement = fnCode.replace(/^export\s+const\s+\w+/, () => `const ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
+  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const internalNameFor = (name) => name === "fetch" ? "__originalFetch" : `__original_${name}`;
+  function visit(node) {
+    if (ts.isFunctionDeclaration(node)) {
+      const modifiers = ts.getModifiers(node);
+      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const defaultMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      const asyncMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+      if (exportMod) {
+        const isDefault = Boolean(defaultMod);
+        const logicalName = isDefault ? "fetch" : node.name?.text;
+        if (logicalName) {
+          const internal = internalNameFor(logicalName);
+          if (isDefault && !node.name) {
+            const funcKeyword = node.getChildren(sourceFile).find((c) => c.kind === ts.SyntaxKind.FunctionKeyword);
+            if (funcKeyword) {
+              const asyncKw = asyncMod ? "async " : "";
+              s.overwrite(node.getStart(sourceFile), funcKeyword.getStart(sourceFile), `const ${internal} = ${asyncKw}`);
+            }
+          } else if (node.name) {
+            s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+            if (defaultMod) {
+              s.remove(defaultMod.getStart(sourceFile), defaultMod.getEnd());
+            }
+            s.overwrite(node.name.getStart(sourceFile), node.name.getEnd(), internal);
+          }
+        }
+      }
+    } else if (ts.isVariableStatement(node)) {
+      const modifiers = ts.getModifiers(node);
+      const exportMod = modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (exportMod) {
+        let rewroteAny = false;
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer && (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))) {
+            const internal = internalNameFor(decl.name.text);
+            s.overwrite(decl.name.getStart(sourceFile), decl.name.getEnd(), internal);
+            rewroteAny = true;
+          }
+        }
+        if (rewroteAny) {
+          s.remove(exportMod.getStart(sourceFile), exportMod.getEnd());
+        }
+      }
     }
+    ts.forEachChild(node, visit);
   }
+  visit(sourceFile);
   let classBody = `
 
 // ============ Devflare WorkerEntrypoint ============
 class ${className} extends WorkerEntrypoint {
 `;
   if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
+    const fetchSig = emitTs ? "async fetch(request: Request): Promise<Response>" : "async fetch(request)";
+    classBody += `	${fetchSig} {
 `;
-      classBody += `			this.env,
+    classBody += `		const __devflareEvent = createFetchEvent(request, this.env, this.ctx)
 `;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
+    if (injectContext) {
+      classBody += `		return runWithEventContext(
 `;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
+      classBody += `			__devflareEvent,
 `;
-      classBody += `			'fetch'
+      classBody += `			() => invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `		)
 `;
       classBody += `	}
 `;
     } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
+      classBody += `		return invokeFetchHandler(__originalFetch, __devflareEvent)
 `;
       classBody += `	}
 `;
@@ -153,10 +214,11 @@ class ${className} extends WorkerEntrypoint {
   }
   for (const fn of rpcMethods) {
     const asyncPrefix = fn.isAsync ? "async " : "";
-    const returnType = fn.returnType ? `: ${fn.returnType}` : "";
     const paramNames = extractParamNames(fn.params);
+    const signatureParams = emitTs ? fn.params : paramNames;
+    const returnType = emitTs && fn.returnType ? `: ${fn.returnType}` : "";
     classBody += `
-	${asyncPrefix}${fn.name}(${fn.params})${returnType} {
+	${asyncPrefix}${fn.name}(${signatureParams})${returnType} {
 `;
     classBody += `		return __original_${fn.name}(${paramNames})
 `;
@@ -223,4 +285,4 @@ function generateRpcInterface(functions, interfaceName) {
   return output;
 }
 
-export { findExportedFunctions, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };
+export { SUPPORTED_WORKER_EXTENSIONS, findExportedFunctions, shouldEmitTsSyntax, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/index-c8p4njqy.js

@@ -0,0 +1,479 @@
+// src/config/env-vars.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "pathe";
+var ENV_DESCRIPTOR_FLAG = "__devflareEnvDescriptor";
+function createDescriptor(state) {
+  const descriptor = {
+    [ENV_DESCRIPTOR_FLAG]: true,
+    __state: state,
+    optional() {
+      return createDescriptor({
+        ...state,
+        optional: true
+      });
+    },
+    parse(parser) {
+      return createDescriptor({
+        ...state,
+        parser
+      });
+    },
+    parser(parser) {
+      return this.parse(parser);
+    },
+    default(value) {
+      return createDescriptor({
+        ...state,
+        defaultValue: value,
+        hasDefault: true,
+        optional: false
+      });
+    },
+    dev(value) {
+      return createDescriptor({
+        ...state,
+        devValue: value,
+        hasDevDefault: true
+      });
+    }
+  };
+  return descriptor;
+}
+function createEnvVarDescriptor(name) {
+  return createDescriptor({
+    name,
+    optional: false,
+    hasDefault: false,
+    hasDevDefault: false
+  });
+}
+var env = new Proxy({}, {
+  get(_target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return createEnvVarDescriptor(prop);
+  }
+});
+function isEnvVarDescriptor(value) {
+  return Boolean(value && typeof value === "object" && value[ENV_DESCRIPTOR_FLAG] === true);
+}
+function parseEnvValue(rawValue) {
+  const trimmed = rawValue.trim();
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
+    const inner = trimmed.slice(1, -1);
+    if (quote !== '"') {
+      return inner;
+    }
+    return inner.replace(/\\n/g, `
+`).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return trimmed;
+}
+function parseDevflareEnvFile(contents) {
+  const values = {};
+  for (const line of contents.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const assignment = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trimStart() : trimmed;
+    const equalsIndex = assignment.indexOf("=");
+    if (equalsIndex <= 0) {
+      continue;
+    }
+    const key = assignment.slice(0, equalsIndex).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      continue;
+    }
+    values[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
+  }
+  return values;
+}
+function collectAncestorDirectories(startDir) {
+  const directories = [];
+  let current = resolve(startDir);
+  while (true) {
+    directories.push(current);
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return directories.reverse();
+}
+function getDevflareDotenvPaths(startDir) {
+  return collectAncestorDirectories(startDir).flatMap((directory) => [
+    resolve(directory, ".env.dev"),
+    resolve(directory, ".env")
+  ]);
+}
+async function loadDevflareDotenv(startDir) {
+  const values = {};
+  const files = [];
+  for (const filePath of getDevflareDotenvPaths(startDir)) {
+    if (!existsSync(filePath)) {
+      continue;
+    }
+    Object.assign(values, parseDevflareEnvFile(await readFile(filePath, "utf8")));
+    files.push(filePath);
+  }
+  return { values, files };
+}
+async function loadDevflareDotenvIntoProcess(startDir) {
+  const loaded = await loadDevflareDotenv(startDir);
+  for (const [key, value] of Object.entries(loaded.values)) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+  return loaded;
+}
+function formatMissingEnvTree(missing) {
+  const root = {};
+  for (const item of missing) {
+    let current = root;
+    for (const segment of item.path.slice(0, -1)) {
+      const next = current[segment];
+      if (!next || typeof next !== "object") {
+        current[segment] = {};
+      }
+      current = current[segment];
+    }
+    current[item.path[item.path.length - 1] ?? item.name] = item.name;
+  }
+  const lines = [];
+  const writeNode = (node, depth) => {
+    const indent = "\t".repeat(depth);
+    for (const [key, value] of Object.entries(node)) {
+      if (value && typeof value === "object") {
+        lines.push(`${indent}${key}:`);
+        writeNode(value, depth + 1);
+      } else {
+        lines.push(`${indent}${key}: ${String(value)}`);
+      }
+    }
+  };
+  writeNode(root, 1);
+  return lines.join(`
+`);
+}
+
+class EnvVarResolutionError extends Error {
+  missing;
+  mode;
+  code = "ENV_VARS_MISSING";
+  constructor(missing, mode) {
+    super([
+      "These environment variables are missing:",
+      "",
+      formatMissingEnvTree(missing)
+    ].join(`
+`));
+    this.missing = missing;
+    this.mode = mode;
+    this.name = "EnvVarResolutionError";
+  }
+}
+
+class EnvVarParseError extends Error {
+  variableName;
+  path;
+  code = "ENV_VAR_PARSE_FAILED";
+  constructor(variableName, path, cause) {
+    super(`Could not parse environment variable ${variableName} for vars.${path.join(".")}.
+` + `Parser error: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.variableName = variableName;
+    this.path = path;
+    this.name = "EnvVarParseError";
+  }
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || isEnvVarDescriptor(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+var OMIT_VALUE = Symbol("omit optional env var");
+function resolveDescriptorValue(descriptor, sources, path, mode, missing) {
+  const state = descriptor.__state;
+  const rawValue = sources[state.name];
+  if (rawValue !== undefined) {
+    try {
+      return state.parser ? state.parser(rawValue) : rawValue;
+    } catch (error) {
+      throw new EnvVarParseError(state.name, path, error);
+    }
+  }
+  if (mode === "dev" && state.hasDevDefault) {
+    return state.devValue;
+  }
+  if (state.hasDefault) {
+    return state.defaultValue;
+  }
+  if (state.optional) {
+    return OMIT_VALUE;
+  }
+  missing.push({ path, name: state.name });
+  return OMIT_VALUE;
+}
+function resolveVarValue(value, sources, path, mode, missing) {
+  if (isEnvVarDescriptor(value)) {
+    return resolveDescriptorValue(value, sources, path, mode, missing);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => resolveVarValue(item, sources, [...path, String(index)], mode, missing)).filter((item) => item !== OMIT_VALUE);
+  }
+  if (isPlainObject(value)) {
+    const resolved = {};
+    for (const [key, childValue] of Object.entries(value)) {
+      const child = resolveVarValue(childValue, sources, [...path, key], mode, missing);
+      if (child !== OMIT_VALUE) {
+        resolved[key] = child;
+      }
+    }
+    return resolved;
+  }
+  return value;
+}
+function resolveVarsObject(vars, sources, mode, missing) {
+  if (!vars) {
+    return vars;
+  }
+  const resolved = resolveVarValue(vars, sources, [], mode, missing);
+  return resolved === OMIT_VALUE ? undefined : resolved;
+}
+async function resolveConfigEnvVars(config, options) {
+  const startDir = options.configPath ? dirname(resolve(options.cwd, options.configPath)) : options.cwd;
+  const dotenv = await loadDevflareDotenv(startDir);
+  const sources = {
+    ...dotenv.values,
+    ...process.env
+  };
+  const missing = [];
+  const vars = resolveVarsObject(config.vars, sources, options.mode, missing);
+  if (missing.length > 0) {
+    throw new EnvVarResolutionError(missing, options.mode);
+  }
+  return vars === config.vars ? config : {
+    ...config,
+    vars
+  };
+}
+
+// src/config/preview.ts
+var PREVIEW_SCOPED_NAME_PREFIX = "__DEVFLARE_PREVIEW_SCOPE__:";
+function getPreviewScopedSeparator(options) {
+  return options?.separator ?? "-";
+}
+function encodePreviewScopedName(value) {
+  return `${PREVIEW_SCOPED_NAME_PREFIX}${JSON.stringify(value)}`;
+}
+function invalidPreviewScopedName(reason) {
+  throw new Error(`Invalid Devflare preview-scoped value: ${reason}. Recreate it with preview.scope(...) instead of constructing preview markers manually.`);
+}
+function decodePreviewScopedName(value) {
+  const payload = value.slice(PREVIEW_SCOPED_NAME_PREFIX.length);
+  let parsed;
+  try {
+    parsed = JSON.parse(payload);
+  } catch {
+    invalidPreviewScopedName("the encoded payload is not valid JSON");
+  }
+  const baseName = typeof parsed.baseName === "string" ? parsed.baseName : "";
+  if (!baseName.trim()) {
+    invalidPreviewScopedName("the encoded payload is missing a non-empty baseName");
+  }
+  return {
+    baseName,
+    separator: typeof parsed.separator === "string" && parsed.separator.length > 0 ? parsed.separator : "-"
+  };
+}
+function normalizePreviewFragment(rawValue) {
+  let normalized = rawValue.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  if (!normalized) {
+    normalized = "preview";
+  }
+  if (!/^[a-z]/.test(normalized)) {
+    normalized = `b-${normalized}`;
+  }
+  return normalized;
+}
+function getPreviewIdentifierFromEnv(env2) {
+  const explicitIdentifier = env2.DEVFLARE_PREVIEW_IDENTIFIER?.trim();
+  if (explicitIdentifier) {
+    return {
+      identifier: normalizePreviewFragment(explicitIdentifier),
+      source: "env-identifier"
+    };
+  }
+  const previewPr = env2.DEVFLARE_PREVIEW_PR?.trim();
+  if (previewPr) {
+    return {
+      identifier: normalizePreviewFragment(`pr-${previewPr}`),
+      source: "env-pr"
+    };
+  }
+  const previewBranch = env2.DEVFLARE_PREVIEW_BRANCH?.trim();
+  if (previewBranch) {
+    return {
+      identifier: normalizePreviewFragment(previewBranch),
+      source: "env-branch"
+    };
+  }
+  return {
+    identifier: undefined,
+    source: "none"
+  };
+}
+function resolvePreviewIdentifier(options = {}) {
+  if (options.identifier?.trim()) {
+    return {
+      identifier: normalizePreviewFragment(options.identifier),
+      source: "identifier"
+    };
+  }
+  const env2 = options.env ?? process.env;
+  const envIdentifier = getPreviewIdentifierFromEnv(env2);
+  if (envIdentifier.identifier) {
+    return envIdentifier;
+  }
+  return options.environment === "preview" ? {
+    identifier: "preview",
+    source: "environment"
+  } : {
+    identifier: undefined,
+    source: "none"
+  };
+}
+function mapRecordValues(record, mapper) {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
+}
+var preview = {
+  scope(defaults = {}) {
+    return (baseName, options = {}) => {
+      if (!baseName.trim()) {
+        throw new Error("preview.scope(...) requires a non-empty baseName.");
+      }
+      return encodePreviewScopedName({
+        baseName,
+        separator: getPreviewScopedSeparator({
+          ...defaults,
+          ...options
+        })
+      });
+    };
+  }
+};
+function isPreviewScopedName(value) {
+  return typeof value === "string" && value.startsWith(PREVIEW_SCOPED_NAME_PREFIX);
+}
+function materializePreviewScopedString(value, options = {}) {
+  if (!isPreviewScopedName(value)) {
+    return value;
+  }
+  const scoped = decodePreviewScopedName(value);
+  const previewIdentifier = resolvePreviewIdentifier(options).identifier;
+  return previewIdentifier ? `${scoped.baseName}${scoped.separator}${previewIdentifier}` : scoped.baseName;
+}
+function materializePreviewScopedConfig(config, options = {}) {
+  if (!config.bindings) {
+    return config;
+  }
+  const bindings = config.bindings;
+  const hasPreviewIdentifier = Boolean(resolvePreviewIdentifier(options).identifier);
+  return {
+    ...config,
+    bindings: {
+      ...bindings,
+      ...bindings.kv ? {
+        kv: mapRecordValues(bindings.kv, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.d1 ? {
+        d1: mapRecordValues(bindings.d1, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.r2 ? {
+        r2: mapRecordValues(bindings.r2, (binding) => {
+          return materializePreviewScopedString(binding, options);
+        })
+      } : {},
+      ...bindings.queues ? {
+        queues: {
+          ...bindings.queues,
+          ...bindings.queues.producers ? {
+            producers: mapRecordValues(bindings.queues.producers, (queueName) => {
+              return materializePreviewScopedString(queueName, options);
+            })
+          } : {},
+          ...bindings.queues.consumers ? {
+            consumers: bindings.queues.consumers.map((consumer) => ({
+              ...consumer,
+              queue: materializePreviewScopedString(consumer.queue, options),
+              ...consumer.deadLetterQueue ? {
+                deadLetterQueue: materializePreviewScopedString(consumer.deadLetterQueue, options)
+              } : {}
+            }))
+          } : {}
+        }
+      } : {},
+      ...bindings.services ? {
+        services: mapRecordValues(bindings.services, (binding) => ({
+          ...binding,
+          service: materializePreviewScopedString(binding.service, options)
+        }))
+      } : {},
+      ...bindings.vectorize ? {
+        vectorize: mapRecordValues(bindings.vectorize, (binding) => ({
+          ...binding,
+          indexName: materializePreviewScopedString(binding.indexName, options)
+        }))
+      } : {},
+      ...bindings.hyperdrive ? {
+        hyperdrive: mapRecordValues(bindings.hyperdrive, (binding) => {
+          if (typeof binding === "string") {
+            return materializePreviewScopedString(binding, options);
+          }
+          if (binding && typeof binding === "object" && "name" in binding && typeof binding.name === "string") {
+            if (hasPreviewIdentifier && binding.previewId) {
+              return {
+                id: binding.previewId,
+                ...binding.localConnectionString && {
+                  localConnectionString: binding.localConnectionString
+                },
+                ...!binding.localConnectionString && binding.previewLocalConnectionString && {
+                  localConnectionString: binding.previewLocalConnectionString
+                }
+              };
+            }
+            return {
+              ...binding,
+              name: materializePreviewScopedString(binding.name, options)
+            };
+          }
+          return binding;
+        })
+      } : {},
+      ...bindings.browser ? {
+        browser: mapRecordValues(bindings.browser, (binding) => {
+          return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+        })
+      } : {},
+      ...bindings.analyticsEngine ? {
+        analyticsEngine: mapRecordValues(bindings.analyticsEngine, (binding) => ({
+          ...binding,
+          dataset: materializePreviewScopedString(binding.dataset, options)
+        }))
+      } : {}
+    }
+  };
+}
+
+export { env, isEnvVarDescriptor, getDevflareDotenvPaths, loadDevflareDotenvIntoProcess, EnvVarResolutionError, resolveConfigEnvVars, resolvePreviewIdentifier, preview, isPreviewScopedName, materializePreviewScopedString, materializePreviewScopedConfig };