@auersperg/flare 0.3.8 → 0.3.10

package/dist/platform/runtime.js

@@ -2,6 +2,35 @@
 import { Buffer as Buffer2 } from "node:buffer";
 import { scrypt, timingSafeEqual } from "node:crypto";
 
+// packages/flare/src/sdk/http.ts
+async function readBody(body, limit, tooLarge) {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      size += value.byteLength;
+      if (size > limit)
+        tooLarge();
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  if (chunks.length === 1)
+    return chunks[0];
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+
 // packages/flare/src/sdk/protocol.ts
 var LIMITS = Object.freeze({
   inputBytes: 65536,
@@ -84,28 +113,7 @@ async function jsonBody(request, limit = LIMITS.inputBytes) {
     fail("INVALID_CONTENT_TYPE");
   if (!request.body)
     fail("INVALID_INPUT");
-  const reader = request.body.getReader();
-  const chunks = [];
-  let size = 0;
-  try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      size += value.byteLength;
-      if (size > limit)
-        fail("TOO_LARGE");
-      chunks.push(value);
-    }
-  } finally {
-    await reader.cancel().catch(() => {});
-  }
-  const bytes = new Uint8Array(size);
-  let offset = 0;
-  for (const c of chunks) {
-    bytes.set(c, offset);
-    offset += c.byteLength;
-  }
+  const bytes = await readBody(request.body, limit, () => fail("TOO_LARGE"));
   try {
     const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
     boundedJson(parsed, limit);
@@ -291,6 +299,12 @@ function validateAuthBackup(users) {
 var ttl = 12 * 60 * 60 * 1000;
 var kdf = { N: 16384, r: 8, p: 5, maxmem: 32 * 1024 * 1024 };
 var dummySalt = "00000000000000000000000000000000";
+var userInfo = (row) => ({
+  id: String(row.id),
+  login: String(row.login),
+  disabled: !!row.disabled,
+  createdAt: Number(row.createdAt)
+});
 function derive(password, salt) {
   return new Promise((resolve, reject) => scrypt(password, salt, 32, kdf, (error, value) => error ? reject(error) : resolve(value)));
 }
@@ -405,12 +419,7 @@ class PasswordAuth {
     const row = this.storage.sql.exec("SELECT id,login,disabled,createdAt FROM auth_users WHERE id=?", id).toArray()[0];
     if (!row)
       fail("NOT_FOUND");
-    return {
-      id: String(row.id),
-      login: String(row.login),
-      disabled: !!row.disabled,
-      createdAt: Number(row.createdAt)
-    };
+    return userInfo(row);
   }
   async authenticate(token) {
     if (!/^flared_session_[a-f0-9]{64}$/.test(token) || !this.settings().enabled)
@@ -498,9 +507,9 @@ class PasswordAuth {
       const cursor = input.cursor ?? "";
       if (typeof cursor !== "string" || cursor.length > 36)
         fail("INVALID_CURSOR");
-      const rows = this.storage.sql.exec("SELECT id FROM auth_users WHERE id>? ORDER BY id LIMIT 51", cursor).toArray();
+      const rows = this.storage.sql.exec("SELECT id,login,disabled,createdAt FROM auth_users WHERE id>? ORDER BY id LIMIT 51", cursor).toArray();
       return {
-        users: rows.slice(0, 50).map((r) => this.user(String(r.id))),
+        users: rows.slice(0, 50).map(userInfo),
         next: rows.length > 50 ? String(rows[49].id) : null
       };
     }
@@ -560,7 +569,7 @@ function dashboardIdentity(value) {
 // packages/core/package.json
 var package_default = {
   name: "@flare/platform",
-  version: "0.3.8",
+  version: "0.3.10",
   type: "module",
   license: "MIT",
   private: true,
@@ -901,6 +910,25 @@ function buildKey(scope, hash, role) {
 var BACKUP_BYTES = SNAPSHOT_BYTES + 4 * 1048576;
 var BACKUP_FILES = 100;
 var BACKUP_FILE_BYTES = 100 * 1048576;
+async function copyInParallel(files, copy) {
+  const copied = new Array(files.length);
+  let next = 0;
+  const results = await Promise.allSettled(Array.from({ length: Math.min(3, files.length) }, async () => {
+    while (next < files.length) {
+      const i = next++;
+      try {
+        copied[i] = await copy(files[i]);
+      } catch (error) {
+        next = files.length;
+        throw error;
+      }
+    }
+  }));
+  for (const result of results)
+    if (result.status === "rejected")
+      throw result.reason;
+  return copied;
+}
 function backupPrefix(scope, id) {
   return `backups/${scopeForDeletion(scope)}/${id === undefined ? "" : uuid(id) + "/"}`;
 }
@@ -955,8 +983,8 @@ class BackupStore {
       fail("BACKUP_TOO_LARGE");
     if (files.length && !this.files)
       fail("UNSUPPORTED");
-    const prefix = backupPrefix(value.scope, value.id), copied = [];
-    for (const file of files) {
+    const prefix = backupPrefix(value.scope, value.id);
+    const copied = await copyInParallel(files, async (file) => {
       const object = await this.files.get(fileKey(value.scope, file.id));
       if (!object || object.size !== file.size || !/^[a-f0-9]{32}$/.test(object.etag))
         fail("INVALID_BACKUP");
@@ -966,8 +994,8 @@ class BackupStore {
       });
       if (!stored || stored.size !== file.size || stored.etag !== object.etag)
         fail("INVALID_BACKUP");
-      copied.push({ ...file, md5: stored.etag });
-    }
+      return { ...file, md5: stored.etag };
+    });
     const backup = { ...value, files: copied }, encoded = boundedJson(backup, BACKUP_BYTES);
     const stored = await this.bucket.put(prefix + "manifest.json", encoded, {
       onlyIf: { etagDoesNotMatch: "*" },
@@ -1005,11 +1033,10 @@ class BackupStore {
       limit: 20,
       cursor
     });
-    const backups = [];
-    for (const prefix of page.delimitedPrefixes) {
+    const backups = await Promise.all(page.delimitedPrefixes.map(async (prefix) => {
       const id = prefix.slice(backupPrefix(scope).length, -1);
       const manifest = await this.bucket.head(prefix + "manifest.json"), meta = manifest?.customMetadata;
-      backups.push(meta ? {
+      return meta ? {
         id,
         scope,
         at: Number(meta.at),
@@ -1017,14 +1044,14 @@ class BackupStore {
         revision: Number(meta.revision),
         rows: Number(meta.rows),
         files: Number(meta.files)
-      } : { id, scope, state: "incomplete" });
-    }
+      } : { id, scope, state: "incomplete" };
+    }));
     return { page: backups, cursor: page.truncated ? page.cursor : null };
   }
   async copyFiles(value, target) {
     if (value.files.length && !this.files)
       fail("UNSUPPORTED");
-    for (const file of value.files) {
+    await copyInParallel(value.files, async (file) => {
       const object = await this.bucket.get(backupPrefix(value.scope, value.id) + "files/" + file.id, { onlyIf: { etagMatches: file.md5 } });
       if (!object || !("body" in object) || !object.body || object.size !== file.size)
         fail("INVALID_BACKUP");
@@ -1034,7 +1061,7 @@ class BackupStore {
       });
       if (!stored || stored.size !== file.size || stored.etag !== file.md5)
         fail("INVALID_BACKUP");
-    }
+    });
   }
   async remove(scope, id) {
     const prefix = backupPrefix(scope, id);
@@ -1097,7 +1124,7 @@ class BackupInventory {
       await this.storage.sync();
     }
     const complete = !!this.storage.sql.exec("SELECT complete FROM backup_inventory WHERE id=1").one().complete;
-    const rows = before ? this.storage.sql.exec("SELECT * FROM backup_index WHERE at<? OR (at=? AND id<?) ORDER BY at DESC,id DESC LIMIT 21", before.at, before.at, before.id).toArray() : this.storage.sql.exec("SELECT * FROM backup_index ORDER BY at DESC,id DESC LIMIT 21").toArray();
+    const rows = before ? this.storage.sql.exec("SELECT * FROM backup_index WHERE (at,id)<(?,?) ORDER BY at DESC,id DESC LIMIT 21", before.at, before.id).toArray() : this.storage.sql.exec("SELECT * FROM backup_index ORDER BY at DESC,id DESC LIMIT 21").toArray();
     const page = rows.slice(0, 20).map((r) => JSON.parse(String(r.summary)));
     const last = rows[19];
     const newest = complete ? this.storage.sql.exec("SELECT summary FROM backup_index WHERE at>=0 ORDER BY at DESC,id DESC LIMIT 1").toArray()[0] : undefined;
@@ -1185,8 +1212,10 @@ function queueBatches(bodies) {
   return batches;
 }
 async function consumeBatch(batch, work, failed) {
-  for (let offset = 0;offset < batch.messages.length; offset += 4) {
-    await Promise.all(batch.messages.slice(offset, offset + 4).map(async (message) => {
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(4, batch.messages.length) }, async () => {
+    while (next < batch.messages.length) {
+      const message = batch.messages[next++];
       try {
         await work(message.body);
         message.ack();
@@ -1194,8 +1223,8 @@ async function consumeBatch(batch, work, failed) {
         failed(message.body, error);
         message.retry();
       }
-    }));
-  }
+    }
+  }));
 }
 
 // packages/core/src/capabilities.ts
@@ -8110,6 +8139,7 @@ class EnvironmentSupervisor extends DurableObject {
           dueAt: Date.now()
         });
         await this.recover();
+        await this.dashboardHint();
       })
     }
   });
@@ -8141,6 +8171,7 @@ class EnvironmentSupervisor extends DurableObject {
     this.ctx.storage.sql.exec("CREATE TABLE IF NOT EXISTS retention (id INTEGER PRIMARY KEY,next INTEGER NOT NULL)");
     this.ctx.storage.sql.exec("CREATE INDEX IF NOT EXISTS receipts_at ON receipts(at)");
     this.ctx.storage.sql.exec("CREATE INDEX IF NOT EXISTS job_events_retention ON job_events(state,at)");
+    this.ctx.storage.sql.exec("CREATE INDEX IF NOT EXISTS job_events_at ON job_events(at)");
     this.ctx.storage.sql.exec("CREATE INDEX IF NOT EXISTS job_events_release ON job_events(release,state)");
     this.nextRetention = Number(this.ctx.storage.sql.exec("SELECT next FROM retention WHERE id=1").toArray()[0]?.next ?? 0);
     const alive = new Set([...this.sockets.getConnections()].map((c) => c.id));
@@ -8427,30 +8458,28 @@ class EnvironmentSupervisor extends DurableObject {
     return s.auth;
   }
   async snapshot(c, row, cache = new SnapshotCache) {
-    const auth = this.connectionAuth(c), key = stableJson({ path: row.path, args: JSON.parse(row.args), auth });
+    const auth = this.connectionAuth(c);
     if (Number(row.sent) > Number(row.acked)) {
       this.ctx.storage.sql.exec("UPDATE subscriptions SET pending=1 WHERE connection=? AND id=?", c.id, row.id);
       return;
     }
     try {
+      const args = JSON.parse(row.args), key = stableJson({ path: row.path, args, auth });
       const { value: result, hash } = await cache.get(key, () => this.invoke({
         path: row.path,
         kind: "query",
-        args: JSON.parse(row.args),
+        args,
         auth
       }));
-      this.ctx.storage.sql.exec("UPDATE subscriptions SET dependencies=?,checked=?,release=? WHERE connection=? AND id=?", JSON.stringify(result.tables), result.revision, this.current(), c.id, row.id);
-      if (row.hash === hash) {
-        this.ctx.storage.sql.exec("UPDATE subscriptions SET pending=0 WHERE connection=? AND id=?", c.id, row.id);
-        return;
-      }
-      c.send(boundedJson({
-        type: "snapshot",
-        id: row.id,
-        result: result.result,
-        revision: result.revision
-      }, LIMITS.outputBytes + 1024));
-      this.ctx.storage.sql.exec("UPDATE subscriptions SET sent=?,hash=?,pending=0 WHERE connection=? AND id=?", result.revision, hash, c.id, row.id);
+      const changed = row.hash !== hash;
+      if (changed)
+        c.send(boundedJson({
+          type: "snapshot",
+          id: row.id,
+          result: result.result,
+          revision: result.revision
+        }, LIMITS.outputBytes + 1024));
+      this.ctx.storage.sql.exec("UPDATE subscriptions SET dependencies=?,checked=?,release=?,sent=?,hash=?,pending=0 WHERE connection=? AND id=?", JSON.stringify(result.tables), result.revision, this.current(), changed ? result.revision : row.sent, hash, c.id, row.id);
     } catch (e) {
       c.send(JSON.stringify({ type: "error", id: row.id, code: status(e).code }));
       this.ctx.storage.sql.exec("DELETE FROM subscriptions WHERE connection=? AND id=?", c.id, row.id);
@@ -8491,7 +8520,6 @@ class EnvironmentSupervisor extends DurableObject {
     }
   }
   async broadcast() {
-    await this.dashboardHint();
     const connections = [...this.sockets.getConnections()].filter((c) => !c.state?.dashboard);
     if (!connections.length)
       return;
@@ -8550,8 +8578,10 @@ class EnvironmentSupervisor extends DurableObject {
   }
   async onJob({ job }) {
     await this.serial(async () => {
-      if (job.fn === "recover")
+      if (job.fn === "recover") {
         await this.recover();
+        await this.dashboardHint();
+      }
       if (job.fn === "files-cleanup")
         await this.files().sweep();
       if (job.fn === "cron-reconcile")
@@ -8682,8 +8712,10 @@ class EnvironmentSupervisor extends DurableObject {
       if (input.authorization && !input.authorization.startsWith("Bearer "))
         fail("UNAUTHORIZED");
       const result = await this.passwords().public(input.operation, input.body ?? {}, input.authorization?.slice(7) ?? null);
-      this.closeRevokedSockets();
-      await this.dashboardHint();
+      if (input.operation !== "me") {
+        this.closeRevokedSockets();
+        await this.dashboardHint();
+      }
       return result;
     });
   }
@@ -8948,7 +8980,8 @@ class EnvironmentSupervisor extends DurableObject {
       if (op.startsWith("auth-")) {
         this.assertAvailable();
         const result = await this.passwords().admin(op, input);
-        this.closeRevokedSockets();
+        if (op !== "auth-users" && op !== "auth-settings")
+          this.closeRevokedSockets();
         return result;
       }
       if (op === "release-export") {

package/dist/sdk/backup.js

@@ -1,6 +1,6 @@
 import { boundedJson, FlareError, stableJson } from "./protocol.js";
 import {
-  documentValue,
+  documentJson,
   quote,
   schemaContract
 } from "./schema.js";
@@ -66,10 +66,10 @@ export async function restoreData(storage, schema, id, snapshot) {
       for (const doc of docs) {
         if (++count > SNAPSHOT_ROWS || !doc || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(doc._id) || !Number.isFinite(doc._creationTime) || doc._creationTime < 0)
           reject("INVALID_BACKUP");
-        const value = await documentValue(schema[name], doc.value);
-        if (stableJson(value) !== stableJson(doc.value))
+        const value = await documentJson(schema[name], doc.value);
+        if (value !== stableJson(doc.value))
           reject("INVALID_BACKUP");
-        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, stableJson(value));
+        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, value);
       }
     }
     storage.sql.exec("UPDATE _flared_revision SET value=? WHERE id=1", snapshot.revision);

package/dist/sdk/client.js

@@ -1,3 +1,4 @@
+import { readBody } from "./http.js";
 import {
   assertPath,
   boundedJson,
@@ -37,12 +38,17 @@ export async function uploadFile(grant, file, options = {}) {
       body: file,
       redirect: "error",
       credentials: "omit",
-      signal: options.signal ?? AbortSignal.timeout(options.timeoutMs ?? 120000)
+      signal: AbortSignal.any([
+        ...options.signal ? [options.signal] : [],
+        AbortSignal.timeout(options.timeoutMs ?? 120000)
+      ])
     });
   } catch {
     throw new FlareError("UPLOAD_UNKNOWN", "Connection interrupted or upload timed out; refresh the file list before trying again", true);
   }
-  const result = await response.json().catch(() => null);
+  const result = response.body ? await readBody(response.body, LIMITS.outputBytes, () => {
+    throw Error("Upload response exceeds limit");
+  }).then((bytes) => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes))).catch(() => null) : null;
   if (!response.ok) {
     const code = result && typeof result === "object" && "error" in result && typeof result.error === "string" ? result.error : `HTTP_${response.status}`;
     throw new FlareError(code, `Upload failed: ${code}`, response.status >= 500);
@@ -77,7 +83,7 @@ export function createClient(options) {
   const notify = (sub, method, value) => {
     for (const observer of sub.observers) {
       try {
-        observer[method]?.(method === "next" ? JSON.parse(stableJson(value)) : value);
+        observer[method]?.(method === "next" ? JSON.parse(value) : value);
       } catch {}
     }
   };
@@ -110,28 +116,9 @@ export function createClient(options) {
       });
       if (!response.body)
         throw new FlareError("INVALID_RESPONSE", "Missing response body", write);
-      const reader = response.body.getReader();
-      let bytes = 0;
-      const chunks = [];
-      try {
-        for (;; ) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          bytes += value.byteLength;
-          if (bytes > LIMITS.outputBytes)
-            throw new FlareError("INVALID_RESPONSE", "Response exceeds limit", write);
-          chunks.push(value);
-        }
-      } finally {
-        await reader.cancel().catch(() => {});
-      }
-      const combined = new Uint8Array(bytes);
-      let offset = 0;
-      for (const chunk of chunks) {
-        combined.set(chunk, offset);
-        offset += chunk.byteLength;
-      }
+      const combined = await readBody(response.body, LIMITS.outputBytes, () => {
+        throw new FlareError("INVALID_RESPONSE", "Response exceeds limit", write);
+      });
       let data;
       try {
         data = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(combined));
@@ -195,7 +182,7 @@ export function createClient(options) {
         attempt = 0;
         for (const sub of subscriptions.values()) {
           sub.revision = -1;
-          sub.hasValue = false;
+          sub.snapshot = undefined;
           if (!sub.terminal)
             register(sub);
         }
@@ -215,8 +202,7 @@ export function createClient(options) {
           if (frame.type === "error") {
             sub.terminal = true;
             if (authorizationErrors.has(frame.code)) {
-              sub.hasValue = false;
-              sub.value = undefined;
+              sub.snapshot = undefined;
             }
             notify(sub, "error", new FlareError(typeof frame.code === "string" ? frame.code : "LIVE_ERROR", "Live subscription failed"));
             return;
@@ -225,12 +211,11 @@ export function createClient(options) {
             throw new Error("Invalid snapshot");
           const json = boundedJson(frame.result, LIMITS.outputBytes);
           if (frame.revision > sub.revision) {
-            const changed = !sub.hasValue || stableJson(sub.value) !== json;
+            const changed = sub.snapshot !== json;
             sub.revision = frame.revision;
-            sub.value = frame.result;
-            sub.hasValue = true;
+            sub.snapshot = json;
             if (changed)
-              notify(sub, "next", sub.value);
+              notify(sub, "next", sub.snapshot);
           }
           send({ type: "ack", id: sub.id, revision: sub.revision });
         } catch {
@@ -244,8 +229,7 @@ export function createClient(options) {
         socket = undefined;
         for (const sub of subscriptions.values()) {
           if (event.code === 1008) {
-            sub.hasValue = false;
-            sub.value = undefined;
+            sub.snapshot = undefined;
             sub.revision = -1;
           }
           if (!sub.terminal)
@@ -271,8 +255,7 @@ export function createClient(options) {
         return;
       for (const sub of subscriptions.values()) {
         if (error instanceof FlareError && authorizationErrors.has(error.code)) {
-          sub.hasValue = false;
-          sub.value = undefined;
+          sub.snapshot = undefined;
           sub.revision = -1;
         }
         notify(sub, "error", error instanceof FlareError ? error : new FlareError("LIVE_UNAVAILABLE", "Live connection failed"));
@@ -319,7 +302,6 @@ export function createClient(options) {
           args: JSON.parse(stableJson(args)),
           observers: new Set,
           revision: -1,
-          hasValue: false,
           terminal: false
         };
         subscriptions.set(key, sub);
@@ -328,8 +310,8 @@ export function createClient(options) {
       }
       const registration = { next: observer.next, error: observer.error };
       sub.observers.add(registration);
-      if (sub.hasValue)
-        notify({ ...sub, observers: new Set([observer]) }, "next", sub.value);
+      if (sub.snapshot !== undefined)
+        notify({ ...sub, observers: new Set([observer]) }, "next", sub.snapshot);
       connect();
       let unsubscribed = false;
       return () => {
@@ -367,8 +349,7 @@ export function createClient(options) {
       socket = undefined;
       old?.close(1000, "Authorization changed");
       for (const sub of subscriptions.values()) {
-        sub.hasValue = false;
-        sub.value = undefined;
+        sub.snapshot = undefined;
         sub.revision = -1;
         sub.terminal = false;
         notify(sub, "error", new FlareError("AUTH_CHANGED", "Authorization changed; cached value invalidated"));

package/dist/sdk/cloudflare.js

@@ -102,7 +102,7 @@ export function createFacet(app) {
         }
         let result = null;
         const changed = new Set;
-        await this.ctx.storage.transaction(async () => {
+        const revision = await this.ctx.storage.transaction(async () => {
           let active = true;
           const scheduled = [];
           const jobs = Object.freeze({
@@ -136,9 +136,7 @@ export function createFacet(app) {
                 if (!active)
                   throw new FlareError("CAPABILITY_EXPIRED", "Mutation invocation ended");
                 const id = crypto.randomUUID();
-                this.ctx.storage.sql.exec("INSERT INTO _flared_outbox (id,release,path,args,auth,dueAt) VALUES (?,?,?,?,?,?)", id, this.env.RELEASE_ID, path, JSON.stringify(input), JSON.stringify(call.auth), Date.now() + Math.ceil(delay * 1000));
-                if (target.auth === "internal")
-                  this.ctx.storage.sql.exec("UPDATE _flared_outbox SET internal=1,auth='null' WHERE id=?", id);
+                this.ctx.storage.sql.exec("INSERT INTO _flared_outbox (id,release,path,args,auth,dueAt,internal) VALUES (?,?,?,?,?,?,?)", id, this.env.RELEASE_ID, path, JSON.stringify(input), JSON.stringify(target.auth === "internal" ? null : call.auth), Date.now() + Math.ceil(delay * 1000), Number(target.auth === "internal"));
                 return id;
               })();
               scheduled.push(pending);
@@ -161,16 +159,17 @@ export function createFacet(app) {
             capability.revoke();
             await Promise.allSettled(scheduled);
           }
-          this.commitRevision(changed);
+          return this.commitRevision(changed);
         });
         await this.ctx.storage.sync();
-        return { result, revision: this.revision(), tables: [...changed] };
+        return { result, revision, tables: [...changed] };
       });
     }
     commitRevision(changed) {
-      this.ctx.storage.sql.exec("UPDATE _flared_revision SET value=value+1 WHERE id=1");
+      const revision = Number(this.ctx.storage.sql.exec("UPDATE _flared_revision SET value=value+1 WHERE id=1 RETURNING value").one().value);
       for (const name of changed)
-        this.ctx.storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?) ON CONFLICT(name) DO UPDATE SET revision=excluded.revision", name, this.revision());
+        this.ctx.storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?) ON CONFLICT(name) DO UPDATE SET revision=excluded.revision", name, revision);
+      return revision;
     }
     pendingJobs(limit = 100) {
       return this.serial(async () => {
@@ -295,7 +294,7 @@ export function createFacet(app) {
         boundedJson(input, LIMITS.inputBytes);
         let rows = [];
         const changed = new Set;
-        await this.ctx.storage.transaction(async () => {
+        const revision = await this.ctx.storage.transaction(async () => {
           if (input.expectedRevision !== this.revision())
             throw new FlareError("CONFLICT", "Data changed; reload before editing");
           const capability = database(this.ctx.storage.sql, app.schema, true, new Set, changed);
@@ -317,10 +316,10 @@ export function createFacet(app) {
           } finally {
             capability.revoke();
           }
-          this.commitRevision(changed);
+          return this.commitRevision(changed);
         });
         await this.ctx.storage.sync();
-        return { rows, revision: this.revision() };
+        return { rows, revision };
       });
     }
   };