@cimplify/cli 0.15.2 → 0.16.0

package/dist/chunk-SF44L2OD.mjs

@@ -0,0 +1,1152 @@
+#!/usr/bin/env node
+import { packageData } from './chunk-CPBESPWK.mjs';
+import { createHash } from 'crypto';
+import { existsSync, readdirSync, promises, mkdirSync, statSync } from 'fs';
+import path from 'path';
+
+var DEV_DATA_ROUTE = "/_ctx/data";
+var LOCAL_ENVIRONMENT = "local";
+var DATA_DIR = [".cimplify", "dev", "data"];
+var DATA_FILE = "data.sqlite";
+var LOCAL_PARTICIPANT = "local-player";
+var DATA_FAMILIES = /* @__PURE__ */ new Set(["db", "tx", "kv", "cache", "counter", "queue", "search", "analytics"]);
+var OWNER_COLUMN = "ix_owner";
+var RESERVED_PREFIX = "ix_";
+var META_DB_KEY = "db";
+var META_STAMP_KEY = "stamp";
+var DEFAULT_PAGE_LIMIT = 50;
+var MAX_PAGE_LIMIT = 100;
+var MAX_NAME_BYTES = 64;
+var MAX_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var MAX_DB_PARAMETERS = 64;
+var KV_KEYS_LIMIT = 1e6;
+var KV_BYTES_LIMIT = 256 * 1024 * 1024;
+var DB_ROWS_LIMIT = 1e7;
+var STORAGE_LIMIT = 1024 * 1024 * 1024;
+var CACHE_MAX_ENTRY_BYTES = 64 * 1024;
+var QUEUE_DEPTH_LIMIT = 1e5;
+var SEARCH_DOCUMENTS_LIMIT = 1e6;
+var TX_HOLD_MS = 3e4;
+var NAMESPACE_HEX = 16;
+var SLOT_HEX = 4;
+var UINT32 = 4294967296;
+var TTL_SEPARATOR = ":";
+var KV_KIND = "k";
+var CACHE_KIND = "c";
+var COUNTER_KINDS = { sum: "n", rate_limit: "r", ranked_set: "z" };
+var SCOPE_CHARS = { personal: "p", interactive: "i", shared: "s" };
+var SCOPES_BY_CHAR = { p: "personal", i: "interactive", s: "shared" };
+var SQL_TYPES = {
+  integer: "INTEGER",
+  real: "REAL",
+  boolean: "INTEGER",
+  timestamp: "INTEGER",
+  text: "TEXT",
+  json: "TEXT",
+  blob_ref: "TEXT"
+};
+var COMPARISONS = { eq: " = ", ne: " <> ", lt: " < ", le: " <= ", gt: " > ", ge: " >= " };
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "all",
+  "alter",
+  "and",
+  "any",
+  "as",
+  "asc",
+  "between",
+  "by",
+  "case",
+  "check",
+  "column",
+  "create",
+  "default",
+  "delete",
+  "desc",
+  "distinct",
+  "drop",
+  "else",
+  "end",
+  "exists",
+  "false",
+  "from",
+  "full",
+  "group",
+  "having",
+  "in",
+  "index",
+  "inner",
+  "insert",
+  "into",
+  "is",
+  "join",
+  "key",
+  "left",
+  "like",
+  "limit",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "primary",
+  "right",
+  "select",
+  "set",
+  "settings",
+  "table",
+  "then",
+  "true",
+  "union",
+  "unique",
+  "update",
+  "user",
+  "using",
+  "values",
+  "when",
+  "where",
+  "with"
+]);
+var PLATFORM_TABLES = [
+  "CREATE TABLE IF NOT EXISTS ix_meta (key TEXT PRIMARY KEY, version INTEGER, schema TEXT)",
+  "CREATE TABLE IF NOT EXISTS ix_kv (ns TEXT NOT NULL, part TEXT NOT NULL, k TEXT NOT NULL, value TEXT, stamp INTEGER NOT NULL, expires_at INTEGER, PRIMARY KEY (ns, part, k))",
+  "CREATE TABLE IF NOT EXISTS ix_cache (ns TEXT NOT NULL, part TEXT NOT NULL, k TEXT NOT NULL, value TEXT, expires_at INTEGER NOT NULL, PRIMARY KEY (ns, part, k))",
+  "CREATE TABLE IF NOT EXISTS ix_counters (id TEXT NOT NULL, part TEXT NOT NULL, value INTEGER NOT NULL, PRIMARY KEY (id, part))",
+  "CREATE TABLE IF NOT EXISTS ix_windows (id TEXT NOT NULL, part TEXT NOT NULL, k TEXT NOT NULL, started INTEGER NOT NULL, used INTEGER NOT NULL, PRIMARY KEY (id, part, k))",
+  "CREATE TABLE IF NOT EXISTS ix_ranks (id TEXT NOT NULL, part TEXT NOT NULL, member TEXT NOT NULL, score REAL NOT NULL, PRIMARY KEY (id, part, member))",
+  "CREATE TABLE IF NOT EXISTS ix_jobs (job_id TEXT PRIMARY KEY, queue TEXT NOT NULL, entry TEXT NOT NULL, payload TEXT, status TEXT NOT NULL, attempt INTEGER NOT NULL, next_run_at INTEGER)",
+  "CREATE TABLE IF NOT EXISTS ix_search (idx TEXT NOT NULL, part TEXT NOT NULL, doc TEXT NOT NULL, classification TEXT NOT NULL, body TEXT, fields TEXT, PRIMARY KEY (idx, part, doc))",
+  "CREATE TABLE IF NOT EXISTS ix_topics (topic TEXT NOT NULL, sequence INTEGER NOT NULL, message TEXT, PRIMARY KEY (topic, sequence))",
+  "CREATE TABLE IF NOT EXISTS ix_events (name TEXT NOT NULL, at INTEGER NOT NULL, properties TEXT)",
+  "CREATE TABLE IF NOT EXISTS ix_metrics (name TEXT NOT NULL, kind TEXT NOT NULL, at INTEGER NOT NULL, value REAL NOT NULL)"
+];
+var Refused = class extends Error {
+  constructor(error) {
+    super(error.code);
+    this.error = error;
+  }
+  error;
+};
+function refuse(error) {
+  throw new Refused(error);
+}
+function invalid(field, problem) {
+  refuse({ code: "invalid_arguments", field, problem });
+}
+function denied(reason) {
+  refuse({ code: "denied", reason });
+}
+function notFound(resource) {
+  refuse({ code: "not_found", resource });
+}
+function isIdentifier(name2) {
+  return /^[a-z][a-z0-9_]{0,62}$/.test(name2) && !name2.startsWith(RESERVED_PREFIX) && !RESERVED_WORDS.has(name2);
+}
+function hex(name2) {
+  return createHash("sha256").update(name2).digest("hex").slice(0, NAMESPACE_HEX);
+}
+function stampOf(n) {
+  return { high: Math.floor(n / UINT32), low: n % UINT32 };
+}
+function stampNumber(stamp) {
+  if (stamp === null || stamp === void 0 || typeof stamp !== "object") return null;
+  const { high, low } = stamp;
+  if (typeof high !== "number" || typeof low !== "number") return null;
+  return high * UINT32 + low;
+}
+function sessionToken(n) {
+  return n.toString(16).padStart(16, "0");
+}
+function consistency(n) {
+  return { stamp: stampOf(n), session: sessionToken(n) };
+}
+function pageLimit(page) {
+  const limit = page?.limit;
+  if (limit === null || limit === void 0) return DEFAULT_PAGE_LIMIT;
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) invalid("page.limit", "out_of_range");
+  return limit;
+}
+function pageOffset(page) {
+  const cursor = page?.cursor;
+  if (cursor === null || cursor === void 0) return 0;
+  const offset = Number(cursor);
+  if (!Number.isInteger(offset) || offset < 0) invalid("page.cursor", "malformed");
+  return offset;
+}
+function name(value, field) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value) > MAX_NAME_BYTES) invalid(field, "out_of_range");
+  return value;
+}
+function text(value, field) {
+  if (typeof value !== "string") invalid(field, "malformed");
+  return value;
+}
+function encode(value) {
+  return JSON.stringify(value ?? null);
+}
+function decode(raw) {
+  return typeof raw === "string" ? JSON.parse(raw) : null;
+}
+function sqlValue(value, field) {
+  switch (value.type) {
+    case "null":
+      return null;
+    case "integer":
+    case "real":
+    case "timestamp":
+      if (typeof value.value !== "number") invalid(field, "malformed");
+      return value.value;
+    case "boolean":
+      return value.value === true ? 1 : 0;
+    case "text":
+    case "blob":
+      return text(value.value, field);
+    case "json":
+      return encode(value.value);
+    default:
+      return invalid(field, "malformed");
+  }
+}
+function cell(raw, columnType) {
+  if (raw === null || raw === void 0) return { type: "null" };
+  switch (columnType) {
+    case "integer":
+      return { type: "integer", value: Number(raw) };
+    case "real":
+      return { type: "real", value: Number(raw) };
+    case "boolean":
+      return { type: "boolean", value: Number(raw) !== 0 };
+    case "timestamp":
+      return { type: "timestamp", value: Number(raw) };
+    case "json":
+      return { type: "json", value: decode(raw) };
+    case "blob_ref":
+      return { type: "blob", value: String(raw) };
+    case "text":
+      return { type: "text", value: String(raw) };
+    default:
+      if (typeof raw === "number") return Number.isInteger(raw) ? { type: "integer", value: raw } : { type: "real", value: raw };
+      if (typeof raw === "bigint") return { type: "integer", value: Number(raw) };
+      return { type: "text", value: String(raw) };
+  }
+}
+function positional(sql) {
+  let out = "";
+  let quote = null;
+  for (let i = 0; i < sql.length; i++) {
+    const c = sql[i];
+    if (quote !== null) {
+      out += c;
+      if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      quote = c;
+      out += c;
+      continue;
+    }
+    if (c === "$" && /[0-9]/.test(sql[i + 1] ?? "")) {
+      out += "?";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function createTable(table) {
+  const owned = table.row_scope === "owner";
+  const columns = table.columns.map((c) => `${c.name} ${SQL_TYPES[c.column_type] ?? "TEXT"}${c.nullable ? "" : " NOT NULL"}`);
+  if (owned) columns.push(`${OWNER_COLUMN} TEXT NOT NULL`);
+  const key = owned ? [OWNER_COLUMN, ...table.primary_key] : [...table.primary_key];
+  return [`CREATE TABLE IF NOT EXISTS ${table.name} (${columns.join(", ")}, PRIMARY KEY (${key.join(", ")}))`, ...table.indexes.map((i) => createIndex(table, i))];
+}
+function createIndex(table, index) {
+  const columns = table.row_scope === "owner" ? [OWNER_COLUMN, ...index.columns] : [...index.columns];
+  return `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${index.name} ON ${table.name} (${columns.join(", ")})`;
+}
+function planMigration(applied, declared) {
+  for (const table of declared.tables) {
+    const valid = isIdentifier(table.name) && table.columns.every((c) => isIdentifier(c.name)) && table.primary_key.length > 0 && table.primary_key.every((k) => table.columns.some((c) => c.name === k)) && table.indexes.every((i) => isIdentifier(i.name) && i.columns.length > 0 && i.columns.every((c) => table.columns.some((col) => col.name === c)));
+    if (!valid) return { kind: "identifier" };
+  }
+  if (applied.tables.some((old) => !declared.tables.some((t) => t.name === old.name))) return { kind: "destructive" };
+  const script = [];
+  for (const table of declared.tables) {
+    const old = applied.tables.find((t) => t.name === table.name);
+    if (old === void 0) {
+      script.push(...createTable(table));
+      continue;
+    }
+    const kept = old.row_scope === table.row_scope && old.primary_key.join(",") === table.primary_key.join(",") && old.columns.every((c) => table.columns.some((n) => n.name === c.name && n.column_type === c.column_type)) && old.indexes.every((i) => table.indexes.some((n) => JSON.stringify(n) === JSON.stringify(i)));
+    if (!kept) return { kind: "destructive" };
+    for (const column of table.columns) {
+      if (old.columns.some((c) => c.name === column.name)) continue;
+      if (!column.nullable) return { kind: "required_column" };
+      script.push(`ALTER TABLE ${table.name} ADD COLUMN ${column.name} ${SQL_TYPES[column.column_type] ?? "TEXT"}`);
+    }
+    for (const index of table.indexes) {
+      if (!old.indexes.some((i) => JSON.stringify(i) === JSON.stringify(index))) script.push(createIndex(table, index));
+    }
+  }
+  return { kind: "apply", script };
+}
+function localDataDir(root, environment = LOCAL_ENVIRONMENT) {
+  return path.join(root, ...DATA_DIR, environment);
+}
+function localEnvironments(root) {
+  const dir = path.join(root, ...DATA_DIR);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((entry) => existsSync(path.join(dir, entry, DATA_FILE)));
+}
+async function resetLocalData(root, environment = null) {
+  const targets = environment === null ? localEnvironments(root) : [environment];
+  const removed = [];
+  for (const target of targets) {
+    const dir = localDataDir(root, target);
+    if (!existsSync(dir)) continue;
+    await promises.rm(dir, { recursive: true, force: true });
+    removed.push(target);
+  }
+  return removed;
+}
+function serverSide(caller) {
+  return caller.location !== "client";
+}
+function partition(caller, scope, write) {
+  if (scope === "shared" && write && !serverSide(caller)) denied("server_writer_required");
+  return scope === "personal" ? `p:${caller.participant}` : "";
+}
+function namespaceId(scope, kind, label) {
+  return `${SCOPE_CHARS[scope] ?? invalid("scope", "malformed")}${kind}${hex(label)}`;
+}
+function parseNamespace(id, kind, field) {
+  if (typeof id !== "string" || id.length !== 2 + NAMESPACE_HEX || id[1] !== kind || !/^[0-9a-f]+$/.test(id.slice(2))) invalid(field, "malformed");
+  const scope = SCOPES_BY_CHAR[id[0]];
+  if (scope === void 0) invalid(field, "malformed");
+  return { id, scope };
+}
+function slot(id) {
+  return Number.parseInt(id.slice(2, 2 + SLOT_HEX), 16);
+}
+var LocalData = class {
+  constructor(options) {
+    this.options = options;
+    this.environment = options.environment ?? LOCAL_ENVIRONMENT;
+    this.file = path.join(localDataDir(options.root, this.environment), DATA_FILE);
+    this.participant = options.participant ?? LOCAL_PARTICIPANT;
+    this.location = options.location ?? "client";
+    this.now = options.now ?? Date.now;
+  }
+  options;
+  environment;
+  file;
+  db = null;
+  participant;
+  location;
+  now;
+  transactions = /* @__PURE__ */ new Map();
+  cached = /* @__PURE__ */ new Map();
+  async open() {
+    if (this.db !== null) return this.db;
+    const sqlite = await import('sqlite').catch(() => null);
+    if (sqlite === null) refuse({ code: "unavailable", family: "db", retry_after_ms: null });
+    mkdirSync(path.dirname(this.file), { recursive: true });
+    const db = new sqlite.DatabaseSync(this.file);
+    db.exec("PRAGMA journal_mode = WAL");
+    for (const statement of PLATFORM_TABLES) db.exec(statement);
+    this.db = db;
+    return db;
+  }
+  close() {
+    this.cached.clear();
+    this.db?.close();
+    this.db = null;
+  }
+  async answer(call, location = this.location) {
+    try {
+      const db = await this.open();
+      const caller = { participant: this.participant, location };
+      return { result: this.dispatch(db, caller, call.operation, call.arguments ?? {}) };
+    } catch (error) {
+      if (error instanceof Refused) return { error: error.error };
+      const family = call.operation.split(".")[0] ?? "db";
+      return { error: { code: "unavailable", family, retry_after_ms: null } };
+    }
+  }
+  prepare(db, sql) {
+    let found = this.cached.get(sql);
+    if (found === void 0) {
+      found = db.prepare(sql);
+      this.cached.set(sql, found);
+    }
+    return found;
+  }
+  run(db, sql, ...params) {
+    const done = this.prepare(db, sql).run(...params);
+    return { changes: Number(done.changes) };
+  }
+  one(db, sql, ...params) {
+    return this.prepare(db, sql).get(...params);
+  }
+  all(db, sql, ...params) {
+    return this.prepare(db, sql).all(...params);
+  }
+  current(db) {
+    const row = this.one(db, "SELECT version FROM ix_meta WHERE key = ?", META_STAMP_KEY);
+    return row === void 0 ? 0 : Number(row.version);
+  }
+  bump(db) {
+    const next = this.current(db) + 1;
+    this.run(db, "INSERT INTO ix_meta (key, version, schema) VALUES (?, ?, NULL) ON CONFLICT (key) DO UPDATE SET version = excluded.version", META_STAMP_KEY, next);
+    return next;
+  }
+  atomic(db, work) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const out = work();
+      db.exec("COMMIT");
+      return out;
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  declared() {
+    return packageData(this.options.declarations()) ?? { schema: { version: 0, tables: [] }, statements: [] };
+  }
+  applied(db) {
+    const row = this.one(db, "SELECT schema FROM ix_meta WHERE key = ?", META_DB_KEY);
+    return row === void 0 ? { version: 0, tables: [] } : decode(row.schema);
+  }
+  dispatch(db, caller, operation, args) {
+    switch (operation) {
+      case "db.describe":
+        return this.describe(db);
+      case "db.migrate":
+        return this.migrate(db, args);
+      case "db.query":
+        return this.query(db, caller, args);
+      case "tx.begin":
+        return this.begin(db, args);
+      case "tx.stage":
+        return this.stage(args);
+      case "tx.commit":
+        return this.commit(db, caller, args);
+      case "tx.abort":
+        return this.abort(args);
+      case "kv.open":
+        return this.kvOpen(db, caller, args);
+      case "kv.get":
+        return this.kvGet(db, caller, args);
+      case "kv.set":
+        return this.atomic(db, () => this.kvSet(db, caller, args.namespace_id, args.key, args.value, args.ttl_ms));
+      case "kv.compare_and_set":
+        return this.atomic(db, () => this.kvSwap(db, caller, args));
+      case "kv.delete":
+        return this.atomic(db, () => this.kvDelete(db, caller, args.namespace_id, args.key));
+      case "kv.list":
+        return this.kvList(db, caller, args);
+      case "cache.open":
+        return this.cacheOpen(db, caller, args);
+      case "cache.get":
+        return this.cacheGet(db, caller, args, false);
+      case "cache.set":
+        return this.cacheSet(db, caller, args);
+      case "cache.delete":
+        return this.cacheGet(db, caller, args, true);
+      case "counter.open":
+        return this.counterOpen(caller, args);
+      case "counter.add":
+        return this.atomic(db, () => this.counterAdd(db, caller, args.counter_id, args.delta));
+      case "counter.read":
+        return this.counterRead(db, caller, args);
+      case "counter.rate_limit":
+        return this.atomic(db, () => this.rateLimit(db, caller, args));
+      case "counter.rank":
+        return this.atomic(db, () => this.rank(db, caller, args));
+      case "counter.rank_range":
+        return this.rankRange(db, caller, args);
+      case "counter.rank_of":
+        return this.rankOf(db, caller, args);
+      case "queue.enqueue":
+        return this.atomic(db, () => this.enqueue(db, caller, args));
+      case "queue.status":
+        return this.job(db, text(args.job_id, "job_id"));
+      case "queue.cancel":
+        return this.cancel(db, args);
+      case "queue.stats":
+        return this.queueStats(db, args);
+      case "search.index":
+        return this.atomic(db, () => this.searchIndex(db, caller, args));
+      case "search.query":
+        return this.searchQuery(db, caller, args);
+      case "search.remove":
+        return this.atomic(db, () => this.searchRemove(db, caller, args));
+      case "pubsub.publish":
+        return this.atomic(db, () => this.publish(db, args));
+      case "analytics.track":
+        return this.track(db, args);
+      case "analytics.record":
+        return this.record(db, args);
+      case "analytics.summary":
+        return this.summary(db, caller, args);
+      default:
+        return refuse({ code: "unavailable", family: operation.split(".")[0] ?? "db", retry_after_ms: null });
+    }
+  }
+  describe(db) {
+    const declared = this.declared().schema;
+    const applied = this.applied(db);
+    let rows = 0;
+    for (const table of applied.tables) rows += Number(this.one(db, `SELECT COUNT(*) AS n FROM ${table.name}`)?.n ?? 0);
+    const bytes = existsSync(this.file) ? statSync(this.file).size : 0;
+    return {
+      schema: applied,
+      pending_version: declared.version > applied.version ? declared.version : null,
+      rows: { used: rows, limit: DB_ROWS_LIMIT },
+      bytes: { used: bytes, limit: STORAGE_LIMIT }
+    };
+  }
+  migrate(db, args) {
+    const declared = this.declared().schema;
+    if (args.target_version !== declared.version) invalid("target_version", "schema_mismatch");
+    const applied = this.applied(db);
+    if (applied.version >= declared.version) return this.describe(db);
+    const plan = planMigration(applied, declared);
+    if (plan.kind === "destructive") refuse({ code: "conflict", resource: "table", current: null });
+    if (plan.kind !== "apply") invalid("schema", "schema_mismatch");
+    this.atomic(db, () => {
+      for (const statement of plan.script) db.exec(statement);
+      this.run(
+        db,
+        "INSERT INTO ix_meta (key, version, schema) VALUES (?, ?, ?) ON CONFLICT (key) DO UPDATE SET version = excluded.version, schema = excluded.schema",
+        META_DB_KEY,
+        declared.version,
+        encode(declared)
+      );
+    });
+    this.cached.clear();
+    return this.describe(db);
+  }
+  table(name2) {
+    const table = this.declared().schema.tables.find((t) => t.name === name2);
+    if (table === void 0) invalid("table", "not_declared");
+    return table;
+  }
+  column(table, name2, field) {
+    const column = table.columns.find((c) => c.name === name2);
+    if (column === void 0) invalid(field, "not_declared");
+    return column.column_type;
+  }
+  statement(name2, access) {
+    const found = this.declared().statements.find((s) => s.name === name2 && s.access === access);
+    if (found === void 0) denied("undeclared_statement");
+    return found;
+  }
+  bindStatement(caller, statement, params) {
+    if (params.length !== statement.params) invalid("params", "schema_mismatch");
+    if (statement.shared_write && !serverSide(caller)) denied("server_writer_required");
+    const out = [];
+    let next = 0;
+    const total = statement.params + (statement.owner_param === null ? 0 : 1);
+    for (let position = 1; position <= total; position++) {
+      if (position === statement.owner_param) out.push(caller.participant);
+      else out.push(sqlValue(params[next++], "params"));
+    }
+    if (out.length > MAX_DB_PARAMETERS) invalid("params", "too_long");
+    return out;
+  }
+  where(table, filter, owner, params) {
+    const clauses = [];
+    for (const predicate of filter) {
+      this.column(table, predicate.column, "filter");
+      const values = predicate.values;
+      if ((predicate.comparison === "eq" || predicate.comparison === "ne") && values.length === 1 && values[0].type === "null") {
+        clauses.push(`${predicate.column} IS ${predicate.comparison === "eq" ? "" : "NOT "}NULL`);
+      } else if (predicate.comparison === "prefix" && values.length === 1 && values[0].type === "text") {
+        clauses.push(`substr(${predicate.column}, 1, ?) = ?`);
+        const prefix = text(values[0].value, "filter");
+        params.push(prefix.length, prefix);
+      } else if (predicate.comparison === "in" && values.length > 0) {
+        clauses.push(`${predicate.column} IN (${values.map(() => "?").join(", ")})`);
+        for (const value of values) params.push(sqlValue(value, "filter"));
+      } else if (COMPARISONS[predicate.comparison] !== void 0 && values.length === 1) {
+        clauses.push(`${predicate.column}${COMPARISONS[predicate.comparison]}?`);
+        params.push(sqlValue(values[0], "filter"));
+      } else {
+        invalid("filter", "malformed");
+      }
+    }
+    if (owner !== null) {
+      clauses.push(`${OWNER_COLUMN} = ?`);
+      params.push(owner);
+    }
+    if (params.length > MAX_DB_PARAMETERS) invalid("params", "too_long");
+    return clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`;
+  }
+  query(db, caller, args) {
+    const query = args.query;
+    const limit = pageLimit(query.page);
+    const offset = pageOffset(query.page);
+    let sql;
+    let params;
+    let cells = null;
+    if (query.kind === "statement") {
+      const statement = this.statement(query.statement, "read");
+      params = this.bindStatement(caller, statement, query.params ?? []);
+      sql = `SELECT * FROM (${positional(statement.sql).trim().replace(/;$/, "")}) AS ix_page LIMIT ${limit + 1} OFFSET ${offset}`;
+    } else if (query.kind === "select") {
+      const table = this.table(query.table);
+      const names = query.columns ?? [];
+      cells = (names.length === 0 ? table.columns.map((c) => c.name) : names).map((n) => ({ name: n, type: this.column(table, n, "columns") }));
+      params = [];
+      sql = `SELECT ${cells.map((c) => c.name).join(", ")} FROM ${table.name}`;
+      sql += this.where(table, query.filter ?? [], table.row_scope === "owner" ? caller.participant : null, params);
+      const order = query.order ?? [];
+      order.forEach((key, at) => {
+        this.column(table, key.column, "order");
+        sql += `${at === 0 ? " ORDER BY " : ", "}${key.column} ${key.direction === "desc" ? "DESC" : "ASC"}`;
+      });
+      sql += ` LIMIT ${limit + 1} OFFSET ${offset}`;
+    } else {
+      return invalid("query.kind", "malformed");
+    }
+    let found;
+    try {
+      found = db.prepare(sql).all(...params);
+    } catch {
+      return invalid("query", "schema_mismatch");
+    }
+    const columns = cells ?? Object.keys(found[0] ?? {}).map((n) => ({ name: n, type: null }));
+    const rows = found.slice(0, limit).map((row) => columns.map((c) => cell(row[c.name], c.type)));
+    return {
+      columns: columns.map((c) => c.name),
+      rows,
+      consistency: consistency(this.current(db)),
+      next: found.length > limit ? String(offset + limit) : null
+    };
+  }
+  write(db, caller, write) {
+    if (write.kind === "statement") {
+      const statement = this.statement(write.statement, "write");
+      const params2 = this.bindStatement(caller, statement, write.params ?? []);
+      try {
+        return this.run(db, positional(statement.sql), ...params2).changes;
+      } catch {
+        return refuse({ code: "conflict", resource: "table", current: null });
+      }
+    }
+    const table = this.table(write.table);
+    const owner = table.row_scope === "owner" ? caller.participant : null;
+    if (table.row_scope === "shared" && !serverSide(caller)) denied("server_writer_required");
+    if (write.kind === "insert") {
+      const columns = write.columns ?? [];
+      const rows = write.rows ?? [];
+      for (const c of columns) this.column(table, c, "columns");
+      if (rows.length === 0 || rows.some((r) => r.length !== columns.length)) invalid("rows", "schema_mismatch");
+      if (table.primary_key.some((k) => !columns.includes(k))) invalid("columns", "missing");
+      const names = owner === null ? columns : [...columns, OWNER_COLUMN];
+      const sql = `INSERT INTO ${table.name} (${names.join(", ")}) VALUES (${names.map(() => "?").join(", ")})`;
+      let changed = 0;
+      for (const row of rows) {
+        const values = row.map((v) => sqlValue(v, "rows"));
+        if (owner !== null) values.push(owner);
+        try {
+          changed += this.run(db, sql, ...values).changes;
+        } catch {
+          return refuse({ code: "conflict", resource: "table", current: null });
+        }
+      }
+      return changed;
+    }
+    const params = [];
+    if (write.kind === "update") {
+      const set = write.set ?? [];
+      if (set.length === 0) invalid("set", "missing");
+      for (const assignment of set) {
+        this.column(table, assignment.column, "set");
+        if (table.primary_key.includes(assignment.column)) invalid("set", "malformed");
+      }
+      const assignments = set.map((a) => {
+        params.push(sqlValue(a.value, "set"));
+        return `${a.column} = ?`;
+      });
+      const where = this.where(table, write.filter ?? [], owner, params);
+      return this.run(db, `UPDATE ${table.name} SET ${assignments.join(", ")}${where}`, ...params).changes;
+    }
+    if (write.kind === "delete") {
+      const where = this.where(table, write.filter ?? [], owner, params);
+      return this.run(db, `DELETE FROM ${table.name}${where}`, ...params).changes;
+    }
+    return invalid("write.kind", "malformed");
+  }
+  begin(db, args) {
+    const transaction = `tx_local_${createHash("sha256").update(text(args.request_key, "request_key")).update(String(this.now())).digest("hex").slice(0, 24)}`;
+    const hold = typeof args.timeout_ms === "number" && args.timeout_ms > 0 ? Math.min(args.timeout_ms, TX_HOLD_MS) : TX_HOLD_MS;
+    const snapshot = this.current(db);
+    const expiresAt = this.now() + hold;
+    this.transactions.set(transaction, { steps: [], expiresAt, snapshot });
+    return { transaction, snapshot: stampOf(snapshot), expires_at: expiresAt };
+  }
+  held(id) {
+    const found = this.transactions.get(text(id, "transaction"));
+    if (found === void 0) notFound("operation");
+    if (found.expiresAt < this.now()) {
+      this.transactions.delete(id);
+      refuse({ code: "expired", resource: "operation" });
+    }
+    return found;
+  }
+  stage(args) {
+    const found = this.held(args.transaction);
+    const steps = args.steps ?? [];
+    found.steps.push(...steps);
+    return { transaction: args.transaction, staged: found.steps.length };
+  }
+  abort(args) {
+    this.transactions.delete(text(args.transaction, "transaction"));
+    return { transaction: args.transaction };
+  }
+  commit(db, caller, args) {
+    const staged = args.transaction === null || args.transaction === void 0 ? [] : this.held(args.transaction).steps;
+    const steps = [...staged, ...args.steps ?? []];
+    const declared = this.declared().schema.version;
+    if (typeof args.schema_version === "number" && args.schema_version !== declared) invalid("schema_version", "schema_mismatch");
+    const results = this.atomic(
+      db,
+      () => steps.map((step) => {
+        switch (step.kind) {
+          case "db":
+            return { kind: "db", changed_rows: this.write(db, caller, step.write) };
+          case "kv_set": {
+            const written = this.kvSet(db, caller, step.namespace_id, step.key, step.value, step.ttl_ms);
+            return { kind: "kv", key: step.key, stamp: written.stamp };
+          }
+          case "kv_delete": {
+            const written = this.kvDelete(db, caller, step.namespace_id, step.key);
+            return { kind: "kv", key: step.key, stamp: written.stamp };
+          }
+          case "kv_expect": {
+            const current = this.kvEntry(db, caller, step.namespace_id, step.key);
+            const expected = stampNumber(step.stamp);
+            const actual = current.value === null ? null : current.stamp;
+            if (expected !== actual) refuse({ code: "conflict", resource: "kv_key", current: null });
+            return { kind: "expectation_met" };
+          }
+          case "counter_add": {
+            const value = this.counterAdd(db, caller, step.counter_id, step.delta);
+            return { kind: "counter", counter_id: step.counter_id, value: value.value };
+          }
+          case "rank":
+            return { kind: "rank", entry: this.rank(db, caller, step.update).entry };
+          case "enqueue":
+            return { kind: "enqueued", job_id: this.enqueue(db, caller, step.job).job_id };
+          case "publish":
+            return { kind: "published", sequence: this.publish(db, step.message).sequence };
+          default:
+            return invalid("steps", "malformed");
+        }
+      })
+    );
+    if (typeof args.transaction === "string") this.transactions.delete(args.transaction);
+    return { results, consistency: consistency(this.current(db)) };
+  }
+  kvOpen(db, caller, args) {
+    const label = name(args.name, "name");
+    const scope = text(args.scope, "scope");
+    const id = namespaceId(scope, KV_KIND, label);
+    const part = partition(caller, scope, false);
+    const used = this.one(db, "SELECT COUNT(*) AS n, COALESCE(SUM(LENGTH(value)), 0) AS b FROM ix_kv WHERE ns = ? AND part = ?", id, part);
+    return {
+      namespace_id: id,
+      slot: slot(id),
+      scope,
+      classification: args.classification,
+      keys: { used: Number(used?.n ?? 0), limit: KV_KEYS_LIMIT },
+      bytes: { used: Number(used?.b ?? 0), limit: KV_BYTES_LIMIT }
+    };
+  }
+  kvEntry(db, caller, namespace, key) {
+    const ns = parseNamespace(namespace, KV_KIND, "namespace_id");
+    const k = name(key, "key");
+    const row = this.one(db, "SELECT value, stamp, expires_at FROM ix_kv WHERE ns = ? AND part = ? AND k = ?", ns.id, partition(caller, ns.scope, false), k);
+    if (row === void 0 || row.expires_at !== null && Number(row.expires_at) <= this.now()) return { value: null, stamp: 0, expiresAt: null };
+    return { value: row.value === null ? null : decode(row.value), stamp: Number(row.stamp), expiresAt: row.expires_at === null ? null : Number(row.expires_at) };
+  }
+  kvGet(db, caller, args) {
+    const entry = this.kvEntry(db, caller, args.namespace_id, args.key);
+    return {
+      entry: { key: args.key, value: entry.value, stamp: stampOf(entry.stamp), expires_at: entry.expiresAt },
+      consistency: consistency(this.current(db))
+    };
+  }
+  kvSet(db, caller, namespace, key, value, ttl) {
+    const ns = parseNamespace(namespace, KV_KIND, "namespace_id");
+    const k = name(key, "key");
+    const part = partition(caller, ns.scope, true);
+    const stamp = this.bump(db);
+    const expiresAt = typeof ttl === "number" && ttl > 0 ? this.now() + ttl : null;
+    this.run(
+      db,
+      "INSERT INTO ix_kv (ns, part, k, value, stamp, expires_at) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (ns, part, k) DO UPDATE SET value = excluded.value, stamp = excluded.stamp, expires_at = excluded.expires_at",
+      ns.id,
+      part,
+      k,
+      encode(value),
+      stamp,
+      expiresAt
+    );
+    return { key, stamp: stampOf(stamp), consistency: consistency(stamp) };
+  }
+  kvDelete(db, caller, namespace, key) {
+    const ns = parseNamespace(namespace, KV_KIND, "namespace_id");
+    const k = name(key, "key");
+    const part = partition(caller, ns.scope, true);
+    const stamp = this.bump(db);
+    this.run(db, "DELETE FROM ix_kv WHERE ns = ? AND part = ? AND k = ?", ns.id, part, k);
+    return { key, stamp: stampOf(stamp), consistency: consistency(stamp) };
+  }
+  kvSwap(db, caller, args) {
+    const current = this.kvEntry(db, caller, args.namespace_id, args.key);
+    const expected = stampNumber(args.expected);
+    const actual = current.value === null ? null : current.stamp;
+    const entry = (stamp2, value, expiresAt) => ({ key: args.key, value, stamp: stampOf(stamp2), expires_at: expiresAt });
+    if (expected !== actual) {
+      return { applied: false, current: entry(current.stamp, current.value, current.expiresAt), consistency: consistency(this.current(db)) };
+    }
+    if (args.value === null || args.value === void 0) {
+      const deleted = this.kvDelete(db, caller, args.namespace_id, args.key);
+      const stamp2 = stampNumber(deleted.stamp) ?? 0;
+      return { applied: true, current: entry(stamp2, null, null), consistency: consistency(stamp2) };
+    }
+    const written = this.kvSet(db, caller, args.namespace_id, args.key, args.value, args.ttl_ms);
+    const stamp = stampNumber(written.stamp) ?? 0;
+    const ttl = typeof args.ttl_ms === "number" && args.ttl_ms > 0 ? this.now() + args.ttl_ms : null;
+    return { applied: true, current: entry(stamp, args.value, ttl), consistency: consistency(stamp) };
+  }
+  kvList(db, caller, args) {
+    const ns = parseNamespace(args.namespace_id, KV_KIND, "namespace_id");
+    const limit = pageLimit(args.page);
+    const after = args.page?.cursor ?? "";
+    const prefix = typeof args.prefix === "string" ? args.prefix : "";
+    const rows = this.all(
+      db,
+      "SELECT k, value, stamp, expires_at FROM ix_kv WHERE ns = ? AND part = ? AND k > ? AND substr(k, 1, ?) = ? AND (expires_at IS NULL OR expires_at > ?) ORDER BY k LIMIT ?",
+      ns.id,
+      partition(caller, ns.scope, false),
+      after,
+      prefix.length,
+      prefix,
+      this.now(),
+      limit + 1
+    );
+    const entries = rows.slice(0, limit).map((row) => ({
+      key: row.k,
+      value: decode(row.value),
+      stamp: stampOf(Number(row.stamp)),
+      expires_at: row.expires_at === null ? null : Number(row.expires_at)
+    }));
+    return { entries, next: rows.length > limit ? String(rows[limit - 1].k) : null, consistency: consistency(this.current(db)) };
+  }
+  cacheNamespace(id) {
+    const raw = text(id, "namespace_id");
+    const at = raw.indexOf(TTL_SEPARATOR);
+    if (at < 0) invalid("namespace_id", "malformed");
+    const ns = parseNamespace(raw.slice(0, at), CACHE_KIND, "namespace_id");
+    const ttl = Number(raw.slice(at + 1));
+    if (!Number.isInteger(ttl) || ttl <= 0) invalid("namespace_id", "malformed");
+    return { id: raw, scope: ns.scope, ttl };
+  }
+  cacheOpen(db, caller, args) {
+    const label = name(args.name, "name");
+    const ttl = args.default_ttl_ms;
+    if (typeof ttl !== "number" || ttl <= 0 || ttl > MAX_CACHE_TTL_MS) invalid("default_ttl_ms", "out_of_range");
+    const scope = text(args.scope, "scope");
+    const id = `${namespaceId(scope, CACHE_KIND, label)}${TTL_SEPARATOR}${ttl}`;
+    const used = this.one(db, "SELECT COALESCE(SUM(LENGTH(value)), 0) AS b FROM ix_cache WHERE ns = ? AND part = ?", id, partition(caller, scope, false));
+    return {
+      namespace_id: id,
+      slot: slot(id),
+      scope,
+      classification: args.classification,
+      max_entry_bytes: CACHE_MAX_ENTRY_BYTES,
+      bytes: { used: Number(used?.b ?? 0), limit: KV_BYTES_LIMIT }
+    };
+  }
+  cacheGet(db, caller, args, take) {
+    const ns = this.cacheNamespace(args.namespace_id);
+    const k = name(args.key, "key");
+    const part = partition(caller, ns.scope, take);
+    const row = this.one(db, "SELECT value, expires_at FROM ix_cache WHERE ns = ? AND part = ? AND k = ? AND expires_at > ?", ns.id, part, k, this.now());
+    if (take) this.run(db, "DELETE FROM ix_cache WHERE ns = ? AND part = ? AND k = ?", ns.id, part, k);
+    return { key: k, value: row === void 0 ? null : decode(row.value), expires_at: row === void 0 ? null : Number(row.expires_at) };
+  }
+  cacheSet(db, caller, args) {
+    const ns = this.cacheNamespace(args.namespace_id);
+    const k = name(args.key, "key");
+    const value = encode(args.value);
+    if (Buffer.byteLength(value) > CACHE_MAX_ENTRY_BYTES) refuse({ code: "limit_exceeded", limit: "payload_bytes" });
+    const ttl = typeof args.ttl_ms === "number" && args.ttl_ms > 0 ? Math.min(args.ttl_ms, MAX_CACHE_TTL_MS) : ns.ttl;
+    const expiresAt = this.now() + ttl;
+    this.run(
+      db,
+      "INSERT INTO ix_cache (ns, part, k, value, expires_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT (ns, part, k) DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at",
+      ns.id,
+      partition(caller, ns.scope, true),
+      k,
+      value,
+      expiresAt
+    );
+    return { key: k, expires_at: expiresAt };
+  }
+  counter(id) {
+    const raw = text(id, "counter_id");
+    const kind = Object.entries(COUNTER_KINDS).find(([, c]) => c === raw[1])?.[0];
+    if (kind === void 0) invalid("counter_id", "malformed");
+    const ns = parseNamespace(raw, raw[1], "counter_id");
+    return { id: ns.id, scope: ns.scope, kind };
+  }
+  counterOpen(caller, args) {
+    const label = name(args.name, "name");
+    const kind = text(args.kind, "kind");
+    const code = COUNTER_KINDS[kind];
+    if (code === void 0) invalid("kind", "malformed");
+    const scope = text(args.scope, "scope");
+    partition(caller, scope, false);
+    const id = namespaceId(scope, code, label);
+    return { counter_id: id, kind, scope, slot: slot(id) };
+  }
+  counterAdd(db, caller, id, delta) {
+    const counter = this.counter(id);
+    if (counter.kind !== "sum") invalid("counter_id", "schema_mismatch");
+    if (typeof delta !== "number" || !Number.isInteger(delta)) invalid("delta", "malformed");
+    const part = partition(caller, counter.scope, true);
+    this.run(db, "INSERT INTO ix_counters (id, part, value) VALUES (?, ?, ?) ON CONFLICT (id, part) DO UPDATE SET value = value + excluded.value", counter.id, part, delta);
+    const stamp = this.bump(db);
+    const value = Number(this.one(db, "SELECT value FROM ix_counters WHERE id = ? AND part = ?", counter.id, part)?.value ?? 0);
+    return { counter_id: counter.id, value, consistency: consistency(stamp) };
+  }
+  counterRead(db, caller, args) {
+    const counter = this.counter(args.counter_id);
+    const value = Number(this.one(db, "SELECT value FROM ix_counters WHERE id = ? AND part = ?", counter.id, partition(caller, counter.scope, false))?.value ?? 0);
+    return { counter_id: counter.id, value, consistency: consistency(this.current(db)) };
+  }
+  rateLimit(db, caller, args) {
+    const counter = this.counter(args.counter_id);
+    if (counter.kind !== "rate_limit") invalid("counter_id", "schema_mismatch");
+    const key = name(args.key, "key");
+    const cost = Number(args.cost);
+    const limit = Number(args.limit);
+    const windowMs = Number(args.window_ms);
+    if (!(cost > 0 && limit > 0 && windowMs > 0)) invalid("window_ms", "out_of_range");
+    const part = partition(caller, counter.scope, false);
+    const now = this.now();
+    const started = now - now % windowMs;
+    const row = this.one(db, "SELECT started, used FROM ix_windows WHERE id = ? AND part = ? AND k = ?", counter.id, part, key);
+    const used = row !== void 0 && Number(row.started) === started ? Number(row.used) : 0;
+    const allowed = used + cost <= limit;
+    const next = allowed ? used + cost : used;
+    this.run(
+      db,
+      "INSERT INTO ix_windows (id, part, k, started, used) VALUES (?, ?, ?, ?, ?) ON CONFLICT (id, part, k) DO UPDATE SET started = excluded.started, used = excluded.used",
+      counter.id,
+      part,
+      key,
+      started,
+      next
+    );
+    return { allowed, remaining: Math.max(0, limit - next), resets_at: started + windowMs };
+  }
+  ranked(db, id, part, member) {
+    const row = this.one(db, "SELECT score FROM ix_ranks WHERE id = ? AND part = ? AND member = ?", id, part, member);
+    if (row === void 0) return null;
+    const score = Number(row.score);
+    const above = Number(this.one(db, "SELECT COUNT(*) AS n FROM ix_ranks WHERE id = ? AND part = ? AND (score > ? OR (score = ? AND member < ?))", id, part, score, score, member)?.n ?? 0);
+    return { member, score, rank: above + 1 };
+  }
+  rank(db, caller, args) {
+    const counter = this.counter(args.counter_id);
+    if (counter.kind !== "ranked_set") invalid("counter_id", "schema_mismatch");
+    const member = name(args.member, "member");
+    const score = Number(args.score);
+    if (!Number.isFinite(score)) invalid("score", "malformed");
+    const part = partition(caller, counter.scope, true);
+    const old = this.one(db, "SELECT score FROM ix_ranks WHERE id = ? AND part = ? AND member = ?", counter.id, part, member);
+    const previous = old === void 0 ? null : Number(old.score);
+    let next = score;
+    if (previous !== null) {
+      if (args.mode === "keep_highest") next = Math.max(previous, score);
+      else if (args.mode === "keep_lowest") next = Math.min(previous, score);
+      else if (args.mode === "increment") next = previous + score;
+    }
+    this.run(db, "INSERT INTO ix_ranks (id, part, member, score) VALUES (?, ?, ?, ?) ON CONFLICT (id, part, member) DO UPDATE SET score = excluded.score", counter.id, part, member, next);
+    const stamp = this.bump(db);
+    return { entry: this.ranked(db, counter.id, part, member), consistency: consistency(stamp) };
+  }
+  rankRange(db, caller, args) {
+    const counter = this.counter(args.counter_id);
+    const part = partition(caller, counter.scope, false);
+    const limit = Number(args.limit);
+    const offset = Number(args.offset ?? 0);
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT || !Number.isInteger(offset) || offset < 0) invalid("limit", "out_of_range");
+    const descending = args.direction !== "asc";
+    const rows = this.all(
+      db,
+      `SELECT member, score FROM ix_ranks WHERE id = ? AND part = ? ORDER BY score ${descending ? "DESC" : "ASC"}, member ASC LIMIT ? OFFSET ?`,
+      counter.id,
+      part,
+      limit,
+      offset
+    );
+    const total = Number(this.one(db, "SELECT COUNT(*) AS n FROM ix_ranks WHERE id = ? AND part = ?", counter.id, part)?.n ?? 0);
+    return {
+      counter_id: counter.id,
+      entries: rows.map((row, at) => ({ member: row.member, score: Number(row.score), rank: offset + at + 1 })),
+      total,
+      consistency: consistency(this.current(db))
+    };
+  }
+  rankOf(db, caller, args) {
+    const counter = this.counter(args.counter_id);
+    const entry = this.ranked(db, counter.id, partition(caller, counter.scope, false), name(args.member, "member"));
+    return { entry, consistency: consistency(this.current(db)) };
+  }
+  enqueue(db, caller, args) {
+    if (args.classification === "personal" && !serverSide(caller)) denied("personal_data_forbidden");
+    const queue = name(args.queue, "queue");
+    const entry = name(args.entry, "entry");
+    const key = text(args.request_key, "request_key");
+    const jobId = `job_${createHash("sha256").update(queue).update("\0").update(key).digest("hex").slice(0, 24)}`;
+    const delay = typeof args.delay_ms === "number" && args.delay_ms > 0 ? args.delay_ms : 0;
+    this.run(
+      db,
+      "INSERT INTO ix_jobs (job_id, queue, entry, payload, status, attempt, next_run_at) VALUES (?, ?, ?, ?, 'queued', 0, ?) ON CONFLICT (job_id) DO NOTHING",
+      jobId,
+      queue,
+      entry,
+      encode(args.payload),
+      this.now() + delay
+    );
+    return this.job(db, jobId);
+  }
+  job(db, jobId) {
+    const row = this.one(db, "SELECT job_id, queue, status, attempt, next_run_at FROM ix_jobs WHERE job_id = ?", jobId);
+    if (row === void 0) notFound("job");
+    return { job_id: row.job_id, queue: row.queue, status: row.status, attempt: Number(row.attempt), next_run_at: row.next_run_at === null ? null : Number(row.next_run_at) };
+  }
+  cancel(db, args) {
+    const jobId = text(args.job_id, "job_id");
+    this.run(db, "UPDATE ix_jobs SET status = 'cancelled', next_run_at = NULL WHERE job_id = ? AND status IN ('queued', 'retrying')", jobId);
+    return this.job(db, jobId);
+  }
+  queueStats(db, args) {
+    const queue = name(args.queue, "queue");
+    const count = (status) => Number(this.one(db, "SELECT COUNT(*) AS n FROM ix_jobs WHERE queue = ? AND status = ?", queue, status)?.n ?? 0);
+    const queued = count("queued") + count("retrying");
+    return { queue, queued, running: count("running"), dead_lettered: count("dead_lettered"), depth: { used: queued, limit: QUEUE_DEPTH_LIMIT } };
+  }
+  searchIndex(db, caller, args) {
+    const index = text(args.index, "index");
+    if (!isIdentifier(index)) invalid("index", "malformed");
+    const documents = args.documents ?? [];
+    for (const document of documents) {
+      const scope = document.classification === "personal" ? "personal" : document.classification === "public" ? "shared" : "interactive";
+      this.run(
+        db,
+        "INSERT INTO ix_search (idx, part, doc, classification, body, fields) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT (idx, part, doc) DO UPDATE SET classification = excluded.classification, body = excluded.body, fields = excluded.fields",
+        index,
+        partition(caller, scope, true),
+        name(document.document_id, "documents.document_id"),
+        document.classification,
+        document.text ?? "",
+        encode(document.fields)
+      );
+    }
+    const used = Number(this.one(db, "SELECT COUNT(*) AS n FROM ix_search WHERE idx = ?", index)?.n ?? 0);
+    return { index, indexed: documents.length, documents: { used, limit: SEARCH_DOCUMENTS_LIMIT } };
+  }
+  searchQuery(db, caller, args) {
+    const index = text(args.index, "index");
+    const limit = Number(args.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_PAGE_LIMIT) invalid("limit", "out_of_range");
+    const terms = (typeof args.text === "string" ? args.text : "").toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+    const filter = args.filter ?? [];
+    const rows = this.all(db, "SELECT doc, body, fields FROM ix_search WHERE idx = ? AND part IN ('', ?)", index, `p:${caller.participant}`);
+    const hits = [];
+    for (const row of rows) {
+      const fields = decode(row.fields);
+      const keep = filter.every((p) => {
+        const actual = fields?.[p.column];
+        const wanted = p.values.map((v) => v.value);
+        if (p.comparison === "in") return wanted.includes(actual);
+        if (p.comparison === "eq") return actual === wanted[0];
+        if (p.comparison === "ne") return actual !== wanted[0];
+        return true;
+      });
+      if (!keep) continue;
+      const body = String(row.body ?? "").toLowerCase();
+      const score = terms.reduce((sum, term) => sum + (body.split(term).length - 1), 0);
+      if (terms.length > 0 && score === 0) continue;
+      hits.push({ document_id: String(row.doc), fields, score });
+    }
+    hits.sort((a, b) => b.score - a.score || a.document_id.localeCompare(b.document_id));
+    return { index, hits: hits.slice(0, limit), consistency: consistency(this.current(db)) };
+  }
+  searchRemove(db, caller, args) {
+    const index = text(args.index, "index");
+    const parts = serverSide(caller) ? ["", `p:${caller.participant}`] : [`p:${caller.participant}`, ""];
+    let removed = 0;
+    for (const document of args.documents ?? []) {
+      for (const part of parts) {
+        const classification = this.one(db, "SELECT classification FROM ix_search WHERE idx = ? AND part = ? AND doc = ?", index, part, document)?.classification;
+        if (classification === void 0) continue;
+        if (classification === "public" && !serverSide(caller)) continue;
+        removed += this.run(db, "DELETE FROM ix_search WHERE idx = ? AND part = ? AND doc = ?", index, part, document).changes;
+      }
+    }
+    return { index, removed };
+  }
+  publish(db, args) {
+    const topic = name(args.topic, "topic");
+    const sequence = Number(this.one(db, "SELECT COALESCE(MAX(sequence), 0) AS n FROM ix_topics WHERE topic = ?", topic)?.n ?? 0) + 1;
+    this.run(db, "INSERT INTO ix_topics (topic, sequence, message) VALUES (?, ?, ?)", topic, sequence, encode(args.message));
+    return { topic, sequence };
+  }
+  track(db, args) {
+    const events = args.events ?? [];
+    let accepted = 0;
+    for (const event of events) {
+      if (typeof event.name !== "string" || event.name.length === 0) continue;
+      this.run(db, "INSERT INTO ix_events (name, at, properties) VALUES (?, ?, ?)", event.name, Number(event.at ?? this.now()), encode(event.properties));
+      accepted++;
+    }
+    return { accepted, dropped: events.length - accepted };
+  }
+  record(db, args) {
+    this.run(db, "INSERT INTO ix_metrics (name, kind, at, value) VALUES (?, ?, ?, ?)", name(args.name, "name"), text(args.kind, "kind"), this.now(), Number(args.value));
+    return { accepted: 1, dropped: 0 };
+  }
+  summary(db, caller, args) {
+    if (!serverSide(caller)) denied("location_not_allowed");
+    const metric = name(args.name, "name");
+    const windows = { hour: 36e5, day: 864e5, week: 6048e5 };
+    const span = windows[text(args.window, "window")] ?? invalid("window", "malformed");
+    const values = this.all(db, "SELECT kind, value FROM ix_metrics WHERE name = ? AND at >= ? ORDER BY value", metric, this.now() - span);
+    const numbers = values.map((v) => Number(v.value));
+    const at = (q) => numbers.length === 0 ? null : numbers[Math.min(numbers.length - 1, Math.floor(q * numbers.length))];
+    return {
+      name: metric,
+      kind: values[0]?.kind ?? "count",
+      window: args.window,
+      count: numbers.length,
+      sum: numbers.reduce((s, v) => s + v, 0),
+      minimum: numbers.length === 0 ? null : numbers[0],
+      maximum: numbers.length === 0 ? null : numbers[numbers.length - 1],
+      p50: at(0.5),
+      p99: at(0.99)
+    };
+  }
+};
+
+export { DATA_FAMILIES, DEV_DATA_ROUTE, LOCAL_ENVIRONMENT, LocalData, localDataDir, localEnvironments, resetLocalData };