@cloudflare/vitest-pool-workers 0.2.2 → 0.2.4

package/dist/worker/lib/cloudflare/test-internal.mjs

@@ -1,739 +0,0 @@
-// src/worker/d1.ts
-function isD1Database(v) {
-  return typeof v === "object" && v !== null && v.constructor.name === "D1Database" && "prepare" in v && typeof v.prepare === "function" && "batch" in v && typeof v.batch === "function" && "exec" in v && typeof v.exec === "function";
-}
-function isD1Migration(v) {
-  return typeof v === "object" && v !== null && "name" in v && typeof v.name === "string" && "queries" in v && Array.isArray(v.queries) && v.queries.every((query) => typeof query === "string");
-}
-function isD1Migrations(v) {
-  return Array.isArray(v) && v.every(isD1Migration);
-}
-async function applyD1Migrations(db, migrations, migrationsTableName = "d1_migrations") {
-  if (!isD1Database(db)) {
-    throw new TypeError(
-      "Failed to execute 'applyD1Migrations': parameter 1 is not of type 'D1Database'."
-    );
-  }
-  if (!isD1Migrations(migrations)) {
-    throw new TypeError(
-      "Failed to execute 'applyD1Migrations': parameter 2 is not of type 'D1Migration[]'."
-    );
-  }
-  if (typeof migrationsTableName !== "string") {
-    throw new TypeError(
-      "Failed to execute 'applyD1Migrations': parameter 3 is not of type 'string'."
-    );
-  }
-  const schema = `CREATE TABLE IF NOT EXISTS ${migrationsTableName} (
-		id         INTEGER PRIMARY KEY AUTOINCREMENT,
-		name       TEXT UNIQUE,
-		applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
-	);`;
-  await db.prepare(schema).run();
-  const appliedMigrationNamesResult = await db.prepare(`SELECT name FROM ${migrationsTableName};`).all();
-  const appliedMigrationNames = appliedMigrationNamesResult.results.map(
-    ({ name }) => name
-  );
-  const insertMigrationStmt = db.prepare(
-    `INSERT INTO ${migrationsTableName} (name) VALUES (?);`
-  );
-  for (const migration of migrations) {
-    if (appliedMigrationNames.includes(migration.name))
-      continue;
-    const queries = migration.queries.map((query) => db.prepare(query));
-    queries.push(insertMigrationStmt.bind(migration.name));
-    await db.batch(queries);
-  }
-}
-
-// src/worker/durable-objects.ts
-import assert2 from "node:assert";
-
-// src/worker/env.ts
-import assert from "node:assert";
-var env;
-var SELF;
-function stripInternalEnv(internalEnv2) {
-  const result = { ...internalEnv2 };
-  delete result.__VITEST_POOL_WORKERS_SELF_NAME;
-  delete result.__VITEST_POOL_WORKERS_SELF_SERVICE;
-  delete result.__VITEST_POOL_WORKERS_LOOPBACK_SERVICE;
-  delete result.__VITEST_POOL_WORKERS_RUNNER_OBJECT;
-  delete result.__VITEST_POOL_WORKERS_UNSAFE_EVAL;
-  return result;
-}
-var internalEnv;
-function setEnv(newEnv) {
-  internalEnv = newEnv;
-  SELF = newEnv.__VITEST_POOL_WORKERS_SELF_SERVICE;
-  env = stripInternalEnv(newEnv);
-}
-function getSerializedOptions() {
-  assert(typeof __vitest_worker__ === "object", "Expected global Vitest state");
-  const options = __vitest_worker__.config?.poolOptions?.workers;
-  assert(options !== void 0, "Expected serialised options");
-  return options;
-}
-function getResolvedMainPath(forBindingType) {
-  const options = getSerializedOptions();
-  if (options.main === void 0) {
-    throw new Error(
-      `Using ${forBindingType} bindings to the current worker requires \`poolOptions.workers.main\` to be set to your worker's entrypoint`
-    );
-  }
-  return options.main;
-}
-
-// src/worker/durable-objects.ts
-var CF_KEY_ACTION = "vitestPoolWorkersDurableObjectAction";
-var nextActionId = 0;
-var kUseResponse = Symbol("kUseResponse");
-var actionResults = /* @__PURE__ */ new Map();
-function isDurableObjectNamespace(v) {
-  return typeof v === "object" && v !== null && v.constructor.name === "DurableObjectNamespace" && "newUniqueId" in v && typeof v.newUniqueId === "function" && "idFromName" in v && typeof v.idFromName === "function" && "idFromString" in v && typeof v.idFromString === "function" && "get" in v && typeof v.get === "function";
-}
-function isDurableObjectStub(v) {
-  return typeof v === "object" && v !== null && (v.constructor.name === "DurableObject" || v.constructor.name === "WorkerRpc") && "fetch" in v && typeof v.fetch === "function" && "id" in v && typeof v.id === "object";
-}
-var sameIsolatedNamespaces;
-function getSameIsolateNamespaces() {
-  if (sameIsolatedNamespaces !== void 0)
-    return sameIsolatedNamespaces;
-  sameIsolatedNamespaces = [];
-  const options = getSerializedOptions();
-  if (options.durableObjectBindingDesignators === void 0) {
-    return sameIsolatedNamespaces;
-  }
-  for (const [key, designator] of options.durableObjectBindingDesignators) {
-    if (designator.scriptName !== void 0)
-      continue;
-    const namespace = internalEnv[key];
-    assert2(
-      isDurableObjectNamespace(namespace),
-      `Expected ${key} to be a DurableObjectNamespace binding`
-    );
-    sameIsolatedNamespaces.push(namespace);
-  }
-  return sameIsolatedNamespaces;
-}
-function assertSameIsolate(stub) {
-  const idString = stub.id.toString();
-  const namespaces = getSameIsolateNamespaces();
-  for (const namespace of namespaces) {
-    try {
-      namespace.idFromString(idString);
-      return;
-    } catch {
-    }
-  }
-  throw new Error(
-    "Durable Object test helpers can only be used with stubs pointing to objects defined within the same worker."
-  );
-}
-async function runInStub(stub, callback) {
-  const id = nextActionId++;
-  actionResults.set(id, callback);
-  const response = await stub.fetch("http://x", {
-    cf: { [CF_KEY_ACTION]: id }
-  });
-  assert2(actionResults.has(id), `Expected action result for ${id}`);
-  const result = actionResults.get(id);
-  actionResults.delete(id);
-  if (result === kUseResponse) {
-    return response;
-  } else if (response.ok) {
-    return result;
-  } else {
-    throw result;
-  }
-}
-async function runInDurableObject(stub, callback) {
-  if (!isDurableObjectStub(stub)) {
-    throw new TypeError(
-      "Failed to execute 'runInDurableObject': parameter 1 is not of type 'DurableObjectStub'."
-    );
-  }
-  if (typeof callback !== "function") {
-    throw new TypeError(
-      "Failed to execute 'runInDurableObject': parameter 2 is not of type 'function'."
-    );
-  }
-  assertSameIsolate(stub);
-  return runInStub(stub, callback);
-}
-async function runAlarm(instance, state) {
-  const alarm = await state.storage.getAlarm();
-  if (alarm === null)
-    return false;
-  await state.storage.deleteAlarm();
-  await instance.alarm?.();
-  return true;
-}
-async function runDurableObjectAlarm(stub) {
-  if (!isDurableObjectStub(stub)) {
-    throw new TypeError(
-      "Failed to execute 'runDurableObjectAlarm': parameter 1 is not of type 'DurableObjectStub'."
-    );
-  }
-  return runInDurableObject(stub, runAlarm);
-}
-function runInRunnerObject(env2, callback) {
-  const stub = env2.__VITEST_POOL_WORKERS_RUNNER_OBJECT.get("singleton");
-  return runInStub(stub, callback);
-}
-function importModule(env2, specifier) {
-  return runInRunnerObject(env2, (instance) => {
-    assert2(
-      instance.executor !== void 0,
-      "Expected Vitest to start running before importing modules"
-    );
-    return instance.executor.executeId(specifier);
-  });
-}
-async function maybeHandleRunRequest(request, instance, state) {
-  const actionId = request.cf?.[CF_KEY_ACTION];
-  if (actionId === void 0)
-    return;
-  assert2(typeof actionId === "number", `Expected numeric ${CF_KEY_ACTION}`);
-  try {
-    const callback = actionResults.get(actionId);
-    assert2(typeof callback === "function", `Expected callback for ${actionId}`);
-    const result = await callback(instance, state);
-    if (result instanceof Response) {
-      actionResults.set(actionId, kUseResponse);
-      return result;
-    } else {
-      actionResults.set(actionId, result);
-    }
-    return new Response(null, { status: 204 });
-  } catch (e) {
-    actionResults.set(actionId, e);
-    return new Response(null, { status: 500 });
-  }
-}
-var DurableObjectWrapper = class {
-  constructor(state, env2, className) {
-    this.state = state;
-    this.env = env2;
-    this.className = className;
-  }
-  instanceConstructor;
-  instance;
-  async ensureInstance() {
-    const mainPath = getResolvedMainPath("Durable Object");
-    const mainModule = await importModule(this.env, mainPath);
-    const constructor = mainModule[this.className];
-    if (typeof constructor !== "function") {
-      throw new Error(
-        `${mainPath} does not export a ${this.className} Durable Object`
-      );
-    }
-    this.instanceConstructor ??= constructor;
-    if (this.instanceConstructor !== constructor) {
-      await this.state.blockConcurrencyWhile(() => {
-        throw new Error(
-          `${mainPath} changed, invalidating this Durable Object. Please retry the \`DurableObjectStub#fetch()\` call.`
-        );
-      });
-      assert2.fail("Unreachable");
-    }
-    if (this.instance === void 0) {
-      const userEnv = stripInternalEnv(this.env);
-      this.instance = new this.instanceConstructor(this.state, userEnv);
-      await this.state.blockConcurrencyWhile(async () => {
-      });
-    }
-    return this.instance;
-  }
-  async fetch(request) {
-    const instance = await this.ensureInstance();
-    const response = await maybeHandleRunRequest(request, instance, this.state);
-    if (response !== void 0)
-      return response;
-    if (instance.fetch === void 0) {
-      throw new Error("Handler does not export a fetch() function.");
-    }
-    return instance.fetch(request);
-  }
-  async alarm(...args) {
-    const instance = await this.ensureInstance();
-    return instance.alarm?.(...args);
-  }
-  async webSocketMessage(...args) {
-    const instance = await this.ensureInstance();
-    return instance.webSocketMessage?.(...args);
-  }
-  async webSocketClose(...args) {
-    const instance = await this.ensureInstance();
-    return instance.webSocketClose?.(...args);
-  }
-  async webSocketError(...args) {
-    const instance = await this.ensureInstance();
-    return instance.webSocketError?.(...args);
-  }
-};
-function createDurableObjectWrapper(className) {
-  return class extends DurableObjectWrapper {
-    constructor(state, env2) {
-      super(state, env2, className);
-    }
-  };
-}
-async function listDurableObjectIds(namespace) {
-  if (!isDurableObjectNamespace(namespace)) {
-    throw new TypeError(
-      "Failed to execute 'listDurableObjectIds': parameter 1 is not of type 'DurableObjectNamespace'."
-    );
-  }
-  const boundName = Object.entries(internalEnv).find(
-    (entry) => namespace === entry[1]
-  )?.[0];
-  assert2(boundName !== void 0, "Expected to find bound name for namespace");
-  const options = getSerializedOptions();
-  const designator = options.durableObjectBindingDesignators?.get(boundName);
-  assert2(designator !== void 0, "Expected to find designator for namespace");
-  let uniqueKey = designator.unsafeUniqueKey;
-  if (uniqueKey === void 0) {
-    const scriptName = designator.scriptName ?? internalEnv.__VITEST_POOL_WORKERS_SELF_NAME;
-    const className = designator.className;
-    uniqueKey = `${scriptName}-${className}`;
-  }
-  const url = `http://placeholder/durable-objects?unique_key=${encodeURIComponent(
-    uniqueKey
-  )}`;
-  const res = await internalEnv.__VITEST_POOL_WORKERS_LOOPBACK_SERVICE.fetch(
-    url
-  );
-  assert2.strictEqual(res.status, 200);
-  const ids = await res.json();
-  assert2(Array.isArray(ids));
-  return ids.map((id) => {
-    assert2(typeof id === "string");
-    return namespace.idFromString(id);
-  });
-}
-
-// src/worker/events.ts
-var kConstructFlag = Symbol("kConstructFlag");
-async function waitForWaitUntil(waitUntil) {
-  const errors = [];
-  while (waitUntil.length > 0) {
-    const results = await Promise.allSettled(waitUntil.splice(0));
-    for (const result of results) {
-      if (result.status === "rejected")
-        errors.push(result.reason);
-    }
-  }
-  if (errors.length === 1) {
-    throw errors[0];
-  } else if (errors.length > 1) {
-    throw new AggregateError(errors);
-  }
-}
-var globalWaitUntil = [];
-function registerGlobalWaitUntil(promise) {
-  globalWaitUntil.push(promise);
-}
-function waitForGlobalWaitUntil() {
-  return waitForWaitUntil(globalWaitUntil);
-}
-var kWaitUntil = Symbol("kWaitUntil");
-var ExecutionContext = class {
-  // https://github.com/cloudflare/workerd/blob/v1.20231218.0/src/workerd/api/global-scope.h#L168
-  [kWaitUntil] = [];
-  constructor(flag) {
-    if (flag !== kConstructFlag)
-      throw new TypeError("Illegal constructor");
-  }
-  waitUntil(promise) {
-    if (!(this instanceof ExecutionContext)) {
-      throw new TypeError("Illegal invocation");
-    }
-    this[kWaitUntil].push(promise);
-    registerGlobalWaitUntil(promise);
-  }
-  passThroughOnException() {
-  }
-};
-function createExecutionContext() {
-  return new ExecutionContext(kConstructFlag);
-}
-async function waitOnExecutionContext(ctx) {
-  if (!(ctx instanceof ExecutionContext)) {
-    throw new TypeError(
-      "Failed to execute 'getWaitUntil': parameter 1 is not of type 'ExecutionContext'.\nYou must call 'createExecutionContext()' to get an 'ExecutionContext' instance."
-    );
-  }
-  return waitForWaitUntil(ctx[kWaitUntil]);
-}
-var ScheduledController = class {
-  // https://github.com/cloudflare/workerd/blob/v1.20231218.0/src/workerd/api/scheduled.h#L35
-  scheduledTime;
-  cron;
-  constructor(flag, options) {
-    if (flag !== kConstructFlag)
-      throw new TypeError("Illegal constructor");
-    const scheduledTime = Number(options?.scheduledTime ?? Date.now());
-    const cron = String(options?.cron ?? "");
-    Object.defineProperties(this, {
-      scheduledTime: {
-        get() {
-          return scheduledTime;
-        }
-      },
-      cron: {
-        get() {
-          return cron;
-        }
-      }
-    });
-  }
-  noRetry() {
-    if (!(this instanceof ScheduledController)) {
-      throw new TypeError("Illegal invocation");
-    }
-  }
-};
-function createScheduledController(options) {
-  if (options !== void 0 && typeof options !== "object") {
-    throw new TypeError(
-      "Failed to execute 'createScheduledController': parameter 1 is not of type 'ScheduledOptions'."
-    );
-  }
-  return new ScheduledController(kConstructFlag, options);
-}
-var kRetry = Symbol("kRetry");
-var kAck = Symbol("kAck");
-var kRetryAll = Symbol("kRetryAll");
-var kAckAll = Symbol("kAckAll");
-var QueueMessage = class {
-  // https://github.com/cloudflare/workerd/blob/v1.20231218.0/src/workerd/api/queue.h#L113
-  #controller;
-  id;
-  timestamp;
-  body;
-  attempts;
-  [kRetry] = false;
-  [kAck] = false;
-  constructor(flag, controller, message) {
-    if (flag !== kConstructFlag)
-      throw new TypeError("Illegal constructor");
-    this.#controller = controller;
-    const id = String(message.id);
-    let timestamp;
-    if (typeof message.timestamp === "number") {
-      timestamp = new Date(message.timestamp);
-    } else if (message.timestamp instanceof Date) {
-      timestamp = new Date(message.timestamp.getTime());
-    } else {
-      throw new TypeError(
-        "Incorrect type for the 'timestamp' field on 'ServiceBindingQueueMessage': the provided value is not of type 'date'."
-      );
-    }
-    let attempts;
-    if (typeof message.attempts === "number") {
-      attempts = message.attempts;
-    } else {
-      throw new TypeError(
-        "Incorrect type for the 'attempts' field on 'ServiceBindingQueueMessage': the provided value is not of type 'number'."
-      );
-    }
-    if ("serializedBody" in message) {
-      throw new TypeError(
-        "Cannot use `serializedBody` with `createMessageBatch()`"
-      );
-    }
-    const body = structuredClone(message.body);
-    Object.defineProperties(this, {
-      id: {
-        get() {
-          return id;
-        }
-      },
-      timestamp: {
-        get() {
-          return timestamp;
-        }
-      },
-      body: {
-        get() {
-          return body;
-        }
-      },
-      attempts: {
-        get() {
-          return attempts;
-        }
-      }
-    });
-  }
-  retry() {
-    if (!(this instanceof QueueMessage)) {
-      throw new TypeError("Illegal invocation");
-    }
-    if (this.#controller[kRetryAll])
-      return;
-    if (this.#controller[kAckAll]) {
-      console.warn(
-        `Received a call to retry() on message ${this.id} after ackAll() was already called. Calling retry() on a message after calling ackAll() has no effect.`
-      );
-      return;
-    }
-    if (this[kAck]) {
-      console.warn(
-        `Received a call to retry() on message ${this.id} after ack() was already called. Calling retry() on a message after calling ack() has no effect.`
-      );
-      return;
-    }
-    this[kRetry] = true;
-  }
-  ack() {
-    if (!(this instanceof QueueMessage)) {
-      throw new TypeError("Illegal invocation");
-    }
-    if (this.#controller[kAckAll])
-      return;
-    if (this.#controller[kRetryAll]) {
-      console.warn(
-        `Received a call to ack() on message ${this.id} after retryAll() was already called. Calling ack() on a message after calling retryAll() has no effect.`
-      );
-      return;
-    }
-    if (this[kRetry]) {
-      console.warn(
-        `Received a call to ack() on message ${this.id} after retry() was already called. Calling ack() on a message after calling retry() has no effect.`
-      );
-      return;
-    }
-    this[kAck] = true;
-  }
-};
-var QueueController = class {
-  // https://github.com/cloudflare/workerd/blob/v1.20231218.0/src/workerd/api/queue.h#L198
-  queue;
-  messages;
-  [kRetryAll] = false;
-  [kAckAll] = false;
-  constructor(flag, queueOption, messagesOption) {
-    if (flag !== kConstructFlag)
-      throw new TypeError("Illegal constructor");
-    const queue = String(queueOption);
-    const messages = messagesOption.map(
-      (message) => new QueueMessage(kConstructFlag, this, message)
-    );
-    Object.defineProperties(this, {
-      queue: {
-        get() {
-          return queue;
-        }
-      },
-      messages: {
-        get() {
-          return messages;
-        }
-      }
-    });
-  }
-  retryAll() {
-    if (!(this instanceof QueueController)) {
-      throw new TypeError("Illegal invocation");
-    }
-    if (this[kAckAll]) {
-      console.warn(
-        "Received a call to retryAll() after ackAll() was already called. Calling retryAll() after calling ackAll() has no effect."
-      );
-      return;
-    }
-    this[kRetryAll] = true;
-  }
-  ackAll() {
-    if (!(this instanceof QueueController)) {
-      throw new TypeError("Illegal invocation");
-    }
-    if (this[kRetryAll]) {
-      console.warn(
-        "Received a call to ackAll() after retryAll() was already called. Calling ackAll() after calling retryAll() has no effect."
-      );
-      return;
-    }
-    this[kAckAll] = true;
-  }
-};
-function createMessageBatch(queueName, messages) {
-  if (arguments.length === 0) {
-    throw new TypeError(
-      "TypeError: Failed to execute 'createMessageBatch': parameter 1 is not of type 'string'."
-    );
-  }
-  if (!Array.isArray(messages)) {
-    throw new TypeError(
-      "TypeError: Failed to execute 'createMessageBatch': parameter 2 is not of type 'Array'."
-    );
-  }
-  return new QueueController(kConstructFlag, queueName, messages);
-}
-async function getQueueResult(batch, ctx) {
-  if (!(batch instanceof QueueController)) {
-    throw new TypeError(
-      "Failed to execute 'getQueueResult': parameter 1 is not of type 'MessageBatch'.\nYou must call 'createMessageBatch()' to get a 'MessageBatch' instance."
-    );
-  }
-  if (!(ctx instanceof ExecutionContext)) {
-    throw new TypeError(
-      "Failed to execute 'getQueueResult': parameter 2 is not of type 'ExecutionContext'.\nYou must call 'createExecutionContext()' to get an 'ExecutionContext' instance."
-    );
-  }
-  await waitOnExecutionContext(ctx);
-  const retryMessages = [];
-  const explicitAcks = [];
-  for (const message of batch.messages) {
-    if (message[kRetry])
-      retryMessages.push({ msgId: message.id });
-    if (message[kAck])
-      explicitAcks.push(message.id);
-  }
-  return {
-    outcome: "ok",
-    retryBatch: {
-      retry: batch[kRetryAll]
-    },
-    ackAll: batch[kAckAll],
-    retryMessages,
-    explicitAcks
-  };
-}
-
-// src/worker/fetch-mock.ts
-import assert3 from "node:assert";
-import { Buffer } from "node:buffer";
-import { isMockActive, MockAgent, setDispatcher } from "cloudflare:mock-agent";
-var DECODER = new TextDecoder();
-var fetchMock = new MockAgent({ connections: 1 });
-var requests = /* @__PURE__ */ new WeakMap();
-var responses = /* @__PURE__ */ new WeakMap();
-var originalFetch = fetch;
-setDispatcher((opts, handler) => {
-  const request = requests.get(opts);
-  assert3(request !== void 0, "Expected dispatch to come from fetch()");
-  originalFetch.call(globalThis, request.request, { body: request.body }).then((response) => {
-    responses.set(opts, response);
-    assert3(handler.onComplete !== void 0, "Expected onComplete() handler");
-    handler.onComplete?.([]);
-  }).catch((error) => {
-    assert3(handler.onError !== void 0, "Expected onError() handler");
-    handler.onError(error);
-  });
-});
-globalThis.fetch = async (input, init) => {
-  const isActive = isMockActive(fetchMock);
-  if (!isActive)
-    return originalFetch.call(globalThis, input, init);
-  const request = new Request(input, init);
-  const url = new URL(request.url);
-  if (request.headers.get("Upgrade") !== null) {
-    return originalFetch.call(globalThis, request);
-  }
-  const requestHeaders = {};
-  for (const entry of request.headers) {
-    const key = entry[0].toLowerCase();
-    const value = entry[1];
-    if (key === "set-cookie") {
-      (requestHeaders[key] ??= []).push(value);
-    } else {
-      requestHeaders[key] = value;
-    }
-  }
-  const bodyArray = request.body === null ? null : new Uint8Array(await request.arrayBuffer());
-  const bodyText = bodyArray === null ? "" : DECODER.decode(bodyArray);
-  const dispatchOptions = {
-    origin: url.origin,
-    path: url.pathname,
-    method: request.method,
-    body: bodyText,
-    headers: requestHeaders,
-    query: Object.fromEntries(url.searchParams)
-  };
-  requests.set(dispatchOptions, { request, body: bodyArray });
-  let responseStatusCode;
-  let responseStatusText;
-  let responseHeaders;
-  const responseChunks = [];
-  let responseResolve;
-  let responseReject;
-  const responsePromise = new Promise((resolve, reject) => {
-    responseResolve = resolve;
-    responseReject = reject;
-  });
-  const dispatchHandlers = {
-    onConnect(_abort) {
-    },
-    // (ignored)
-    onError(error) {
-      responseReject(error);
-    },
-    onUpgrade(_statusCode, _headers, _socket) {
-      assert3.fail("Unreachable: upgrade requests not supported");
-    },
-    // `onHeaders` and `onData` will only be called if the response was mocked
-    onHeaders(statusCode, headers, _resume, statusText) {
-      responseStatusCode = statusCode;
-      responseStatusText = statusText;
-      if (headers === null)
-        return true;
-      assert3.strictEqual(headers.length % 2, 0, "Expected key/value array");
-      responseHeaders = Array.from({ length: headers.length / 2 }).map(
-        (_, i) => [headers[i * 2].toString(), headers[i * 2 + 1].toString()]
-      );
-      return true;
-    },
-    onData(chunk) {
-      responseChunks.push(chunk);
-      return true;
-    },
-    onComplete(_trailers) {
-      const maybeResponse = responses.get(dispatchOptions);
-      if (maybeResponse === void 0) {
-        const responseBody = Buffer.concat(responseChunks);
-        const response = new Response(responseBody, {
-          status: responseStatusCode,
-          statusText: responseStatusText,
-          headers: responseHeaders
-        });
-        responseResolve(response);
-      } else {
-        responseResolve(maybeResponse);
-      }
-    },
-    onBodySent(_chunk) {
-    }
-    // (ignored)
-  };
-  fetchMock.dispatch(dispatchOptions, dispatchHandlers);
-  return responsePromise;
-};
-export {
-  SELF,
-  applyD1Migrations,
-  createDurableObjectWrapper,
-  createExecutionContext,
-  createMessageBatch,
-  createScheduledController,
-  env,
-  fetchMock,
-  getQueueResult,
-  getResolvedMainPath,
-  getSerializedOptions,
-  importModule,
-  internalEnv,
-  listDurableObjectIds,
-  maybeHandleRunRequest,
-  registerGlobalWaitUntil,
-  runDurableObjectAlarm,
-  runInDurableObject,
-  runInRunnerObject,
-  setEnv,
-  stripInternalEnv,
-  waitForGlobalWaitUntil,
-  waitOnExecutionContext
-};
-//# sourceMappingURL=test-internal.mjs.map