@meshagent/meshagent-ts-auth 0.35.6 → 0.35.7

package/dist/browser/ma-auth.global.js

@@ -14835,11 +14835,14 @@ ${err.toString()}`);
       }
       function toCredentials(values) {
         return values.map((entry) => ({
-          registry: entry.registry,
+          registry: entry.registry ?? null,
           username: entry.username,
           password: entry.password
         }));
       }
+      function toMountList(values) {
+        return values.map((entry) => entry);
+      }
       function readStringField(data, field, operation) {
         const value = data[field];
         if (typeof value !== "string") {
@@ -14847,28 +14850,124 @@ ${err.toString()}`);
         }
         return value;
       }
-      function decodeJsonStatus(data) {
-        const text = new TextDecoder().decode(data);
+      function readIntegerField(data, field, operation) {
+        const value = data[field];
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return value;
+      }
+      function readOptionalIntegerField(data, field, operation) {
+        const value = data[field];
+        if (value === void 0 || value === null) {
+          return void 0;
+        }
+        if (typeof value !== "number" || !Number.isInteger(value)) {
+          throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return value;
+      }
+      function decodeUtf8(data, operation) {
+        try {
+          return new TextDecoder("utf-8", { fatal: true }).decode(data);
+        } catch {
+          throw new room_server_client_1.RoomServerException(`containers.${operation} returned invalid UTF-8 data`);
+        }
+      }
+      function decodeJsonStatus(data, operation) {
+        const text = decodeUtf8(data, operation);
         let parsed;
         try {
           parsed = JSON.parse(text);
         } catch {
-          throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+          throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
         }
         if (!isRecord(parsed)) {
-          throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+          throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
         }
         const status = parsed["status"];
         if (typeof status !== "number" || !Number.isInteger(status)) {
-          throw new room_server_client_1.RoomServerException("containers.exec returned an invalid status payload");
+          throw new room_server_client_1.RoomServerException(`containers.${operation} returned an invalid status payload`);
         }
         return status;
       }
+      function normalizeImageLabels(labelsRaw, operation) {
+        if (Array.isArray(labelsRaw)) {
+          const labels = {};
+          for (const entry of labelsRaw) {
+            if (!isRecord(entry)) {
+              throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            const key = entry["key"];
+            const value = entry["value"];
+            if (typeof key !== "string" || typeof value !== "string") {
+              throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            labels[key] = value;
+          }
+          return labels;
+        }
+        if (isRecord(labelsRaw)) {
+          const labels = {};
+          for (const [key, value] of Object.entries(labelsRaw)) {
+            if (typeof value !== "string") {
+              throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+            }
+            labels[key] = value;
+          }
+          return labels;
+        }
+        if (labelsRaw === void 0 || labelsRaw === null) {
+          return {};
+        }
+        throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+      }
+      function parseImportedImage(data, operation) {
+        const resolvedRef = data["resolved_ref"];
+        const refsRaw = data["refs"];
+        if (typeof resolvedRef !== "string" || !Array.isArray(refsRaw) || refsRaw.some((entry) => typeof entry !== "string")) {
+          throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return {
+          resolvedRef,
+          refs: refsRaw
+        };
+      }
+      function parseBuildJob(data, operation) {
+        const id = readStringField(data, "id", operation);
+        const tag2 = readStringField(data, "tag", operation);
+        const status = readStringField(data, "status", operation);
+        if (!["queued", "running", "failed", "cancelled", "succeeded"].includes(status)) {
+          throw new room_server_client_1.RoomServerException(`unexpected return type from containers.${operation}`);
+        }
+        return {
+          id,
+          tag: tag2,
+          status,
+          exitCode: readOptionalIntegerField(data, "exit_code", operation)
+        };
+      }
+      function buildRequestPayload(params) {
+        return {
+          tag: params.tag,
+          mounts: toMountList(params.mounts),
+          context_path: params.contextPath,
+          dockerfile_path: params.dockerfilePath ?? null,
+          private: params.private ?? false,
+          credentials: toCredentials(params.credentials ?? []),
+          context_archive_path: params.contextArchivePath ?? null,
+          context_archive_ref: params.contextArchiveRef ?? null,
+          context_archive_mount_path: params.contextArchiveMountPath ?? null,
+          context_archive_arch: params.contextArchiveArch ?? null
+        };
+      }
       var ExecSession = class {
         constructor(params) {
           this.previousOutput = [];
+          this.previousError = [];
           this.resultCompleter = new completer_1.Completer();
           this.outputController = new stream_controller_1.StreamController();
+          this.errorController = new stream_controller_1.StreamController();
           this.queuedInput = [];
           this.inputClosed = false;
           this.closed = false;
@@ -14879,6 +14978,7 @@ ${err.toString()}`);
           this.tty = params.tty;
           this.result = this.resultCompleter.fut;
           this.output = this.outputController.stream;
+          this.stderr = this.errorController.stream;
         }
         async *inputStream() {
           yield new response_1.BinaryContent({
@@ -14933,6 +15033,7 @@ ${err.toString()}`);
           this.closed = true;
           this.closeInputStream();
           this.outputController.close();
+          this.errorController.close();
         }
         closeError(error) {
           if (!this.resultCompleter.completed) {
@@ -14941,11 +15042,16 @@ ${err.toString()}`);
           this.closed = true;
           this.closeInputStream();
           this.outputController.close();
+          this.errorController.close();
         }
         addOutput(data) {
           this.previousOutput.push(data);
           this.outputController.add(data);
         }
+        addError(data) {
+          this.previousError.push(data);
+          this.errorController.add(data);
+        }
         get isClosed() {
           return this.closed;
         }
@@ -14989,7 +15095,7 @@ ${err.toString()}`);
         }
         async listImages() {
           const output = await this.invoke("list_images", {});
-          if (!(output instanceof response_1.JsonContent)) {
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("list_images");
           }
           const imagesRaw = output.json["images"];
@@ -15013,17 +15119,65 @@ ${err.toString()}`);
               id,
               tags: normalizedTags,
               size: typeof size === "number" ? size : void 0,
-              labels: isRecord(labelsRaw) ? labelsRaw : {}
+              labels: normalizeImageLabels(labelsRaw, "list_images")
             });
           }
           return images;
         }
+        async deleteImage(params) {
+          await this.invoke("delete_image", {
+            image: params.image
+          });
+        }
         async pullImage(params) {
           await this.invoke("pull_image", {
             tag: params.tag,
             credentials: toCredentials(params.credentials ?? [])
           });
         }
+        async pushImage(params) {
+          const output = await this.invoke("push_image", {
+            tag: params.tag,
+            credentials: toCredentials(params.credentials ?? []),
+            private: params.private ?? false
+          });
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("push_image");
+          }
+          return readStringField(output.json, "container_id", "push_image");
+        }
+        async load(params) {
+          const output = await this.invoke("load", {
+            archive_path: params.archivePath
+          });
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("load");
+          }
+          return parseImportedImage(output.json, "load");
+        }
+        async loadImage(params) {
+          const output = await this.invoke("load_image", {
+            mounts: toMountList(params.mounts),
+            archive_path: params.archivePath,
+            private: params.private ?? false
+          });
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("load_image");
+          }
+          return readStringField(output.json, "container_id", "load_image");
+        }
+        async saveImage(params) {
+          const output = await this.invoke("save_image", {
+            tag: params.tag,
+            mounts: toMountList(params.mounts),
+            archive_path: params.archivePath,
+            private: params.private ?? false
+          });
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("save_image");
+          }
+          return readStringField(output.json, "container_id", "save_image");
+        }
         async run(params) {
           const output = await this.invoke("run", {
             image: params.image,
@@ -15046,6 +15200,46 @@ ${err.toString()}`);
           }
           return readStringField(output.json, "container_id", "run");
         }
+        async startBuild(params) {
+          const output = await this.invoke("start_build", buildRequestPayload(params));
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("start_build");
+          }
+          return readStringField(output.json, "build_id", "start_build");
+        }
+        async build(params) {
+          const output = await this.invoke("build", buildRequestPayload(params));
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("build");
+          }
+          return readStringField(output.json, "build_id", "build");
+        }
+        async listBuilds() {
+          const output = await this.invoke("list_builds", {});
+          if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
+            throw this.unexpectedResponseError("list_builds");
+          }
+          const buildsRaw = output.json["builds"];
+          if (!Array.isArray(buildsRaw)) {
+            throw this.unexpectedResponseError("list_builds");
+          }
+          return buildsRaw.map((entry) => {
+            if (!isRecord(entry)) {
+              throw this.unexpectedResponseError("list_builds");
+            }
+            return parseBuildJob(entry, "list_builds");
+          });
+        }
+        async cancelBuild(params) {
+          await this.invoke("cancel_build", {
+            build_id: params.buildId
+          });
+        }
+        async deleteBuild(params) {
+          await this.invoke("delete_build", {
+            build_id: params.buildId
+          });
+        }
         async runService(params) {
           const output = await this.invoke("run_service", {
             service_id: params.serviceId,
@@ -15073,6 +15267,12 @@ ${err.toString()}`);
               if (chunk instanceof response_1.ErrorContent) {
                 throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
               }
+              if (chunk instanceof response_1.ControlContent) {
+                if (chunk.method === "close") {
+                  break;
+                }
+                throw this.unexpectedResponseError("exec");
+              }
               if (!(chunk instanceof response_1.BinaryContent)) {
                 throw this.unexpectedResponseError("exec");
               }
@@ -15084,8 +15284,12 @@ ${err.toString()}`);
                 session.addOutput(chunk.data);
                 continue;
               }
+              if (channel === 2) {
+                session.addError(chunk.data);
+                continue;
+              }
               if (channel === 3) {
-                session.close(decodeJsonStatus(chunk.data));
+                session.close(decodeJsonStatus(chunk.data, "exec"));
                 return;
               }
             }
@@ -15098,7 +15302,7 @@ ${err.toString()}`);
         async stop(params) {
           await this.invoke("stop_container", {
             container_id: params.containerId,
-            force: params.force ?? true
+            force: params.force ?? false
           });
         }
         async waitForExit(params) {
@@ -15108,11 +15312,7 @@ ${err.toString()}`);
           if (!(output instanceof response_1.JsonContent) || !isRecord(output.json)) {
             throw this.unexpectedResponseError("wait_for_exit");
           }
-          const exitCode = output.json["exit_code"];
-          if (typeof exitCode !== "number" || !Number.isInteger(exitCode)) {
-            throw this.unexpectedResponseError("wait_for_exit");
-          }
-          return exitCode;
+          return readIntegerField(output.json, "exit_code", "wait_for_exit");
         }
         async deleteContainer(params) {
           await this.invoke("delete_container", {
@@ -15151,13 +15351,20 @@ ${err.toString()}`);
             tool: "logs",
             input: inputStream()
           }).then(async (stream) => {
-            const decoder2 = new TextDecoder();
             for await (const chunk of stream) {
               if (chunk instanceof response_1.ErrorContent) {
                 throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
               }
               if (chunk instanceof response_1.ControlContent) {
-                continue;
+                if (chunk.method === "close") {
+                  closeInputStream();
+                  streamController.close();
+                  if (!result.completed) {
+                    result.complete();
+                  }
+                  return;
+                }
+                throw this.unexpectedResponseError("logs");
               }
               if (!(chunk instanceof response_1.BinaryContent)) {
                 throw this.unexpectedResponseError("logs");
@@ -15169,11 +15376,122 @@ ${err.toString()}`);
               if (channel !== 1) {
                 continue;
               }
-              streamController.add(decoder2.decode(chunk.data));
+              streamController.add(decodeUtf8(chunk.data, "logs"));
             }
             closeInputStream();
             streamController.close();
-            result.complete();
+            if (!result.completed) {
+              result.complete();
+            }
+          }).catch((error) => {
+            closeInputStream();
+            streamController.close();
+            if (!result.completed) {
+              result.completeError(error);
+            }
+          });
+          const outputStream = {
+            [Symbol.asyncIterator]() {
+              const it = streamController.stream[Symbol.asyncIterator]();
+              return {
+                async next() {
+                  return await it.next();
+                },
+                async return(value) {
+                  closeInputStream();
+                  return await it.return?.(value) ?? { done: true, value };
+                },
+                async throw(e) {
+                  closeInputStream();
+                  if (it.throw) {
+                    return await it.throw(e);
+                  }
+                  throw e;
+                }
+              };
+            }
+          };
+          return {
+            stream: outputStream,
+            result: result.fut,
+            cancel: async () => {
+              closeInputStream();
+              await result.fut.catch(() => void 0);
+            }
+          };
+        }
+        getBuildLogs(params) {
+          const requestId = (0, uuid_1.v4)();
+          const closeInput = new completer_1.Completer();
+          const streamController = new stream_controller_1.StreamController();
+          const result = new completer_1.Completer();
+          let inputClosed = false;
+          const closeInputStream = () => {
+            if (inputClosed) {
+              return;
+            }
+            inputClosed = true;
+            if (!closeInput.completed) {
+              closeInput.complete();
+            }
+          };
+          const inputStream = async function* () {
+            yield new response_1.BinaryContent({
+              data: new Uint8Array(0),
+              headers: {
+                kind: "start",
+                request_id: requestId,
+                build_id: params.buildId,
+                follow: params.follow ?? true
+              }
+            });
+            await closeInput.fut;
+          };
+          this.room.invokeStream({
+            toolkit: "containers",
+            tool: "get_build_logs",
+            input: inputStream()
+          }).then(async (stream) => {
+            for await (const chunk of stream) {
+              if (chunk instanceof response_1.ErrorContent) {
+                throw new room_server_client_1.RoomServerException(chunk.text, chunk.code);
+              }
+              if (chunk instanceof response_1.ControlContent) {
+                if (chunk.method === "close") {
+                  closeInputStream();
+                  streamController.close();
+                  if (!result.completed) {
+                    result.complete(null);
+                  }
+                  return;
+                }
+                throw this.unexpectedResponseError("get_build_logs");
+              }
+              if (!(chunk instanceof response_1.BinaryContent)) {
+                throw this.unexpectedResponseError("get_build_logs");
+              }
+              const channel = chunk.headers["channel"];
+              if (typeof channel !== "number") {
+                throw new room_server_client_1.RoomServerException("containers.get_build_logs returned a chunk without a valid channel");
+              }
+              if (channel === 1) {
+                streamController.add(decodeUtf8(chunk.data, "get_build_logs"));
+                continue;
+              }
+              if (channel === 3) {
+                closeInputStream();
+                streamController.close();
+                if (!result.completed) {
+                  result.complete(decodeJsonStatus(chunk.data, "get_build_logs"));
+                }
+                return;
+              }
+            }
+            closeInputStream();
+            streamController.close();
+            if (!result.completed) {
+              result.complete(null);
+            }
           }).catch((error) => {
             closeInputStream();
             streamController.close();
@@ -15510,6 +15828,52 @@ ${err.toString()}`);
           data_type: toolkitDataTypeJson(dataType)
         }));
       }
+      function publicDataTypeJson(value) {
+        if (!isRecord(value)) {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+        }
+        const type = value.type;
+        if (typeof type !== "string") {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+        }
+        const metadataList = value.metadata;
+        let metadata;
+        if (metadataList != null) {
+          if (!Array.isArray(metadataList)) {
+            throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+          }
+          metadata = {};
+          for (const entry of metadataList) {
+            if (!isRecord(entry) || typeof entry.key !== "string" || typeof entry.value !== "string") {
+              throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+            }
+            metadata[entry.key] = entry.value;
+          }
+        }
+        const payload = {
+          type,
+          nullable: value.nullable,
+          metadata
+        };
+        if (type === "vector") {
+          payload.size = value.size;
+          payload.element_type = publicDataTypeJson(value.element_type);
+        } else if (type === "list") {
+          payload.element_type = publicDataTypeJson(value.element_type);
+        } else if (type === "struct") {
+          const rawFields = value.fields;
+          if (!Array.isArray(rawFields)) {
+            throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+          }
+          payload.fields = Object.fromEntries(rawFields.map((field) => {
+            if (!isRecord(field) || typeof field.name !== "string") {
+              throw new room_server_client_1.RoomServerException("unexpected return type from database.inspect");
+            }
+            return [field.name, publicDataTypeJson(field.data_type)];
+          }));
+        }
+        return payload;
+      }
       function encodeLegacyValue(value) {
         if (value instanceof Uint8Array) {
           return {
@@ -15679,6 +16043,47 @@ ${err.toString()}`);
         }
         return null;
       }
+      function normalizeTableRefs(tables) {
+        return tables.map((table) => typeof table === "string" ? { name: table } : table);
+      }
+      function tableIndexFromJson(value) {
+        if (!isRecord(value) || typeof value.name !== "string" || typeof value.type !== "string" || !Array.isArray(value.columns)) {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.list_indexes");
+        }
+        return {
+          name: value.name,
+          type: value.type,
+          columns: value.columns.map((column) => {
+            if (typeof column !== "string") {
+              throw new room_server_client_1.RoomServerException("unexpected return type from database.list_indexes");
+            }
+            return column;
+          })
+        };
+      }
+      function tableVersionFromJson(value) {
+        if (!isRecord(value) || typeof value.metadata_json !== "string" || typeof value.timestamp !== "string" || typeof value.version !== "number") {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+        }
+        const timestamp = new Date(value.timestamp);
+        if (Number.isNaN(timestamp.getTime())) {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+        }
+        let metadata;
+        try {
+          metadata = JSON.parse(value.metadata_json);
+        } catch (_) {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+        }
+        if (!isRecord(metadata)) {
+          throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+        }
+        return {
+          version: value.version,
+          timestamp,
+          metadata
+        };
+      }
       var DatabaseWriteInputStream = class {
         constructor(start, chunks) {
           this.start = start;
@@ -15857,79 +16262,90 @@ ${err.toString()}`);
             input.close();
           }
         }
-        async listTables() {
-          const response = await this.invoke("list_tables", { namespace: null });
+        async listTables({ namespace } = {}) {
+          const response = await this.invoke("list_tables", { namespace: namespace ?? null });
           if (!(response instanceof response_1.JsonContent)) {
             throw this._unexpectedResponseError("list_tables");
           }
           return Array.isArray(response.json.tables) ? response.json.tables : [];
         }
-        async createTable({ name, data, schema, mode = "create" }) {
+        async createTable({ name, data, schema, mode = "create", namespace, metadata }) {
           const input = new DatabaseWriteInputStream({
             kind: "start",
             name,
             fields: schemaEntries(schema),
             mode,
-            namespace: null,
-            metadata: null
+            namespace: namespace ?? null,
+            metadata: metadataEntries(metadata)
           }, data ?? []);
           await this.drainWriteStream("create_table", input);
         }
-        async createTableWithSchema({ name, schema, data, mode = "create" }) {
+        async createTableWithSchema({ name, schema, data, mode = "create", namespace, metadata }) {
           return this.createTable({
             name,
             schema,
             data: data == null ? void 0 : rowChunkList(data),
-            mode
+            mode,
+            namespace,
+            metadata
           });
         }
-        async createTableFromData({ name, data, mode = "create" }) {
+        async createTableFromData({ name, data, mode = "create", namespace, metadata }) {
           return this.createTable({
             name,
             data: data == null ? void 0 : rowChunkList(data),
-            mode
+            mode,
+            namespace,
+            metadata
           });
         }
-        async createTableFromDataStream({ name, chunks, schema, mode = "create" }) {
-          return this.createTable({ name, data: chunks, schema, mode });
+        async createTableFromDataStream({ name, chunks, schema, mode = "create", namespace, metadata }) {
+          return this.createTable({ name, data: chunks, schema, mode, namespace, metadata });
         }
-        async dropTable({ name, ignoreMissing = false }) {
+        async dropTable({ name, ignoreMissing = false, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "drop_table",
-            input: { name, ignore_missing: ignoreMissing, namespace: null }
+            input: { name, ignore_missing: ignoreMissing, namespace: namespace ?? null }
           });
         }
-        async addColumns({ table, newColumns }) {
+        async dropIndex({ table, name, namespace }) {
+          await this.room.invoke({
+            toolkit: "database",
+            tool: "drop_index",
+            input: { table, name, namespace: namespace ?? null }
+          });
+        }
+        async addColumns({ table, newColumns, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "add_columns",
             input: {
               table,
-              columns: Object.entries(newColumns).map(([name, valueSql]) => ({ name, value_sql: valueSql, data_type: null })),
-              namespace: null
+              columns: Object.entries(newColumns).map(([name, value]) => value instanceof data_types_1.DataType ? { name, value_sql: null, data_type: toolkitDataTypeJson(value) } : { name, value_sql: value, data_type: null }),
+              namespace: namespace ?? null
             }
           });
         }
-        async dropColumns({ table, columns }) {
+        async dropColumns({ table, columns, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "drop_columns",
-            input: { table, columns, namespace: null }
+            input: { table, columns, namespace: namespace ?? null }
           });
         }
-        async insert({ table, records }) {
-          await this.insertStream({ table, chunks: rowChunkList(records) });
+        async insert({ table, records, namespace }) {
+          await this.insertStream({ table, chunks: rowChunkList(records), namespace });
         }
-        async insertStream({ table, chunks }) {
+        async insertStream({ table, chunks, namespace }) {
           const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
-            namespace: null
+            namespace: namespace ?? null
           }, chunks);
           await this.drainWriteStream("insert", input);
         }
-        async update({ table, where, values, valuesSql }) {
+        async update({ table, where, values, valuesSql, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "update",
@@ -15938,26 +16354,26 @@ ${err.toString()}`);
               where,
               values: values == null ? null : Object.entries(values).map(([column, value]) => ({ column, value_json: JSON.stringify(encodeLegacyValue(value)) })),
               values_sql: valuesSql == null ? null : Object.entries(valuesSql).map(([column, expression]) => ({ column, expression })),
-              namespace: null
+              namespace: namespace ?? null
             }
           });
         }
-        async delete({ table, where }) {
+        async delete({ table, where, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "delete",
-            input: { table, where, namespace: null }
+            input: { table, where, namespace: namespace ?? null }
           });
         }
-        async merge({ table, on, records }) {
-          await this.mergeStream({ table, on, chunks: rowChunkList(records) });
+        async merge({ table, on, records, namespace }) {
+          await this.mergeStream({ table, on, chunks: rowChunkList(records), namespace });
         }
-        async mergeStream({ table, on, chunks }) {
+        async mergeStream({ table, on, chunks, namespace }) {
           const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
             on,
-            namespace: null
+            namespace: namespace ?? null
           }, chunks);
           await this.drainWriteStream("merge", input);
         }
@@ -15972,18 +16388,18 @@ ${err.toString()}`);
           yield* this.streamRows("sql", {
             kind: "start",
             query,
-            tables,
+            tables: normalizeTableRefs(tables),
             params_json: params == null ? null : JSON.stringify(encodeLegacyValue(params))
           });
         }
-        async search({ table, text, vector, where, limit, select }) {
+        async search({ table, text, vector, where, offset, limit, select, namespace }) {
           const rows = [];
-          for await (const chunk of this.searchStream({ table, text, vector, where, limit, select })) {
+          for await (const chunk of this.searchStream({ table, text, vector, where, offset, limit, select, namespace })) {
             rows.push(...chunk);
           }
           return rows;
         }
-        async *searchStream({ table, text, vector, where, limit, select }) {
+        async *searchStream({ table, text, vector, where, offset, limit, select, namespace }) {
           yield* this.streamRows("search", {
             kind: "start",
             table,
@@ -15991,45 +16407,91 @@ ${err.toString()}`);
             vector: vector ?? null,
             text_columns: null,
             where: buildWhereClause(where),
-            offset: null,
+            offset: offset ?? null,
             limit: limit ?? null,
             select: select ?? null,
-            namespace: null
+            namespace: namespace ?? null
           });
         }
-        async optimize(table) {
-          await this.room.invoke({ toolkit: "database", tool: "optimize", input: { table, namespace: null } });
+        async count({ table, text, vector, where, namespace }) {
+          const response = await this.invoke("count", {
+            table,
+            text: text ?? null,
+            vector: vector ?? null,
+            text_columns: null,
+            where: buildWhereClause(where),
+            namespace: namespace ?? null
+          });
+          if (!(response instanceof response_1.JsonContent) || typeof response.json.count !== "number" || !Number.isInteger(response.json.count)) {
+            throw this._unexpectedResponseError("count");
+          }
+          return response.json.count;
+        }
+        async inspect({ table, namespace }) {
+          const response = await this.invoke("inspect", { table, namespace: namespace ?? null });
+          if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.fields)) {
+            throw this._unexpectedResponseError("inspect");
+          }
+          return Object.fromEntries(response.json.fields.map((field) => {
+            if (!isRecord(field) || typeof field.name !== "string") {
+              throw this._unexpectedResponseError("inspect");
+            }
+            return [field.name, data_types_1.DataType.fromJson(publicDataTypeJson(field.data_type))];
+          }));
         }
-        async createVectorIndex({ table, column, replace = false }) {
+        async optimize(tableOrParams) {
+          const table = typeof tableOrParams === "string" ? tableOrParams : tableOrParams.table;
+          const namespace = typeof tableOrParams === "string" ? void 0 : tableOrParams.namespace;
+          await this.room.invoke({ toolkit: "database", tool: "optimize", input: { table, namespace: namespace ?? null } });
+        }
+        async restore({ table, version, namespace }) {
+          await this.room.invoke({
+            toolkit: "database",
+            tool: "restore",
+            input: { table, version, namespace: namespace ?? null }
+          });
+        }
+        async checkout({ table, version, namespace }) {
+          await this.room.invoke({
+            toolkit: "database",
+            tool: "checkout",
+            input: { table, version, namespace: namespace ?? null }
+          });
+        }
+        async listVersions({ table, namespace }) {
+          const response = await this.invoke("list_versions", { table, namespace: namespace ?? null });
+          if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.versions)) {
+            throw this._unexpectedResponseError("list_versions");
+          }
+          return response.json.versions.map((version) => tableVersionFromJson(version));
+        }
+        async createVectorIndex({ table, column, replace = false, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "create_vector_index",
-            input: { table, column, replace, namespace: null }
+            input: { table, column, replace, namespace: namespace ?? null }
           });
         }
-        async createScalarIndex({ table, column, replace = false }) {
+        async createScalarIndex({ table, column, replace = false, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "create_scalar_index",
-            input: { table, column, replace, namespace: null }
+            input: { table, column, replace, namespace: namespace ?? null }
           });
         }
-        async createFullTextSearchIndex({ table, column, replace = false }) {
+        async createFullTextSearchIndex({ table, column, replace = false, namespace }) {
           await this.room.invoke({
             toolkit: "database",
             tool: "create_full_text_search_index",
-            input: { table, column, replace, namespace: null }
+            input: { table, column, replace, namespace: namespace ?? null }
           });
         }
-        async listIndexes({ table }) {
-          const response = await this.invoke("list_indexes", { table, namespace: null });
-          if (!(response instanceof response_1.JsonContent)) {
+        async listIndexes({ table, namespace }) {
+          const response = await this.invoke("list_indexes", { table, namespace: namespace ?? null });
+          if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.indexes)) {
             throw this._unexpectedResponseError("list_indexes");
           }
-          if (!Array.isArray(response.json.indexes)) {
-            throw this._unexpectedResponseError("list_indexes");
-          }
-          return response.json.indexes;
+          return response.json.indexes.map((index) => tableIndexFromJson(index));
         }
       };
       exports.DatabaseClient = DatabaseClient;
@@ -16082,9 +16544,10 @@ ${err.toString()}`);
       };
       exports.FileCreatedEvent = FileCreatedEvent;
       var FileDeletedEvent = class extends RoomEvent {
-        constructor({ path }) {
+        constructor({ path, participantId }) {
           super();
           this.path = path;
+          this.participantId = participantId;
         }
         get name() {
           return "file deleted";
@@ -16095,9 +16558,10 @@ ${err.toString()}`);
       };
       exports.FileDeletedEvent = FileDeletedEvent;
       var FileUpdatedEvent = class extends RoomEvent {
-        constructor({ path }) {
+        constructor({ path, participantId }) {
           super();
           this.path = path;
+          this.participantId = participantId;
         }
         get name() {
           return "file updated";
@@ -23487,6 +23951,14 @@ ${newlined}
         getAttribute(name) {
           return this._attributes[name];
         }
+        _setAttribute(name, value) {
+          this._attributes[name] = value;
+        }
+        _setAttributes(attributes) {
+          for (const [name, value] of Object.entries(attributes)) {
+            this._setAttribute(name, value);
+          }
+        }
       };
       exports.Participant = Participant;
       var RemoteParticipant = class extends Participant {
@@ -23505,7 +23977,7 @@ ${newlined}
           super(client, id);
         }
         async setAttribute(name, value) {
-          this._attributes[name] = value;
+          this._setAttribute(name, value);
           try {
             const payload = (0, utils_1.packMessage)({ [name]: value });
             await this.client.protocol.send("set_attributes", payload);
@@ -23523,15 +23995,13 @@ ${newlined}
     "../meshagent-ts/dist/browser/messaging-client.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.MessageStreamReader = exports.MessageStreamWriter = exports.MessagingClient = exports.MessageStreamChunk = void 0;
-      var uuid_1 = require_cjs_browser();
+      exports.MessagingClient = void 0;
       var event_emitter_1 = require_event_emitter();
+      var completer_1 = require_completer();
       var participant_1 = require_participant();
       var room_event_1 = require_room_event();
       var room_server_client_1 = require_room_server_client();
-      var utils_1 = require_utils();
-      var stream_controller_1 = require_stream_controller();
-      var completer_1 = require_completer();
+      var utils_1 = require_utils();
       var globalScope = globalThis;
       function bytesToBase64(bytes) {
         if (globalScope.Buffer) {
@@ -23546,21 +24016,18 @@ ${newlined}
         }
         return globalScope.btoa(binary);
       }
-      var MessageStreamChunk = class {
-        constructor({ header, data }) {
-          this.header = header;
-          this.data = data;
-        }
-      };
-      exports.MessageStreamChunk = MessageStreamChunk;
       var MessagingClient = class extends event_emitter_1.EventEmitter {
         constructor({ room }) {
           super();
-          this._streamWriters = {};
-          this._streamReaders = {};
+          this._messageHandler = this._handleMessageSend.bind(this);
           this._participants = {};
+          this._messageQueue = [];
+          this._messageQueued = null;
+          this._sendTask = null;
+          this._messageQueueClosed = false;
+          this._enabled = false;
           this.client = room;
-          this.client.protocol.addHandler("messaging.send", this._handleMessageSend.bind(this));
+          this.client.protocol.addHandler("messaging.send", this._messageHandler);
         }
         _messageInput(params) {
           const input = {
@@ -23575,6 +24042,16 @@ ${newlined}
           }
           return input;
         }
+        _syntheticMessageEvent(params) {
+          return new room_event_1.RoomMessageEvent({
+            message: new room_event_1.RoomMessage({
+              fromParticipantId: params.fromParticipantId,
+              type: params.type,
+              message: params.message,
+              local: true
+            })
+          });
+        }
         _removeParticipant(participantId) {
           const participant = this._participants[participantId];
           if (participant === void 0) {
@@ -23582,15 +24059,24 @@ ${newlined}
           }
           participant._setOnline(false);
           delete this._participants[participantId];
-          for (const [streamId, reader] of Object.entries(this._streamReaders)) {
-            if (reader._to.id !== participant.id) {
-              continue;
-            }
-            reader._controller.close();
-            delete this._streamReaders[streamId];
-          }
           return participant;
         }
+        _markParticipantOffline(participant) {
+          if (!(participant instanceof participant_1.RemoteParticipant)) {
+            return;
+          }
+          participant._setOnline(false);
+          const current = this._participants[participant.id];
+          if (current === void 0) {
+            return;
+          }
+          this._removeParticipant(participant.id);
+          this.emit("participant_removed", this._syntheticMessageEvent({
+            fromParticipantId: participant.id,
+            type: "participant.disabled",
+            message: { id: participant.id }
+          }));
+        }
         _resolveMessageRecipient(to) {
           if (!(to instanceof participant_1.RemoteParticipant)) {
             return to;
@@ -23600,46 +24086,129 @@ ${newlined}
           }
           return this._participants[to.id] ?? null;
         }
-        _participantNotFound(ignoreOffline) {
-          if (ignoreOffline) {
-            return null;
+        _queueMessage(message2) {
+          if (this._sendTask === null) {
+            throw new room_server_client_1.RoomServerException("Cannot send messages because messaging has not been started");
+          }
+          this._messageQueue.push(message2);
+          const waiter = this._messageQueued;
+          if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+          }
+        }
+        _rejectQueuedMessages(error) {
+          while (this._messageQueue.length > 0) {
+            const message2 = this._messageQueue.shift();
+            message2?.completer?.completeError(error);
+          }
+        }
+        _isParticipantNotFound(error) {
+          return error instanceof room_server_client_1.RoomServerException && error.message === "the participant was not found";
+        }
+        async _nextQueuedMessage() {
+          while (this._messageQueue.length === 0) {
+            if (this._messageQueueClosed) {
+              return null;
+            }
+            if (this._messageQueued === null) {
+              this._messageQueued = new completer_1.Completer();
+            }
+            await this._messageQueued.fut;
+          }
+          return this._messageQueue.shift() ?? null;
+        }
+        async _sendMessages() {
+          while (true) {
+            const queued = await this._nextQueuedMessage();
+            if (queued === null) {
+              return;
+            }
+            const resolvedTo = this._resolveMessageRecipient(queued.to);
+            if (resolvedTo === null) {
+              const error = new room_server_client_1.RoomServerException("the participant was not found");
+              if (queued.dropIfOffline) {
+                queued.completer?.complete();
+              } else {
+                queued.completer?.completeError(error);
+              }
+              continue;
+            }
+            try {
+              await this.client.invoke({
+                toolkit: "messaging",
+                tool: "send",
+                input: this._messageInput({
+                  toParticipantId: resolvedTo.id,
+                  type: queued.type,
+                  message: queued.message,
+                  attachment: queued.attachment
+                })
+              });
+              queued.completer?.complete();
+            } catch (error) {
+              if (this._isParticipantNotFound(error)) {
+                this._markParticipantOffline(queued.to);
+                if (queued.dropIfOffline) {
+                  queued.completer?.complete();
+                  continue;
+                }
+              }
+              queued.completer?.completeError(error);
+            }
+          }
+        }
+        async start() {
+          if (this._sendTask !== null) {
+            return;
+          }
+          this._messageQueueClosed = false;
+          this._sendTask = this._sendMessages();
+        }
+        async stop() {
+          if (this._sendTask === null) {
+            this._enabled = false;
+            return;
+          }
+          this._messageQueueClosed = true;
+          const waiter = this._messageQueued;
+          if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
           }
-          throw new room_server_client_1.RoomServerException("the participant was not found");
+          const sendTask = this._sendTask;
+          this._sendTask = null;
+          await sendTask;
+          this._enabled = false;
         }
-        async createStream({ to, header }) {
-          const streamId = (0, uuid_1.v4)();
+        async sendMessage({ to, type, message: message2, attachment, ignoreOffline = false }) {
           const completer = new completer_1.Completer();
-          this._streamWriters[streamId] = completer;
-          await this.sendMessage({
+          this._queueMessage({
             to,
-            type: "stream.open",
-            message: { stream_id: streamId, header }
+            type,
+            message: message2,
+            attachment,
+            dropIfOffline: ignoreOffline,
+            completer
           });
-          return completer.fut;
+          await completer.fut;
         }
-        async sendMessage({ to, type, message: message2, attachment, ignoreOffline = false }) {
-          const resolvedTo = this._resolveMessageRecipient(to) ?? this._participantNotFound(ignoreOffline);
-          if (resolvedTo === null) {
-            return;
-          }
-          await this.client.invoke({
-            toolkit: "messaging",
-            tool: "send",
-            input: this._messageInput({
-              toParticipantId: resolvedTo.id,
-              type,
-              message: message2,
-              attachment
-            })
+        sendMessageNowait({ to, type, message: message2, attachment }) {
+          this._queueMessage({
+            to,
+            type,
+            message: message2,
+            attachment,
+            dropIfOffline: true
           });
         }
-        async enable(onStreamAccept) {
+        async enable() {
           await this.client.invoke({
             toolkit: "messaging",
             tool: "enable",
             input: {}
           });
-          this._onStreamAcceptCallback = onStreamAccept;
+          this._enabled = true;
         }
         async disable() {
           await this.client.invoke({
@@ -23647,6 +24216,7 @@ ${newlined}
             tool: "disable",
             input: {}
           });
+          this._enabled = false;
         }
         async broadcastMessage({ type, message: message2, attachment }) {
           await this.client.invoke({
@@ -23658,6 +24228,23 @@ ${newlined}
         get remoteParticipants() {
           return Object.values(this._participants);
         }
+        get isEnabled() {
+          return this._enabled;
+        }
+        getParticipants() {
+          return this.remoteParticipants;
+        }
+        getParticipant(id) {
+          return this._participants[id] ?? null;
+        }
+        getParticipantByName(name) {
+          for (const participant of this.remoteParticipants) {
+            if (participant.getAttribute("name") === name) {
+              return participant;
+            }
+          }
+          return null;
+        }
         async _handleMessageSend(protocol, messageId, type, bytes) {
           const headerStr = (0, utils_1.splitMessageHeader)(bytes || new Uint8Array());
           const payload = (0, utils_1.splitMessagePayload)(bytes || new Uint8Array());
@@ -23681,21 +24268,6 @@ ${newlined}
             case "participant.disabled":
               this._onParticipantDisabled(message2);
               break;
-            case "stream.open":
-              this._onStreamOpen(message2);
-              break;
-            case "stream.accept":
-              this._onStreamAccept(message2);
-              break;
-            case "stream.reject":
-              this._onStreamReject(message2);
-              break;
-            case "stream.chunk":
-              this._onStreamChunk(message2);
-              break;
-            case "stream.close":
-              this._onStreamClose(message2);
-              break;
           }
           const messageEvent = new room_event_1.RoomMessageEvent({ message: message2 });
           this.client.emit(messageEvent);
@@ -23704,20 +24276,17 @@ ${newlined}
         _onParticipantEnabled(message2) {
           const data = message2.message;
           const p = new participant_1.RemoteParticipant(this.client, data["id"], data["role"], true);
-          for (const [k, v] of Object.entries(data["attributes"] || {})) {
-            p._attributes[k] = v;
-          }
+          p._setAttributes(data["attributes"] ?? {});
           this._participants[data["id"]] = p;
           this.emit("participant_added", { message: message2 });
         }
         _onParticipantAttributes(message2) {
           const part = this._participants[message2.fromParticipantId];
-          if (!part)
+          if (!part) {
             return;
-          const attrObj = message2.message["attributes"];
-          for (const [k, v] of Object.entries(attrObj)) {
-            part._attributes[k] = v;
           }
+          const attrObj = message2.message["attributes"];
+          part._setAttributes(attrObj);
           this.emit("participant_attributes_updated", { message: message2 });
         }
         _onParticipantDisabled(message2) {
@@ -23730,128 +24299,27 @@ ${newlined}
           const participants = message2.message["participants"];
           for (const data of participants) {
             const rp = new participant_1.RemoteParticipant(this.client, data["id"], data["role"], true);
-            for (const [k, v] of Object.entries(data["attributes"] || {})) {
-              rp._attributes[k] = v;
-            }
+            rp._setAttributes(data["attributes"] ?? {});
             this._participants[data["id"]] = rp;
           }
+          this._enabled = true;
           this.emit("messaging_enabled", { message: message2 });
         }
-        _onStreamOpen(message2) {
-          const from = [...this.remoteParticipants].find((x) => x.id === message2.fromParticipantId);
-          if (!from)
-            return;
-          const streamId = message2.message["stream_id"];
-          const controller = new stream_controller_1.StreamController();
-          const reader = new MessageStreamReader({
-            streamId,
-            to: from,
-            client: this,
-            controller
-          });
-          try {
-            if (!this._onStreamAcceptCallback) {
-              throw new Error("streams are not allowed by this client");
-            }
-            this._onStreamAcceptCallback(reader);
-            void this.sendMessage({
-              to: from,
-              type: "stream.accept",
-              message: { stream_id: streamId },
-              ignoreOffline: true
-            }).catch((error) => {
-              console.warn("unable to send stream response", error);
-            });
-          } catch (e) {
-            void this.sendMessage({
-              to: from,
-              type: "stream.reject",
-              message: { stream_id: streamId, error: String(e) },
-              ignoreOffline: true
-            }).catch((error) => {
-              console.warn("unable to send stream response", error);
-            });
-          }
-          this._streamReaders[streamId] = reader;
-          this.emit("stream_opened", { message: message2 });
-        }
-        _onStreamAccept(message2) {
-          const streamId = message2.message["stream_id"];
-          const writerCompleter = this._streamWriters[streamId];
-          if (!writerCompleter)
-            return;
-          const from = [...this.remoteParticipants].find((x) => x.id === message2.fromParticipantId);
-          if (!from)
-            return;
-          writerCompleter.complete(new MessageStreamWriter({
-            streamId,
-            to: from,
-            client: this
-          }));
-        }
-        _onStreamReject(message2) {
-          const streamId = message2.message["stream_id"];
-          const writerCompleter = this._streamWriters[streamId];
-          if (!writerCompleter)
-            return;
-          writerCompleter.completeError(new Error("The stream was rejected by the remote client"));
-        }
-        _onStreamChunk(message2) {
-          const streamId = message2.message["stream_id"];
-          const reader = this._streamReaders[streamId];
-          if (!reader)
-            return;
-          reader._controller.add(new MessageStreamChunk({
-            header: message2.message,
-            data: message2.attachment
-          }));
-        }
-        _onStreamClose(message2) {
-          const streamId = message2.message["stream_id"];
-          const reader = this._streamReaders[streamId];
-          if (!reader)
-            return;
-          reader._controller.close();
-          delete this._streamReaders[streamId];
-        }
         dispose() {
+          const error = new room_server_client_1.RoomServerException("messaging client disposed");
+          this._messageQueueClosed = true;
+          this._enabled = false;
+          this._rejectQueuedMessages(error);
+          const waiter = this._messageQueued;
+          if (waiter !== null) {
+            this._messageQueued = null;
+            waiter.complete();
+          }
           super.dispose();
           this.client.protocol.removeHandler("messaging.send");
         }
       };
       exports.MessagingClient = MessagingClient;
-      var MessageStreamWriter = class {
-        constructor({ streamId, to, client }) {
-          this._streamId = streamId;
-          this._to = to;
-          this._client = client;
-        }
-        async write(chunk) {
-          await this._client.sendMessage({
-            to: this._to,
-            type: "stream.chunk",
-            message: { stream_id: this._streamId, header: chunk.header },
-            attachment: chunk.data
-          });
-        }
-        async close() {
-          await this._client.sendMessage({
-            to: this._to,
-            type: "stream.close",
-            message: { stream_id: this._streamId }
-          });
-        }
-      };
-      exports.MessageStreamWriter = MessageStreamWriter;
-      var MessageStreamReader = class {
-        constructor({ streamId, to, client, controller }) {
-          this._streamId = streamId;
-          this._to = to;
-          this._client = client;
-          this._controller = controller;
-        }
-      };
-      exports.MessageStreamReader = MessageStreamReader;
     }
   });
 
@@ -24807,12 +25275,62 @@ ${newlined}
     "../meshagent-ts/dist/browser/storage-client.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.StorageClient = exports.FileHandle = void 0;
+      exports.StorageClient = exports.StorageEntry = exports.FileHandle = void 0;
       var room_event_1 = require_room_event();
       var response_1 = require_response();
       var utils_1 = require_utils();
       var event_emitter_1 = require_event_emitter();
       var room_server_client_1 = require_room_server_client();
+      var _DEFAULT_UPLOAD_MIME_TYPE = "application/octet-stream";
+      var _UPLOAD_MIME_TYPES_BY_SUFFIX = /* @__PURE__ */ new Map([
+        [".tar.gz", "application/x-tar"],
+        [".tgz", "application/x-tar"]
+      ]);
+      var _UPLOAD_MIME_TYPES_BY_EXTENSION = /* @__PURE__ */ new Map([
+        [".bin", "application/octet-stream"],
+        [".css", "text/css"],
+        [".csv", "text/csv"],
+        [".gif", "image/gif"],
+        [".gz", "application/gzip"],
+        [".htm", "text/html"],
+        [".html", "text/html"],
+        [".jpeg", "image/jpeg"],
+        [".jpg", "image/jpeg"],
+        [".js", "text/javascript"],
+        [".json", "application/json"],
+        [".md", "text/markdown"],
+        [".mp3", "audio/mpeg"],
+        [".mp4", "video/mp4"],
+        [".pdf", "application/pdf"],
+        [".png", "image/png"],
+        [".svg", "image/svg+xml"],
+        [".tar", "application/x-tar"],
+        [".txt", "text/plain"],
+        [".ts", "text/typescript"],
+        [".tsx", "text/tsx"],
+        [".wasm", "application/wasm"],
+        [".webp", "image/webp"],
+        [".xml", "application/xml"],
+        [".yaml", "application/yaml"],
+        [".yml", "application/yaml"],
+        [".zip", "application/zip"]
+      ]);
+      function _unexpectedStorageResponseError(operation) {
+        return new room_server_client_1.RoomServerException(`unexpected return type from storage.${operation}`);
+      }
+      function _parseStorageTimestamp(value, operation) {
+        if (value == null) {
+          return null;
+        }
+        if (typeof value !== "string") {
+          throw _unexpectedStorageResponseError(operation);
+        }
+        const timestamp = new Date(value);
+        if (Number.isNaN(timestamp.getTime())) {
+          throw _unexpectedStorageResponseError(operation);
+        }
+        return timestamp;
+      }
       var FileHandle = class {
         constructor({ id }) {
           this.id = id;
@@ -24820,16 +25338,19 @@ ${newlined}
       };
       exports.FileHandle = FileHandle;
       var StorageEntry = class {
-        constructor({ name, isFolder, size = null }) {
+        constructor({ name, isFolder, size = null, createdAt = null, updatedAt = null }) {
           this.name = name;
           this.isFolder = isFolder;
           this.size = size;
+          this.createdAt = createdAt;
+          this.updatedAt = updatedAt;
         }
         nameWithoutExtension() {
           const segments = this.name.replace(/^\/+/, "").replace(/\/+$/, "").split(/\/+/);
           return (segments[segments.length - 1] || "").replace(/\.[^/.]+$/, "");
         }
       };
+      exports.StorageEntry = StorageEntry;
       var StorageClient = class extends event_emitter_1.EventEmitter {
         constructor({ room }) {
           super();
@@ -24839,18 +25360,30 @@ ${newlined}
         }
         async _handleFileUpdated(protocol, messageId, type, bytes) {
           const [data, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
-          const event = new room_event_1.FileUpdatedEvent({ path: data["path"] });
+          const event = new room_event_1.FileUpdatedEvent({ path: data["path"], participantId: data["participant_id"] });
           this.client.emit(event);
           this.emit("file.updated", event);
         }
         async _handleFileDeleted(protocol, messageId, type, bytes) {
           const [data, _] = (0, utils_1.unpackMessage)(bytes || new Uint8Array());
-          const event = new room_event_1.FileDeletedEvent({ path: data["path"] });
+          const event = new room_event_1.FileDeletedEvent({ path: data["path"], participantId: data["participant_id"] });
           this.client.emit(event);
           this.emit("file.deleted", event);
         }
         _unexpectedResponseError(operation) {
-          return new room_server_client_1.RoomServerException(`unexpected return type from storage.${operation}`);
+          return _unexpectedStorageResponseError(operation);
+        }
+        _storageEntry(operation, value) {
+          if (typeof value["name"] !== "string" || typeof value["is_folder"] !== "boolean" || value["size"] != null && typeof value["size"] !== "number") {
+            throw this._unexpectedResponseError(operation);
+          }
+          return new StorageEntry({
+            name: value["name"],
+            isFolder: value["is_folder"],
+            size: typeof value["size"] === "number" ? value["size"] : null,
+            createdAt: _parseStorageTimestamp(value["created_at"], operation),
+            updatedAt: _parseStorageTimestamp(value["updated_at"], operation)
+          });
         }
         async _invoke(operation, input, callerContext) {
           return await this.client.invoke({
@@ -24862,22 +25395,26 @@ ${newlined}
         }
         async list(path) {
           const response = await this._invoke("list", { path });
-          if (!(response instanceof response_1.JsonContent)) {
+          if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json["files"])) {
             throw this._unexpectedResponseError("list");
           }
           const files = response.json["files"];
-          const entries = files.map((f) => {
-            return new StorageEntry({
-              name: f["name"],
-              isFolder: f["is_folder"],
-              size: typeof f["size"] === "number" ? f["size"] : null
-            });
-          });
+          const entries = files.map((f) => this._storageEntry("list", f));
           entries.sort((a, b) => a.name.localeCompare(b.name));
           return entries;
         }
-        async delete(path) {
-          await this._invoke("delete", { path, recursive: null });
+        async stat(path) {
+          const response = await this._invoke("stat", { path });
+          if (!(response instanceof response_1.JsonContent) || typeof response.json["exists"] !== "boolean") {
+            throw this._unexpectedResponseError("stat");
+          }
+          if (!response.json["exists"]) {
+            return null;
+          }
+          return this._storageEntry("stat", response.json);
+        }
+        async delete(path, { recursive = null } = {}) {
+          await this._invoke("delete", { path, recursive });
         }
         async exists(path) {
           const result = await this._invoke("exists", { path });
@@ -24894,6 +25431,22 @@ ${newlined}
           const lastSegment = segments.length > 0 ? segments[segments.length - 1] : void 0;
           return lastSegment ?? path;
         }
+        _defaultUploadMimeType(name, mimeType) {
+          if (typeof mimeType === "string" && mimeType.length > 0) {
+            return mimeType;
+          }
+          const lowerName = name.toLowerCase();
+          for (const [suffix, contentType] of _UPLOAD_MIME_TYPES_BY_SUFFIX.entries()) {
+            if (lowerName.endsWith(suffix)) {
+              return contentType;
+            }
+          }
+          const lastDot = lowerName.lastIndexOf(".");
+          if (lastDot >= 0) {
+            return _UPLOAD_MIME_TYPES_BY_EXTENSION.get(lowerName.slice(lastDot)) ?? _DEFAULT_UPLOAD_MIME_TYPE;
+          }
+          return _DEFAULT_UPLOAD_MIME_TYPE;
+        }
         async upload(path, bytes, { overwrite = false, name, mimeType = null } = {}) {
           async function* singleChunk() {
             yield bytes;
@@ -24907,6 +25460,7 @@ ${newlined}
         }
         async uploadStream(path, chunks, { overwrite = false, chunkSize = 64 * 1024, size = null, name, mimeType = null } = {}) {
           const resolvedName = this._defaultUploadName(path, name);
+          const resolvedMimeType = this._defaultUploadMimeType(resolvedName, mimeType);
           const input = new _StorageUploadInputStream({
             path,
             overwrite,
@@ -24914,7 +25468,7 @@ ${newlined}
             chunkSize,
             size,
             name: resolvedName,
-            mimeType
+            mimeType: resolvedMimeType
           });
           const response = await this.client.invokeStream({
             toolkit: "storage",
@@ -25244,86 +25798,285 @@ ${newlined}
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.SecretsClient = void 0;
       var response_1 = require_response();
+      var room_server_client_1 = require_room_server_client();
+      var utils_1 = require_utils();
+      function isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      }
       var SecretsClient = class {
-        constructor({ room }) {
+        constructor({ room, oauthTokenRequestHandler, secretRequestHandler }) {
+          this._oauthRequestHandler = this._handleClientOAuthTokenRequest.bind(this);
+          this._secretRequestHandler = this._handleClientSecretRequest.bind(this);
           this.client = room;
+          this.oauthTokenRequestHandler = oauthTokenRequestHandler;
+          this.secretRequestHandler = secretRequestHandler;
+          this.client.protocol.addHandler("secrets.request_oauth_token", this._oauthRequestHandler);
+          this.client.protocol.addHandler("secrets.request_secret", this._secretRequestHandler);
         }
         unexpectedResponse(operation) {
-          return new Error(`unexpected return type from secrets.${operation}`);
+          return new room_server_client_1.RoomServerException(`unexpected return type from secrets.${operation}`);
         }
-        async setSecret({ secretId, data, mimeType, name, delegatedTo, forIdentity }) {
-          const response = await this.client.invoke({
+        async invoke(operation, input) {
+          return await this.client.invoke({
             toolkit: "secrets",
-            tool: "set_secret",
-            input: new response_1.BinaryContent({
-              data,
-              headers: {
-                secret_id: secretId,
-                type: mimeType ?? null,
-                name: name ?? null,
-                delegated_to: delegatedTo ?? null,
-                for_identity: forIdentity ?? null,
-                has_data: true
-              }
-            })
+            tool: operation,
+            input
           });
-          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
-            return;
+        }
+        serializeConnectorRef(connector) {
+          if (connector == null) {
+            return null;
           }
-          throw this.unexpectedResponse("set_secret");
+          return {
+            openai_connector_id: connector.openaiConnectorId ?? null,
+            server_url: connector.serverUrl ?? null,
+            client_secret_id: connector.clientSecretId ?? null
+          };
         }
-        async getSecret({ secretId, delegatedTo }) {
-          const req = {
-            secret_id: secretId,
-            type: null,
-            name: null,
-            delegated_to: delegatedTo ?? null
+        serializeOAuthConfig(oauth) {
+          if (oauth == null) {
+            return null;
+          }
+          return {
+            client_id: oauth.client_id,
+            client_secret: oauth.client_secret ?? null,
+            authorization_endpoint: oauth.authorization_endpoint,
+            token_endpoint: oauth.token_endpoint,
+            no_pkce: oauth.no_pkce ?? null,
+            scopes: oauth.scopes ?? null
           };
-          const response = await this.client.invoke({ toolkit: "secrets", tool: "get_secret", input: req });
-          if (response instanceof response_1.EmptyContent) {
+        }
+        parseAccessToken(operation, response) {
+          if (!(response instanceof response_1.JsonContent)) {
+            throw this.unexpectedResponse(operation);
+          }
+          const token = response.json["access_token"];
+          if (typeof token !== "string" || token.length === 0) {
             return null;
           }
-          if (response instanceof response_1.FileContent) {
-            return response;
+          return token;
+        }
+        parseSecretInfo(value) {
+          if (!isRecord(value) || typeof value["id"] !== "string" || typeof value["name"] !== "string" || typeof value["type"] !== "string") {
+            throw this.unexpectedResponse("list_secrets");
           }
-          throw this.unexpectedResponse("get_secret");
+          const delegatedTo = value["delegated_to"];
+          if (delegatedTo !== void 0 && delegatedTo !== null && typeof delegatedTo !== "string") {
+            throw this.unexpectedResponse("list_secrets");
+          }
+          return {
+            id: value["id"],
+            name: value["name"],
+            type: value["type"],
+            delegatedTo
+          };
+        }
+        async _handleClientOAuthTokenRequest(protocol, messageId, type, bytes) {
+          void protocol;
+          void messageId;
+          void type;
+          if (bytes == null) {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_oauth_token payload");
+          }
+          if (this.oauthTokenRequestHandler == null) {
+            throw new room_server_client_1.RoomServerException("No oauth token handler registered");
+          }
+          const [request] = (0, utils_1.unpackMessage)(bytes);
+          const requestId = request["request_id"];
+          const challenge = request["challenge"];
+          const requestPayload = request["request"];
+          if (typeof requestId !== "string" || !isRecord(requestPayload)) {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_oauth_token payload");
+          }
+          const oauth = requestPayload["oauth"];
+          if (!isRecord(oauth) || typeof oauth["authorization_endpoint"] !== "string" || typeof oauth["token_endpoint"] !== "string") {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_oauth_token payload");
+          }
+          const scopes = oauth["scopes"];
+          if (scopes !== void 0 && scopes !== null && (!Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string"))) {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_oauth_token payload");
+          }
+          Promise.resolve(this.oauthTokenRequestHandler({
+            requestId,
+            authorizationEndpoint: oauth["authorization_endpoint"],
+            tokenEndpoint: oauth["token_endpoint"],
+            challenge: typeof challenge === "string" ? challenge : null,
+            scopes: scopes ?? null,
+            clientId: typeof oauth["client_id"] === "string" ? oauth["client_id"] : null
+          })).catch((error) => {
+            console.warn("OAuth token request handler threw", error);
+          });
+        }
+        async _handleClientSecretRequest(protocol, messageId, type, bytes) {
+          void protocol;
+          void messageId;
+          void type;
+          if (bytes == null) {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_secret payload");
+          }
+          if (this.secretRequestHandler == null) {
+            throw new room_server_client_1.RoomServerException("No secret handler registered");
+          }
+          const [request] = (0, utils_1.unpackMessage)(bytes);
+          const requestId = request["request_id"];
+          const requestPayload = request["request"];
+          if (typeof requestId !== "string" || !isRecord(requestPayload) || typeof requestPayload["url"] !== "string" || typeof requestPayload["type"] !== "string") {
+            throw new room_server_client_1.RoomServerException("invalid secrets.request_secret payload");
+          }
+          Promise.resolve(this.secretRequestHandler({
+            requestId,
+            url: requestPayload["url"],
+            type: requestPayload["type"],
+            delegateTo: typeof requestPayload["delegate_to"] === "string" ? requestPayload["delegate_to"] : null
+          })).catch((error) => {
+            console.warn("Secret request handler threw", error);
+          });
+        }
+        async provideOAuthAuthorization({ requestId, code }) {
+          const response = await this.invoke("provide_oauth_authorization", {
+            request_id: requestId,
+            code,
+            error: null
+          });
+          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+          }
+          throw this.unexpectedResponse("provide_oauth_authorization");
+        }
+        async rejectOAuthAuthorization({ requestId, error }) {
+          const response = await this.invoke("provide_oauth_authorization", {
+            request_id: requestId,
+            code: null,
+            error
+          });
+          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+          }
+          throw this.unexpectedResponse("provide_oauth_authorization");
+        }
+        async provideSecret({ requestId, data }) {
+          const response = await this.invoke("provide_secret", new response_1.BinaryContent({
+            data,
+            headers: {
+              request_id: requestId,
+              error: null
+            }
+          }));
+          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+          }
+          throw this.unexpectedResponse("provide_secret");
+        }
+        async rejectSecret({ requestId, error }) {
+          const response = await this.invoke("provide_secret", new response_1.BinaryContent({
+            data: new Uint8Array(0),
+            headers: {
+              request_id: requestId,
+              error
+            }
+          }));
+          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+          }
+          throw this.unexpectedResponse("provide_secret");
+        }
+        async getOfflineOAuthToken({ connector, oauth, delegatedTo, delegatedBy }) {
+          const response = await this.invoke("get_offline_oauth_token", {
+            connector: this.serializeConnectorRef(connector),
+            oauth: this.serializeOAuthConfig(oauth),
+            delegated_to: delegatedTo ?? null,
+            delegated_by: delegatedBy ?? null
+          });
+          return this.parseAccessToken("get_offline_oauth_token", response);
+        }
+        async requestOAuthToken({ connector, oauth, timeout = 60 * 5, fromParticipantId, redirectUri, delegateTo }) {
+          const response = await this.invoke("request_oauth_token", {
+            connector: this.serializeConnectorRef(connector),
+            oauth: this.serializeOAuthConfig(oauth),
+            redirect_uri: typeof redirectUri === "string" ? redirectUri : redirectUri.toString(),
+            timeout,
+            participant_id: fromParticipantId,
+            delegate_to: delegateTo ?? null
+          });
+          return this.parseAccessToken("request_oauth_token", response);
         }
         async listSecrets() {
-          const response = await this.client.invoke({ toolkit: "secrets", tool: "list_secrets", input: {} });
+          const response = await this.invoke("list_secrets", {});
           if (!(response instanceof response_1.JsonContent)) {
             throw this.unexpectedResponse("list_secrets");
           }
-          const secrets = Array.isArray(response.json?.secrets) ? response.json.secrets : [];
-          return secrets.map((item) => ({
-            id: item.id,
-            name: item.name,
-            type: item.type,
-            delegatedTo: item.delegated_to
-          }));
+          const secrets = response.json["secrets"];
+          if (!Array.isArray(secrets)) {
+            throw this.unexpectedResponse("list_secrets");
+          }
+          return secrets.map((item) => this.parseSecretInfo(item));
         }
         async deleteSecret({ secretId, delegatedTo }) {
-          const req = {
+          const response = await this.invoke("delete_secret", {
             id: secretId,
             delegated_to: delegatedTo ?? null
-          };
-          const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_secret", input: req });
+          });
           if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
           }
           throw this.unexpectedResponse("delete_secret");
         }
         async deleteRequestedSecret({ url, type, delegatedTo }) {
-          const req = {
+          const response = await this.invoke("delete_requested_secret", {
             url,
             type,
             delegated_to: delegatedTo ?? null
-          };
-          const response = await this.client.invoke({ toolkit: "secrets", tool: "delete_requested_secret", input: req });
+          });
           if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
             return;
           }
           throw this.unexpectedResponse("delete_requested_secret");
         }
+        async requestSecret({ fromParticipantId, url, type, timeout = 60 * 5, delegateTo }) {
+          const response = await this.invoke("request_secret", {
+            url,
+            type,
+            participant_id: fromParticipantId,
+            timeout,
+            delegate_to: delegateTo ?? null
+          });
+          if (response instanceof response_1.FileContent) {
+            return response.data;
+          }
+          throw this.unexpectedResponse("request_secret");
+        }
+        async setSecret({ secretId, type, mimeType, name, delegatedTo, forIdentity, data }) {
+          const response = await this.invoke("set_secret", new response_1.BinaryContent({
+            data,
+            headers: {
+              secret_id: secretId ?? null,
+              type: type ?? mimeType ?? null,
+              name: name ?? null,
+              delegated_to: delegatedTo ?? null,
+              for_identity: forIdentity ?? null,
+              has_data: true
+            }
+          }));
+          if (response instanceof response_1.EmptyContent || response instanceof response_1.JsonContent) {
+            return;
+          }
+          throw this.unexpectedResponse("set_secret");
+        }
+        async getSecret({ secretId, type, name, delegatedTo }) {
+          const response = await this.invoke("get_secret", {
+            secret_id: secretId ?? null,
+            type: type ?? null,
+            name: name ?? null,
+            delegated_to: delegatedTo ?? null
+          });
+          if (response instanceof response_1.EmptyContent) {
+            return null;
+          }
+          if (response instanceof response_1.FileContent) {
+            return response;
+          }
+          throw this.unexpectedResponse("get_secret");
+        }
       };
       exports.SecretsClient = SecretsClient;
     }
@@ -25482,6 +26235,7 @@ ${newlined}
           return this._ready.fut;
         }
         async start({ onDone, onError } = {}) {
+          await this.messaging.start();
           this.sync.start({ onDone, onError });
           await this.ready;
         }
@@ -25491,6 +26245,7 @@ ${newlined}
             pr?.reject(new Error("Disposed"));
             this._pendingRequests.delete(prKey);
           }
+          this.messaging.dispose();
           this.sync.dispose();
           for (const stream of this._toolCallStreams.values()) {
             stream.close();
@@ -26252,9 +27007,6 @@ ${newlined}
 
   // src/ensure-login.ts
   var DEFAULT_SERVER_URL = "https://api.meshagent.com";
-  var CALLBACK_URL_KEY = "ma:callback_url";
-  var CALLBACK_SOURCE_QUERY_PARAM = "ma_origin";
-  var CALLBACK_SOURCE_QUERY_VALUE = "meshagent_auth";
   function getCurrentUrl() {
     if (typeof window === "undefined") {
       throw new Error("ensureLogin requires a browser environment");
@@ -26263,23 +27015,17 @@ ${newlined}
   }
   function clearMeshagentAuthQueryParams(url) {
     url.searchParams.delete("code");
+    url.searchParams.delete("scope");
     url.searchParams.delete("state");
     url.searchParams.delete("error");
     url.searchParams.delete("error_description");
     url.searchParams.delete("error_uri");
-    url.searchParams.delete(CALLBACK_SOURCE_QUERY_PARAM);
-  }
-  function hasMeshagentCallbackMarker(url) {
-    return url.searchParams.get(CALLBACK_SOURCE_QUERY_PARAM) === CALLBACK_SOURCE_QUERY_VALUE;
   }
   function isMeshagentCallbackUrl(callbackUrl) {
     const currentUrl = getCurrentUrl();
     if (!currentUrl.searchParams.has("code")) {
       return false;
     }
-    if (!callbackUrl) {
-      return hasMeshagentCallbackMarker(currentUrl);
-    }
     const expectedCallbackUrl = new URL(callbackUrl, currentUrl);
     clearMeshagentAuthQueryParams(currentUrl);
     clearMeshagentAuthQueryParams(expectedCallbackUrl);
@@ -26291,28 +27037,8 @@ ${newlined}
     }
     const currentUrl = getCurrentUrl();
     clearMeshagentAuthQueryParams(currentUrl);
-    currentUrl.searchParams.set(
-      CALLBACK_SOURCE_QUERY_PARAM,
-      CALLBACK_SOURCE_QUERY_VALUE
-    );
     return currentUrl.toString();
   }
-  function getExchangeCallbackUrl(callbackUrl, storage) {
-    if (callbackUrl) {
-      return callbackUrl;
-    }
-    const storedCallbackUrl = storage.getItem(CALLBACK_URL_KEY);
-    if (storedCallbackUrl) {
-      return storedCallbackUrl;
-    }
-    return getRedirectCallbackUrl(void 0);
-  }
-  function saveCallbackUrl(storage, callbackUrl) {
-    storage.setItem(CALLBACK_URL_KEY, callbackUrl);
-  }
-  function clearCallbackUrl(storage) {
-    storage.removeItem(CALLBACK_URL_KEY);
-  }
   function replaceCurrentUrlWithoutAuthParams() {
     if (typeof window === "undefined" || typeof window.history.replaceState !== "function") {
       return;
@@ -26330,9 +27056,9 @@ ${newlined}
     const serverBaseUrl = serverUrl ?? DEFAULT_SERVER_URL;
     const storage = getDefaultStorage();
     const cache2 = new LocalStoragePkceCache(storage);
-    const authorizationCode = isMeshagentCallbackUrl(callbackUrl) ? getAuthorizationCode() : null;
+    const authorizationCode = isMeshagentCallbackUrl(callbackUrl ?? window.location.href) ? getAuthorizationCode() : null;
     if (authorizationCode) {
-      const exchangeCallbackUrl = getExchangeCallbackUrl(callbackUrl, storage);
+      const exchangeCallbackUrl = getRedirectCallbackUrl(callbackUrl);
       await exchangeToken({
         oauthClientId,
         serverUrl: serverBaseUrl,
@@ -26342,18 +27068,22 @@ ${newlined}
         auth: MeshagentAuth.current
       });
       await cache2.clearVerifier();
-      clearCallbackUrl(storage);
       replaceCurrentUrlWithoutAuthParams();
       return;
     }
     if (MeshagentAuth.current.isLoggedIn()) {
+      const auth = MeshagentAuth.current;
+      const client = getMeshagentClient(auth, serverUrl ?? DEFAULT_SERVER_URL);
+      const me = await client.getUserProfile("me");
+      if (me) {
+        auth.setUser(me);
+      }
       return;
     }
     const redirectCallbackUrl = getRedirectCallbackUrl(callbackUrl);
     const generator = new PkceGenerator();
     const pkce = await generator.generate();
     await cache2.saveVerifier(pkce.codeVerifier);
-    saveCallbackUrl(storage, redirectCallbackUrl);
     const query = new URLSearchParams({
       scope: "email",
       client_id: oauthClientId,