devflare 0.0.0 → 1.0.0-next.1

package/dist/types-5nyrz1sz.js

@@ -0,0 +1,454 @@
+import {
+  discoverEntrypointsAsync,
+  resolvePackageSpecifier
+} from "./index-tk6ej9dj.js";
+import {
+  DEFAULT_DO_PATTERN,
+  DEFAULT_ENTRYPOINT_PATTERN,
+  findFiles
+} from "./index-rbht7m9r.js";
+import {
+  findDurableObjectClasses
+} from "./index-gz1gndna.js";
+import"./index-07q6yxyc.js";
+import"./index-67qcae0f.js";
+import {
+  loadConfig,
+  normalizeDOBinding
+} from "./index-hcex3rgh.js";
+import {
+  getDependencies
+} from "./index-1xpj0m4r.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/cli/commands/types.ts
+import { resolve, relative, dirname } from "pathe";
+async function parseConfigForRefs(configPath) {
+  const fs = await import("node:fs/promises");
+  const refs = [];
+  const serviceBindings = [];
+  const doBindings = [];
+  try {
+    const code = await fs.readFile(configPath, "utf-8");
+    const refPattern = /const\s+(\w+)\s*=\s*ref\s*\(\s*(?:'[^']*'\s*,\s*)?(?:\(\s*\)\s*=>\s*)?import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = refPattern.exec(code)) !== null) {
+      refs.push({
+        varName: match[1],
+        importPath: match[2]
+      });
+    }
+    const servicePattern = /(\w+)\s*:\s*(\w+)\.worker(?:\s*\(\s*['"](\w+)['"]\s*\))?/g;
+    while ((match = servicePattern.exec(code)) !== null) {
+      serviceBindings.push({
+        bindingName: match[1],
+        varName: match[2],
+        entrypoint: match[3]
+      });
+    }
+    const doPattern = /(\w+)\s*:\s*(\w+)\.([A-Z][A-Z0-9_]*)\s*[,\n\r}]/g;
+    while ((match = doPattern.exec(code)) !== null) {
+      if (match[3] === "worker")
+        continue;
+      doBindings.push({
+        bindingName: match[1],
+        varName: match[2],
+        doName: match[3]
+      });
+    }
+  } catch {}
+  return { refs, serviceBindings, doBindings };
+}
+async function findInterfaceTypes(searchDirs) {
+  const fs = await import("node:fs/promises");
+  const interfaces = new Map;
+  for (const dir of searchDirs) {
+    const typeFiles = await findFiles("**/*.types.ts", { cwd: dir });
+    const srcFiles = await findFiles("src/**/*.ts", { cwd: dir });
+    const allFiles = [...new Set([...typeFiles, ...srcFiles])];
+    for (const filePath of allFiles) {
+      try {
+        const code = await fs.readFile(filePath, "utf-8");
+        const interfacePattern = /export\s+interface\s+(\w+(?:Interface|Rpc))\s*\{/g;
+        let match;
+        while ((match = interfacePattern.exec(code)) !== null) {
+          const interfaceName = match[1];
+          let baseName;
+          if (interfaceName.endsWith("Interface")) {
+            baseName = interfaceName.slice(0, -9);
+          } else if (interfaceName.endsWith("Rpc")) {
+            baseName = interfaceName.slice(0, -3);
+          } else {
+            continue;
+          }
+          if (!interfaces.has(baseName)) {
+            interfaces.set(baseName, { filePath, interfaceName });
+          }
+          if (!interfaces.has("__default__")) {
+            if (baseName === "Worker" || baseName === "Default" || baseName === "MathService") {
+              interfaces.set("__default__", { filePath, interfaceName });
+            }
+          }
+        }
+      } catch {}
+    }
+  }
+  return interfaces;
+}
+async function resolveReferencedConfigs(configPath, cwd) {
+  const fs = await import("node:fs/promises");
+  const referenced = [];
+  const { refs, serviceBindings, doBindings } = await parseConfigForRefs(configPath);
+  if (refs.length === 0) {
+    return referenced;
+  }
+  const configDir = dirname(configPath);
+  for (const ref of refs) {
+    let refConfigPath = resolvePackageSpecifier(ref.importPath, configDir);
+    if (!refConfigPath.endsWith(".ts") && !refConfigPath.endsWith(".js")) {
+      refConfigPath += ".ts";
+    }
+    try {
+      await fs.access(refConfigPath);
+      const refDir = dirname(refConfigPath);
+      const entrypoints = await discoverEntrypointsAsync(refDir, DEFAULT_ENTRYPOINT_PATTERN);
+      const refDOs = await discoverDurableObjects(refDir, DEFAULT_DO_PATTERN);
+      const interfaceMap = await findInterfaceTypes([configDir, refDir]);
+      const bindings = serviceBindings.filter((sb) => sb.varName === ref.varName).map((sb) => {
+        const info = {
+          bindingName: sb.bindingName,
+          entrypoint: sb.entrypoint
+        };
+        const lookupKey = sb.entrypoint || "__default__";
+        const interfaceInfo = interfaceMap.get(lookupKey) || sb.entrypoint && interfaceMap.get(sb.entrypoint);
+        if (interfaceInfo) {
+          info.interfaceImport = generateImportPath(cwd, interfaceInfo.filePath);
+          info.interfaceType = interfaceInfo.interfaceName;
+        }
+        return info;
+      });
+      const crossWorkerDOs = doBindings.filter((doBinding) => doBinding.varName === ref.varName).map((doBinding) => {
+        const matchingDO = refDOs.find((do_) => do_.bindingName === doBinding.doName);
+        if (matchingDO) {
+          return {
+            bindingName: doBinding.bindingName,
+            doName: doBinding.doName,
+            className: matchingDO.className,
+            filePath: matchingDO.filePath
+          };
+        }
+        return null;
+      }).filter((item) => item !== null);
+      referenced.push({
+        varName: ref.varName,
+        importPath: ref.importPath,
+        refDir,
+        entrypoints,
+        serviceBindings: bindings,
+        durableObjects: crossWorkerDOs
+      });
+    } catch {}
+  }
+  return referenced;
+}
+async function discoverDurableObjects(cwd, pattern) {
+  const fs = await import("node:fs/promises");
+  const discovered = [];
+  const files = await findFiles(pattern, { cwd });
+  for (const filePath of files) {
+    try {
+      const code = await fs.readFile(filePath, "utf-8");
+      const classNames = findDurableObjectClasses(code);
+      for (const className of classNames) {
+        const bindingName = className.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+        discovered.push({
+          className,
+          filePath,
+          bindingName
+        });
+      }
+    } catch {}
+  }
+  return discovered;
+}
+function generateImportPath(cwd, filePath) {
+  let relativePath = relative(cwd, filePath);
+  relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (!relativePath.startsWith(".") && !relativePath.startsWith("/")) {
+    relativePath = "./" + relativePath;
+  }
+  return relativePath;
+}
+function generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, indent) {
+  const lines = [];
+  const imports = [];
+  if (config.bindings) {
+    if (config.bindings.kv) {
+      for (const binding of Object.keys(config.bindings.kv)) {
+        lines.push(`${indent}${binding}: KVNamespace`);
+      }
+    }
+    if (config.bindings.d1) {
+      for (const binding of Object.keys(config.bindings.d1)) {
+        lines.push(`${indent}${binding}: D1Database`);
+      }
+    }
+    if (config.bindings.r2) {
+      for (const binding of Object.keys(config.bindings.r2)) {
+        lines.push(`${indent}${binding}: R2Bucket`);
+      }
+    }
+    if (config.bindings.durableObjects) {
+      for (const [binding, doConfig] of Object.entries(config.bindings.durableObjects)) {
+        const crossWorkerDO = crossWorkerDOMap.get(binding);
+        if (crossWorkerDO) {
+          const importPath = generateImportPath(cwd, crossWorkerDO.filePath);
+          lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${importPath}').${crossWorkerDO.className}>`);
+          continue;
+        }
+        const className = doConfig.className;
+        if (className) {
+          const classInfo = doClassMap.get(className);
+          if (classInfo) {
+            lines.push(`${indent}${binding}: DurableObjectNamespace<Rpc.DurableObjectBranded & import('${classInfo.importPath}').${classInfo.className}>`);
+            continue;
+          }
+        }
+        lines.push(`${indent}${binding}: DurableObjectNamespace`);
+      }
+    }
+    if (config.bindings.queues?.producers) {
+      for (const binding of Object.keys(config.bindings.queues.producers)) {
+        lines.push(`${indent}${binding}: Queue`);
+      }
+    }
+    if (config.bindings.services) {
+      for (const binding of Object.keys(config.bindings.services)) {
+        const serviceInfo = serviceBindingMap.get(binding);
+        if (serviceInfo?.interfaceType && serviceInfo.interfaceImport) {
+          imports.push(`import type { ${serviceInfo.interfaceType} } from '${serviceInfo.interfaceImport}'`);
+          lines.push(`${indent}${binding}: ${serviceInfo.interfaceType}`);
+        } else {
+          lines.push(`${indent}${binding}: Fetcher`);
+        }
+      }
+    }
+    if (config.bindings.ai) {
+      lines.push(`${indent}${config.bindings.ai.binding}: Ai`);
+    }
+    if (config.bindings.vectorize) {
+      for (const binding of Object.keys(config.bindings.vectorize)) {
+        lines.push(`${indent}${binding}: VectorizeIndex`);
+      }
+    }
+    if (config.bindings.hyperdrive) {
+      for (const binding of Object.keys(config.bindings.hyperdrive)) {
+        lines.push(`${indent}${binding}: Hyperdrive`);
+      }
+    }
+    if (config.bindings.browser) {
+      lines.push(`${indent}${config.bindings.browser.binding}: Fetcher`);
+    }
+    if (config.bindings.analyticsEngine) {
+      for (const binding of Object.keys(config.bindings.analyticsEngine)) {
+        lines.push(`${indent}${binding}: AnalyticsEngineDataset`);
+      }
+    }
+  }
+  if (config.vars) {
+    for (const key of Object.keys(config.vars)) {
+      lines.push(`${indent}${key}: string`);
+    }
+  }
+  if (config.secrets) {
+    for (const secret of Object.keys(config.secrets)) {
+      lines.push(`${indent}${secret}: string`);
+    }
+  }
+  return { lines, imports };
+}
+function generateBindingTypes(config, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd) {
+  const doClassMap = new Map;
+  for (const do_ of discoveredDOs) {
+    doClassMap.set(do_.className, {
+      importPath: generateImportPath(cwd, do_.filePath),
+      className: do_.className
+    });
+  }
+  const crossWorkerDOMap = new Map;
+  for (const ref of referencedConfigs) {
+    for (const doInfo of ref.durableObjects) {
+      crossWorkerDOMap.set(doInfo.bindingName, doInfo);
+    }
+  }
+  const serviceBindingMap = new Map;
+  for (const ref of referencedConfigs) {
+    for (const sb of ref.serviceBindings) {
+      serviceBindingMap.set(sb.bindingName, sb);
+    }
+  }
+  const usedTypes = new Set;
+  if (config.bindings) {
+    if (config.bindings.kv && Object.keys(config.bindings.kv).length > 0)
+      usedTypes.add("KVNamespace");
+    if (config.bindings.d1 && Object.keys(config.bindings.d1).length > 0)
+      usedTypes.add("D1Database");
+    if (config.bindings.r2 && Object.keys(config.bindings.r2).length > 0)
+      usedTypes.add("R2Bucket");
+    if (config.bindings.durableObjects && Object.keys(config.bindings.durableObjects).length > 0)
+      usedTypes.add("DurableObjectNamespace");
+    if (config.bindings.queues?.producers && Object.keys(config.bindings.queues.producers).length > 0)
+      usedTypes.add("Queue");
+    if (config.bindings.services) {
+      const hasUntypedServices = Object.keys(config.bindings.services).some((name) => !serviceBindingMap.get(name)?.interfaceType);
+      if (hasUntypedServices)
+        usedTypes.add("Fetcher");
+    }
+    if (config.bindings.ai)
+      usedTypes.add("Ai");
+    if (config.bindings.vectorize && Object.keys(config.bindings.vectorize).length > 0)
+      usedTypes.add("VectorizeIndex");
+    if (config.bindings.hyperdrive && Object.keys(config.bindings.hyperdrive).length > 0)
+      usedTypes.add("Hyperdrive");
+    if (config.bindings.browser)
+      usedTypes.add("Fetcher");
+    if (config.bindings.analyticsEngine && Object.keys(config.bindings.analyticsEngine).length > 0)
+      usedTypes.add("AnalyticsEngineDataset");
+  }
+  const lines = [
+    "// Generated by devflare - DO NOT EDIT",
+    "// Run `devflare types` to regenerate",
+    ""
+  ];
+  const hasLocalDOsWithClasses = config.bindings?.durableObjects && Object.values(config.bindings.durableObjects).some((doConfig) => doConfig.className && doClassMap.has(doConfig.className));
+  const hasCrossWorkerDOs = crossWorkerDOMap.size > 0;
+  const hasDOsWithClasses = hasLocalDOsWithClasses || hasCrossWorkerDOs;
+  if (usedTypes.size > 0) {
+    const sortedTypes = [...usedTypes].sort();
+    if (hasDOsWithClasses) {
+      lines.push(`import type { ${sortedTypes.join(", ")}, Rpc } from '@cloudflare/workers-types'`);
+    } else {
+      lines.push(`import type { ${sortedTypes.join(", ")} } from '@cloudflare/workers-types'`);
+    }
+    lines.push("");
+  }
+  const { lines: bindingMembers, imports: serviceImports } = generateBindingMembers(config, doClassMap, crossWorkerDOMap, serviceBindingMap, cwd, "\t\t");
+  const uniqueImports = [...new Set(serviceImports)];
+  if (uniqueImports.length > 0) {
+    lines.push(...uniqueImports);
+    lines.push("");
+  }
+  lines.push("declare global {");
+  lines.push("\tinterface DevflareEnv {");
+  lines.push(...bindingMembers);
+  lines.push("\t}");
+  lines.push("}");
+  lines.push("");
+  if (discoveredEntrypoints.length > 0) {
+    const entrypointNames = discoveredEntrypoints.map((ep) => `'${ep.className}'`).join(" | ");
+    lines.push("/**");
+    lines.push(" * Named entrypoints discovered from ep.*.ts files.");
+    lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
+    lines.push(" */");
+    lines.push(`export type Entrypoints = ${entrypointNames}`);
+  } else {
+    lines.push("/**");
+    lines.push(" * Named entrypoints (none discovered - add ep.*.ts files to enable).");
+    lines.push(" * Use with defineConfig<Entrypoints>() for type-safe cross-worker references.");
+    lines.push(" */");
+    lines.push("export type Entrypoints = string");
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+async function runTypesCommand(parsed, logger, options) {
+  const cwd = options.cwd || process.cwd();
+  const configPath = parsed.options.config;
+  const outputPath = parsed.options.output || "env.d.ts";
+  logger.info("Generating TypeScript types...");
+  try {
+    const actualConfigPath = configPath ? resolve(cwd, configPath) : resolve(cwd, "devflare.config.ts");
+    const config = await loadConfig({ cwd, configFile: configPath });
+    const doPattern = typeof config.files?.durableObjects === "string" ? config.files.durableObjects : DEFAULT_DO_PATTERN;
+    let discoveredDOs = [];
+    if (config.files?.durableObjects !== false) {
+      discoveredDOs = await discoverDurableObjects(cwd, doPattern);
+      if (discoveredDOs.length > 0) {
+        logger.info(`Discovered ${discoveredDOs.length} Durable Object class(es):`);
+        for (const do_ of discoveredDOs) {
+          logger.info(`  • ${do_.className} → ${do_.bindingName}`);
+        }
+      }
+    }
+    if (config.bindings?.durableObjects) {
+      for (const [bindingName, doConfig] of Object.entries(config.bindings.durableObjects)) {
+        const normalized = normalizeDOBinding(doConfig);
+        const className = normalized.className;
+        if (!className)
+          continue;
+        const existing = discoveredDOs.find((d) => d.className === className);
+        if (existing)
+          continue;
+        if (normalized.scriptName && (normalized.scriptName.endsWith(".ts") || normalized.scriptName.endsWith(".js"))) {
+          const filePath = resolve(cwd, "src", normalized.scriptName);
+          discoveredDOs.push({
+            className,
+            filePath,
+            bindingName
+          });
+        }
+      }
+    }
+    const epPattern = typeof config.files?.entrypoints === "string" ? config.files.entrypoints : DEFAULT_ENTRYPOINT_PATTERN;
+    let discoveredEntrypoints = [];
+    if (config.files?.entrypoints !== false) {
+      discoveredEntrypoints = await discoverEntrypointsAsync(cwd, epPattern);
+      if (discoveredEntrypoints.length > 0) {
+        logger.info(`Discovered ${discoveredEntrypoints.length} entrypoint class(es):`);
+        for (const ep of discoveredEntrypoints) {
+          logger.info(`  • ${ep.className}`);
+        }
+      }
+    }
+    const referencedConfigs = await resolveReferencedConfigs(actualConfigPath, cwd);
+    if (referencedConfigs.length > 0) {
+      logger.info(`Found ${referencedConfigs.length} referenced worker(s):`);
+      for (const ref of referencedConfigs) {
+        const typedBindings = ref.serviceBindings.filter((sb) => sb.interfaceType);
+        if (typedBindings.length > 0) {
+          logger.info(`  • ${ref.varName}: ${typedBindings.map((sb) => `${sb.bindingName} → ${sb.interfaceType}`).join(", ")}`);
+        }
+      }
+    }
+    const normalizedConfig = {
+      ...config,
+      bindings: config.bindings ? {
+        ...config.bindings,
+        durableObjects: config.bindings.durableObjects ? Object.fromEntries(Object.entries(config.bindings.durableObjects).map(([name, doConfig]) => {
+          const normalized = normalizeDOBinding(doConfig);
+          return [name, { className: normalized.className, scriptName: normalized.scriptName }];
+        })) : undefined
+      } : undefined
+    };
+    const types = generateBindingTypes(normalizedConfig, discoveredDOs, discoveredEntrypoints, referencedConfigs, cwd);
+    const { fs } = await getDependencies();
+    const fullPath = resolve(cwd, outputPath);
+    await fs.writeFile(fullPath, types, "utf-8");
+    logger.success(`Generated types: ${outputPath}`);
+    return { exitCode: 0 };
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error("Type generation failed:", error.message);
+      if (parsed.options.debug) {
+        logger.error(error.stack);
+      }
+    }
+    return { exitCode: 1 };
+  }
+}
+export {
+  runTypesCommand
+};

package/dist/utils/entrypoint-discovery.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Information about a discovered entrypoint class
+ */
+export interface DiscoveredEntrypoint {
+    className: string;
+    filePath: string;
+}
+/**
+ * Find WorkerEntrypoint classes in source code
+ * @param code - Source code to search
+ * @returns Array of class names found
+ */
+export declare function findEntrypointClasses(code: string): string[];
+/**
+ * Discover entrypoint classes from ep.*.ts files in a directory (synchronous)
+ * @param dir - Directory to scan
+ * @returns Array of discovered entrypoints
+ */
+export declare function discoverEntrypointsSync(dir: string): DiscoveredEntrypoint[];
+/**
+ * Discover entrypoint classes from ep.*.ts files using glob pattern (async).
+ * Respects .gitignore automatically.
+ *
+ * @param cwd - Working directory for glob
+ * @param pattern - Glob pattern for ep.*.ts files (default: **​/ep.*.{ts,js})
+ * @returns Array of discovered entrypoints
+ */
+export declare function discoverEntrypointsAsync(cwd: string, pattern?: string): Promise<DiscoveredEntrypoint[]>;
+//# sourceMappingURL=entrypoint-discovery.d.ts.map

package/dist/utils/entrypoint-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint-discovery.d.ts","sourceRoot":"","sources":["../../src/utils/entrypoint-discovery.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CAChB;AAYD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY5D;AAWD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,EAAE,CA0B3E;AAMD;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAC7C,GAAG,EAAE,MAAM,EACX,OAAO,SAA6B,GAClC,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAoBjC"}

package/dist/utils/glob.d.ts

@@ -0,0 +1,33 @@
+/** Default glob pattern for Durable Object discovery */
+export declare const DEFAULT_DO_PATTERN = "**/do.*.{ts,js}";
+/** Default glob pattern for WorkerEntrypoint discovery */
+export declare const DEFAULT_ENTRYPOINT_PATTERN = "**/ep.*.{ts,js}";
+/** Default glob pattern for Workflow discovery */
+export declare const DEFAULT_WORKFLOW_PATTERN = "**/wf.*.{ts,js}";
+export interface GlobOptions {
+    /** Working directory for glob pattern */
+    cwd: string;
+    /** Return absolute paths instead of relative */
+    absolute?: boolean;
+    /** Respect .gitignore files (default: true) */
+    gitignore?: boolean;
+}
+/**
+ * Find files matching a glob pattern with .gitignore support.
+ * This is the async version for use in CLI commands and bundlers.
+ *
+ * @param pattern - Glob pattern (e.g., '**​/do.*.{ts,js}')
+ * @param options - Glob options
+ * @returns Array of matching file paths
+ */
+export declare function findFiles(pattern: string | string[], options: GlobOptions): Promise<string[]>;
+/**
+ * Find files matching a glob pattern synchronously.
+ * Use sparingly — prefer async version for better performance.
+ *
+ * @param pattern - Glob pattern (e.g., '**​/do.*.{ts,js}')
+ * @param options - Glob options
+ * @returns Array of matching file paths
+ */
+export declare function findFilesSync(pattern: string | string[], options: GlobOptions): string[];
+//# sourceMappingURL=glob.d.ts.map

package/dist/utils/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/utils/glob.ts"],"names":[],"mappings":"AAaA,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,oBAAoB,CAAA;AAEnD,0DAA0D;AAC1D,eAAO,MAAM,0BAA0B,oBAAoB,CAAA;AAE3D,kDAAkD;AAClD,eAAO,MAAM,wBAAwB,oBAAoB,CAAA;AAMzD,MAAM,WAAW,WAAW;IAC3B,yCAAyC;IACzC,GAAG,EAAE,MAAM,CAAA;IACX,gDAAgD;IAChD,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAA;CACnB;AAMD;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC9B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAiBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,EAAE,WAAW,GAClB,MAAM,EAAE,CAeV"}

package/dist/utils/resolve-package.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve a package specifier to a filesystem path
+ * Handles workspace packages like '@devflare/case11-do-shared/devflare.config'
+ *
+ * @param specifier - Package specifier (e.g., '@scope/pkg/path' or './relative/path')
+ * @param fromDir - Directory to resolve relative paths from
+ * @returns Resolved filesystem path
+ */
+export declare function resolvePackageSpecifier(specifier: string, fromDir: string): string;
+//# sourceMappingURL=resolve-package.d.ts.map

package/dist/utils/resolve-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-package.d.ts","sourceRoot":"","sources":["../../src/utils/resolve-package.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAgDlF"}

package/dist/vite/index.d.ts

@@ -0,0 +1,3 @@
+export { devflarePlugin, getPluginContext, getCloudflareConfig, getDevflareConfigs, type DevflarePluginOptions, type DevflarePluginContext, type AuxiliaryWorkerConfig, type DODiscoveryResult } from './plugin';
+export { devflarePlugin as default } from './plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vite/index.ts"],"names":[],"mappings":"AAIA,OAAO,EACN,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,cAAc,IAAI,OAAO,EAAE,MAAM,UAAU,CAAA"}