deepspace 0.23.0 → 0.23.2

package/dist/worker.js

@@ -1,3 +1,83 @@
+// src/shared/protocol/constants.ts
+var MSG = {
+  // ---- Records / CRUD --------------------------------------------------
+  SUBSCRIBE: "core.subscribe",
+  UNSUBSCRIBE: "core.unsubscribe",
+  QUERY_RESULT: "core.query_result",
+  RECORD_CHANGE: "core.record_change",
+  PUT: "core.put",
+  DELETE: "core.delete",
+  ERROR: "core.error",
+  // ---- Users -----------------------------------------------------------
+  USER_INFO: "user.info",
+  USER_LIST: "user.list",
+  SET_ROLE: "user.set_role",
+  USER_UPDATE: "user.update",
+  // ---- Auth signal -----------------------------------------------------
+  // Server → client one-shot on connect from rooms that enforce role-based
+  // writes (Canvas, Game, Cron). Tells the client whether this connection
+  // can write so its hook can disable local write APIs and the UI can
+  // render controls accordingly. Without this, a viewer's click would
+  // round-trip to the server and silently come back as ERROR.
+  AUTH: "auth",
+  // ---- Yjs JSON control frames (binary sync lives in ./yjs.ts) ---------
+  YJS_JOIN: "yjs.join",
+  YJS_LEAVE: "yjs.leave",
+  // ---- Records room misc -----------------------------------------------
+  ACK: "records.ack",
+  LIST_SCHEMAS: "records.list_schemas",
+  RESUBSCRIBE: "records.resubscribe",
+  // ---- CanvasRoom ------------------------------------------------------
+  CANVAS_SHAPES: "canvas.shapes",
+  CANVAS_ADD: "canvas.add",
+  CANVAS_MOVE: "canvas.move",
+  CANVAS_RESIZE: "canvas.resize",
+  CANVAS_DELETE: "canvas.delete",
+  CANVAS_UPDATE: "canvas.update",
+  CANVAS_VIEWPORT: "canvas.viewport",
+  CANVAS_UNDO: "canvas.undo",
+  CANVAS_REDO: "canvas.redo",
+  // ---- CronRoom --------------------------------------------------------
+  CRON_TASKS: "cron.tasks",
+  CRON_HISTORY: "cron.history",
+  CRON_TRIGGER: "cron.trigger",
+  CRON_PAUSE: "cron.pause",
+  CRON_RESUME: "cron.resume",
+  CRON_STATUS: "cron.status",
+  // Per-mutation receipt, sent only to the socket whose trigger/pause/
+  // resume carried a `requestId` — frames without one stay fire-and-forget.
+  CRON_ACK: "cron.ack",
+  // ---- JobRoom ---------------------------------------------------------
+  // Background-job queue with durable, alarm-driven execution. See
+  // server/rooms/job-room.ts. Clients enqueue and subscribe to updates;
+  // the room broadcasts JOB_UPDATE for every status transition.
+  JOB_ENQUEUE: "job.enqueue",
+  JOB_CANCEL: "job.cancel",
+  JOB_RETRY: "job.retry",
+  JOB_UPDATE: "job.update",
+  // ---- PresenceRoom ----------------------------------------------------
+  PRESENCE_SYNC: "presence.sync",
+  PRESENCE_JOIN: "presence.join",
+  PRESENCE_LEAVE: "presence.leave",
+  PRESENCE_UPDATE: "presence.update",
+  // ---- Gateway multiplexing --------------------------------------------
+  GW_SCOPE_CONNECT: "gateway.scope_connect",
+  GW_SCOPE_DISCONNECT: "gateway.scope_disconnect",
+  GW_SCOPE_ERROR: "gateway.scope_error",
+  GW_TOKEN_REFRESH: "gateway.token_refresh",
+  GW_USER_UPDATE: "gateway.user_update"
+};
+var MSG_YJS_SYNC = 22;
+var MSG_YJS_AWARENESS = 23;
+var ROLE_ANONYMOUS = "viewer";
+var ANONYMOUS_USER_ID_PREFIX = "anon-";
+function isAnonymousUserId(userId) {
+  return userId.startsWith(ANONYMOUS_USER_ID_PREFIX);
+}
+var ROLE_DEFAULT = "member";
+var ROLE_ADMIN = "admin";
+var RECORD_NOT_FOUND = "Record not found";
+
 // src/shared/room-identity-headers.ts
 var BASE64URL = /^[A-Za-z0-9_-]*$/;
 var IDENTITY_QUERY_PARAMS = ["userId", "userName", "userEmail", "userImageUrl", "role"];
@@ -51,7 +131,7 @@ function authenticatedRoomRequest(request, auth, identity) {
 // src/server/rooms/base-room.ts
 function connectionAttachmentFromRequest(request) {
   return {
-    userId: decodeRoomIdentityHeader(request.headers.get("x-user-id")) || `anon-${crypto.randomUUID()}`,
+    userId: decodeRoomIdentityHeader(request.headers.get("x-user-id")) || `${ANONYMOUS_USER_ID_PREFIX}${crypto.randomUUID()}`,
     userName: decodeRoomIdentityHeader(request.headers.get("x-user-name")) || "Anonymous",
     userEmail: decodeRoomIdentityHeader(request.headers.get("x-user-email")) || "",
     userImageUrl: decodeRoomIdentityHeader(request.headers.get("x-user-image-url")),
@@ -305,82 +385,6 @@ var BaseRoom = class {
   }
 };
 
-// src/shared/protocol/constants.ts
-var MSG = {
-  // ---- Records / CRUD --------------------------------------------------
-  SUBSCRIBE: "core.subscribe",
-  UNSUBSCRIBE: "core.unsubscribe",
-  QUERY_RESULT: "core.query_result",
-  RECORD_CHANGE: "core.record_change",
-  PUT: "core.put",
-  DELETE: "core.delete",
-  ERROR: "core.error",
-  // ---- Users -----------------------------------------------------------
-  USER_INFO: "user.info",
-  USER_LIST: "user.list",
-  SET_ROLE: "user.set_role",
-  USER_UPDATE: "user.update",
-  // ---- Auth signal -----------------------------------------------------
-  // Server → client one-shot on connect from rooms that enforce role-based
-  // writes (Canvas, Game, Cron). Tells the client whether this connection
-  // can write so its hook can disable local write APIs and the UI can
-  // render controls accordingly. Without this, a viewer's click would
-  // round-trip to the server and silently come back as ERROR.
-  AUTH: "auth",
-  // ---- Yjs JSON control frames (binary sync lives in ./yjs.ts) ---------
-  YJS_JOIN: "yjs.join",
-  YJS_LEAVE: "yjs.leave",
-  // ---- Records room misc -----------------------------------------------
-  ACK: "records.ack",
-  LIST_SCHEMAS: "records.list_schemas",
-  RESUBSCRIBE: "records.resubscribe",
-  // ---- CanvasRoom ------------------------------------------------------
-  CANVAS_SHAPES: "canvas.shapes",
-  CANVAS_ADD: "canvas.add",
-  CANVAS_MOVE: "canvas.move",
-  CANVAS_RESIZE: "canvas.resize",
-  CANVAS_DELETE: "canvas.delete",
-  CANVAS_UPDATE: "canvas.update",
-  CANVAS_VIEWPORT: "canvas.viewport",
-  CANVAS_UNDO: "canvas.undo",
-  CANVAS_REDO: "canvas.redo",
-  // ---- CronRoom --------------------------------------------------------
-  CRON_TASKS: "cron.tasks",
-  CRON_HISTORY: "cron.history",
-  CRON_TRIGGER: "cron.trigger",
-  CRON_PAUSE: "cron.pause",
-  CRON_RESUME: "cron.resume",
-  CRON_STATUS: "cron.status",
-  // Per-mutation receipt, sent only to the socket whose trigger/pause/
-  // resume carried a `requestId` — frames without one stay fire-and-forget.
-  CRON_ACK: "cron.ack",
-  // ---- JobRoom ---------------------------------------------------------
-  // Background-job queue with durable, alarm-driven execution. See
-  // server/rooms/job-room.ts. Clients enqueue and subscribe to updates;
-  // the room broadcasts JOB_UPDATE for every status transition.
-  JOB_ENQUEUE: "job.enqueue",
-  JOB_CANCEL: "job.cancel",
-  JOB_RETRY: "job.retry",
-  JOB_UPDATE: "job.update",
-  // ---- PresenceRoom ----------------------------------------------------
-  PRESENCE_SYNC: "presence.sync",
-  PRESENCE_JOIN: "presence.join",
-  PRESENCE_LEAVE: "presence.leave",
-  PRESENCE_UPDATE: "presence.update",
-  // ---- Gateway multiplexing --------------------------------------------
-  GW_SCOPE_CONNECT: "gateway.scope_connect",
-  GW_SCOPE_DISCONNECT: "gateway.scope_disconnect",
-  GW_SCOPE_ERROR: "gateway.scope_error",
-  GW_TOKEN_REFRESH: "gateway.token_refresh",
-  GW_USER_UPDATE: "gateway.user_update"
-};
-var MSG_YJS_SYNC = 22;
-var MSG_YJS_AWARENESS = 23;
-var ROLE_ANONYMOUS = "viewer";
-var ROLE_DEFAULT = "member";
-var ROLE_ADMIN = "admin";
-var RECORD_NOT_FOUND = "Record not found";
-
 // src/server/schemas/registry.ts
 function collectionTableName(name) {
   return `c_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
@@ -640,12 +644,28 @@ function lintSchema(schema) {
   }
   return warnings;
 }
+function lintSchemas(schemas) {
+  return [...schemas.flatMap((schema) => lintSchema(schema)), ...lintSchemaSet(schemas)];
+}
+function lintSchemaSet(schemas) {
+  const warnings = [];
+  if (!schemas.some((schema) => schema.name === "team_members")) {
+    for (const schema of schemas) {
+      const teamRoles = Object.entries(schema.permissions).filter(([, p]) => [p.read, p.update, p.delete].includes("team")).map(([role]) => role);
+      if (teamRoles.length > 0) {
+        warnings.push(
+          `[${schema.name}] role(s) ${teamRoles.join(", ")} use the 'team' permission level, but no 'team_members' collection is registered. 'team' resolves membership from team_members (teamId, userId, status), so without it those roles are denied everything \u2014 silently. Register a team_members schema or use another level.`
+        );
+      }
+    }
+  }
+  return warnings;
+}
 var SchemaRegistry = class {
   trusted = /* @__PURE__ */ new Map();
   constructor(schemas = []) {
-    for (const schema of schemas) {
-      this.registerTrusted(schema);
-    }
+    for (const w of lintSchemaSet(schemas)) console.warn(`[schema-lint] ${w}`);
+    for (const schema of schemas) this.registerTrusted(schema);
   }
   registerTrusted(schema) {
     for (const w of lintSchema(schema)) {
@@ -1035,6 +1055,123 @@ function getMessageType(data) {
   return readVarUint(decoder);
 }
 
+// src/server/utils/tools.ts
+var DEFAULT_QUERY_LIMIT = 50;
+var DEFAULT_DELETE_WHERE_LIMIT = 100;
+var MAX_DELETE_WHERE_LIMIT = 500;
+function applyAiToolDefaults(toolName, params) {
+  if (toolName === "records.query" && params.limit === void 0) {
+    return { ...params, limit: DEFAULT_QUERY_LIMIT };
+  }
+  return params;
+}
+var BUILT_IN_TOOLS = [
+  // Record tools (structured collections with RBAC)
+  {
+    name: "records.query",
+    description: `Query records from a collection with optional filtering, ordering, and pagination. Returns at most \`limit\` records (default ${DEFAULT_QUERY_LIMIT}). Large result sets are capped at ~30KB: an oversized page is truncated to the leading records that fit and flagged with \`{ truncated, returned, total }\`, so narrow with a \`where\` filter (or page via \`orderBy\` + \`limit\`) to see the rest.`,
+    params: {
+      collection: { type: "string", description: "Collection name to query", required: true },
+      where: { type: "object", description: "Filter object with field=value equality conditions; every key must be recordId, createdBy, or a schema column (an unknown key is refused, not ignored)", required: false },
+      orderBy: { type: "string", description: 'Field to order by (or "createdAt"/"updatedAt")', required: false },
+      orderDir: { type: "string", description: 'Order direction: "asc" or "desc" (default: "desc")', required: false },
+      limit: { type: "number", description: `Maximum number of records to return (default: ${DEFAULT_QUERY_LIMIT}). Oversized pages are still capped at ~30KB and truncated with returned/total flags.`, required: false }
+    }
+  },
+  {
+    name: "records.get",
+    description: "Get a single record by ID from a collection",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      recordId: { type: "string", description: "Record ID to retrieve", required: true }
+    }
+  },
+  {
+    name: "records.create",
+    description: "Create a new record in a collection",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      data: { type: "object", description: "Record data matching the collection schema", required: true },
+      recordId: { type: "string", description: "Custom record ID (auto-generated if omitted)", required: false }
+    }
+  },
+  {
+    name: "records.update",
+    description: "Update an existing record in a collection",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      recordId: { type: "string", description: "Record ID to update", required: true },
+      data: { type: "object", description: "Fields to update (merged with existing data)", required: true }
+    }
+  },
+  {
+    name: "records.delete",
+    description: "Delete a record from a collection",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      recordId: { type: "string", description: "Record ID to delete", required: true }
+    }
+  },
+  {
+    name: "records.deleteWhere",
+    description: `Delete every record matching a filter, in one bounded batch. Deletes at most \`limit\` records (default ${DEFAULT_DELETE_WHERE_LIMIT}, max ${MAX_DELETE_WHERE_LIMIT}) and returns \`{ deleted }\`; repeat the same call until \`deleted\` is less than the limit to drain a larger set. A non-empty \`where\` whose every key names a real field (\`recordId\`, \`createdBy\`, or a schema column) is required \u2014 an unknown key is refused rather than ignored, so this tool never deletes a whole collection. Every matched record goes through the same delete permission check as \`records.delete\`; if any of them is denied, nothing in the batch is deleted.`,
+    params: {
+      collection: { type: "string", description: "Collection name (must have a schema)", required: true },
+      where: { type: "object", description: "Filter object with field=value equality conditions; every key must be recordId, createdBy, or a schema column", required: true },
+      limit: { type: "number", description: `Maximum number of records to delete in this call (default: ${DEFAULT_DELETE_WHERE_LIMIT}, max: ${MAX_DELETE_WHERE_LIMIT})`, required: false }
+    }
+  },
+  // Schema tools
+  {
+    name: "schema.list",
+    description: "List all registered collection schemas with their fields and permissions",
+    params: {}
+  },
+  {
+    name: "schema.describe",
+    description: "Get the full schema for a specific collection including field types and role permissions",
+    params: {
+      collection: { type: "string", description: "Collection name to describe", required: true }
+    }
+  },
+  // User tools
+  {
+    name: "user.current",
+    description: "Get the current user's profile (ID, name, email, role)",
+    params: {}
+  },
+  {
+    name: "user.list",
+    description: "List all users in this room",
+    params: {}
+  },
+  // Yjs tools (collaborative document access)
+  {
+    name: "yjs.list",
+    description: "List all Yjs documents stored in this room, showing collection, recordId, fieldName, and last update time",
+    params: {}
+  },
+  {
+    name: "yjs.getText",
+    description: "Read text content from a Yjs document (for fields using useYjsText)",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      recordId: { type: "string", description: "Record ID", required: true },
+      fieldName: { type: "string", description: 'Field name (e.g., "content")', required: true }
+    }
+  },
+  {
+    name: "yjs.setText",
+    description: "Write text content to a Yjs document (replaces existing text, broadcasts to connected clients)",
+    params: {
+      collection: { type: "string", description: "Collection name", required: true },
+      recordId: { type: "string", description: "Record ID", required: true },
+      fieldName: { type: "string", description: 'Field name (e.g., "content")', required: true },
+      text: { type: "string", description: "The text content to set", required: true }
+    }
+  }
+];
+
 // src/shared/protocol/messages.ts
 var EMPTY = Object.freeze({});
 var clientBuild = {
@@ -1436,6 +1573,86 @@ function deleteRecord(ctx, collection, recordId, userId, userRole, skipUserRbac
   notifyTeamMembershipChange(ctx, collection, record);
   return { success: true, data: { deleted: true } };
 }
+function refuseUnknownWhere(collection, schema, where) {
+  const columns = (schema.columns ?? []).map(resolveColumn);
+  const filterable = ["recordId", "createdBy", ...columns.map((c) => c.name)];
+  const unknown = Object.keys(where).filter(
+    (key) => key !== "recordId" && key !== "createdBy" && !columns.some((c) => c.id === columnId(key) || c.name === key)
+  );
+  if (unknown.length > 0) {
+    return {
+      success: false,
+      error: `Unknown field(s) in where for "${collection}": ${unknown.join(", ")} \u2014 filterable fields: ${filterable.join(", ")}`
+    };
+  }
+  const nonPrimitive = Object.entries(where).filter(([, v]) => v !== null && typeof v === "object");
+  if (nonPrimitive.length > 0) {
+    return {
+      success: false,
+      error: `where values must be primitives (equality only): ${nonPrimitive.map(([k]) => k).join(", ")}`
+    };
+  }
+  return null;
+}
+function deleteWhere(ctx, collection, where, limit, userId, userRole, skipUserRbac = false) {
+  const resolved = resolveCollection(ctx, collection);
+  if (!resolved.ok) return { success: false, error: resolved.error };
+  const schema = resolved.schema;
+  if (!schema) {
+    return {
+      success: false,
+      error: `records.deleteWhere: collection "${collection}" has no schema, so it has no filterable fields \u2014 delete its rows by recordId with records.delete`
+    };
+  }
+  if (!where || typeof where !== "object" || Array.isArray(where) || Object.keys(where).length === 0) {
+    return { success: false, error: "Missing required param: where (must match at least one field)" };
+  }
+  const whereRefusal = refuseUnknownWhere(collection, schema, where);
+  if (whereRefusal) return whereRefusal;
+  if (limit !== void 0 && !(typeof limit === "number" && Number.isFinite(limit))) {
+    return { success: false, error: "limit must be a finite number" };
+  }
+  const page = Math.min(
+    Math.max(1, Math.floor(limit ?? DEFAULT_DELETE_WHERE_LIMIT)),
+    MAX_DELETE_WHERE_LIMIT
+  );
+  const scan = { capped: false };
+  const matched = executeQuery(
+    ctx,
+    { collection, where, limit: page },
+    userId,
+    userRole,
+    skipUserRbac,
+    scan
+  );
+  if (scan.capped && matched.length < page) {
+    return {
+      success: false,
+      error: `records.deleteWhere scanned ${MAX_FILTERED_SCAN_ROWS} rows without filling a page of readable matches in "${collection}" \u2014 narrow \`where\` (or delete by recordId) and retry`
+    };
+  }
+  if (!skipUserRbac && schema) {
+    const permCtx = ctx.getPermissionContext();
+    for (const record of matched) {
+      if (!canDelete(schema, userRole, record, userId, permCtx)) {
+        return { success: false, error: `DELETE DENIED: role=${userRole}, collection=${collection}` };
+      }
+    }
+  }
+  let deleted = 0;
+  for (const record of matched) {
+    if (deleteRecord(ctx, collection, record.recordId, userId, userRole, skipUserRbac).success) {
+      deleted++;
+    }
+  }
+  if (deleted < matched.length) {
+    return {
+      success: false,
+      error: `Deleted ${deleted} of ${matched.length} matched record(s) in "${collection}"; the rest failed \u2014 retry`
+    };
+  }
+  return { success: true, data: { deleted } };
+}
 function readRecord(ctx, collection, recordId, userId, userRole, skipUserRbac = false) {
   const resolved = resolveCollection(ctx, collection);
   if (!resolved.ok) return { success: false, error: resolved.error };
@@ -1771,7 +1988,8 @@ function handleSubscribe(ctx, ws, attachment, payload) {
 }
 function handleUnsubscribe(_ctx, _ws, _attachment, _payload) {
 }
-function executeQuery(ctx, query, userId, userRole, skipUserRbac = false) {
+var MAX_FILTERED_SCAN_ROWS = 5e3;
+function executeQuery(ctx, query, userId, userRole, skipUserRbac = false, scanState) {
   const resolved = resolveCollection(ctx, query.collection);
   if (!resolved.ok) return [];
   if (!resolved.schema) {
@@ -1784,7 +2002,8 @@ function executeQuery(ctx, query, userId, userRole, skipUserRbac = false) {
     userId,
     userRole,
     resolved.isSystem,
-    skipUserRbac
+    skipUserRbac,
+    scanState
   );
 }
 function executeSystemQuery(ctx, query) {
@@ -1821,7 +2040,7 @@ function preloadUserTeamIds(ctx, userId) {
   );
   return cursor.toArray().map((r) => r.col_teamid);
 }
-function executeTableQuery(ctx, query, schema, userId, userRole, isSystem, skipUserRbac = false) {
+function executeTableQuery(ctx, query, schema, userId, userRole, isSystem, skipUserRbac = false, scanState) {
   const columns = (schema.columns ?? []).map(resolveColumn);
   const perms = getRolePermissions(schema, userRole);
   let sql = buildTableSelect(query.collection, columns);
@@ -1829,16 +2048,27 @@ function executeTableQuery(ctx, query, schema, userId, userRole, isSystem, skipU
   const whereClauses = [];
   let skipPerRecordCheck = skipUserRbac;
   if (!skipUserRbac && schema.teamField && perms.read === "team") {
-    const filterCol = schema.teamField === "_rowId" ? "_row_id" : columns.find((c) => c.name === schema.teamField)?.id ?? columnId(schema.teamField);
-    const teamIds = preloadUserTeamIds(ctx, userId);
-    if (teamIds && teamIds.length > 0) {
-      const placeholders = teamIds.map(() => "?").join(", ");
-      whereClauses.push(`("${filterCol}" IN (${placeholders}) OR _created_by = ?)`);
-      params.push(...teamIds, userId);
-    } else {
-      whereClauses.push(`_created_by = ?`);
+    const filterCol = schema.teamField === "_rowId" ? "_row_id" : columns.find((c) => c.name === schema.teamField)?.id;
+    const teamIds = filterCol ? preloadUserTeamIds(ctx, userId) : null;
+    if (filterCol) {
+      if (teamIds && teamIds.length > 0) {
+        const placeholders = teamIds.map(() => "?").join(", ");
+        whereClauses.push(`("${filterCol}" IN (${placeholders}) OR _created_by = ?)`);
+        params.push(...teamIds, userId);
+      } else {
+        whereClauses.push(`_created_by = ?`);
+        params.push(userId);
+      }
+      skipPerRecordCheck = true;
+    }
+  } else if (!skipUserRbac && perms.read === "own") {
+    const ownerCol = schema.ownerField ? columns.find((c) => c.name === schema.ownerField)?.id : "_created_by";
+    if (ownerCol) {
+      whereClauses.push(`"${ownerCol}" = ?`);
       params.push(userId);
+      skipPerRecordCheck = true;
     }
+  } else if (!skipUserRbac && perms.read === true) {
     skipPerRecordCheck = true;
   }
   if (query.where) {
@@ -1876,27 +2106,44 @@ function executeTableQuery(ctx, query, schema, userId, userRole, isSystem, skipU
   } else {
     sql += ` ORDER BY _created_at DESC`;
   }
-  if (query.limit) {
-    sql += ` LIMIT ?`;
-    params.push(query.limit);
-  }
-  const cursor = ctx.sql.exec(sql, ...params);
+  const readPage = (limitClause, limitParams) => {
+    const cursor = ctx.sql.exec(sql + limitClause, ...params, ...limitParams);
+    const rows = cursor.toArray();
+    const records = [];
+    for (const row of rows) {
+      const r = row;
+      const record = {
+        recordId: r._row_id,
+        data: rowToData(r, columns),
+        createdBy: r._created_by,
+        createdAt: r._created_at,
+        updatedAt: r._updated_at
+      };
+      if (isSystem || skipPerRecordCheck || canRead(schema, userRole, { data: record.data, createdBy: record.createdBy, recordId: record.recordId }, userId, ctx.getPermissionContext())) {
+        records.push(record);
+      }
+    }
+    return { records, scanned: rows.length };
+  };
+  if (!query.limit) return readPage("", []).records;
+  const rowFiltered = !isSystem && !skipPerRecordCheck;
+  if (!rowFiltered) return readPage(" LIMIT ?", [query.limit]).records;
   const results = [];
-  for (const row of cursor.toArray()) {
-    const r = row;
-    const data = rowToData(r, columns);
-    const record = {
-      recordId: r._row_id,
-      data,
-      createdBy: r._created_by,
-      createdAt: r._created_at,
-      updatedAt: r._updated_at
-    };
-    if (isSystem || skipPerRecordCheck || canRead(schema, userRole, { data: record.data, createdBy: record.createdBy, recordId: record.recordId }, userId, ctx.getPermissionContext())) {
+  const batch = Math.max(query.limit, 200);
+  for (let offset = 0; ; offset += batch) {
+    const { records, scanned } = readPage(" LIMIT ? OFFSET ?", [batch, offset]);
+    for (const record of records) {
       results.push(record);
+      if (results.length >= query.limit) return results;
+    }
+    if (scanned < batch) return results;
+    if (offset + batch >= MAX_FILTERED_SCAN_ROWS) {
+      if (scanState && readPage(" LIMIT ? OFFSET ?", [1, offset + batch]).scanned > 0) {
+        scanState.capped = true;
+      }
+      return results;
     }
   }
-  return results;
 }
 function recordMatchesSubscription(record, collection, query, userId, userRole, schema, ctx) {
   if (query.collection !== collection) return false;
@@ -2093,30 +2340,56 @@ async function registerUser(sql, userId, name, email, imageUrl, isAdmin, default
   );
   return { id: userId, email, name, imageUrl, role, createdAt: now, lastSeenAt: now };
 }
+function rosterFor(ctx, schema, records, publicRoster, attachment) {
+  if (isAnonymousUserId(attachment.userId)) return [];
+  if (attachment.role === "admin") {
+    const permissionContext = ctx.getPermissionContext();
+    return records.filter((record) => canRead(schema, "admin", record, attachment.userId, permissionContext)).map((record) => ({ id: record.recordId, ...record.data }));
+  }
+  if (!getRolePermissions(schema, attachment.role).read) return [];
+  if (schema.roster === "read-policy") {
+    const permissionContext = ctx.getPermissionContext();
+    const readable = new Set(
+      records.filter((record) => canRead(schema, attachment.role, record, attachment.userId, permissionContext)).map((record) => record.recordId)
+    );
+    return publicRoster.filter((user) => readable.has(user.id));
+  }
+  return publicRoster;
+}
+function publicIdentities(records) {
+  return records.map(({ recordId, data }) => ({
+    id: recordId,
+    name: data.name,
+    ...data.imageUrl ? { imageUrl: data.imageUrl } : {},
+    role: data.role
+  }));
+}
 function handleUserList(ctx, ws, attachment) {
   const schema = ctx.schemaRegistry.get("users");
-  const permissionContext = ctx.getPermissionContext();
-  const visibleRecords = attachment.userId.startsWith("anon-") || !schema ? [] : getAllUserRecords(ctx.sql, ctx.schemaRegistry).filter(
-    (record) => canRead(
-      schema,
-      attachment.role,
-      record,
-      attachment.userId,
-      permissionContext
-    )
-  );
-  const users = visibleRecords.map((record) => {
-    if (attachment.role === "admin") return { id: record.recordId, ...record.data };
-    const { name, imageUrl, role } = record.data;
-    return {
-      id: record.recordId,
-      name,
-      ...imageUrl ? { imageUrl } : {},
-      role
-    };
-  });
+  if (!schema) {
+    ctx.send(ws, { type: MSG.USER_LIST, payload: { users: [] } });
+    return;
+  }
+  const records = getAllUserRecords(ctx.sql, ctx.schemaRegistry);
+  const users = rosterFor(ctx, schema, records, publicIdentities(records), attachment);
   ctx.send(ws, { type: MSG.USER_LIST, payload: { users } });
 }
+function broadcastUserList(ctx, except) {
+  const schema = ctx.schemaRegistry.get("users");
+  if (!schema) return;
+  const skip = except instanceof Set ? except : new Set(except ? [except] : []);
+  const records = getAllUserRecords(ctx.sql, ctx.schemaRegistry);
+  const publicRoster = publicIdentities(records);
+  for (const other of ctx.state.getWebSockets()) {
+    if (skip.has(other)) continue;
+    const attachment = other.deserializeAttachment();
+    if (!attachment) continue;
+    ctx.send(other, {
+      type: MSG.USER_LIST,
+      payload: { users: rosterFor(ctx, schema, records, publicRoster, attachment) }
+    });
+  }
+}
 function handleUserUpdate(ctx, _ws, attachment, payload) {
   const existing = getUserRecord(ctx.sql, attachment.userId, ctx.schemaRegistry);
   if (!existing) return;
@@ -2125,6 +2398,8 @@ function handleUserUpdate(ctx, _ws, attachment, payload) {
   if (payload.email) data.email = payload.email;
   if (payload.imageUrl !== void 0) data.imageUrl = payload.imageUrl || void 0;
   putRecord(ctx, "users", attachment.userId, data, attachment.userId, "admin", true, true);
+  const rosterChanged = data.name !== void 0 && data.name !== existing.data.name || data.imageUrl !== void 0 && data.imageUrl !== existing.data.imageUrl;
+  if (rosterChanged) broadcastUserList(ctx);
 }
 async function handleSetRole(ctx, ws, attachment, payload) {
   if (attachment.role !== "admin") {
@@ -2143,132 +2418,21 @@ async function handleSetRole(ctx, ws, attachment, payload) {
     now,
     payload.userId
   );
+  const closing = /* @__PURE__ */ new Set();
   for (const otherWs of ctx.state.getWebSockets()) {
     const otherAttachment = otherWs.deserializeAttachment();
-    if (!otherAttachment) continue;
-    if (otherAttachment.userId === payload.userId) {
-      try {
-        otherWs.close(1008, "role-changed");
-      } catch {
-      }
-      continue;
-    }
-    if (otherAttachment.role === "admin") {
-      handleUserList(ctx, otherWs, otherAttachment);
+    if (otherAttachment?.userId !== payload.userId) continue;
+    closing.add(otherWs);
+    try {
+      otherWs.close(1008, "role-changed");
+    } catch {
     }
   }
+  broadcastUserList(ctx, closing);
 }
 
 // src/server/handlers/tools-api.ts
 import * as Y3 from "yjs";
-
-// src/server/utils/tools.ts
-var DEFAULT_QUERY_LIMIT = 50;
-function applyAiToolDefaults(toolName, params) {
-  if (toolName === "records.query" && params.limit === void 0) {
-    return { ...params, limit: DEFAULT_QUERY_LIMIT };
-  }
-  return params;
-}
-var BUILT_IN_TOOLS = [
-  // Record tools (structured collections with RBAC)
-  {
-    name: "records.query",
-    description: `Query records from a collection with optional filtering, ordering, and pagination. Returns at most \`limit\` records (default ${DEFAULT_QUERY_LIMIT}). Large result sets are capped at ~30KB: an oversized page is truncated to the leading records that fit and flagged with \`{ truncated, returned, total }\`, so narrow with a \`where\` filter (or page via \`orderBy\` + \`limit\`) to see the rest.`,
-    params: {
-      collection: { type: "string", description: "Collection name to query", required: true },
-      where: { type: "object", description: "Filter object with field=value equality conditions", required: false },
-      orderBy: { type: "string", description: 'Field to order by (or "createdAt"/"updatedAt")', required: false },
-      orderDir: { type: "string", description: 'Order direction: "asc" or "desc" (default: "desc")', required: false },
-      limit: { type: "number", description: `Maximum number of records to return (default: ${DEFAULT_QUERY_LIMIT}). Oversized pages are still capped at ~30KB and truncated with returned/total flags.`, required: false }
-    }
-  },
-  {
-    name: "records.get",
-    description: "Get a single record by ID from a collection",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      recordId: { type: "string", description: "Record ID to retrieve", required: true }
-    }
-  },
-  {
-    name: "records.create",
-    description: "Create a new record in a collection",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      data: { type: "object", description: "Record data matching the collection schema", required: true },
-      recordId: { type: "string", description: "Custom record ID (auto-generated if omitted)", required: false }
-    }
-  },
-  {
-    name: "records.update",
-    description: "Update an existing record in a collection",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      recordId: { type: "string", description: "Record ID to update", required: true },
-      data: { type: "object", description: "Fields to update (merged with existing data)", required: true }
-    }
-  },
-  {
-    name: "records.delete",
-    description: "Delete a record from a collection",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      recordId: { type: "string", description: "Record ID to delete", required: true }
-    }
-  },
-  // Schema tools
-  {
-    name: "schema.list",
-    description: "List all registered collection schemas with their fields and permissions",
-    params: {}
-  },
-  {
-    name: "schema.describe",
-    description: "Get the full schema for a specific collection including field types and role permissions",
-    params: {
-      collection: { type: "string", description: "Collection name to describe", required: true }
-    }
-  },
-  // User tools
-  {
-    name: "user.current",
-    description: "Get the current user's profile (ID, name, email, role)",
-    params: {}
-  },
-  {
-    name: "user.list",
-    description: "List all users in this room",
-    params: {}
-  },
-  // Yjs tools (collaborative document access)
-  {
-    name: "yjs.list",
-    description: "List all Yjs documents stored in this room, showing collection, recordId, fieldName, and last update time",
-    params: {}
-  },
-  {
-    name: "yjs.getText",
-    description: "Read text content from a Yjs document (for fields using useYjsText)",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      recordId: { type: "string", description: "Record ID", required: true },
-      fieldName: { type: "string", description: 'Field name (e.g., "content")', required: true }
-    }
-  },
-  {
-    name: "yjs.setText",
-    description: "Write text content to a Yjs document (replaces existing text, broadcasts to connected clients)",
-    params: {
-      collection: { type: "string", description: "Collection name", required: true },
-      recordId: { type: "string", description: "Record ID", required: true },
-      fieldName: { type: "string", description: 'Field name (e.g., "content")', required: true },
-      text: { type: "string", description: "The text content to set", required: true }
-    }
-  }
-];
-
-// src/server/handlers/tools-api.ts
 var CORS_HEADERS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
@@ -2351,9 +2515,20 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
       if (!collection) return { success: false, error: "Missing required param: collection" };
       const resolved = resolveCollection(ctx, collection);
       if (!resolved.ok) return { success: false, error: resolved.error };
+      const where = params.where;
+      if (where && typeof where === "object" && Object.keys(where).length > 0) {
+        if (!resolved.schema) {
+          return {
+            success: false,
+            error: `records.query: collection "${collection}" has no schema, so it has no filterable fields \u2014 query it without \`where\``
+          };
+        }
+        const refusal = refuseUnknownWhere(collection, resolved.schema, where);
+        if (refusal) return refusal;
+      }
       const query = {
         collection,
-        where: params.where,
+        where,
         orderBy: params.orderBy,
         orderDir: params.orderDir,
         limit: params.limit
@@ -2392,6 +2567,15 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
       if (!recordId) return { success: false, error: "Missing required param: recordId" };
       return deleteRecord(ctx, collection, recordId, userId, userRole, skipUserRbac);
     }
+    // Bounded batch delete — one subrequest per page instead of one per row.
+    // Same authorization posture as `records.delete`; `deleteWhere` itself
+    // validates `where` (every key must name a real field) and `limit`, so no
+    // dispatch path can reach a collection-wide truncation.
+    case "records.deleteWhere": {
+      const collection = params.collection;
+      if (!collection) return { success: false, error: "Missing required param: collection" };
+      return deleteWhere(ctx, collection, params.where, params.limit, userId, userRole, skipUserRbac);
+    }
     // ---- Users ----
     // Bootstrap or refresh the `users` row for a given userId. Same path
     // the SDK uses on WS connect via registerUser, exposed for server
@@ -2939,12 +3123,13 @@ var RecordRoom = class extends BaseRoom {
     const userName = user.userName;
     const userEmail = user.userEmail;
     const userImageUrl = user.userImageUrl;
-    const isAuthenticated = !userId.startsWith("anon-");
+    const isAuthenticated = !isAnonymousUserId(userId);
     let attachment;
     if (isAuthenticated) {
       const isOwner2 = this.ownerUserId != null && userId === this.ownerUserId;
       const regStart = Date.now();
       const defaultRole = this.schemaRegistry.get("users")?.defaultRole ?? "member";
+      const before = getUser(this.sql, userId, this.schemaRegistry);
       const registeredUser = await registerUser(
         this.sql,
         userId,
@@ -2956,6 +3141,9 @@ var RecordRoom = class extends BaseRoom {
         this.schemaRegistry
       );
       const regMs = Date.now() - regStart;
+      if (!before || before.name !== registeredUser.name || before.imageUrl !== registeredUser.imageUrl || before.role !== registeredUser.role) {
+        broadcastUserList(this.createUserContext(), ws);
+      }
       attachment = {
         userId: registeredUser.id,
         userName,
@@ -8415,43 +8603,35 @@ async function createChat(stub, userId, opts = {}) {
   return toChatRow(result.record);
 }
 async function updateChat(stub, chatId, userId, patch) {
+  if (!await getChat(stub, chatId, userId)) return false;
   await executeToolAsApp(stub, userId, "records.update", {
     collection: "ai-chats",
     recordId: chatId,
     data: patch
   });
+  return true;
 }
+var MESSAGE_DELETE_PAGE = 200;
 async function deleteChatCascade(stub, chatId, userId) {
-  const list = await executeToolAsApp(stub, userId, "records.query", {
-    collection: "ai-messages",
-    where: { chatId }
-  });
-  const errors = [];
-  for (const env of list.records) {
-    try {
-      await executeToolAsApp(stub, userId, "records.delete", {
+  let messagesError = null;
+  try {
+    let deleted = MESSAGE_DELETE_PAGE;
+    while (deleted === MESSAGE_DELETE_PAGE) {
+      const page = await executeToolAsApp(stub, userId, "records.deleteWhere", {
         collection: "ai-messages",
-        recordId: env.recordId
+        where: { chatId },
+        limit: MESSAGE_DELETE_PAGE
       });
-    } catch (err) {
-      errors.push(err);
+      deleted = page.deleted;
     }
-  }
-  try {
-    await executeToolAsApp(stub, userId, "records.delete", {
-      collection: "ai-chats",
-      recordId: chatId
-    });
   } catch (err) {
-    errors.push(err);
-  }
-  if (errors.length > 0) {
-    const first = errors[0];
-    throw new Error(
-      `deleteChatCascade: ${errors.length} delete(s) failed; first: ${first instanceof Error ? first.message : String(first)}`,
-      { cause: errors }
-    );
+    messagesError = err;
   }
+  await executeToolAsApp(stub, userId, "records.delete", {
+    collection: "ai-chats",
+    recordId: chatId
+  });
+  if (messagesError) throw messagesError;
 }
 async function loadMessages(stub, chatId, userId) {
   const result = await executeToolAsApp(stub, userId, "records.query", {
@@ -8463,6 +8643,7 @@ async function loadMessages(stub, chatId, userId) {
   return result.records.map(toMessageRow);
 }
 async function appendMessage(stub, msg) {
+  if (!await getChat(stub, msg.chatId, msg.userId)) return false;
   const data = {
     chatId: msg.chatId,
     userId: msg.userId,
@@ -8475,6 +8656,7 @@ async function appendMessage(stub, msg) {
     recordId: msg.id,
     data
   });
+  return true;
 }
 
 // src/server/utils/metering.ts
@@ -10176,6 +10358,7 @@ export {
   AI_CHATS_SCHEMA,
   AI_MESSAGES_SCHEMA,
   ALLOWED_BINDING_TYPES,
+  ANONYMOUS_USER_ID_PREFIX,
   APP_ID_RE,
   APP_LOG_EVENT_KEYS,
   APP_NAME_RULES,
@@ -10200,6 +10383,7 @@ export {
   DEEPSPACE_AI_MODELS,
   DEEPSPACE_MODEL_CATALOG_PROVENANCE,
   DEFAULT_CONTEXT_CONFIG,
+  DEFAULT_DELETE_WHERE_LIMIT,
   DEFAULT_DO_MANIFEST,
   DEFAULT_QUERY_LIMIT,
   DEPLOYED_APPS_DEFAULTS,
@@ -10211,6 +10395,7 @@ export {
   JobRoom,
   LOG_LEVELS,
   MAX_APP_FILE_BYTES,
+  MAX_DELETE_WHERE_LIMIT,
   MAX_DEPLOY_ASSET_FILE_BYTES,
   MAX_UPLOAD_PARTS,
   MAX_UPLOAD_REQUEST_BYTES,
@@ -10311,6 +10496,7 @@ export {
   handleClientErrorReport,
   handleSyncMessage,
   hasContent,
+  isAnonymousUserId,
   isAssetNotFoundHandling,
   isAutoProvision,
   isFilesVerbPath,
@@ -10320,6 +10506,8 @@ export {
   isTestAccountEmail,
   isTestAccountTier,
   lintSchema,
+  lintSchemaSet,
+  lintSchemas,
   listDeepSpaceAgentModels,
   loadMessages,
   makeDefaultSummarizer,