@statewalker/cellb 0.0.0-stage → 0.1.0

package/vendor/miniflare/d1-api.js

@@ -0,0 +1,738 @@
+// GENERATED by scripts/vendor-miniflare.mjs from cloudflare/workerd@2e36a384412f6eb5ccec513635728041b5da9533 src/cloudflare/internal/d1-api.ts (Apache-2.0). Do not edit.
+
+// src/miniflare-compat/shims/workerd-globals.ts
+var g = globalThis;
+if (typeof g.IdentityTransformStream === "undefined") {
+  g.IdentityTransformStream = class IdentityTransformStream extends TransformStream {
+  };
+}
+var BYOB = globalThis.ReadableStreamBYOBReader;
+if (BYOB && typeof BYOB.prototype.readAtLeast !== "function") {
+  BYOB.prototype.readAtLeast = async function readAtLeast(min, view) {
+    let offset = 0;
+    let buffer = view.buffer;
+    while (offset < min) {
+      const { value, done } = await this.read(
+        new Uint8Array(buffer, view.byteOffset + offset, view.byteLength - offset)
+      );
+      if (value) {
+        buffer = value.buffer;
+        offset += value.byteLength;
+      }
+      if (done)
+        return { value: new Uint8Array(buffer, view.byteOffset, offset), done: offset === 0 };
+    }
+    return { value: new Uint8Array(buffer, view.byteOffset, offset), done: false };
+  };
+}
+
+// src/miniflare-compat/shims/workerd-performance.ts
+var real = globalThis.performance;
+
+// src/miniflare-compat/shims/workerd-cloudflare.ts
+var Cloudflare = { compatibilityFlags: {} };
+
+// src/miniflare-compat/shims/workerd-internal.ts
+var WrappedBinding = class {
+  // biome-ignore lint/complexity/noUselessConstructor: mirrors workerd's signature
+  constructor(_inner) {
+  }
+};
+var workerd_internal_default = { WrappedBinding };
+var noopSpan = {
+  setAttribute() {
+  },
+  setAttributes() {
+  },
+  end() {
+  }
+};
+function withSpan(_name, fn) {
+  return fn(noopSpan);
+}
+
+// ../../../../../tmp/wd/src/cloudflare/internal/d1-api.ts
+var d1BindingJsrpc = !!Cloudflare.compatibilityFlags["d1_binding_jsrpc"];
+var D1_SESSION_CONSTRAINT_FIRST_PRIMARY = "first-primary";
+var D1_SESSION_CONSTRAINT_FIRST_UNCONSTRAINED = "first-unconstrained";
+var D1_SESSION_COMMIT_TOKEN_HTTP_HEADER = "x-cf-d1-session-commit-token";
+var D1Database = class extends workerd_internal_default.WrappedBinding {
+  // TODO(soon): Can we use the # syntax here?
+  // eslint-disable-next-line no-restricted-syntax
+  alwaysPrimarySession;
+  fetcher;
+  constructor(fetcher) {
+    super(fetcher);
+    this.fetcher = fetcher;
+    this.alwaysPrimarySession = new D1DatabaseSessionAlwaysPrimary(
+      this.fetcher
+    );
+  }
+  prepare(query) {
+    return new D1PreparedStatement(this.alwaysPrimarySession, query);
+  }
+  async batch(statements) {
+    return this.alwaysPrimarySession.batch(statements);
+  }
+  async exec(query) {
+    return this.alwaysPrimarySession.exec(query);
+  }
+  withSession(constraintOrBookmark) {
+    constraintOrBookmark = constraintOrBookmark?.trim();
+    if (constraintOrBookmark == null || constraintOrBookmark === "") {
+      constraintOrBookmark = D1_SESSION_CONSTRAINT_FIRST_UNCONSTRAINED;
+    }
+    return new D1DatabaseSession(this.fetcher, constraintOrBookmark);
+  }
+  /**
+   * Send one or more SQL queries directly to D1 and return raw rows-and-columns results.
+   *
+   * Unlike `prepare().all()`, `prepare().raw()`, `prepare().first()`, or
+   * `batch()`, this method does not reshape rows into objects or apply the
+   * public convenience return types. It returns the lower-level D1 response
+   * format so callers can inspect result metadata and manage session bookmarks
+   * directly.
+   *
+   * Successful responses contain `results` and an optional `bookmark`. Errors
+   * are thrown without binding-level wrapping.
+   * Legacy RpcResponse support is temporary (CFSQL-1814) and will be removed
+   * once the D1 eyeball entrypoint returns direct successes and throws errors.
+   *
+   * @example
+   * ```
+   * await env.D1.query({
+   *   queries: [{ sql: "select * from users where id=?", params: [1] }],
+   *   bookmark: "<insert_bookmark>"
+   * });
+   * ```
+   */
+  async query(request) {
+    if (!d1BindingJsrpc) {
+      const message = "D1Database.query() requires the d1_binding_jsrpc compatibility flag. Enable d1_binding_jsrpc before calling query().";
+      throw new Error(`D1_ERROR: ${message}`);
+    }
+    return await fetcherQuery(this.fetcher, request);
+  }
+  /**
+   * @deprecated
+   */
+  async dump() {
+    return this.alwaysPrimarySession.dump();
+  }
+};
+var D1DatabaseSession = class {
+  fetcher;
+  bookmarkOrConstraint;
+  constructor(fetcher, bookmarkOrConstraint) {
+    this.fetcher = fetcher;
+    if (bookmarkOrConstraint == null) {
+      this.bookmarkOrConstraint = null;
+    } else {
+      this.bookmarkOrConstraint = bookmarkOrConstraint.trim();
+      if (!this.bookmarkOrConstraint) {
+        throw new Error("D1_SESSION_ERROR: invalid bookmark or constraint");
+      }
+    }
+  }
+  // Update the bookmark IFF the given newBookmark is more recent.
+  // The bookmark held in the session should always be the latest value we
+  // have observed in the responses to our API. There can be cases where we have concurrent
+  // queries running within the same session, and therefore here we ensure we only
+  // retain the latest bookmark received.
+  // @returns the final bookmark after the update.
+  _updateBookmark(newBookmark) {
+    newBookmark = newBookmark.trim();
+    if (!newBookmark) {
+      return this.getBookmark();
+    }
+    const currentBookmark = this.getBookmark();
+    if (currentBookmark === null || currentBookmark.localeCompare(newBookmark) < 0) {
+      this.bookmarkOrConstraint = newBookmark;
+    }
+    return this.getBookmark();
+  }
+  prepare(sql) {
+    return new D1PreparedStatement(this, sql);
+  }
+  async batch(statements) {
+    return withSpan("d1_batch", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "batch",
+        "db.query.text": (
+          // TODO: Joining all the statement without truncating it can lead to truncated
+          // span tags. We should find out if that's the case and where is the limit, and
+          // then decide if we need to truncate it ourselves.
+          statements.map((s) => s.statement).join("\n")
+        ),
+        "db.operation.batch.size": statements.length,
+        "cloudflare.binding.type": "D1",
+        "cloudflare.d1.query.bookmark": this.getBookmark() ?? void 0
+      });
+      const exec = d1BindingJsrpc ? await this._queryOrThrow(
+        {
+          queries: statements.map((s) => ({
+            sql: s.statement,
+            params: s.params
+          }))
+        },
+        span
+      ) : await this._sendOrThrow(
+        "/query",
+        statements.map((s) => s.statement),
+        statements.map((s) => s.params),
+        "ROWS_AND_COLUMNS",
+        span
+      );
+      span.setAttributes({
+        "cloudflare.d1.response.bookmark": this.getBookmark() ?? void 0
+      });
+      addAggregatedD1MetaToSpan(
+        span,
+        exec.map((e) => e.meta)
+      );
+      return exec.map(toArrayOfObjects);
+    });
+  }
+  // Returns the latest bookmark we received from all responses processed so far.
+  // It does not return constraints that might have be passed during the session creation.
+  getBookmark() {
+    switch (this.bookmarkOrConstraint) {
+      // First to any replica, and then anywhere that satisfies the bookmark.
+      case D1_SESSION_CONSTRAINT_FIRST_UNCONSTRAINED:
+        return null;
+      // First to primary, and then anywhere that satisfies the bookmark.
+      case D1_SESSION_CONSTRAINT_FIRST_PRIMARY:
+        return null;
+      default:
+        return this.bookmarkOrConstraint;
+    }
+  }
+  // fetch will append the bookmark header to all outgoing fetch calls.
+  // The response headers are parsed automatically, extracting the bookmark
+  // from the response headers and updating it through `_updateBookmark(token)`.
+  async _wrappedFetch(input, init) {
+    const h = new Headers(init?.headers);
+    if (this.bookmarkOrConstraint) {
+      h.set(D1_SESSION_COMMIT_TOKEN_HTTP_HEADER, this.bookmarkOrConstraint);
+    }
+    if (!init) {
+      init = { headers: h };
+    } else {
+      init.headers = h;
+    }
+    return this.fetcher.fetch(input, init).then((resp) => {
+      const newBookmark = resp.headers.get(D1_SESSION_COMMIT_TOKEN_HTTP_HEADER);
+      if (newBookmark) {
+        this._updateBookmark(newBookmark);
+      }
+      return resp;
+    });
+  }
+  async _sendOrThrow(endpoint, query, params, resultsFormat, span) {
+    const results = await this._send(
+      endpoint,
+      query,
+      params,
+      resultsFormat,
+      span
+    );
+    const firstResult = firstIfArray(results);
+    if (!firstResult.success) {
+      span.setAttribute("error.type", firstResult.error);
+      throw new Error(`D1_ERROR: ${firstResult.error}`, {
+        cause: new Error(firstResult.error)
+      });
+    } else {
+      return results;
+    }
+  }
+  async _send(endpoint, query, params, resultsFormat, span) {
+    const body = JSON.stringify(
+      Array.isArray(query) ? query.map((s, index) => {
+        return { sql: s, params: params[index] };
+      }) : {
+        sql: query,
+        params
+      }
+    );
+    const url = new URL(endpoint, "http://d1");
+    url.searchParams.set("resultsFormat", resultsFormat);
+    const response = await this._wrappedFetch(url.href, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body
+    });
+    try {
+      const answer = await toJson(response);
+      if (Array.isArray(answer)) {
+        return answer.map((r) => mapD1Result(r));
+      } else {
+        return mapD1Result(answer);
+      }
+    } catch (_e) {
+      const e = _e;
+      const message = e.cause?.message || e.message || "Something went wrong";
+      span.setAttribute("error.type", message);
+      throw new Error(`D1_ERROR: ${message}`, {
+        cause: new Error(message)
+      });
+    }
+  }
+  async _queryOrThrow(request, span, errorPrefix = "D1_ERROR") {
+    try {
+      const queryParams = this.bookmarkOrConstraint ? { ...request, bookmark: this.bookmarkOrConstraint } : request;
+      const response = await fetcherQuery(this.fetcher, queryParams);
+      if (response.bookmark) {
+        this._updateBookmark(response.bookmark);
+      }
+      return response.results.map(mapQueryResult);
+    } catch (e) {
+      const message = Error.isError(e) ? e.message : String(e);
+      span.setAttribute("error.type", message);
+      throw new Error(`${errorPrefix}: ${message}`, { cause: e });
+    }
+  }
+};
+var D1DatabaseSessionAlwaysPrimary = class extends D1DatabaseSession {
+  constructor(fetcher) {
+    super(fetcher, null);
+  }
+  // We ignore bookmarks for this special type of session,
+  // since all queries are sent to the primary.
+  _updateBookmark(_newBookmark) {
+    return null;
+  }
+  // There is no bookmark returned ever by this special type of session,
+  // since all queries are sent to the primary.
+  getBookmark() {
+    return null;
+  }
+  //////////////////////////////////////////////////////////////////////////////////////////////
+  // These are only used by the D1Database which is our existing API pre-Sessions API.
+  // For backwards compatibility they always go to the primary database.
+  //
+  async exec(query) {
+    return withSpan("d1_exec", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "exec",
+        "db.query.text": query,
+        "cloudflare.binding.type": "D1"
+      });
+      const lines = query.trim().split("\n");
+      let execResults;
+      if (d1BindingJsrpc) {
+        execResults = await this._queryOrThrow(
+          { queries: lines.map((sql) => ({ sql })) },
+          span,
+          "D1_EXEC_ERROR"
+        );
+      } else {
+        execResults = await this._send("/execute", lines, [], "NONE", span);
+      }
+      const results = Array.isArray(execResults) ? execResults : [execResults];
+      let duration = 0;
+      const metas = [];
+      for (const [i, res] of results.entries()) {
+        if (!res.success) {
+          const message = res.error || "Something went wrong";
+          const lineNumber = i + 1;
+          const line = lines[lineNumber - 1];
+          const legacyMessage = `Error in line ${lineNumber}: ${line}: ${message}`;
+          span.setAttribute("error.type", `Error in line ${lineNumber}`);
+          throw new Error(`D1_EXEC_ERROR: ${legacyMessage}`, {
+            cause: new Error(legacyMessage)
+          });
+        }
+        duration += res.meta.duration;
+        metas.push(res.meta);
+      }
+      if (metas.length) {
+        addAggregatedD1MetaToSpan(span, metas);
+      }
+      return {
+        count: results.length,
+        duration
+      };
+    });
+  }
+  /**
+   * DEPRECATED, TO BE REMOVED WITH NEXT BREAKING CHANGE
+   * Only applies to the deprecated v1 alpha databases.
+   */
+  async dump() {
+    const response = await this._wrappedFetch("http://d1/dump", {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      }
+    });
+    if (response.status !== 200) {
+      try {
+        const err = await response.json();
+        throw new Error(`D1_DUMP_ERROR: ${err.error}`, {
+          cause: new Error(err.error)
+        });
+      } catch {
+        throw new Error(`D1_DUMP_ERROR: Status + ${response.status}`, {
+          cause: new Error(`Status ${response.status}`)
+        });
+      }
+    }
+    return await response.arrayBuffer();
+  }
+};
+var D1PreparedStatement = class _D1PreparedStatement {
+  // TODO(soon): Can we use the # syntax here?
+  // eslint-disable-next-line no-restricted-syntax
+  dbSession;
+  statement;
+  params;
+  constructor(dbSession, statement, values) {
+    this.dbSession = dbSession;
+    this.statement = statement;
+    this.params = values || [];
+  }
+  bind(...values) {
+    const transformedValues = values.map((r) => {
+      const rType = typeof r;
+      if (rType === "number" || rType === "string") {
+        return r;
+      } else if (rType === "boolean") {
+        return r ? 1 : 0;
+      } else if (rType === "object") {
+        if (r == null) return r;
+        if (Array.isArray(r) && r.every((b) => {
+          return typeof b == "number" && b >= 0 && b < 256;
+        }))
+          return r;
+        if (r instanceof ArrayBuffer) {
+          return Array.from(new Uint8Array(r));
+        }
+        if (ArrayBuffer.isView(r)) {
+          return Array.from(r);
+        }
+      }
+      throw new Error(
+        `D1_TYPE_ERROR: Type '${rType}' not supported for value '${r}'`,
+        {
+          cause: new Error(`Type '${rType}' not supported for value '${r}'`)
+        }
+      );
+    });
+    return new _D1PreparedStatement(
+      this.dbSession,
+      this.statement,
+      transformedValues
+    );
+  }
+  async first(colName) {
+    return withSpan("d1_first", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "first",
+        "db.query.text": this.statement,
+        "cloudflare.binding.type": "D1",
+        "cloudflare.d1.query.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      const info = firstIfArray(
+        d1BindingJsrpc ? await this.dbSession._queryOrThrow(
+          { queries: [{ sql: this.statement, params: this.params }] },
+          span
+        ) : await this.dbSession._sendOrThrow(
+          "/query",
+          this.statement,
+          this.params,
+          "ROWS_AND_COLUMNS",
+          span
+        )
+      );
+      span.setAttributes({
+        "cloudflare.d1.response.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      addD1MetaToSpan(span, info.meta);
+      const results = toArrayOfObjects(info).results;
+      const hasResults = results.length > 0;
+      if (!hasResults) return null;
+      const firstResult = results.at(0);
+      if (colName !== void 0) {
+        if (firstResult?.[colName] === void 0) {
+          span.setAttribute("error.type", "Column not found");
+          throw new Error(`D1_COLUMN_NOTFOUND: Column not found (${colName})`, {
+            cause: new Error("Column not found")
+          });
+        }
+        return firstResult[colName];
+      } else {
+        return firstResult;
+      }
+    });
+  }
+  // TODO: Update this return type because we always includes a `results` array
+  // and people are relying on that.
+  /* eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters */
+  async run() {
+    return withSpan("d1_run", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "run",
+        "db.query.text": this.statement,
+        "cloudflare.binding.type": "D1",
+        "cloudflare.d1.query.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      const result = firstIfArray(
+        d1BindingJsrpc ? await this.dbSession._queryOrThrow(
+          { queries: [{ sql: this.statement, params: this.params }] },
+          span
+        ) : await this.dbSession._sendOrThrow(
+          "/execute",
+          this.statement,
+          this.params,
+          "NONE",
+          span
+        )
+      );
+      span.setAttributes({
+        "cloudflare.d1.response.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      addD1MetaToSpan(span, result.meta);
+      return d1BindingJsrpc ? toArrayOfObjects(result) : result;
+    });
+  }
+  async all() {
+    return withSpan("d1_all", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "all",
+        "db.query.text": this.statement,
+        "cloudflare.binding.type": "D1",
+        "cloudflare.d1.query.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      const result = firstIfArray(
+        d1BindingJsrpc ? await this.dbSession._queryOrThrow(
+          { queries: [{ sql: this.statement, params: this.params }] },
+          span
+        ) : await this.dbSession._sendOrThrow(
+          "/query",
+          this.statement,
+          this.params,
+          "ROWS_AND_COLUMNS",
+          span
+        )
+      );
+      span.setAttributes({
+        "cloudflare.d1.response.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      addD1MetaToSpan(span, result.meta);
+      return toArrayOfObjects(result);
+    });
+  }
+  async raw(options) {
+    return withSpan("d1_all", async (span) => {
+      span.setAttributes({
+        "db.system.name": "cloudflare-d1",
+        "db.operation.name": "raw",
+        "db.query.text": this.statement,
+        "cloudflare.binding.type": "D1",
+        "cloudflare.d1.query.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      if (d1BindingJsrpc) {
+        const s2 = firstIfArray(
+          await this.dbSession._queryOrThrow(
+            { queries: [{ sql: this.statement, params: this.params }] },
+            span
+          )
+        );
+        span.setAttributes({
+          "cloudflare.d1.response.bookmark": this.dbSession.getBookmark() ?? void 0
+        });
+        addD1MetaToSpan(span, s2.meta);
+        return [
+          ...options?.columnNames ? [s2.results.columns] : [],
+          ...s2.results.rows
+        ];
+      }
+      const s = firstIfArray(
+        await this.dbSession._sendOrThrow(
+          "/query",
+          this.statement,
+          this.params,
+          "ROWS_AND_COLUMNS",
+          span
+        )
+      );
+      span.setAttributes({
+        "cloudflare.d1.response.bookmark": this.dbSession.getBookmark() ?? void 0
+      });
+      addD1MetaToSpan(span, s.meta);
+      if (!("results" in s)) return [];
+      if (Array.isArray(s.results)) {
+        const raw = [];
+        for (const row of s.results) {
+          if (options?.columnNames && raw.length === 0) {
+            raw.push(Array.from(Object.keys(row)));
+          }
+          const entry = Object.keys(row).map((k) => {
+            return row[k];
+          });
+          raw.push(entry);
+        }
+        return raw;
+      } else {
+        return [
+          ...options?.columnNames ? [s.results.columns] : [],
+          ...s.results.rows
+        ];
+      }
+    });
+  }
+};
+async function fetcherQuery(fetcher, request) {
+  const response = await fetcher.query(request);
+  if ("success" in response) {
+    if (!response.success) {
+      throw response.error;
+    }
+    const { queryResults, bookmark } = response.results;
+    const normalizedResponse = { results: queryResults };
+    if (bookmark !== void 0) {
+      normalizedResponse.bookmark = bookmark;
+    }
+    return normalizedResponse;
+  }
+  return response;
+}
+function mapQueryResult(queryResult) {
+  const { data } = queryResult;
+  switch (data.kind) {
+    // Keep the switch so future result kinds have an obvious extension point.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    case "raw":
+      return {
+        success: true,
+        meta: queryResult.meta,
+        results: {
+          columns: data.columns,
+          rows: data.rows
+        }
+      };
+    default: {
+      data.kind;
+      throw new Error(`Unsupported D1 query result kind: ${String(data.kind)}`);
+    }
+  }
+}
+function firstIfArray(results) {
+  return Array.isArray(results) ? results.at(0) : results;
+}
+function toArrayOfObjects(response) {
+  if (!("results" in response))
+    return {
+      ...response,
+      results: []
+    };
+  const results = response.results;
+  if (Array.isArray(results)) {
+    return { ...response, results };
+  } else {
+    const { rows, columns } = results;
+    return {
+      ...response,
+      results: rows.map(
+        (row) => Object.fromEntries(row.map((cell, i) => [columns[i], cell]))
+      )
+    };
+  }
+}
+function mapD1Result(result) {
+  return result.error ? {
+    success: false,
+    error: result.error
+  } : {
+    success: true,
+    meta: result.meta,
+    ..."results" in result ? { results: result.results } : {}
+  };
+}
+async function toJson(response) {
+  const body = await response.text();
+  try {
+    return JSON.parse(body);
+  } catch {
+    throw new Error(`Failed to parse body as JSON, got: ${body}`);
+  }
+}
+function addAggregatedD1MetaToSpan(span, metas) {
+  if (!metas.length) {
+    return;
+  }
+  const aggregatedMeta = aggregateD1Meta(metas);
+  addD1MetaToSpan(span, aggregatedMeta);
+}
+function addD1MetaToSpan(span, meta) {
+  span.setAttributes({
+    "cloudflare.d1.response.size_after": meta.size_after,
+    "cloudflare.d1.response.rows_read": meta.rows_read,
+    "cloudflare.d1.response.rows_written": meta.rows_written,
+    "cloudflare.d1.response.last_row_id": meta.last_row_id,
+    "cloudflare.d1.response.changed_db": meta.changed_db,
+    "cloudflare.d1.response.changes": meta.changes,
+    "cloudflare.d1.response.served_by_region": meta.served_by_region,
+    "cloudflare.d1.response.served_by_colo": meta.served_by_colo,
+    "cloudflare.d1.response.served_by_primary": meta.served_by_primary,
+    "cloudflare.d1.response.sql_duration_ms": meta.timings?.sql_duration_ms ?? void 0,
+    "cloudflare.d1.response.total_attempts": meta.total_attempts
+  });
+}
+function aggregateD1Meta(metas) {
+  const aggregatedMeta = {
+    duration: 0,
+    size_after: 0,
+    rows_read: 0,
+    rows_written: 0,
+    last_row_id: 0,
+    changed_db: false,
+    changes: 0
+  };
+  for (const meta of metas) {
+    if (!meta) {
+      continue;
+    }
+    aggregatedMeta.duration += meta.duration ?? 0;
+    aggregatedMeta.size_after = meta.size_after ?? 0;
+    aggregatedMeta.rows_read += meta.rows_read ?? 0;
+    aggregatedMeta.rows_written += meta.rows_written ?? 0;
+    aggregatedMeta.last_row_id = meta.last_row_id ?? 0;
+    if (meta.served_by_region) {
+      aggregatedMeta.served_by_region = meta.served_by_region;
+    }
+    if (meta.served_by_colo) {
+      aggregatedMeta.served_by_colo = meta.served_by_colo;
+    }
+    if (meta.served_by_primary) {
+      aggregatedMeta.served_by_primary = meta.served_by_primary;
+    }
+    if (meta.timings?.sql_duration_ms) {
+      aggregatedMeta.timings = {
+        sql_duration_ms: (aggregatedMeta.timings?.sql_duration_ms ?? 0) + meta.timings.sql_duration_ms
+      };
+    }
+    if (meta.total_attempts) {
+      aggregatedMeta.total_attempts = (aggregatedMeta.total_attempts ?? 0) + meta.total_attempts;
+    }
+    aggregatedMeta.changes += meta.changes ?? 0;
+    if (meta.changed_db) {
+      aggregatedMeta.changed_db = true;
+    }
+  }
+  return aggregatedMeta;
+}
+function makeBinding(env) {
+  return new D1Database(env.fetcher);
+}
+export {
+  makeBinding as default
+};