json-fs-query 3.2.0 → 3.3.1

package/browser/jsonFsQuery.js

@@ -3375,11 +3375,18 @@ var jsonFsQuery = (() => {
             }
           }
         }
-        return strings.reduceRight((masked, {
+        const parts = [];
+        let copied = 0;
+        for (const {
           start,
           end,
           value
-        }) => `${masked.slice(0, start)}\0${toHex(value)}\0${masked.slice(end)}`, query);
+        } of strings) {
+          parts.push(query.slice(copied, start), `\0${toHex(value)}\0`);
+          copied = end;
+        }
+        parts.push(query.slice(copied));
+        return parts.join("");
       };
       exports.maskStrings = maskStrings;
       var unmaskStrings = (text, quote = "json") => text.replace(placeholderMatch, (placeholder, hex) => {
@@ -3486,20 +3493,31 @@ var jsonFsQuery = (() => {
       var _parseLiteralValue = require_parseLiteralValue();
       var _maskStrings = require_maskStrings();
       var literal = `(?:${_maskStrings.placeholderSource.replace("(", "(?:")}|${_parseLiteralValue.numberSource}|${_maskStrings.arraySource.replace("(", "(?:")}|null|true|false)`;
-      var valuesMatch = new RegExp(`^([a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*)`, "i");
+      var assignments = `[a-z0-9_-]+\\s*=\\s*${literal}(?:\\s*,\\s*[a-z0-9_-]+\\s*=\\s*${literal})*`;
+      var valuesMatch = new RegExp(`^(${assignments})`, "i");
+      var rowSource = `\\(\\s*(${assignments})\\s*\\)`;
+      var rowsMatch = new RegExp(`^${rowSource}(?:\\s*,\\s*${rowSource.replace("(" + assignments, "(?:" + assignments)})*`, "i");
+      var rowMatch = new RegExp(rowSource, "ig");
       var assignmentMatch = new RegExp(`([a-z0-9_-]+)\\s*=\\s*(${_maskStrings.placeholderSource}|(${_parseLiteralValue.numberSource})|${_maskStrings.arraySource}|(null)|(true)|(false))`, "ig");
+      var parseRow = (assignments2) => {
+        const row = {};
+        for (const assignment of assignments2.matchAll(assignmentMatch)) {
+          row[assignment[1]] = (0, _parseLiteralValue.parseLiteralValue)(assignment, 3);
+        }
+        return row;
+      };
       var findInsertValues = (parsed, body) => {
-        const clauseFound = body.match(valuesMatch);
         parsed["insertValues"] = [];
+        const rowsFound = body.match(rowsMatch);
+        if (rowsFound) {
+          parsed["insertValues"] = [...rowsFound[0].matchAll(rowMatch)].map((row) => parseRow(row[1]));
+          return body.slice(rowsFound[0].length).trim();
+        }
+        const clauseFound = body.match(valuesMatch);
         if (!clauseFound) {
           return body;
         }
-        const row = {};
-        const assignmentsFound = clauseFound[1].matchAll(assignmentMatch);
-        for (const assignment of assignmentsFound) {
-          row[assignment[1]] = (0, _parseLiteralValue.parseLiteralValue)(assignment, 3);
-        }
-        parsed["insertValues"] = [row];
+        parsed["insertValues"] = [parseRow(clauseFound[1])];
         return body.slice(clauseFound[0].length).trim();
       };
       exports.findInsertValues = findInsertValues;
@@ -5022,7 +5040,7 @@ var jsonFsQuery = (() => {
         value: true
       });
       exports.startsQueryMatch = void 0;
-      var startsQueryMatch = exports.startsQueryMatch = /^\s*(create|delete|describe|drop|insert|read|show|update)(?![a-z0-9_-])/i;
+      var startsQueryMatch = exports.startsQueryMatch = /^\s*(alter|create|delete|describe|drop|insert|read|show|update|use)(?![a-z0-9_-])/i;
     }
   });
 
@@ -5034,7 +5052,7 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.parseCreate = exports.createMatch = void 0;
+      exports.parseField = exports.parseCreate = exports.nameSource = exports.nameMatch = exports.keyLookup = exports.fieldMatch = exports.createMatch = void 0;
       require_es_array_includes();
       require_esnext_iterator_constructor();
       require_esnext_iterator_filter();
@@ -5063,10 +5081,10 @@ var jsonFsQuery = (() => {
       var _startsQuery = require_startsQuery();
       var createMatch = exports.createMatch = /^\s*create(?![a-z0-9_-])/i;
       var headMatch = /^\s*create\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)\s*\(/i;
-      var nameSource = "[a-z0-9_-]+";
-      var nameMatch = new RegExp(`^${nameSource}$`, "i");
+      var nameSource = exports.nameSource = "[a-z0-9_-]+";
+      var nameMatch = exports.nameMatch = new RegExp(`^${nameSource}$`, "i");
       var numberMatch = new RegExp(`^${_parseLiteralValue.numberSource}$`, "i");
-      var fieldMatch = new RegExp(`^(${nameSource})\\s+(${nameSource})((?:\\s[\\s\\S]*)?)$`, "i");
+      var fieldMatch = exports.fieldMatch = new RegExp(`^(${nameSource})\\s+(${nameSource})((?:\\s[\\s\\S]*)?)$`, "i");
       var primaryMatch = /^primary\s+key\s*\(([^()]*)\)$/i;
       var uniqueMatch = /^unique\s*\(([^()]*)\)$/i;
       var indexMatch = /^index\s*\(([^()]*)\)$/i;
@@ -5079,6 +5097,8 @@ var jsonFsQuery = (() => {
         index: "index",
         foreign: "fk"
       };
+      var keyLookup = (type, fields) => `${lookupPrefix[type]}_${fields.join("_")}.json`;
+      exports.keyLookup = keyLookup;
       var shown = (text) => (0, _maskStrings.unmaskStrings)(text.trim(), "'");
       var findClose = (text, open) => {
         let depth = 0;
@@ -5197,6 +5217,7 @@ var jsonFsQuery = (() => {
         }
         return field;
       };
+      exports.parseField = parseField;
       var parseKey = (item) => {
         let found = item.match(primaryMatch);
         if (found) {
@@ -5248,7 +5269,7 @@ var jsonFsQuery = (() => {
           if (missing) {
             throw new Error(`The ${key.type} key (${key.fields.join(", ")}) names "${missing}", which is not a field`);
           }
-          const lookup = `${lookupPrefix[key.type]}_${key.fields.join("_")}.json`;
+          const lookup = keyLookup(key.type, key.fields);
           if (lookups.has(lookup)) {
             throw new Error(`The same ${key.type} key on "${key.fields.join(", ")}" is given twice`);
           }
@@ -5394,6 +5415,162 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/utilities/parsers/parseAlter.js
+  var require_parseAlter = __commonJS({
+    "dist/data/utilities/parsers/parseAlter.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.parseAlter = exports.alterMatch = void 0;
+      var _parseCreate = require_parseCreate();
+      var _maskStrings = require_maskStrings();
+      var _startsQuery = require_startsQuery();
+      var alterMatch = exports.alterMatch = /^\s*alter(?![a-z0-9_-])/i;
+      var headMatch = new RegExp(`^\\s*alter\\s+(${_parseCreate.nameSource})\\s+(add|drop|rename|modify)(?![a-z0-9_-])([\\s\\S]*)$`, "i");
+      var renameMatch = new RegExp(`^\\s*(${_parseCreate.nameSource})\\s+to\\s+(${_parseCreate.nameSource})\\s*$`, "i");
+      var expected = "Expected: alter <record> add <field> <type> ..., drop <field>, rename <field> to <name>, or modify <field> <type> ...";
+      var shown = (text) => (0, _maskStrings.unmaskStrings)(text.trim(), "'");
+      var fieldSpec = (text) => {
+        const found = text.trim().match(_parseCreate.fieldMatch);
+        if (!found) {
+          throw new Error(`Expected a field (<name> <type> ...) in: ${shown(text)}`);
+        }
+        return (0, _parseCreate.parseField)(found);
+      };
+      var parseAlter = (query) => {
+        const head = query.match(headMatch);
+        if (!head) {
+          throw new Error(expected);
+        }
+        const [, entity, actionWord, rest] = head;
+        if (entity === "__RECORDS") {
+          throw new Error("__RECORDS is reserved for the list of records");
+        }
+        const action = actionWord.toLowerCase();
+        if (_startsQuery.startsQueryMatch.test(rest.trim()) && !/^\s*(add|drop|rename|modify)\b/i.test(rest)) {
+          throw new Error(`Missing ; before: ${shown(rest)}`);
+        }
+        switch (action) {
+          case "add":
+          case "modify":
+            return {
+              entity,
+              alter: {
+                action,
+                field: fieldSpec(rest)
+              }
+            };
+          case "drop": {
+            const name = rest.trim();
+            if (!_parseCreate.nameMatch.test(name)) {
+              throw new Error(`Expected: alter ${entity} drop <field>${name ? ` (got: ${shown(name)})` : ""}`);
+            }
+            return {
+              entity,
+              alter: {
+                action,
+                name
+              }
+            };
+          }
+          default: {
+            const found = rest.match(renameMatch);
+            if (!found) {
+              throw new Error(`Expected: alter ${entity} rename <field> to <name>${rest.trim() ? ` (got: ${shown(rest)})` : ""}`);
+            }
+            return {
+              entity,
+              alter: {
+                action: "rename",
+                name: found[1],
+                to: found[2]
+              }
+            };
+          }
+        }
+      };
+      exports.parseAlter = parseAlter;
+    }
+  });
+
+  // dist/data/utilities/parsers/parseDatabaseStatement.js
+  var require_parseDatabaseStatement = __commonJS({
+    "dist/data/utilities/parsers/parseDatabaseStatement.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.parseDatabaseStatement = exports.databaseStatementMatch = void 0;
+      var _maskStrings = require_maskStrings();
+      var _startsQuery = require_startsQuery();
+      var databaseStatementMatch = exports.databaseStatementMatch = /^\s*(?:(?:create|drop)\s+database\s+(?!\()[a-z0-9_-]|show\s+databases(?![a-z0-9_-])|use(?![a-z0-9_.-]))/i;
+      var createMatch = /^\s*create\s+database\s+(if\s+not\s+exists\s+)?([a-z0-9_-]+)/i;
+      var dropMatch = /^\s*drop\s+database\s+(if\s+exists\s+)?([a-z0-9_-]+)/i;
+      var useMatch = /^\s*use\s+([a-z0-9_-]+)/i;
+      var showMatch = /^\s*show\s+databases/i;
+      var assertNothingAfter = (rest) => {
+        const after = rest.trim();
+        if (!after) {
+          return;
+        }
+        const shown = (0, _maskStrings.unmaskStrings)(after, "'");
+        if (_startsQuery.startsQueryMatch.test(after)) {
+          throw new Error(`Missing ; before: ${shown}`);
+        }
+        throw new Error(`Unrecognized query value: ${shown}`);
+      };
+      var parseDatabaseStatement = (query) => {
+        const statement = {
+          ifExists: false,
+          ifNotExists: false
+        };
+        let found = query.match(createMatch);
+        if (found) {
+          assertNothingAfter(query.slice(found[0].length));
+          return {
+            ...statement,
+            command: "create database",
+            entity: found[2],
+            ifNotExists: Boolean(found[1])
+          };
+        }
+        found = query.match(dropMatch);
+        if (found) {
+          assertNothingAfter(query.slice(found[0].length));
+          return {
+            ...statement,
+            command: "drop database",
+            entity: found[2],
+            ifExists: Boolean(found[1])
+          };
+        }
+        found = query.match(showMatch);
+        if (found) {
+          assertNothingAfter(query.slice(found[0].length));
+          return {
+            ...statement,
+            command: "show databases",
+            entity: "__DATABASES"
+          };
+        }
+        found = query.match(useMatch);
+        if (!found) {
+          throw new Error("Expected: use <database>");
+        }
+        assertNothingAfter(query.slice(found[0].length));
+        return {
+          ...statement,
+          command: "use",
+          entity: found[1]
+        };
+      };
+      exports.parseDatabaseStatement = parseDatabaseStatement;
+    }
+  });
+
   // dist/data/utilities/parsers/parseQuery.js
   var require_parseQuery = __commonJS({
     "dist/data/utilities/parsers/parseQuery.js"(exports) {
@@ -5419,6 +5596,8 @@ var jsonFsQuery = (() => {
       var _maskStrings = require_maskStrings();
       var _parseCreate = require_parseCreate();
       var _parseSchemaStatement = require_parseSchemaStatement();
+      var _parseAlter = require_parseAlter();
+      var _parseDatabaseStatement = require_parseDatabaseStatement();
       var _splitClauses = require_splitClauses();
       var _startsQuery = require_startsQuery();
       var clauseSteps = {
@@ -5489,6 +5668,9 @@ var jsonFsQuery = (() => {
           ifExists: void 0
         };
         query = (0, _maskStrings.maskArrays)((0, _maskStrings.maskStrings)(query));
+        if (_parseDatabaseStatement.databaseStatementMatch.test(query)) {
+          return Object.assign(parsedQuery, (0, _parseDatabaseStatement.parseDatabaseStatement)(query));
+        }
         if (_parseCreate.createMatch.test(query)) {
           const {
             entity,
@@ -5503,6 +5685,17 @@ var jsonFsQuery = (() => {
         if (_parseSchemaStatement.schemaStatementMatch.test(query)) {
           return Object.assign(parsedQuery, (0, _parseSchemaStatement.parseSchemaStatement)(query));
         }
+        if (_parseAlter.alterMatch.test(query)) {
+          const {
+            entity,
+            alter
+          } = (0, _parseAlter.parseAlter)(query);
+          return Object.assign(parsedQuery, {
+            command: "alter",
+            entity,
+            alter
+          });
+        }
         const split = (0, _splitClauses.splitClauses)(query);
         if (!split) {
           query = query.trim();
@@ -5532,6 +5725,9 @@ var jsonFsQuery = (() => {
             throw leftoverError(rest, `${keyword} ${body.slice(0, body.length - rest.length).trim()}`);
           }
         }
+        if ((parsedQuery.joinClauses || []).length && !parsedQuery.joinEntity) {
+          throw new Error(`"on" needs the record to join, after the one read: ${parsedQuery.command} ${parsedQuery.entity}.<record> on ...`);
+        }
         return parsedQuery;
       };
       exports.parseQuery = parseQuery;
@@ -6086,16 +6282,39 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.trackDatabaseCall = exports.resolveDatabasePath = exports.getSetting = exports.configure = void 0;
+      exports.trackDatabaseCall = exports.switchDatabase = exports.resolveDatabasePath = exports.lockPath = exports.getSetting = exports.databasesFolder = exports.configure = exports.activeDatabasePath = void 0;
+      require_es_json_stringify();
       var defaults = {
         databasePath: "database/",
         relativePath: "",
-        enforceForeignKeys: true
+        enforceForeignKeys: true,
+        readConcurrency: 16,
+        format: "compact"
       };
       var settings = {
         ...defaults
       };
       var activeCalls = 0;
+      var databaseNameMatch = /^[a-z0-9_-]+$/i;
+      var withSlash = (path) => path.endsWith("/") ? path : `${path}/`;
+      var activeDatabasePath = () => settings.databasesPath && settings.database ? `${withSlash(settings.databasesPath)}${settings.database}/` : getSetting("databasePath", "database/");
+      exports.activeDatabasePath = activeDatabasePath;
+      var lockPath = () => settings.databasesPath ? withSlash(settings.databasesPath) : activeDatabasePath();
+      exports.lockPath = lockPath;
+      var databasesFolder = () => {
+        if (!settings.databasesPath) {
+          throw new Error("Several databases need a folder to hold them: configure({ databasesPath: 'databases/' }) first");
+        }
+        return withSlash(settings.databasesPath);
+      };
+      exports.databasesFolder = databasesFolder;
+      var switchDatabase = (name) => {
+        settings = {
+          ...settings,
+          database: name
+        };
+      };
+      exports.switchDatabase = switchDatabase;
       var resolveDatabasePath = (databasePath) => require_path_browserify().resolve(databasePath);
       exports.resolveDatabasePath = resolveDatabasePath;
       var trackDatabaseCall = () => {
@@ -6110,13 +6329,34 @@ var jsonFsQuery = (() => {
       };
       exports.trackDatabaseCall = trackDatabaseCall;
       var configure = (newSettings) => {
-        if (activeCalls > 0 && typeof newSettings.databasePath !== "undefined" && resolveDatabasePath(newSettings.databasePath) !== resolveDatabasePath(settings.databasePath)) {
-          throw new Error(`Can't change databasePath while ${activeCalls} database call(s) are still running or queued: await them first`);
+        if (typeof newSettings.format !== "undefined" && newSettings.format !== "compact" && newSettings.format !== "pretty") {
+          throw new Error(`Unknown format "${newSettings.format}": use 'compact' or 'pretty'`);
         }
-        settings = {
+        if (typeof newSettings.database !== "undefined" && newSettings.database !== null && !databaseNameMatch.test(newSettings.database)) {
+          throw new Error(`Invalid database name ${JSON.stringify(newSettings.database)}: names use letters, digits, _ and - only`);
+        }
+        const next = {
           ...settings,
           ...newSettings
         };
+        if (next.database && !next.databasesPath) {
+          throw new Error("A database name needs the folder that holds the databases: configure({ databasesPath: 'databases/', database: '...' })");
+        }
+        if (activeCalls > 0) {
+          const before = {
+            active: resolveDatabasePath(activeDatabasePath()),
+            lock: resolveDatabasePath(lockPath())
+          };
+          const previous = settings;
+          settings = next;
+          const changed = resolveDatabasePath(activeDatabasePath()) !== before.active || resolveDatabasePath(lockPath()) !== before.lock;
+          settings = previous;
+          if (changed) {
+            const named = ["databasePath", "databasesPath", "database"].filter((key) => typeof newSettings[key] !== "undefined").join(" / ");
+            throw new Error(`Can't change ${named} while ${activeCalls} database call(s) are still running or queued: await them first`);
+          }
+        }
+        settings = next;
       };
       exports.configure = configure;
       var getSetting = (key, defaultValue) => {
@@ -6152,7 +6392,7 @@ var jsonFsQuery = (() => {
       }
       var storagePath = (path = "") => {
         const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)("relativePath", "") : "";
-        return `${relativePath}${(0, _config.getSetting)("databasePath", "database/")}${path}`;
+        return `${relativePath}${(0, _config.activeDatabasePath)()}${path}`;
       };
       exports.storagePath = storagePath;
     }
@@ -6644,6 +6884,248 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/storage/writeSet.js
+  var require_writeSet = __commonJS({
+    "dist/data/storage/writeSet.js"(exports) {
+      "use strict";
+      init_process();
+      require_esnext_weak_map_delete_all();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.writeAtomically = exports.withWriteSet = exports.stageWrite = exports.stageRemoveDirectory = exports.stageRemove = exports.stageMakeDirectory = exports.pendingListing = exports.pendingFile = exports.pendingExists = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      require_esnext_map_delete_all();
+      require_esnext_map_every();
+      require_esnext_map_filter();
+      require_esnext_map_find();
+      require_esnext_map_find_key();
+      require_esnext_map_includes();
+      require_esnext_map_key_of();
+      require_esnext_map_map_keys();
+      require_esnext_map_map_values();
+      require_esnext_map_merge();
+      require_esnext_map_reduce();
+      require_esnext_map_some();
+      require_esnext_map_update();
+      require_esnext_set_add_all();
+      require_esnext_set_delete_all();
+      require_esnext_set_difference();
+      require_esnext_set_every();
+      require_esnext_set_filter();
+      require_esnext_set_find();
+      require_esnext_set_intersection();
+      require_esnext_set_is_disjoint_from();
+      require_esnext_set_is_subset_of();
+      require_esnext_set_is_superset_of();
+      require_esnext_set_join();
+      require_esnext_set_map();
+      require_esnext_set_reduce();
+      require_esnext_set_some();
+      require_esnext_set_symmetric_difference();
+      require_esnext_set_union();
+      var jsEnv = _interopRequireWildcard(require_dist());
+      var _storagePath = require_storagePath();
+      var _nodeFiles = require_nodeFiles();
+      var _readCache = require_readCache();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
+        }
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var writeSets = /* @__PURE__ */ new Map();
+      var currentWriteSet = () => writeSets.get((0, _storagePath.storagePath)());
+      var folderPrefix = (location) => location.endsWith("/") ? location : `${location}/`;
+      var insideAny = (location, folders) => {
+        for (const folder of folders) {
+          if (location === folder || location.startsWith(folderPrefix(folder))) {
+            return true;
+          }
+        }
+        return false;
+      };
+      var writeAtomically = async (location, text) => {
+        const temporary = `${location}.${crypto.randomUUID()}.tmp`;
+        const files = (0, _nodeFiles.nodeFiles)();
+        try {
+          await files.writeFile(temporary, text);
+          await files.rename(temporary, location);
+        } catch (error) {
+          await files.rm(temporary, {
+            force: true
+          }).catch(() => void 0);
+          throw error;
+        }
+      };
+      exports.writeAtomically = writeAtomically;
+      var removeFolder = async (location) => {
+        (0, _readCache.cacheRemove)(location, true);
+        await (0, _nodeFiles.nodeFiles)().rm(location, {
+          recursive: true,
+          force: true
+        });
+        (0, _readCache.cacheRemove)(location, true);
+      };
+      var commit = async (writeSet) => {
+        const files = (0, _nodeFiles.nodeFiles)();
+        const writtenInto = (folder) => {
+          const prefix = folderPrefix(folder);
+          return [...writeSet.madeFolders].some((made) => made === folder || made.startsWith(prefix)) || [...writeSet.files].some(([location, text]) => text !== null && location.startsWith(prefix));
+        };
+        const removedFolders = [...writeSet.removedFolders];
+        for (const folder of removedFolders.filter(writtenInto)) {
+          await removeFolder(folder);
+        }
+        for (const folder of writeSet.madeFolders) {
+          await files.mkdir(folder, {
+            recursive: true
+          });
+        }
+        for (const [location, text] of writeSet.files) {
+          if (text !== null) {
+            await writeAtomically(location, text);
+            (0, _readCache.cacheWrite)(location, text);
+          }
+        }
+        for (const [location, text] of writeSet.files) {
+          if (text === null) {
+            (0, _readCache.cacheRemove)(location);
+            await files.rm(location, {
+              force: true
+            });
+            (0, _readCache.cacheRemove)(location);
+          }
+        }
+        for (const folder of removedFolders.filter((folder2) => !writtenInto(folder2))) {
+          await removeFolder(folder);
+        }
+      };
+      var withWriteSet = async (task) => {
+        const database = (0, _storagePath.storagePath)();
+        if (!jsEnv.isNode || writeSets.has(database)) {
+          return task();
+        }
+        const writeSet = {
+          files: /* @__PURE__ */ new Map(),
+          madeFolders: /* @__PURE__ */ new Set(),
+          removedFolders: /* @__PURE__ */ new Set()
+        };
+        writeSets.set(database, writeSet);
+        let result;
+        try {
+          result = await task();
+        } finally {
+          writeSets.delete(database);
+        }
+        await commit(writeSet);
+        return result;
+      };
+      exports.withWriteSet = withWriteSet;
+      var pendingFile = (location) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return void 0;
+        }
+        if (writeSet.files.has(location)) {
+          return writeSet.files.get(location);
+        }
+        return insideAny(location, writeSet.removedFolders) ? null : void 0;
+      };
+      exports.pendingFile = pendingFile;
+      var pendingExists = (location) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return void 0;
+        }
+        if (writeSet.files.has(location)) {
+          return writeSet.files.get(location) !== null;
+        }
+        const prefix = folderPrefix(location);
+        const madeInside = (path) => path === location || path.startsWith(prefix);
+        if ([...writeSet.madeFolders].some(madeInside) || [...writeSet.files].some(([path, text]) => text !== null && path.startsWith(prefix))) {
+          return true;
+        }
+        return insideAny(location, writeSet.removedFolders) ? false : void 0;
+      };
+      exports.pendingExists = pendingExists;
+      var pendingListing = (folder, onDisk) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return onDisk;
+        }
+        const prefix = folderPrefix(folder);
+        const listed = new Set(onDisk.filter((location) => !insideAny(location, writeSet.removedFolders)));
+        for (const [location, text] of writeSet.files) {
+          if (location.startsWith(prefix)) {
+            if (text === null) {
+              listed.delete(location);
+            } else {
+              listed.add(location);
+            }
+          }
+        }
+        return [...listed];
+      };
+      exports.pendingListing = pendingListing;
+      var stageWrite = (location, text) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return false;
+        }
+        writeSet.files.delete(location);
+        writeSet.files.set(location, text);
+        return true;
+      };
+      exports.stageWrite = stageWrite;
+      var stageRemove = (location) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return false;
+        }
+        writeSet.files.delete(location);
+        writeSet.files.set(location, null);
+        return true;
+      };
+      exports.stageRemove = stageRemove;
+      var stageMakeDirectory = (location) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return false;
+        }
+        writeSet.madeFolders.add(location);
+        return true;
+      };
+      exports.stageMakeDirectory = stageMakeDirectory;
+      var stageRemoveDirectory = (location) => {
+        const writeSet = currentWriteSet();
+        if (!writeSet) {
+          return false;
+        }
+        for (const file of [...writeSet.files.keys()]) {
+          if (insideAny(file, /* @__PURE__ */ new Set([location]))) {
+            writeSet.files.delete(file);
+          }
+        }
+        for (const folder of [...writeSet.madeFolders]) {
+          if (insideAny(folder, /* @__PURE__ */ new Set([location]))) {
+            writeSet.madeFolders.delete(folder);
+          }
+        }
+        writeSet.removedFolders.add(location);
+        return true;
+      };
+      exports.stageRemoveDirectory = stageRemoveDirectory;
+    }
+  });
+
   // dist/data/storage/readJson.js
   var require_readJson = __commonJS({
     "dist/data/storage/readJson.js"(exports) {
@@ -6653,11 +7135,12 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.readJson = void 0;
+      exports.readText = exports.readJson = void 0;
       var jsEnv = _interopRequireWildcard(require_dist());
       var _storagePath = require_storagePath();
       var _nodeFiles = require_nodeFiles();
       var _readCache = require_readCache();
+      var _writeSet = require_writeSet();
       var e;
       function _interopRequireWildcard(t, r) {
         if (!r && t && t.__esModule) return t;
@@ -6670,11 +7153,16 @@ var jsonFsQuery = (() => {
         for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
         return f;
       }
-      var readJson = async (path) => {
+      var readText = async (path) => {
         const location = (0, _storagePath.storagePath)(path);
-        const text = await (0, _readCache.cachedRead)(location, () => jsEnv.isNode ? (0, _nodeFiles.nodeFiles)().readFile(location, "utf8") : fetch(location).then((response) => response.text()));
-        return JSON.parse(text);
+        const pending = (0, _writeSet.pendingFile)(location);
+        if (pending === null) {
+          throw new Error(`ENOENT: no such file or directory, open '${location}' (deleted by this statement)`);
+        }
+        return typeof pending === "string" ? pending : (0, _readCache.cachedRead)(location, () => jsEnv.isNode ? (0, _nodeFiles.nodeFiles)().readFile(location, "utf8") : fetch(location).then((response) => response.text()));
       };
+      exports.readText = readText;
+      var readJson = async (path) => JSON.parse(await readText(path));
       exports.readJson = readJson;
     }
   });
@@ -6687,15 +7175,21 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.writeJson = void 0;
+      exports.writeJson = exports.jsonText = void 0;
       require_es_json_stringify();
       var _storagePath = require_storagePath();
-      var _nodeFiles = require_nodeFiles();
       var _readCache = require_readCache();
-      var writeJson = async (path, content) => {
+      var _writeSet = require_writeSet();
+      var _config = require_config();
+      var jsonText = (content, format = (0, _config.getSetting)("format", "compact")) => format === "pretty" ? JSON.stringify(content, null, 2) : JSON.stringify(content);
+      exports.jsonText = jsonText;
+      var writeJson = async (path, content, format) => {
         const location = (0, _storagePath.storagePath)(path);
-        const text = JSON.stringify(content, null, 2);
-        await (0, _nodeFiles.nodeFiles)().writeFile(location, text);
+        const text = jsonText(content, format);
+        if ((0, _writeSet.stageWrite)(location, text)) {
+          return;
+        }
+        await (0, _writeSet.writeAtomically)(location, text);
         (0, _readCache.cacheWrite)(location, text);
       };
       exports.writeJson = writeJson;
@@ -6713,8 +7207,13 @@ var jsonFsQuery = (() => {
       exports.makeDirectory = void 0;
       var _storagePath = require_storagePath();
       var _nodeFiles = require_nodeFiles();
+      var _writeSet = require_writeSet();
       var makeDirectory = async (path = "") => {
-        await (0, _nodeFiles.nodeFiles)().mkdir((0, _storagePath.storagePath)(path), {
+        const location = (0, _storagePath.storagePath)(path);
+        if ((0, _writeSet.stageMakeDirectory)(location)) {
+          return;
+        }
+        await (0, _nodeFiles.nodeFiles)().mkdir(location, {
           recursive: true
         });
       };
@@ -6722,6 +7221,14 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // js-build-tools-empty:fs
+  var require_fs = __commonJS({
+    "js-build-tools-empty:fs"(exports, module) {
+      init_process();
+      module.exports = {};
+    }
+  });
+
   // dist/data/storage/removeFile.js
   var require_removeFile = __commonJS({
     "dist/data/storage/removeFile.js"(exports) {
@@ -6734,8 +7241,16 @@ var jsonFsQuery = (() => {
       var _storagePath = require_storagePath();
       var _nodeFiles = require_nodeFiles();
       var _readCache = require_readCache();
+      var _writeSet = require_writeSet();
       var removeFile = async (path) => {
         const location = (0, _storagePath.storagePath)(path);
+        const pending = (0, _writeSet.pendingFile)(location);
+        if (pending === null || pending === void 0 && !require_fs().existsSync(location)) {
+          throw new Error(`ENOENT: no such file or directory, rm '${location}'`);
+        }
+        if ((0, _writeSet.stageRemove)(location)) {
+          return;
+        }
         (0, _readCache.cacheRemove)(location);
         await (0, _nodeFiles.nodeFiles)().rm(location);
         (0, _readCache.cacheRemove)(location);
@@ -6756,8 +7271,12 @@ var jsonFsQuery = (() => {
       var _storagePath = require_storagePath();
       var _nodeFiles = require_nodeFiles();
       var _readCache = require_readCache();
+      var _writeSet = require_writeSet();
       var removeDirectory = async (path) => {
         const location = (0, _storagePath.storagePath)(path);
+        if ((0, _writeSet.stageRemoveDirectory)(location)) {
+          return;
+        }
         (0, _readCache.cacheRemove)(location, true);
         await (0, _nodeFiles.nodeFiles)().rm(location, {
           recursive: true,
@@ -6769,14 +7288,6 @@ var jsonFsQuery = (() => {
     }
   });
 
-  // js-build-tools-empty:fs
-  var require_fs = __commonJS({
-    "js-build-tools-empty:fs"(exports, module) {
-      init_process();
-      module.exports = {};
-    }
-  });
-
   // dist/data/storage/fileExists.js
   var require_fileExists = __commonJS({
     "dist/data/storage/fileExists.js"(exports) {
@@ -6787,16 +7298,151 @@ var jsonFsQuery = (() => {
       });
       exports.fileExists = void 0;
       var _storagePath = require_storagePath();
+      var _writeSet = require_writeSet();
       var fileExists = (path) => {
+        const location = (0, _storagePath.storagePath)(path);
+        const pending = (0, _writeSet.pendingExists)(location);
+        if (pending !== void 0) {
+          return pending;
+        }
         const {
           existsSync
         } = require_fs();
-        return existsSync((0, _storagePath.storagePath)(path));
+        return existsSync(location);
       };
       exports.fileExists = fileExists;
     }
   });
 
+  // dist/data/storage/listFiles.js
+  var require_listFiles = __commonJS({
+    "dist/data/storage/listFiles.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.listFiles = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_map();
+      var _storagePath = require_storagePath();
+      var _nodeFiles = require_nodeFiles();
+      var _writeSet = require_writeSet();
+      var walk = async (base) => {
+        let entries;
+        try {
+          entries = await (0, _nodeFiles.nodeFiles)().readdir((0, _storagePath.storagePath)(base), {
+            withFileTypes: true
+          });
+        } catch (error) {
+          if (error?.code === "ENOENT") {
+            return [];
+          }
+          throw error;
+        }
+        const paths = [];
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            paths.push(...await walk(`${base}${entry.name}/`));
+          } else if (entry.isFile()) {
+            paths.push(`${base}${entry.name}`);
+          }
+        }
+        return paths;
+      };
+      var listFiles = async (path = "") => {
+        const base = path ? `${path.replace(/\/+$/, "")}/` : "";
+        const onDisk = (await walk(base)).map((file) => (0, _storagePath.storagePath)(file));
+        const root = (0, _storagePath.storagePath)();
+        return (0, _writeSet.pendingListing)((0, _storagePath.storagePath)(path), onDisk).map((location) => location.slice(root.length)).sort();
+      };
+      exports.listFiles = listFiles;
+    }
+  });
+
+  // dist/data/storage/databases.js
+  var require_databases = __commonJS({
+    "dist/data/storage/databases.js"(exports) {
+      "use strict";
+      init_process();
+      require_esnext_weak_map_delete_all();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.writeDatabaseList = exports.removeDatabaseFolder = exports.readDatabaseList = exports.makeDatabaseFolder = exports.databasesLocation = exports.databaseFolderExists = void 0;
+      require_es_json_stringify();
+      var jsEnv = _interopRequireWildcard(require_dist());
+      var _config = require_config();
+      var _nodeFiles = require_nodeFiles();
+      var _readCache = require_readCache();
+      var _writeSet = require_writeSet();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
+        }
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var databasesLocation = (path = "") => {
+        const relativePath = jsEnv.isBrowser ? (0, _config.getSetting)("relativePath", "") : "";
+        return `${relativePath}${(0, _config.databasesFolder)()}${path}`;
+      };
+      exports.databasesLocation = databasesLocation;
+      var listLocation = () => databasesLocation("__DATABASES.json");
+      var readDatabaseList = async () => {
+        let text;
+        try {
+          text = jsEnv.isNode ? await (0, _nodeFiles.nodeFiles)().readFile(listLocation(), "utf8") : await fetch(listLocation()).then((response) => response.ok === false ? "[]" : response.text());
+        } catch (error) {
+          if (jsEnv.isNode && error?.code !== "ENOENT") {
+            throw error;
+          }
+          return [];
+        }
+        try {
+          const names = JSON.parse(text);
+          return Array.isArray(names) ? names : [];
+        } catch (error) {
+          if (!jsEnv.isNode) {
+            return [];
+          }
+          throw new Error(`Could not read ${listLocation()}: ${error.message}`);
+        }
+      };
+      exports.readDatabaseList = readDatabaseList;
+      var writeDatabaseList = async (names) => {
+        await (0, _nodeFiles.nodeFiles)().mkdir(databasesLocation(), {
+          recursive: true
+        });
+        await (0, _writeSet.writeAtomically)(listLocation(), JSON.stringify(names));
+      };
+      exports.writeDatabaseList = writeDatabaseList;
+      var databaseFolderExists = (name) => require_fs().existsSync(databasesLocation(name));
+      exports.databaseFolderExists = databaseFolderExists;
+      var makeDatabaseFolder = async (name) => {
+        await (0, _nodeFiles.nodeFiles)().mkdir(databasesLocation(name), {
+          recursive: true
+        });
+      };
+      exports.makeDatabaseFolder = makeDatabaseFolder;
+      var removeDatabaseFolder = async (name) => {
+        const location = databasesLocation(name);
+        (0, _readCache.cacheRemove)(location, true);
+        await (0, _nodeFiles.nodeFiles)().rm(location, {
+          recursive: true,
+          force: true
+        });
+        (0, _readCache.cacheRemove)(location, true);
+      };
+      exports.removeDatabaseFolder = removeDatabaseFolder;
+    }
+  });
+
   // dist/data/storage/index.js
   var require_storage = __commonJS({
     "dist/data/storage/index.js"(exports) {
@@ -6805,24 +7451,72 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
+      Object.defineProperty(exports, "databaseFolderExists", {
+        enumerable: true,
+        get: function() {
+          return _databases.databaseFolderExists;
+        }
+      });
+      Object.defineProperty(exports, "databasesLocation", {
+        enumerable: true,
+        get: function() {
+          return _databases.databasesLocation;
+        }
+      });
       Object.defineProperty(exports, "fileExists", {
         enumerable: true,
         get: function() {
           return _fileExists.fileExists;
         }
       });
+      Object.defineProperty(exports, "jsonText", {
+        enumerable: true,
+        get: function() {
+          return _writeJson.jsonText;
+        }
+      });
+      Object.defineProperty(exports, "listFiles", {
+        enumerable: true,
+        get: function() {
+          return _listFiles.listFiles;
+        }
+      });
+      Object.defineProperty(exports, "makeDatabaseFolder", {
+        enumerable: true,
+        get: function() {
+          return _databases.makeDatabaseFolder;
+        }
+      });
       Object.defineProperty(exports, "makeDirectory", {
         enumerable: true,
         get: function() {
           return _makeDirectory.makeDirectory;
         }
       });
+      Object.defineProperty(exports, "readDatabaseList", {
+        enumerable: true,
+        get: function() {
+          return _databases.readDatabaseList;
+        }
+      });
       Object.defineProperty(exports, "readJson", {
         enumerable: true,
         get: function() {
           return _readJson.readJson;
         }
       });
+      Object.defineProperty(exports, "readText", {
+        enumerable: true,
+        get: function() {
+          return _readJson.readText;
+        }
+      });
+      Object.defineProperty(exports, "removeDatabaseFolder", {
+        enumerable: true,
+        get: function() {
+          return _databases.removeDatabaseFolder;
+        }
+      });
       Object.defineProperty(exports, "removeDirectory", {
         enumerable: true,
         get: function() {
@@ -6847,6 +7541,18 @@ var jsonFsQuery = (() => {
           return _readCache.withReadCache;
         }
       });
+      Object.defineProperty(exports, "withWriteSet", {
+        enumerable: true,
+        get: function() {
+          return _writeSet.withWriteSet;
+        }
+      });
+      Object.defineProperty(exports, "writeDatabaseList", {
+        enumerable: true,
+        get: function() {
+          return _databases.writeDatabaseList;
+        }
+      });
       Object.defineProperty(exports, "writeJson", {
         enumerable: true,
         get: function() {
@@ -6860,7 +7566,10 @@ var jsonFsQuery = (() => {
       var _removeFile = require_removeFile();
       var _removeDirectory = require_removeDirectory();
       var _fileExists = require_fileExists();
+      var _listFiles = require_listFiles();
+      var _databases = require_databases();
       var _readCache = require_readCache();
+      var _writeSet = require_writeSet();
     }
   });
 
@@ -6885,17 +7594,59 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/utilities/recordExists.js
+  var require_recordExists = __commonJS({
+    "dist/data/utilities/recordExists.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.recordExists = void 0;
+      var _storage = require_storage();
+      var recordExists = (entity) => (0, _storage.fileExists)(`${entity}.json`);
+      exports.recordExists = recordExists;
+    }
+  });
+
   // dist/data/utilities/retrieveRecord.js
   var require_retrieveRecord = __commonJS({
     "dist/data/utilities/retrieveRecord.js"(exports) {
       "use strict";
       init_process();
+      require_esnext_weak_map_delete_all();
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
       exports.retrieveRecord = void 0;
+      var jsEnv = _interopRequireWildcard(require_dist());
       var _retrieveFile = require_retrieveFile();
-      var retrieveRecord = async (entity = "") => await (0, _retrieveFile.retrieveFile)(`${entity}.json`);
+      var _recordExists = require_recordExists();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
+        }
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var retrieveRecord = async (entity = "") => {
+        if (jsEnv.isNode && !(0, _recordExists.recordExists)(entity)) {
+          throw new Error(`Record "${entity}" doesn't exist`);
+        }
+        try {
+          return await (0, _retrieveFile.retrieveFile)(`${entity}.json`);
+        } catch (error) {
+          if (!jsEnv.isNode) {
+            throw new Error(`Record "${entity}" doesn't exist, or ${entity}.json can't be read`);
+          }
+          throw error;
+        }
+      };
       exports.retrieveRecord = retrieveRecord;
     }
   });
@@ -7042,6 +7793,104 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/utilities/retrieveFiles.js
+  var require_retrieveFiles = __commonJS({
+    "dist/data/utilities/retrieveFiles.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.retrieveFiles = void 0;
+      var _retrieveFile = require_retrieveFile();
+      var _config = require_config();
+      var retrieveFiles = async (paths, read = _retrieveFile.retrieveFile) => {
+        const limit = Math.max(1, Math.floor((0, _config.getSetting)("readConcurrency", 16)) || 1);
+        const contents = new Array(paths.length);
+        const failures = [];
+        let next = 0;
+        const worker = async () => {
+          while (next < paths.length && !failures.length) {
+            const position = next++;
+            try {
+              contents[position] = await read(paths[position]);
+            } catch (error) {
+              failures.push({
+                position,
+                error
+              });
+            }
+          }
+        };
+        await Promise.all(Array.from({
+          length: Math.min(limit, paths.length)
+        }, worker));
+        if (failures.length) {
+          throw failures.reduce((first, failure) => failure.position < first.position ? failure : first).error;
+        }
+        return contents;
+      };
+      exports.retrieveFiles = retrieveFiles;
+    }
+  });
+
+  // dist/data/utilities/packedTable.js
+  var require_packedTable = __commonJS({
+    "dist/data/utilities/packedTable.js"(exports) {
+      "use strict";
+      init_process();
+      require_esnext_weak_map_delete_all();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.usesPackedReads = exports.retrievePacked = exports.packedPath = exports.discardPacked = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_some();
+      var jsEnv = _interopRequireWildcard(require_dist());
+      var _storage = require_storage();
+      var _config = require_config();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
+        }
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var packedPath = (recordPath) => `__packed/${recordPath}.json`;
+      exports.packedPath = packedPath;
+      var usesPackedReads = () => (0, _config.getSetting)("packedReads", !jsEnv.isNode);
+      exports.usesPackedReads = usesPackedReads;
+      var retrievePacked = async (record) => {
+        if (!usesPackedReads()) {
+          return void 0;
+        }
+        let packed;
+        try {
+          packed = await (0, _storage.readJson)(packedPath(record.path));
+        } catch (error) {
+          return void 0;
+        }
+        const entries = record.entries || [];
+        if (!packed || !Array.isArray(packed.entries) || !Array.isArray(packed.rows) || packed.entries.length !== entries.length || packed.rows.length !== entries.length || packed.entries.some((entry, position) => entry !== entries[position])) {
+          return void 0;
+        }
+        return packed;
+      };
+      exports.retrievePacked = retrievePacked;
+      var discardPacked = async (recordPath) => {
+        if ((0, _storage.fileExists)(packedPath(recordPath))) {
+          await (0, _storage.removeFile)(packedPath(recordPath));
+        }
+      };
+      exports.discardPacked = discardPacked;
+    }
+  });
+
   // dist/data/utilities/retrieveRecords.js
   var require_retrieveRecords = __commonJS({
     "dist/data/utilities/retrieveRecords.js"(exports) {
@@ -7050,20 +7899,51 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.retrieveRecords = void 0;
+      exports.retrieveRecords = exports.retrieveEntryRows = exports.retrieveEntry = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      require_esnext_iterator_map();
+      require_esnext_map_delete_all();
+      require_esnext_map_every();
+      require_esnext_map_filter();
+      require_esnext_map_find();
+      require_esnext_map_find_key();
+      require_esnext_map_includes();
+      require_esnext_map_key_of();
+      require_esnext_map_map_keys();
+      require_esnext_map_map_values();
+      require_esnext_map_merge();
+      require_esnext_map_reduce();
+      require_esnext_map_some();
+      require_esnext_map_update();
       var _retrieveFile = require_retrieveFile();
       var _retrieveRecord = require_retrieveRecord();
+      var _retrieveFiles = require_retrieveFiles();
+      var _packedTable = require_packedTable();
+      var _config = require_config();
+      var retrieveEntry = async (path) => {
+        const data = await (0, _retrieveFile.retrieveFile)(path).catch((err) => console.error(err));
+        if (!data) {
+          throw new Error(`Could not read entity ${path.slice(path.lastIndexOf("/") + 1)}`);
+        }
+        return data;
+      };
+      exports.retrieveEntry = retrieveEntry;
+      var retrieveEntryRows = async (record, files, read = retrieveEntry) => {
+        const packed = files.length > (0, _config.getSetting)("readConcurrency", 16) ? await (0, _packedTable.retrievePacked)(record) : void 0;
+        if (!packed) {
+          return (0, _retrieveFiles.retrieveFiles)(files.map((file) => `${record.path}/${file}`), read);
+        }
+        const positions = new Map(packed.entries.map((entry, position) => [entry, position]));
+        const unpacked = files.filter((file) => !positions.has(file));
+        const readRows = unpacked.length ? await (0, _retrieveFiles.retrieveFiles)(unpacked.map((file) => `${record.path}/${file}`), read) : [];
+        const fromFiles = new Map(unpacked.map((file, position) => [file, readRows[position]]));
+        return files.map((file) => positions.has(file) ? packed.rows[positions.get(file)] : fromFiles.get(file));
+      };
+      exports.retrieveEntryRows = retrieveEntryRows;
       var retrieveRecords = async (entity = "") => {
         const recordFile = await (0, _retrieveRecord.retrieveRecord)(entity);
-        const dataSet = [];
-        for (const file of recordFile.entries) {
-          const data = await (0, _retrieveFile.retrieveFile)(`${recordFile.path}/${file}`).catch((err) => console.error(err));
-          if (!data) {
-            throw new Error(`Could not read entity ${file}`);
-          }
-          dataSet.push(data);
-        }
-        return dataSet;
+        return retrieveEntryRows(recordFile, recordFile.entries);
       };
       exports.retrieveRecords = retrieveRecords;
     }
@@ -7482,6 +8362,7 @@ var jsonFsQuery = (() => {
       var _config = require_config();
       var _keyIndexFiles = require_keyIndexFiles();
       var _storage = require_storage();
+      var _packedTable = require_packedTable();
       var assertNoDependents = async (entity, primaryKey, toDelete) => {
         if (!(0, _config.getSetting)("enforceForeignKeys", true) || primaryKey.fields.length !== 1) {
           return;
@@ -7531,7 +8412,11 @@ var jsonFsQuery = (() => {
         }
         await assertNoDependents(entity, primaryKey, toDelete);
         const deletedValues = new Set(toDelete.map((row) => (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row)));
-        record.entries = await removeMatchingEntries(entity, record, primaryKey, deletedValues);
+        const remaining = await removeMatchingEntries(entity, record, primaryKey, deletedValues);
+        if (remaining.length !== record.entries.length) {
+          await (0, _packedTable.discardPacked)(record.path);
+        }
+        record.entries = remaining;
         await (0, _storage.writeJson)(`${record.path}.json`, record);
         return dataSet;
       };
@@ -7539,48 +8424,45 @@ var jsonFsQuery = (() => {
     }
   });
 
-  // dist/data/utilities/updateIndex.js
-  var require_updateIndex = __commonJS({
-    "dist/data/utilities/updateIndex.js"(exports) {
+  // node_modules/core-js/modules/es.iterator.every.js
+  var require_es_iterator_every = __commonJS({
+    "node_modules/core-js/modules/es.iterator.every.js"() {
       "use strict";
       init_process();
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.updateIndex = void 0;
-      require_es_array_includes();
-      require_esnext_iterator_constructor();
-      require_esnext_iterator_find();
-      var _compareAs = require_compareAs();
-      var _storage = require_storage();
-      var updateIndex = async (path = "", key = null, value = void 0, fileName = "", type = void 0) => {
-        if (!key || !key.lookup) {
-          return null;
-        }
-        const indexDir = `__indexes/${path}`;
-        const indexPath = `${indexDir}/${key.lookup}`;
-        let index = [];
-        try {
-          index = await (0, _storage.readJson)(indexPath);
-        } catch (err) {
-          index = [];
-        }
-        const existingEntry = index.find((entry) => (0, _compareAs.sameValue)(type, entry.value, value));
-        if (existingEntry) {
-          if (!existingEntry.record.includes(fileName)) {
-            existingEntry.record.push(fileName);
+      var $ = require_export();
+      var call = require_function_call();
+      var iterate = require_iterate();
+      var aCallable = require_a_callable();
+      var anObject = require_an_object();
+      var getIteratorDirect = require_get_iterator_direct();
+      var iteratorClose = require_iterator_close();
+      var iteratorHelperWithoutClosingOnEarlyError = require_iterator_helper_without_closing_on_early_error();
+      var everyWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError("every", TypeError);
+      $({ target: "Iterator", proto: true, real: true, forced: everyWithoutClosingOnEarlyError }, {
+        every: function every(predicate) {
+          anObject(this);
+          try {
+            aCallable(predicate);
+          } catch (error) {
+            iteratorClose(this, "throw", error);
           }
-        } else {
-          index.push({
-            value,
-            record: [fileName]
-          });
+          if (everyWithoutClosingOnEarlyError) return call(everyWithoutClosingOnEarlyError, this, predicate);
+          var record = getIteratorDirect(this);
+          var counter = 0;
+          return !iterate(record, function(value, stop) {
+            if (!predicate(value, counter++)) return stop();
+          }, { IS_RECORD: true, INTERRUPTED: true }).stopped;
         }
-        await (0, _storage.makeDirectory)(indexDir);
-        await (0, _storage.writeJson)(indexPath, index);
-        return index;
-      };
-      exports.updateIndex = updateIndex;
+      });
+    }
+  });
+
+  // node_modules/core-js/modules/esnext.iterator.every.js
+  var require_esnext_iterator_every = __commonJS({
+    "node_modules/core-js/modules/esnext.iterator.every.js"() {
+      "use strict";
+      init_process();
+      require_es_iterator_every();
     }
   });
 
@@ -7624,29 +8506,6 @@ var jsonFsQuery = (() => {
     }
   });
 
-  // dist/data/introspect/policies/keyGenerate.js
-  var require_keyGenerate = __commonJS({
-    "dist/data/introspect/policies/keyGenerate.js"(exports) {
-      "use strict";
-      init_process();
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.keyGenerate = void 0;
-      var _keyUnique = require_keyUnique();
-      var keyGenerate = async (entity, references = []) => {
-        let uuid = null;
-        let isUnique = false;
-        while (!isUnique) {
-          uuid = crypto.randomUUID();
-          isUnique = await (0, _keyUnique.keyUnique)(entity, references, [uuid]);
-        }
-        return uuid;
-      };
-      exports.keyGenerate = keyGenerate;
-    }
-  });
-
   // dist/data/introspect/policies/useDefault.js
   var require_useDefault = __commonJS({
     "dist/data/introspect/policies/useDefault.js"(exports) {
@@ -7698,6 +8557,253 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/utilities/indexBuffer.js
+  var require_indexBuffer = __commonJS({
+    "dist/data/utilities/indexBuffer.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.IndexBuffer = void 0;
+      require_es_array_includes();
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_find();
+      require_esnext_iterator_some();
+      require_esnext_map_delete_all();
+      require_esnext_map_every();
+      require_esnext_map_filter();
+      require_esnext_map_find();
+      require_esnext_map_find_key();
+      require_esnext_map_includes();
+      require_esnext_map_key_of();
+      require_esnext_map_map_keys();
+      require_esnext_map_map_values();
+      require_esnext_map_merge();
+      require_esnext_map_reduce();
+      require_esnext_map_some();
+      require_esnext_map_update();
+      require_esnext_set_add_all();
+      require_esnext_set_delete_all();
+      require_esnext_set_difference();
+      require_esnext_set_every();
+      require_esnext_set_filter();
+      require_esnext_set_find();
+      require_esnext_set_intersection();
+      require_esnext_set_is_disjoint_from();
+      require_esnext_set_is_subset_of();
+      require_esnext_set_is_superset_of();
+      require_esnext_set_join();
+      require_esnext_set_map();
+      require_esnext_set_reduce();
+      require_esnext_set_some();
+      require_esnext_set_symmetric_difference();
+      require_esnext_set_union();
+      require_esnext_weak_map_delete_all();
+      var _compareAs = require_compareAs();
+      var unkeyed = /* @__PURE__ */ Symbol("unkeyed");
+      var keyOf = (type, value) => {
+        if (!_compareAs.comparableTypes.includes(type)) {
+          return unkeyed;
+        }
+        const key = (0, _compareAs.compareAs)(type, value);
+        return typeof key === "object" && key !== null ? unkeyed : key;
+      };
+      var IndexBuffer = class {
+        /**
+         * @param entries - The index as read from its file ([] when there's none yet).
+         * @param type - The key's value type (see keyValueType).
+         */
+        constructor(entries, type) {
+          this.byKey = /* @__PURE__ */ new Map();
+          this.listed = /* @__PURE__ */ new WeakMap();
+          this.entries = entries;
+          this.type = type;
+          for (const entry of entries) {
+            const key = keyOf(type, entry.value);
+            if (key !== unkeyed && !this.byKey.has(key)) {
+              this.byKey.set(key, entry);
+            }
+          }
+        }
+        /**
+         * The entry for `value`, as updateIndex finds it.
+         * @param value
+         */
+        find(value) {
+          const key = keyOf(this.type, value);
+          return key === unkeyed ? this.entries.find((entry) => (0, _compareAs.sameValue)(this.type, entry.value, value)) : this.byKey.get(key);
+        }
+        /**
+         * Whether a row holds `value`, as indexHas answers it: an entry for it lists a file (never for null or undefined).
+         * @param value
+         */
+        has(value) {
+          if (value === null || typeof value === "undefined") {
+            return false;
+          }
+          const listsFiles = (entry) => Boolean(entry && Array.isArray(entry.record) && entry.record.length);
+          const first = this.find(value);
+          if (!first || listsFiles(first)) {
+            return listsFiles(first);
+          }
+          return this.entries.some((entry) => (0, _compareAs.sameValue)(this.type, entry.value, value) && listsFiles(entry));
+        }
+        /**
+         * List `fileName` under `value`, as updateIndex does.
+         * @param value
+         * @param fileName
+         */
+        add(value, fileName) {
+          const existing = this.find(value);
+          if (existing) {
+            if (!this.listed.has(existing)) {
+              this.listed.set(existing, new Set(existing.record));
+            }
+            const files = this.listed.get(existing);
+            if (!files.has(fileName)) {
+              files.add(fileName);
+              existing.record.push(fileName);
+            }
+            return;
+          }
+          const entry = {
+            value,
+            record: [fileName]
+          };
+          this.entries.push(entry);
+          this.listed.set(entry, new Set(entry.record));
+          const key = keyOf(this.type, value);
+          if (key !== unkeyed) {
+            this.byKey.set(key, entry);
+          }
+        }
+      };
+      exports.IndexBuffer = IndexBuffer;
+    }
+  });
+
+  // dist/data/utilities/parsers/isEntityProperty.js
+  var require_isEntityProperty = __commonJS({
+    "dist/data/utilities/parsers/isEntityProperty.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.isEntityProperty = void 0;
+      var isEntityProperty = (property) => /^[a-z0-9_-]+\.([a-z0-9_-]+)$/i.test(property);
+      exports.isEntityProperty = isEntityProperty;
+    }
+  });
+
+  // dist/data/utilities/knownFields.js
+  var require_knownFields = __commonJS({
+    "dist/data/utilities/knownFields.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.assertKnownFields = exports.assertFieldsDefined = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      require_esnext_iterator_find();
+      require_esnext_iterator_flat_map();
+      require_esnext_iterator_map();
+      require_esnext_set_add_all();
+      require_esnext_set_delete_all();
+      require_esnext_set_difference();
+      require_esnext_set_every();
+      require_esnext_set_filter();
+      require_esnext_set_find();
+      require_esnext_set_intersection();
+      require_esnext_set_is_disjoint_from();
+      require_esnext_set_is_subset_of();
+      require_esnext_set_is_superset_of();
+      require_esnext_set_join();
+      require_esnext_set_map();
+      require_esnext_set_reduce();
+      require_esnext_set_some();
+      require_esnext_set_symmetric_difference();
+      require_esnext_set_union();
+      var _retrieveRecord = require_retrieveRecord();
+      var _isEntityProperty = require_isEntityProperty();
+      var _splitEntityProperty = require_splitEntityProperty();
+      var _conditionTree = require_conditionTree();
+      var fieldList = (record) => record.definition.map((field) => field.name).join(", ");
+      var assertFieldsDefined = (entity, record, fields, where) => {
+        const defined = new Set(record.definition.map((field) => field.name));
+        const unknown = fields.find((field) => !defined.has(field));
+        if (typeof unknown !== "undefined") {
+          throw new Error(`Unknown field "${unknown}" in ${where}: ${entity} has ${fieldList(record)}`);
+        }
+      };
+      exports.assertFieldsDefined = assertFieldsDefined;
+      var assertKnownFields = async (parsed, recordData) => {
+        const merged = new Set((parsed.mergeJoins || []).map((merge) => (0, _splitEntityProperty.splitEntityProperty)(merge.propertyB).entity));
+        const named = [...(0, _conditionTree.conditionsOf)(parsed.where).map((condition) => ({
+          property: condition.property,
+          clause: "where"
+        })), ...(parsed.sortClauses || []).map((sort) => ({
+          property: sort.property,
+          clause: "sort"
+        })), ...(parsed.groupBy || []).map((property) => ({
+          property,
+          clause: "group by"
+        })), ...(parsed.selectClauses || []).filter((select) => select.property !== parsed.joinEntity).map((select) => ({
+          property: select.property,
+          clause: "select"
+        })), ...(parsed.insertValues || []).flatMap((row) => Object.keys(row || {}).map((property) => ({
+          property,
+          clause: "insert",
+          own: true
+        }))), ...Object.keys(parsed.updateValues || {}).map((property) => ({
+          property,
+          clause: "set",
+          own: true
+        })), ...(parsed.joinClauses || []).flatMap((join) => [{
+          property: join.propertyA,
+          clause: "on"
+        }, {
+          property: join.propertyB,
+          clause: "on"
+        }]), ...(parsed.mergeJoins || []).flatMap((merge) => [{
+          property: merge.propertyA,
+          clause: "merge"
+        }, {
+          property: merge.propertyB,
+          clause: "merge"
+        }])];
+        for (const {
+          property,
+          clause,
+          own
+        } of named) {
+          if (typeof property !== "string") {
+            continue;
+          }
+          let entity = parsed.entity;
+          let field = property;
+          if (!own && (0, _isEntityProperty.isEntityProperty)(property)) {
+            ({
+              entity,
+              property: field
+            } = (0, _splitEntityProperty.splitEntityProperty)(property));
+          }
+          if (clause === "select" && entity !== parsed.entity && !merged.has(entity)) {
+            throw new Error(`Can't select "${property}": a joined record's rows are a list under its name (select ${entity}), and its fields are on each row only when merged (merge ... with ${entity}.<field>)`);
+          }
+          if (!Object.prototype.hasOwnProperty.call(recordData, entity)) {
+            recordData[entity] = await (0, _retrieveRecord.retrieveRecord)(entity);
+          }
+          assertFieldsDefined(entity, recordData[entity], [field], clause);
+        }
+      };
+      exports.assertKnownFields = assertKnownFields;
+    }
+  });
+
   // dist/data/queries/insertEntity.js
   var require_insertEntity = __commonJS({
     "dist/data/queries/insertEntity.js"(exports) {
@@ -7707,13 +8813,44 @@ var jsonFsQuery = (() => {
         value: true
       });
       exports.insertEntity = void 0;
+      require_es_array_includes();
+      require_es_json_stringify();
       require_esnext_iterator_constructor();
+      require_esnext_iterator_every();
       require_esnext_iterator_find();
+      require_esnext_iterator_for_each();
       require_esnext_iterator_map();
       require_esnext_iterator_some();
+      require_esnext_map_delete_all();
+      require_esnext_map_every();
+      require_esnext_map_filter();
+      require_esnext_map_find();
+      require_esnext_map_find_key();
+      require_esnext_map_includes();
+      require_esnext_map_key_of();
+      require_esnext_map_map_keys();
+      require_esnext_map_map_values();
+      require_esnext_map_merge();
+      require_esnext_map_reduce();
+      require_esnext_map_some();
+      require_esnext_map_update();
+      require_esnext_set_add_all();
+      require_esnext_set_delete_all();
+      require_esnext_set_difference();
+      require_esnext_set_every();
+      require_esnext_set_filter();
+      require_esnext_set_find();
+      require_esnext_set_intersection();
+      require_esnext_set_is_disjoint_from();
+      require_esnext_set_is_subset_of();
+      require_esnext_set_is_superset_of();
+      require_esnext_set_join();
+      require_esnext_set_map();
+      require_esnext_set_reduce();
+      require_esnext_set_some();
+      require_esnext_set_symmetric_difference();
+      require_esnext_set_union();
       var _retrieveRecord = require_retrieveRecord();
-      var _updateIndex = require_updateIndex();
-      var _keyGenerate = require_keyGenerate();
       var _keyUnique = require_keyUnique();
       var _useDefault = require_useDefault();
       var _typeCheck = require_typeCheck();
@@ -7721,19 +8858,262 @@ var jsonFsQuery = (() => {
       var _splitEntityProperty = require_splitEntityProperty();
       var _computeKeyValue = require_computeKeyValue();
       var _fieldType = require_fieldType();
+      var _compareAs = require_compareAs();
+      var _retrieveRecords = require_retrieveRecords();
+      var _isSingleFieldKey = require_isSingleFieldKey();
+      var _indexBuffer = require_indexBuffer();
       var _storage = require_storage();
-      var buildEntityValues = async (entity, record, rowValues = {}) => {
+      var _packedTable = require_packedTable();
+      var _knownFields = require_knownFields();
+      var RowValues = class {
+        constructor(record, fields) {
+          this.seen = /* @__PURE__ */ new Set();
+          this.fields = fields;
+          this.types = fields.map((field) => (0, _fieldType.fieldType)(record, field));
+        }
+        /**
+         * Whether these fields' values can be compared this way: every field of a comparable type (see compareAs).
+         * @param record
+         * @param fields
+         */
+        static usable(record, fields) {
+          return fields.every((field) => _compareAs.comparableTypes.includes((0, _fieldType.fieldType)(record, field)));
+        }
+        /**
+         * The values' key, or undefined when one is null or missing (where's = never matches those) or compareAs leaves it an
+         * object (compared by identity, so not by a key).
+         * @param row
+         */
+        keyOf(row) {
+          const typed = [];
+          for (let position = 0; position < this.fields.length; position++) {
+            const value = row[this.fields[position]];
+            if (value === null || typeof value === "undefined") {
+              return void 0;
+            }
+            const key = (0, _compareAs.compareAs)(this.types[position], value);
+            if (typeof key === "object") {
+              return void 0;
+            }
+            typed.push([typeof key, key]);
+          }
+          return JSON.stringify(typed);
+        }
+        add(row) {
+          const key = this.keyOf(row);
+          if (typeof key !== "undefined") {
+            this.seen.add(key);
+          }
+        }
+        has(row) {
+          const key = this.keyOf(row);
+          return typeof key !== "undefined" && this.seen.has(key);
+        }
+      };
+      var InsertStatement = class {
+        constructor(entity, record) {
+          this.rows = [];
+          this.buffers = /* @__PURE__ */ new Map();
+          this.unreadable = /* @__PURE__ */ new Set();
+          this.otherLookups = /* @__PURE__ */ new Map();
+          this.scans = /* @__PURE__ */ new Map();
+          this.entity = entity;
+          this.record = record;
+          this.hadEntries = (record.entries || []).length > 0;
+        }
+        /**
+         * Read the record's index files, once. An index that can't be read starts empty (as updateIndex starts one) and its
+         * key is checked by looking at every row.
+         */
+        async load() {
+          for (const key of this.record.keys) {
+            if (!key.lookup) {
+              continue;
+            }
+            let entries = [];
+            try {
+              entries = await (0, _storage.readJson)(`__indexes/${this.record.path}/${key.lookup}`);
+            } catch (error) {
+              this.unreadable.add(key);
+            }
+            this.buffers.set(key, new _indexBuffer.IndexBuffer(Array.isArray(entries) ? entries : [], (0, _fieldType.keyValueType)(this.record, key)));
+          }
+        }
+        /**
+         * How to look up a non-null value of `property` in the record being inserted into: through its index buffer, which
+         * holds the statement's rows so far. indexHas reads a record with no entries as holding nothing, whatever its index
+         * file says, so until this statement adds a row to a record that had none, nothing is found.
+         * @param property
+         */
+        ownLookup(property) {
+          const key = this.record.keys.find((key2) => (0, _isSingleFieldKey.isSingleFieldKey)(key2, property) && key2.lookup);
+          if (!key || this.unreadable.has(key)) {
+            return () => void 0;
+          }
+          const buffer = this.buffers.get(key);
+          return (value) => (this.hadEntries || this.rows.length > 0) && buffer.has(value);
+        }
+        /**
+         * How to look up a non-null value of `property` in another record, read once (an insert doesn't change it).
+         * @param entity
+         * @param property
+         */
+        otherLookup(entity, property) {
+          const name = `${entity}\0${property}`;
+          if (!this.otherLookups.has(name)) {
+            this.otherLookups.set(name, (async () => {
+              const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+              const key = record.keys.find((key2) => (0, _isSingleFieldKey.isSingleFieldKey)(key2, property) && key2.lookup);
+              if (!key) {
+                return () => void 0;
+              }
+              if (!(record.entries || []).length) {
+                return () => false;
+              }
+              let entries;
+              try {
+                entries = await (0, _storage.readJson)(`__indexes/${record.path}/${key.lookup}`);
+              } catch (error) {
+                return () => void 0;
+              }
+              const buffer = new _indexBuffer.IndexBuffer(Array.isArray(entries) ? entries : [], (0, _fieldType.fieldType)(record, property));
+              return (value) => buffer.has(value);
+            })());
+          }
+          return this.otherLookups.get(name);
+        }
+        /**
+         * The values of these fields in every row of `entity` (read once per statement), plus, for the record being inserted
+         * into, every row this statement adds; undefined when a field's type can't be compared by key.
+         * @param entity
+         * @param fields
+         */
+        scan(entity, fields) {
+          const name = `${entity}\0${fields.join("\0")}`;
+          if (!this.scans.has(name)) {
+            this.scans.set(name, (async () => {
+              const record = entity === this.entity ? this.record : await (0, _retrieveRecord.retrieveRecord)(entity);
+              if (!RowValues.usable(record, fields)) {
+                return void 0;
+              }
+              const values = new RowValues(record, fields);
+              for (const row of await (0, _retrieveRecords.retrieveRecords)(entity)) {
+                values.add(row);
+              }
+              if (entity === this.entity) {
+                this.rows.forEach((row) => values.add(row));
+              }
+              return values;
+            })());
+          }
+          return this.scans.get(name);
+        }
+        /**
+         * Whether one of this statement's rows already holds these values in every one of these fields (none of them null).
+         * @param fields
+         * @param values
+         */
+        claimed(fields, values) {
+          return this.rows.some((row) => fields.every((field) => row[field] !== null && typeof row[field] !== "undefined" && (0, _compareAs.sameValue)((0, _fieldType.fieldType)(this.record, field), row[field], values[field])));
+        }
+        /**
+         * Whether no row (in storage or earlier in this statement) holds these values for these fields, as keyUnique answers
+         * it after each earlier row is written.
+         * @param fields
+         * @param values
+         */
+        async isUnique(fields, values) {
+          if (fields.length === 1) {
+            const found = this.ownLookup(fields[0])(values[fields[0]]);
+            if (typeof found !== "undefined") {
+              return !found;
+            }
+          }
+          const scanned = await this.scan(this.entity, fields);
+          if (scanned) {
+            return !scanned.has(values);
+          }
+          return await (0, _keyUnique.keyUnique)(this.entity, fields, fields.map((field) => values[field])) && !this.claimed(fields, values);
+        }
+        /**
+         * Whether `entity` holds `value` in `property`, as foreignKeyExists answers it after each earlier row is written: a
+         * row may reference one added earlier in the same statement when the key points at its own record.
+         * @param entity
+         * @param property
+         * @param value
+         */
+        async exists(entity, property, value) {
+          const own = entity === this.entity;
+          const found = own ? this.ownLookup(property)(value) : (await this.otherLookup(entity, property))(value);
+          if (typeof found !== "undefined") {
+            return found;
+          }
+          const scanned = await this.scan(entity, [property]);
+          if (scanned) {
+            return scanned.has({
+              [property]: value
+            });
+          }
+          return await (0, _foreignKeyExists.foreignKeyExists)(entity, property, value) || own && this.claimed([property], {
+            [property]: value
+          });
+        }
+        /**
+         * Note a row added to the statement, filed under `fileName`, in the record's entries and every index buffer.
+         * @param entityValues
+         * @param fileName
+         */
+        async add(entityValues, fileName) {
+          this.rows.push(entityValues);
+          for (const [name, scanned] of this.scans) {
+            if (name.startsWith(`${this.entity}\0`)) {
+              (await scanned)?.add(entityValues);
+            }
+          }
+          this.record.entries.push(fileName);
+          for (const [key, buffer] of this.buffers) {
+            buffer.add((0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName);
+          }
+        }
+        /**
+         * Write the record file and each index once, with every row the statement added.
+         */
+        async write() {
+          await (0, _storage.writeJson)(`${this.record.path}.json`, this.record);
+          if (this.buffers.size) {
+            await (0, _storage.makeDirectory)(`__indexes/${this.record.path}`);
+          }
+          for (const [key, buffer] of this.buffers) {
+            await (0, _storage.writeJson)(`__indexes/${this.record.path}/${key.lookup}`, buffer.entries);
+          }
+        }
+      };
+      var generateKey = async (statement, field) => {
+        let uuid;
+        do {
+          uuid = crypto.randomUUID();
+        } while (!await statement.isUnique([field], {
+          [field]: uuid
+        }));
+        return uuid;
+      };
+      var buildEntityValues = async (statement, rowValues = {}) => {
         const entityValues = {};
-        for (const field of record.definition) {
+        for (const field of statement.record.definition) {
           let value = rowValues[field.name];
+          if (value === null && field.optional && !field.nullable) {
+            value = void 0;
+          }
           if (field.autoGenerate) {
-            value = await (0, _keyGenerate.keyGenerate)(entity, [field.name]);
+            if (value === void 0 || value === null) {
+              value = await generateKey(statement, field.name);
+            }
           } else if (Object.prototype.hasOwnProperty.call(field, "default")) {
             value = (0, _useDefault.useDefault)(field["default"], value);
           }
           if (typeof value === "undefined") {
             if (!field.optional) {
-              throw new Error(`Missing required field "${field.name}" for ${entity}`);
+              throw new Error(`Missing required field "${field.name}" for ${statement.entity}`);
             }
             continue;
           }
@@ -7741,23 +9121,21 @@ var jsonFsQuery = (() => {
         }
         return entityValues;
       };
-      var assertUnique = async (entity, record, entityValues) => {
-        for (const key of record.keys) {
+      var assertUnique = async (statement, entityValues) => {
+        for (const key of statement.record.keys) {
           if (key.type !== "primary" && key.type !== "unique") {
             continue;
           }
-          const checkKeys = key.fields.map((field) => entityValues[field]);
-          if (checkKeys.some((value) => value === null)) {
+          if (key.fields.some((field) => entityValues[field] === null)) {
             continue;
           }
-          const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
-          if (!isUnique) {
-            throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(", ")}" on ${entity}`);
+          if (!await statement.isUnique(key.fields, entityValues)) {
+            throw new Error(`Duplicate value for ${key.type} key "${key.fields.join(", ")}" on ${statement.entity}`);
           }
         }
       };
-      var assertForeignKeys = async (entity, record, entityValues) => {
-        for (const key of record.keys) {
+      var assertForeignKeys = async (statement, entityValues) => {
+        for (const key of statement.record.keys) {
           if (key.type !== "foreign" || key.fields.length !== 1 || !key.references || key.references.length !== 1) {
             continue;
           }
@@ -7769,9 +9147,8 @@ var jsonFsQuery = (() => {
             entity: refEntity,
             property: refProperty
           } = (0, _splitEntityProperty.splitEntityProperty)(key.references[0].fields[0]);
-          const exists = await (0, _foreignKeyExists.foreignKeyExists)(refEntity, refProperty, entityValues[field]);
-          if (!exists) {
-            throw new Error(`Foreign key "${field}" on ${entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`);
+          if (!await statement.exists(refEntity, refProperty, entityValues[field])) {
+            throw new Error(`Foreign key "${field}" on ${statement.entity} references a nonexistent ${refEntity}.${refProperty} = ${entityValues[field]}`);
           }
         }
       };
@@ -7781,20 +9158,26 @@ var jsonFsQuery = (() => {
         if (!Object.prototype.hasOwnProperty.call(dataSet, entity)) {
           dataSet[entity] = [];
         }
-        await (0, _storage.makeDirectory)(record.path);
+        await (0, _storage.makeDirectory)(record.path);
+        if (!values.length) {
+          return dataSet;
+        }
+        for (const rowValues of values) {
+          (0, _knownFields.assertFieldsDefined)(entity, record, Object.keys(rowValues || {}), "insert");
+        }
+        await (0, _packedTable.discardPacked)(record.path);
+        const statement = new InsertStatement(entity, record);
+        await statement.load();
         for (const rowValues of values) {
-          const entityValues = await buildEntityValues(entity, record, rowValues);
-          await assertUnique(entity, record, entityValues);
-          await assertForeignKeys(entity, record, entityValues);
+          const entityValues = await buildEntityValues(statement, rowValues);
+          await assertUnique(statement, entityValues);
+          await assertForeignKeys(statement, entityValues);
           const fileName = `${primaryKey ? entityValues[primaryKey.fields[0]] : crypto.randomUUID()}.json`;
           await (0, _storage.writeJson)(`${record.path}/${fileName}`, entityValues);
-          record.entries.push(fileName);
-          await (0, _storage.writeJson)(`${record.path}.json`, record);
-          for (const key of record.keys) {
-            await (0, _updateIndex.updateIndex)(record.path, key, (0, _computeKeyValue.computeKeyValue)(key.fields, entityValues), fileName, (0, _fieldType.keyValueType)(record, key));
-          }
+          await statement.add(entityValues, fileName);
           dataSet[entity].push(entityValues);
         }
+        await statement.write();
         return dataSet;
       };
       exports.insertEntity = insertEntity;
@@ -7821,6 +9204,51 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/utilities/updateIndex.js
+  var require_updateIndex = __commonJS({
+    "dist/data/utilities/updateIndex.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.updateIndex = void 0;
+      require_es_array_includes();
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_find();
+      var _compareAs = require_compareAs();
+      var _storage = require_storage();
+      var updateIndex = async (path = "", key = null, value = void 0, fileName = "", type = void 0) => {
+        if (!key || !key.lookup) {
+          return null;
+        }
+        const indexDir = `__indexes/${path}`;
+        const indexPath = `${indexDir}/${key.lookup}`;
+        let index = [];
+        try {
+          index = await (0, _storage.readJson)(indexPath);
+        } catch (err) {
+          index = [];
+        }
+        const existingEntry = index.find((entry) => (0, _compareAs.sameValue)(type, entry.value, value));
+        if (existingEntry) {
+          if (!existingEntry.record.includes(fileName)) {
+            existingEntry.record.push(fileName);
+          }
+        } else {
+          index.push({
+            value,
+            record: [fileName]
+          });
+        }
+        await (0, _storage.makeDirectory)(indexDir);
+        await (0, _storage.writeJson)(indexPath, index);
+        return index;
+      };
+      exports.updateIndex = updateIndex;
+    }
+  });
+
   // dist/data/queries/updateEntity.js
   var require_updateEntity = __commonJS({
     "dist/data/queries/updateEntity.js"(exports) {
@@ -7849,6 +9277,8 @@ var jsonFsQuery = (() => {
       var _config = require_config();
       var _keyIndexFiles = require_keyIndexFiles();
       var _storage = require_storage();
+      var _packedTable = require_packedTable();
+      var _knownFields = require_knownFields();
       var findEntryFile = async (record, primaryKey, primaryValue) => {
         const type = (0, _fieldType.keyValueType)(record, primaryKey);
         const isMatch = async (fileName) => (0, _compareAs.sameValue)(type, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`)), primaryValue);
@@ -7871,7 +9301,7 @@ var jsonFsQuery = (() => {
             continue;
           }
           const checkKeys = key.fields.map((field) => newData[field]);
-          if (checkKeys.some((value) => value === null)) {
+          if (checkKeys.some((value) => value === null || typeof value === "undefined")) {
             continue;
           }
           const isUnique = await (0, _keyUnique.keyUnique)(entity, key.fields, checkKeys);
@@ -7886,7 +9316,7 @@ var jsonFsQuery = (() => {
             continue;
           }
           const field = key.fields[0];
-          if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] === null || (0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field])) {
+          if (!Object.prototype.hasOwnProperty.call(newValues, field) || newValues[field] === null || typeof newValues[field] === "undefined" || (0, _compareAs.sameValue)((0, _fieldType.fieldType)(record, field), newValues[field], oldData[field])) {
             continue;
           }
           const {
@@ -7927,7 +9357,7 @@ var jsonFsQuery = (() => {
             oldData,
             newData
           } of planned) {
-            if (!keyFieldsChanged(record, key, oldData, newValues) || key.fields.some((field) => newData[field] === null)) {
+            if (!keyFieldsChanged(record, key, oldData, newValues) || key.fields.some((field) => newData[field] === null || typeof newData[field] === "undefined")) {
               continue;
             }
             const value = (0, _computeKeyValue.computeKeyValue)(key.fields, newData);
@@ -7949,18 +9379,33 @@ var jsonFsQuery = (() => {
         const typedValues = Object.assign({}, values);
         for (const field of record.definition) {
           if (Object.prototype.hasOwnProperty.call(typedValues, field.name)) {
-            typedValues[field.name] = (0, _typeCheck.typeCheck)(field.type, typedValues[field.name], field.nullable);
+            typedValues[field.name] = typedValues[field.name] === null && field.optional && !field.nullable ? void 0 : (0, _typeCheck.typeCheck)(field.type, typedValues[field.name], field.nullable);
           }
         }
         return typedValues;
       };
+      var withoutRemoved = (row, typedValues) => {
+        const kept = Object.assign({}, row);
+        for (const field of Object.keys(typedValues)) {
+          if (typeof typedValues[field] === "undefined") {
+            delete kept[field];
+          }
+        }
+        return kept;
+      };
       var updateEntity = async (entity = "", values = {}, dataSet = {}) => {
         const record = await (0, _retrieveRecord.retrieveRecord)(entity);
         const primaryKey = record.keys.find((key) => key.type === "primary");
         if (!primaryKey) {
           throw new Error(`Cannot update "${entity}" without a primary key`);
         }
+        (0, _knownFields.assertFieldsDefined)(entity, record, Object.keys(values || {}), "set");
         const typedValues = applyFieldTypes(record, values);
+        for (const field of primaryKey.fields) {
+          if (Object.prototype.hasOwnProperty.call(typedValues, field) && typeof typedValues[field] === "undefined") {
+            throw new Error(`Cannot clear "${field}" on ${entity}: it's part of the primary key`);
+          }
+        }
         const planned = [];
         for (const row of dataSet[entity] || []) {
           const fileName = await findEntryFile(record, primaryKey, (0, _computeKeyValue.computeKeyValue)(primaryKey.fields, row));
@@ -7971,7 +9416,7 @@ var jsonFsQuery = (() => {
             continue;
           }
           const oldData = await (0, _retrieveFile.retrieveFile)(`${record.path}/${fileName}`);
-          const newData = Object.assign({}, oldData, typedValues);
+          const newData = withoutRemoved(Object.assign({}, oldData, typedValues), typedValues);
           await assertUniqueForUpdate(entity, record, oldData, newData, typedValues);
           await assertForeignKeysForUpdate(entity, record, oldData, typedValues);
           await assertNoDependentsForUpdate(entity, record, primaryKey, oldData, typedValues);
@@ -7983,6 +9428,9 @@ var jsonFsQuery = (() => {
           });
         }
         assertUniqueWithinUpdate(entity, record, planned, typedValues);
+        if (planned.length) {
+          await (0, _packedTable.discardPacked)(record.path);
+        }
         for (const {
           fileName,
           oldData,
@@ -8233,7 +9681,7 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.create = void 0;
+      exports.create = exports.assertValidDefinition = void 0;
       require_es_array_includes();
       require_esnext_iterator_constructor();
       require_esnext_iterator_filter();
@@ -8277,11 +9725,16 @@ var jsonFsQuery = (() => {
         }
         const primaryKey = recordContent.keys.find((key) => key.type === "primary");
         for (const fieldName of primaryKey ? primaryKey.fields : []) {
-          if (recordContent.definition.some((field) => field.name === fieldName && field.nullable)) {
+          const field = recordContent.definition.find((defined) => defined.name === fieldName);
+          if (field && field.nullable) {
             throw new Error(`Primary key field "${fieldName}" of ${recordName} can't be nullable`);
           }
+          if (field && field.optional && !field.autoGenerate) {
+            throw new Error(`Primary key field "${fieldName}" of ${recordName} can't be optional`);
+          }
         }
       };
+      exports.assertValidDefinition = assertValidDefinition;
       var create = async (recordName, definition = [], keys = []) => {
         (0, _requireNode.requireNode)("create()");
         if (recordName === "__RECORDS") {
@@ -8314,21 +9767,6 @@ var jsonFsQuery = (() => {
     }
   });
 
-  // dist/data/utilities/recordExists.js
-  var require_recordExists = __commonJS({
-    "dist/data/utilities/recordExists.js"(exports) {
-      "use strict";
-      init_process();
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.recordExists = void 0;
-      var _storage = require_storage();
-      var recordExists = (entity) => (0, _storage.fileExists)(`${entity}.json`);
-      exports.recordExists = recordExists;
-    }
-  });
-
   // dist/data/queries/createRecord.js
   var require_createRecord = __commonJS({
     "dist/data/queries/createRecord.js"(exports) {
@@ -8426,6 +9864,7 @@ var jsonFsQuery = (() => {
       var _deregisterRecord = require_deregisterRecord();
       var _requireNode = require_requireNode();
       var _storage = require_storage();
+      var _packedTable = require_packedTable();
       var drop = async (record) => {
         (0, _requireNode.requireNode)("drop()");
         if (record === "__RECORDS") {
@@ -8437,6 +9876,7 @@ var jsonFsQuery = (() => {
         }
         await (0, _storage.removeDirectory)(recordFile.path);
         await (0, _storage.removeDirectory)(`__indexes/${recordFile.path}`);
+        await (0, _packedTable.discardPacked)(recordFile.path);
         await (0, _storage.removeFile)(`${record}.json`);
         await (0, _deregisterRecord.deregisterRecord)(record);
       };
@@ -8514,41 +9954,446 @@ var jsonFsQuery = (() => {
         if (!(0, _recordExists.recordExists)(entity)) {
           throw new Error(`Record "${entity}" doesn't exist`);
         }
-        const {
-          path,
-          definition,
-          keys
-        } = await (0, _retrieveRecord.retrieveRecord)(entity);
-        return {
-          path,
-          definition,
-          keys
-        };
+        const {
+          path,
+          definition,
+          keys
+        } = await (0, _retrieveRecord.retrieveRecord)(entity);
+        return {
+          path,
+          definition,
+          keys
+        };
+      };
+      exports.describeRecord = describeRecord;
+    }
+  });
+
+  // dist/data/queries/showRecords.js
+  var require_showRecords = __commonJS({
+    "dist/data/queries/showRecords.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.showRecords = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_map();
+      var _retrieveRecord = require_retrieveRecord();
+      var _recordExists = require_recordExists();
+      var showRecords = async () => {
+        if (!(0, _recordExists.recordExists)("__RECORDS")) {
+          return [];
+        }
+        return (await (0, _retrieveRecord.retrieveRecord)("__RECORDS")).entries.map((fileName) => fileName.replace(/\.json$/, ""));
+      };
+      exports.showRecords = showRecords;
+    }
+  });
+
+  // dist/data/introspect/alter.js
+  var require_alter = __commonJS({
+    "dist/data/introspect/alter.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.alter = void 0;
+      require_es_array_includes();
+      require_es_json_stringify();
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      require_esnext_iterator_find();
+      require_esnext_iterator_map();
+      require_esnext_iterator_some();
+      var _field = require_field();
+      var _create = require_create();
+      var _parseCreate = require_parseCreate();
+      var _retrieveRecord = require_retrieveRecord();
+      var _retrieveFiles = require_retrieveFiles();
+      var _retrieveRecords = require_retrieveRecords();
+      var _knownFields = require_knownFields();
+      var _packedTable = require_packedTable();
+      var _requireNode = require_requireNode();
+      var _showRecords = require_showRecords();
+      var _updateEntity = require_updateEntity();
+      var _typeCheck = require_typeCheck();
+      var _storage = require_storage();
+      var rowsOf = async (record) => {
+        const rows = await (0, _retrieveFiles.retrieveFiles)(record.entries.map((file) => `${record.path}/${file}`), _retrieveRecords.retrieveEntry);
+        return rows.map((data, position) => ({
+          fileName: record.entries[position],
+          data
+        }));
+      };
+      var has = (row, name) => Object.prototype.hasOwnProperty.call(row, name);
+      var keysUsing = (record, name) => record.keys.filter((key) => key.fields.includes(name));
+      var describeKey = (key) => `${key.type} key (${key.fields.join(", ")})`;
+      var referencesTo = async (entity, name) => {
+        const found = [];
+        for (const other of await (0, _showRecords.showRecords)()) {
+          const record = await (0, _retrieveRecord.retrieveRecord)(other);
+          for (const key of record.keys) {
+            if (key.type === "foreign" && (key.references || []).some((reference) => reference.fields.includes(`${entity}.${name}`))) {
+              found.push({
+                entity: other,
+                record,
+                key
+              });
+            }
+          }
+        }
+        return found;
+      };
+      var writeRecord = async (entity, record) => {
+        (0, _create.assertValidDefinition)(entity, record);
+        await (0, _storage.writeJson)(`${entity}.json`, record);
+      };
+      var setField = async (entity, record, rows, name, value) => {
+        if (!rows.length) {
+          return;
+        }
+        await (0, _packedTable.discardPacked)(record.path);
+        if (keysUsing(record, name).length && typeof value !== "function") {
+          if (!record.keys.some((key) => key.type === "primary")) {
+            throw new Error(`Can't change "${name}" on ${entity}'s rows: a key uses it, and rows are found by the primary key, which ${entity} doesn't have`);
+          }
+          await (0, _updateEntity.updateEntity)(entity, {
+            [name]: typeof value === "undefined" ? null : value
+          }, {
+            [entity]: rows.map((row) => row.data)
+          });
+          return;
+        }
+        for (const row of rows) {
+          const changed = Object.assign({}, row.data);
+          const next = typeof value === "function" ? value(row) : value;
+          if (typeof next === "undefined") {
+            delete changed[name];
+          } else {
+            changed[name] = next;
+          }
+          await (0, _storage.writeJson)(`${record.path}/${row.fileName}`, changed);
+        }
+      };
+      var addField = async (entity, record, added) => {
+        if (record.definition.some((field) => field.name === added.name)) {
+          throw new Error(`Field "${added.name}" already exists on ${entity}`);
+        }
+        const updated = {
+          ...record,
+          definition: [...record.definition, added]
+        };
+        const rows = await rowsOf(record);
+        for (const row of rows.filter((row2) => has(row2.data, added.name))) {
+          try {
+            (0, _typeCheck.typeCheck)(added.type, row.data[added.name], added.nullable);
+          } catch (error) {
+            throw new Error(`Can't add "${added.name}" to ${entity}: row ${row.fileName} already holds a value for it that doesn't fit (${error.message})`);
+          }
+        }
+        const missing = rows.filter((row) => !has(row.data, added.name));
+        const hasDefault = has(added, "default");
+        if (missing.length && !added.optional && !hasDefault && !added.autoGenerate) {
+          throw new Error(`Can't add required field "${added.name}" to ${entity}: its ${missing.length} row(s) have no value for it (give it a default, or make it optional)`);
+        }
+        await writeRecord(entity, updated);
+        if (added.autoGenerate) {
+          await setField(entity, updated, missing, added.name, () => crypto.randomUUID());
+        } else if (hasDefault) {
+          await setField(entity, updated, missing, added.name, added["default"]);
+        }
+        return updated;
+      };
+      var dropField = async (entity, record, name) => {
+        (0, _knownFields.assertFieldsDefined)(entity, record, [name], "alter");
+        const key = keysUsing(record, name)[0];
+        if (key) {
+          throw new Error(`Can't drop "${name}" from ${entity}: its ${describeKey(key)} uses it`);
+        }
+        const reference = (await referencesTo(entity, name))[0];
+        if (reference) {
+          throw new Error(`Can't drop "${name}" from ${entity}: ${reference.entity}'s foreign key "${reference.key.fields[0]}" references it`);
+        }
+        const updated = {
+          ...record,
+          definition: record.definition.filter((field) => field.name !== name)
+        };
+        await writeRecord(entity, updated);
+        await setField(entity, updated, (await rowsOf(record)).filter((row) => has(row.data, name)), name, void 0);
+        return updated;
+      };
+      var renameField = async (entity, record, name, to) => {
+        (0, _knownFields.assertFieldsDefined)(entity, record, [name], "alter");
+        if (record.definition.some((field) => field.name === to)) {
+          throw new Error(`Can't rename "${name}" on ${entity} to "${to}": a field of that name already exists`);
+        }
+        const references = await referencesTo(entity, name);
+        const keys = record.keys.map((key) => {
+          if (!key.fields.includes(name)) {
+            return key;
+          }
+          const fields = key.fields.map((field) => field === name ? to : field);
+          const lookup = key.lookup && key.lookup === (0, _parseCreate.keyLookup)(key.type, key.fields) ? (0, _parseCreate.keyLookup)(key.type, fields) : key.lookup;
+          return {
+            ...key,
+            fields,
+            lookup
+          };
+        });
+        const renameReferences = (key) => key.type !== "foreign" ? key : {
+          ...key,
+          references: (key.references || []).map((reference) => ({
+            ...reference,
+            fields: reference.fields.map((field) => field === `${entity}.${name}` ? `${entity}.${to}` : field)
+          }))
+        };
+        const updated = {
+          ...record,
+          definition: record.definition.map((field) => field.name === name ? {
+            ...field,
+            name: to
+          } : field),
+          keys: keys.map(renameReferences)
+        };
+        for (const [position, key] of record.keys.entries()) {
+          const moved = keys[position].lookup;
+          if (key.lookup && moved !== key.lookup && (0, _storage.fileExists)(`__indexes/${record.path}/${key.lookup}`)) {
+            await (0, _storage.writeJson)(`__indexes/${record.path}/${moved}`, await (0, _storage.readJson)(`__indexes/${record.path}/${key.lookup}`));
+            await (0, _storage.removeFile)(`__indexes/${record.path}/${key.lookup}`);
+          }
+        }
+        await writeRecord(entity, updated);
+        for (const reference of references.filter((reference2) => reference2.entity !== entity)) {
+          await (0, _storage.writeJson)(`${reference.entity}.json`, {
+            ...reference.record,
+            keys: reference.record.keys.map(renameReferences)
+          });
+        }
+        const rows = (await rowsOf(record)).filter((row) => has(row.data, name));
+        if (rows.length) {
+          await (0, _packedTable.discardPacked)(record.path);
+        }
+        for (const row of rows) {
+          const moved = Object.assign({}, row.data);
+          moved[to] = moved[name];
+          delete moved[name];
+          await (0, _storage.writeJson)(`${record.path}/${row.fileName}`, moved);
+        }
+        return updated;
+      };
+      var modifyField = async (entity, record, changed) => {
+        (0, _knownFields.assertFieldsDefined)(entity, record, [changed.name], "alter");
+        const current = record.definition.find((field) => field.name === changed.name);
+        if (current.type !== changed.type) {
+          throw new Error(`Can't change the type of "${changed.name}" on ${entity} (${current.type} to ${changed.type}): only optional, null and default can change`);
+        }
+        if (Boolean(current.autoGenerate) !== Boolean(changed.autoGenerate)) {
+          throw new Error(`Can't change whether "${changed.name}" on ${entity} is auto: only optional, null and default can change`);
+        }
+        const updated = {
+          ...record,
+          definition: record.definition.map((field) => field.name === changed.name ? changed : field)
+        };
+        const rows = await rowsOf(record);
+        const hasDefault = has(changed, "default");
+        const holdsNull = changed.nullable ? [] : rows.filter((row) => row.data[changed.name] === null);
+        const missing = changed.optional ? [] : rows.filter((row) => !has(row.data, changed.name));
+        const unfillable = changed.optional ? [] : holdsNull;
+        if ((missing.length || unfillable.length) && !hasDefault) {
+          throw missing.length ? new Error(`Can't make "${changed.name}" required on ${entity}: ${missing.length} row(s) have no value for it (give it a default to fill them in)`) : new Error(`Can't make "${changed.name}" not null on ${entity}: ${unfillable.length} row(s) hold null (give it a default to fill them in, or make it optional)`);
+        }
+        await writeRecord(entity, updated);
+        if (hasDefault) {
+          await setField(entity, updated, [...missing, ...unfillable], changed.name, changed["default"]);
+        }
+        if (changed.optional && holdsNull.length) {
+          await setField(entity, updated, holdsNull, changed.name, void 0);
+        }
+        return updated;
+      };
+      var alter = async (entity, change) => {
+        (0, _requireNode.requireNode)("alter");
+        if (entity === "__RECORDS") {
+          throw new Error("__RECORDS is reserved for the list of records");
+        }
+        const names = [entity, ..."field" in change ? [change.field?.name] : [], ..."name" in change ? [change.name] : [], ..."to" in change ? [change.to] : []];
+        const invalid = names.findIndex((name) => typeof name !== "string" || !_parseCreate.nameMatch.test(name));
+        if (invalid !== -1) {
+          throw new Error(`Invalid name ${JSON.stringify(names[invalid]) ?? "undefined"} in alter: names use letters, digits, _ and - only`);
+        }
+        const record = await (0, _retrieveRecord.retrieveRecord)(entity);
+        switch (change.action) {
+          case "add":
+            return (await addField(entity, record, (0, _field.field)(change.field))).definition;
+          case "drop":
+            return (await dropField(entity, record, change.name)).definition;
+          case "rename":
+            return (await renameField(entity, record, change.name, change.to)).definition;
+          case "modify":
+            return (await modifyField(entity, record, (0, _field.field)(change.field))).definition;
+          default:
+            throw new Error(`Unknown alter action: ${change.action}`);
+        }
+      };
+      exports.alter = alter;
+    }
+  });
+
+  // dist/data/utilities/databaseLock.js
+  var require_databaseLock = __commonJS({
+    "dist/data/utilities/databaseLock.js"(exports) {
+      "use strict";
+      init_process();
+      require_esnext_weak_map_delete_all();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.withDatabaseLock = exports.browserCallsRunning = void 0;
+      require_esnext_map_delete_all();
+      require_esnext_map_every();
+      require_esnext_map_filter();
+      require_esnext_map_find();
+      require_esnext_map_find_key();
+      require_esnext_map_includes();
+      require_esnext_map_key_of();
+      require_esnext_map_map_keys();
+      require_esnext_map_map_values();
+      require_esnext_map_merge();
+      require_esnext_map_reduce();
+      require_esnext_map_some();
+      require_esnext_map_update();
+      var jsEnv = _interopRequireWildcard(require_dist());
+      var _config = require_config();
+      var _storage = require_storage();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
+        }
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var queues = /* @__PURE__ */ new Map();
+      var browserCalls = 0;
+      var browserCallsRunning = () => browserCalls;
+      exports.browserCallsRunning = browserCallsRunning;
+      var withDatabaseLock = async (task) => {
+        if (!jsEnv.isNode) {
+          browserCalls++;
+          try {
+            return await (0, _storage.withReadCache)(task);
+          } finally {
+            browserCalls--;
+          }
+        }
+        const database = (0, _config.resolveDatabasePath)((0, _config.lockPath)());
+        const ended = (0, _config.trackDatabaseCall)();
+        const previous = queues.get(database) || Promise.resolve();
+        let release;
+        const turn = new Promise((resolve) => {
+          release = resolve;
+        });
+        const queued = previous.then(() => turn);
+        queues.set(database, queued);
+        await previous;
+        try {
+          return await (0, _storage.withReadCache)(task);
+        } finally {
+          ended();
+          release();
+          if (queues.get(database) === queued) {
+            queues.delete(database);
+          }
+        }
       };
-      exports.describeRecord = describeRecord;
+      exports.withDatabaseLock = withDatabaseLock;
     }
   });
 
-  // dist/data/queries/showRecords.js
-  var require_showRecords = __commonJS({
-    "dist/data/queries/showRecords.js"(exports) {
+  // dist/data/queries/databaseStatements.js
+  var require_databaseStatements = __commonJS({
+    "dist/data/queries/databaseStatements.js"(exports) {
       "use strict";
       init_process();
+      require_esnext_weak_map_delete_all();
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.showRecords = void 0;
+      exports.useDatabase = exports.showDatabases = exports.dropDatabase = exports.createDatabase = void 0;
+      require_es_array_includes();
       require_esnext_iterator_constructor();
-      require_esnext_iterator_map();
-      var _retrieveRecord = require_retrieveRecord();
-      var _recordExists = require_recordExists();
-      var showRecords = async () => {
-        if (!(0, _recordExists.recordExists)("__RECORDS")) {
-          return [];
+      require_esnext_iterator_filter();
+      var jsEnv = _interopRequireWildcard(require_dist());
+      var _config = require_config();
+      var _requireNode = require_requireNode();
+      var _databaseLock = require_databaseLock();
+      var _storage = require_storage();
+      var e;
+      function _interopRequireWildcard(t, r) {
+        if (!r && t && t.__esModule) return t;
+        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
+        if (Object(t) !== t) return f;
+        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
+          if (e.has(t)) return e.get(t);
+          e.set(t, f);
         }
-        return (await (0, _retrieveRecord.retrieveRecord)("__RECORDS")).entries.map((fileName) => fileName.replace(/\.json$/, ""));
+        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
+        return f;
+      }
+      var databaseExists = async (name) => (await (0, _storage.readDatabaseList)()).includes(name) || jsEnv.isNode && (0, _storage.databaseFolderExists)(name);
+      var createDatabase = async (name, ifNotExists = false) => {
+        (0, _requireNode.requireNode)('"create database"');
+        const listed = await (0, _storage.readDatabaseList)();
+        if (listed.includes(name) || (0, _storage.databaseFolderExists)(name)) {
+          if (!ifNotExists) {
+            throw new Error(listed.includes(name) ? `Database "${name}" already exists` : `Database "${name}" already exists as a folder that isn't listed: create database if not exists ${name} lists it`);
+          }
+          if (!listed.includes(name)) {
+            await (0, _storage.writeDatabaseList)([...listed, name]);
+          }
+          return null;
+        }
+        await (0, _storage.writeDatabaseList)([...listed, name]);
+        await (0, _storage.makeDatabaseFolder)(name);
+        return name;
       };
-      exports.showRecords = showRecords;
+      exports.createDatabase = createDatabase;
+      var dropDatabase = async (name, ifExists = false) => {
+        (0, _requireNode.requireNode)('"drop database"');
+        if (!await databaseExists(name)) {
+          if (ifExists) {
+            return null;
+          }
+          throw new Error(`Database "${name}" doesn't exist`);
+        }
+        if ((0, _config.getSetting)("database", void 0) === name) {
+          throw new Error(`Can't drop the database in use ("${name}"): use another one first`);
+        }
+        await (0, _storage.writeDatabaseList)((await (0, _storage.readDatabaseList)()).filter((listed) => listed !== name));
+        await (0, _storage.removeDatabaseFolder)(name);
+        return name;
+      };
+      exports.dropDatabase = dropDatabase;
+      var useDatabase = async (name) => {
+        if (!jsEnv.isNode && (0, _databaseLock.browserCallsRunning)() > 1) {
+          throw new Error(`Can't use "${name}" while other calls are running in this page: await them first, or pick the database with configure({ database }) between calls`);
+        }
+        if (!await databaseExists(name)) {
+          throw new Error(`Database "${name}" doesn't exist${jsEnv.isNode ? "" : " (or isn't listed in __DATABASES.json)"}`);
+        }
+        (0, _config.switchDatabase)(name);
+        return name;
+      };
+      exports.useDatabase = useDatabase;
+      var showDatabases = async () => (0, _storage.readDatabaseList)();
+      exports.showDatabases = showDatabases;
     }
   });
 
@@ -8824,7 +10669,7 @@ var jsonFsQuery = (() => {
       require_esnext_set_union();
       var _readEntity = require_readEntity();
       var _retrieveRecord = require_retrieveRecord();
-      var _retrieveFile = require_retrieveFile();
+      var _retrieveRecords = require_retrieveRecords();
       var _retrieveIndexes = require_retrieveIndexes();
       var _joinKey = require_joinKey();
       var _rowLookup = require_rowLookup();
@@ -8841,15 +10686,7 @@ var jsonFsQuery = (() => {
           }
         }
         const record = await (0, _retrieveRecord.retrieveRecord)(entity);
-        const rows = [];
-        for (const file of record.entries.filter((entry) => files.has(entry))) {
-          const data = await (0, _retrieveFile.retrieveFile)(`${record.path}/${file}`).catch((err) => console.error(err));
-          if (!data) {
-            throw new Error(`Could not read entity ${file}`);
-          }
-          rows.push(data);
-        }
-        return rows;
+        return (0, _retrieveRecords.retrieveEntryRows)(record, record.entries.filter((entry) => files.has(entry)));
       };
       var joinBases = async (entity, joinEntity, dataSets, steps, joinAlreadyResolved) => {
         const bases = /* @__PURE__ */ new Map();
@@ -9050,20 +10887,23 @@ var jsonFsQuery = (() => {
         value: true
       });
       exports.reconcileJoin = void 0;
+      require_es_json_stringify();
       require_esnext_iterator_constructor();
+      require_esnext_iterator_every();
+      require_esnext_iterator_find();
       require_esnext_iterator_for_each();
-      var _where = require_where();
+      var sameValue = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
       var reconcileJoin = (dataSet, entityName, entityKey, joinEntity, joinProp) => {
         const entity = dataSet[entityName][entityKey];
-        if (Object.prototype.hasOwnProperty.call(entity, joinEntity) && Array.isArray(entity[joinEntity])) {
-          entity[joinEntity].forEach((mergedEntity, k) => {
-            const matchedEntity = (0, _where.where)(dataSet[joinEntity], {
-              property: joinProp,
-              comparator: "=",
-              value: mergedEntity[joinProp]
-            });
-            if (matchedEntity.length) {
-              dataSet[entityName][entityKey][joinEntity][k] = matchedEntity[0];
+        if (Object.prototype.hasOwnProperty.call(entity, joinEntity) && Array.isArray(entity[joinEntity]) && Array.isArray(dataSet[joinEntity])) {
+          entity[joinEntity].forEach((joinedRow, k) => {
+            if (!joinedRow || !Object.prototype.hasOwnProperty.call(joinedRow, joinProp)) {
+              return;
+            }
+            const fields = Object.keys(joinedRow);
+            const mergedRow = dataSet[joinEntity].find((row) => fields.every((field) => sameValue(row[field], joinedRow[field])));
+            if (mergedRow) {
+              dataSet[entityName][entityKey][joinEntity][k] = mergedRow;
             }
           });
         }
@@ -9289,47 +11129,39 @@ var jsonFsQuery = (() => {
       require_esnext_iterator_constructor();
       require_esnext_iterator_map();
       require_esnext_iterator_reduce();
-      var shapeRow = (row, selectClauses) => selectClauses.reduce((shaped, {
+      var pick = (row, property, entity) => {
+        if (Object.prototype.hasOwnProperty.call(row, property) || typeof entity === "undefined" || !property.startsWith(`${entity}.`)) {
+          return row[property];
+        }
+        return row[property.slice(entity.length + 1)];
+      };
+      var shapeRow = (row, selectClauses, entity) => selectClauses.reduce((shaped, {
         property,
         alias
       }) => {
-        shaped[alias || property] = row[property];
+        shaped[alias || property] = pick(row, property, entity);
         return shaped;
       }, {});
-      var shapeGroup = (group, selectClauses) => group.groups ? {
+      var shapeGroup = (group, selectClauses, entity) => group.groups ? {
         ...group,
-        groups: group.groups.map((inner) => shapeGroup(inner, selectClauses))
+        groups: group.groups.map((inner) => shapeGroup(inner, selectClauses, entity))
       } : {
         ...group,
-        rows: group.rows.map((row) => shapeRow(row, selectClauses))
+        rows: group.rows.map((row) => shapeRow(row, selectClauses, entity))
       };
-      var selectFields = (dataSet = [], selectClauses = [], grouped = false) => {
+      var selectFields = (dataSet = [], selectClauses = [], grouped = false, entity) => {
         if (!selectClauses.length) {
           return dataSet;
         }
         if (grouped) {
-          return dataSet.map((group) => shapeGroup(group, selectClauses));
+          return dataSet.map((group) => shapeGroup(group, selectClauses, entity));
         }
-        return dataSet.map((row) => shapeRow(row, selectClauses));
+        return dataSet.map((row) => shapeRow(row, selectClauses, entity));
       };
       exports.selectFields = selectFields;
     }
   });
 
-  // dist/data/utilities/parsers/isEntityProperty.js
-  var require_isEntityProperty = __commonJS({
-    "dist/data/utilities/parsers/isEntityProperty.js"(exports) {
-      "use strict";
-      init_process();
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.isEntityProperty = void 0;
-      var isEntityProperty = (property) => /^[a-z0-9_-]+\.([a-z0-9_-]+)$/i.test(property);
-      exports.isEntityProperty = isEntityProperty;
-    }
-  });
-
   // dist/data/utilities/getConditionIndexedList.js
   var require_getConditionIndexedList = __commonJS({
     "dist/data/utilities/getConditionIndexedList.js"(exports) {
@@ -9363,6 +11195,7 @@ var jsonFsQuery = (() => {
       var _splitEntityProperty = require_splitEntityProperty();
       var _retrieveRecord = require_retrieveRecord();
       var _where = require_where();
+      var _retrieveRecords = require_retrieveRecords();
       var _retrieveFile = require_retrieveFile();
       var _retrieveIndexes = require_retrieveIndexes();
       var _isSingleFieldKey = require_isSingleFieldKey();
@@ -9445,10 +11278,8 @@ var jsonFsQuery = (() => {
         }
         for (const entity of Object.keys(matchedFiles)) {
           resolved.add(entity);
-          dataSet[entity] = [];
-          for (const file of matchedFiles[entity]) {
-            dataSet[entity].push(await (0, _retrieveFile.retrieveFile)(`${entity}/${file}`));
-          }
+          const record = recordData[entity] || await (0, _retrieveRecord.retrieveRecord)(entity);
+          dataSet[entity] = await (0, _retrieveRecords.retrieveEntryRows)(record, [...matchedFiles[entity]], _retrieveFile.retrieveFile);
         }
         return parsed;
       };
@@ -9563,6 +11394,8 @@ var jsonFsQuery = (() => {
       var _createRecord = require_createRecord();
       var _dropRecord = require_dropRecord();
       var _describeRecord = require_describeRecord();
+      var _alter = require_alter();
+      var _databaseStatements = require_databaseStatements();
       var _showRecords = require_showRecords();
       var _joinEntity = require_joinEntity();
       var _mergeJoins = require_mergeJoins();
@@ -9579,6 +11412,7 @@ var jsonFsQuery = (() => {
       var _conditionTree = require_conditionTree();
       var _conditionEntities = require_conditionEntities();
       var _requireNode = require_requireNode();
+      var _knownFields = require_knownFields();
       var typeClauses = async (parsed, recordData) => {
         for (const clause of [...(0, _conditionTree.conditionsOf)(parsed.where), ...parsed.sortClauses]) {
           let entity = parsed.entity;
@@ -9597,7 +11431,7 @@ var jsonFsQuery = (() => {
       };
       var runQuery = async (parsed) => {
         const perPair = typeof parsed.where !== "undefined" && (0, _conditionEntities.conditionEntities)(parsed);
-        if (["insert", "update", "delete", "create", "drop"].includes(parsed.command)) {
+        if (["insert", "update", "delete", "create", "drop", "alter"].includes(parsed.command)) {
           (0, _requireNode.requireNode)(`"${parsed.command}"`);
         }
         switch (parsed.command) {
@@ -9613,6 +11447,26 @@ var jsonFsQuery = (() => {
             return {
               [parsed.entity]: await (0, _describeRecord.describeRecord)(parsed.entity)
             };
+          case "alter":
+            return {
+              [parsed.entity]: await (0, _alter.alter)(parsed.entity, parsed.alter)
+            };
+          case "create database":
+            return {
+              [parsed.entity]: await (0, _databaseStatements.createDatabase)(parsed.entity, parsed.ifNotExists)
+            };
+          case "drop database":
+            return {
+              [parsed.entity]: await (0, _databaseStatements.dropDatabase)(parsed.entity, parsed.ifExists)
+            };
+          case "use":
+            return {
+              [parsed.entity]: await (0, _databaseStatements.useDatabase)(parsed.entity)
+            };
+          case "show databases":
+            return {
+              [parsed.entity]: await (0, _databaseStatements.showDatabases)()
+            };
           case "show":
             return {
               [parsed.entity]: await (0, _showRecords.showRecords)()
@@ -9624,6 +11478,7 @@ var jsonFsQuery = (() => {
         if (typeof parsed.joinEntity !== "undefined") {
           recordData[parsed.joinEntity] = await (0, _retrieveRecord.retrieveRecord)(parsed.joinEntity);
         }
+        await (0, _knownFields.assertKnownFields)(parsed, recordData);
         await typeClauses(parsed, recordData);
         let dataSet = {
           [parsed.entity]: []
@@ -9663,80 +11518,13 @@ var jsonFsQuery = (() => {
         dataSet[parsed.entity] = (0, _sortBy.sortBy)(dataSet[parsed.entity], parsed.sortClauses);
         dataSet[parsed.entity] = (0, _groupBy.groupBy)(dataSet[parsed.entity], parsed.groupBy);
         dataSet[parsed.entity] = (0, _limitOffset.limitOffset)(dataSet[parsed.entity], parsed.offset, parsed.limit);
-        dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses, Boolean(parsed.groupBy?.length));
+        dataSet[parsed.entity] = (0, _selectFields.selectFields)(dataSet[parsed.entity], parsed.selectClauses, Boolean(parsed.groupBy?.length), parsed.entity);
         return dataSet;
       };
       exports.runQuery = runQuery;
     }
   });
 
-  // dist/data/utilities/databaseLock.js
-  var require_databaseLock = __commonJS({
-    "dist/data/utilities/databaseLock.js"(exports) {
-      "use strict";
-      init_process();
-      require_esnext_weak_map_delete_all();
-      Object.defineProperty(exports, "__esModule", {
-        value: true
-      });
-      exports.withDatabaseLock = void 0;
-      require_esnext_map_delete_all();
-      require_esnext_map_every();
-      require_esnext_map_filter();
-      require_esnext_map_find();
-      require_esnext_map_find_key();
-      require_esnext_map_includes();
-      require_esnext_map_key_of();
-      require_esnext_map_map_keys();
-      require_esnext_map_map_values();
-      require_esnext_map_merge();
-      require_esnext_map_reduce();
-      require_esnext_map_some();
-      require_esnext_map_update();
-      var jsEnv = _interopRequireWildcard(require_dist());
-      var _config = require_config();
-      var _storage = require_storage();
-      var e;
-      function _interopRequireWildcard(t, r) {
-        if (!r && t && t.__esModule) return t;
-        var n, a, o = Object.defineProperty, f = { __proto__: null, default: t };
-        if (Object(t) !== t) return f;
-        if (e || "function" != typeof WeakMap || (e = /* @__PURE__ */ new WeakMap()), e) {
-          if (e.has(t)) return e.get(t);
-          e.set(t, f);
-        }
-        for (a in t) "default" !== a && {}.hasOwnProperty.call(t, a) && ((n = o && Object.getOwnPropertyDescriptor(t, a)) && (n.get || n.set) ? o(f, a, n) : f[a] = t[a]);
-        return f;
-      }
-      var queues = /* @__PURE__ */ new Map();
-      var withDatabaseLock = async (task) => {
-        if (!jsEnv.isNode) {
-          return (0, _storage.withReadCache)(task);
-        }
-        const database = (0, _config.resolveDatabasePath)((0, _config.getSetting)("databasePath", "database/"));
-        const ended = (0, _config.trackDatabaseCall)();
-        const previous = queues.get(database) || Promise.resolve();
-        let release;
-        const turn = new Promise((resolve) => {
-          release = resolve;
-        });
-        const queued = previous.then(() => turn);
-        queues.set(database, queued);
-        await previous;
-        try {
-          return await (0, _storage.withReadCache)(task);
-        } finally {
-          ended();
-          release();
-          if (queues.get(database) === queued) {
-            queues.delete(database);
-          }
-        }
-      };
-      exports.withDatabaseLock = withDatabaseLock;
-    }
-  });
-
   // dist/data/queries/query.js
   var require_query = __commonJS({
     "dist/data/queries/query.js"(exports) {
@@ -9749,12 +11537,13 @@ var jsonFsQuery = (() => {
       var _parser = require_parser();
       var _runQuery = require_runQuery();
       var _databaseLock = require_databaseLock();
+      var _storage = require_storage();
       var query = async (queryString = "") => {
         const parsedQueries = (0, _parser.parser)(queryString);
         return (0, _databaseLock.withDatabaseLock)(async () => {
           const queryResults = [];
           for (const parsed of parsedQueries) {
-            const dataSet = await (0, _runQuery.runQuery)(parsed);
+            const dataSet = await (0, _storage.withWriteSet)(() => (0, _runQuery.runQuery)(parsed));
             queryResults.push(dataSet[parsed.entity]);
           }
           return queryResults;
@@ -9827,6 +11616,150 @@ var jsonFsQuery = (() => {
     }
   });
 
+  // dist/data/introspect/formatDatabase.js
+  var require_formatDatabase = __commonJS({
+    "dist/data/introspect/formatDatabase.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.formatDatabase = void 0;
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      var _storage = require_storage();
+      var _config = require_config();
+      var _requireNode = require_requireNode();
+      var formatDatabase = async (format = (0, _config.getSetting)("format", "compact")) => {
+        (0, _requireNode.requireNode)("formatDatabase");
+        if (format !== "compact" && format !== "pretty") {
+          throw new Error(`Unknown format "${format}": use 'compact' or 'pretty'`);
+        }
+        const paths = (await (0, _storage.listFiles)()).filter((path) => path.endsWith(".json"));
+        const changes = [];
+        for (const path of paths) {
+          const text = await (0, _storage.readText)(path);
+          let content;
+          try {
+            content = JSON.parse(text);
+          } catch (error) {
+            throw new Error(`Could not format ${path}: ${error.message}`);
+          }
+          if ((0, _storage.jsonText)(content, format) !== text) {
+            changes.push({
+              path,
+              content
+            });
+          }
+        }
+        for (const {
+          path,
+          content
+        } of changes) {
+          await (0, _storage.writeJson)(path, content, format);
+        }
+        return {
+          files: paths.length,
+          rewritten: changes.length
+        };
+      };
+      exports.formatDatabase = formatDatabase;
+    }
+  });
+
+  // dist/data/introspect/packDatabase.js
+  var require_packDatabase = __commonJS({
+    "dist/data/introspect/packDatabase.js"(exports) {
+      "use strict";
+      init_process();
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.packDatabase = exports.checkPacked = void 0;
+      require_es_json_stringify();
+      require_esnext_iterator_constructor();
+      require_esnext_iterator_filter();
+      require_esnext_iterator_map();
+      require_esnext_set_add_all();
+      require_esnext_set_delete_all();
+      require_esnext_set_difference();
+      require_esnext_set_every();
+      require_esnext_set_filter();
+      require_esnext_set_find();
+      require_esnext_set_intersection();
+      require_esnext_set_is_disjoint_from();
+      require_esnext_set_is_subset_of();
+      require_esnext_set_is_superset_of();
+      require_esnext_set_join();
+      require_esnext_set_map();
+      require_esnext_set_reduce();
+      require_esnext_set_some();
+      require_esnext_set_symmetric_difference();
+      require_esnext_set_union();
+      var _storage = require_storage();
+      var _retrieveRecord = require_retrieveRecord();
+      var _retrieveFiles = require_retrieveFiles();
+      var _retrieveRecords = require_retrieveRecords();
+      var _packedTable = require_packedTable();
+      var _showRecords = require_showRecords();
+      var _requireNode = require_requireNode();
+      var packedText = async (name) => {
+        const record = await (0, _retrieveRecord.retrieveRecord)(name);
+        const entries = record.entries || [];
+        const rows = await (0, _retrieveFiles.retrieveFiles)(entries.map((file) => `${record.path}/${file}`), _retrieveRecords.retrieveEntry);
+        const packed = {
+          entries,
+          rows
+        };
+        return {
+          path: (0, _packedTable.packedPath)(record.path),
+          text: (0, _storage.jsonText)(packed, "compact"),
+          rows: entries.length
+        };
+      };
+      var orphanedPacks = async (names) => {
+        const expected = new Set(names.map((name) => (0, _packedTable.packedPath)(name)));
+        return (await (0, _storage.listFiles)("__packed")).filter((path) => !expected.has(path));
+      };
+      var packDatabase = async () => {
+        (0, _requireNode.requireNode)("packDatabase");
+        const names = await (0, _showRecords.showRecords)();
+        let rows = 0;
+        for (const name of names) {
+          const packed = await packedText(name);
+          await (0, _storage.makeDirectory)(packed.path.slice(0, packed.path.lastIndexOf("/")));
+          await (0, _storage.writeJson)(packed.path, JSON.parse(packed.text), "compact");
+          rows += packed.rows;
+        }
+        for (const path of await orphanedPacks(names)) {
+          await (0, _storage.removeFile)(path);
+        }
+        return {
+          records: names.length,
+          rows
+        };
+      };
+      exports.packDatabase = packDatabase;
+      var checkPacked = async () => {
+        (0, _requireNode.requireNode)("checkPacked");
+        const names = await (0, _showRecords.showRecords)();
+        const stale = [];
+        for (const name of names) {
+          const packed = await packedText(name);
+          const current = (0, _storage.fileExists)(packed.path) ? await (0, _storage.readText)(packed.path).catch(() => void 0) : void 0;
+          if (typeof current === "undefined" || JSON.stringify(JSON.parse(current)) !== packed.text) {
+            stale.push(name);
+          }
+        }
+        return {
+          stale,
+          orphaned: await orphanedPacks(names)
+        };
+      };
+      exports.checkPacked = checkPacked;
+    }
+  });
+
   // dist/data/introspect/index.js
   var require_introspect = __commonJS({
     "dist/data/introspect/index.js"(exports) {
@@ -9839,17 +11772,29 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
-      exports.drop = exports.describe = exports.create = void 0;
+      exports.packDatabase = exports.formatDatabase = exports.drop = exports.describe = exports.create = exports.checkPacked = exports.alter = void 0;
       var _create = require_create();
       var _drop = require_drop();
       var _describe = require_describe();
+      var _formatDatabase = require_formatDatabase();
+      var _alter = require_alter();
+      var _packDatabase = require_packDatabase();
       var _databaseLock = require_databaseLock();
-      var create = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _create.create)(...args));
+      var _storage = require_storage();
+      var create = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _create.create)(...args)));
       exports.create = create;
-      var drop = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _drop.drop)(...args));
+      var drop = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _drop.drop)(...args)));
       exports.drop = drop;
+      var alter = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _alter.alter)(...args)));
+      exports.alter = alter;
       var describe = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _describe.describe)(...args));
       exports.describe = describe;
+      var formatDatabase = (...args) => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _formatDatabase.formatDatabase)(...args)));
+      exports.formatDatabase = formatDatabase;
+      var packDatabase = () => (0, _databaseLock.withDatabaseLock)(() => (0, _storage.withWriteSet)(() => (0, _packDatabase.packDatabase)()));
+      exports.packDatabase = packDatabase;
+      var checkPacked = () => (0, _databaseLock.withDatabaseLock)(() => (0, _packDatabase.checkPacked)());
+      exports.checkPacked = checkPacked;
     }
   });
 
@@ -9864,6 +11809,18 @@ var jsonFsQuery = (() => {
       Object.defineProperty(exports, "__esModule", {
         value: true
       });
+      Object.defineProperty(exports, "alter", {
+        enumerable: true,
+        get: function() {
+          return _introspect.alter;
+        }
+      });
+      Object.defineProperty(exports, "checkPacked", {
+        enumerable: true,
+        get: function() {
+          return _introspect.checkPacked;
+        }
+      });
       Object.defineProperty(exports, "configure", {
         enumerable: true,
         get: function() {
@@ -9888,6 +11845,18 @@ var jsonFsQuery = (() => {
           return _introspect.drop;
         }
       });
+      Object.defineProperty(exports, "formatDatabase", {
+        enumerable: true,
+        get: function() {
+          return _introspect.formatDatabase;
+        }
+      });
+      Object.defineProperty(exports, "packDatabase", {
+        enumerable: true,
+        get: function() {
+          return _introspect.packDatabase;
+        }
+      });
       Object.defineProperty(exports, "query", {
         enumerable: true,
         get: function() {