deepspace 0.23.1 → 0.24.0

package/dist/worker.js

@@ -105,11 +105,11 @@ function decodeRoomIdentityHeader(value) {
     return void 0;
   }
 }
-function authenticatedRoomRequest(request, auth, identity) {
-  const url = new URL(request.url);
+function authenticatedRoomRequest(request2, auth, identity) {
+  const url = new URL(request2.url);
   url.searchParams.delete("token");
   for (const key of IDENTITY_QUERY_PARAMS) url.searchParams.delete(key);
-  const forwarded = new Request(url.toString(), request);
+  const forwarded = new Request(url.toString(), request2);
   for (const header of IDENTITY_HEADERS) forwarded.headers.delete(header);
   if (!auth) return forwarded;
   forwarded.headers.set("x-user-id", encodeRoomIdentityHeader(auth.userId));
@@ -129,13 +129,18 @@ function authenticatedRoomRequest(request, auth, identity) {
 }
 
 // src/server/rooms/base-room.ts
-function connectionAttachmentFromRequest(request) {
+function connectionAttachmentFromRequest(request2) {
+  if (!request2.headers.has("x-user-id") && new URL(request2.url).searchParams.has("userId")) {
+    console.warn(
+      "[BaseRoom] Connection carries identity in the URL (?userId=) but no x-user-id header, so this user joins as anonymous. The app worker's room proxy predates 0.19 or forwards the client's URL unstripped: forward with authenticatedRoomRequest() from deepspace/worker."
+    );
+  }
   return {
-    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")),
-    role: decodeRoomIdentityHeader(request.headers.get("x-user-role"))
+    userId: decodeRoomIdentityHeader(request2.headers.get("x-user-id")) || `${ANONYMOUS_USER_ID_PREFIX}${crypto.randomUUID()}`,
+    userName: decodeRoomIdentityHeader(request2.headers.get("x-user-name")) || "Anonymous",
+    userEmail: decodeRoomIdentityHeader(request2.headers.get("x-user-email")) || "",
+    userImageUrl: decodeRoomIdentityHeader(request2.headers.get("x-user-image-url")),
+    role: decodeRoomIdentityHeader(request2.headers.get("x-user-role"))
   };
 }
 var BaseRoom = class {
@@ -151,15 +156,15 @@ var BaseRoom = class {
   // ==========================================================================
   // HTTP Entry Point
   // ==========================================================================
-  async fetch(request) {
-    const url = new URL(request.url);
-    const internal = await this.handleInternalRequest(request, url);
+  async fetch(request2) {
+    const url = new URL(request2.url);
+    const internal = await this.handleInternalRequest(request2, url);
     if (internal) return internal;
-    if (request.headers.get("Upgrade") === "websocket") {
-      return this.handleWebSocketUpgrade(request, url);
+    if (request2.headers.get("Upgrade") === "websocket") {
+      return this.handleWebSocketUpgrade(request2, url);
     }
     if (this.onRequest) {
-      return this.onRequest(request);
+      return this.onRequest(request2);
     }
     return new Response("Not Found", { status: 404 });
   }
@@ -180,11 +185,11 @@ var BaseRoom = class {
    * See the security note on `fetch()`: this path is only reachable via DO
    * stub fetch from the app worker, never from the public internet.
    */
-  async handleInternalRequest(request, url) {
-    if (request.method === "POST" && url.pathname === "/internal/disconnect-sockets") {
+  async handleInternalRequest(request2, url) {
+    if (request2.method === "POST" && url.pathname === "/internal/disconnect-sockets") {
       let options;
       try {
-        const text = await request.text();
+        const text = await request2.text();
         if (text) options = JSON.parse(text);
       } catch {
       }
@@ -196,11 +201,11 @@ var BaseRoom = class {
   // ==========================================================================
   // WebSocket Connection
   // ==========================================================================
-  async handleWebSocketUpgrade(request, _url) {
+  async handleWebSocketUpgrade(request2, _url) {
     const pair = new WebSocketPair();
     const [client, server] = Object.values(pair);
     this.state.acceptWebSocket(server);
-    const attachment = connectionAttachmentFromRequest(request);
+    const attachment = connectionAttachmentFromRequest(request2);
     const augmented = await this.onConnect(server, attachment) ?? attachment;
     server.serializeAttachment(augmented);
     return new Response(null, { status: 101, webSocket: client });
@@ -436,7 +441,8 @@ function dataToColumnValues(data, columns) {
   return values;
 }
 function coerceValue(value, storage, interpretation) {
-  if (value === null || value === void 0 || value === "") return null;
+  if (value === null || value === void 0) return null;
+  if (value === "") return storage === "text" ? "" : null;
   if (storage === "text") {
     if (interpretation.kind === "json") {
       if (typeof value === "string") return value;
@@ -470,7 +476,7 @@ function coerceValue(value, storage, interpretation) {
   }
   if (interpretation.kind === "date" || interpretation.kind === "datetime") {
     const d = new Date(s);
-    if (!isNaN(d.getTime())) return Math.floor(d.getTime() / 1e3);
+    if (!isNaN(d.getTime())) return epochSeconds(d);
     return s;
   }
   const cleaned = s.replace(/[$€£¥,\s]/g, "");
@@ -478,6 +484,9 @@ function coerceValue(value, storage, interpretation) {
   if (!isNaN(n) && isFinite(n)) return n;
   return s;
 }
+function epochSeconds(date = /* @__PURE__ */ new Date()) {
+  return Math.floor(date.getTime() / 1e3);
+}
 function buildTableSelect(collectionName, columns) {
   const tbl = collectionTableName(collectionName);
   const parts = ["_row_id", "_created_by", "_created_at", "_updated_at"];
@@ -1072,7 +1081,7 @@ var BUILT_IN_TOOLS = [
     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 },
+      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 }
@@ -1142,7 +1151,7 @@ var BUILT_IN_TOOLS = [
   },
   {
     name: "user.list",
-    description: "List all users in this room",
+    description: "List the users this caller may see, exactly as the room's roster does: an admin gets whole rows (including email and any app-defined column) through the users collection's read policy; everyone else gets the public identity projection (id, name, imageUrl, role, lastSeenAt) of the roster the users policy allows them \u2014 nothing if that policy denies reads, and only their own scope if the schema sets `roster: 'read-policy'`. A caller with no identity gets an empty list. Called from a server action (X-App-Action), it returns whole rows like the other RBAC-off tools.",
     params: {}
   },
   // Yjs tools (collaborative document access)
@@ -1316,6 +1325,9 @@ function encode(message) {
 function getResolvedColumns(schema) {
   return (schema.columns ?? []).map(resolveColumn);
 }
+function triggerTimestamp(col) {
+  return col.storage === "number" ? epochSeconds() : (/* @__PURE__ */ new Date()).toISOString();
+}
 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.`;
@@ -1434,7 +1446,7 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
       if (!isUpdate) {
         if (mergedData[triggerField] !== void 0 && mergedData[triggerField] !== null) {
           if (triggerValue === void 0 || mergedData[triggerField] === triggerValue) {
-            mergedData[col.name] = (/* @__PURE__ */ new Date()).toISOString();
+            mergedData[col.name] = triggerTimestamp(col);
           }
         }
       } else {
@@ -1442,7 +1454,7 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
         const newVal = mergedData[triggerField];
         if (newVal !== oldVal) {
           if (triggerValue === void 0 || newVal === triggerValue) {
-            mergedData[col.name] = (/* @__PURE__ */ new Date()).toISOString();
+            mergedData[col.name] = triggerTimestamp(col);
           }
         }
       }
@@ -1487,27 +1499,27 @@ function putRecord(ctx, collection, recordId, data, userId, userRole, skipUserRb
       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;
+      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);
-  if (!isUpdate && schema.uniqueOn && schema.uniqueOn.length > 0) {
-    const uniqueWhere = schema.uniqueOn.map((fieldName) => {
-      const colSqlId = columnId(fieldName);
-      return `"${colSqlId}" = ?`;
-    });
-    const uniqueParams = schema.uniqueOn.map((fieldName) => {
-      const val = finalData[fieldName];
-      return val !== void 0 ? val : null;
+  if (schema.uniqueOn && schema.uniqueOn.length > 0) {
+    const uniqueColumns = schema.uniqueOn.map((fieldName) => {
+      const id = columns.find((column) => column.name === fieldName)?.id ?? columnId(fieldName);
+      return { id, value: colValues[id] ?? null };
     });
-    const existing2 = ctx.sql.exec(
-      `SELECT _row_id FROM "${tbl}" WHERE ${uniqueWhere.join(" AND ")} LIMIT 1`,
+    const uniqueWhere = uniqueColumns.map(({ id }) => `"${id}" = ?`);
+    const uniqueParams = uniqueColumns.map(({ value }) => value);
+    if (isUpdate) uniqueParams.push(recordId);
+    const conflict = ctx.sql.exec(
+      `SELECT _row_id FROM "${tbl}" WHERE ${uniqueWhere.join(" AND ")}${isUpdate ? " AND _row_id <> ?" : ""} LIMIT 1`,
       ...uniqueParams
     );
-    if (existing2.toArray().length > 0) {
+    if (conflict.toArray().length > 0) {
       const fields = schema.uniqueOn.map((f) => `${f}=${finalData[f] ?? "null"}`).join(", ");
       return {
         success: false,
@@ -1573,21 +1585,22 @@ function deleteRecord(ctx, collection, recordId, userId, userRole, skipUserRbac
   notifyTeamMembershipChange(ctx, collection, record);
   return { success: true, data: { deleted: true } };
 }
-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) {
+function refuseUnknownWhere(collection, schema, where) {
+  const columns = (schema?.columns ?? []).map(resolveColumn);
+  const filterable = ["recordId", "createdBy", ...columns.map((c) => c.name)];
+  if (typeof where !== "object" || where === null || Array.isArray(where)) {
+    const got = where === null ? "null" : Array.isArray(where) ? "an array" : typeof where;
     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`
+      error: `where for "${collection}" must be an object of field=value pairs, not ${got} \u2014 filterable fields: ${filterable.join(", ")}`
     };
   }
-  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)" };
+  if (!schema && Object.keys(where).length > 0) {
+    return {
+      success: false,
+      error: `"${collection}" has no schema, so it has no filterable fields \u2014 query it without \`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)
   );
@@ -1604,6 +1617,26 @@ function deleteWhere(ctx, collection, where, limit, userId, userRole, skipUserRb
       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`
+    };
+  }
+  const whereRefusal = refuseUnknownWhere(collection, schema, where);
+  if (whereRefusal) return whereRefusal;
+  if (Object.keys(where).length === 0) {
+    return {
+      success: false,
+      error: "Missing required param: where (must match at least one field)"
+    };
+  }
   if (limit !== void 0 && !(typeof limit === "number" && Number.isFinite(limit))) {
     return { success: false, error: "limit must be a finite number" };
   }
@@ -1611,32 +1644,27 @@ function deleteWhere(ctx, collection, where, limit, userId, userRole, skipUserRb
     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
+    true
   );
-  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) {
+  if (!skipUserRbac) {
     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}` };
+        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) {
+    if (deleteRecord(ctx, collection, record.recordId, userId, userRole, true).success) {
       deleted++;
     }
   }
@@ -2335,17 +2363,17 @@ 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") {
+function rosterFor(ctx, schema, records, publicRoster, userId, role) {
+  if (!userId || isAnonymousUserId(userId)) return [];
+  if (role === "admin") {
     const permissionContext = ctx.getPermissionContext();
-    return records.filter((record) => canRead(schema, "admin", record, attachment.userId, permissionContext)).map((record) => ({ id: record.recordId, ...record.data }));
+    return records.filter((record) => canRead(schema, "admin", record, userId, permissionContext)).map((record) => ({ id: record.recordId, ...record.data }));
   }
-  if (!getRolePermissions(schema, attachment.role).read) return [];
+  if (!getRolePermissions(schema, 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)
+      records.filter((record) => canRead(schema, role, record, userId, permissionContext)).map((record) => record.recordId)
     );
     return publicRoster.filter((user) => readable.has(user.id));
   }
@@ -2356,17 +2384,18 @@ function publicIdentities(records) {
     id: recordId,
     name: data.name,
     ...data.imageUrl ? { imageUrl: data.imageUrl } : {},
-    role: data.role
+    role: data.role,
+    lastSeenAt: data.lastSeenAt
   }));
 }
-function handleUserList(ctx, ws, attachment) {
+function rosterForCaller(ctx, userId, role) {
   const schema = ctx.schemaRegistry.get("users");
-  if (!schema) {
-    ctx.send(ws, { type: MSG.USER_LIST, payload: { users: [] } });
-    return;
-  }
+  if (!schema) return [];
   const records = getAllUserRecords(ctx.sql, ctx.schemaRegistry);
-  const users = rosterFor(ctx, schema, records, publicIdentities(records), attachment);
+  return rosterFor(ctx, schema, records, publicIdentities(records), userId, role);
+}
+function handleUserList(ctx, ws, attachment) {
+  const users = rosterForCaller(ctx, attachment.userId, attachment.role);
   ctx.send(ws, { type: MSG.USER_LIST, payload: { users } });
 }
 function broadcastUserList(ctx, except) {
@@ -2381,7 +2410,9 @@ function broadcastUserList(ctx, except) {
     if (!attachment) continue;
     ctx.send(other, {
       type: MSG.USER_LIST,
-      payload: { users: rosterFor(ctx, schema, records, publicRoster, attachment) }
+      payload: {
+        users: rosterFor(ctx, schema, records, publicRoster, attachment.userId, attachment.role)
+      }
     });
   }
 }
@@ -2434,8 +2465,8 @@ var CORS_HEADERS = {
   "Access-Control-Allow-Headers": "Content-Type, X-User-Id, X-App-Action",
   "Content-Type": "application/json"
 };
-async function handleToolsRequest(ctx, request, path) {
-  if (request.method === "OPTIONS") {
+async function handleToolsRequest(ctx, request2, path) {
+  if (request2.method === "OPTIONS") {
     return new Response(null, { headers: CORS_HEADERS });
   }
   if (path === "tools/list") {
@@ -2452,15 +2483,15 @@ async function handleToolsRequest(ctx, request, path) {
     }
     return Response.json({ tool: tool3 }, { headers: CORS_HEADERS });
   }
-  if (path.startsWith("tools/execute") && request.method === "POST") {
-    return handleToolExecute(ctx, request);
+  if (path.startsWith("tools/execute") && request2.method === "POST") {
+    return handleToolExecute(ctx, request2);
   }
   return Response.json({ error: "Not found" }, { status: 404, headers: CORS_HEADERS });
 }
-async function handleToolExecute(ctx, request) {
+async function handleToolExecute(ctx, request2) {
   let body;
   try {
-    body = await request.json();
+    body = await request2.json();
   } catch {
     return Response.json(
       { success: false, error: "Invalid JSON body" },
@@ -2474,8 +2505,8 @@ async function handleToolExecute(ctx, request) {
       { status: 400, headers: CORS_HEADERS }
     );
   }
-  const userId = request.headers.get("x-user-id") ?? "";
-  const isAppAction = request.headers.get("x-app-action")?.toLowerCase() === "true";
+  const userId = request2.headers.get("x-user-id") ?? "";
+  const isAppAction = request2.headers.get("x-app-action")?.toLowerCase() === "true";
   let userRole = "viewer";
   if (userId && ctx.ownerUserId && userId === ctx.ownerUserId) {
     userRole = "admin";
@@ -2510,9 +2541,14 @@ 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 };
+      if (params.where !== void 0) {
+        const refusal = refuseUnknownWhere(collection, resolved.schema, params.where);
+        if (refusal) return refusal;
+      }
+      const where = params.where;
       const query = {
         collection,
-        where: params.where,
+        where,
         orderBy: params.orderBy,
         orderDir: params.orderDir,
         limit: params.limit
@@ -2618,8 +2654,16 @@ async function executeTool(ctx, toolName, params, userId, userRole, skipUserRbac
       if (!user) return { success: false, error: "User not found" };
       return { success: true, data: { user } };
     }
+    // The same roster the socket's `user.list` returns, for the same caller.
+    // Reading the users table directly here handed any member every peer's
+    // email regardless of the room's users policy, while their own socket
+    // roster and `useQuery('users')` obeyed it.
+    //
+    // An app action (`X-App-Action`) is the app's own server-side code, which
+    // is already the trust boundary and reads every other collection RBAC-off;
+    // it keeps the full rows.
     case "user.list": {
-      const users = getAllUsers(ctx.sql, ctx.schemaRegistry);
+      const users = skipUserRbac ? getAllUsers(ctx.sql, ctx.schemaRegistry) : rosterForCaller(ctx, userId, userRole);
       return { success: true, data: { users } };
     }
     default:
@@ -2754,25 +2798,25 @@ var CORS_HEADERS2 = {
   "Access-Control-Allow-Headers": "Content-Type",
   "Content-Type": "application/json"
 };
-async function handleApiRequest(ctx, request, url) {
-  if (request.method === "OPTIONS") {
+async function handleApiRequest(ctx, request2, url) {
+  if (request2.method === "OPTIONS") {
     return new Response(null, { headers: CORS_HEADERS2 });
   }
   const path = url.pathname.replace("/api/", "");
   if (path.startsWith("tools/")) {
-    return handleToolsRequest(ctx, request, path);
+    return handleToolsRequest(ctx, request2, path);
   }
   if (path === "debug/status") {
     return handleDebugStatus(ctx);
   }
   if (path === "debug/sql") {
-    return handleDebugSql(ctx, request, url);
+    return handleDebugSql(ctx, request2, url);
   }
   if (path === "debug/user-role") {
     return handleDebugUserRole(ctx, url);
   }
-  if (path === "debug/set-role" && request.method === "POST") {
-    return handleDebugSetRole(ctx, request);
+  if (path === "debug/set-role" && request2.method === "POST") {
+    return handleDebugSetRole(ctx, request2);
   }
   if (path.startsWith("debug/records/")) {
     return handleDebugRecords(ctx, path);
@@ -2803,8 +2847,8 @@ function handleDebugUserRole(ctx, url) {
     role: user.role
   }, { headers: CORS_HEADERS2 });
 }
-async function handleDebugSetRole(ctx, request) {
-  const body = await request.json();
+async function handleDebugSetRole(ctx, request2) {
+  const body = await request2.json();
   if (!body.role) {
     return Response.json({ error: "role is required" }, { status: 400, headers: CORS_HEADERS2 });
   }
@@ -2912,11 +2956,11 @@ function handleDebugQuery(ctx, url) {
     records
   }, { headers: CORS_HEADERS2 });
 }
-async function handleDebugSql(ctx, request, url) {
+async function handleDebugSql(ctx, request2, url) {
   let sql;
   let params = [];
-  if (request.method === "POST") {
-    const body = await request.json();
+  if (request2.method === "POST") {
+    const body = await request2.json();
     sql = body.sql;
     params = body.params ?? [];
   } else {
@@ -3036,10 +3080,10 @@ var RecordRoom = class extends BaseRoom {
   // ============================================================================
   // HTTP Entry Point (overrides BaseRoom.fetch)
   // ============================================================================
-  async fetch(request) {
-    const url = new URL(request.url);
+  async fetch(request2) {
+    const url = new URL(request2.url);
     if (url.pathname.startsWith("/internal/")) {
-      const internal = await this.handleInternalRequest(request, url);
+      const internal = await this.handleInternalRequest(request2, url);
       if (internal) return internal;
     }
     const fetchStart = Date.now();
@@ -3052,11 +3096,11 @@ var RecordRoom = class extends BaseRoom {
       if (url.pathname.startsWith("/api/debug/") && !this.debugRoutesEnabled) {
         return new Response("Not Found", { status: 404 });
       }
-      return handleApiRequest(this.createHandlerContext(), request, url);
+      return handleApiRequest(this.createHandlerContext(), request2, url);
     }
-    if (request.headers.get("Upgrade") === "websocket") {
+    if (request2.headers.get("Upgrade") === "websocket") {
       this._fetchTiming = { fetchStart, isColdStart, needsInit, initMs };
-      return super.fetch(request);
+      return super.fetch(request2);
     }
     return new Response("Not Found", { status: 404 });
   }
@@ -3638,9 +3682,9 @@ var CanvasRoom = class extends BaseRoom {
   // --------------------------------------------------------------------------
   // BaseRoom Lifecycle
   // --------------------------------------------------------------------------
-  async fetch(request) {
+  async fetch(request2) {
     this.ensureInitialized();
-    return super.fetch(request);
+    return super.fetch(request2);
   }
   onConnect(ws, user) {
     this.ensureInitialized();
@@ -4119,6 +4163,7 @@ function cronMatches(parsed, timezone, date) {
 }
 
 // src/server/rooms/cron-room.ts
+var CRON_TASKS_INTERNAL_PATH = "/internal/cron/tasks";
 var CRON_WRITE_TYPES = /* @__PURE__ */ new Set([
   MSG.CRON_TRIGGER,
   MSG.CRON_PAUSE,
@@ -4193,9 +4238,15 @@ var CronRoom = class extends BaseRoom {
   // ==========================================================================
   // BaseRoom Lifecycle
   // ==========================================================================
-  async fetch(request) {
+  async fetch(request2) {
     this.ensureInitialized();
-    return super.fetch(request);
+    return super.fetch(request2);
+  }
+  async handleInternalRequest(request2, url) {
+    if (request2.method === "GET" && url.pathname === CRON_TASKS_INTERNAL_PATH) {
+      return Response.json({ tasks: this.getTaskStates() });
+    }
+    return super.handleInternalRequest(request2, url);
   }
   onConnect(ws, user) {
     this.ensureInitialized();
@@ -4343,15 +4394,22 @@ var CronRoom = class extends BaseRoom {
     const start = Date.now();
     let success = true;
     let error;
+    let thrown;
     try {
       await this.onTask(taskName);
     } catch (e) {
       success = false;
+      thrown = e;
       error = e instanceof Error ? e.message : String(e);
-      console.error(`[CronRoom] Task "${taskName}" failed:`, e);
     }
     const durationMs = Date.now() - start;
     const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (success) {
+      console.log(`[cron] ${taskName} ok ${durationMs}ms`);
+    } else {
+      const stack = thrown instanceof Error ? thrown.stack : void 0;
+      console.error(`[cron] ${taskName} failed ${durationMs}ms: ${error}`, ...stack ? [stack] : []);
+    }
     this.sql.exec(
       `INSERT INTO cron_history (task_name, started_at, completed_at, success, duration_ms, error, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`,
@@ -4460,6 +4518,19 @@ var CronRoom = class extends BaseRoom {
     );
   }
 };
+var armedCronRooms = /* @__PURE__ */ new Set();
+function armCronRoom(ctx, namespace, roomId, tasks) {
+  if (tasks.length === 0 || armedCronRooms.has(roomId)) return;
+  armedCronRooms.add(roomId);
+  ctx.waitUntil(
+    namespace.get(namespace.idFromName(roomId)).fetch(`https://internal${CRON_TASKS_INTERNAL_PATH}`).then((response) => {
+      if (!response.ok) armedCronRooms.delete(roomId);
+      return response;
+    }).catch(() => {
+      armedCronRooms.delete(roomId);
+    })
+  );
+}
 function computeNextRunAt(task, from) {
   if (task.interval_minutes) {
     return new Date(from.getTime() + task.interval_minutes * 60 * 1e3).toISOString();
@@ -4532,9 +4603,9 @@ var JobRoom = class extends BaseRoom {
   // ==========================================================================
   // BaseRoom Lifecycle
   // ==========================================================================
-  async fetch(request) {
+  async fetch(request2) {
     this.ensureInitialized();
-    return super.fetch(request);
+    return super.fetch(request2);
   }
   async onConnect(ws, user) {
     this.ensureInitialized();
@@ -4621,13 +4692,13 @@ var JobRoom = class extends BaseRoom {
    * Subclasses overriding `onRequest` should call `super.onRequest(req)`
    * for paths they don't handle.
    */
-  async onRequest(request) {
+  async onRequest(request2) {
     this.ensureInitialized();
-    const url = new URL(request.url);
-    if (request.method !== "POST" || !url.pathname.endsWith("/enqueue")) {
+    const url = new URL(request2.url);
+    if (request2.method !== "POST" || !url.pathname.endsWith("/enqueue")) {
       return new Response("Not Found", { status: 404 });
     }
-    const body = await request.json().catch(() => null);
+    const body = await request2.json().catch(() => null);
     if (!body || typeof body.type !== "string" || !body.type) {
       return new Response(JSON.stringify({ error: "type required" }), {
         status: 400,
@@ -4793,7 +4864,8 @@ var JobRoom = class extends BaseRoom {
     } catch (e) {
       outcome = "failed";
       errorMessage = e instanceof Error ? e.message : String(e);
-      console.error(`[JobRoom] Job "${row.type}" (${row.id}) failed:`, e);
+      const stack = e instanceof Error ? e.stack : void 0;
+      console.error(`[jobs] ${row.type} (${row.id}) failed: ${errorMessage}`, ...stack ? [stack] : []);
     } finally {
       this.inFlight.delete(row.id);
     }
@@ -5107,7 +5179,8 @@ var AUTO_PROVISIONABLE_TYPES = /* @__PURE__ */ new Set([
   "kv_namespace",
   "vectorize",
   "r2_bucket",
-  "queue"
+  "queue",
+  "ai_search"
 ]);
 var VECTORIZE_METRICS = /* @__PURE__ */ new Set(["cosine", "euclidean", "dot-product"]);
 function isAutoProvision(b) {
@@ -5122,6 +5195,8 @@ function isAutoProvision(b) {
       return b.bucket_name === AUTO_PROVISION_SENTINEL;
     case "queue":
       return b.queue_name === AUTO_PROVISION_SENTINEL;
+    case "ai_search":
+      return b.instance_name === AUTO_PROVISION_SENTINEL;
     default:
       return false;
   }
@@ -5136,7 +5211,8 @@ var ALLOWED_BINDING_TYPES = /* @__PURE__ */ new Set([
   "browser_rendering",
   "analytics_engine",
   "hyperdrive",
-  "ratelimit"
+  "ratelimit",
+  "ai_search"
 ]);
 var RESERVED_BINDING_NAMES = /* @__PURE__ */ new Set([
   "ASSETS",
@@ -5160,6 +5236,7 @@ function validateBindingManifest(manifest) {
   }
   const errors = [];
   const seenNames = /* @__PURE__ */ new Set();
+  let aiSearchCount = 0;
   for (const entry of manifest) {
     if (!entry || typeof entry !== "object") {
       errors.push({
@@ -5190,14 +5267,23 @@ function validateBindingManifest(manifest) {
     }
     seenNames.add(name);
     const binding = entry;
+    if (binding.type === "ai_search") aiSearchCount++;
     const fieldErr = requiredFieldError(binding);
     if (fieldErr) errors.push({ binding, reason: fieldErr });
   }
+  if (aiSearchCount > 1) {
+    errors.push({ reason: "Only one ai_search binding may be declared per app" });
+  }
   if (errors.length) return { valid: false, errors };
   return { valid: true, bindings: manifest };
 }
 function requiredFieldError(b) {
   switch (b.type) {
+    case "ai_search":
+      if (b.instance_name !== AUTO_PROVISION_SENTINEL) {
+        return `ai_search binding "${b.name}" must set instance_name = "auto"; managed instances cannot be selected directly`;
+      }
+      return null;
     case "vectorize": {
       if (!b.index_name) return `vectorize binding "${b.name}" missing index_name (or "auto")`;
       if (b.index_name === AUTO_PROVISION_SENTINEL) {
@@ -5259,6 +5345,13 @@ function requiredFieldError(b) {
   }
 }
 function bindingManifestFromOutputConfig(outputConfig) {
+  const aiSearchNamespaces = outputConfig.ai_search_namespaces;
+  const declaresAiSearchNamespace = Array.isArray(aiSearchNamespaces) ? aiSearchNamespaces.length > 0 : aiSearchNamespaces !== void 0 && aiSearchNamespaces !== null;
+  if (declaresAiSearchNamespace) {
+    throw new Error(
+      'ai_search_namespaces is not supported by DeepSpace; declare one [[ai_search]] instance_name = "auto" instead'
+    );
+  }
   const out = [];
   const aiBinding = pluckString(outputConfig.ai, "binding");
   if (aiBinding) out.push({ type: "ai", name: aiBinding });
@@ -5276,6 +5369,11 @@ function bindingManifestFromOutputConfig(outputConfig) {
       ...metric && (metric === "cosine" || metric === "euclidean" || metric === "dot-product") && { metric }
     });
   }
+  for (const a of asObjectArray(outputConfig.ai_search)) {
+    const name = pluckString(a, "binding");
+    const instance_name = pluckString(a, "instance_name");
+    if (name && instance_name) out.push({ type: "ai_search", name, instance_name });
+  }
   for (const r of asObjectArray(outputConfig.r2_buckets)) {
     const name = pluckString(r, "binding");
     const bucket_name = pluckString(r, "bucket_name");
@@ -5811,218 +5909,8 @@ var DIRECTORY_SCHEMAS = [
   postsSchema
 ];
 
-// src/server/schemas/workspace.ts
-var workspaceTeamsSchema = {
-  name: "teams",
-  columns: [
-    { name: "Name", storage: "text", interpretation: "plain" },
-    { name: "CreatedBy", storage: "text", interpretation: "plain" },
-    { name: "IsOpen", storage: "number", interpretation: { kind: "boolean" } }
-  ],
-  teamField: "_rowId",
-  permissions: {
-    admin: { read: true, create: true, update: true, delete: true },
-    member: { read: "team", create: true, update: "team", delete: "own" }
-  }
-};
-var workspaceTeamMembersSchema = {
-  name: "team_members",
-  columns: [
-    { name: "TeamId", storage: "text", interpretation: "plain" },
-    { name: "UserId", storage: "text", interpretation: "plain" },
-    { name: "RoleInTeam", storage: "text", interpretation: { kind: "select", options: ["admin", "member"] } },
-    { name: "JoinedAt", storage: "text", interpretation: { kind: "datetime" } },
-    { name: "Email", storage: "text", interpretation: { kind: "email" } },
-    { name: "Status", storage: "text", interpretation: { kind: "select", options: ["active", "invited"] } }
-  ],
-  teamField: "TeamId",
-  permissions: {
-    admin: { read: true, create: true, update: true, delete: true },
-    member: { read: "team", create: true, update: "team", delete: "team" }
-  }
-};
-var workspaceTasksSchema = {
-  name: "tasks",
-  columns: [
-    { name: "TeamId", storage: "text", interpretation: "plain" },
-    { name: "Title", storage: "text", interpretation: "plain" },
-    { name: "Notes", storage: "text", interpretation: "plain" },
-    { name: "Completed", storage: "number", interpretation: { kind: "boolean" } },
-    { name: "CompletedAt", storage: "number", interpretation: "plain" },
-    { name: "Deleted", storage: "number", interpretation: { kind: "boolean" } },
-    { name: "DeletedAt", storage: "number", interpretation: "plain" },
-    { name: "Priority", storage: "text", interpretation: { kind: "select", options: ["none", "low", "medium", "high"] } },
-    { name: "DueDate", storage: "text", interpretation: "plain" },
-    { name: "ProjectId", storage: "text", interpretation: "plain" },
-    { name: "KanbanStatus", storage: "text", interpretation: { kind: "select", options: ["backlog", "ready", "in_progress", "review", "done"] } },
-    { name: "Order", storage: "number", interpretation: "plain" },
-    { name: "AssignedUser", storage: "text", interpretation: { kind: "json" } },
-    { name: "AssignedBy", storage: "text", interpretation: { kind: "json" } },
-    { name: "TagIds", storage: "text", interpretation: { kind: "json" } },
-    { name: "CreatedAt", storage: "number", interpretation: "plain" }
-  ],
-  teamField: "TeamId",
-  permissions: {
-    admin: { read: true, create: true, update: true, delete: true },
-    member: { read: "team", create: true, update: "team", delete: "team" },
-    viewer: { read: false, create: false, update: false, delete: false }
-  }
-};
-var workspaceProjectsSchema = {
-  name: "projects",
-  columns: [
-    { name: "TeamId", storage: "text", interpretation: "plain" },
-    { name: "Title", storage: "text", interpretation: "plain" },
-    { name: "Notes", storage: "text", interpretation: "plain" },
-    { name: "Color", storage: "text", interpretation: "plain" },
-    { name: "ParentId", storage: "text", interpretation: "plain" },
-    { name: "Order", storage: "number", interpretation: "plain" },
-    { name: "CreatedAt", storage: "number", interpretation: "plain" }
-  ],
-  teamField: "TeamId",
-  permissions: {
-    admin: { read: true, create: true, update: true, delete: true },
-    member: { read: "team", create: true, update: "team", delete: "team" },
-    viewer: { read: false, create: false, update: false, delete: false }
-  }
-};
-var workspaceTagsSchema = {
-  name: "tags",
-  columns: [
-    { name: "TeamId", storage: "text", interpretation: "plain" },
-    { name: "Name", storage: "text", interpretation: "plain" },
-    { name: "Color", storage: "text", interpretation: "plain" },
-    { name: "CreatedAt", storage: "number", interpretation: "plain" }
-  ],
-  teamField: "TeamId",
-  permissions: {
-    admin: { read: true, create: true, update: true, delete: true },
-    member: { read: "team", create: true, update: "team", delete: "team" },
-    viewer: { read: false, create: false, update: false, delete: false }
-  }
-};
-var workspacePeopleSchema = {
-  name: "people",
-  columns: [
-    { name: "Name", storage: "text", interpretation: "plain" },
-    { name: "Email", storage: "text", interpretation: { kind: "email" } },
-    { name: "Type", storage: "text", interpretation: { kind: "select", options: ["employee", "customer", "vendor", "contact"] } },
-    { name: "Status", storage: "text", interpretation: { kind: "select", options: ["active", "inactive", "archived"] } },
-    { name: "CompanyId", storage: "text", interpretation: "plain" },
-    { name: "Department", storage: "text", interpretation: "plain" },
-    { name: "Title", storage: "text", interpretation: "plain" },
-    { name: "LastContactedAt", storage: "text", interpretation: { kind: "datetime" } },
-    { name: "Metadata", storage: "text", interpretation: { kind: "json" } }
-  ],
-  permissions: {
-    "*": { read: true, create: true, update: true, delete: false },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var workspaceTransactionsSchema = {
-  name: "transactions",
-  columns: [
-    { name: "Type", storage: "text", interpretation: { kind: "select", options: ["revenue", "expense", "payment", "transfer", "invoice", "refund"] } },
-    { name: "Amount", storage: "number", interpretation: { kind: "currency", symbol: "$", decimals: 2 } },
-    { name: "Currency", storage: "text", interpretation: "plain" },
-    { name: "Description", storage: "text", interpretation: "plain" },
-    { name: "Category", storage: "text", interpretation: "plain" },
-    { name: "CounterpartyRef", storage: "text", interpretation: "plain" },
-    { name: "OrderRef", storage: "text", interpretation: "plain" },
-    { name: "Account", storage: "text", interpretation: "plain" }
-  ],
-  permissions: {
-    "*": { read: true, create: true, update: true, delete: false },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var workspaceAccountsSchema = {
-  name: "accounts",
-  columns: [
-    { name: "Name", storage: "text", interpretation: "plain" },
-    { name: "Balance", storage: "number", interpretation: { kind: "currency", symbol: "$", decimals: 2 } },
-    { name: "Currency", storage: "text", interpretation: "plain" }
-  ],
-  permissions: {
-    "*": { read: true, create: true, update: true, delete: false },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var workspaceContentSharesSchema = {
-  name: "content_shares",
-  ownerField: "OwnerId",
-  columns: [
-    { name: "ContentType", storage: "text", interpretation: { kind: "select", options: ["document", "slide", "spreadsheet"] } },
-    { name: "ContentId", storage: "text", interpretation: "plain" },
-    { name: "OwnerId", storage: "text", interpretation: "plain" },
-    { name: "OwnerName", storage: "text", interpretation: "plain" },
-    { name: "Title", storage: "text", interpretation: "plain" },
-    { name: "ShareType", storage: "text", interpretation: { kind: "select", options: ["self", "channel", "team", "direct", "link", "org"] } },
-    { name: "ShareTarget", storage: "text", interpretation: "plain" },
-    { name: "Permission", storage: "text", interpretation: { kind: "select", options: ["view", "edit"] } },
-    { name: "SharedAt", storage: "text", interpretation: { kind: "datetime" } },
-    { name: "SharedBy", storage: "text", interpretation: "plain" },
-    { name: "SourceApp", storage: "text", interpretation: "plain" },
-    { name: "WordCount", storage: "number", interpretation: "plain" },
-    { name: "LastEditedAt", storage: "text", interpretation: { kind: "datetime" } }
-  ],
-  permissions: {
-    "*": { read: true, create: true, update: true, delete: "own" },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var workspaceFormResponsesSchema = {
-  name: "form_responses",
-  columns: [
-    { name: "FormId", storage: "text", interpretation: "plain" },
-    { name: "FormTitle", storage: "text", interpretation: "plain" },
-    { name: "RespondentId", storage: "text", interpretation: "plain" },
-    { name: "RespondentEmail", storage: "text", interpretation: { kind: "email" } },
-    { name: "RespondentName", storage: "text", interpretation: "plain" },
-    { name: "Data", storage: "text", interpretation: { kind: "json" } },
-    { name: "SubmittedAt", storage: "text", interpretation: { kind: "datetime" } }
-  ],
-  permissions: {
-    "*": { read: true, create: true, update: false, delete: false },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var workspaceEmailHandlesSchema = {
-  name: "email_handles",
-  columns: [
-    { name: "UserId", storage: "text", interpretation: "plain" },
-    { name: "Handle", storage: "text", interpretation: "plain" },
-    { name: "EmailAddress", storage: "text", interpretation: { kind: "email" } },
-    { name: "Status", storage: "text", interpretation: { kind: "select", options: ["active", "disabled"] } }
-  ],
-  uniqueOn: ["Handle"],
-  ownerField: "UserId",
-  permissions: {
-    "*": { read: true, create: true, update: "own", delete: false },
-    admin: { read: true, create: true, update: true, delete: true }
-  }
-};
-var WORKSPACE_SCHEMAS = [
-  workspaceTeamsSchema,
-  workspaceTeamMembersSchema,
-  workspaceTasksSchema,
-  workspaceProjectsSchema,
-  workspaceTagsSchema,
-  workspacePeopleSchema,
-  workspaceTransactionsSchema,
-  workspaceAccountsSchema,
-  workspaceContentSharesSchema,
-  workspaceFormResponsesSchema,
-  workspaceEmailHandlesSchema
-];
-
 // src/server/schemas/shared-do.ts
 var GLOBAL_DO_TYPES = [
-  {
-    name: "workspace",
-    schemas: WORKSPACE_SCHEMAS,
-    description: "Shared workspace data (teams, tasks, projects, people, ledger)"
-  },
   {
     name: "conv",
     schemas: [...CONVERSATION_SCHEMAS, ...VOTING_SCHEMAS],
@@ -6050,6 +5938,9 @@ var APP_MIGRATION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/;
 var MAX_APP_MIGRATION_IDS = 256;
 var WORKER_OWNED_NOT_FOUND_MIGRATION_ID = "2026-08-worker-owned-not-found";
 var SECURE_ROOM_BOUNDARIES_MIGRATION_ID = "2026-08-secure-room-boundaries";
+var ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID = "2026-08-action-tools-delete-where";
+var BUILD_INJECTED_APP_ID_MIGRATION_ID = "2026-08-build-injected-app-id";
+var ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID = "2026-08-action-routes-bearer-guard";
 function validateAppMigrationIds(value) {
   if (!Array.isArray(value)) {
     return { valid: false, reason: "app migrations must be a JSON string array" };
@@ -6918,8 +6809,8 @@ function overPartBound(bytes) {
   if (bytes <= UPLOAD_PART_BYTES) return null;
   return fail2(413, oversizePartMessage(bytes), "too_large", { maxBytes: UPLOAD_PART_BYTES });
 }
-function declaredLength(request, what) {
-  const raw = request.headers.get("content-length");
+function declaredLength(request2, what) {
+  const raw = request2.headers.get("content-length");
   const declared = raw === null ? NaN : Number(raw);
   if (!Number.isSafeInteger(declared) || declared < 0) {
     return fail2(
@@ -6997,7 +6888,7 @@ function multipartFailure(error) {
 }
 function createScopedR2Handler(config) {
   const requireAuthForMutations = config.requireAuthForMutations ?? true;
-  return async (request, url, bucket, auth) => {
+  return async (request2, url, bucket, auth) => {
     let subpathRaw;
     try {
       subpathRaw = decodeURIComponent(url.pathname.replace("/api/files", "").replace(/^\//, ""));
@@ -7026,26 +6917,26 @@ function createScopedR2Handler(config) {
     }
     const prefix = result.prefix;
     const excludedPrefixes = result.excludedPrefixes ?? [];
-    if (isFilesVerbPath(request.method, subpath)) {
+    if (isFilesVerbPath(request2.method, subpath)) {
       if (requireAuthForMutations && !auth.userId) {
-        await request.body?.cancel().catch(() => void 0);
+        await request2.body?.cancel().catch(() => void 0);
         return fail2(401, "Authentication required", "unauthorized");
       }
-      return subpath === "upload" ? handleUpload(request, url, bucket, prefix, excludedPrefixes, auth, scope) : handleMultipart(request, url, bucket, prefix, excludedPrefixes, auth, scope, subpath);
+      return subpath === "upload" ? handleUpload(request2, url, bucket, prefix, excludedPrefixes, auth, scope) : handleMultipart(request2, url, bucket, prefix, excludedPrefixes, auth, scope, subpath);
     }
-    if (!subpath && request.method === "GET") {
+    if (!subpath && request2.method === "GET") {
       return handleList(bucket, prefix, excludedPrefixes, url, scope, auth);
     }
-    if (subpath && request.method === "GET") {
+    if (subpath && request2.method === "GET") {
       if (!isKeyWithinScope(subpath, prefix, excludedPrefixes)) {
         return Response.json(
           { error: "Access denied: key outside scope" },
           { status: 403, headers: CORS_HEADERS4 }
         );
       }
-      return handleDownload(request, bucket, subpath, scope);
+      return handleDownload(request2, bucket, subpath, scope);
     }
-    if (subpath && request.method === "DELETE") {
+    if (subpath && request2.method === "DELETE") {
       if (requireAuthForMutations && !auth.userId) {
         return Response.json(
           { error: "Authentication required" },
@@ -7071,18 +6962,18 @@ function createScopedR2Handler(config) {
     return Response.json({ error: "Method not allowed" }, { status: 405, headers: CORS_HEADERS4 });
   };
 }
-async function handleUpload(request, url, bucket, prefix, excludedPrefixes, auth, scope) {
+async function handleUpload(request2, url, bucket, prefix, excludedPrefixes, auth, scope) {
   try {
-    const declaredBytes = declaredLength(request, "File uploads");
+    const declaredBytes = declaredLength(request2, "File uploads");
     if (declaredBytes instanceof Response) return declaredBytes;
     const tooLargeRequest = overRequestBound(declaredBytes, 8 * 1024);
     if (tooLargeRequest) return tooLargeRequest;
-    const contentType = request.headers.get("content-type") || "";
+    const contentType = request2.headers.get("content-type") || "";
     let fileData;
     let fileName;
     let rawMimeType;
     if (contentType.includes("multipart/form-data")) {
-      const formData = await request.formData();
+      const formData = await request2.formData();
       const file = formData.get("file");
       if (!file) return fail2(400, "No file provided", "bad_request");
       const tooBig = overRequestBound(file.size);
@@ -7091,7 +6982,7 @@ async function handleUpload(request, url, bucket, prefix, excludedPrefixes, auth
       fileName = formData.get("name")?.toString() || file.name;
       rawMimeType = file.type || "application/octet-stream";
     } else {
-      const body = await request.json();
+      const body = await request2.json();
       if (!body.data || !body.name) return fail2(400, "Missing data or name", "bad_request");
       const base64Data = body.data.replace(/^data:[^;]+;base64,/, "");
       const tooBig = overRequestBound(Math.floor(base64Data.length * 3 / 4));
@@ -7172,15 +7063,15 @@ function storedFileJson(key, prefix, name, url, scope) {
   );
 }
 var MAX_CONTROL_BODY_BYTES = 64 * 1024;
-async function readControlJson(request) {
-  const declared = declaredLength(request, "This request");
+async function readControlJson(request2) {
+  const declared = declaredLength(request2, "This request");
   if (declared instanceof Response) return declared;
   if (declared > MAX_CONTROL_BODY_BYTES) {
     return fail2(413, `Request body exceeds ${MAX_CONTROL_BODY_BYTES} bytes`, "too_large");
   }
   let parsed;
   try {
-    parsed = await request.json();
+    parsed = await request2.json();
   } catch {
     return fail2(400, "Body must be JSON", "bad_request");
   }
@@ -7232,7 +7123,7 @@ function multipartLayoutError(declaredBytes) {
     { partSize: UPLOAD_PART_BYTES, partCount: multipartPartCount(declaredBytes) }
   );
 }
-async function streamPart(upload, partNumber, body, expectedBytes) {
+async function streamPart(upload2, partNumber, body, expectedBytes) {
   let observedBytes = 0;
   const sized = new FixedLengthStream(expectedBytes);
   const pumped = body.pipeThrough(
@@ -7244,7 +7135,7 @@ async function streamPart(upload, partNumber, body, expectedBytes) {
     })
   ).pipeTo(sized.writable);
   const [uploaded, drained] = await Promise.allSettled([
-    upload.uploadPart(partNumber, sized.readable),
+    upload2.uploadPart(partNumber, sized.readable),
     pumped
   ]);
   if (uploaded.status === "rejected" || drained.status === "rejected") {
@@ -7253,20 +7144,20 @@ async function streamPart(upload, partNumber, body, expectedBytes) {
   }
   return { ok: true, part: uploaded.value };
 }
-async function handleMultipart(request, url, bucket, prefix, excludedPrefixes, auth, scope, subpath) {
-  if (subpath === "multipart" && request.method === "POST") {
-    return multipartInit(request, url, bucket, prefix, excludedPrefixes, auth);
+async function handleMultipart(request2, url, bucket, prefix, excludedPrefixes, auth, scope, subpath) {
+  if (subpath === "multipart" && request2.method === "POST") {
+    return multipartInit(request2, url, bucket, prefix, excludedPrefixes, auth);
   }
   if (subpath === "multipart/part") {
-    return multipartPart(request, url, bucket, prefix, excludedPrefixes, auth);
+    return multipartPart(request2, url, bucket, prefix, excludedPrefixes, auth);
   }
   if (subpath === "multipart/complete") {
-    return multipartComplete(request, url, bucket, prefix, excludedPrefixes, auth, scope);
+    return multipartComplete(request2, url, bucket, prefix, excludedPrefixes, auth, scope);
   }
   return multipartAbort(url, bucket, prefix, excludedPrefixes, auth);
 }
-async function multipartInit(request, url, bucket, prefix, excludedPrefixes, auth) {
-  const body = await readControlJson(request);
+async function multipartInit(request2, url, bucket, prefix, excludedPrefixes, auth) {
+  const body = await readControlJson(request2);
   if (body instanceof Response) return body;
   const size = body.size;
   if (!Number.isSafeInteger(size) || size <= 0) {
@@ -7307,9 +7198,9 @@ async function multipartInit(request, url, bucket, prefix, excludedPrefixes, aut
       "request_id_conflict"
     );
   }
-  let upload;
+  let upload2;
   try {
-    upload = await bucket.createMultipartUpload(located.key, {
+    upload2 = await bucket.createMultipartUpload(located.key, {
       httpMetadata: { contentType: mimeType },
       customMetadata: fileMetadata(name, auth.userId, requestId, size)
     });
@@ -7321,7 +7212,7 @@ async function multipartInit(request, url, bucket, prefix, excludedPrefixes, aut
     body: JSON.stringify({
       version: 1,
       reservationId: requestId,
-      uploadId: upload.uploadId,
+      uploadId: upload2.uploadId,
       objectKey: located.key,
       uploadKey: located.subkey,
       admitted: false,
@@ -7335,7 +7226,7 @@ async function multipartInit(request, url, bucket, prefix, excludedPrefixes, aut
   const reservedBytes = Math.max(size, 5 * 1024 * 1024);
   const admission = await admitStorage(bucket, auth.storage, reservedBytes, 0, marker);
   if (admission instanceof Response) {
-    await upload.abort().catch(() => void 0);
+    await upload2.abort().catch(() => void 0);
     if (admission.status === 409 && auth.storage) {
       const winner = await readMultipartReservation(bucket, auth.storage, requestId);
       if (winner && winner !== "invalid" && winner.objectKey === located.key && winner.uploadKey === located.subkey && winner.declaredBytes === size && winner.admitted) {
@@ -7345,11 +7236,11 @@ async function multipartInit(request, url, bucket, prefix, excludedPrefixes, aut
     return admission;
   }
   if (auth.storage && !await activateMultipartReservation(bucket, auth.storage, requestId)) {
-    await upload.abort().catch(() => void 0);
+    await upload2.abort().catch(() => void 0);
     await releaseQuotaMarker(bucket, auth.storage, admission.markerKey, true);
     return quotaUnavailable("This upload reservation could not be finalized. Retry shortly.");
   }
-  return multipartSessionJson(upload.uploadId, located.subkey, requestId);
+  return multipartSessionJson(upload2.uploadId, located.subkey, requestId);
 }
 async function abandonMultipart(bucket, session, auth, reservation) {
   let result = "aborted";
@@ -7367,12 +7258,12 @@ async function abandonMultipart(bucket, session, auth, reservation) {
   }
   return result;
 }
-async function multipartPart(request, url, bucket, prefix, excludedPrefixes, auth) {
+async function multipartPart(request2, url, bucket, prefix, excludedPrefixes, auth) {
   const refuse = async (response) => {
-    await request.body?.cancel().catch(() => void 0);
+    await request2.body?.cancel().catch(() => void 0);
     return response;
   };
-  const declaredBytes = declaredLength(request, "Part uploads");
+  const declaredBytes = declaredLength(request2, "Part uploads");
   if (declaredBytes instanceof Response) return refuse(declaredBytes);
   const tooBig = overPartBound(declaredBytes);
   if (tooBig) return refuse(tooBig);
@@ -7384,7 +7275,7 @@ async function multipartPart(request, url, bucket, prefix, excludedPrefixes, aut
   }
   const session = resolveSession(url, prefix, excludedPrefixes);
   if (session instanceof Response) return refuse(session);
-  if (!request.body) return fail2(400, "A part body is required", "bad_request");
+  if (!request2.body) return fail2(400, "A part body is required", "bad_request");
   const reservation = await readMultipartReservation(bucket, auth.storage, session.reservationId);
   if (reservation === "invalid") {
     return refuse(quotaUnavailable("This upload reservation could not be read. Retry shortly."));
@@ -7426,8 +7317,8 @@ async function multipartPart(request, url, bucket, prefix, excludedPrefixes, aut
   if (refreshed === "busy") {
     return refuse(quotaUnavailable("This upload reservation is busy. Retry the part shortly."));
   }
-  const upload = bucket.resumeMultipartUpload(session.key, session.uploadId);
-  const stored = await streamPart(upload, partNumber, request.body, declaredBytes);
+  const upload2 = bucket.resumeMultipartUpload(session.key, session.uploadId);
+  const stored = await streamPart(upload2, partNumber, request2.body, declaredBytes);
   if (!stored.ok) {
     if (r2ErrorCode(stored.error) === 10024 && reservation) {
       await releaseQuotaMarker(bucket, auth.storage, reservation.key, true);
@@ -7483,8 +7374,8 @@ async function finishCompletedMultipart(bucket, session, reservation, object, au
   const name = object.customMetadata?.originalName ?? session.uploadKey.split("/").pop() ?? "file";
   return storedFileJson(session.key, prefix, name, url, scope);
 }
-async function multipartComplete(request, url, bucket, prefix, excludedPrefixes, auth, scope) {
-  const body = await readControlJson(request);
+async function multipartComplete(request2, url, bucket, prefix, excludedPrefixes, auth, scope) {
+  const body = await readControlJson(request2);
   if (body instanceof Response) return body;
   const session = resolveSession(url, prefix, excludedPrefixes);
   if (session instanceof Response) return session;
@@ -7643,7 +7534,7 @@ async function handleList(bucket, prefix, excludedPrefixes, url, scope, auth) {
     { headers: CORS_HEADERS4 }
   );
 }
-async function handleDownload(request, bucket, key, scope) {
+async function handleDownload(request2, bucket, key, scope) {
   const object = await bucket.get(key);
   if (!object) {
     return Response.json({ error: "File not found" }, { status: 404, headers: CORS_HEADERS4 });
@@ -7665,7 +7556,7 @@ async function handleDownload(request, bucket, key, scope) {
     contentDisposition(originalName, mustDownload ? "attachment" : "inline")
   );
   if (mustDownload) headers.set("Content-Security-Policy", "sandbox; default-src 'none'");
-  if (scope === "app" && request.headers.get("if-none-match") === object.httpEtag) {
+  if (scope === "app" && request2.headers.get("if-none-match") === object.httpEtag) {
     return new Response(null, { status: 304, headers });
   }
   return new Response(object.body, { headers });
@@ -8118,8 +8009,8 @@ async function composioTools(env, options) {
   if (!list.ok || !list.success) {
     throw new Error(`composioTools: failed to list Composio tools: ${list.detail}`);
   }
-  const listItems = list.data?.items;
-  const items = Array.isArray(listItems) ? listItems : [];
+  const listItems2 = list.data?.items;
+  const items = Array.isArray(listItems2) ? listItems2 : [];
   const tools = {};
   for (const item of items) {
     if (!item?.slug) continue;
@@ -8704,18 +8595,272 @@ var COST_RATES = {
     queriedPerDim: VECTORIZE_QUERIED_USD_PER_M_DIMS / 1e6,
     /** USD per stored dimension per month. */
     storedPerDimPerMonth: VECTORIZE_STORED_USD_PER_100M_DIMS / 1e8
+  },
+  aiSearch: {
+    ingestPerToken: 0.75 / 1e6,
+    ingestImagePerToken: 0.5 / 1e6,
+    storagePerByteMonth: 2 / 1e9,
+    hybridOrSemanticPerQuery: 0.75 / 1e3,
+    fulltextPerQuery: 0.1 / 1e3
   }
 };
 function priceBindingUsageEvent(kind, op, units) {
+  if (!Number.isFinite(units) || units < 0) return 0;
   if (kind === "ai" && op === "input") {
     return units * COST_RATES.ai.embedInputPerChar;
   }
   if (kind === "vectorize" && op === "query") {
     return units * COST_RATES.vectorize.queriedPerDim;
   }
+  if (kind === "ai_search") {
+    if (op === "ingest") return units * COST_RATES.aiSearch.ingestPerToken;
+    if (op === "ingest-image") return units * COST_RATES.aiSearch.ingestImagePerToken;
+    if (op === "storage") return units * COST_RATES.aiSearch.storagePerByteMonth;
+    if (op === "search-hybrid" || op === "search-semantic")
+      return units * COST_RATES.aiSearch.hybridOrSemanticPerQuery;
+    if (op === "search-fulltext") return units * COST_RATES.aiSearch.fulltextPerQuery;
+  }
   return 0;
 }
 
+// src/server/utils/knowledge-base.ts
+var MAX_UPLOAD_BYTES = 4 * 1024 * 1024;
+var TEXT_MIME = /^(text\/|application\/(json|xml|javascript|x-(javascript|typescript)))/iu;
+var MAX_QUERY_CHARS = 4096;
+function hasControlChar(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code < 32 || code === 127) return true;
+  }
+  return false;
+}
+var KnowledgeError = class extends Error {
+  constructor(status, code, message, uploadedItems) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.uploadedItems = uploadedItems;
+    this.name = "KnowledgeError";
+  }
+};
+function normalizeKnowledgeFolder(folder) {
+  if (!folder || folder.includes("\\") || hasControlChar(folder) || folder.startsWith("/"))
+    throw new KnowledgeError(400, "invalid_folder", "Folder must be a relative forward-slash path");
+  const withoutTrailingSlash = folder.endsWith("/") ? folder.slice(0, -1) : folder;
+  if (!withoutTrailingSlash || withoutTrailingSlash.endsWith("/"))
+    throw new KnowledgeError(400, "invalid_folder", "Folder cannot contain empty segments");
+  const parts = withoutTrailingSlash.split("/");
+  if (parts.some((part) => !part || part === "." || part === ".."))
+    throw new KnowledgeError(
+      400,
+      "invalid_folder",
+      "Folder cannot contain empty, dot, or parent segments"
+    );
+  const normalized = `${parts.join("/")}/`;
+  if (normalized.length > 128)
+    throw new KnowledgeError(400, "invalid_folder", "Folder is too long for an AI Search item key");
+  return normalized;
+}
+function validateKnowledgeFilename(name) {
+  if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\\") || hasControlChar(name)) {
+    throw new KnowledgeError(
+      400,
+      "invalid_filename",
+      "File name must be a non-empty base name without path separators"
+    );
+  }
+}
+function folderFilter(folder) {
+  const value = normalizeKnowledgeFolder(folder);
+  return { folder: { $gte: value, $lt: `${value.slice(0, -1)}0` } };
+}
+function knowledge(env) {
+  const add = (file, options = {}) => addFile(env, file, options);
+  const list = (options = {}) => listItems(env, options);
+  const search = (query, options = {}) => searchItems(env, query, options);
+  return {
+    add,
+    list,
+    search,
+    async remove(itemId) {
+      if (!/^[A-Za-z0-9_-]{1,256}$/u.test(itemId))
+        throw new KnowledgeError(400, "invalid_item_id", "Invalid knowledge item id");
+      await request(env, `/api/knowledge/items/${encodeURIComponent(itemId)}`, { method: "DELETE" });
+    },
+    scoped({ folder }) {
+      const fixed = normalizeKnowledgeFolder(folder);
+      return {
+        add: (file) => add(file, { folder: fixed }),
+        list: (options = {}) => list({ ...options, folder: fixed }),
+        search: (query, options = {}) => search(query, { ...options, folder: fixed })
+      };
+    }
+  };
+}
+async function addFile(env, file, options) {
+  validateKnowledgeFilename(file.name);
+  const folder = options.folder === void 0 ? void 0 : normalizeKnowledgeFolder(options.folder);
+  if ((folder?.length ?? 0) + file.name.length > 128)
+    throw new KnowledgeError(
+      400,
+      "invalid_key",
+      "Folder and filename together exceed the 128-character AI Search key limit"
+    );
+  if (file.size <= MAX_UPLOAD_BYTES) return upload(env, file, folder);
+  if (!TEXT_MIME.test(file.type) && !/\.(txt|md|mdx|csv|json|xml|html?|ya?ml|tsx?|jsx?|css)$/iu.test(file.name))
+    throw new KnowledgeError(
+      413,
+      "file_too_large",
+      "This file exceeds 4 MB. Split the source document with a format-aware tool before uploading."
+    );
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const parts = splitUtf8(bytes, MAX_UPLOAD_BYTES);
+  const uploaded = [];
+  try {
+    for (let i = 0; i < parts.length; i++) {
+      const bytes2 = parts[i];
+      const contents = bytes2.buffer.slice(
+        bytes2.byteOffset,
+        bytes2.byteOffset + bytes2.byteLength
+      );
+      const part = new File([contents], partName(file.name, i + 1), {
+        type: file.type || "text/plain"
+      });
+      if ((folder?.length ?? 0) + part.name.length > 128)
+        throw new KnowledgeError(
+          400,
+          "invalid_key",
+          "Folder and split filename together exceed the 128-character AI Search key limit"
+        );
+      uploaded.push(...(await upload(env, part, folder)).items);
+    }
+  } catch (error) {
+    if (error instanceof KnowledgeError)
+      throw new KnowledgeError(error.status, error.code, error.message, uploaded);
+    throw new KnowledgeError(502, "knowledge_upload_failed", "Knowledge upload failed", uploaded);
+  }
+  return { items: uploaded };
+}
+function splitUtf8(bytes, max) {
+  const out = [];
+  for (let start = 0; start < bytes.length; ) {
+    let end = Math.min(start + max, bytes.length);
+    if (end < bytes.length) {
+      let cut = end;
+      while (cut > start && (bytes[cut] & 192) === 128) cut--;
+      for (let i = cut - 1; i > Math.max(start, cut - 8192); i--)
+        if (bytes[i] === 10 && (i === start || bytes[i - 1] === 10)) {
+          cut = i + 1;
+          break;
+        }
+      end = cut > start ? cut : end;
+    }
+    out.push(bytes.slice(start, end));
+    start = end;
+  }
+  return out;
+}
+function partName(name, n) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? `${name.slice(0, dot)}.part-${n}${name.slice(dot)}` : `${name}.part-${n}`;
+}
+async function upload(env, file, folder) {
+  const body = new FormData();
+  body.append("file", file);
+  if (folder) body.append("folder", folder);
+  return await request(env, "/api/knowledge/items", {
+    method: "POST",
+    body
+  });
+}
+async function listItems(env, options) {
+  if (options.page !== void 0 && (!Number.isInteger(options.page) || options.page < 1))
+    throw new KnowledgeError(400, "invalid_page", "List page must be a positive integer");
+  if (options.perPage !== void 0 && (!Number.isInteger(options.perPage) || options.perPage < 1 || options.perPage > 50))
+    throw new KnowledgeError(
+      400,
+      "invalid_per_page",
+      "List perPage must be an integer from 1 to 50"
+    );
+  if (options.search !== void 0 && options.search.length > 256)
+    throw new KnowledgeError(400, "invalid_search", "List search cannot exceed 256 characters");
+  if (options.status !== void 0 && !["queued", "running", "completed", "error", "skipped", "outdated"].includes(options.status))
+    throw new KnowledgeError(400, "invalid_status", "Invalid knowledge item status");
+  const q = new URLSearchParams();
+  if (options.folder) q.set("folder", normalizeKnowledgeFolder(options.folder));
+  if (options.page !== void 0) q.set("page", String(options.page));
+  if (options.perPage !== void 0) q.set("perPage", String(options.perPage));
+  if (options.status) q.set("status", options.status);
+  if (options.search) q.set("search", options.search);
+  return await request(env, `/api/knowledge/items${q.size ? `?${q}` : ""}`);
+}
+async function searchItems(env, query, options) {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery) throw new KnowledgeError(400, "invalid_query", "Search query is required");
+  if (normalizedQuery.length > MAX_QUERY_CHARS)
+    throw new KnowledgeError(
+      400,
+      "invalid_query",
+      `Search query cannot exceed ${MAX_QUERY_CHARS} characters`
+    );
+  if (options.mode !== void 0 && options.mode !== "hybrid" && options.mode !== "semantic" && options.mode !== "fulltext")
+    throw new KnowledgeError(400, "invalid_mode", "Invalid knowledge search mode");
+  if (options.limit !== void 0 && (!Number.isInteger(options.limit) || options.limit < 1 || options.limit > 50))
+    throw new KnowledgeError(
+      400,
+      "invalid_limit",
+      "Search limit must be an integer from 1 through 50"
+    );
+  if (options.matchThreshold !== void 0 && (!Number.isFinite(options.matchThreshold) || options.matchThreshold < 0 || options.matchThreshold > 1))
+    throw new KnowledgeError(
+      400,
+      "invalid_match_threshold",
+      "Match threshold must be between 0 and 1"
+    );
+  if (options.queryRewrite !== void 0 && typeof options.queryRewrite !== "boolean")
+    throw new KnowledgeError(
+      400,
+      "invalid_query_rewrite",
+      "queryRewrite must be a boolean when provided"
+    );
+  const folder = options.folder === void 0 ? void 0 : normalizeKnowledgeFolder(options.folder);
+  return await request(env, "/api/knowledge/search", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      query: normalizedQuery,
+      mode: options.mode ?? "hybrid",
+      limit: options.limit ?? 10,
+      queryRewrite: options.queryRewrite ?? false,
+      ...options.matchThreshold !== void 0 && {
+        matchThreshold: options.matchThreshold
+      },
+      ...folder && { folder }
+    })
+  });
+}
+async function request(env, path, init = {}) {
+  const headers = new Headers(init.headers);
+  appendAppIdentity(headers, env);
+  const response = await apiWorkerFetch(env, path, { ...init, headers });
+  const text = await response.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : void 0;
+  } catch {
+    data = void 0;
+  }
+  if (!response.ok) {
+    const body = data && typeof data === "object" ? data : {};
+    throw new KnowledgeError(
+      response.status,
+      typeof body.code === "string" ? body.code : "knowledge_request_failed",
+      typeof body.error === "string" ? body.error : "Knowledge request failed"
+    );
+  }
+  return data;
+}
+
 // src/server/utils/d1-migrations.ts
 var META_TABLE = "_dpc_migrations";
 var META_BOOTSTRAP_SQL = `CREATE TABLE IF NOT EXISTS ${META_TABLE} (idx INTEGER PRIMARY KEY, applied_at TEXT NOT NULL)`;
@@ -9226,16 +9371,16 @@ var RequestBodyTooLargeError = class extends Error {
     this.name = "RequestBodyTooLargeError";
   }
 };
-async function readBoundedRequestText(request, maxBytes) {
+async function readBoundedRequestText(request2, maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
     throw new TypeError("maxBytes must be a positive safe integer");
   }
-  const declared = request.headers.get("content-length");
+  const declared = request2.headers.get("content-length");
   if (declared && /^\d+$/.test(declared.trim()) && Number(declared) > maxBytes) {
     throw new RequestBodyTooLargeError(maxBytes);
   }
-  if (!request.body) return "";
-  const reader = request.body.getReader();
+  if (!request2.body) return "";
+  const reader = request2.body.getReader();
   const decoder = new TextDecoder();
   let bytes = 0;
   let text = "";
@@ -9449,10 +9594,10 @@ function documentationRequestPath(pathname, publicBasePath) {
   const clean = logical === "/" ? "/" : logical.replace(/\/$/, "");
   return canonicalNativeDocumentationRequestPath(clean);
 }
-async function fetchDocumentationAsset(env, request, initialUrl, assetBasePath) {
+async function fetchDocumentationAsset(env, request2, initialUrl, assetBasePath) {
   let url = initialUrl;
   for (let redirects = 0; redirects < 3; redirects++) {
-    const response = await env.ASSETS.fetch(new Request(url, request));
+    const response = await env.ASSETS.fetch(new Request(url, request2));
     const location = response.headers.get("Location");
     if (response.status < 300 || response.status >= 400 || !location) return response;
     const next = new URL(location, url);
@@ -9492,11 +9637,11 @@ function secureDocumentationResponse(response, status, pathname) {
 var MCP_SERVER_VERSION = "1.0.0";
 var CURRENT_PROTOCOL_VERSION = "2025-11-25";
 var SUPPORTED_PROTOCOL_VERSIONS = /* @__PURE__ */ new Set([CURRENT_PROTOCOL_VERSION, "2025-06-18", "2025-03-26"]);
-function initializeResponse(request) {
-  const params = objectValue(request.params);
+function initializeResponse(request2) {
+  const params = objectValue(request2.params);
   const requested = typeof params?.protocolVersion === "string" ? params.protocolVersion : CURRENT_PROTOCOL_VERSION;
   const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requested) ? requested : CURRENT_PROTOCOL_VERSION;
-  return mcpResult(request.id, {
+  return mcpResult(request2.id, {
     protocolVersion,
     capabilities: {
       tools: { listChanged: false },
@@ -9510,11 +9655,11 @@ function initializeResponse(request) {
     instructions: "Search the published documentation before answering, then read exact pages when full context is needed."
   });
 }
-function hasValidOrigin(request) {
-  const origin = request.headers.get("Origin");
+function hasValidOrigin(request2) {
+  const origin = request2.headers.get("Origin");
   if (!origin) return true;
   try {
-    return new URL(origin).origin === new URL(request.url).origin;
+    return new URL(origin).origin === new URL(request2.url).origin;
   } catch {
     return false;
   }
@@ -9640,8 +9785,8 @@ var DOCUMENTATION_TOOLS = [
     }
   }
 ];
-async function callDocumentationTool(rawRequest, request, corpus, env, basePath = "/docs", assetBasePath = "/_documentation") {
-  const params = objectValue(request.params);
+async function callDocumentationTool(rawRequest, request2, corpus, env, basePath = "/docs", assetBasePath = "/_documentation") {
+  const params = objectValue(request2.params);
   const name = typeof params?.name === "string" ? params.name : "";
   const args = objectValue(params?.arguments) ?? {};
   const origin = new URL(rawRequest.url).origin;
@@ -9649,13 +9794,13 @@ async function callDocumentationTool(rawRequest, request, corpus, env, basePath
     const query = typeof args.query === "string" ? args.query.trim() : "";
     const limit = args.limit === void 0 ? 6 : args.limit;
     if (query.length < 2 || query.length > 300 || !Number.isInteger(limit) || Number(limit) < 1 || Number(limit) > 10) {
-      return mcpError(request.id, -32602, "Invalid documentation_search arguments");
+      return mcpError(request2.id, -32602, "Invalid documentation_search arguments");
     }
     const results = searchDocumentationCorpus(corpus, query, Number(limit)).map((result) => ({
       ...result,
       url: new URL(documentationPublicPath(basePath, result.route), origin).toString()
     }));
-    return toolResult(request.id, {
+    return toolResult(request2.id, {
       ...results[0]?.termCoverage === 1 ? {} : {
         notice: "No section matches every search term \u2014 the topic may be absent or spread across sections."
       },
@@ -9665,7 +9810,7 @@ async function callDocumentationTool(rawRequest, request, corpus, env, basePath
   if (name === "documentation_read") {
     const route = typeof args.route === "string" ? args.route.trim() : "";
     if (!route || route.length > 500) {
-      return mcpError(request.id, -32602, "Invalid documentation_read arguments");
+      return mcpError(request2.id, -32602, "Invalid documentation_read arguments");
     }
     const hash = route.indexOf("#");
     const fragment = hash === -1 ? "" : route.slice(hash + 1);
@@ -9677,9 +9822,9 @@ async function callDocumentationTool(rawRequest, request, corpus, env, basePath
         rawRequest.url,
         assetBasePath
       );
-      if (!page) return toolError(request.id, `No published documentation page exists at ${route}`);
+      if (!page) return toolError(request2.id, `No published documentation page exists at ${route}`);
       const section = fragment ? documentationPageSection(page.markdown, fragment) : null;
-      return toolResult(request.id, {
+      return toolResult(request2.id, {
         ...fragment && section === null ? { notice: `The fragment #${fragment} was not found; returning the whole page.` } : {},
         ...page,
         ...section === null ? {} : { markdown: section },
@@ -9687,10 +9832,10 @@ async function callDocumentationTool(rawRequest, request, corpus, env, basePath
       });
     } catch (error) {
       console.error("[documentation-mcp] page unavailable:", error);
-      return toolError(request.id, "The documentation page could not be read");
+      return toolError(request2.id, "The documentation page could not be read");
     }
   }
-  return mcpError(request.id, -32602, `Unknown documentation tool: ${name || "<missing>"}`);
+  return mcpError(request2.id, -32602, `Unknown documentation tool: ${name || "<missing>"}`);
 }
 
 // src/documentation/worker/mcp-routes.ts
@@ -9727,27 +9872,27 @@ function registerDocumentationMcpRoutes(app, publicBasePath = DOCUMENTATION_BASE
     }
     const parsed = parseRequest(raw);
     if (!parsed.ok) return mcpError(null, -32700, parsed.message, 400);
-    const request = parsed.request;
-    if (request.method !== "initialize") {
+    const request2 = parsed.request;
+    if (request2.method !== "initialize") {
       const protocolVersion = c.req.header("MCP-Protocol-Version");
       if (protocolVersion && !SUPPORTED_PROTOCOL_VERSIONS.has(protocolVersion)) {
-        return mcpError(request.id ?? null, -32600, "Unsupported MCP-Protocol-Version", 400);
+        return mcpError(request2.id ?? null, -32600, "Unsupported MCP-Protocol-Version", 400);
       }
     }
-    const requestId = request.id;
+    const requestId = request2.id;
     if (requestId === void 0) return new Response(null, { status: 202 });
-    const requestWithId = { ...request, id: requestId };
-    if (request.method === "initialize") return initializeResponse(requestWithId);
-    if (request.method === "ping") return mcpResult(requestId, {});
-    if (request.method === "tools/list") {
+    const requestWithId = { ...request2, id: requestId };
+    if (request2.method === "initialize") return initializeResponse(requestWithId);
+    if (request2.method === "ping") return mcpResult(requestId, {});
+    if (request2.method === "tools/list") {
       return mcpResult(requestId, { tools: DOCUMENTATION_TOOLS });
     }
-    if (request.method === "resources/list") {
+    if (request2.method === "resources/list") {
       return mcpResult(requestId, {
         resources: [skillResource(c.req.raw, manifest, publicBasePath)]
       });
     }
-    if (request.method === "resources/read") {
+    if (request2.method === "resources/read") {
       return readSkillResource(
         c.req.raw,
         requestWithId,
@@ -9757,8 +9902,8 @@ function registerDocumentationMcpRoutes(app, publicBasePath = DOCUMENTATION_BASE
         assetBasePath
       );
     }
-    if (request.method !== "tools/call") {
-      return mcpError(requestId, -32601, `Method not found: ${request.method}`);
+    if (request2.method !== "tools/call") {
+      return mcpError(requestId, -32601, `Method not found: ${request2.method}`);
     }
     const clientKey = await documentationPublicClientKey(
       c.req.header("CF-Connecting-IP") ?? "unknown"
@@ -9815,44 +9960,44 @@ function registerDocumentationMcpRoutes(app, publicBasePath = DOCUMENTATION_BASE
     }
   );
 }
-async function readSkillResource(rawRequest, request, manifest, env, publicBasePath, assetBasePath) {
-  const params = objectValue(request.params);
+async function readSkillResource(rawRequest, request2, manifest, env, publicBasePath, assetBasePath) {
+  const params = objectValue(request2.params);
   const requestedUri = typeof params?.uri === "string" ? params.uri : "";
   const resource = skillResource(rawRequest, manifest, publicBasePath);
   if (requestedUri !== resource.uri) {
-    return mcpError(request.id, -32602, "Unknown documentation resource");
+    return mcpError(request2.id, -32602, "Unknown documentation resource");
   }
   const assetUrl = new URL(`${assetBasePath}/skill.md`, rawRequest.url);
   const response = await env.ASSETS.fetch(new Request(assetUrl, { method: "GET" }));
-  if (!response.ok) return mcpError(request.id, -32002, "Documentation skill is unavailable", 503);
+  if (!response.ok) return mcpError(request2.id, -32002, "Documentation skill is unavailable", 503);
   const text = await response.text();
   if (text.length > MAX_SKILL_CHARS) {
-    return mcpError(request.id, -32002, "Documentation skill exceeds the published size limit", 503);
+    return mcpError(request2.id, -32002, "Documentation skill exceeds the published size limit", 503);
   }
-  return mcpResult(request.id, {
+  return mcpResult(request2.id, {
     contents: [{ uri: resource.uri, mimeType: resource.mimeType, text }]
   });
 }
-function skillResource(request, manifest, publicBasePath) {
+function skillResource(request2, manifest, publicBasePath) {
   const subject = documentationSubject(manifest.name);
   return {
-    uri: new URL(`${publicBasePath}/skill.md`, request.url).toString(),
+    uri: new URL(`${publicBasePath}/skill.md`, request2.url).toString(),
     name: `${subject} skill`,
     title: `Use ${manifest.name}`,
     description: `Agent instructions grounded in the published ${subject}.`,
     mimeType: "text/markdown"
   };
 }
-async function publicManifest(request, env, assetBasePath) {
-  const manifest = await loadDocumentationPublishedManifest(env, request.url, assetBasePath);
+async function publicManifest(request2, env, assetBasePath) {
+  const manifest = await loadDocumentationPublishedManifest(env, request2.url, assetBasePath);
   return manifest?.mcp.access === "public" ? manifest : null;
 }
-function discoveryResponse(request, manifest, publicBasePath) {
-  return jsonResponse(serverCard(request, manifest, publicBasePath), 200, {
+function discoveryResponse(request2, manifest, publicBasePath) {
+  return jsonResponse(serverCard(request2, manifest, publicBasePath), 200, {
     "Cache-Control": "public, max-age=300"
   });
 }
-function serverCard(request, manifest, publicBasePath) {
+function serverCard(request2, manifest, publicBasePath) {
   return {
     name: manifest.name,
     description: `Search and read the published ${documentationSubject(manifest.name)}.`,
@@ -9865,7 +10010,7 @@ function serverCard(request, manifest, publicBasePath) {
     protocolVersions: [...SUPPORTED_PROTOCOL_VERSIONS],
     transport: {
       type: "streamable-http",
-      url: new URL(`${publicBasePath}/mcp`, request.url).toString()
+      url: new URL(`${publicBasePath}/mcp`, request2.url).toString()
     },
     authentication: { required: false },
     capabilities: {
@@ -9874,7 +10019,7 @@ function serverCard(request, manifest, publicBasePath) {
         title,
         description
       })),
-      resources: [skillResource(request, manifest, publicBasePath)]
+      resources: [skillResource(request2, manifest, publicBasePath)]
     }
   };
 }
@@ -10297,21 +10442,21 @@ function jsonResponse2(body, status) {
     headers: { "Content-Type": "application/json" }
   });
 }
-async function handleClientErrorReport(request) {
-  const site = request.headers.get("sec-fetch-site");
+async function handleClientErrorReport(request2) {
+  const site = request2.headers.get("sec-fetch-site");
   if (site && site !== "same-origin" && site !== "none") {
     return new Response(null, { status: 403 });
   }
   if (shouldThrottleClientError()) {
     return new Response(null, { status: 429, headers: { "Retry-After": "1" } });
   }
-  const declared = Number(request.headers.get("content-length"));
+  const declared = Number(request2.headers.get("content-length"));
   if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
     return jsonResponse2({ error: "payload_too_large" }, 413);
   }
   let body;
   try {
-    body = await request.json();
+    body = await request2.json();
   } catch {
     return jsonResponse2({ error: "invalid_json" }, 400);
   }
@@ -10339,6 +10484,8 @@ var APP_LOG_EVENT_KEYS = [
 ];
 export {
   ACCOUNT_STORAGE_LIMIT_BYTES,
+  ACTION_ROUTES_BEARER_GUARD_MIGRATION_ID,
+  ACTION_TOOLS_DELETE_WHERE_MIGRATION_ID,
   AI_CHATS_SCHEMA,
   AI_MESSAGES_SCHEMA,
   ALLOWED_BINDING_TYPES,
@@ -10352,6 +10499,7 @@ export {
   Awareness,
   BASE_USERS_SCHEMA,
   BROWSER_PROXY_ROUTES,
+  BUILD_INJECTED_APP_ID_MIGRATION_ID,
   BUILT_IN_TOOLS,
   BaseRoom,
   CHANNELS_SCHEMA,
@@ -10377,6 +10525,7 @@ export {
   GLOBAL_DO_TYPES,
   GLOBAL_DO_TYPE_NAMES,
   JobRoom,
+  KnowledgeError,
   LOG_LEVELS,
   MAX_APP_FILE_BYTES,
   MAX_DELETE_WHERE_LIMIT,
@@ -10423,13 +10572,13 @@ export {
   USERS_COLUMNS,
   VOTING_SCHEMAS,
   WORKER_OWNED_NOT_FOUND_MIGRATION_ID,
-  WORKSPACE_SCHEMAS,
   YjsRoom,
   analyzePermissions,
   apiWorkerFetch,
   appendMessage,
   applyAiToolDefaults,
   applySlidingWindow,
+  armCronRoom,
   authWorkerFetch,
   authenticatedRoomRequest,
   bindingManifestFromOutputConfig,
@@ -10469,6 +10618,8 @@ export {
   encodeSyncStep2,
   encodeUpdate,
   enqueueJob,
+  epochSeconds,
+  folderFilter,
   formatBytes,
   getChat,
   getDeepSpaceAIModel,
@@ -10489,6 +10640,7 @@ export {
   isTestAccountClaims,
   isTestAccountEmail,
   isTestAccountTier,
+  knowledge,
   lintSchema,
   lintSchemaSet,
   lintSchemas,
@@ -10502,6 +10654,7 @@ export {
   mintAppId,
   mintUlid,
   noopPermissionContext,
+  normalizeKnowledgeFolder,
   parseQuotaLimit,
   platformCorsPatterns,
   platformWorkerFetch,
@@ -10537,17 +10690,6 @@ export {
   validateBindingManifest,
   validateDoManifest,
   verifyJwt,
-  workspaceAccountsSchema,
-  workspaceContentSharesSchema,
-  workspaceEmailHandlesSchema,
-  workspaceFormResponsesSchema,
-  workspacePeopleSchema,
-  workspaceProjectsSchema,
-  workspaceTagsSchema,
-  workspaceTasksSchema,
-  workspaceTeamMembersSchema,
-  workspaceTeamsSchema,
-  workspaceTransactionsSchema,
   writeVarUint,
   writeVarUint8Array
 };