@super-line/collections-cloudflare 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+Generated from conventional commits by [git-cliff](https://git-cliff.org) —
+run `pnpm changelog` rather than editing by hand.
+
+## [collections-cloudflare-v0.1.0] — 2026-10-15
+
+### Features
+
+- **collections-cloudflare:** Row collections on Durable Object SQLite ([6b1f3eb])
+
+### Documentation
+
+- Teach hosting a node on Cloudflare Durable Objects ([a893f83])
+
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# @super-line/collections-cloudflare
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[**super-line**](https://super-line.dogar.biz/) [row collections](https://super-line.dogar.biz/collections/row-collections) stored in a Cloudflare **Durable Object's** own SQLite — the object that is the node (see [`@super-line/transport-cloudflare`](https://github.com/mertdogar/super-line/tree/main/packages/transport-cloudflare)). Each collection gets its own typed table, laid out exactly as [`@super-line/collections-sqlite`](https://github.com/mertdogar/super-line/tree/main/packages/collections-sqlite) does, with the same IR→SQL snapshot pushdown, and one `transactionSync` spans every collection, so a cross-collection batch stays atomic.
+
+```bash
+pnpm add @super-line/core @super-line/collections-cloudflare
+```
+
+```ts
+import { createSuperLineServer } from '@super-line/server'
+import { createDurableNode } from '@super-line/transport-cloudflare'
+import { cloudflareCollections } from '@super-line/collections-cloudflare'
+import { contract } from './contract'
+
+export class Node extends createDurableNode((ctx, env, base) =>
+  createSuperLineServer(contract, {
+    ...base,
+    authenticate,
+    policies,
+    collections: cloudflareCollections(ctx.storage, contract.collections),
+  }),
+) {}
+```
+
+`cloudflareCollections(storage, collections)` is synchronous and opens on the first operation, so building it in the object's constructor costs nothing and never throws. It needs the contract's post-merge `collections` map. `clustering: 'relay'`, `coordination: 'local'` — one node, so nothing is relayed.
+
+## Limits
+
+Durable Object SQLite is stricter than a SQLite file:
+
+- **98 typed columns per collection** (the platform allows 100; two are row timestamps). A wider collection fails its own operations with an `INTERNAL` error naming it; the rest keep working.
+- **2 MB per row.** A larger write fails, and the client receives `INTERNAL`.
+- **100 bound values per query.** A snapshot filter needing more than 98 values scans the table and filters in JavaScript — same results, slower on a large table.
+
+## Schema changes on a deployed object
+
+A new optional field is altered in on the first operation. Any other change — a field that changed type, a removed field, a new required field — makes that collection fail its operations with an `INTERNAL` error naming it and the fix, while the rest of the object works. Either rename the collection (a new table; the old rows stay unread), or migrate `col_<name>` and its `col_meta` row with `ctx.storage.sql.exec` in your factory before you create the server.
+
+The backend owns the `col_<name>` and `col_meta` tables in the object's storage.
+
+- 📖 Guide: [Host a node on Cloudflare Durable Objects](https://super-line.dogar.biz/how-to/cloudflare-durable-objects)
+- 📚 Reference: [Backends & clustering](https://super-line.dogar.biz/collections/backends)
+- 🧩 Source: <https://github.com/mertdogar/super-line>
+
+MIT © Mert

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { CollectionDef, RelayCollectionStore } from '@super-line/core';
+
+/**
+ * The Durable Object SQLite RelayCollectionStore: every LWW collection on the contract gets its own typed table
+ * (`col_<name>`) in the object's own storage, exactly as `sqliteCollections` lays it out, and one
+ * `transactionSync` spans all of them, so a cross-collection batch stays atomic.
+ *
+ * Opens lazily, on the first operation, so building it in the object's constructor never throws (a throw there
+ * resets the object). A collection that can't open — its schema drifted non-additively, or it plans more than 98
+ * columns — fails only its own operations, with an `INTERNAL` error that names it and the fix; the rest keep
+ * working. Additive drift (new optional fields) is altered in, as with `sqliteCollections`.
+ *
+ * ```ts
+ * createSuperLineServer(contract, { ...base, collections: cloudflareCollections(ctx.storage, contract.collections) })
+ * ```
+ */
+declare function cloudflareCollections(storage: DurableObjectStorage, collections: Record<string, CollectionDef>): RelayCollectionStore;
+
+export { cloudflareCollections };

package/dist/index.js

@@ -0,0 +1,358 @@
+// src/index.ts
+import { SuperLineError, applyQuery, isCrdtCollection, matchesFilter } from "@super-line/core";
+
+// ../collections-sqlite/src/sql.ts
+import { DEGENERATE_DATA_COLUMN, planColumns } from "@super-line/core";
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var sqlType = (kind) => kind === "text" ? "TEXT" : kind === "real" ? "REAL" : kind === "integer-bool" ? "INTEGER" : "TEXT";
+var norm = (v) => typeof v === "boolean" ? v ? 1 : 0 : v;
+var kindMatches = (kind, v) => kind === "text" && typeof v === "string" || kind === "real" && typeof v === "number" || kind === "integer-bool" && typeof v === "boolean";
+var META_SQL = {
+  create: `CREATE TABLE IF NOT EXISTS col_meta (collection TEXT PRIMARY KEY, fingerprint TEXT NOT NULL)`,
+  get: `SELECT fingerprint FROM col_meta WHERE collection = ?`,
+  insert: `INSERT INTO col_meta (collection, fingerprint) VALUES (?, ?)`,
+  update: `UPDATE col_meta SET fingerprint = ? WHERE collection = ?`
+};
+function defineTable(n, def) {
+  if (!IDENT.test(n) || n.length > 60) throw new Error(`invalid collection name '${n}'`);
+  const plan = planColumns(def);
+  const name = `col_${n}`;
+  const indexes = (def.indexes ?? []).map((fields, index) => {
+    if (fields.length === 0 || fields.some((field) => !plan.columns.some((column) => column.name === field)))
+      throw new Error(`invalid index ${index} on '${n}'`);
+    return `CREATE INDEX IF NOT EXISTS "${name}_idx_${index}" ON "${name}" (${fields.map((field) => `"${field}"`).join(", ")})`;
+  });
+  const colList = plan.columns.map((c) => `"${c.name}"`).join(", ");
+  const setList = [...plan.columns.filter((c) => c.name !== plan.key).map((c) => `"${c.name}" = ?`), `"_sl_updated_at" = ?`].join(", ");
+  return {
+    name,
+    plan,
+    byName: new Map(plan.columns.map((c) => [c.name, c])),
+    create: createTableSql(name, plan),
+    indexes,
+    sql: {
+      get: `SELECT ${colList} FROM "${name}" WHERE "${plan.key}" = ?`,
+      has: `SELECT 1 FROM "${name}" WHERE "${plan.key}" = ?`,
+      insert: `INSERT INTO "${name}" (${colList}, "_sl_created_at", "_sl_updated_at") VALUES (${plan.columns.map(() => "?").join(", ")}, ?, ?)`,
+      update: `UPDATE "${name}" SET ${setList} WHERE "${plan.key}" = ?`,
+      delete: `DELETE FROM "${name}" WHERE "${plan.key}" = ?`
+    }
+  };
+}
+function resolveField(t, field) {
+  if (t.plan.degenerate) return { at: "json", col: DEGENERATE_DATA_COLUMN, path: "$." + field };
+  const dot = field.indexOf(".");
+  const head = dot === -1 ? field : field.slice(0, dot);
+  const col = t.byName.get(head);
+  if (!col) return { at: "absent" };
+  if (col.kind === "json") return { at: "json", col: col.name, path: dot === -1 ? "$" : "$." + field.slice(dot + 1) };
+  return dot === -1 ? { at: "scalar", col } : { at: "absent" };
+}
+var TRUE = { sql: "1=1", params: [], exact: true };
+var FALSE = { sql: "1=0", params: [], exact: true };
+function compileExpr(t, expr) {
+  switch (expr.op) {
+    case "and":
+    case "or": {
+      if (expr.args.length === 0) return expr.op === "and" ? TRUE : FALSE;
+      const parts = [];
+      const params = [];
+      let exact = true;
+      for (const arg of expr.args) {
+        const c = compileExpr(t, arg);
+        if (!c) {
+          if (expr.op === "or") return null;
+          exact = false;
+          continue;
+        }
+        exact &&= c.exact;
+        parts.push(`(${c.sql})`);
+        params.push(...c.params);
+      }
+      if (parts.length === 0) return null;
+      return { sql: parts.join(expr.op === "and" ? " AND " : " OR "), params, exact };
+    }
+    case "not": {
+      const c = compileExpr(t, expr.arg);
+      return c?.exact ? { sql: `NOT (${c.sql})`, params: c.params, exact: true } : null;
+    }
+    case "eq": {
+      const ref = resolveField(t, expr.field);
+      if (ref.at === "absent") return FALSE;
+      if (ref.at === "scalar") {
+        if (expr.value === null) return ref.col.nullable ? { sql: `"${ref.col.name}" IS NULL`, params: [], exact: true } : FALSE;
+        if (!kindMatches(ref.col.kind, expr.value)) return FALSE;
+        return { sql: `"${ref.col.name}" IS ?`, params: [norm(expr.value)], exact: true };
+      }
+      const je = `json_extract("${ref.col}", ?)`;
+      return expr.value === null ? { sql: `${je} IS NULL`, params: [ref.path], exact: false } : { sql: `${je} IS ?`, params: [ref.path, norm(expr.value)], exact: false };
+    }
+    case "neq": {
+      const ref = resolveField(t, expr.field);
+      if (ref.at === "absent") return TRUE;
+      if (ref.at === "scalar") {
+        if (expr.value === null) return ref.col.nullable ? { sql: `"${ref.col.name}" IS NOT NULL`, params: [], exact: true } : TRUE;
+        if (!kindMatches(ref.col.kind, expr.value)) return TRUE;
+        return { sql: `"${ref.col.name}" IS NOT ?`, params: [norm(expr.value)], exact: true };
+      }
+      return null;
+    }
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte": {
+      if (expr.value === null) return FALSE;
+      const op = expr.op === "lt" ? "<" : expr.op === "lte" ? "<=" : expr.op === "gt" ? ">" : ">=";
+      const ref = resolveField(t, expr.field);
+      if (ref.at === "absent") return FALSE;
+      if (ref.at === "scalar") {
+        if (ref.col.kind === "real" && typeof expr.value === "number") {
+          return { sql: `COALESCE("${ref.col.name}" ${op} ?, 0)`, params: [expr.value], exact: true };
+        }
+        if (ref.col.kind === "text" && typeof expr.value === "string") return null;
+        return FALSE;
+      }
+      if (typeof expr.value !== "number") return null;
+      return { sql: `COALESCE(json_extract("${ref.col}", ?) ${op} ?, 0)`, params: [ref.path, expr.value], exact: false };
+    }
+    case "in": {
+      if (expr.values.length === 0) return FALSE;
+      const ref = resolveField(t, expr.field);
+      if (ref.at === "absent") return FALSE;
+      if (ref.at === "scalar") {
+        const usable = expr.values.filter((v) => kindMatches(ref.col.kind, v));
+        const parts = [];
+        const params = [];
+        if (usable.length > 0) {
+          parts.push(`COALESCE("${ref.col.name}" IN (${usable.map(() => "?").join(",")}), 0)`);
+          params.push(...usable.map(norm));
+        }
+        if (expr.values.includes(null) && ref.col.nullable) parts.push(`"${ref.col.name}" IS NULL`);
+        return parts.length === 0 ? FALSE : { sql: parts.join(" OR "), params, exact: true };
+      }
+      if (expr.values.some((v) => v === null)) return null;
+      return {
+        sql: `COALESCE(json_extract("${ref.col}", ?) IN (${expr.values.map(() => "?").join(",")}), 0)`,
+        params: [ref.path, ...expr.values.map(norm)],
+        exact: false
+      };
+    }
+    default:
+      return null;
+  }
+}
+function compileOrder(t, orderBy) {
+  const parts = [];
+  for (const { field, dir } of orderBy) {
+    const ref = resolveField(t, field);
+    if (ref.at !== "scalar" || ref.col.kind !== "real") return null;
+    parts.push(dir === "desc" ? `"${ref.col.name}" DESC NULLS FIRST` : `"${ref.col.name}" ASC NULLS LAST`);
+  }
+  return parts.join(", ");
+}
+function snapshotSql(t, query, maxParams = Infinity) {
+  let sql = `SELECT ${t.plan.columns.map((c) => `"${c.name}"`).join(", ")} FROM "${t.name}"`;
+  const params = [];
+  let where = query.filter ? compileExpr(t, query.filter) : TRUE;
+  if (where && where.params.length + 2 > maxParams) where = null;
+  if (query.filter && where) {
+    sql += ` WHERE ${where.sql}`;
+    params.push(...where.params);
+  }
+  const order = query.orderBy?.length ? compileOrder(t, query.orderBy) : "";
+  if (!where?.exact || order === null) return { sql, params, exact: false };
+  if (order) sql += ` ORDER BY ${order}`;
+  if (query.limit !== void 0 || query.offset !== void 0) {
+    sql += ` LIMIT ? OFFSET ?`;
+    params.push(query.limit ?? -1, query.offset ?? 0);
+  }
+  return { sql, params, exact: true };
+}
+var rowMetaSql = (t, count) => `SELECT "${t.plan.key}" AS id, "_sl_created_at" AS c, "_sl_updated_at" AS u FROM "${t.name}" WHERE "${t.plan.key}" IN (${Array.from({ length: count }, () => "?").join(",")})`;
+var encode = (col, v) => {
+  if (col.kind === "json") return v === void 0 ? null : JSON.stringify(v);
+  if (v === void 0 || v === null) return null;
+  return norm(v);
+};
+function rowParams(t, id, row) {
+  if (t.plan.degenerate) return [id, JSON.stringify(row)];
+  const rec = row;
+  return t.plan.columns.map((c) => c.name === t.plan.key ? id : encode(c, rec[c.name]));
+}
+function updateParams(t, id, row, ts) {
+  return [...rowParams(t, id, row).filter((_, i) => t.plan.columns[i].name !== t.plan.key), ts, id];
+}
+function fromRow(t, dbRow) {
+  if (t.plan.degenerate) return JSON.parse(dbRow[DEGENERATE_DATA_COLUMN]);
+  const row = {};
+  for (const col of t.plan.columns) {
+    const v = dbRow[col.name];
+    if (col.kind === "json") {
+      if (v !== null) row[col.name] = JSON.parse(v);
+      continue;
+    }
+    if (v === null) {
+      if (col.nullable) row[col.name] = null;
+      continue;
+    }
+    row[col.name] = col.kind === "integer-bool" ? v === 1 : v;
+  }
+  return row;
+}
+function createTableSql(name, plan) {
+  const cols = plan.columns.map((c) => {
+    const constraint = c.name === plan.key ? " NOT NULL PRIMARY KEY" : c.optional || c.nullable ? "" : " NOT NULL";
+    return `"${c.name}" ${sqlType(c.kind)}${constraint}`;
+  });
+  return `CREATE TABLE IF NOT EXISTS "${name}" (${cols.join(", ")}, "_sl_created_at" INTEGER NOT NULL, "_sl_updated_at" INTEGER NOT NULL)`;
+}
+var parseFingerprint = (fp) => {
+  const parts = fp.split(";");
+  const cols = /* @__PURE__ */ new Map();
+  for (const p of parts.slice(2)) cols.set(p.slice(0, p.indexOf(":")), p);
+  return { head: parts[0], key: parts[1], cols };
+};
+function driftOf(t, stored) {
+  const old = parseFingerprint(stored);
+  const next = parseFingerprint(t.plan.fingerprint);
+  if (old.head !== next.head || old.key !== next.key) return { refuse: "changed its key or shape non-additively" };
+  for (const [name, entry] of old.cols) {
+    if (next.cols.get(name) !== entry) return { refuse: `changed or removed field '${name}'` };
+  }
+  const alter = [];
+  for (const col of t.plan.columns) {
+    if (old.cols.has(col.name)) continue;
+    if (!col.optional && !col.nullable) return { refuse: `added required field '${col.name}' (existing rows can't be backfilled)` };
+    alter.push(`ALTER TABLE "${t.name}" ADD COLUMN "${col.name}" ${sqlType(col.kind)}`);
+  }
+  return { alter };
+}
+
+// src/index.ts
+var MAX_PARAMS = 100;
+var MAX_COLUMNS = 98;
+function cloudflareCollections(storage, collections) {
+  const sql = storage.sql;
+  const rows = (query, ...params) => Array.from(sql.exec(query, ...params));
+  const openTable = (n, def) => {
+    const t = defineTable(n, def);
+    if (t.plan.columns.length > MAX_COLUMNS)
+      throw new Error(`plans ${t.plan.columns.length} columns; a Durable Object table holds ${MAX_COLUMNS} besides the row timestamps`);
+    sql.exec(t.create);
+    const stored = rows(META_SQL.get, n)[0]?.fingerprint;
+    if (stored === void 0) sql.exec(META_SQL.insert, n, t.plan.fingerprint);
+    else if (stored !== t.plan.fingerprint) {
+      const drift = driftOf(t, stored);
+      if ("refuse" in drift)
+        throw new Error(`schema ${drift.refuse} \u2014 rename the collection, or migrate table "${t.name}" and its col_meta row in code`);
+      for (const alter of drift.alter) sql.exec(alter);
+      sql.exec(META_SQL.update, t.plan.fingerprint, n);
+    }
+    for (const index of t.indexes) sql.exec(index);
+    return t;
+  };
+  let tables;
+  const open = () => {
+    if (tables) return tables;
+    sql.exec(META_SQL.create);
+    tables = /* @__PURE__ */ new Map();
+    for (const [n, def] of Object.entries(collections)) {
+      if (isCrdtCollection(def)) continue;
+      try {
+        tables.set(n, openTable(n, def));
+      } catch (err) {
+        tables.set(n, new SuperLineError("INTERNAL", `cloudflareCollections: collection '${n}' is unusable: ${err.message}`));
+      }
+    }
+    return tables;
+  };
+  const table = (n) => {
+    const t = open().get(n);
+    if (t instanceof SuperLineError) throw t;
+    return t;
+  };
+  const readRow = (t, id) => {
+    const r = rows(t.sql.get, id)[0];
+    return r ? fromRow(t, r) : void 0;
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (changes) => {
+    for (const c of changes) for (const cb of listeners) cb(c);
+  };
+  const applyOps = (ops, origin) => {
+    const changes = [];
+    const ts = Date.now();
+    for (const op of ops) {
+      const t = table(op.n);
+      if (!t) throw new SuperLineError("NOT_FOUND", `Unknown collection: ${op.n}`);
+      if (op.op === "insert") {
+        if (rows(t.sql.has, op.id).length > 0) throw new SuperLineError("CONFLICT", `Row already exists: ${op.n}/${op.id}`);
+        sql.exec(t.sql.insert, ...rowParams(t, op.id, op.row), ts, ts);
+        changes.push({ n: op.n, k: "insert", id: op.id, next: op.row, origin });
+      } else if (op.op === "update") {
+        const prev = readRow(t, op.id);
+        if (prev === void 0) throw new SuperLineError("NOT_FOUND", `No row: ${op.n}/${op.id}`);
+        sql.exec(t.sql.update, ...updateParams(t, op.id, op.row, ts));
+        changes.push({ n: op.n, k: "update", id: op.id, prev, next: op.row, origin });
+      } else {
+        const prev = readRow(t, op.id);
+        if (prev === void 0) continue;
+        sql.exec(t.sql.delete, op.id);
+        changes.push({ n: op.n, k: "delete", id: op.id, prev, origin });
+      }
+    }
+    return changes;
+  };
+  return {
+    clustering: "relay",
+    coordination: "local",
+    apply(ops, origin) {
+      const changes = storage.transactionSync(() => applyOps(ops, origin));
+      emit(changes);
+      return changes;
+    },
+    conditionalApply(conditions, ops, origin) {
+      const changes = storage.transactionSync(() => {
+        for (const condition of conditions) {
+          const t = table(condition.n);
+          const row = t ? readRow(t, condition.id) : void 0;
+          if (row === void 0 || !matchesFilter(condition.filter, row)) return void 0;
+        }
+        return applyOps(ops, origin);
+      });
+      if (!changes) return false;
+      emit(changes);
+      return true;
+    },
+    snapshot(n, query) {
+      const t = table(n);
+      if (!t) return [];
+      const q = snapshotSql(t, query, MAX_PARAMS);
+      const found = rows(q.sql, ...q.params).map((r) => fromRow(t, r));
+      return q.exact ? found : applyQuery(found, query);
+    },
+    read(n, id) {
+      const t = table(n);
+      return t ? readRow(t, id) : void 0;
+    },
+    rowMeta(n, ids) {
+      const out = {};
+      const t = table(n);
+      if (!t) return out;
+      for (let i = 0; i < ids.length; i += MAX_PARAMS) {
+        const chunk = ids.slice(i, i + MAX_PARAMS);
+        for (const r of rows(rowMetaSql(t, chunk.length), ...chunk)) {
+          out[r.id] = { createdAt: r.c, updatedAt: r.u };
+        }
+      }
+      return out;
+    },
+    onChange(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    }
+  };
+}
+export {
+  cloudflareCollections
+};

package/package.json

@@ -1,6 +1,49 @@
 {
   "name": "@super-line/collections-cloudflare",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Durable Object SQLite CollectionStore backend for super-line — typed row collections stored in the object that is the node, with IR→SQL snapshot pushdown.",
+  "license": "MIT",
+  "author": "Mert",
+  "keywords": [
+    "super-line",
+    "collections",
+    "cloudflare",
+    "durable-objects",
+    "sqlite",
+    "rows"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mertdogar/super-line.git",
+    "directory": "packages/collections-cloudflare"
+  },
+  "homepage": "https://mertdogar.github.io/super-line/",
+  "bugs": "https://github.com/mertdogar/super-line/issues",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@super-line/core": ">=0.17.0 <1.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^5.20261013.1",
+    "@super-line/core": "^0.21.0"
+  },
+  "scripts": {
+    "build": "tsup"
+  }
 }