@auersperg/flare 0.3.1 → 0.3.4

package/dist/platform/dashboard/bootstrap/facet.js

@@ -0,0 +1,914 @@
+// packages/flare/dist/sdk/protocol.js
+var LIMITS = Object.freeze({
+  inputBytes: 65536,
+  outputBytes: 262144,
+  frameBytes: 8192,
+  subscriptions: 64,
+  fileBytes: 10485760
+});
+
+class FlareError extends Error {
+  code;
+  ambiguous;
+  constructor(code, message, ambiguous = false) {
+    super(message);
+    this.code = code;
+    this.ambiguous = ambiguous;
+    this.name = "FlareError";
+  }
+}
+function errorCode(error) {
+  if (error instanceof Error && ["FlareError", "FlaredError"].includes(error.name)) {
+    const code = error.code;
+    if (typeof code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(code))
+      return code;
+  }
+  return "OPERATION_FAILED";
+}
+function assertPath(path) {
+  if (path.length > 256 || !/^[A-Za-z][A-Za-z0-9_]*(\/[A-Za-z][A-Za-z0-9_]*)*$/.test(path) || path.split("/").some((p) => ["__proto__", "prototype", "constructor"].includes(p))) {
+    throw new FlareError("INVALID_PATH", "Invalid function path");
+  }
+}
+function stableJson(value) {
+  const ancestors = new Set;
+  function visit(v, depth) {
+    if (depth > 40)
+      throw new FlareError("INVALID_JSON", "JSON nesting limit exceeded");
+    if (v === null || typeof v === "string" || typeof v === "boolean")
+      return v;
+    if (typeof v === "number" && Number.isFinite(v))
+      return v;
+    if (typeof v !== "object" || v === null || ancestors.has(v))
+      throw new FlareError("INVALID_JSON", "Expected lossless JSON");
+    if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null) {
+      throw new FlareError("INVALID_JSON", "Expected plain JSON object");
+    }
+    if (Object.getOwnPropertySymbols(v).length)
+      throw new FlareError("INVALID_JSON", "Symbol keys are unsupported");
+    ancestors.add(v);
+    let result;
+    if (Array.isArray(v)) {
+      result = Array.from(v, (item) => visit(item, depth + 1));
+    } else {
+      const out = Object.create(null);
+      for (const key of Object.keys(v).sort()) {
+        const descriptor = Object.getOwnPropertyDescriptor(v, key);
+        if (!("value" in descriptor))
+          throw new FlareError("INVALID_JSON", "Getters are unsupported");
+        out[key] = visit(descriptor.value, depth + 1);
+      }
+      result = out;
+    }
+    ancestors.delete(v);
+    return result;
+  }
+  return JSON.stringify(visit(value, 0));
+}
+function boundedJson(value, maxBytes) {
+  const json = stableJson(value);
+  if (new TextEncoder().encode(json).byteLength > maxBytes)
+    throw new FlareError("TOO_LARGE", "JSON payload exceeds limit");
+  return json;
+}
+
+// packages/flare/dist/sdk/schema.js
+function identifier(name) {
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,47}$/.test(name) || name.toLowerCase().startsWith("sqlite_"))
+    throw new FlareError("INVALID_SCHEMA", "Invalid table, index or field name");
+  return name;
+}
+var quote = (name) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,127}$/.test(name))
+    throw new FlareError("INVALID_SCHEMA", "Invalid SQL identifier");
+  return `"${name}"`;
+};
+var fieldSql = (field) => field === "_id" || field === "_creationTime" ? `"${field}"` : `json_extract("_data", '$.${identifier(field)}')`;
+var indexName = (table, index) => `idx_${table.length}_${table}_${index}`;
+var creationIndex = (table) => `creation_${table}`;
+function schemaContract(schema) {
+  const out = Object.create(null);
+  if (Object.keys(schema).length > 100)
+    throw new FlareError("INVALID_SCHEMA", "Maximum 100 tables");
+  for (const [name, table] of Object.entries(schema)) {
+    identifier(name);
+    const document = table.validator["~standard"].jsonSchema.output({
+      target: "draft-2020-12"
+    });
+    out[name] = { document, indexes: table.indexes };
+  }
+  assertSchemaContract(out);
+  return out;
+}
+function assertSchemaContract(contract) {
+  boundedJson(contract, 1048576);
+  if (!contract || Array.isArray(contract) || typeof contract !== "object" || Object.keys(contract).length > 100)
+    throw new FlareError("INVALID_SCHEMA", "Invalid schema");
+  const names = new Set;
+  for (const [name, table] of Object.entries(contract)) {
+    if (names.has(name.toLowerCase()))
+      throw new FlareError("INVALID_SCHEMA", "SQLite table names are case-insensitive");
+    names.add(name.toLowerCase());
+    identifier(name);
+    const doc = table?.document;
+    if (!doc || doc.type !== "object" || !doc.properties || doc.additionalProperties !== false)
+      throw new FlareError("INVALID_SCHEMA", "Tables require a closed object validator");
+    for (const field of Object.keys(doc.properties))
+      identifier(field);
+    if (Object.keys(doc.properties).length > 64 || !table.indexes || Object.keys(table.indexes).length > 20)
+      throw new FlareError("INVALID_SCHEMA", "Schema exceeds limits");
+    const indexes = new Set;
+    for (const [index, fields] of Object.entries(table.indexes)) {
+      if (indexes.has(index.toLowerCase()))
+        throw new FlareError("INVALID_SCHEMA", "SQLite index names are case-insensitive");
+      indexes.add(index.toLowerCase());
+      identifier(index);
+      if (!Array.isArray(fields) || fields.length < 1 || fields.length > 4 || new Set(fields).size !== fields.length)
+        throw new FlareError("INVALID_SCHEMA", "Invalid index fields");
+      for (const field of fields) {
+        identifier(field);
+        const p = doc.properties[field];
+        const scalar = (s) => Array.isArray(s?.type) && s.type.every((type) => ["string", "number", "integer", "boolean", "null"].includes(type)) || ["string", "number", "integer", "boolean", "null"].includes(s?.type) || Array.isArray(s?.anyOf) && s.anyOf.every(scalar);
+        if (!p || !scalar(p))
+          throw new FlareError("INVALID_SCHEMA", "Indexes require declared scalar fields");
+      }
+    }
+  }
+}
+var documents = new WeakMap;
+function documentSchema(table) {
+  let doc = documents.get(table.validator);
+  if (!doc) {
+    doc = table.validator["~standard"].jsonSchema.output({
+      target: "draft-2020-12"
+    });
+    documents.set(table.validator, doc);
+  }
+  return doc;
+}
+async function documentValue(table, input) {
+  boundedJson(input, 65536);
+  const properties = documentSchema(table).properties ?? {};
+  if (!input || Array.isArray(input) || typeof input !== "object" || Object.keys(input).some((k) => !Object.hasOwn(properties, k)))
+    throw new FlareError("INVALID_INPUT", "Unknown document field");
+  const result = await table.validator["~standard"].validate(input);
+  if (result.issues || !result.value || Array.isArray(result.value) || typeof result.value !== "object" || Object.keys(result.value).some((k) => !Object.hasOwn(properties, k)))
+    throw new FlareError("INVALID_INPUT", "Document failed schema validation");
+  return JSON.parse(boundedJson(result.value, 65536));
+}
+async function applySchema(storage, schema) {
+  const contract = schemaContract(schema), encoded = stableJson(contract);
+  await storage.transaction(async () => {
+    storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_schema (id INTEGER PRIMARY KEY CHECK(id=1), contract TEXT NOT NULL)");
+    const oldRow = storage.sql.exec("SELECT contract FROM _flared_schema WHERE id=1").toArray()[0];
+    if (oldRow?.contract === encoded)
+      return;
+    const old = oldRow ? JSON.parse(String(oldRow.contract)) : {};
+    for (const name of Object.keys(old))
+      if (!Object.hasOwn(schema, name)) {
+        if (storage.sql.exec(`SELECT 1 FROM ${quote(name)} LIMIT 1`).toArray().length)
+          throw new FlareError("INVALID_SCHEMA", "Cannot remove a nonempty table; explicitly clear it first");
+        storage.sql.exec(`DROP TABLE ${quote(name)}`);
+      }
+    for (const [name, definition] of Object.entries(contract)) {
+      storage.sql.exec(`CREATE TABLE IF NOT EXISTS ${quote(name)} (_id TEXT PRIMARY KEY, _creationTime REAL NOT NULL, _data TEXT NOT NULL CHECK(json_valid(_data)))`);
+      let cursor = "";
+      while (!old[name] || stableJson(old[name].document) !== stableJson(definition.document)) {
+        const rows = storage.sql.exec(`SELECT _id,_data FROM ${quote(name)} WHERE _id > ? ORDER BY _id LIMIT 100`, cursor).toArray();
+        for (const row of rows) {
+          const value = await documentValue(schema[name], JSON.parse(String(row._data)));
+          if (stableJson(value) !== stableJson(JSON.parse(String(row._data))))
+            storage.sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, stableJson(value), row._id);
+        }
+        if (rows.length < 100)
+          break;
+        cursor = String(rows.at(-1)._id);
+      }
+      storage.sql.exec(`CREATE INDEX IF NOT EXISTS ${quote(creationIndex(name))} ON ${quote(name)} (_creationTime,_id)`);
+      for (const [index, fields] of Object.entries(old[name]?.indexes ?? {}))
+        if (stableJson(definition.indexes[index] ?? null) !== stableJson(fields))
+          storage.sql.exec(`DROP INDEX IF EXISTS ${quote(indexName(name, index))}`);
+      for (const [index, fields] of Object.entries(definition.indexes))
+        storage.sql.exec(`CREATE INDEX IF NOT EXISTS ${quote(indexName(name, index))} ON ${quote(name)} (${[...fields.map(fieldSql), "_creationTime", "_id"].join(",")})`);
+    }
+    storage.sql.exec("INSERT INTO _flared_schema VALUES (1,?) ON CONFLICT(id) DO UPDATE SET contract=excluded.contract", encoded);
+  });
+  await storage.sync();
+}
+
+// packages/flare/dist/sdk/server.js
+function declare(kind) {
+  return (options) => Object.freeze({ ...options, kind, auth: options.auth ?? "required" });
+}
+var query = declare("query");
+var mutation = declare("mutation");
+var action = declare("action");
+function defineApp(options) {
+  flatten(options.functions);
+  schemaContract(options.schema);
+  return Object.freeze(options);
+}
+function flatten(tree) {
+  const out = Object.create(null);
+  const ancestors = new Set;
+  function walk(node, prefix, depth) {
+    if (depth > 20 || ancestors.has(node))
+      throw new FlareError("INVALID_CONTRACT", "Invalid function tree");
+    ancestors.add(node);
+    for (const [name, value] of Object.entries(node)) {
+      const path = prefix ? `${prefix}/${name}` : name;
+      assertPath(path);
+      if (value && typeof value === "object" && "handler" in value && typeof value.handler === "function") {
+        const definition = value;
+        if (!["query", "mutation", "action"].includes(definition.kind))
+          throw new FlareError("INVALID_CONTRACT", "Invalid function kind");
+        if (out[path])
+          throw new FlareError("INVALID_CONTRACT", "Duplicate function path");
+        out[path] = definition;
+      } else if (value && typeof value === "object")
+        walk(value, path, depth + 1);
+      else
+        throw new FlareError("INVALID_CONTRACT", "Invalid function definition");
+    }
+    ancestors.delete(node);
+  }
+  walk(tree, "", 0);
+  return out;
+}
+async function validate(validator, value, output = false) {
+  boundedJson(value, output ? LIMITS.outputBytes : LIMITS.inputBytes);
+  const result = await validator["~standard"].validate(value);
+  if (result.issues)
+    throw new FlareError(output ? "INVALID_OUTPUT" : "INVALID_INPUT", output ? "Function returned invalid data" : "Arguments failed validation");
+  boundedJson(result.value, output ? LIMITS.outputBytes : LIMITS.inputBytes);
+  return result.value;
+}
+
+// packages/core/bootstrap/app.ts
+var app_default = defineApp({ schema: {}, functions: {} });
+
+// packages/flare/dist/sdk/cloudflare.js
+import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
+
+// packages/flare/dist/sdk/backup.js
+var SNAPSHOT_BYTES = 4 * 1048576;
+var SNAPSHOT_ROWS = 1e4;
+var reject = (code) => {
+  throw new FlareError(code, code);
+};
+function emptyData(storage, schema) {
+  for (const name of Object.keys(schema))
+    if (storage.sql.exec(`SELECT 1 FROM ${quote(name)} LIMIT 1`).toArray().length)
+      return false;
+  return !storage.sql.exec("SELECT 1 FROM _flared_outbox LIMIT 1").toArray().length;
+}
+function exportData(storage, schema) {
+  if (storage.sql.exec("SELECT 1 FROM _flared_outbox LIMIT 1").toArray().length)
+    reject("BACKUP_BUSY");
+  const snapshot = {
+    format: 1,
+    schema: schemaContract(schema),
+    revision: Number(storage.sql.exec("SELECT value FROM _flared_revision WHERE id=1").one().value),
+    tables: Object.create(null)
+  };
+  let count = 0, bytes = 0;
+  for (const name of Object.keys(schema)) {
+    const docs = [];
+    snapshot.tables[name] = docs;
+    let cursor = "";
+    for (;; ) {
+      const page = storage.sql.exec(`SELECT * FROM ${quote(name)} WHERE _id>? ORDER BY _id LIMIT 100`, cursor).toArray();
+      for (const row of page) {
+        const doc = {
+          _id: String(row._id),
+          _creationTime: Number(row._creationTime),
+          value: JSON.parse(String(row._data))
+        };
+        bytes += new TextEncoder().encode(stableJson(doc)).length;
+        if (++count > SNAPSHOT_ROWS || bytes > SNAPSHOT_BYTES)
+          reject("BACKUP_TOO_LARGE");
+        docs.push(doc);
+      }
+      if (page.length < 100)
+        break;
+      cursor = String(page.at(-1)._id);
+    }
+  }
+  return JSON.parse(boundedJson(snapshot, SNAPSHOT_BYTES));
+}
+async function restoreData(storage, schema, id, snapshot) {
+  boundedJson(snapshot, SNAPSHOT_BYTES);
+  if (!/^[0-9a-f-]{36}$/.test(id) || snapshot?.format !== 1 || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || stableJson(snapshot.schema) !== stableJson(schemaContract(schema)) || !snapshot.tables || Array.isArray(snapshot.tables) || Object.keys(snapshot.tables).sort().join() !== Object.keys(schema).sort().join())
+    reject("INVALID_BACKUP");
+  await storage.transaction(async () => {
+    storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_restore (id TEXT PRIMARY KEY)");
+    if (storage.sql.exec("SELECT id FROM _flared_restore WHERE id=?", id).toArray().length)
+      return;
+    if (!emptyData(storage, schema))
+      reject("RESTORE_NOT_EMPTY");
+    let count = 0;
+    for (const [name, docs] of Object.entries(snapshot.tables)) {
+      if (!Array.isArray(docs))
+        reject("INVALID_BACKUP");
+      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))
+          reject("INVALID_BACKUP");
+        storage.sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, doc._id, doc._creationTime, stableJson(value));
+      }
+    }
+    storage.sql.exec("UPDATE _flared_revision SET value=? WHERE id=1", snapshot.revision);
+    storage.sql.exec("DELETE FROM _flared_changes");
+    for (const name of Object.keys(schema))
+      storage.sql.exec("INSERT INTO _flared_changes VALUES (?,?)", name, snapshot.revision);
+    storage.sql.exec("INSERT INTO _flared_restore VALUES (?)", id);
+  });
+  await storage.sync();
+  return { restored: true, revision: snapshot.revision };
+}
+
+// packages/flare/dist/sdk/database.js
+var scalar = (v) => v === null || typeof v === "string" || typeof v === "boolean" || typeof v === "number" && Number.isFinite(v);
+var bind = (v) => typeof v === "boolean" ? Number(v) : v;
+var checkedId = (id) => {
+  if (typeof id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id))
+    throw new FlareError("INVALID_INPUT", "Invalid document ID");
+};
+var size = (limit) => {
+  if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+    throw new FlareError("INVALID_INPUT", "Page size must be 1..100");
+};
+function database(sql, schema, writable, touched = new Set, changed = new Set) {
+  let active = true;
+  const pending = new Set;
+  let operations = 0;
+  const check = () => {
+    if (!active)
+      throw new FlareError("CAPABILITY_EXPIRED", "Database invocation ended");
+  };
+  const writing = () => {
+    check();
+    if (!writable)
+      throw new FlareError("READ_ONLY", "Queries cannot write");
+  };
+  function table(name) {
+    check();
+    if (!Object.hasOwn(schema, name))
+      throw new FlareError("INVALID_TABLE", "Unknown table");
+    touched.add(name);
+    return schema[name];
+  }
+  const task = (fn, count = true) => {
+    if (count && ++operations > 1000) {
+      const rejected = Promise.reject(new FlareError("LIMIT_EXCEEDED", "Maximum 1000 database operations per invocation"));
+      rejected.catch(() => {
+        return;
+      });
+      pending.add(rejected);
+      return rejected;
+    }
+    const promise = fn();
+    pending.add(promise);
+    promise.then(() => pending.delete(promise), () => {
+      return;
+    });
+    return promise;
+  };
+  const decode = (row) => ({
+    ...JSON.parse(String(row._data)),
+    _id: String(row._id),
+    _creationTime: Number(row._creationTime)
+  });
+  const get = (name, id) => task(async () => {
+    table(name);
+    checkedId(id);
+    const row = sql.exec(`SELECT * FROM ${quote(name)} WHERE _id=?`, id).toArray()[0];
+    return row ? decode(row) : null;
+  });
+  function query(name) {
+    const definition = table(name);
+    function make(index, filters, direction) {
+      const page = (options) => task(async () => {
+        table(name);
+        size(options.limit);
+        const fields = [
+          ...index ? definition.indexes[index] : [],
+          "_creationTime",
+          "_id"
+        ];
+        const expressions = fields.map(fieldSql);
+        const signature = stableJson({ name, index, filters, direction });
+        const where = filters.map((f) => `${fieldSql(f.field)} ${f.operator === "=" ? "IS" : f.operator} ?`);
+        const bindings = filters.map((f) => bind(f.value));
+        if (options.cursor != null) {
+          let token;
+          try {
+            if (options.cursor.length > 8192)
+              throw Error();
+            token = JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(options.cursor), (c) => c.charCodeAt(0))));
+          } catch {
+            throw new FlareError("INVALID_CURSOR", "Invalid cursor");
+          }
+          if (token.signature !== signature || !Array.isArray(token.values) || token.values.length !== fields.length || !token.values.every(scalar))
+            throw new FlareError("INVALID_CURSOR", "Cursor belongs to a different query");
+          const terms = expressions.map((expr, i) => {
+            const prefix = expressions.slice(0, i).map((e) => `${e} IS ?`);
+            bindings.push(...token.values.slice(0, i).map(bind));
+            const value = token.values[i];
+            if (value === null)
+              prefix.push(direction === "asc" ? `${expr} IS NOT NULL` : "0");
+            else {
+              prefix.push(direction === "asc" ? `${expr} > ?` : `(${expr} < ? OR ${expr} IS NULL)`);
+              bindings.push(bind(value));
+            }
+            return "(" + prefix.join(" AND ") + ")";
+          });
+          where.push("(" + terms.join(" OR ") + ")");
+        }
+        const rows = sql.exec(`SELECT *,${expressions.map((e, i) => `${e} AS __k${i}`).join(",")} FROM ${quote(name)} ${where.length ? "WHERE " + where.join(" AND ") : ""} ORDER BY ${expressions.map((e) => `${e} ${direction}`).join(",")} LIMIT ?`, ...bindings, options.limit + 1).toArray();
+        let more = rows.length > options.limit;
+        if (more)
+          rows.pop();
+        const docs = [];
+        let bytes = 2;
+        for (const row of rows) {
+          const doc = decode(row), length = new TextEncoder().encode(JSON.stringify(doc)).length + (docs.length ? 1 : 0);
+          if (bytes + length > 262144) {
+            more = true;
+            break;
+          }
+          docs.push(doc);
+          bytes += length;
+        }
+        const last = rows[docs.length - 1];
+        const continueCursor = more && last ? btoa(String.fromCharCode(...new TextEncoder().encode(boundedJson({
+          signature,
+          values: expressions.map((_, i) => last[`__k${i}`])
+        }, 6144)))) : null;
+        boundedJson(docs, 262144);
+        return { page: docs, continueCursor, isDone: !more };
+      });
+      return Object.freeze({
+        withIndex(next, range) {
+          check();
+          if (index || !Object.hasOwn(definition.indexes, next))
+            throw new FlareError("INVALID_INDEX", "Unknown or duplicate index");
+          const selected = [], fields = definition.indexes[next];
+          let pos = 0, open = true;
+          const bounds = new Set;
+          const add = (operator) => (field, value) => {
+            if (!open)
+              throw new FlareError("CAPABILITY_EXPIRED", "Index range declaration ended");
+            if (!scalar(value) || operator !== "=" && value === null || !fields.includes(field) || field !== fields[pos])
+              throw new FlareError("INVALID_INPUT", "Index range must follow its field order");
+            const bound = operator === "=" ? "equal" : operator.startsWith(">") ? "lower" : "upper";
+            if (bound === "equal" && bounds.size || bounds.has(bound))
+              throw new FlareError("INVALID_INPUT", "Duplicate or mixed index bounds");
+            selected.push({ field, operator, value });
+            if (operator === "=") {
+              pos++;
+              bounds.clear();
+            } else
+              bounds.add(bound);
+            if (selected.length > fields.length + 2)
+              throw new FlareError("INVALID_INPUT", "Index range exceeds limits");
+            return q;
+          };
+          const q = Object.freeze({
+            eq: add("="),
+            gt: add(">"),
+            gte: add(">="),
+            lt: add("<"),
+            lte: add("<=")
+          });
+          try {
+            if (range && range(q) !== q)
+              throw new FlareError("INVALID_INPUT", "Invalid index range");
+          } finally {
+            open = false;
+          }
+          return make(next, Object.freeze([...selected]), direction);
+        },
+        order(next) {
+          check();
+          if (!["asc", "desc"].includes(next))
+            throw new FlareError("INVALID_INPUT", "Invalid order");
+          return make(index, filters, next);
+        },
+        paginate: page,
+        take(limit) {
+          return task(async () => {
+            const result = await page({ limit });
+            if (!result.isDone && result.page.length < limit)
+              throw new FlareError("TOO_LARGE", "Use paginate for large documents");
+            return result.page;
+          }, false);
+        },
+        first() {
+          return task(async () => (await page({ limit: 1 })).page[0] ?? null, false);
+        }
+      });
+    }
+    return make(null, [], "asc");
+  }
+  const read = { get, query };
+  const write = {
+    insert(name, input) {
+      return task(async () => {
+        writing();
+        const definition = table(name), value = await documentValue(definition, input);
+        writing();
+        const id = crypto.randomUUID();
+        sql.exec(`INSERT INTO ${quote(name)} VALUES (?,?,?)`, id, Date.now(), stableJson(value));
+        changed.add(name);
+        return id;
+      });
+    },
+    patch(name, id, patch) {
+      return task(async () => {
+        writing();
+        const definition = table(name);
+        checkedId(id);
+        boundedJson(patch, 65536);
+        if (!patch || Array.isArray(patch) || typeof patch !== "object")
+          throw new FlareError("INVALID_INPUT", "Invalid patch");
+        const row = sql.exec(`SELECT _data FROM ${quote(name)} WHERE _id=?`, id).toArray()[0];
+        if (!row)
+          throw new FlareError("NOT_FOUND", "Document not found");
+        const value = await documentValue(definition, {
+          ...JSON.parse(String(row._data)),
+          ...patch
+        });
+        writing();
+        sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=?`, stableJson(value), id);
+        changed.add(name);
+      });
+    },
+    replace(name, id, input) {
+      return task(async () => {
+        writing();
+        const definition = table(name);
+        checkedId(id);
+        const value = await documentValue(definition, input);
+        writing();
+        const rows = sql.exec(`UPDATE ${quote(name)} SET _data=? WHERE _id=? RETURNING _id`, stableJson(value), id).toArray();
+        if (!rows.length)
+          throw new FlareError("NOT_FOUND", "Document not found");
+        changed.add(name);
+      });
+    },
+    delete(name, id) {
+      return task(async () => {
+        writing();
+        table(name);
+        checkedId(id);
+        if (!sql.exec(`DELETE FROM ${quote(name)} WHERE _id=? RETURNING _id`, id).toArray().length)
+          throw new FlareError("NOT_FOUND", "Document not found");
+        changed.add(name);
+      });
+    }
+  };
+  return {
+    db: Object.freeze(writable ? { ...read, ...write } : read),
+    async finish() {
+      try {
+        while (pending.size) {
+          const settled = await Promise.allSettled([...pending]);
+          const failed = settled.find((result) => result.status === "rejected");
+          if (failed?.status === "rejected")
+            throw failed.reason;
+        }
+      } finally {
+        active = false;
+      }
+    },
+    revoke() {
+      active = false;
+    }
+  };
+}
+
+// packages/flare/dist/sdk/cloudflare.js
+function authorize(mode, auth, internal = false) {
+  if (mode === "internal" && !internal)
+    throw new FlareError("UNAUTHORIZED", "Internal function");
+  if (auth && (!auth.subject || !auth.issuer || !Number.isFinite(auth.expiresAt) || auth.expiresAt <= Date.now()))
+    throw new FlareError("AUTH_EXPIRED", "Authorization expired");
+  if (mode === "required" && !auth)
+    throw new FlareError("UNAUTHORIZED", "Authentication required");
+}
+function createFacet(app) {
+  const functions = flatten(app.functions);
+  const contract = schemaContract(app.schema);
+  return class AppFacet extends DurableObject {
+    tail = Promise.resolve();
+    constructor(ctx, env) {
+      super(ctx, env);
+      ctx.blockConcurrencyWhile(async () => {
+        await applySchema(ctx.storage, app.schema);
+        ctx.storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_revision (id INTEGER PRIMARY KEY CHECK(id=1), value INTEGER NOT NULL)");
+        ctx.storage.sql.exec("INSERT OR IGNORE INTO _flared_revision VALUES (1,0)");
+        ctx.storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_outbox (id TEXT PRIMARY KEY, release TEXT NOT NULL, path TEXT NOT NULL, args TEXT NOT NULL, auth TEXT NOT NULL, dueAt INTEGER NOT NULL,internal INTEGER NOT NULL DEFAULT 0)");
+        ctx.storage.sql.exec("CREATE TABLE IF NOT EXISTS _flared_changes (name TEXT PRIMARY KEY,revision INTEGER NOT NULL)");
+        ctx.storage.sql.exec("CREATE INDEX IF NOT EXISTS outbox_pending ON _flared_outbox(dueAt,id)");
+      });
+    }
+    serial(fn) {
+      const result = this.tail.then(fn);
+      this.tail = result.catch(() => {
+        return;
+      });
+      return result;
+    }
+    revision() {
+      return Number(this.ctx.storage.sql.exec("SELECT value FROM _flared_revision WHERE id=1").one().value);
+    }
+    snapshot() {
+      return this.serial(async () => ({
+        revision: this.revision(),
+        changes: Object.fromEntries(this.ctx.storage.sql.exec("SELECT * FROM _flared_changes").toArray().map((row) => [String(row.name), Number(row.revision)]))
+      }));
+    }
+    async invoke(call) {
+      try {
+        return { ok: true, value: await this.execute(call) };
+      } catch (error) {
+        return {
+          ok: false,
+          code: errorCode(error)
+        };
+      }
+    }
+    async administrative(operation, input) {
+      try {
+        const work = {
+          inspect: () => this.inspect(input),
+          edit: () => this.edit(input),
+          "backup-export": () => this.serial(async () => exportData(this.ctx.storage, app.schema)),
+          "backup-empty": () => this.serial(async () => emptyData(this.ctx.storage, app.schema)),
+          "backup-restore": () => this.serial(() => restoreData(this.ctx.storage, app.schema, input.id, input.snapshot))
+        };
+        if (!Object.hasOwn(work, operation))
+          throw new FlareError("INVALID_OPERATION", "Unknown administrative capability");
+        return { ok: true, value: await work[operation]() };
+      } catch (error) {
+        return {
+          ok: false,
+          code: errorCode(error)
+        };
+      }
+    }
+    execute(call) {
+      return this.serial(async () => {
+        const fn = functions[call.path];
+        if (!fn || fn.kind !== call.kind || call.kind === "action")
+          throw new FlareError("FUNCTION_NOT_FOUND", "Data function not found");
+        authorize(fn.auth, call.auth, call.internal);
+        const args = await validate(fn.input, call.args);
+        if (call.kind === "query") {
+          return this.ctx.storage.transaction(async () => {
+            const tables = new Set;
+            const capability = database(this.ctx.storage.sql, app.schema, false, tables);
+            try {
+              const result = await validate(fn.output, await fn.handler({ db: capability.db, auth: call.auth }, args), true);
+              await capability.finish();
+              return { result, revision: this.revision(), tables: [...tables] };
+            } finally {
+              capability.revoke();
+            }
+          });
+        }
+        let result = null;
+        const changed = new Set;
+        await this.ctx.storage.transaction(async () => {
+          let active = true;
+          const scheduled = [];
+          const jobs = Object.freeze({
+            cancel: (id) => {
+              const pending = (async () => {
+                if (!active)
+                  throw new FlareError("CAPABILITY_EXPIRED", "Mutation invocation ended");
+                if (scheduled.length >= 100)
+                  throw new FlareError("LIMIT_EXCEEDED", "Maximum 100 job operations per mutation");
+                return this.cancelPending(id);
+              })();
+              scheduled.push(pending);
+              pending.catch(() => {
+                return;
+              });
+              return pending;
+            },
+            schedule: (path, jobArgs, options = {}) => {
+              const pending = (async () => {
+                if (!active)
+                  throw new FlareError("CAPABILITY_EXPIRED", "Mutation invocation ended");
+                if (scheduled.length >= 100)
+                  throw new FlareError("LIMIT_EXCEEDED", "Maximum 100 jobs per mutation");
+                const target = functions[path];
+                if (!target || target.kind !== "action")
+                  throw new FlareError("FUNCTION_NOT_FOUND", "Scheduled action not found");
+                const delay = options.delaySeconds ?? 0;
+                if (!Number.isFinite(delay) || delay < 0 || delay > 31536000)
+                  throw new FlareError("INVALID_INPUT", "Invalid job delay");
+                const input = await validate(target.input, jobArgs);
+                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);
+                return id;
+              })();
+              scheduled.push(pending);
+              pending.catch(() => {
+                return;
+              });
+              return pending;
+            }
+          });
+          const capability = database(this.ctx.storage.sql, app.schema, true, new Set, changed);
+          try {
+            result = await validate(fn.output, await fn.handler({ db: capability.db, auth: call.auth, jobs }, args), true);
+            await capability.finish();
+            const settled = await Promise.allSettled(scheduled);
+            const failed = settled.find((result) => result.status === "rejected");
+            if (failed?.status === "rejected")
+              throw failed.reason;
+          } finally {
+            active = false;
+            capability.revoke();
+            await Promise.allSettled(scheduled);
+          }
+          this.commitRevision(changed);
+        });
+        await this.ctx.storage.sync();
+        return { result, revision: this.revision(), tables: [...changed] };
+      });
+    }
+    commitRevision(changed) {
+      this.ctx.storage.sql.exec("UPDATE _flared_revision SET value=value+1 WHERE id=1");
+      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());
+    }
+    pendingJobs(limit = 100) {
+      return this.serial(async () => {
+        if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+          throw new FlareError("INVALID_INPUT", "Invalid outbox page size");
+        return this.ctx.storage.sql.exec("SELECT * FROM _flared_outbox ORDER BY dueAt,id LIMIT ?", limit).toArray().map((row) => ({
+          id: String(row.id),
+          release: String(row.release),
+          path: String(row.path),
+          args: JSON.parse(String(row.args)),
+          auth: JSON.parse(String(row.auth)),
+          dueAt: Number(row.dueAt),
+          internal: Number(row.internal) === 1
+        }));
+      });
+    }
+    cancelPending(id) {
+      if (typeof id !== "string" || !/^[a-z0-9_-]{1,128}$/.test(id))
+        throw new FlareError("INVALID_INPUT", "Invalid job ID");
+      return this.ctx.storage.sql.exec("DELETE FROM _flared_outbox WHERE id=? RETURNING id", id).toArray().length === 1;
+    }
+    cancelJob(id) {
+      return this.serial(async () => {
+        const cancelled = this.cancelPending(id);
+        await this.ctx.storage.sync();
+        return cancelled;
+      });
+    }
+    pendingJobReferences() {
+      return this.serial(async () => {
+        const paths = this.ctx.storage.sql.exec("SELECT DISTINCT path FROM _flared_outbox ORDER BY path LIMIT 201").toArray().map((row) => String(row.path));
+        const releases = this.ctx.storage.sql.exec("SELECT DISTINCT release FROM _flared_outbox ORDER BY release LIMIT 1001").toArray().map((row) => String(row.release));
+        return {
+          paths: paths.slice(0, 200),
+          releases: releases.slice(0, 1000),
+          truncated: paths.length > 200 || releases.length > 1000
+        };
+      });
+    }
+    validateJob(path, args) {
+      return this.serial(async () => {
+        const target = functions[path];
+        if (!target || target.kind !== "action")
+          throw new FlareError("FUNCTION_NOT_FOUND", "Scheduled action not found");
+        await validate(target.input, args);
+      });
+    }
+    enqueueJob(job) {
+      return this.serial(async () => {
+        const target = functions[job.path];
+        if (!target || target.kind !== "action")
+          throw new FlareError("FUNCTION_NOT_FOUND", "Scheduled action not found");
+        const args = await validate(target.input, job.args);
+        this.ctx.storage.sql.exec("INSERT OR IGNORE INTO _flared_outbox (id,release,path,args,auth,dueAt,internal) VALUES (?,?,?,?,?,?,1)", job.id, this.env.RELEASE_ID, job.path, JSON.stringify(args), "null", job.dueAt);
+        await this.ctx.storage.sync();
+      });
+    }
+    markJobsSent(ids) {
+      return this.serial(async () => {
+        if (!Array.isArray(ids) || ids.length > 100 || ids.some((id) => typeof id !== "string" || !/^[a-z0-9_-]{1,128}$/.test(id)))
+          throw new FlareError("INVALID_INPUT", "Invalid outbox IDs");
+        if (ids.length)
+          this.ctx.storage.transactionSync(() => {
+            this.ctx.storage.sql.exec(`DELETE FROM _flared_outbox WHERE id IN (${ids.map(() => "?").join(",")})`, ...ids);
+          });
+        await this.ctx.storage.sync();
+      });
+    }
+    inspect(input = {}) {
+      return this.serial(async () => {
+        if (!input.table)
+          return {
+            revision: this.revision(),
+            tables: Object.entries(contract).map(([name, definition]) => ({
+              name,
+              document: definition.document,
+              indexes: definition.indexes,
+              columns: this.columns(name)
+            }))
+          };
+        const capability = database(this.ctx.storage.sql, app.schema, false);
+        try {
+          const result = await capability.db.query(input.table).paginate({ limit: input.limit ?? 50, cursor: input.cursor });
+          await capability.finish();
+          return {
+            revision: this.revision(),
+            columns: this.columns(input.table),
+            rows: result.page,
+            next: result.continueCursor
+          };
+        } finally {
+          capability.revoke();
+        }
+      });
+    }
+    columns(name) {
+      const definition = contract[name];
+      if (!definition)
+        throw new FlareError("INVALID_TABLE", "Unknown table");
+      return [
+        { name: "_id", type: "TEXT", pk: 1, notnull: 1, dflt_value: null },
+        {
+          name: "_creationTime",
+          type: "REAL",
+          pk: 0,
+          notnull: 1,
+          dflt_value: null,
+          readonly: true
+        },
+        ...Object.entries(definition.document.properties).map(([field, value]) => ({
+          name: field,
+          type: value.type === "boolean" ? "BOOLEAN" : ["integer", "number"].includes(value.type) ? "REAL" : value.type === "string" ? "TEXT" : "JSON",
+          pk: 0,
+          notnull: Number((definition.document.required ?? []).includes(field)),
+          dflt_value: value.default === undefined ? null : JSON.stringify(value.default),
+          schema: value
+        }))
+      ];
+    }
+    edit(input) {
+      return this.serial(async () => {
+        boundedJson(input, LIMITS.inputBytes);
+        let rows = [];
+        const changed = new Set;
+        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);
+          try {
+            if (input.operation === "insert") {
+              const id = await capability.db.insert(input.table, input.values ?? {});
+              rows = [await capability.db.get(input.table, id)];
+            } else if (input.key && input.operation === "update") {
+              await capability.db.patch(input.table, input.key, input.values ?? {});
+              rows = [await capability.db.get(input.table, input.key)];
+            } else if (input.key && input.operation === "delete") {
+              const row = await capability.db.get(input.table, input.key);
+              await capability.db.delete(input.table, input.key);
+              rows = [row];
+            } else
+              throw new FlareError("INVALID_INPUT", "Invalid edit");
+            await capability.finish();
+            boundedJson(rows, LIMITS.outputBytes);
+          } finally {
+            capability.revoke();
+          }
+          this.commitRevision(changed);
+        });
+        await this.ctx.storage.sync();
+        return { rows, revision: this.revision() };
+      });
+    }
+  };
+}
+
+// packages/core/bootstrap/facet-entry.ts
+class AppFacet extends createFacet(app_default) {
+}
+export {
+  AppFacet
+};