@bytesbrains/cruise 0.0.0-stage → 0.12.1

package/dist/chunk-GUZNI3NS.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  DEMO_ENVIRONMENT
+} from "./chunk-N3YKWKOA.mjs";
+import {
+  assertUid
+} from "./chunk-2NVDAK5J.mjs";
+import {
+  CONTRIBUTOR_LANE_PREFIX,
+  LANE_PREFIX,
+  SLUG
+} from "./chunk-FGLMW5IY.mjs";
+
+// src/tenants-prepaid.ts
+var STARTING_WALLET_SOFT_MICROS = 1e6;
+function prepaidOn(environment) {
+  return environment !== DEMO_ENVIRONMENT;
+}
+function walletInsert(db, tenantId, actor) {
+  return db.prepare(
+    `INSERT INTO budgets (scope, subject, period, soft_micros, hard_micros, updated_by)
+       VALUES ('tenant', ?1, 'lifetime', ?2, (SELECT COALESCE(sum(micros), 0) FROM credits WHERE tenant_id = ?1), ?3)`
+  ).bind(tenantId, STARTING_WALLET_SOFT_MICROS, actor);
+}
+var SIGNUP_MADE = `EXISTS (SELECT 1 FROM audit_events a
+                      WHERE a.action = 'tenant.provision' AND a.subject = t.id
+                        AND substr(a.actor, 1, 12) = 'key:cru_svc_')`;
+async function unprepaidSignups(db) {
+  const { results } = await db.prepare(
+    `SELECT t.id, t.billable
+         FROM tenants t
+        WHERE ${SIGNUP_MADE}
+          AND NOT EXISTS (SELECT 1 FROM budgets b WHERE b.scope = 'tenant' AND b.subject = t.id)
+        ORDER BY t.created_at, t.id`
+  ).all();
+  return results.map((row) => ({ id: row.id, billable: row.billable === 1 }));
+}
+async function prepaySignups(db, environment, actor) {
+  if (!prepaidOn(environment)) {
+    throw new Error(
+      "Signup on the demo is not prepaid: every price there is zero, and a zero wallet would refuse every request. Nothing was changed."
+    );
+  }
+  const pending = await unprepaidSignups(db);
+  for (const tenant of pending) {
+    await db.batch([
+      walletInsert(db, tenant.id, actor),
+      ...tenant.billable ? [] : [db.prepare(`UPDATE tenants SET billable = 1 WHERE id = ?`).bind(tenant.id)],
+      db.prepare(
+        `INSERT INTO audit_events (id, actor, action, subject, detail, tenant_id)
+           VALUES (?, ?, 'tenant.prepay', ?, ?, ?)`
+      ).bind(
+        crypto.randomUUID(),
+        actor,
+        tenant.id,
+        JSON.stringify({ wallet_written: true, billable_set: !tenant.billable }),
+        tenant.id
+      )
+    ]);
+  }
+  return pending;
+}
+
+// src/tenants-validate.ts
+var GLOBAL_NAMESPACES = [LANE_PREFIX, CONTRIBUTOR_LANE_PREFIX].map((prefix) => prefix.slice(0, -1));
+var MAX_NAME_LENGTH = 128;
+function softFor(hardMicros) {
+  return Math.round(hardMicros * 0.8);
+}
+async function assertTenantId(db, rawId) {
+  const id = rawId.trim();
+  if (!SLUG.test(id)) {
+    throw new Error(
+      `'${rawId}' is not a valid tenant id: lowercase letters, digits and dashes, up to 64 characters. It is the lane namespace \u2014 lane ids are '<tenant>/<slug>' \u2014 and cannot be changed afterwards.`
+    );
+  }
+  if (GLOBAL_NAMESPACES.includes(id)) {
+    throw new Error(
+      `'${id}' is a global lane namespace and cannot be a tenant. Every tenant can already see '${id}/\u2026' lanes.`
+    );
+  }
+  const upstream = await db.prepare(`SELECT id FROM upstreams WHERE id = ?`).bind(id).first();
+  if (upstream !== null) {
+    throw new Error(
+      `'${id}' is an upstream id, so '${id}/<model>' would be ambiguous between a lane and a model. Choose another.`
+    );
+  }
+  return id;
+}
+function assertGateway(value) {
+  if (value !== "gw-sensitive" && value !== "gw-internal") {
+    throw new Error(
+      `Unknown gateway: ${value}. Use gw-sensitive (retention off) or gw-internal (logs payloads).`
+    );
+  }
+  return value;
+}
+function gatewayRefusal(gateway, operator) {
+  return gateway === "gw-internal" && !operator ? "gw-internal logs payloads and is reserved for the tenant that operates Cruise. Omit 'gateway' for gw-sensitive, which logs none." : null;
+}
+function assertName(rawName) {
+  const name = rawName.trim();
+  if (name === "") throw new Error("A tenant name is required.");
+  if (name.length > MAX_NAME_LENGTH) throw new Error(`A tenant name cannot exceed ${MAX_NAME_LENGTH} characters.`);
+  return name;
+}
+function assertCap(micros, label) {
+  if (!Number.isInteger(micros)) throw new Error(`${label} must be an integer count of micros, got ${micros}`);
+  if (micros < 0) throw new Error(`${label} cannot be negative.`);
+  return micros;
+}
+
+// src/tenants.ts
+var STARTING_HARD_MICROS = 5e6;
+var STARTING_PROJECT_SLUG = "default";
+var STARTING_TIER = "free";
+async function readTenant(db, tenantId) {
+  const tenant = await db.prepare(`SELECT id, name, tier, billable, created_at FROM tenants WHERE id = ?`).bind(tenantId).first();
+  if (tenant === null) return null;
+  const { results: projects } = await db.prepare(
+    `SELECT p.id, p.slug, p.gateway, b.period, b.soft_micros, b.hard_micros
+         FROM projects p
+         LEFT JOIN budgets b ON b.scope = 'project' AND b.subject = p.id
+        WHERE p.tenant_id = ?
+        ORDER BY p.slug`
+  ).bind(tenantId).all();
+  const { results: members } = await db.prepare(`SELECT uid, role FROM memberships WHERE tenant_id = ? ORDER BY created_at, uid`).bind(tenantId).all();
+  return {
+    id: tenant.id,
+    name: tenant.name,
+    tier: tenant.tier,
+    billable: tenant.billable === 1,
+    createdAt: tenant.created_at,
+    projects: projects.map(projectView),
+    members: members.map(memberView)
+  };
+}
+function projectView(row) {
+  return {
+    id: row.id,
+    slug: row.slug,
+    gateway: row.gateway,
+    period: row.period,
+    softMicros: row.soft_micros,
+    hardMicros: row.hard_micros
+  };
+}
+function memberView(row) {
+  return { uid: row.uid, role: row.role };
+}
+function alreadyThere(tenant, ownerUid) {
+  const owners = tenant.members.filter((member) => member.role === "owner").map((member) => member.uid);
+  return owners.includes(ownerUid) ? { created: false, tenant } : { created: false, tenant, ownerConflict: { given: ownerUid, owners } };
+}
+async function provisionTenant(db, request, actor) {
+  const id = await assertTenantId(db, request.id);
+  const name = assertName(request.name);
+  const ownerUid = assertUid(request.ownerUid);
+  const gateway = assertGateway(request.gateway ?? "gw-sensitive");
+  const gatewayRefused = gatewayRefusal(gateway, false);
+  if (gatewayRefused !== null) throw new Error(gatewayRefused);
+  const tier = request.tier ?? STARTING_TIER;
+  const known = await db.prepare(`SELECT id FROM tiers WHERE id = ?`).bind(tier).first();
+  if (known === null) throw new Error(`No such tier: ${tier}`);
+  const hardMicros = assertCap(request.hardMicros ?? STARTING_HARD_MICROS, "--hard");
+  if (hardMicros === 0) {
+    throw new Error(
+      "A hard cap of zero is an account that cannot serve a single request. Leave --hard out for the starting cap, or give the figure you mean."
+    );
+  }
+  const softMicros = request.softMicros === void 0 ? softFor(hardMicros) : request.softMicros === null ? null : assertCap(request.softMicros, "--soft");
+  if (softMicros !== null && softMicros > hardMicros) {
+    throw new Error(`The soft threshold (${softMicros}) cannot exceed the hard cap (${hardMicros}).`);
+  }
+  const prepaid = request.prepaid === true;
+  const existing = await readTenant(db, id);
+  if (existing !== null) return alreadyThere(existing, ownerUid);
+  const projectId = `${id}/${STARTING_PROJECT_SLUG}`;
+  const taken = await db.prepare(`SELECT tenant_id FROM projects WHERE id = ?`).bind(projectId).first();
+  if (taken !== null) {
+    throw new Error(`Project id '${projectId}' already belongs to tenant '${taken.tenant_id}'.`);
+  }
+  try {
+    await db.batch([
+      db.prepare(`INSERT INTO tenants (id, name, tier, billable) VALUES (?1, ?2, ?3, ?4)`).bind(id, name, tier, prepaid ? 1 : 0),
+      // `budget_behaviour` is left at its schema default of `refuse`. v0 ships
+      // only the refusal path — `degrade` waits on auto mode (#19) — so recording
+      // an intent nothing honours would be a promise to a customer we cannot keep.
+      db.prepare(`INSERT INTO projects (id, tenant_id, slug, name, gateway) VALUES (?1, ?2, ?3, ?4, ?5)`).bind(projectId, id, STARTING_PROJECT_SLUG, name, gateway),
+      db.prepare(
+        `INSERT INTO budgets (scope, subject, period, soft_micros, hard_micros, updated_by)
+           VALUES ('project', ?1, 'day', ?2, ?3, ?4)`
+      ).bind(projectId, softMicros, hardMicros, actor),
+      db.prepare(`INSERT INTO memberships (uid, tenant_id, role, created_by) VALUES (?1, ?2, 'owner', ?3)`).bind(ownerUid, id, actor),
+      // In this batch and not after it, for the budget's reason one row up:
+      // a prepaid tenant without its wallet is served uncapped at tenant scope
+      // — the #376 incident — so the account exists with it or not at all.
+      ...prepaid ? [walletInsert(db, id, actor)] : [],
+      db.prepare(
+        `INSERT INTO audit_events (id, actor, action, subject, detail, tenant_id)
+           VALUES (?, ?, 'tenant.provision', ?, ?, ?)`
+      ).bind(
+        crypto.randomUUID(),
+        actor,
+        id,
+        JSON.stringify({
+          name,
+          tier,
+          project: projectId,
+          gateway,
+          soft_micros: softMicros,
+          hard_micros: hardMicros,
+          owner: ownerUid,
+          prepaid
+        }),
+        // The tenant this event is about, so the trail can be scoped
+        // without guessing at `subject` (0044).
+        id
+      )
+    ]);
+  } catch (error) {
+    if (error instanceof Error && /partial batch: [1-9]\d* of/.test(error.message)) throw error;
+    if (!(error instanceof Error) || !/UNIQUE constraint failed/i.test(error.message)) throw error;
+    const raced = await readTenant(db, id);
+    if (raced === null) throw error;
+    return alreadyThere(raced, ownerUid);
+  }
+  const tenant = await readTenant(db, id);
+  if (tenant === null) throw new Error(`Provisioning ${id} wrote nothing. No part of the account was created.`);
+  return { created: true, tenant };
+}
+async function listTenants(db) {
+  const { results: tenants } = await db.prepare(`SELECT id, name, tier, billable, created_at FROM tenants ORDER BY created_at, id`).all();
+  const { results: projects } = await db.prepare(
+    `SELECT p.tenant_id, p.id, p.slug, p.gateway, b.period, b.soft_micros, b.hard_micros
+         FROM projects p
+         LEFT JOIN budgets b ON b.scope = 'project' AND b.subject = p.id
+        ORDER BY p.tenant_id, p.slug`
+  ).all();
+  const { results: members } = await db.prepare(`SELECT tenant_id, uid, role FROM memberships ORDER BY tenant_id, created_at, uid`).all();
+  const byTenant = (rows) => {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const row of rows) grouped.set(row.tenant_id, [...grouped.get(row.tenant_id) ?? [], row]);
+    return grouped;
+  };
+  const projectsFor = byTenant(projects);
+  const membersFor = byTenant(members);
+  return tenants.map((tenant) => ({
+    id: tenant.id,
+    name: tenant.name,
+    tier: tenant.tier,
+    billable: tenant.billable === 1,
+    createdAt: tenant.created_at,
+    projects: (projectsFor.get(tenant.id) ?? []).map(projectView),
+    members: (membersFor.get(tenant.id) ?? []).map(memberView)
+  }));
+}
+
+export {
+  prepaidOn,
+  unprepaidSignups,
+  prepaySignups,
+  assertGateway,
+  provisionTenant,
+  listTenants
+};

package/dist/chunk-HQDQTXRX.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  isSessionId,
+  sessionDigest
+} from "./chunk-SYTYOTO4.mjs";
+
+// src/report-compression.ts
+async function compressionSavings(db, month = null, tenantId) {
+  const scope = tenantId === void 0 ? "" : "AND tenant_id = ?2";
+  const statement = db.prepare(
+    `SELECT project_id AS projectId,
+            strftime('%Y-%m', at) AS month,
+            count(*) AS requests,
+            sum(CASE WHEN compress_bytes_after < compress_bytes_before THEN 1 ELSE 0 END) AS applied,
+            COALESCE(sum(compress_bytes_before), 0) AS bytesBefore,
+            COALESCE(sum(compress_bytes_after), 0) AS bytesAfter,
+            COALESCE(sum(prompt_tokens), 0) AS promptTokens
+       FROM ledger
+      WHERE compress_bytes_before IS NOT NULL
+        AND (?1 IS NULL OR strftime('%Y-%m', at) = ?1) ${scope}
+      GROUP BY project_id, month
+      ORDER BY month DESC, project_id`
+  );
+  const { results } = await (tenantId === void 0 ? statement.bind(month) : statement.bind(month, tenantId)).all();
+  return results;
+}
+async function compressionBySession(db, session, tenantId) {
+  if (!isSessionId(session)) throw new Error(`'${session}' is not a session id Cruise accepts: 1-128 of letters, digits, '.', '_', ':' or '-'.`);
+  const scope = tenantId === void 0 ? "" : "AND tenant_id = ?2";
+  const statement = db.prepare(
+    `SELECT project_id AS projectId,
+            count(*) AS requests,
+            count(compress_bytes_before) AS ran,
+            sum(CASE WHEN compress_bytes_after < compress_bytes_before THEN 1 ELSE 0 END) AS applied,
+            COALESCE(sum(compress_bytes_before), 0) AS bytesBefore,
+            COALESCE(sum(compress_bytes_after), 0) AS bytesAfter,
+            COALESCE(sum(CASE WHEN compress_bytes_before IS NOT NULL THEN prompt_tokens END), 0) AS promptTokens,
+            COALESCE(sum(cost_micros), 0) AS micros,
+            min(at) AS first,
+            max(at) AS last
+       FROM ledger
+      WHERE session_digest = ?1 ${scope}
+      GROUP BY project_id
+      ORDER BY first`
+  );
+  const digest = await sessionDigest(session);
+  const { results } = await (tenantId === void 0 ? statement.bind(digest) : statement.bind(digest, tenantId)).all();
+  return results;
+}
+var savedShare = (row) => row.bytesBefore > 0 ? (row.bytesBefore - row.bytesAfter) / row.bytesBefore : null;
+
+export {
+  compressionSavings,
+  compressionBySession,
+  savedShare
+};

package/dist/chunk-ICJVJSTC.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/pricing-usage.ts
+var IMPLAUSIBLE_TOKENS = 1e8;
+function tokenCount(value) {
+  if (typeof value !== "number") return null;
+  if (!Number.isSafeInteger(value)) return null;
+  if (value < 0 || value > IMPLAUSIBLE_TOKENS) return null;
+  return value;
+}
+function usageFromJson(body) {
+  const usage = body?.usage;
+  if (!usage) return null;
+  const prompt = tokenCount(usage.prompt_tokens);
+  const completion = tokenCount(usage.completion_tokens);
+  if (prompt === null || completion === null) {
+    console.warn(
+      `Refusing implausible usage from upstream: prompt=${String(usage.prompt_tokens)} completion=${String(usage.completion_tokens)}. Recorded as no_usage and charged the reservation.`
+    );
+    return null;
+  }
+  const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+  const cached = usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens;
+  const searches = tokenCount(usage.server_tool_use?.web_search_requests ?? usage.num_search_queries);
+  const contextSize = typeof usage.search_context_size === "string" ? usage.search_context_size : void 0;
+  return {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    // These two only ever refine a figure already accepted, so an implausible
+    // value drops to zero rather than discarding the whole reading.
+    reasoning_tokens: tokenCount(reasoning) ?? 0,
+    cached_input_tokens: tokenCount(cached) ?? 0,
+    ...searches === null ? {} : { web_search_requests: searches },
+    ...contextSize === void 0 ? {} : { search_context_size: contextSize }
+  };
+}
+
+export {
+  tokenCount,
+  usageFromJson
+};

package/dist/chunk-JZPUTXM7.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// scripts/d1-http.ts
+var NonRetryable = class extends Error {
+};
+var PartialBatchError = class extends Error {
+  applied;
+  total;
+  cause;
+  constructor(applied, total, cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(
+      applied === 0 ? `partial batch: 0 of ${total} statements applied: ${detail}` : `partial batch: ${applied} of ${total} statements applied; preceding statements stand: ${detail}`
+    );
+    this.name = "PartialBatchError";
+    this.applied = applied;
+    this.total = total;
+    this.cause = cause;
+  }
+};
+var HttpD1 = class {
+  #accountId;
+  #databaseId;
+  #token;
+  constructor(accountId, databaseId, token) {
+    this.#accountId = accountId;
+    this.#databaseId = databaseId;
+    this.#token = token;
+  }
+  /**
+   * Run a statement, retrying transport failures.
+   *
+   * Every CLI reaches D1 through here, and a single `fetch failed` used to end
+   * whatever was being done. That matters more than convenience for the ones that
+   * batch: `batch()` here is sequential, so a blip partway through a grant could
+   * leave a membership with no audit row beside it.
+   *
+   * Seven attempts on a quadratic backoff — about 45 seconds in all — since
+   * #549. Three at 0.5s and 1s gave a stall 1.5 seconds to clear, and on
+   * 2026-09-30 four local conformance runs in a row died of `fetch failed`
+   * partway through a forty-minute catalogue, on a connection where one request
+   * in thirty took six seconds. The fifth, with this, ran to the end.
+   *
+   * Only transport failures retry. A statement the API *rejected* is deterministic
+   * and repeating it would just fail again more slowly.
+   */
+  async query(sql, params, attempts = 7) {
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        const response = await fetch(
+          `https://api.cloudflare.com/client/v4/accounts/${this.#accountId}/d1/database/${this.#databaseId}/query`,
+          {
+            method: "POST",
+            headers: { authorization: `Bearer ${this.#token}`, "content-type": "application/json" },
+            body: JSON.stringify({ sql, params })
+          }
+        );
+        const body = await response.json();
+        if (!body.success) {
+          throw new NonRetryable(
+            `D1 query failed: ${body.errors?.map((e) => e.message).join("; ") ?? response.status}`
+          );
+        }
+        const first = body.result[0];
+        return { results: first?.results ?? [], changes: first?.meta?.changes ?? 0 };
+      } catch (cause) {
+        if (cause instanceof NonRetryable) throw cause;
+        lastError = cause;
+        if (attempt < attempts) await new Promise((r) => setTimeout(r, attempt * attempt * 500));
+      }
+    }
+    throw new Error(`D1 unreachable after ${attempts} attempts: ${String(lastError)}`);
+  }
+  prepare(sql) {
+    return new HttpStatement(this, sql, []);
+  }
+  /**
+   * Sequential, not atomic — the REST API has no batch equivalent.
+   *
+   * `issueKey` is written to tolerate exactly this: the key is inserted revoked
+   * and activated by the final statement, so a partial run leaves a dead key
+   * rather than an unrestricted live one.
+   *
+   * **It returns what D1's own `batch` returns**: one result per statement, in
+   * order, each carrying `meta.changes`. It returned `void` until the first
+   * live `demo:seed`, which reads its results positionally to say which models
+   * it actually measured — and got `Cannot read properties of undefined
+   * (reading '5')`, the boundary between the five fixed statements and the
+   * per-model ones (`src/demo-catalogue.ts`). Nothing in the suite could catch
+   * it: tests run against workerd's real binding, which returns the array, so
+   * this shim is the one D1 implementation no test exercises. Anything reading
+   * a batch's results through the CLI was broken and this is the only caller
+   * that does.
+   *
+   * Returning results does not make it atomic, and review of PR #344 was right
+   * to ask what a failure partway through `demo:seed` leaves: a catalogue with
+   * its measurements cleared and not yet re-stamped, which is a demo that
+   * routes nothing. The recovery is to run the seeder again — every statement
+   * it issues is an `UPDATE` with no read-modify-write, so a second run
+   * converges on the same rows whatever the first one got through
+   * (`src/demo-catalogue.ts`). That is a property of that caller, not of this
+   * method, and the reason it is written that way. A caller that needs the
+   * transaction has to have it inside the Worker, where `db.batch` is real; the
+   * REST API this speaks has no batch endpoint to borrow one from.
+   *
+   * A mid-loop failure is thrown as `PartialBatchError`, naming how many
+   * statements already landed (#357). Silent rethrow of the inner cause is how
+   * `provisionTenant`'s race catch mistook a partial write for "already there".
+   */
+  async batch(statements) {
+    const results = [];
+    for (const statement of statements) {
+      try {
+        results.push(await statement.run());
+      } catch (cause) {
+        throw new PartialBatchError(results.length, statements.length, cause);
+      }
+    }
+    return results;
+  }
+};
+var HttpStatement = class _HttpStatement {
+  #db;
+  #sql;
+  #params;
+  constructor(db, sql, params) {
+    this.#db = db;
+    this.#sql = sql;
+    this.#params = params;
+  }
+  bind(...params) {
+    return new _HttpStatement(this.#db, this.#sql, params);
+  }
+  async first() {
+    const { results } = await this.#db.query(this.#sql, this.#params);
+    return results[0] ?? null;
+  }
+  async all() {
+    const { results } = await this.#db.query(this.#sql, this.#params);
+    return { results };
+  }
+  async run() {
+    const { changes } = await this.#db.query(this.#sql, this.#params);
+    return { meta: { changes } };
+  }
+};
+
+// scripts/d1-local.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+function adminToken() {
+  if (process.env.CRUISE_ADMIN_TOKEN) return process.env.CRUISE_ADMIN_TOKEN;
+  const file = path.join(process.env.CRUISE_DATA_DIR || "/data", "secrets.json");
+  try {
+    return JSON.parse(readFileSync(file, "utf8")).ADMIN_TOKEN;
+  } catch {
+    throw new Error(
+      `No admin token: set CRUISE_ADMIN_TOKEN, or run this where ${file} exists (inside the container: docker compose exec cruise \u2026).`
+    );
+  }
+}
+var LocalD1 = class {
+  #url;
+  #token;
+  constructor(url = process.env.CRUISE_ADMIN_URL || "http://127.0.0.1:8788", token = adminToken()) {
+    this.#url = url.replace(/\/$/, "");
+    this.#token = token;
+  }
+  async post(route, body) {
+    let response;
+    try {
+      response = await fetch(`${this.#url}${route}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${this.#token}`, "content-type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (cause) {
+      throw new Error(`Cannot reach the self-hosted admin endpoint at ${this.#url}: is Cruise running? (${String(cause)})`);
+    }
+    const answer = await response.json();
+    if (!answer.success) throw new Error(`D1 query failed: ${answer.error ?? response.status}`);
+    return answer;
+  }
+  async query(sql, params) {
+    const answer = await this.post("/d1/query", { sql, params });
+    return { results: answer.results ?? [], changes: answer.changes ?? 0 };
+  }
+  prepare(sql) {
+    return new LocalStatement(this, sql, []);
+  }
+  /** One transaction: every statement applies or none does. */
+  async batch(statements) {
+    const answer = await this.post(
+      "/d1/batch",
+      statements.map((s) => s.toJSON())
+    );
+    return answer.results.map((r) => ({ results: r.results, meta: { changes: r.changes } }));
+  }
+};
+var LocalStatement = class _LocalStatement {
+  #db;
+  #sql;
+  #params;
+  constructor(db, sql, params) {
+    this.#db = db;
+    this.#sql = sql;
+    this.#params = params;
+  }
+  bind(...params) {
+    return new _LocalStatement(this.#db, this.#sql, params);
+  }
+  toJSON() {
+    return { sql: this.#sql, params: this.#params };
+  }
+  async first(column) {
+    const { results } = await this.#db.query(this.#sql, this.#params);
+    const row = results[0];
+    if (row === void 0) return null;
+    return column === void 0 ? row : row[column];
+  }
+  async all() {
+    const { results } = await this.#db.query(this.#sql, this.#params);
+    return { results };
+  }
+  async run() {
+    const { changes } = await this.#db.query(this.#sql, this.#params);
+    return { meta: { changes } };
+  }
+};
+
+export {
+  HttpD1,
+  LocalD1
+};