npm - lakebed - Versions diffs - 0.0.1 - Mend

lakebed 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +94 -0
package/package.json +62 -0
package/src/anonymous-server.js +1078 -0
package/src/anonymous.js +996 -0
package/src/cli.js +1066 -0
package/src/client.d.ts +8 -0
package/src/client.js +154 -0
package/src/runtime.js +252 -0
package/src/server.d.ts +53 -0
package/src/server.js +39 -0
package/src/source-store.js +110 -0

package/src/anonymous-server.js ADDED Viewed

@@ -0,0 +1,1078 @@
+import { createServer } from "node:http";
+import {
+  createClaimToken,
+  createDeployId,
+  createSlug,
+  DEFAULT_ANONYMOUS_LIMITS,
+  executeAnonymousMutation,
+  executeAnonymousQuery,
+  hashClaimToken,
+  parseTtlSeconds,
+  validateAnonymousDeployPayload
+} from "./anonymous.js";
+import { WebSocketServer } from "ws";
+function now() {
+  return new Date().toISOString();
+}
+function dayWindowStart() {
+  return `${new Date().toISOString().slice(0, 10)}T00:00:00.000Z`;
+}
+function toGuestName(name) {
+  return (
+    String(name ?? "local")
+      .replace(/^guest:/, "")
+      .trim()
+      .replace(/[^a-zA-Z0-9_.-]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .toLowerCase() || "local"
+  );
+}
+function toDisplayName(name) {
+  return toGuestName(name)
+    .split(/[-_\s.]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+    .join(" ");
+}
+function createGuestAuth(name) {
+  const guestName = toGuestName(name);
+  return {
+    displayName: toDisplayName(guestName),
+    userId: `guest:${guestName}`
+  };
+}
+function authFromUrl(url) {
+  return createGuestAuth(url.searchParams.get("lakebed_guest") ?? url.searchParams.get("guest") ?? "local");
+}
+function html(title, basePath) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title}</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script>window.__LAKEBED_BASE_PATH__ = ${JSON.stringify(basePath)};</script>
+    <script type="module" src="${basePath}/client.js"></script>
+    <script>
+      const tailwind = document.createElement("script");
+      tailwind.src = "https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4";
+      tailwind.async = true;
+      document.head.appendChild(tailwind);
+    </script>
+  </body>
+</html>`;
+}
+function sendJson(res, status, value, headers = {}) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    ...headers
+  });
+  res.end(JSON.stringify(value, null, 2));
+}
+function sendText(res, status, value, headers = {}) {
+  res.writeHead(status, headers);
+  res.end(value);
+}
+function websocketSend(ws, message) {
+  ws.send(JSON.stringify(message));
+}
+async function readJsonBody(req, maxBytes = 2 * 1024 * 1024) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    total += chunk.byteLength;
+    if (total > maxBytes) {
+      throw new Error(`Request body exceeds ${maxBytes} bytes.`);
+    }
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function normalizePublicRootUrl(value, port) {
+  const fallback = `http://localhost:${port}`;
+  return String(value || fallback).replace(/\/+$/g, "");
+}
+function appUrlForSlug({ appBaseDomain, publicRootUrl, slug }) {
+  if (appBaseDomain) {
+    return `https://${slug}.${appBaseDomain}`;
+  }
+  return `${publicRootUrl}/d/${slug}`;
+}
+function claimUrlForDeploy({ deployId, publicRootUrl, token }) {
+  return `${publicRootUrl}/claim/${deployId}/${token}`;
+}
+function inspectUrls(url) {
+  return {
+    db: `${url}/__lakebed/db`,
+    logs: `${url}/__lakebed/logs`,
+    manifest: `${url}/__lakebed/manifest`,
+    usage: `${url}/__lakebed/usage`
+  };
+}
+function responseForDeploy({ deploy, token }) {
+  return {
+    claimUrl: token ? claimUrlForDeploy({ deployId: deploy.id, publicRootUrl: deploy.publicRootUrl, token }) : undefined,
+    deployId: deploy.id,
+    expiresAt: deploy.expiresAt,
+    inspect: inspectUrls(deploy.url),
+    limits: deploy.limits,
+    url: deploy.url
+  };
+}
+function isExpired(deploy) {
+  return Boolean(deploy.expiresAt) && Date.parse(deploy.expiresAt) <= Date.now();
+}
+function routeSystemPath(pathname) {
+  if (pathname.startsWith("/__span/")) {
+    return `/__lakebed/${pathname.slice("/__span/".length)}`;
+  }
+  if (pathname === "/__span") {
+    return "/__lakebed";
+  }
+  return pathname;
+}
+function parsePathDeploy(url) {
+  const parts = url.pathname.split("/").filter(Boolean);
+  if (parts[0] !== "d" || !parts[1]) {
+    return null;
+  }
+  const prefix = `/d/${parts[1]}`;
+  const appPath = url.pathname === prefix ? "/" : url.pathname.slice(prefix.length) || "/";
+  return {
+    appPath,
+    basePath: prefix,
+    slug: parts[1]
+  };
+}
+function parseHostDeploy({ appBaseDomain, host, url }) {
+  if (!appBaseDomain) {
+    return null;
+  }
+  const hostname = host.split(":")[0].toLowerCase();
+  const suffix = `.${appBaseDomain.toLowerCase()}`;
+  if (!hostname.endsWith(suffix)) {
+    return null;
+  }
+  const slug = hostname.slice(0, -suffix.length);
+  if (!slug || slug === "www") {
+    return null;
+  }
+  return {
+    appPath: url.pathname || "/",
+    basePath: "",
+    slug
+  };
+}
+function quotaLimitForBucket(bucket, deploy) {
+  if (bucket === "mutations") {
+    return deploy.limits.mutationsPerDay;
+  }
+  return deploy.limits.requestsPerDay;
+}
+export class MemoryAnonymousStore {
+  constructor() {
+    this.artifacts = new Map();
+    this.deploys = new Map();
+    this.deploysBySlug = new Map();
+    this.logs = new Map();
+    this.quotaEvents = new Map();
+    this.queues = new Map();
+    this.rows = new Map();
+  }
+  async initialize() {}
+  async createDeploy({ appBaseDomain, artifact, artifactHash, clientBundleBase64, clientBundleHash, publicRootUrl, requestedTtlSeconds }) {
+    const deployId = createDeployId();
+    let slug = createSlug();
+    while (this.deploysBySlug.has(slug)) {
+      slug = createSlug();
+    }
+    const token = createClaimToken();
+    const createdAt = now();
+    const ttlSeconds = parseTtlSeconds(requestedTtlSeconds);
+    const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+    const url = appUrlForSlug({ appBaseDomain, publicRootUrl, slug });
+    const currentArtifact = this.artifacts.get(artifactHash);
+    this.artifacts.set(artifactHash, {
+      artifact,
+      bytes: Buffer.byteLength(clientBundleBase64, "base64"),
+      clientBundleBase64,
+      clientBundleHash,
+      createdAt,
+      hash: artifactHash,
+      refCount: (currentArtifact?.refCount ?? 0) + 1
+    });
+    const deploy = {
+      appBaseDomain,
+      artifactHash,
+      claimTokenHash: hashClaimToken(token),
+      clientBundleHash,
+      createdAt,
+      expiresAt,
+      id: deployId,
+      limits: { ...DEFAULT_ANONYMOUS_LIMITS },
+      publicRootUrl,
+      slug,
+      status: "active",
+      url
+    };
+    this.deploys.set(deployId, deploy);
+    this.deploysBySlug.set(slug, deployId);
+    return { deploy, token };
+  }
+  async getDeployById(id) {
+    return this.deploys.get(id) ?? null;
+  }
+  async getDeployBySlug(slug) {
+    const id = this.deploysBySlug.get(slug);
+    return id ? this.getDeployById(id) : null;
+  }
+  async getArtifact(hash) {
+    return this.artifacts.get(hash) ?? null;
+  }
+  rowKey(deployId, tableName) {
+    return `${deployId}:${tableName}`;
+  }
+  tableRows(deployId, tableName) {
+    const key = this.rowKey(deployId, tableName);
+    if (!this.rows.has(key)) {
+      this.rows.set(key, new Map());
+    }
+    return this.rows.get(key);
+  }
+  async listRows(deployId, tableName) {
+    return Array.from(this.tableRows(deployId, tableName).values()).map((row) => ({ ...row }));
+  }
+  async getRow(deployId, tableName, rowId) {
+    const row = this.tableRows(deployId, tableName).get(rowId);
+    return row ? { ...row } : null;
+  }
+  async insertRow(deployId, tableName, row) {
+    this.tableRows(deployId, tableName).set(row.id, { ...row });
+  }
+  async updateRow(deployId, tableName, rowId, patch) {
+    const rows = this.tableRows(deployId, tableName);
+    const row = rows.get(rowId);
+    if (row) {
+      rows.set(rowId, { ...row, ...patch });
+    }
+  }
+  async deleteRow(deployId, tableName, rowId) {
+    this.tableRows(deployId, tableName).delete(rowId);
+  }
+  async transaction(deployId, handler) {
+    const run = () => handler(this);
+    const next = (this.queues.get(deployId) ?? Promise.resolve()).then(run, run);
+    this.queues.set(
+      deployId,
+      next.then(
+        () => undefined,
+        () => undefined
+      )
+    );
+    return next;
+  }
+  async appendLog(deployId, level, message, data) {
+    const entries = this.logs.get(deployId) ?? [];
+    entries.push({ at: now(), data, level, message });
+    this.logs.set(deployId, entries.slice(-DEFAULT_ANONYMOUS_LIMITS.logEntries));
+  }
+  async readLogs(deployId, limit = 100) {
+    return (this.logs.get(deployId) ?? []).slice(-limit);
+  }
+  async tableCounts(deployId, schema) {
+    const counts = {};
+    for (const tableName of Object.keys(schema ?? {})) {
+      counts[tableName] = this.tableRows(deployId, tableName).size;
+    }
+    return counts;
+  }
+  async dumpState(deployId, schema, limit = 1000) {
+    const tables = {};
+    let remaining = limit;
+    let truncated = false;
+    for (const tableName of Object.keys(schema ?? {})) {
+      const rows = await this.listRows(deployId, tableName);
+      tables[tableName] = rows.slice(0, remaining);
+      remaining -= tables[tableName].length;
+      if (rows.length > tables[tableName].length) {
+        truncated = true;
+      }
+      if (remaining <= 0) {
+        truncated = true;
+      }
+    }
+    return { tables, truncated };
+  }
+  async incrementQuota(deployId, bucket, limit) {
+    const windowStart = dayWindowStart();
+    const key = `${deployId}:${bucket}:${windowStart}`;
+    const count = (this.quotaEvents.get(key) ?? 0) + 1;
+    this.quotaEvents.set(key, count);
+    if (count > limit) {
+      throw new Error(`Anonymous ${bucket} quota exceeded. Limit: ${limit} per day.`);
+    }
+    return { bucket, count, limit, windowStart };
+  }
+  async readUsage(deployId) {
+    const usage = [];
+    for (const [key, count] of this.quotaEvents) {
+      const [eventDeployId, bucket, windowStart] = key.split(":");
+      if (eventDeployId === deployId) {
+        usage.push({ bucket, count, windowStart });
+      }
+    }
+    return usage;
+  }
+}
+export class PostgresAnonymousStore {
+  constructor({ connectionString }) {
+    this.connectionString = connectionString;
+    this.pool = null;
+    this.queues = new Map();
+  }
+  async initialize() {
+    const { Pool } = await import("pg");
+    this.pool = new Pool({ connectionString: this.connectionString });
+    await this.query(`
+      create table if not exists deploys(
+        id text primary key,
+        slug text unique not null,
+        status text not null,
+        artifact_hash text not null,
+        client_bundle_hash text not null,
+        created_at timestamptz not null,
+        expires_at timestamptz not null,
+        claimed_at timestamptz,
+        owner_id text,
+        claim_token_hash text not null,
+        limits_json jsonb not null,
+        counters_json jsonb not null default '{}',
+        public_root_url text not null,
+        app_base_domain text,
+        url text not null
+      )
+    `);
+    await this.query(`
+      create table if not exists artifacts(
+        hash text primary key,
+        artifact_json jsonb not null,
+        client_bundle_base64 text not null,
+        client_bundle_hash text not null,
+        bytes integer not null,
+        created_at timestamptz not null,
+        ref_count integer not null default 1
+      )
+    `);
+    await this.query(`
+      create table if not exists state_rows(
+        deploy_id text not null,
+        table_name text not null,
+        row_id text not null,
+        created_at timestamptz not null,
+        updated_at timestamptz not null,
+        data_json jsonb not null,
+        primary key (deploy_id, table_name, row_id)
+      )
+    `);
+    await this.query(`
+      create table if not exists logs(
+        deploy_id text not null,
+        sequence bigserial primary key,
+        level text not null,
+        message text not null,
+        data_json jsonb,
+        created_at timestamptz not null
+      )
+    `);
+    await this.query(`
+      create table if not exists quota_events(
+        deploy_id text not null,
+        bucket text not null,
+        window_start timestamptz not null,
+        count integer not null,
+        primary key (deploy_id, bucket, window_start)
+      )
+    `);
+  }
+  async query(sql, params = []) {
+    if (!this.pool) {
+      throw new Error("Postgres store is not initialized.");
+    }
+    return this.pool.query(sql, params);
+  }
+  async createDeploy({ appBaseDomain, artifact, artifactHash, clientBundleBase64, clientBundleHash, publicRootUrl, requestedTtlSeconds }) {
+    const createdAt = now();
+    const ttlSeconds = parseTtlSeconds(requestedTtlSeconds);
+    const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+    const token = createClaimToken();
+    const deployId = createDeployId();
+    await this.query(
+      `
+      insert into artifacts(hash, artifact_json, client_bundle_base64, client_bundle_hash, bytes, created_at, ref_count)
+      values($1, $2::jsonb, $3, $4, $5, $6, 1)
+      on conflict(hash) do update set ref_count = artifacts.ref_count + 1
+      `,
+      [artifactHash, JSON.stringify(artifact), clientBundleBase64, clientBundleHash, Buffer.byteLength(clientBundleBase64, "base64"), createdAt]
+    );
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const slug = createSlug();
+      const url = appUrlForSlug({ appBaseDomain, publicRootUrl, slug });
+      const deploy = {
+        appBaseDomain,
+        artifactHash,
+        claimTokenHash: hashClaimToken(token),
+        clientBundleHash,
+        createdAt,
+        expiresAt,
+        id: deployId,
+        limits: { ...DEFAULT_ANONYMOUS_LIMITS },
+        publicRootUrl,
+        slug,
+        status: "active",
+        url
+      };
+      try {
+        await this.query(
+          `
+          insert into deploys(
+            id, slug, status, artifact_hash, client_bundle_hash, created_at, expires_at,
+            claim_token_hash, limits_json, counters_json, public_root_url, app_base_domain, url
+          )
+          values($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb, '{}'::jsonb, $10, $11, $12)
+          `,
+          [
+            deploy.id,
+            deploy.slug,
+            deploy.status,
+            deploy.artifactHash,
+            deploy.clientBundleHash,
+            deploy.createdAt,
+            deploy.expiresAt,
+            deploy.claimTokenHash,
+            JSON.stringify(deploy.limits),
+            deploy.publicRootUrl,
+            deploy.appBaseDomain,
+            deploy.url
+          ]
+        );
+        return { deploy, token };
+      } catch (error) {
+        if (error?.code !== "23505" || attempt === 7) {
+          throw error;
+        }
+      }
+    }
+    throw new Error("Unable to allocate anonymous deploy slug.");
+  }
+  rowToDeploy(row) {
+    if (!row) {
+      return null;
+    }
+    return {
+      appBaseDomain: row.app_base_domain,
+      artifactHash: row.artifact_hash,
+      claimTokenHash: row.claim_token_hash,
+      clientBundleHash: row.client_bundle_hash,
+      createdAt: new Date(row.created_at).toISOString(),
+      expiresAt: new Date(row.expires_at).toISOString(),
+      id: row.id,
+      limits: row.limits_json,
+      publicRootUrl: row.public_root_url,
+      slug: row.slug,
+      status: row.status,
+      url: row.url
+    };
+  }
+  async getDeployById(id) {
+    const result = await this.query("select * from deploys where id = $1", [id]);
+    return this.rowToDeploy(result.rows[0]);
+  }
+  async getDeployBySlug(slug) {
+    const result = await this.query("select * from deploys where slug = $1", [slug]);
+    return this.rowToDeploy(result.rows[0]);
+  }
+  async getArtifact(hash) {
+    const result = await this.query("select * from artifacts where hash = $1", [hash]);
+    const row = result.rows[0];
+    if (!row) {
+      return null;
+    }
+    return {
+      artifact: row.artifact_json,
+      bytes: row.bytes,
+      clientBundleBase64: row.client_bundle_base64,
+      clientBundleHash: row.client_bundle_hash,
+      createdAt: new Date(row.created_at).toISOString(),
+      hash: row.hash,
+      refCount: row.ref_count
+    };
+  }
+  async listRows(deployId, tableName) {
+    const result = await this.query("select data_json from state_rows where deploy_id = $1 and table_name = $2", [deployId, tableName]);
+    return result.rows.map((row) => row.data_json);
+  }
+  async getRow(deployId, tableName, rowId) {
+    const result = await this.query("select data_json from state_rows where deploy_id = $1 and table_name = $2 and row_id = $3", [
+      deployId,
+      tableName,
+      rowId
+    ]);
+    return result.rows[0]?.data_json ?? null;
+  }
+  async insertRow(deployId, tableName, row) {
+    await this.query(
+      `
+      insert into state_rows(deploy_id, table_name, row_id, created_at, updated_at, data_json)
+      values($1, $2, $3, $4, $5, $6::jsonb)
+      `,
+      [deployId, tableName, row.id, row.createdAt, row.updatedAt, JSON.stringify(row)]
+    );
+  }
+  async updateRow(deployId, tableName, rowId, patch) {
+    const row = await this.getRow(deployId, tableName, rowId);
+    if (!row) {
+      return;
+    }
+    const next = { ...row, ...patch };
+    await this.query(
+      `
+      update state_rows
+      set updated_at = $4, data_json = $5::jsonb
+      where deploy_id = $1 and table_name = $2 and row_id = $3
+      `,
+      [deployId, tableName, rowId, next.updatedAt, JSON.stringify(next)]
+    );
+  }
+  async deleteRow(deployId, tableName, rowId) {
+    await this.query("delete from state_rows where deploy_id = $1 and table_name = $2 and row_id = $3", [deployId, tableName, rowId]);
+  }
+  async transaction(deployId, handler) {
+    const run = () => handler(this);
+    const next = (this.queues.get(deployId) ?? Promise.resolve()).then(run, run);
+    this.queues.set(
+      deployId,
+      next.then(
+        () => undefined,
+        () => undefined
+      )
+    );
+    return next;
+  }
+  async appendLog(deployId, level, message, data) {
+    await this.query(
+      "insert into logs(deploy_id, level, message, data_json, created_at) values($1, $2, $3, $4::jsonb, $5)",
+      [deployId, level, message, JSON.stringify(data ?? null), now()]
+    );
+  }
+  async readLogs(deployId, limit = 100) {
+    const result = await this.query(
+      "select level, message, data_json, created_at from logs where deploy_id = $1 order by sequence desc limit $2",
+      [deployId, limit]
+    );
+    return result.rows.reverse().map((row) => ({
+      at: new Date(row.created_at).toISOString(),
+      data: row.data_json,
+      level: row.level,
+      message: row.message
+    }));
+  }
+  async tableCounts(deployId, schema) {
+    const counts = {};
+    for (const tableName of Object.keys(schema ?? {})) {
+      const result = await this.query("select count(*)::int as count from state_rows where deploy_id = $1 and table_name = $2", [
+        deployId,
+        tableName
+      ]);
+      counts[tableName] = result.rows[0]?.count ?? 0;
+    }
+    return counts;
+  }
+  async dumpState(deployId, schema, limit = 1000) {
+    const tables = {};
+    let remaining = limit;
+    let truncated = false;
+    for (const tableName of Object.keys(schema ?? {})) {
+      const result = await this.query(
+        "select data_json from state_rows where deploy_id = $1 and table_name = $2 order by created_at asc limit $3",
+        [deployId, tableName, Math.max(0, remaining)]
+      );
+      tables[tableName] = result.rows.map((row) => row.data_json);
+      remaining -= tables[tableName].length;
+      const count = await this.tableCounts(deployId, { [tableName]: schema[tableName] });
+      if (count[tableName] > tables[tableName].length) {
+        truncated = true;
+      }
+      if (remaining <= 0) {
+        truncated = true;
+      }
+    }
+    return { tables, truncated };
+  }
+  async incrementQuota(deployId, bucket, limit) {
+    const windowStart = dayWindowStart();
+    const result = await this.query(
+      `
+      insert into quota_events(deploy_id, bucket, window_start, count)
+      values($1, $2, $3, 1)
+      on conflict(deploy_id, bucket, window_start)
+      do update set count = quota_events.count + 1
+      returning count
+      `,
+      [deployId, bucket, windowStart]
+    );
+    const count = result.rows[0].count;
+    if (count > limit) {
+      throw new Error(`Anonymous ${bucket} quota exceeded. Limit: ${limit} per day.`);
+    }
+    return { bucket, count, limit, windowStart };
+  }
+  async readUsage(deployId) {
+    const result = await this.query("select bucket, window_start, count from quota_events where deploy_id = $1 order by window_start desc", [
+      deployId
+    ]);
+    return result.rows.map((row) => ({
+      bucket: row.bucket,
+      count: row.count,
+      windowStart: new Date(row.window_start).toISOString()
+    }));
+  }
+}
+export async function createAnonymousStoreFromEnv(env = process.env) {
+  if (env.DATABASE_URL) {
+    const store = new PostgresAnonymousStore({ connectionString: env.DATABASE_URL });
+    await store.initialize();
+    return store;
+  }
+  const store = new MemoryAnonymousStore();
+  await store.initialize();
+  return store;
+}
+async function loadDeployByRoute({ appBaseDomain, host, store, url }) {
+  const route = parseHostDeploy({ appBaseDomain, host, url }) ?? parsePathDeploy(url);
+  if (!route) {
+    return null;
+  }
+  const deploy = await store.getDeployBySlug(route.slug);
+  if (!deploy) {
+    return { error: "Unknown anonymous deploy.", route, status: 404 };
+  }
+  if (deploy.status !== "active") {
+    return { error: "Anonymous deploy is not active.", route, status: 410 };
+  }
+  if (isExpired(deploy)) {
+    return { error: "Anonymous deploy has expired.", route, status: 410 };
+  }
+  const storedArtifact = await store.getArtifact(deploy.artifactHash);
+  if (!storedArtifact) {
+    return { error: "Anonymous deploy artifact is missing.", route, status: 500 };
+  }
+  return { artifact: storedArtifact.artifact, basePath: route.basePath, deploy, route, storedArtifact };
+}
+async function serveInspect({ artifact, deploy, route, store, systemPath }, res) {
+  if (systemPath === "/__lakebed/manifest") {
+    sendJson(res, 200, {
+      artifactHash: deploy.artifactHash,
+      clientBundleHash: deploy.clientBundleHash,
+      deployId: deploy.id,
+      expiresAt: deploy.expiresAt,
+      limits: deploy.limits,
+      mutations: Object.keys(artifact.server.mutations ?? {}),
+      queries: Object.keys(artifact.server.queries ?? {}),
+      schema: artifact.server.schema,
+      slug: deploy.slug,
+      url: deploy.url
+    });
+    return true;
+  }
+  if (systemPath === "/__lakebed/db/tables") {
+    const counts = await store.tableCounts(deploy.id, artifact.server.schema);
+    sendJson(res, 200, {
+      tables: Object.keys(artifact.server.schema ?? {}),
+      counts
+    });
+    return true;
+  }
+  if (systemPath === "/__lakebed/db") {
+    sendJson(res, 200, await store.dumpState(deploy.id, artifact.server.schema, deploy.limits.rowsReturned));
+    return true;
+  }
+  if (systemPath === "/__lakebed/logs") {
+    sendJson(res, 200, await store.readLogs(deploy.id, 100));
+    return true;
+  }
+  if (systemPath === "/__lakebed/usage") {
+    sendJson(res, 200, {
+      limits: deploy.limits,
+      usage: await store.readUsage(deploy.id)
+    });
+    return true;
+  }
+  if (systemPath === "/__lakebed/url") {
+    sendJson(res, 200, {
+      basePath: route.basePath,
+      url: deploy.url
+    });
+    return true;
+  }
+  return false;
+}
+export async function startAnonymousServer({
+  appBaseDomain = process.env.LAKEBED_APP_BASE_DOMAIN ?? "",
+  port = Number(process.env.PORT ?? 8787),
+  publicRootUrl,
+  quiet = false,
+  store
+} = {}) {
+  const resolvedPublicRootUrl = normalizePublicRootUrl(publicRootUrl ?? process.env.PUBLIC_ROOT_URL, port);
+  const resolvedStore = store ?? (await createAnonymousStoreFromEnv());
+  await resolvedStore.initialize();
+  const subscriptions = new Map();
+  async function publishDeploy(deployId) {
+    for (const [ws, subscription] of subscriptions) {
+      if (subscription.deploy.id !== deployId) {
+        continue;
+      }
+      for (const name of subscription.queries) {
+        try {
+          const data = await executeAnonymousQuery({
+            artifact: subscription.artifact,
+            auth: subscription.auth,
+            deployId,
+            name,
+            state: resolvedStore
+          });
+          websocketSend(ws, { data, name, op: "query.result" });
+        } catch (error) {
+          websocketSend(ws, { error: error instanceof Error ? error.message : String(error), name, op: "query.error" });
+        }
+      }
+    }
+  }
+  const server = createServer(async (req, res) => {
+    const host = req.headers.host ?? "localhost";
+    const requestUrl = new URL(req.url ?? "/", `http://${host}`);
+    try {
+      if (req.method === "GET" && requestUrl.pathname === "/healthz") {
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "POST" && requestUrl.pathname === "/v1/anonymous-deploys") {
+        const body = await readJsonBody(req);
+        const payload = validateAnonymousDeployPayload(body);
+        const { deploy, token } = await resolvedStore.createDeploy({
+          appBaseDomain,
+          artifact: payload.artifact,
+          artifactHash: payload.artifactHash,
+          clientBundleBase64: payload.clientBundleBase64,
+          clientBundleHash: payload.clientBundleHash,
+          publicRootUrl: resolvedPublicRootUrl,
+          requestedTtlSeconds: body.requestedTtlSeconds ?? requestUrl.searchParams.get("ttl") ?? undefined
+        });
+        await resolvedStore.appendLog(deploy.id, "info", "anonymous deploy created", { artifactHash: deploy.artifactHash });
+        sendJson(res, 201, responseForDeploy({ deploy, token }));
+        return;
+      }
+      if (req.method === "GET" && requestUrl.pathname.startsWith("/v1/deploys/")) {
+        const id = requestUrl.pathname.slice("/v1/deploys/".length);
+        const deploy = (await resolvedStore.getDeployById(id)) ?? (await resolvedStore.getDeployBySlug(id));
+        if (!deploy) {
+          sendJson(res, 404, { error: "Unknown deploy." });
+          return;
+        }
+        sendJson(res, 200, responseForDeploy({ deploy }));
+        return;
+      }
+      const loaded = await loadDeployByRoute({ appBaseDomain, host, store: resolvedStore, url: requestUrl });
+      if (!loaded) {
+        sendText(res, 200, "Lakebed anonymous deploy runner\n", { "Content-Type": "text/plain; charset=utf-8" });
+        return;
+      }
+      if (loaded.error) {
+        sendJson(res, loaded.status, { error: loaded.error });
+        return;
+      }
+      await resolvedStore.incrementQuota(
+        loaded.deploy.id,
+        "requests",
+        quotaLimitForBucket("requests", loaded.deploy)
+      );
+      const appPath = routeSystemPath(loaded.route.appPath);
+      if (req.method === "GET" && (appPath === "/" || appPath === "/index.html")) {
+        sendText(res, 200, html(loaded.artifact.name ?? "Lakebed Capsule", loaded.basePath), {
+          "Content-Type": "text/html; charset=utf-8"
+        });
+        return;
+      }
+      if (req.method === "GET" && appPath === "/client.js") {
+        sendText(res, 200, Buffer.from(loaded.storedArtifact.clientBundleBase64, "base64"), {
+          "Cache-Control": "public, max-age=31536000, immutable",
+          "Content-Type": "application/javascript; charset=utf-8"
+        });
+        return;
+      }
+      if (req.method === "GET" && (await serveInspect({ ...loaded, store: resolvedStore, systemPath: appPath }, res))) {
+        return;
+      }
+      sendText(res, 404, "Not found\n", { "Content-Type": "text/plain; charset=utf-8" });
+    } catch (error) {
+      sendJson(res, 500, { error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+  const wss = new WebSocketServer({ noServer: true });
+  wss.on("connection", (ws, _req, loaded, auth) => {
+    subscriptions.set(ws, {
+      artifact: loaded.artifact,
+      auth,
+      deploy: loaded.deploy,
+      queries: new Set()
+    });
+    websocketSend(ws, { auth, op: "auth.result" });
+    ws.on("message", async (raw) => {
+      const subscription = subscriptions.get(ws);
+      if (!subscription) {
+        return;
+      }
+      let message;
+      try {
+        message = JSON.parse(String(raw));
+      } catch {
+        websocketSend(ws, { error: "Invalid JSON message.", op: "error", ok: false });
+        return;
+      }
+      try {
+        await resolvedStore.incrementQuota(
+          subscription.deploy.id,
+          "requests",
+          quotaLimitForBucket("requests", subscription.deploy)
+        );
+        if (message.op === "auth.get") {
+          websocketSend(ws, { auth: subscription.auth, id: message.id, ok: true, op: "auth.result" });
+          return;
+        }
+        if (message.op === "query.subscribe") {
+          subscription.queries.add(message.name);
+          const data = await executeAnonymousQuery({
+            artifact: subscription.artifact,
+            auth: subscription.auth,
+            deployId: subscription.deploy.id,
+            name: message.name,
+            state: resolvedStore
+          });
+          websocketSend(ws, { data, id: message.id, name: message.name, ok: true, op: "query.result" });
+          return;
+        }
+        if (message.op === "mutation.run") {
+          await resolvedStore.incrementQuota(
+            subscription.deploy.id,
+            "mutations",
+            quotaLimitForBucket("mutations", subscription.deploy)
+          );
+          const result = await executeAnonymousMutation({
+            args: message.args ?? [],
+            artifact: subscription.artifact,
+            auth: subscription.auth,
+            deployId: subscription.deploy.id,
+            name: message.name,
+            state: resolvedStore
+          });
+          websocketSend(ws, { id: message.id, ok: true, op: "mutation.result", result });
+          await publishDeploy(subscription.deploy.id);
+          return;
+        }
+        throw new Error(`Unknown operation: ${message.op}`);
+      } catch (error) {
+        await resolvedStore.appendLog(subscription.deploy.id, "error", "websocket operation failed", {
+          error: error instanceof Error ? error.message : String(error),
+          op: message?.op
+        });
+        websocketSend(ws, {
+          error: error instanceof Error ? error.message : String(error),
+          id: message?.id,
+          ok: false,
+          op: "error"
+        });
+      }
+    });
+    ws.on("close", () => {
+      subscriptions.delete(ws);
+    });
+  });
+  server.on("upgrade", async (req, socket, head) => {
+    const host = req.headers.host ?? "localhost";
+    const requestUrl = new URL(req.url ?? "/", `http://${host}`);
+    const loaded = await loadDeployByRoute({ appBaseDomain, host, store: resolvedStore, url: requestUrl });
+    if (!loaded || loaded.error || routeSystemPath(loaded.route.appPath) !== "/__lakebed/ws") {
+      socket.destroy();
+      return;
+    }
+    const auth = authFromUrl(requestUrl);
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req, loaded, auth);
+    });
+  });
+  await new Promise((resolveListen, rejectListen) => {
+    server.once("error", rejectListen);
+    server.listen(port, () => {
+      server.off("error", rejectListen);
+      resolveListen();
+    });
+  });
+  if (!quiet) {
+    console.log(`Lakebed anonymous runner listening at ${resolvedPublicRootUrl}`);
+  }
+  return {
+    port,
+    publicRootUrl: resolvedPublicRootUrl,
+    store: resolvedStore,
+    url: resolvedPublicRootUrl,
+    async close() {
+      for (const client of wss.clients) {
+        client.close();
+      }
+      await new Promise((resolveClose) => {
+        wss.close(() => {
+          server.close(() => resolveClose());
+        });
+      });
+    }
+  };
+}
+export async function main() {
+  await startAnonymousServer();
+}