devflare 1.0.0-next.1 → 1.0.0-next.10

package/dist/{index-pf5s73n9.js → index-59df49vn.js}

@@ -1,10 +1,3 @@
-import {
-  normalizeDOBinding
-} from "./index-hcex3rgh.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
 // src/bridge/protocol.ts
 var BinaryKind = {
   StreamChunk: 1,
@@ -1016,6 +1009,13 @@ function createAIProxy(client, bindingName) {
     }
   };
 }
+function createSendEmailProxy(client, bindingName) {
+  return {
+    async send(message) {
+      return client.call(`${bindingName}.email.send`, [message]);
+    }
+  };
+}
 var globalBindingHints = {};
 function createEnvProxy(options = {}) {
   const client = options.client ?? getClient();
@@ -1050,6 +1050,9 @@ function createEnvProxy(options = {}) {
         case "ai":
           proxy = createAIProxy(client, prop);
           break;
+        case "sendEmail":
+          proxy = createSendEmailProxy(client, prop);
+          break;
         case "secret":
         case "var":
           proxy = createSimpleBindingProxy(client, prop);
@@ -1137,277 +1140,4 @@ function setBindingHints(hints) {
   globalEnvProxy = null;
 }
 
-// src/bridge/miniflare.ts
-function generateGatewayScript() {
-  return `
-// Gateway Worker — Provides RPC access to all bindings
-export default {
-	async fetch(request, env, ctx) {
-		const url = new URL(request.url)
-		
-		// Health check
-		if (url.pathname === '/_devflare/health') {
-			return new Response(JSON.stringify({ status: 'ok', bindings: Object.keys(env) }), {
-				headers: { 'Content-Type': 'application/json' }
-			})
-		}
-		
-		// RPC endpoint
-		if (url.pathname === '/_devflare/rpc' && request.method === 'POST') {
-			try {
-				const { method, params } = await request.json()
-				const result = await executeRpc(env, method, params)
-				return new Response(JSON.stringify({ ok: true, result }), {
-					headers: { 'Content-Type': 'application/json' }
-				})
-			} catch (error) {
-				return new Response(JSON.stringify({
-					ok: false,
-					error: { code: 'RPC_ERROR', message: error.message }
-				}), {
-					status: 500,
-					headers: { 'Content-Type': 'application/json' }
-				})
-			}
-		}
-		
-		return new Response('Devflare Gateway', { status: 200 })
-	}
-}
-
-async function executeRpc(env, method, params) {
-	const [bindingName, ...methodPath] = method.split('.')
-	const binding = env[bindingName]
-	
-	if (!binding) {
-		throw new Error(\`Binding "\${bindingName}" not found\`)
-	}
-	
-	const methodName = methodPath.join('.')
-	
-	// KV operations
-	if (methodName === 'get') return binding.get(params[0], params[1])
-	if (methodName === 'put') return binding.put(params[0], params[1], params[2])
-	if (methodName === 'delete') return binding.delete(params[0])
-	if (methodName === 'list') return binding.list(params[0])
-	if (methodName === 'getWithMetadata') return binding.getWithMetadata(params[0], params[1])
-	
-	// R2 operations
-	if (methodName === 'head') return binding.head(params[0])
-	if (methodName === 'r2.get') return serializeR2Object(await binding.get(params[0], params[1]))
-	if (methodName === 'r2.put') return serializeR2Object(await binding.put(params[0], params[1], params[2]))
-	if (methodName === 'r2.delete') return binding.delete(params[0])
-	if (methodName === 'r2.list') return serializeR2Objects(await binding.list(params[0]))
-	
-	// D1 operations
-	if (methodName === 'exec') return binding.exec(params[0])
-	if (methodName === 'batch') {
-		const statements = params[0].map(s => binding.prepare(s.sql).bind(...(s.bindings || [])))
-		return binding.batch(statements)
-	}
-	if (methodName.startsWith('stmt.')) {
-		const [, stmtMethod] = methodName.split('.')
-		const [sql, ...bindings] = params
-		const stmt = binding.prepare(sql).bind(...bindings.slice(0, -1))
-		
-		if (stmtMethod === 'first') return stmt.first(bindings[bindings.length - 1])
-		if (stmtMethod === 'all') return stmt.all()
-		if (stmtMethod === 'run') return stmt.run()
-		if (stmtMethod === 'raw') return stmt.raw(bindings[bindings.length - 1])
-	}
-	
-	// DO operations
-	if (methodName === 'idFromName') {
-		const id = binding.idFromName(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'idFromString') {
-		const id = binding.idFromString(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'newUniqueId') {
-		const id = binding.newUniqueId(params[0])
-		return { __type: 'DOId', hex: id.toString() }
-	}
-	if (methodName === 'stub.fetch') {
-		const [, doId, serializedReq] = params
-		const id = binding.idFromString(doId.hex)
-		const stub = binding.get(id)
-		const response = await stub.fetch(new Request(serializedReq.url, {
-			method: serializedReq.method,
-			headers: serializedReq.headers,
-			body: serializedReq.body?.type === 'bytes' ? atob(serializedReq.body.data) : undefined
-		}))
-		return serializeResponse(response)
-	}
-	if (methodName === 'stub.rpc') {
-		// DO RPC: Call a method on the DO instance
-		const [, doId, rpcMethod, rpcParams] = params
-		const id = binding.idFromString(doId.hex)
-		const stub = binding.get(id)
-		
-		// Use fetch to call the RPC endpoint
-		const response = await stub.fetch(new Request('http://do/_rpc', {
-			method: 'POST',
-			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ method: rpcMethod, params: rpcParams })
-		}))
-		
-		const result = await response.json()
-		if (!result.ok) throw new Error(result.error?.message || 'RPC failed')
-		return result.result
-	}
-	
-	// Queue operations
-	if (methodName === 'send') return binding.send(params[0], params[1])
-	if (methodName === 'sendBatch') return binding.sendBatch(params[0], params[1])
-	
-	// Generic fallback
-	if (typeof binding[methodName] === 'function') {
-		return binding[methodName](...params)
-	}
-	
-	throw new Error(\`Unknown method: \${method}\`)
-}
-
-function serializeResponse(response) {
-	return {
-		status: response.status,
-		statusText: response.statusText,
-		headers: [...response.headers.entries()],
-		body: null // Will be streamed separately for large bodies
-	}
-}
-
-function serializeR2Object(obj) {
-	if (!obj) return null
-	return {
-		key: obj.key,
-		version: obj.version,
-		size: obj.size,
-		etag: obj.etag,
-		httpEtag: obj.httpEtag,
-		uploaded: obj.uploaded?.toISOString(),
-		httpMetadata: obj.httpMetadata,
-		customMetadata: obj.customMetadata
-	}
-}
-
-function serializeR2Objects(result) {
-	if (!result) return null
-	return {
-		objects: result.objects.map(serializeR2Object),
-		truncated: result.truncated,
-		cursor: result.cursor,
-		delimitedPrefixes: result.delimitedPrefixes
-	}
-}
-`;
-}
-async function startMiniflare(options = {}) {
-  const { Miniflare, Log, LogLevel } = await import("miniflare");
-  const port = options.port ?? 8787;
-  const persistPath = options.persistPath ?? ".devflare/data";
-  const mfConfig = {
-    modules: true,
-    script: generateGatewayScript(),
-    port,
-    host: "127.0.0.1",
-    log: options.verbose ? new Log(LogLevel.DEBUG) : new Log(LogLevel.WARN),
-    compatibilityDate: options.compatibilityDate ?? "2024-01-01",
-    compatibilityFlags: options.compatibilityFlags ?? []
-  };
-  const hasBindings = (val) => {
-    if (!val)
-      return false;
-    if (Array.isArray(val))
-      return val.length > 0;
-    return Object.keys(val).length > 0;
-  };
-  if (hasBindings(options.kvNamespaces)) {
-    mfConfig.kvNamespaces = options.kvNamespaces;
-    if (options.persist) {
-      mfConfig.kvPersist = `${persistPath}/kv`;
-    }
-  }
-  if (hasBindings(options.r2Buckets)) {
-    mfConfig.r2Buckets = options.r2Buckets;
-    if (options.persist) {
-      mfConfig.r2Persist = `${persistPath}/r2`;
-    }
-  }
-  if (hasBindings(options.d1Databases)) {
-    mfConfig.d1Databases = options.d1Databases;
-    if (options.persist) {
-      mfConfig.d1Persist = `${persistPath}/d1`;
-    }
-  }
-  if (options.durableObjects) {
-    mfConfig.durableObjects = options.durableObjects;
-    if (options.persist) {
-      mfConfig.durableObjectsPersist = `${persistPath}/do`;
-    }
-  }
-  if (options.bindings) {
-    mfConfig.bindings = options.bindings;
-  }
-  if (options.queues?.length) {
-    mfConfig.queueProducers = Object.fromEntries(options.queues.map((q) => [q, { queueName: q }]));
-  }
-  const mf = new Miniflare(mfConfig);
-  await mf.ready;
-  return {
-    ready: Promise.resolve(),
-    async dispose() {
-      await mf.dispose();
-    },
-    async getBindings() {
-      return mf.getBindings();
-    },
-    getKVNamespace: mf.getKVNamespace.bind(mf),
-    getR2Bucket: mf.getR2Bucket.bind(mf),
-    getD1Database: mf.getD1Database.bind(mf),
-    getDurableObjectNamespace: mf.getDurableObjectNamespace.bind(mf),
-    dispatchFetch: mf.dispatchFetch.bind(mf),
-    _mf: mf
-  };
-}
-async function startMiniflareFromConfig(config, options = {}) {
-  const bindings = config.bindings ?? {};
-  const mfOptions = {
-    ...options,
-    compatibilityDate: config.compatibilityDate,
-    compatibilityFlags: config.compatibilityFlags,
-    kvNamespaces: bindings.kv ? bindings.kv : undefined,
-    r2Buckets: bindings.r2 ? bindings.r2 : undefined,
-    d1Databases: bindings.d1 ? bindings.d1 : undefined,
-    queues: bindings.queues?.consumers?.map((c) => c.queue),
-    bindings: config.vars,
-    durableObjects: bindings.durableObjects ? Object.fromEntries(Object.entries(bindings.durableObjects).map(([bindingName, doConfig]) => {
-      const normalized = normalizeDOBinding(doConfig);
-      return [
-        bindingName,
-        {
-          className: normalized.className,
-          scriptPath: normalized.scriptName
-        }
-      ];
-    })) : undefined
-  };
-  return startMiniflare(mfOptions);
-}
-var globalMiniflare = null;
-async function getMiniflare(options) {
-  if (!globalMiniflare) {
-    globalMiniflare = await startMiniflare(options);
-  }
-  return globalMiniflare;
-}
-async function stopMiniflare() {
-  if (globalMiniflare) {
-    await globalMiniflare.dispose();
-    globalMiniflare = null;
-  }
-}
-
-export { BinaryKind, BinaryFlags, encodeBinaryFrame, decodeBinaryFrame, parseJsonMsg, stringifyJsonMsg, serializeValue, deserializeValue, base64Encode, base64Decode, BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints, startMiniflare, startMiniflareFromConfig, getMiniflare, stopMiniflare };
+export { BinaryKind, BinaryFlags, encodeBinaryFrame, decodeBinaryFrame, parseJsonMsg, stringifyJsonMsg, serializeValue, deserializeValue, base64Encode, base64Decode, BridgeClient, getClient, createEnvProxy, bridgeEnv, initEnv, setBindingHints };

package/dist/index-5yxg30va.js

@@ -0,0 +1,304 @@
+import {
+  wrapEnvSendEmailBindings
+} from "./index-fef08w43.js";
+
+// src/runtime/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage;
+function createLocals(locals) {
+  return locals ?? {};
+}
+function createAugmentedTarget(target, extra) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop in extra) {
+        return extra[prop];
+      }
+      const value = Reflect.get(target2, prop, target2);
+      return typeof value === "function" ? value.bind(target2) : value;
+    },
+    has(target2, prop) {
+      return prop in extra || prop in target2;
+    },
+    ownKeys(target2) {
+      return Array.from(new Set([
+        ...Reflect.ownKeys(target2),
+        ...Reflect.ownKeys(extra)
+      ]));
+    },
+    getOwnPropertyDescriptor(target2, prop) {
+      if (prop in extra) {
+        return {
+          configurable: true,
+          enumerable: true,
+          writable: false,
+          value: extra[prop]
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(target2, prop);
+    }
+  });
+}
+function createBaseEvent(type, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return {
+    type,
+    env: runtimeEnv,
+    ctx,
+    locals,
+    request: options.request ?? null,
+    params: options.params
+  };
+}
+function createFetchEvent(request, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(request, {
+    type: "fetch",
+    env: runtimeEnv,
+    ctx,
+    locals,
+    request,
+    params: options.params ?? {}
+  });
+}
+function createQueueEvent(batch, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(batch, {
+    type: "queue",
+    env: runtimeEnv,
+    ctx,
+    locals,
+    batch
+  });
+}
+function createScheduledEvent(controller, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(controller, {
+    type: "scheduled",
+    env: runtimeEnv,
+    ctx,
+    locals,
+    controller
+  });
+}
+function createEmailEvent(message, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(message, {
+    type: "email",
+    env: runtimeEnv,
+    ctx,
+    locals,
+    message
+  });
+}
+function createTailEvent(events, env, ctx, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(events, {
+    type: "tail",
+    env: runtimeEnv,
+    ctx,
+    locals,
+    events
+  });
+}
+function createDurableObjectFetchEvent(request, env, state, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(request, {
+    type: "durable-object-fetch",
+    env: runtimeEnv,
+    ctx: state,
+    state,
+    locals,
+    request
+  });
+}
+function createDurableObjectAlarmEvent(env, state, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return {
+    type: "durable-object-alarm",
+    env: runtimeEnv,
+    ctx: state,
+    state,
+    locals
+  };
+}
+function createDurableObjectWebSocketMessageEvent(ws, message, env, state, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-message",
+    env: runtimeEnv,
+    ctx: state,
+    state,
+    locals,
+    ws,
+    message
+  });
+}
+function createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, env, state, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-close",
+    env: runtimeEnv,
+    ctx: state,
+    state,
+    locals,
+    ws,
+    code,
+    reason,
+    wasClean
+  });
+}
+function createDurableObjectWebSocketErrorEvent(ws, error, env, state, options = {}) {
+  const runtimeEnv = wrapEnvSendEmailBindings(env);
+  const locals = createLocals(options.locals);
+  return createAugmentedTarget(ws, {
+    type: "durable-object-websocket-error",
+    env: runtimeEnv,
+    ctx: state,
+    state,
+    locals,
+    ws,
+    error
+  });
+}
+function createDefaultEvent(env, ctx, request, type, locals) {
+  if (type === "fetch" && request && ctx) {
+    return createFetchEvent(request, env, ctx, { locals });
+  }
+  if (type === "durable-object-fetch" && request && ctx) {
+    return createDurableObjectFetchEvent(request, env, ctx, { locals });
+  }
+  return createBaseEvent(type, env, ctx, {
+    locals,
+    request
+  });
+}
+function runWithContext(env, ctx, request, fn, type = "fetch") {
+  const locals = createLocals();
+  const event = createDefaultEvent(env, ctx, request, type, locals);
+  return runWithEventContext(event, fn);
+}
+function runWithEventContext(event, fn) {
+  const context = {
+    env: event.env,
+    ctx: event.ctx,
+    request: event.request ?? null,
+    locals: event.locals,
+    type: event.type,
+    event
+  };
+  return storage.run(context, fn);
+}
+function getContext() {
+  const context = storage.getStore();
+  if (!context) {
+    throw new ContextUnavailableError;
+  }
+  return context;
+}
+function getContextOrNull() {
+  const context = storage.getStore();
+  return context ?? null;
+}
+function getEventContext() {
+  return getContext().event;
+}
+function getEventContextOrNull() {
+  return getContextOrNull()?.event ?? null;
+}
+function hasContext() {
+  return storage.getStore() !== undefined;
+}
+function createEventAccessor(name, matcher) {
+  const accessor = () => {
+    const currentEvent = getEventContextOrNull();
+    if (!currentEvent) {
+      throw new ContextUnavailableError;
+    }
+    if (!matcher(currentEvent)) {
+      throw new ContextUnavailableError(`${name} is not available in the current '${currentEvent.type}' context.
+
+Devflare stores event objects in AsyncLocalStorage so helpers called within a handler can reach the active event.
+Use ${name}.safe() to return null instead of throwing, or call the getter that matches the active surface.`);
+    }
+    return currentEvent;
+  };
+  accessor.safe = () => {
+    const currentEvent = getEventContextOrNull();
+    return currentEvent && matcher(currentEvent) ? currentEvent : null;
+  };
+  return accessor;
+}
+function isFetchEvent(event) {
+  return event.type === "fetch" && event.request instanceof Request;
+}
+function isQueueEvent(event) {
+  return event.type === "queue" && "batch" in event;
+}
+function isScheduledEvent(event) {
+  return event.type === "scheduled" && "controller" in event;
+}
+function isEmailEvent(event) {
+  return event.type === "email" && "message" in event;
+}
+function isTailEvent(event) {
+  return event.type === "tail" && Array.isArray(event) && "events" in event;
+}
+function isDurableObjectEvent(event) {
+  return event.type.startsWith("durable-object-") && "state" in event;
+}
+function isDurableObjectFetchEvent(event) {
+  return event.type === "durable-object-fetch" && event.request instanceof Request;
+}
+function isDurableObjectAlarmEvent(event) {
+  return event.type === "durable-object-alarm";
+}
+function isDurableObjectWebSocketMessageEvent(event) {
+  return event.type === "durable-object-websocket-message" && "ws" in event && "message" in event;
+}
+function isDurableObjectWebSocketCloseEvent(event) {
+  return event.type === "durable-object-websocket-close" && "ws" in event && "code" in event;
+}
+function isDurableObjectWebSocketErrorEvent(event) {
+  return event.type === "durable-object-websocket-error" && "ws" in event && "error" in event;
+}
+var getFetchEvent = createEventAccessor("getFetchEvent()", isFetchEvent);
+var getQueueEvent = createEventAccessor("getQueueEvent()", isQueueEvent);
+var getScheduledEvent = createEventAccessor("getScheduledEvent()", isScheduledEvent);
+var getEmailEvent = createEventAccessor("getEmailEvent()", isEmailEvent);
+var getTailEvent = createEventAccessor("getTailEvent()", isTailEvent);
+var getDurableObjectEvent = createEventAccessor("getDurableObjectEvent()", isDurableObjectEvent);
+var getDurableObjectFetchEvent = createEventAccessor("getDurableObjectFetchEvent()", isDurableObjectFetchEvent);
+var getDurableObjectAlarmEvent = createEventAccessor("getDurableObjectAlarmEvent()", isDurableObjectAlarmEvent);
+var getDurableObjectWebSocketMessageEvent = createEventAccessor("getDurableObjectWebSocketMessageEvent()", isDurableObjectWebSocketMessageEvent);
+var getDurableObjectWebSocketCloseEvent = createEventAccessor("getDurableObjectWebSocketCloseEvent()", isDurableObjectWebSocketCloseEvent);
+var getDurableObjectWebSocketErrorEvent = createEventAccessor("getDurableObjectWebSocketErrorEvent()", isDurableObjectWebSocketErrorEvent);
+
+class ContextUnavailableError extends Error {
+  code = "CONTEXT_UNAVAILABLE";
+  constructor(message) {
+    super(message ?? `Context not available. Devflare uses AsyncLocalStorage to carry the active event through fetch, queue, scheduled, email, tail, and Durable Object handler call chains.
+
+` + `This usually means one of:
+
+` + `1. Accessing context at module top-level (runs at cold start, not per-request)
+` + `2. Accessing context in setTimeout/setInterval callbacks
+` + `3. Missing 'nodejs_compat' compatibility flag in your worker config
+
+` + `Fix: Move the access inside your handler, middleware, or a helper called from that handler trail.
+` + `Learn more: https://devflare.dev/docs/context-errors`);
+    this.name = "ContextUnavailableError";
+  }
+}
+
+export { createFetchEvent, createQueueEvent, createScheduledEvent, createEmailEvent, createTailEvent, createDurableObjectFetchEvent, createDurableObjectAlarmEvent, createDurableObjectWebSocketMessageEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, runWithContext, runWithEventContext, getContext, getContextOrNull, getEventContext, getEventContextOrNull, hasContext, getFetchEvent, getQueueEvent, getScheduledEvent, getEmailEvent, getTailEvent, getDurableObjectEvent, getDurableObjectFetchEvent, getDurableObjectAlarmEvent, getDurableObjectWebSocketMessageEvent, getDurableObjectWebSocketCloseEvent, getDurableObjectWebSocketErrorEvent, ContextUnavailableError };

package/dist/index-62b3gt2g.js

@@ -0,0 +1,12 @@
+// src/workerName.ts
+var workerName = (() => {
+  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
+    return __DEVFLARE_WORKER_NAME__;
+  }
+  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
+    return process.env.DEVFLARE_WORKER_NAME;
+  }
+  return "unknown";
+})();
+
+export { workerName };

package/dist/index-6h8xbs75.js

@@ -0,0 +1,44 @@
+// src/cli/package-metadata.ts
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "pathe";
+var packageMetadataPromise = null;
+async function loadPackageMetadata() {
+  let currentDir = dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    try {
+      const packageJson = await readFile(packageJsonPath, "utf8");
+      const metadata = JSON.parse(packageJson);
+      if (metadata.name === "devflare") {
+        return metadata;
+      }
+    } catch {}
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not resolve the devflare package.json file");
+    }
+    currentDir = parentDir;
+  }
+}
+async function getPackageMetadata() {
+  if (!packageMetadataPromise) {
+    packageMetadataPromise = loadPackageMetadata();
+  }
+  return packageMetadataPromise;
+}
+async function getPackageVersion() {
+  return (await getPackageMetadata()).version ?? "0.0.0";
+}
+async function getInitDependencyVersions() {
+  const metadata = await getPackageMetadata();
+  const devDependencies = metadata.devDependencies ?? {};
+  return {
+    devflare: `^${metadata.version ?? "0.0.0"}`,
+    typescript: devDependencies.typescript ?? "^5.7.0",
+    wrangler: devDependencies.wrangler ?? "^3.99.0",
+    workersTypes: devDependencies["@cloudflare/workers-types"] ?? "^4.20250109.0"
+  };
+}
+
+export { getPackageVersion, getInitDependencyVersions };