deepspace 0.22.1 → 0.23.1

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,81 +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";
-
 // src/server/schemas/registry.ts
 function collectionTableName(name) {
   return `c_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
@@ -581,13 +586,11 @@ function checkUnclaimedOwnerTransition(schema, role, nextData, userId) {
   }
   return `Role '${role}' can set '${schema.ownerField}' only to their own user id or leave it unclaimed`;
 }
+var SYSTEM_ASSIGNED_COLUMNS = /* @__PURE__ */ new Set(["email", "name", "imageUrl", "role"]);
+var SYSTEM_MAINTAINED_COLUMNS = /* @__PURE__ */ new Set(["createdAt", "lastSeenAt"]);
 var SYSTEM_MANAGED_COLUMNS = /* @__PURE__ */ new Set([
-  "email",
-  "name",
-  "imageUrl",
-  "role",
-  "createdAt",
-  "lastSeenAt"
+  ...SYSTEM_ASSIGNED_COLUMNS,
+  ...SYSTEM_MAINTAINED_COLUMNS
 ]);
 var USERS_COLUMNS = [
   { name: "email", storage: "text", interpretation: "plain" },
@@ -641,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)) {
@@ -1036,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", 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 = {
@@ -1180,6 +1316,11 @@ function encode(message) {
 function getResolvedColumns(schema) {
   return (schema.columns ?? []).map(resolveColumn);
 }
+function systemManagedColumnError(column, isUpdate) {
+  const roleHint = column === "role" ? ", or the admin-gated useUsers().setRole() to change a role" : "";
+  const remedy = isUpdate ? `Re-sending the current value of '${column}' unchanged is accepted and ignored.` : `A users row is created by registration, so no value for '${column}' is accepted here \u2014 omit it.`;
+  return `FIELD ERROR: '${column}' is system-managed and cannot be set by a record write \u2014 nothing was written. Use tools.registerUser({ userId, isAdmin })${roleHint}. ${remedy}`;
+}
 function notifyTeamMembershipChange(ctx, collection, record) {
   if (collection !== "team_members") return;
   const affectedUserId = record.data.UserId;
@@ -1250,11 +1391,9 @@ function handleDelete(ctx, ws, attachment, payload) {
   }
 }
 function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRbac = false, systemUpdate = false) {
-  const isSystem = SYSTEM_COLLECTIONS.has(collection);
-  const schema = ctx.schemaRegistry.get(collection);
-  if (!schema && !isSystem) {
-    return { success: false, error: `Schema not registered for collection: ${collection}` };
-  }
+  const resolved = resolveCollection(ctx, collection);
+  if (!resolved.ok) return { success: false, error: resolved.error };
+  const schema = resolved.schema;
   if (!schema) {
     return { success: false, error: `Schema not registered for collection: ${collection}` };
   }
@@ -1309,17 +1448,7 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
       }
     }
   }
-  let finalData = mergedData;
-  if (!systemUpdate && schema.name === "users") {
-    finalData = { ...mergedData };
-    for (const key of SYSTEM_MANAGED_COLUMNS) {
-      if (existing?.data[key] !== void 0) {
-        finalData[key] = existing.data[key];
-      } else {
-        delete finalData[key];
-      }
-    }
-  }
+  const finalData = { ...mergedData };
   if (!skipUserRbac) {
     const permCtx = ctx.getPermissionContext();
     if (isUpdate) {
@@ -1351,6 +1480,17 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
       return { success: false, error: `FIELD ERROR: ${ownerError}` };
     }
   }
+  if (!systemUpdate && schema.name === "users") {
+    for (const col of columns) {
+      if (!SYSTEM_MANAGED_COLUMNS.has(col.name)) continue;
+      const current = existing?.data[col.name];
+      if (SYSTEM_ASSIGNED_COLUMNS.has(col.name) && Object.hasOwn(data, col.name) && coerceValue(data[col.name], col.storage, col.interpretation) !== coerceValue(current, col.storage, col.interpretation)) {
+        return { success: false, error: systemManagedColumnError(col.name, isUpdate) };
+      }
+      if (current !== void 0) finalData[col.name] = current;
+      else delete finalData[col.name];
+    }
+  }
   const colValues = dataToColumnValues(finalData, columns);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const tbl = collectionTableName(collection);
@@ -1410,14 +1550,12 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
   return { success: true, data: { recordId, record } };
 }
 function deleteRecord(ctx, collection, recordId, userId, userRole, skipUserRbac = false) {
-  const isSystem = SYSTEM_COLLECTIONS.has(collection);
-  const schema = ctx.schemaRegistry.get(collection);
-  if (!schema && !isSystem) {
-    return { success: false, error: `Schema not registered for collection: ${collection}` };
-  }
+  const resolved = resolveCollection(ctx, collection);
+  if (!resolved.ok) return { success: false, error: resolved.error };
+  const schema = resolved.schema;
   const existing = getRecord(ctx.sql, collection, recordId, schema);
   if (!existing) {
-    return { success: false, error: "Record not found" };
+    return { success: false, error: RECORD_NOT_FOUND };
   }
   if (!skipUserRbac && schema && !canDelete(schema, userRole, { ...existing, recordId }, userId, ctx.getPermissionContext())) {
     return { success: false, error: `DELETE DENIED: role=${userRole}, collection=${collection}` };
@@ -1435,15 +1573,88 @@ function deleteRecord(ctx, collection, recordId, userId, userRole, skipUserRbac
   notifyTeamMembershipChange(ctx, collection, record);
   return { success: true, data: { deleted: true } };
 }
-function readRecord(ctx, collection, recordId, userId, userRole, skipUserRbac = false) {
-  const isSystem = SYSTEM_COLLECTIONS.has(collection);
-  const schema = ctx.schemaRegistry.get(collection);
-  if (!schema && !isSystem) {
-    return { success: false, error: `Schema not registered for collection: ${collection}` };
+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 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(", ")}`
+    };
+  }
+  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 };
+  const schema = resolved.schema;
   const existing = getRecord(ctx.sql, collection, recordId, schema);
   if (!existing) {
-    return { success: false, error: "Record not found" };
+    return { success: false, error: RECORD_NOT_FOUND };
   }
   if (!skipUserRbac && schema && !canRead(schema, userRole, { ...existing, recordId }, userId, ctx.getPermissionContext())) {
     return { success: false, error: `READ DENIED: role=${userRole}, collection=${collection}` };
@@ -1474,9 +1685,7 @@ function hasYjsSubscription(attachment, target) {
     (subscription) => subscription.collection === target.collection && subscription.recordId === target.recordId && subscription.fieldName === target.fieldName
   );
 }
-var SYSTEM_COLLECTIONS = /* @__PURE__ */ new Set([
-  "canvas-settings"
-]);
+var SYSTEM_COLLECTIONS = /* @__PURE__ */ new Set(["canvas-settings"]);
 var SYSTEM_COLLECTION_SCHEMAS = [
   {
     name: "canvas-settings",
@@ -1493,10 +1702,7 @@ function getOrCreateYjsDoc(ctx, docKey) {
   let doc = ctx.yjsDocs.get(docKey);
   if (doc) return doc;
   doc = new Y2.Doc();
-  const row = ctx.sql.exec(
-    `SELECT state FROM yjs_docs WHERE doc_key = ?`,
-    docKey
-  ).toArray()[0];
+  const row = ctx.sql.exec(`SELECT state FROM yjs_docs WHERE doc_key = ?`, docKey).toArray()[0];
   if (row?.state) {
     try {
       Y2.applyUpdate(doc, new Uint8Array(row.state));
@@ -1561,11 +1767,17 @@ function handleYjsJoin(ctx, ws, attachment, payload) {
     }
   } else {
     if (!schema) {
-      ctx.send(ws, { type: MSG.ERROR, payload: { error: `Schema not registered for collection: ${collection}` } });
+      const resolution = resolveCollection(ctx, collection);
+      ctx.send(ws, {
+        type: MSG.ERROR,
+        payload: {
+          error: resolution.ok ? `Schema not registered for collection: ${collection}` : resolution.error
+        }
+      });
       return;
     }
     if (!record) {
-      ctx.send(ws, { type: MSG.ERROR, payload: { error: "Record not found" } });
+      ctx.send(ws, { type: MSG.ERROR, payload: { error: RECORD_NOT_FOUND } });
       return;
     }
     const permCtx = ctx.getPermissionContext();
@@ -1598,7 +1810,10 @@ function handleYjsJoin(ctx, ws, attachment, payload) {
     writeVarUint8Array(encoder2, fullState);
     ctx.sendBinary(ws, toUint8Array(encoder2));
   }
-  ctx.send(ws, { type: MSG.YJS_JOIN, payload: { collection, recordId, fieldName, canWrite: hasWriteAccess } });
+  ctx.send(ws, {
+    type: MSG.YJS_JOIN,
+    payload: { collection, recordId, fieldName, canWrite: hasWriteAccess }
+  });
 }
 function handleYjsLeave(ctx, ws, attachment, payload) {
   const { collection, recordId, fieldName } = payload;
@@ -1667,7 +1882,14 @@ function handleYjsBinaryMessage(ctx, ws, attachment, data) {
         if (!syncSchema) return;
         const record = getRecord(ctx.sql, collection, recordId, syncSchema);
         if (!record) return;
-        if (!canUpdate(syncSchema, attachment.role, { ...record, recordId }, attachment.userId, ctx.getPermissionContext())) return;
+        if (!canUpdate(
+          syncSchema,
+          attachment.role,
+          { ...record, recordId },
+          attachment.userId,
+          ctx.getPermissionContext()
+        ))
+          return;
       }
       const update = readVarUint8Array(decoder);
       Y2.applyUpdate(doc, update, "client");
@@ -1741,6 +1963,19 @@ function handleYjsDisconnect(ctx, ws, attachment) {
 }
 
 // src/server/handlers/subscriptions.ts
+function resolveCollection(ctx, collection) {
+  const isSystem = SYSTEM_COLLECTIONS.has(collection);
+  const schema = ctx.schemaRegistry.get(collection);
+  if (!schema && !isSystem) {
+    const known = ctx.schemaRegistry.names().sort().join(", ") || "(none)";
+    const room = ctx.scopeId ? `Room '${ctx.scopeId}'` : "This room";
+    return {
+      ok: false,
+      error: `Schema not registered for collection: ${collection} \u2014 ${room} serves only: ${known}. Records are sharded by scope, so address the room that owns '${collection}', or add it to the schemas this room is constructed with.`
+    };
+  }
+  return { ok: true, schema, isSystem };
+}
 function handleSubscribe(ctx, ws, attachment, payload) {
   const { subscriptionId, query } = payload;
   const records = executeQuery(ctx, query, attachment.userId, attachment.role);
@@ -1748,16 +1983,23 @@ function handleSubscribe(ctx, ws, attachment, payload) {
 }
 function handleUnsubscribe(_ctx, _ws, _attachment, _payload) {
 }
-function executeQuery(ctx, query, userId, userRole, skipUserRbac = false) {
-  const isSystem = SYSTEM_COLLECTIONS.has(query.collection);
-  const schema = ctx.schemaRegistry.get(query.collection);
-  if (!schema && !isSystem) {
-    return [];
-  }
-  if (!schema) {
+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) {
     return executeSystemQuery(ctx, query);
   }
-  return executeTableQuery(ctx, query, schema, userId, userRole, isSystem, skipUserRbac);
+  return executeTableQuery(
+    ctx,
+    query,
+    resolved.schema,
+    userId,
+    userRole,
+    resolved.isSystem,
+    skipUserRbac,
+    scanState
+  );
 }
 function executeSystemQuery(ctx, query) {
   const tbl = collectionTableName(query.collection);
@@ -1793,7 +2035,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);
@@ -1801,16 +2043,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) {
@@ -1848,27 +2101,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;
@@ -2065,30 +2335,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;
@@ -2097,6 +2393,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") {
@@ -2115,132 +2413,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",
@@ -2258,7 +2445,10 @@ async function handleToolsRequest(ctx, request, path) {
     const toolName = path.replace("tools/describe/", "");
     const tool3 = BUILT_IN_TOOLS.find((t) => t.name === toolName);
     if (!tool3) {
-      return Response.json({ error: `Tool not found: ${toolName}` }, { status: 404, headers: CORS_HEADERS });
+      return Response.json(
+        { error: `Tool not found: ${toolName}` },
+        { status: 404, headers: CORS_HEADERS }
+      );
     }
     return Response.json({ tool: tool3 }, { headers: CORS_HEADERS });
   }
@@ -2303,6 +2493,7 @@ async function handleToolExecute(ctx, request) {
   const recordCtx = {
     sql: ctx.sql,
     schemaRegistry: ctx.schemaRegistry,
+    scopeId: ctx.scopeId,
     state: ctx.state,
     getPermissionContext: ctx.getPermissionContext,
     send: ctx.send
@@ -2317,6 +2508,8 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
     case "records.query": {
       const collection = params.collection;
       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 query = {
         collection,
         where: params.where,
@@ -2358,6 +2551,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
@@ -2426,10 +2628,13 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
 }
 function checkYjsPermission(ctx, collection, recordId, userId, userRole, action) {
   if (SYSTEM_COLLECTIONS.has(collection)) return null;
-  const schema = ctx.schemaRegistry.get(collection);
-  if (!schema) return { success: false, error: `Schema not registered for collection: ${collection}` };
+  const resolution = resolveCollection(ctx, collection);
+  if (!resolution.ok) return { success: false, error: resolution.error };
+  const schema = resolution.schema;
+  if (!schema)
+    return { success: false, error: `Schema not registered for collection: ${collection}` };
   const record = getRecord(ctx.sql, collection, recordId, schema);
-  if (!record) return { success: false, error: `Record not found: ${collection}/${recordId}` };
+  if (!record) return { success: false, error: `${RECORD_NOT_FOUND}: ${collection}/${recordId}` };
   const recordWithId = { ...record, recordId };
   const permCtx = ctx.getPermissionContext();
   if (action === "read" && !canRead(schema, userRole, recordWithId, userId, permCtx)) {
@@ -2462,9 +2667,7 @@ function withYjsDoc(ctx, docKey, operation) {
 function executeYjsTool(ctx, toolName, params, userId, userRole) {
   switch (toolName) {
     case "yjs.list": {
-      const rows = ctx.sql.exec(
-        `SELECT doc_key, updated_at FROM yjs_docs ORDER BY updated_at DESC`
-      ).toArray();
+      const rows = ctx.sql.exec(`SELECT doc_key, updated_at FROM yjs_docs ORDER BY updated_at DESC`).toArray();
       const docs = rows.map((row) => {
         const firstColon = row.doc_key.indexOf(":");
         const lastColon = row.doc_key.lastIndexOf(":");
@@ -2904,12 +3107,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,
@@ -2921,6 +3125,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,
@@ -3087,6 +3294,10 @@ var RecordRoom = class extends BaseRoom {
       sql: this.sql,
       state: this.state,
       schemaRegistry: this.schemaRegistry,
+      // Every record room stub is addressed with `idFromName(scopeId)`, so the
+      // DO's own name is the scope. Handlers use it to name the room when a
+      // caller asks it for a collection that lives in a different scope.
+      scopeId: this.state.id.name,
       getPermissionContext: () => this.getPermissionContext(),
       send: (ws, msg) => this.send(ws, msg),
       sendBinary: (ws, data) => this.sendBinaryHelper(ws, data),
@@ -7542,7 +7753,7 @@ function authWorkerFetch(env, path, init) {
 function buildCronContext(env, ownerUserId, roomId = "default") {
   const roomIdObj = env.RECORD_ROOMS.idFromName(roomId);
   const room = env.RECORD_ROOMS.get(roomIdObj);
-  async function executeTool3(tool3, params) {
+  async function executeTool2(tool3, params) {
     const response = await room.fetch(
       new Request("https://internal/api/tools/execute", {
         method: "POST",
@@ -7565,18 +7776,18 @@ function buildCronContext(env, ownerUserId, roomId = "default") {
       const params = { collection };
       if (opts?.where) params.where = opts.where;
       if (opts?.limit) params.limit = opts.limit;
-      const data = await executeTool3("records.query", params);
+      const data = await executeTool2("records.query", params);
       const records2 = data?.records;
       return records2 ?? [];
     },
     async create(collection, data) {
-      return executeTool3("records.create", { collection, data });
+      return executeTool2("records.create", { collection, data });
     },
     async update(collection, recordId, data) {
-      return executeTool3("records.update", { collection, recordId, data });
+      return executeTool2("records.update", { collection, recordId, data });
     },
     async delete(collection, recordId) {
-      return executeTool3("records.delete", { collection, recordId });
+      return executeTool2("records.delete", { collection, recordId });
     }
   };
   const integrations = {
@@ -8312,7 +8523,7 @@ function makeDefaultSummarizer(env, options = {}) {
 }
 
 // src/server/utils/chat-history.ts
-async function executeTool2(stub, userId, tool3, params) {
+async function executeToolAsApp(stub, userId, tool3, params) {
   const res = await stub.fetch(new Request("https://internal/api/tools/execute", {
     method: "POST",
     headers: {
@@ -8353,13 +8564,15 @@ function toMessageRow(env) {
 }
 async function getChat(stub, chatId, userId) {
   try {
-    const result = await executeTool2(stub, userId, "records.get", {
+    const result = await executeToolAsApp(stub, userId, "records.get", {
       collection: "ai-chats",
       recordId: chatId
     });
-    return result.record ? toChatRow(result.record) : null;
+    if (!result.record) return null;
+    const chat = toChatRow(result.record);
+    return chat.userId === userId ? chat : null;
   } catch (err) {
-    if (err instanceof Error && err.message.includes("Record not found")) return null;
+    if (err instanceof Error && err.message.includes(RECORD_NOT_FOUND)) return null;
     throw err;
   }
 }
@@ -8367,53 +8580,45 @@ async function createChat(stub, userId, opts = {}) {
   const data = { userId };
   if (opts.title !== void 0) data.title = opts.title;
   if (opts.model !== void 0) data.model = opts.model;
-  const result = await executeTool2(stub, userId, "records.create", {
+  const result = await executeToolAsApp(stub, userId, "records.create", {
     collection: "ai-chats",
     data
   });
   return toChatRow(result.record);
 }
 async function updateChat(stub, chatId, userId, patch) {
-  await executeTool2(stub, userId, "records.update", {
+  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 executeTool2(stub, userId, "records.query", {
-    collection: "ai-messages",
-    where: { chatId }
-  });
-  const errors = [];
-  for (const env of list.records) {
-    try {
-      await executeTool2(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 executeTool2(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 executeTool2(stub, userId, "records.query", {
+  const result = await executeToolAsApp(stub, userId, "records.query", {
     collection: "ai-messages",
     where: { chatId, userId },
     orderBy: "createdAt",
@@ -8422,6 +8627,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,
@@ -8429,11 +8635,12 @@ async function appendMessage(stub, msg) {
     content: msg.content
   };
   if (msg.parts !== void 0) data.parts = msg.parts;
-  await executeTool2(stub, msg.userId, "records.create", {
+  await executeToolAsApp(stub, msg.userId, "records.create", {
     collection: "ai-messages",
     recordId: msg.id,
     data
   });
+  return true;
 }
 
 // src/server/utils/metering.ts
@@ -10135,6 +10342,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,
@@ -10159,6 +10367,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,
@@ -10170,6 +10379,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,
@@ -10185,6 +10395,7 @@ export {
   PresenceRoom,
   REACTIONS_SCHEMA,
   READ_RECEIPTS_SCHEMA,
+  RECORD_NOT_FOUND,
   REGISTRY_INSTANCE,
   RELEASE_STAMP_PATH,
   REPO_STORE_LIMIT_BYTES,
@@ -10201,7 +10412,9 @@ export {
   SDK_RUN_WORKER_FIRST,
   SECURE_ROOM_BOUNDARIES_MIGRATION_ID,
   STRICT_APP_ID_RE,
+  SYSTEM_ASSIGNED_COLUMNS,
   SYSTEM_COLLECTIONS,
+  SYSTEM_MAINTAINED_COLUMNS,
   SYSTEM_MANAGED_COLUMNS,
   SchemaRegistry,
   TEST_ACCOUNT_EMAIL_SUFFIX,
@@ -10267,6 +10480,7 @@ export {
   handleClientErrorReport,
   handleSyncMessage,
   hasContent,
+  isAnonymousUserId,
   isAssetNotFoundHandling,
   isAutoProvision,
   isFilesVerbPath,
@@ -10276,6 +10490,8 @@ export {
   isTestAccountEmail,
   isTestAccountTier,
   lintSchema,
+  lintSchemaSet,
+  lintSchemas,
   listDeepSpaceAgentModels,
   loadMessages,
   makeDefaultSummarizer,