devflare 1.0.0-next.5 → 1.0.0-next.50

package/dist/index-tk6ej9dj.js

@@ -1,94 +0,0 @@
-import {
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/utils/entrypoint-discovery.ts
-import { readdirSync, readFileSync } from "fs";
-import { join } from "path";
-var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
-function findEntrypointClasses(code) {
-  const classes = [];
-  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-var EP_FILE_PATTERN = /^ep\.[^.]+\.ts$/;
-function discoverEntrypointsSync(dir) {
-  const discovered = [];
-  try {
-    const files = readdirSync(dir, { withFileTypes: true });
-    for (const file of files) {
-      if (file.isFile() && EP_FILE_PATTERN.test(file.name)) {
-        const filePath = join(dir, file.name);
-        try {
-          const code = readFileSync(filePath, "utf-8");
-          const classNames = findEntrypointClasses(code);
-          for (const className of classNames) {
-            discovered.push({ className, filePath });
-          }
-        } catch {}
-      }
-    }
-  } catch {}
-  return discovered;
-}
-async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_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 = findEntrypointClasses(code);
-      for (const className of classNames) {
-        discovered.push({ className, filePath });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-
-// src/utils/resolve-package.ts
-import { resolve, dirname } from "pathe";
-import { readFileSync as readFileSync2, existsSync } from "node:fs";
-function resolvePackageSpecifier(specifier, fromDir) {
-  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
-    return resolve(fromDir, specifier);
-  }
-  try {
-    const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-    const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
-    const pkgJsonPath = __require.resolve(`${parts}/package.json`, { paths: [fromDir] });
-    const pkgDir = dirname(pkgJsonPath);
-    if (subpath) {
-      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
-      const exportPath = pkgJson.exports?.[`./${subpath}`];
-      if (exportPath) {
-        const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
-        return resolve(pkgDir, targetPath);
-      }
-      const directPath = resolve(pkgDir, `${subpath}.ts`);
-      if (existsSync(directPath))
-        return directPath;
-      const withExt = resolve(pkgDir, subpath);
-      if (existsSync(withExt))
-        return withExt;
-      if (existsSync(`${withExt}.ts`))
-        return `${withExt}.ts`;
-      if (existsSync(`${withExt}.js`))
-        return `${withExt}.js`;
-    }
-    return pkgDir;
-  } catch {
-    return resolve(fromDir, specifier);
-  }
-}
-
-export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };

package/dist/index-z14anrqp.js

@@ -1,226 +0,0 @@
-// src/transform/worker-entrypoint.ts
-import ts from "typescript";
-import MagicString from "magic-string";
-function findExportedFunctions(code) {
-  const functions = [];
-  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const funcName = isDefault ? "fetch" : node.name.text;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: funcName,
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault
-        });
-      }
-    }
-    if (ts.isFunctionDeclaration(node) && !node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported && isDefault) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: "fetch",
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault: true
-        });
-      }
-    }
-    if (ts.isVariableStatement(node)) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      if (isExported) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts.isIdentifier(decl.name) && decl.initializer) {
-            let funcExpr;
-            if (ts.isFunctionExpression(decl.initializer)) {
-              funcExpr = decl.initializer;
-            } else if (ts.isArrowFunction(decl.initializer)) {
-              funcExpr = decl.initializer;
-            }
-            if (funcExpr) {
-              const modifiersArr = ts.getModifiers(funcExpr);
-              const isAsync = modifiersArr?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
-              const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-              const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : undefined;
-              functions.push({
-                name: decl.name.text,
-                isAsync,
-                params,
-                returnType,
-                start: node.getStart(sourceFile),
-                end: node.getEnd()
-              });
-            }
-          }
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return functions;
-}
-function shouldTransformWorker(code, filePath) {
-  if (!filePath.endsWith("worker.ts") && !filePath.endsWith("worker.js")) {
-    return false;
-  }
-  const functions = findExportedFunctions(code);
-  return functions.length > 0;
-}
-function transformWorkerEntrypoint(code, id, options = {}) {
-  const className = options.className ?? "Worker";
-  const injectContext = options.injectContext ?? true;
-  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 s = new MagicString(code);
-  const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
-`;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } 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);
-    }
-  }
-  let classBody = `
-
-// ============ Devflare WorkerEntrypoint ============
-class ${className} extends WorkerEntrypoint {
-`;
-  if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
-`;
-      classBody += `			this.env,
-`;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
-`;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
-`;
-      classBody += `			'fetch'
-`;
-      classBody += `		)
-`;
-      classBody += `	}
-`;
-    } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
-`;
-      classBody += `	}
-`;
-    }
-  }
-  for (const fn of rpcMethods) {
-    const asyncPrefix = fn.isAsync ? "async " : "";
-    const returnType = fn.returnType ? `: ${fn.returnType}` : "";
-    const paramNames = extractParamNames(fn.params);
-    classBody += `
-	${asyncPrefix}${fn.name}(${fn.params})${returnType} {
-`;
-    classBody += `		return __original_${fn.name}(${paramNames})
-`;
-    classBody += `	}
-`;
-  }
-  classBody += `}
-
-`;
-  classBody += `export { ${className} }
-`;
-  classBody += `export { ${className} as default }
-`;
-  classBody += `// ============ End Devflare WorkerEntrypoint ============
-`;
-  s.append(classBody);
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: id,
-      file: id + ".map",
-      includeContent: true
-    }),
-    rpcMethods: rpcMethods.map((fn) => fn.name),
-    className
-  };
-}
-function extractParamNames(params) {
-  if (!params.trim())
-    return "";
-  const tempCode = `function f(${params}) {}`;
-  const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const names = [];
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node)) {
-      for (const param of node.parameters) {
-        if (ts.isIdentifier(param.name)) {
-          names.push(param.name.text);
-        } else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) {
-          names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return names.join(", ");
-}
-function generateRpcInterface(functions, interfaceName) {
-  const rpcMethods = functions.filter((f) => f.name !== "fetch");
-  if (rpcMethods.length === 0) {
-    return "";
-  }
-  let output = `export interface ${interfaceName} {
-`;
-  for (const fn of rpcMethods) {
-    const returnType = fn.returnType ?? "unknown";
-    const promiseReturn = returnType.startsWith("Promise<") ? returnType : `Promise<${returnType}>`;
-    output += `	${fn.name}(${fn.params}): ${promiseReturn}
-`;
-  }
-  output += `}
-`;
-  return output;
-}
-
-export { findExportedFunctions, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/init-f9mgmew3.js

@@ -1,186 +0,0 @@
-import {
-  getDependencies
-} from "./index-1xpj0m4r.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/init.ts
-import { resolve, join } from "pathe";
-var MINIMAL_TEMPLATE = {
-  name: "minimal",
-  description: "Minimal starter with single handler",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
-
-export default defineConfig({
-	name: '{{PROJECT_NAME}}',
-	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-})
-`,
-    "src/index.ts": `import { env, ctx, event, locals } from 'devflare/runtime'
-
-export default {
-	async fetch(request: Request): Promise<Response> {
-		return new Response('Hello from devflare!')
-	}
-}
-`,
-    "package.json": `{
-	"name": "{{PROJECT_NAME}}",
-	"version": "0.0.1",
-	"private": true,
-	"type": "module",
-	"scripts": {
-		"dev": "devflare dev",
-		"build": "devflare build",
-		"deploy": "devflare deploy",
-		"types": "devflare types"
-	},
-	"devDependencies": {
-		"devflare": "^0.1.0",
-		"typescript": "^5.7.0"
-	}
-}
-`,
-    "tsconfig.json": `{
-	"compilerOptions": {
-		"target": "ESNext",
-		"module": "ESNext",
-		"moduleResolution": "bundler",
-		"strict": true,
-		"skipLibCheck": true,
-		"types": ["@cloudflare/workers-types"]
-	},
-	"include": ["src/**/*", "devflare.config.ts"]
-}
-`
-  }
-};
-var API_TEMPLATE = {
-  name: "api",
-  description: "API starter with middleware and routing",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
-
-export default defineConfig({
-	name: '{{PROJECT_NAME}}',
-	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-	bindings: {
-		// Add your bindings here
-		// kv: [{ binding: 'CACHE' }],
-		// d1: [{ binding: 'DB', database_name: 'my-db' }],
-	}
-})
-`,
-    "src/index.ts": `import { sequence, resolve } from 'devflare/runtime'
-import { corsMiddleware } from './middleware/cors'
-import { apiRouter } from './routes/api'
-
-const handler = sequence(
-	corsMiddleware
-)(
-	resolve(
-		apiRouter,
-		async () => new Response('Not Found', { status: 404 })
-	)
-)
-
-export default {
-	async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
-		return handler()
-	}
-}
-`,
-    "src/middleware/cors.ts": `import type { Middleware } from 'devflare/runtime'
-import { event } from 'devflare/runtime'
-
-export const corsMiddleware: Middleware = async (next) => {
-	// Handle preflight
-	if (event.request?.method === 'OPTIONS') {
-		return new Response(null, {
-			headers: {
-				'Access-Control-Allow-Origin': '*',
-				'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-				'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-			}
-		})
-	}
-
-	const response = await next()
-	const newResponse = new Response(response.body, response)
-	newResponse.headers.set('Access-Control-Allow-Origin', '*')
-	return newResponse
-}
-`,
-    "src/routes/api.ts": `import type { Handler } from 'devflare/runtime'
-import { event, env, locals } from 'devflare/runtime'
-
-export const apiRouter: Handler = async () => {
-	const request = event.request
-	if (!request) return null
-
-	const url = new URL(request.url)
-
-	if (url.pathname === '/api/health') {
-		return new Response(JSON.stringify({ status: 'ok' }), {
-			headers: { 'Content-Type': 'application/json' }
-		})
-	}
-
-	if (url.pathname.startsWith('/api/')) {
-		return new Response(JSON.stringify({ error: 'Not found' }), {
-			status: 404,
-			headers: { 'Content-Type': 'application/json' }
-		})
-	}
-
-	// Not an API route, pass through
-	return null
-}
-`,
-    "package.json": MINIMAL_TEMPLATE.files["package.json"],
-    "tsconfig.json": MINIMAL_TEMPLATE.files["tsconfig.json"]
-  }
-};
-var TEMPLATES = {
-  minimal: MINIMAL_TEMPLATE,
-  api: API_TEMPLATE
-};
-async function runInitCommand(parsed, logger, options) {
-  const projectName = parsed.args[0] || "my-devflare-app";
-  const templateName = parsed.options.template || "minimal";
-  const cwd = options.cwd || process.cwd();
-  logger.info(`Creating new devflare project: ${projectName}`);
-  const template = TEMPLATES[templateName];
-  if (!template) {
-    logger.error(`Unknown template: ${templateName}`);
-    logger.info(`Available templates: ${Object.keys(TEMPLATES).join(", ")}`);
-    return { exitCode: 1 };
-  }
-  const projectDir = resolve(cwd, projectName);
-  const { fs } = await getDependencies();
-  try {
-    await fs.access(projectDir);
-    logger.error(`Directory already exists: ${projectDir}`);
-    return { exitCode: 1 };
-  } catch {}
-  await fs.mkdir(projectDir, { recursive: true });
-  for (const [filePath, content] of Object.entries(template.files)) {
-    const fullPath = join(projectDir, filePath);
-    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    await fs.mkdir(dir, { recursive: true }).catch(() => {});
-    const processedContent = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName);
-    await fs.writeFile(fullPath, processedContent, "utf-8");
-    logger.info(`  Created: ${filePath}`);
-  }
-  logger.success(`
-Project created successfully!`);
-  logger.info(`
-Next steps:`);
-  logger.info(`  cd ${projectName}`);
-  logger.info(`  bun install`);
-  logger.info(`  bun run dev`);
-  return { exitCode: 0 };
-}
-export {
-  runInitCommand
-};

package/dist/remote-q59qk463.js

@@ -1,97 +0,0 @@
-import {
-  BOLD,
-  DIM,
-  GREEN,
-  RED,
-  RESET,
-  YELLOW
-} from "./index-3t6rypgc.js";
-import {
-  disableRemoteMode,
-  enableRemoteMode,
-  getEffectiveRemoteModeStatus
-} from "./index-d8bdkx2h.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/remote.ts
-function log(message = "") {
-  console.log(message);
-}
-function showStatus() {
-  const status = getEffectiveRemoteModeStatus();
-  log();
-  log(`${BOLD}Remote Test Mode${RESET}`);
-  log();
-  if (status.isActive) {
-    log(`  ${GREEN}●${RESET} ${BOLD}Enabled${RESET}`);
-    if (status.source === "env") {
-      log(`    Source: ${YELLOW}DEVFLARE_REMOTE${RESET} environment variable`);
-      log(`    ${DIM}(unset the variable to disable)${RESET}`);
-    } else {
-      log(`    Expires in ${status.remainingMinutes} minute(s)`);
-      log(`    ${DIM}At: ${status.expiresAt?.toLocaleTimeString()}${RESET}`);
-    }
-  } else {
-    log(`  ${DIM}○${RESET} Disabled`);
-    log(`    ${DIM}Remote-only tests (AI, Vectorize) will be skipped${RESET}`);
-  }
-  log();
-  log(`${DIM}Commands:${RESET}`);
-  log(`  devflare remote enable [minutes]  Enable for N minutes (default: 30)`);
-  log(`  devflare remote disable           Disable immediately`);
-  log(`  devflare remote status            Show current status`);
-  log();
-}
-function enable(inputMinutes) {
-  const actualMinutes = enableRemoteMode(inputMinutes);
-  const status = getEffectiveRemoteModeStatus();
-  log();
-  if (inputMinutes !== actualMinutes) {
-    log(`${YELLOW}⚠${RESET}  Invalid duration, using ${actualMinutes} minute(s)`);
-  }
-  log(`${GREEN}✓${RESET} Remote test mode ${BOLD}enabled${RESET} for ${actualMinutes} minute(s)`);
-  log(`  Expires at: ${status.expiresAt?.toLocaleTimeString()}`);
-  log();
-  log(`${YELLOW}⚠${RESET}  Remote tests use real Cloudflare infrastructure and may incur costs.`);
-  log(`   Run ${DIM}devflare remote disable${RESET} when done.`);
-  log();
-}
-function disable() {
-  const statusBefore = getEffectiveRemoteModeStatus();
-  disableRemoteMode();
-  log();
-  log(`${GREEN}✓${RESET} Remote test mode ${BOLD}disabled${RESET}`);
-  if (statusBefore.envVarSet) {
-    log();
-    log(`${YELLOW}⚠${RESET}  Note: ${BOLD}DEVFLARE_REMOTE${RESET} environment variable is still set.`);
-    log(`   Remote mode will remain active until you unset it.`);
-  } else {
-    log(`  Remote-only tests (AI, Vectorize) will now be skipped.`);
-  }
-  log();
-}
-function runRemoteCommand(parsed, _logger, _options) {
-  const subcommand = parsed.args[0];
-  const arg = parsed.args[1];
-  switch (subcommand) {
-    case "enable": {
-      const minutes = arg ? parseInt(arg, 10) : 30;
-      enable(isNaN(minutes) ? 30 : minutes);
-      return { exitCode: 0 };
-    }
-    case "disable":
-      disable();
-      return { exitCode: 0 };
-    case "status":
-    case undefined:
-      showStatus();
-      return { exitCode: 0 };
-    default:
-      log(`${RED}Unknown subcommand:${RESET} ${subcommand}`);
-      log(`Run ${DIM}devflare remote${RESET} for usage.`);
-      return { exitCode: 1 };
-  }
-}
-export {
-  runRemoteCommand
-};

package/dist/test/bridge-context.d.ts

@@ -1,76 +0,0 @@
-import { type DevflareConfig } from '../config';
-import { type MiniflareInstance, type MiniflareOptions } from '../bridge/miniflare';
-import { runWithContext } from '../runtime/context';
-export interface BridgeTestContextOptions {
-    /** Path to devflare.config.ts */
-    configPath?: string;
-    /** Direct config object (alternative to configPath) */
-    config?: DevflareConfig;
-    /** Miniflare options override */
-    miniflare?: Partial<MiniflareOptions>;
-    /** Port for Miniflare (default: 8787) */
-    port?: number;
-    /** Persist data between tests */
-    persist?: boolean;
-    /** Verbose logging */
-    verbose?: boolean;
-}
-export interface BridgeTestContext {
-    /** The env object with real bindings */
-    env: Record<string, unknown>;
-    /** The Miniflare instance */
-    miniflare: MiniflareInstance;
-    /** Stop the test context */
-    stop(): Promise<void>;
-    /** Reset all data (clear KV, R2, D1, etc.) */
-    reset(): Promise<void>;
-}
-/**
- * Create a test context with real Miniflare bindings
- *
- * @example
- * ```ts
- * import { createBridgeTestContext } from 'devflare'
- * import { createEnvProxy } from 'devflare'
- *
- * const bridgeEnv = createEnvProxy({ lazy: true })
- *
- * beforeAll(async () => {
- *   await createBridgeTestContext({ configPath: './devflare.config.ts' })
- * })
- *
- * afterAll(async () => {
- *   await stopBridgeTestContext()
- * })
- *
- * test('KV works', async () => {
- *   await bridgeEnv.MY_KV.put('key', 'value')
- *   expect(await bridgeEnv.MY_KV.get('key')).toBe('value')
- * })
- * ```
- */
-export declare function createBridgeTestContext(options?: BridgeTestContextOptions): Promise<BridgeTestContext>;
-/**
- * Stop the global test context
- */
-export declare function stopBridgeTestContext(): Promise<void>;
-/**
- * Get the current test context (throws if not initialized)
- */
-export declare function getBridgeTestContext(): BridgeTestContext;
-/**
- * Direct access to Miniflare bindings in tests
- *
- * @example
- * ```ts
- * import { testEnv } from 'devflare/test'
- *
- * test('KV works', async () => {
- *   const kv = testEnv.MY_KV as KVNamespace
- *   await kv.put('key', 'value')
- * })
- * ```
- */
-export declare const testEnv: Record<string, unknown>;
-export { runWithContext };
-//# sourceMappingURL=bridge-context.d.ts.map

package/dist/test/bridge-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bridge-context.d.ts","sourceRoot":"","sources":["../../src/test/bridge-context.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EAA2D,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG5I,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAMnD,MAAM,WAAW,wBAAwB;IACxC,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,uDAAuD;IACvD,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,iCAAiC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACrC,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,iCAAiC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,iBAAiB;IACjC,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,6BAA6B;IAC7B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,4BAA4B;IAC5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACrB,8CAA8C;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB;AAYD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,uBAAuB,CAC5C,OAAO,GAAE,wBAA6B,GACpC,OAAO,CAAC,iBAAiB,CAAC,CAmF5B;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAI3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CAOxD;AAMD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAM1C,CAAA;AAqBF,OAAO,EAAE,cAAc,EAAE,CAAA"}