devflare 1.0.0-next.34 → 1.0.0-next.35

package/dist/index-4xmtkg9g.js

@@ -1,109 +0,0 @@
-// src/cloudflare/remote-config.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var MIN_MINUTES = 1;
-var MAX_MINUTES = 1440;
-function getConfigDir() {
-  return join(homedir(), ".devflare");
-}
-function getConfigPath() {
-  return join(getConfigDir(), "remote.json");
-}
-function readConfig() {
-  const path = getConfigPath();
-  if (!existsSync(path))
-    return null;
-  try {
-    const content = readFileSync(path, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function writeConfig(config) {
-  const dir = getConfigDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(getConfigPath(), JSON.stringify(config, null, "\t"));
-}
-function deleteConfig() {
-  const path = getConfigPath();
-  if (existsSync(path)) {
-    try {
-      unlinkSync(path);
-    } catch {}
-  }
-}
-function enableRemoteMode(minutes = 30) {
-  const validMinutes = Math.max(MIN_MINUTES, Math.min(MAX_MINUTES, Math.floor(minutes) || 30));
-  const now = Date.now();
-  writeConfig({
-    enabledAt: now,
-    expiresAt: now + validMinutes * 60 * 1000,
-    durationMinutes: validMinutes
-  });
-  return validMinutes;
-}
-function disableRemoteMode() {
-  deleteConfig();
-}
-function getRemoteModeStatus() {
-  const config = readConfig();
-  if (!config) {
-    return { isEnabled: false, remainingMinutes: 0, expiresAt: null };
-  }
-  const now = Date.now();
-  if (now >= config.expiresAt) {
-    deleteConfig();
-    return { isEnabled: false, remainingMinutes: 0, expiresAt: null };
-  }
-  const remainingMs = config.expiresAt - now;
-  const remainingMinutes = Math.ceil(remainingMs / 60000);
-  return {
-    isEnabled: true,
-    remainingMinutes,
-    expiresAt: new Date(config.expiresAt)
-  };
-}
-function getEffectiveRemoteModeStatus() {
-  const envValue = process.env.DEVFLARE_REMOTE ?? "";
-  const envVarSet = ["1", "true", "yes"].includes(envValue.toLowerCase());
-  if (envVarSet) {
-    return {
-      isActive: true,
-      source: "env",
-      remainingMinutes: Number.POSITIVE_INFINITY,
-      expiresAt: null,
-      envVarSet: true
-    };
-  }
-  const status = getRemoteModeStatus();
-  if (status.isEnabled) {
-    return {
-      isActive: true,
-      source: "config",
-      remainingMinutes: status.remainingMinutes,
-      expiresAt: status.expiresAt,
-      envVarSet: false
-    };
-  }
-  return {
-    isActive: false,
-    source: "none",
-    remainingMinutes: 0,
-    expiresAt: null,
-    envVarSet: false
-  };
-}
-function isRemoteModeActive() {
-  const envValue = process.env.DEVFLARE_REMOTE ?? "";
-  if (["1", "true", "yes"].includes(envValue.toLowerCase())) {
-    return true;
-  }
-  const status = getRemoteModeStatus();
-  return status.isEnabled;
-}
-
-export { enableRemoteMode, disableRemoteMode, getRemoteModeStatus, getEffectiveRemoteModeStatus, isRemoteModeActive };

package/dist/index-62b3gt2g.js

@@ -1,12 +0,0 @@
-// 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-97rfy7n2.js

@@ -1,413 +0,0 @@
-import {
-  createContextProxy,
-  createFetchEvent,
-  getContextOrNull,
-  runWithEventContext
-} from "./index-1trss579.js";
-
-// src/runtime/exports.ts
-function createReadonlyProxy(getter, name) {
-  return createContextProxy(getter, name, { mutable: false });
-}
-var env = createReadonlyProxy(() => getContextOrNull()?.env, "env");
-var vars = createReadonlyProxy(() => getContextOrNull()?.env, "vars");
-var ctx = createReadonlyProxy(() => getContextOrNull()?.ctx, "ctx");
-var event = createReadonlyProxy(() => getContextOrNull()?.event, "event");
-var locals = createContextProxy(() => getContextOrNull()?.locals, "locals");
-// src/runtime/middleware.ts
-var FETCH_SEQUENCE_SYMBOL = Symbol.for("devflare.fetch-sequence");
-var FETCH_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-style");
-var FETCH_WORKER_STYLE_SYMBOL = Symbol.for("devflare.fetch-worker-style");
-var QUEUE_WORKER_STYLE_SYMBOL = Symbol.for("devflare.queue-worker-style");
-var SCHEDULED_WORKER_STYLE_SYMBOL = Symbol.for("devflare.scheduled-worker-style");
-function createNotFoundResponse() {
-  return new Response("Not Found", { status: 404 });
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function markResolveStyle(handler) {
-  Object.defineProperty(handler, FETCH_RESOLVE_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function markWorkerStyle(handler) {
-  Object.defineProperty(handler, FETCH_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function defineFetchHandler(handler, options) {
-  if (options?.style === "resolve") {
-    return markResolveStyle(handler);
-  }
-  if (options?.style === "worker") {
-    return markWorkerStyle(handler);
-  }
-  return handler;
-}
-function hasResolveStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[FETCH_RESOLVE_STYLE_SYMBOL] || record[FETCH_SEQUENCE_SYMBOL]);
-}
-function hasWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[FETCH_WORKER_STYLE_SYMBOL]);
-}
-function isResolveStyleFunction(handler) {
-  return hasResolveStyleMarker(handler);
-}
-function assertExplicit2ArgStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasResolveStyleMarker(handler) || hasWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument fetch handler. The calling convention must be declared explicitly via " + "`defineFetchHandler(fn, { style: 'resolve' })` (for `(event, resolve) => Response`) or " + "`defineFetchHandler(fn, { style: 'worker' })` (for `(request, env) => Response`). " + "Single-arg `(event) => Response` and 3-arg worker-style `(request, env, ctx) => Response` " + "handlers do not require wrapping.");
-}
-function defineQueueHandler(handler) {
-  Object.defineProperty(handler, QUEUE_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function defineScheduledHandler(handler) {
-  Object.defineProperty(handler, SCHEDULED_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function hasQueueWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[QUEUE_WORKER_STYLE_SYMBOL]);
-}
-function hasScheduledWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[SCHEDULED_WORKER_STYLE_SYMBOL]);
-}
-function assertExplicitQueueHandlerStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasQueueWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument queue handler. The calling convention must be declared explicitly via " + "`defineQueueHandler(fn)` for `(batch, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(batch, env, ctx) => void` handlers do not require wrapping.");
-}
-function assertExplicitScheduledHandlerStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasScheduledWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument scheduled handler. The calling convention must be declared explicitly via " + "`defineScheduledHandler(fn)` for `(controller, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(controller, env, ctx) => void` handlers do not require wrapping.");
-}
-function isWorkerStyleFetchFunction(handler) {
-  if (isResolveStyleFunction(handler)) {
-    return false;
-  }
-  if (handler.length >= 3) {
-    return true;
-  }
-  return hasWorkerStyleMarker(handler);
-}
-function invokeWorkerStyleFetchFunction(handler, event2) {
-  return handler(event2.request, event2.env, event2.ctx);
-}
-function bindMethod(target, key) {
-  if (!target || typeof target !== "object") {
-    return null;
-  }
-  const value = target[key];
-  if (!isFunction(value)) {
-    return null;
-  }
-  const boundHandler = value.bind(target);
-  if (isResolveStyleFunction(value)) {
-    markResolveStyle(boundHandler);
-  }
-  if (hasWorkerStyleMarker(value)) {
-    markWorkerStyle(boundHandler);
-  }
-  return boundHandler;
-}
-function createFetchSequence(middlewares) {
-  return async (event2, resolve = async () => createNotFoundResponse()) => {
-    const executeMiddleware = async (index, activeEvent) => {
-      if (index >= middlewares.length) {
-        return resolve(activeEvent);
-      }
-      const middleware = middlewares[index];
-      return middleware(activeEvent, async (nextEvent = activeEvent) => {
-        return executeMiddleware(index + 1, nextEvent);
-      });
-    };
-    return executeMiddleware(0, event2);
-  };
-}
-function sequence(...middlewares) {
-  const composed = createFetchSequence(middlewares);
-  Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return markResolveStyle(composed);
-}
-function getDefaultHandleHandler(module) {
-  return bindMethod(module.default, "handle");
-}
-function getDefaultFetchHandler(module) {
-  const defaultExport = module.default;
-  if (isFunction(defaultExport)) {
-    return defaultExport;
-  }
-  return bindMethod(defaultExport, "fetch");
-}
-function getPrimaryFetchEntryCandidates(module) {
-  const candidates = [];
-  const namedHandle = isFunction(module.handle) ? module.handle : null;
-  if (namedHandle) {
-    candidates.push({
-      name: "handle",
-      handler: namedHandle
-    });
-  }
-  const namedFetch = isFunction(module.fetch) ? module.fetch : null;
-  if (namedFetch) {
-    candidates.push({
-      name: "fetch",
-      handler: namedFetch
-    });
-  }
-  const defaultHandle = getDefaultHandleHandler(module);
-  if (defaultHandle) {
-    candidates.push({
-      name: "default.handle",
-      handler: defaultHandle
-    });
-  }
-  const defaultFetch = getDefaultFetchHandler(module);
-  if (defaultFetch) {
-    candidates.push({
-      name: isFunction(module.default) ? "default" : "default.fetch",
-      handler: defaultFetch
-    });
-  }
-  return candidates;
-}
-function assertSinglePrimaryFetchEntry(candidates) {
-  if (candidates.length <= 1) {
-    return;
-  }
-  const foundEntries = candidates.map(({ name }) => `"${name}"`).join(", ");
-  throw new Error(`Ambiguous fetch entry module. Export exactly one primary fetch entry per module. ` + `Use either "fetch" or "handle" (or one default equivalent), not both. ` + `Found: ${foundEntries}`);
-}
-function resolveMethodHandler(module, method) {
-  const normalizedMethod = method.toUpperCase();
-  const directHandler = isFunction(module[normalizedMethod]) ? module[normalizedMethod] : bindMethod(module.default, normalizedMethod);
-  if (directHandler) {
-    return {
-      handler: directHandler,
-      stripBody: false
-    };
-  }
-  if (normalizedMethod === "HEAD") {
-    const getHandler = isFunction(module.GET) ? module.GET : bindMethod(module.default, "GET");
-    if (getHandler) {
-      return {
-        handler: getHandler,
-        stripBody: true
-      };
-    }
-  }
-  const allHandler = isFunction(module.ALL) ? module.ALL : bindMethod(module.default, "ALL");
-  if (allHandler) {
-    return {
-      handler: allHandler,
-      stripBody: false
-    };
-  }
-  return null;
-}
-async function invokeResolvedFetchHandler(handler, event2) {
-  if (isResolveStyleFunction(handler)) {
-    return handler(event2, async () => createNotFoundResponse());
-  }
-  if (isWorkerStyleFetchFunction(handler)) {
-    return invokeWorkerStyleFetchFunction(handler, event2);
-  }
-  assertExplicit2ArgStyle(handler);
-  return handler(event2);
-}
-function resolveFetchHandler(module) {
-  const candidates = getPrimaryFetchEntryCandidates(module);
-  assertSinglePrimaryFetchEntry(candidates);
-  return candidates[0]?.handler ?? null;
-}
-async function invokeFetchHandler(handler, event2, resolve = async () => createNotFoundResponse()) {
-  if (!isFunction(handler)) {
-    return resolve(event2);
-  }
-  if (isResolveStyleFunction(handler)) {
-    const response2 = await handler(event2, resolve);
-    return response2 ?? createNotFoundResponse();
-  }
-  if (isWorkerStyleFetchFunction(handler)) {
-    const response2 = await invokeWorkerStyleFetchFunction(handler, event2);
-    return response2 ?? createNotFoundResponse();
-  }
-  assertExplicit2ArgStyle(handler);
-  const response = await handler(event2);
-  return response ?? createNotFoundResponse();
-}
-function createResolveFetch(module, _currentEntry, initialEvent, options = {}) {
-  return async (nextEvent = initialEvent) => {
-    return runWithEventContext(nextEvent, async () => {
-      const methodResolution = resolveMethodHandler(module, nextEvent.request.method);
-      if (methodResolution) {
-        const response = await invokeResolvedFetchHandler(methodResolution.handler, nextEvent);
-        const finalResponse = response ?? createNotFoundResponse();
-        if (methodResolution.stripBody) {
-          return new Response(null, finalResponse);
-        }
-        return finalResponse;
-      }
-      if (options.fallbackResolve) {
-        return options.fallbackResolve(nextEvent);
-      }
-      return createNotFoundResponse();
-    });
-  };
-}
-async function invokeFetchModule(module, event2, fallbackResolve) {
-  const handler = resolveFetchHandler(module);
-  if (!handler) {
-    return createResolveFetch(module, null, event2, { fallbackResolve })(event2);
-  }
-  return invokeFetchHandler(handler, event2, createResolveFetch(module, handler, event2, { fallbackResolve }));
-}
-// src/runtime/router/index.ts
-function normalizePathname(pathname) {
-  if (!pathname || pathname === "/") {
-    return "/";
-  }
-  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  const trimmed = normalized.replace(/\/+$|\/+$/g, "");
-  return trimmed === "" ? "/" : trimmed;
-}
-function decodePathSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-function getPathSegments(pathname) {
-  const normalizedPathname = normalizePathname(pathname);
-  if (normalizedPathname === "/") {
-    return [];
-  }
-  return normalizedPathname.slice(1).split("/").filter(Boolean).map(decodePathSegment);
-}
-function getMatchPathname(input) {
-  if (input instanceof Request) {
-    return new URL(input.url).pathname;
-  }
-  if (input instanceof URL) {
-    return input.pathname;
-  }
-  if (input.includes("://")) {
-    return new URL(input).pathname;
-  }
-  return input;
-}
-function matchRouteSegments(routeSegments, pathnameSegments) {
-  if (routeSegments.length === 0) {
-    return pathnameSegments.length === 0 ? {} : null;
-  }
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    if (routeSegment.type === "optional-rest") {
-      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
-      pathIndex = pathnameSegments.length;
-      routeIndex += 1;
-      continue;
-    }
-    if (routeSegment.type === "rest") {
-      if (pathIndex >= pathnameSegments.length) {
-        return null;
-      }
-      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
-      pathIndex = pathnameSegments.length;
-      routeIndex += 1;
-      continue;
-    }
-    const pathnameSegment = pathnameSegments[pathIndex];
-    if (pathnameSegment === undefined) {
-      return null;
-    }
-    if (routeSegment.type === "static") {
-      if (pathnameSegment !== routeSegment.value) {
-        return null;
-      }
-    } else {
-      params[routeSegment.name] = pathnameSegment;
-    }
-    pathIndex += 1;
-    routeIndex += 1;
-  }
-  if (pathIndex !== pathnameSegments.length) {
-    return null;
-  }
-  return params;
-}
-function matchFetchRoute(routes, input) {
-  const pathnameSegments = getPathSegments(getMatchPathname(input));
-  for (const route of routes) {
-    const params = matchRouteSegments(route.segments, pathnameSegments);
-    if (params) {
-      return {
-        route,
-        params
-      };
-    }
-  }
-  return null;
-}
-async function invokeRouteModules(routes, event2) {
-  const match = matchFetchRoute(routes, event2.request);
-  if (!match) {
-    return new Response("Not Found", { status: 404 });
-  }
-  const routeEvent = createFetchEvent(event2.request, event2.env, event2.ctx, {
-    params: match.params,
-    locals: event2.locals
-  });
-  return runWithEventContext(routeEvent, () => invokeFetchModule(match.route.module, routeEvent));
-}
-function createRouteResolve(routes, initialEvent) {
-  return async (nextEvent = initialEvent) => {
-    return invokeRouteModules(routes, nextEvent);
-  };
-}
-export { env, vars, ctx, event, locals, markResolveStyle, markWorkerStyle, defineFetchHandler, defineQueueHandler, defineScheduledHandler, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, sequence, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };

package/dist/index-c4zd39tc.js

@@ -1,155 +0,0 @@
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/test/binding-hints.ts
-function extractBindingHints(config) {
-  const hints = {};
-  if (config.bindings?.kv) {
-    for (const name of Object.keys(config.bindings.kv)) {
-      hints[name] = "kv";
-    }
-  }
-  if (config.bindings?.r2) {
-    for (const name of Object.keys(config.bindings.r2)) {
-      hints[name] = "r2";
-    }
-  }
-  if (config.bindings?.d1) {
-    for (const name of Object.keys(config.bindings.d1)) {
-      hints[name] = "d1";
-    }
-  }
-  if (config.bindings?.durableObjects) {
-    for (const name of Object.keys(config.bindings.durableObjects)) {
-      hints[name] = "do";
-    }
-  }
-  if (config.bindings?.services) {
-    for (const name of Object.keys(config.bindings.services)) {
-      hints[name] = "service";
-    }
-  }
-  if (config.bindings?.queues?.consumers) {
-    for (const consumer of config.bindings.queues.consumers) {
-      hints[consumer.queue] = "queue";
-    }
-  }
-  if (config.bindings?.queues?.producers) {
-    for (const name of Object.keys(config.bindings.queues.producers)) {
-      hints[name] = "queue";
-    }
-  }
-  if (config.bindings?.ai) {
-    hints[config.bindings.ai.binding] = "ai";
-  }
-  if (config.bindings?.sendEmail) {
-    for (const name of Object.keys(config.bindings.sendEmail)) {
-      hints[name] = "sendEmail";
-    }
-  }
-  if (config.bindings?.workflows) {
-    for (const name of Object.keys(config.bindings.workflows)) {
-      hints[name] = "workflow";
-    }
-  }
-  return hints;
-}
-
-// src/shims/local-hyperdrive.ts
-var HYPERDRIVE_CONNECT_MESSAGE = "Local Hyperdrive does not implement the raw socket connect(). " + "Use the populated connection fields (connectionString, or host/port/user/password/database) " + "with your Node database driver, or run a createTestContext()/Miniflare-backed test " + "(Miniflare establishes real Hyperdrive socket connections) for socket-level behavior.";
-function defaultPortForDatabaseUrl(url) {
-  if (url.port) {
-    return Number(url.port);
-  }
-  return url.protocol === "mysql:" ? 3306 : 5432;
-}
-function createLocalHyperdrive(connectionString) {
-  const url = new URL(connectionString);
-  return {
-    connectionString,
-    host: url.hostname,
-    port: defaultPortForDatabaseUrl(url),
-    user: decodeURIComponent(url.username),
-    password: decodeURIComponent(url.password),
-    database: decodeURIComponent(url.pathname.replace(/^\//, "")),
-    connect() {
-      throw new Error(HYPERDRIVE_CONNECT_MESSAGE);
-    }
-  };
-}
-
-// src/shims/local-worker-loader.ts
-var activeWorkerLoaderRuntimes = new Set;
-function getModuleSource(module, mainModule) {
-  if (typeof module === "string") {
-    return module;
-  }
-  if (module && typeof module === "object" && typeof module.js === "string") {
-    return module.js;
-  }
-  throw new Error(`Worker Loader local shim only supports JavaScript main modules. Could not load "${mainModule}".`);
-}
-function createRequestInit(request) {
-  return {
-    method: request.method,
-    headers: request.headers,
-    body: request.body
-  };
-}
-async function createRuntime(code) {
-  const { Miniflare } = await import("miniflare");
-  const mainModule = code.mainModule;
-  const script = getModuleSource(code.modules[mainModule], mainModule);
-  const miniflare = new Miniflare({
-    modules: true,
-    compatibilityDate: code.compatibilityDate,
-    ...code.compatibilityFlags && { compatibilityFlags: code.compatibilityFlags },
-    ...code.env && { bindings: code.env },
-    script
-  });
-  await miniflare.ready;
-  activeWorkerLoaderRuntimes.add(miniflare);
-  return miniflare;
-}
-function createLocalWorkerStub(codeProvider) {
-  let runtimePromise = null;
-  const getRuntime = () => {
-    runtimePromise ??= Promise.resolve(codeProvider()).then(createRuntime);
-    return runtimePromise;
-  };
-  const fetcher = {
-    async fetch(input, init) {
-      const request = input instanceof Request ? input : new Request(input, init);
-      const runtime = await getRuntime();
-      return runtime.dispatchFetch(request.url, createRequestInit(request));
-    }
-  };
-  return {
-    getEntrypoint() {
-      return fetcher;
-    },
-    getDurableObjectClass() {
-      throw new Error("Worker Loader local shim cannot materialise a dynamic Durable Object class. getDurableObjectClass() returns an opaque facet-spawning reference that workerd only exposes inside the runtime. Use createTestContext() (a real Miniflare worker) for Durable Object behavior, or createMockWorkerLoader({ stub }) to inject a stub.");
-    }
-  };
-}
-function createLocalWorkerLoaderBinding() {
-  return {
-    get(_name, getCode) {
-      return createLocalWorkerStub(getCode);
-    },
-    load(code) {
-      return createLocalWorkerStub(() => code);
-    }
-  };
-}
-async function disposeLocalWorkerLoaderBindings() {
-  const runtimes = Array.from(activeWorkerLoaderRuntimes);
-  activeWorkerLoaderRuntimes.clear();
-  await Promise.all(runtimes.map(async (runtime) => {
-    await runtime.dispose();
-  }));
-}
-
-export { extractBindingHints, createLocalWorkerLoaderBinding, disposeLocalWorkerLoaderBindings, createLocalHyperdrive };