@isaijs/core 0.1.6 → 0.1.9

package/dist/{make-ByA-84h8.js → make-D6_caNkv.js}

@@ -1,4 +1,4 @@
-import { U as systemClock, f as dayOf, h as snapshotOf, p as generateMigration, y as MigrationError } from "./migrator-B25prc9n.js";
+import { W as systemClock, f as dayOf, h as snapshotOf, p as generateMigration, y as MigrationError } from "./migrator-vvvKa0Vk.js";
 //#region src/db/migrations/cleanup.ts
 /** Dropped tables, those that refer to others first, so no row is left pointing at a dropped one. */
 function dropOrder(tables) {
@@ -88,10 +88,12 @@ function cleanupMigration(options) {
 *   tighten one, or add a check     a check data step: passes when no row breaks it, else a `fix`
 *   add a unique                    a resolution step before the index (duplicates as chosen)
 *   remove a unique                 retired until cleanup (an earlier release may rely on it)
+*   change a ref's onDelete or      a rebuild: the table and every table referencing it, copied
+*   table, or a table's storage     whole in one step (`operations.ts` → rebuild)
 *
 * Refused, each with the safe sequence: an incompatible kind change (or toggling `secret`), a field
 * becoming or ceasing to be kept by the database, a new required unique field over existing rows,
-* a rebuild (a ref's `onDelete`, an FK on an existing column), reusing a retired name.
+* reusing a retired name, a rebuild of tables that reference each other.
 */
 const pad = (n) => String(n).padStart(4, "0");
 const json = (value) => JSON.stringify(value);
@@ -299,13 +301,17 @@ function describeOperation(operation, tables) {
 			what: `add ${tables[operation.table]?.model ?? operation.table}.${operation.column.field}`,
 			how: "ADD COLUMN"
 		};
+		case "rebuild": return {
+			what: `rebuild ${operation.tables.map((table) => table.model).join(", ")}`,
+			how: "copies every row"
+		};
 		default: return {
 			what: operation.op,
 			how: ""
 		};
 	}
 }
-const slugOf = (operation) => operation.op === "createTable" ? `create_${operation.table.name}` : operation.op === "addColumn" ? `add_${operation.table}_${operation.column.name}` : operation.op;
+const slugOf = (operation) => operation.op === "createTable" ? `create_${operation.table.name}` : operation.op === "addColumn" ? `add_${operation.table}_${operation.column.name}` : operation.op === "rebuild" ? `rebuild_${operation.tables[0]?.name ?? "tables"}` : operation.op;
 /** A template literal holding SQL (no backtick or `${` is left live). */
 const literal = (text) => `\`${text.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")}\``;
 function structureSource(name, after, statements, day, framework) {
@@ -482,6 +488,18 @@ function makeMigrations(options) {
 /** The structure operations between two snapshots, for naming the step and the plan. */
 function snapshotOperations(previous, next) {
 	const operations = [];
+	const rebuilt = Object.values(next.tables).filter((table) => {
+		const before = previous.tables[table.name];
+		if (!before) return false;
+		const references = new Map(before.columns.map((c) => [c.name, JSON.stringify(c.references)]));
+		return Boolean(before.withoutRowid) !== Boolean(table.withoutRowid) || table.columns.some((c) => references.has(c.name) && references.get(c.name) !== JSON.stringify(c.references));
+	});
+	if (rebuilt.length > 0) operations.push({
+		op: "rebuild",
+		tables: rebuilt,
+		copy: {},
+		triggers: []
+	});
 	for (const table of Object.values(next.tables)) {
 		const before = previous.tables[table.name];
 		if (!before) {

package/dist/{makers-P9kg68C8.js → makers-DjkBP74P.js}

@@ -1,6 +1,6 @@
-import { K as Fake, q as fakeValue } from "./validation-Cppmd0RV.js";
-import { D as recordAction, E as forUpkeep, K as CheckFailed, S as clockOf, k as planInsert } from "./migrator-B25prc9n.js";
-import { I as fromBase64url, L as toBase64url, l as IMPLICIT_FIELDS, t as Model } from "./model-Dc3HunKb.js";
+import { J as Fake, Y as fakeValue } from "./validation-C3MCRBQO.js";
+import { D as recordAction, E as forUpkeep, S as clockOf, k as planInsert, q as CheckFailed } from "./migrator-vvvKa0Vk.js";
+import { I as fromBase64url, L as toBase64url, l as IMPLICIT_FIELDS, t as Model } from "./model-6pJBqqGd.js";
 //#region src/auth/roles.ts
 const same = (a, b) => a.length === b.length && a.every((value, i) => value === b[i]);
 /** What a role in `app.ts` is stored as. */

package/dist/{migrator-B25prc9n.js → migrator-vvvKa0Vk.js}

@@ -1,5 +1,5 @@
-import { G as ValidationError, M as id } from "./validation-Cppmd0RV.js";
-import { A as mapOperands, B as aroundDelete, F as unbound, H as aroundUpsert, I as fromBase64url$1, K as wrap, L as toBase64url, M as readsNow, N as readsOtherRows, O as storageOf, P as tableTotals, R as actionEntry, V as aroundUpdate, W as assertNotLog, _ as Expr, c as rowOf$1, h as Condition, i as columnNode, k as fieldsOf, l as IMPLICIT_FIELDS, n as assertNotEncrypted, o as fieldOf, r as columnName, v as Now, w as conditionNode, z as aroundCreate } from "./model-Dc3HunKb.js";
+import { P as id, q as ValidationError } from "./validation-C3MCRBQO.js";
+import { A as mapOperands, B as aroundDelete, F as unbound, H as aroundUpsert, I as fromBase64url$1, K as wrap, L as toBase64url, M as readsNow, N as readsOtherRows, O as storageOf, P as tableTotals, R as actionEntry, V as aroundUpdate, W as assertNotLog, _ as Expr, c as rowOf$1, h as Condition, i as columnNode, k as fieldsOf, l as IMPLICIT_FIELDS, n as assertNotEncrypted, o as fieldOf, r as columnName, v as Now, w as conditionNode, z as aroundCreate } from "./model-6pJBqqGd.js";
 import { r as ulid } from "./case-DpXlJCL9.js";
 import { t as NotImplementedError } from "./errors-mCNLlXg9.js";
 //#region src/db/errors.ts
@@ -814,13 +814,28 @@ function onConflict(model, conflict, writer) {
 	if ("fromInsert" in action) return `${target} DO UPDATE SET ${action.fromInsert.map((field) => `${column(model, field)} = excluded.${column(model, field)}`).join(", ")}`;
 	return `${target} DO UPDATE SET ${writer.set(action.set)}`;
 }
+/**
+* A select. With a limit, computed fields are worked out for the rows it returns only: an inner
+* query picks them (filtered, sorted, limited), and the outer one adds the computed values. SQLite
+* otherwise works out every select-list subquery for every matching row before it sorts (a page of
+* 24 products would price all 800 in their category), and each of those reads is billed. Not when
+* the order is by a computed value: the inner query couldn't sort by it.
+*/
 function select(model, query, context) {
 	return withinLimit(context, (mode) => {
 		const writer = new Writer(model, mode, context);
-		let text = `SELECT ${writer.selection()} FROM ${quote(model.table)}${writer.where(query.where)}`;
-		if (query.order.length > 0) text += ` ORDER BY ${query.order.map(({ field, direction }) => `${column(model, field)} ${direction.toUpperCase()}`).join(", ")}`;
-		if (query.limit !== void 0 || query.offset !== void 0) text += ` LIMIT ${writer.value(query.limit ?? -1)}`;
+		const table = quote(model.table);
+		const order = query.order.length > 0 ? ` ORDER BY ${query.order.map(({ field, direction }) => `${column(model, field)} ${direction.toUpperCase()}`).join(", ")}` : "";
+		const limited = query.limit !== void 0 || query.offset !== void 0;
+		const computed = Object.values(model.fields).some((spec) => spec.computed);
+		const sortsByComputed = query.order.some(({ field }) => model.fields[field]?.computed);
+		const selection = writer.selection();
+		const inner = limited && computed && !sortsByComputed;
+		let text = inner ? `SELECT * FROM ${table}` : `SELECT ${selection} FROM ${table}`;
+		text += writer.where(query.where) + order;
+		if (limited) text += ` LIMIT ${writer.value(query.limit ?? -1)}`;
 		if (query.offset !== void 0) text += ` OFFSET ${writer.value(query.offset)}`;
+		if (inner) text = `SELECT ${selection} FROM (${text}) AS ${table}${order}`;
 		return writer.sql(text);
 	});
 }
@@ -1037,7 +1052,23 @@ function columnDefinition(column) {
 	return definition;
 }
 function createTable(table) {
-	return `CREATE TABLE ${quote(table.name)} (${table.columns.map(columnDefinition).join(", ")})`;
+	const columns = table.columns.map(columnDefinition).join(", ");
+	return `CREATE TABLE ${quote(table.name)} (${columns})${table.withoutRowid ? " WITHOUT ROWID" : ""}`;
+}
+/** Where a rebuilt table's old rows wait while the new table is filled. */
+const aside = (table) => quote(`_isai_rebuild_${table}`);
+/** `operations.ts` → rebuild, in SQLite: one atomic step, its foreign keys checked at the end. */
+function rebuild(operation) {
+	const { tables, copy, triggers } = operation;
+	const columns = (table) => (copy[table] ?? []).map(quote).join(", ");
+	return [
+		"PRAGMA defer_foreign_keys = ON",
+		...triggers.map((name) => `DROP TRIGGER IF EXISTS ${quote(name)}`),
+		...tables.map((table) => `ALTER TABLE ${quote(table.name)} RENAME TO ${aside(table.name)}`),
+		...tables.map(createTable),
+		...tables.filter((table) => (copy[table.name] ?? []).length > 0).map((table) => `INSERT INTO ${quote(table.name)} (${columns(table.name)}) SELECT ${columns(table.name)} FROM ${aside(table.name)}`),
+		...[...tables].reverse().map((table) => `DROP TABLE ${aside(table.name)}`)
+	];
 }
 function createIndex(table, index) {
 	const columns = index.columns.map(quote).join(", ");
@@ -1229,6 +1260,7 @@ function render(operation) {
 		case "dropRule": return [`DROP ${operation.rule.kind.toUpperCase()} IF EXISTS ${quote(operation.rule.name)}`];
 		case "dropColumn": return [`ALTER TABLE ${quote(operation.table)} DROP COLUMN ${quote(operation.column.name)}`, ...dropCounter(operation.table, operation.column)];
 		case "dropTable": return [`DROP TABLE ${quote(operation.table.name)}`, ...operation.table.columns.flatMap((column) => dropCounter(operation.table.name, column))];
+		case "rebuild": return rebuild(operation);
 	}
 }
 //#endregion
@@ -1500,10 +1532,15 @@ var Engine = class Engine {
 };
 //#endregion
 //#region src/db/orm/include.ts
+/** How the boundary gives a query its `IncludeRule`: internal, so the app's API never shows it. */
+const withIncludeRule = Symbol("isai.withIncludeRule");
 /** The rows of `model` whose `field` is one of `values`. */
-async function rowsWhereIn(engine, model, field, values) {
+async function rowsWhereIn(engine, model, field, values, rule) {
 	const spec = fieldOf(model, field);
 	if (!spec) throw new TypeError(`isai: ${model.name} has no field "${field}"`);
+	if (values.length === 0) return [];
+	const allowed = rule ? await rule(model) : void 0;
+	if (allowed === false) return [];
 	const chunk = engine.driver.capabilities.maxBoundParams;
 	const found = [];
 	for (let start = 0; start < values.length; start += chunk) {
@@ -1513,7 +1550,7 @@ async function rowsWhereIn(engine, model, field, values) {
 			values: values.slice(start, start + chunk)
 		};
 		found.push(...await engine.read(model, {
-			where: [where],
+			where: allowed ? [where, allowed] : [where],
 			order: [{
 				field: "id",
 				direction: "asc"
@@ -1535,27 +1572,27 @@ function byHead(paths) {
 	}
 	return groups;
 }
-async function loadIncludes(engine, model, registry, rows, paths) {
+async function loadIncludes(engine, model, registry, rows, paths, rule) {
 	if (rows.length === 0 || paths.length === 0) return;
 	for (const [head, tails] of byHead(paths)) {
 		const ref = fieldOf(model, head)?.ref;
 		if (ref) {
 			const target = registry.get(ref.model);
-			const found = await rowsWhereIn(engine, target, "id", [...new Set(rows.map((row) => row[head]).filter((id) => id !== null && id !== void 0))]);
-			await loadIncludes(engine, target, registry, found, tails);
+			const found = await rowsWhereIn(engine, target, "id", [...new Set(rows.map((row) => row[head]).filter((id) => id !== null && id !== void 0))], rule);
+			await loadIncludes(engine, target, registry, found, tails, rule);
 			const byId = new Map(found.map((row) => [row.id, row]));
 			for (const row of rows) row[head] = row[head] === null ? null : byId.get(row[head]) ?? null;
 			continue;
 		}
 		const relation = registry.relation(model.name, head);
 		if (!relation) throw new TypeError(`isai: ${model.name} has no ref or relation named "${head}"`);
-		const found = await rowsWhereIn(engine, relation.model, relation.field, rows.map((row) => row.id));
+		const found = await rowsWhereIn(engine, relation.model, relation.field, rows.map((row) => row.id), rule);
 		const groups = /* @__PURE__ */ new Map();
 		for (const row of found) {
 			const owner = row[relation.field];
 			groups.set(owner, [...groups.get(owner) ?? [], row]);
 		}
-		await loadIncludes(engine, relation.model, registry, found, tails);
+		await loadIncludes(engine, relation.model, registry, found, tails, rule);
 		for (const row of rows) row[head] = groups.get(row.id) ?? [];
 	}
 }
@@ -1707,15 +1744,21 @@ var Query = class Query {
 	target;
 	query;
 	paths;
+	rule;
 	constructor(engine, target, query = {
 		where: [],
 		order: [],
 		limit: void 0
-	}, paths = []) {
+	}, paths = [], rule) {
 		this.engine = engine;
 		this.target = target;
 		this.query = query;
 		this.paths = paths;
+		this.rule = rule;
+	}
+	/** The same query, its includes held to `rule` (the boundary's; `./include`). */
+	[withIncludeRule](rule) {
+		return new Query(this.engine, this.target, this.query, this.paths, rule);
 	}
 	/** Repeated calls are ANDed. */
 	where(build) {
@@ -1739,7 +1782,7 @@ var Query = class Query {
 	}
 	/** Loads related rows: refs in place of their ids, relations as lists (`"fest"`, `"registrations.members"`). */
 	include(...paths) {
-		return new Query(this.engine, this.target, this.query, [...this.paths, ...paths]);
+		return new Query(this.engine, this.target, this.query, [...this.paths, ...paths], this.rule);
 	}
 	async all() {
 		return this.fetch({
@@ -1843,7 +1886,7 @@ var Query = class Query {
 		return this.withIncludes(await this.engine.read(this.target.spec, query));
 	}
 	async withIncludes(rows) {
-		await loadIncludes(this.engine, this.target.spec, this.target.registry, rows, this.paths);
+		await loadIncludes(this.engine, this.target.spec, this.target.registry, rows, this.paths, this.rule);
 		return rows;
 	}
 	/** The first row (by the query's order), or `undefined`. */
@@ -1870,7 +1913,7 @@ var Query = class Query {
 		return new Query(this.engine, this.target, {
 			...this.query,
 			...change
-		}, this.paths);
+		}, this.paths, this.rule);
 	}
 };
 /** Kinds a group key may be: never free text. */
@@ -2077,7 +2120,7 @@ function planInsert(model, input, now) {
 * A patch as assignments. A value is read through its kind; a function is an SQL expression over
 * the stored row (`(v) => v.stock.minus(2)`), which only the database can compute (and guard).
 */
-function planUpdate(model, registry, patch, now, touch = true) {
+function planUpdate(model, registry, patch, now, upkeep = false) {
 	const issues = [];
 	rejectUnknown(model, patch, /* @__PURE__ */ new Set(), issues);
 	const values = {};
@@ -2085,7 +2128,7 @@ function planUpdate(model, registry, patch, now, touch = true) {
 	for (const [field, raw] of Object.entries(patch)) {
 		const spec = fieldOf(model, field);
 		if (!spec || spec.computed || spec.maintained || MANAGED$1.has(field) || raw === void 0) continue;
-		if (spec.fixed) {
+		if (spec.fixed && !upkeep) {
 			issues.push({
 				path: [field],
 				code: "fixed",
@@ -2105,10 +2148,10 @@ function planUpdate(model, registry, patch, now, touch = true) {
 	if (issues.length > 0) throw new ValidationError(issues, { model: model.name });
 	runChecks(model, values, now);
 	return {
-		values: touch ? {
+		values: upkeep ? values : {
 			...values,
 			updatedAt: now
-		} : values,
+		},
 		expressions
 	};
 }
@@ -2164,7 +2207,7 @@ function planUpsertOne(engine, target, key, options, context) {
 		...options.create,
 		...key
 	}, context.now);
-	const set = options.update && planUpdate(target.spec, target.registry, options.update, context.now, !engine.upkeep);
+	const set = options.update && planUpdate(target.spec, target.registry, options.update, context.now, engine.upkeep);
 	const statements = async () => {
 		const action = set ? { set: {
 			...set,
@@ -2183,7 +2226,7 @@ function planUpsertOne(engine, target, key, options, context) {
 }
 function planUpdateWhere(engine, target, patch, where, context, returning) {
 	assertNotLog(target.spec);
-	const assignments = planUpdate(target.spec, target.registry, patch, context.now, !engine.upkeep);
+	const assignments = planUpdate(target.spec, target.registry, patch, context.now, engine.upkeep);
 	return async () => {
 		const values = await engine.seal(target.spec, assignments.values);
 		return wrap(aroundUpdate(engine, target, where, context), [engine.dialect.update(target.spec, {
@@ -2885,7 +2928,6 @@ var UnsafeMigration = class extends Error {
 const COPY = "add a new field, copy the values in a data step, then remove the old one";
 const KEPT = "add a new field; the database fills it, then remove the old one";
 const PLAIN = "add a plain field, copy the values in a data step, then remove the old one";
-const REBUILD = "it needs a table rebuild, which isn't supported yet; add a new field instead";
 const CLEANUP = "pick another name, or drop the retired one first with `isai cleanup`";
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 /** Why a column can't stay as it is when its field changes, and what to do instead; undefined when it can. */
@@ -2905,9 +2947,88 @@ function columnChange(before, after) {
 		change: `it's no longer kept by the database (${before.maintained})`,
 		advice: PLAIN
 	};
-	if (!same(before.references, after.references)) return {
-		change: before.references && after.references && before.references.table === after.references.table ? `its onDelete changed from ${before.references.onDelete} to ${after.references.onDelete}` : "its reference changed",
-		advice: REBUILD
+}
+/** Every table in the database under a schema: live ones with their retired columns, and retired tables. */
+function physicalTables(schema, alsoRetired = []) {
+	const retired = [...schema.retired, ...alsoRetired];
+	const tables = /* @__PURE__ */ new Map();
+	for (const table of Object.values(schema.tables)) {
+		const gone = retired.flatMap((r) => r.kind === "column" && r.table === table.name ? [r.column] : []);
+		tables.set(table.name, {
+			table,
+			columns: [...table.columns, ...gone]
+		});
+	}
+	for (const r of retired) if (r.kind === "table" && !tables.has(r.table.name)) tables.set(r.table.name, {
+		table: r.table,
+		columns: r.table.columns
+	});
+	return tables;
+}
+const referenced = (columns) => new Set(columns.flatMap((c) => c.references ? [c.references.table] : []));
+/**
+* The rebuild these schemas need, if any: the tables whose storage or a reference changed, with
+* every table that references one of them (live or retired, before or after), so no foreign key is
+* left pointing at a table that was dropped (`operations.ts` → rebuild).
+*/
+function rebuildOf(previous, next, retiredNow, unsafe) {
+	const before = physicalTables(previous);
+	const after = physicalTables({
+		...next,
+		retired: previous.retired
+	}, retiredNow);
+	const roots = Object.values(next.tables).filter((table) => {
+		const was = previous.tables[table.name];
+		if (!was) return false;
+		if (Boolean(was.withoutRowid) !== Boolean(table.withoutRowid)) return true;
+		const references = new Map(was.columns.map((c) => [c.name, c.references]));
+		return table.columns.some((c) => references.has(c.name) && !same(references.get(c.name), c.references));
+	});
+	if (roots.length === 0) return void 0;
+	const members = new Set(roots.map((table) => table.name));
+	for (let grew = true; grew;) {
+		grew = false;
+		for (const [name, table] of after) {
+			if (members.has(name) || !before.has(name)) continue;
+			if ([.../* @__PURE__ */ new Set([...referenced(table.columns), ...referenced(before.get(name)?.columns ?? [])])].some((ref) => members.has(ref))) {
+				members.add(name);
+				grew = true;
+			}
+		}
+	}
+	const ordered = [];
+	const pending = new Set(members);
+	while (pending.size > 0) {
+		const ready = [...pending].filter((name) => [...referenced(after.get(name)?.columns ?? [])].every((ref) => ref === name || !pending.has(ref)));
+		if (ready.length === 0) {
+			const tables = [...pending].sort();
+			unsafe.push({
+				model: after.get(tables[0] ?? "")?.table.model ?? "",
+				change: `its table is rebuilt, and ${tables.join(", ")} reference each other`,
+				advice: "break the cycle (make one of the refs a plain field) before the change that rebuilds them"
+			});
+			return;
+		}
+		for (const name of ready.sort()) {
+			ordered.push(name);
+			pending.delete(name);
+		}
+	}
+	const tables = ordered.map((name) => {
+		const { table, columns } = after.get(name);
+		return {
+			...table,
+			columns
+		};
+	});
+	return {
+		op: "rebuild",
+		tables,
+		copy: Object.fromEntries(tables.map((table) => {
+			const had = new Set(before.get(table.name)?.columns.map((c) => c.name));
+			return [table.name, table.columns.flatMap((c) => had.has(c.name) ? [c.name] : [])];
+		})),
+		triggers: []
 	};
 }
 /** A dropped column and an added one of the same kind, in one model: probably a rename. */
@@ -2998,12 +3119,18 @@ function diff(previous, next, since) {
 			index
 		});
 	}
+	const rebuild = rebuildOf(previous, next, retired, unsafe);
 	if (unsafe.length > 0) throw new UnsafeMigration(unsafe);
+	const rebuilt = new Set(rebuild?.tables.map((table) => table.name));
 	return {
-		operations: [...created.map((table) => ({
-			op: "createTable",
-			table
-		})), ...addColumns],
+		operations: [
+			...rebuild ? [rebuild] : [],
+			...created.map((table) => ({
+				op: "createTable",
+				table
+			})),
+			...addColumns.filter((operation) => operation.op !== "addColumn" || !rebuilt.has(operation.table))
+		],
 		retired,
 		renames
 	};
@@ -3154,7 +3281,15 @@ function tableOf(spec, registry, tables) {
 			unique: true
 		};
 	});
-	const refIndexes = columns.filter((c) => c.references && !uniques.some((u) => u.columns[0] === c.name)).map((c) => ({
+	const declared = spec.indexes.map((index) => {
+		const columns = index.fields.map(column);
+		return {
+			name: `${spec.table}_${columns.join("_")}_index`,
+			columns,
+			unique: false
+		};
+	});
+	const refIndexes = columns.filter((c) => c.references && ![...uniques, ...declared].some((index) => index.columns[0] === c.name)).map((c) => ({
 		name: `${spec.table}_${c.name}_index`,
 		columns: [c.name],
 		unique: false
@@ -3169,7 +3304,11 @@ function tableOf(spec, registry, tables) {
 		name: spec.table,
 		model: spec.name,
 		columns,
-		indexes: [...uniques, ...refIndexes],
+		indexes: [
+			...uniques,
+			...declared,
+			...refIndexes
+		],
 		guards: [...checks, ...limitGuards(spec)],
 		counts: countsOf(spec, registry),
 		copies: copiesOf(spec, registry),
@@ -3177,7 +3316,8 @@ function tableOf(spec, registry, tables) {
 			field,
 			column: columnName(field, fieldSpec),
 			transitions: fieldSpec.flow
-		}] : [])
+		}] : []),
+		withoutRowid: true
 	};
 }
 function snapshotOf(models) {
@@ -3209,7 +3349,11 @@ function generateMigration(options) {
 	const { previous, dialect, name, clock = systemClock } = options;
 	const live = snapshotOf(options.models);
 	const { operations, retired, renames } = diff(previous, live, dayOf(clock.now()));
-	const statements = operations.flatMap((operation) => dialect.render(operation));
+	const triggers = dialect.migrations.rules(previous).flatMap((rule) => rule.kind === "trigger" ? [rule.name] : []);
+	const statements = operations.map((operation) => operation.op === "rebuild" ? {
+		...operation,
+		triggers
+	} : operation).flatMap((operation) => dialect.render(operation));
 	const last = statements.length > 0 ? name : previous.last;
 	const stillRetired = previous.retired.filter((r) => r.kind !== "index" || !live.tables[r.table]?.indexes.some((index) => index.name === r.index.name));
 	const snapshot = {
@@ -3605,4 +3749,4 @@ async function migrateFresh(driver, models, options = {}) {
 	await sync(driver, manifest, options);
 }
 //#endregion
-export { planUpdate as A, NeedsDatabase as B, database as C, recordAction as D, forUpkeep as E, dialectFor as F, newSecretKey as G, fixedClock as H, sqlite as I, NotFound as J, CheckFailed as K, PLATFORM as L, Query as M, conditionOf as N, withTableTotals as O, modelOfRow as P, TENANT as R, clockOf as S, driverOf as T, systemClock as U, evaluate as V, utc as W, UniqueFailed as X, ReferenceFailed as Y, TODO as _, currentRelease as a, Database as b, rollback as c, applyRules as d, dayOf as f, UnsafeMigration as g, snapshotOf as h, acquireLock as i, keyCondition as j, planInsert as k, setReleaseStatus as l, emptySnapshot as m, migrateFresh as n, holdOf as o, generateMigration as p, DatabaseError as q, sync as r, releaseLock as s, migrate as t, startRelease as u, dataStep as v, decodeStored as w, Transaction as x, MigrationError as y, checkTenancy as z };
+export { planUpdate as A, checkTenancy as B, database as C, recordAction as D, forUpkeep as E, modelOfRow as F, utc as G, evaluate as H, dialectFor as I, DatabaseError as J, newSecretKey as K, sqlite as L, Query as M, conditionOf as N, withTableTotals as O, withIncludeRule as P, PLATFORM as R, clockOf as S, driverOf as T, fixedClock as U, NeedsDatabase as V, systemClock as W, ReferenceFailed as X, NotFound as Y, UniqueFailed as Z, TODO as _, currentRelease as a, Database as b, rollback as c, applyRules as d, dayOf as f, UnsafeMigration as g, snapshotOf as h, acquireLock as i, keyCondition as j, planInsert as k, setReleaseStatus as l, emptySnapshot as m, migrateFresh as n, holdOf as o, generateMigration as p, CheckFailed as q, sync as r, releaseLock as s, migrate as t, startRelease as u, dataStep as v, decodeStored as w, Transaction as x, MigrationError as y, TENANT as z };

package/dist/{model-Dc3HunKb.js → model-6pJBqqGd.js}

@@ -1,4 +1,4 @@
-import { A as fakeUlid, C as text, D as choice, E as url, F as quantity, I as sequence, M as id, N as int, O as date, P as money, R as list, S as subdomain, T as token, W as kind, _ as newToken, a as file, b as slug, c as image, d as json, f as urls, g as markdown, h as line, j as flag, k as datetime, l as images, n as phoneKind, p as email, s as files, u as define, v as personName, w as textKind, x as slugify, y as secret } from "./validation-Cppmd0RV.js";
+import { A as date, B as list, C as slugify, D as token, E as textKind, F as int, I as money, K as kind, L as quantity, M as fakeUlid, N as flag, O as url, P as id, R as sequence, S as slug, T as text, _ as line, a as document, b as personName, d as images, f as define, h as email, j as datetime, k as choice, l as files, m as urls, n as phoneKind, o as documents, p as json, s as file, u as image, v as markdown, w as subdomain, x as secret, y as newToken } from "./validation-C3MCRBQO.js";
 import { n as snakeCase, r as ulid } from "./case-DpXlJCL9.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/internal/scope.ts
@@ -920,6 +920,10 @@ function fieldKinds(defaults) {
 		image: (options = {}) => field(image(options), "json"),
 		files: (options = {}) => field(files(options), "json"),
 		images: (options = {}) => field(images(options), "json"),
+		/** A PDF or image to print or read whole (never resized), up to 100 MB; `{ storage }` as for `file`. */
+		document: (options = {}) => field(document(options), "json"),
+		/** Up to 100 documents: an order's files. */
+		documents: (options = {}) => field(documents(options), "json"),
 		/** A row of another model, by its id. Restricts deletes of that row unless `.cascade()` / `.setNull()`. */
 		ref: (model, options = {}) => new Field(fieldSpec(id(`a ${model} id`), "text", { ref: {
 			model,
@@ -1091,6 +1095,31 @@ var Model = class Model {
 		});
 	}
 	/**
+	* An index on these fields, in this order, for the lists the app runs: a list sorted by a field
+	* (`.index("createdAt")`), or filtered by one field then sorted by another
+	* (`.index("status", "createdAt")`). Refs index themselves, and traits bring the indexes their
+	* behaviour needs (`publishable`: `publishedAt`; `ordered`: its group, then `position`), so most
+	* models never call it. `isai check` warns when a resource sorts by a field no index leads with.
+	* Each index costs a row written on every insert, and on each update of its fields.
+	*/
+	index(...fields) {
+		const name = this.spec.name;
+		if (fields.length === 0) throw new TypeError(`isai: ${name}.index() takes one or more fields`);
+		if (new Set(fields).size !== fields.length) throw new TypeError(`isai: ${name}.index() lists a field twice`);
+		for (const field of fields) {
+			const spec = this.spec.fields[field];
+			if (!spec || spec.computed) throw new TypeError(`isai: ${name}.index() lists "${field}", which isn't one of ${name}'s stored fields`);
+			assertNotEncrypted(this.spec, field, "indexed");
+		}
+		const key = fields.join(",");
+		if (this.spec.indexes.some((index) => index.fields.join(",") === key)) throw new TypeError(`isai: ${name} already has an index on ${fields.join(", ")}`);
+		if (this.spec.uniques.some((unique) => unique.fields.join(",") === key)) throw new TypeError(`isai: ${name} already has a unique on ${fields.join(", ")}, which is an index too`);
+		return this.derive({
+			...this.spec,
+			indexes: [...this.spec.indexes, { fields }]
+		});
+	}
+	/**
 	* The table it's stored in, when that isn't its name in snake_case: after the model was renamed,
 	* so the data stays where it is (`model("Squad", {…}).table("team")`). Physical renames never happen.
 	*/
@@ -1302,6 +1331,7 @@ function defineModel(registry, name, declared, traits = [], origin = {}) {
 		table: snakeCase(name),
 		fields: withCopyPaths(name, specs, registry, () => spec),
 		uniques,
+		indexes: traits.flatMap((trait) => (trait.spec.indexes ?? []).map((fields) => ({ fields }))),
 		checks: [],
 		traits: names,
 		...origin.database === void 0 ? {} : { database: origin.database },

package/dist/{policies-KsqmlX67.js → policies-C_oiSgmY.js}

@@ -1,4 +1,4 @@
-import { G as isRecorded, _ as Expr, c as rowOf, h as Condition, j as nodesOf, r as columnName, w as conditionNode } from "./model-Dc3HunKb.js";
+import { G as isRecorded, _ as Expr, c as rowOf, h as Condition, j as nodesOf, r as columnName, w as conditionNode } from "./model-6pJBqqGd.js";
 //#region src/auth/enforce.ts
 /**
 * Checking a policy: its action's condition, with the

package/dist/{resource-BQK7bkPQ.js → resource-DCg6LvMH.js}

@@ -1,7 +1,7 @@
-import { G as ValidationError, H as validate, V as toKind, z as object } from "./validation-Cppmd0RV.js";
-import { J as NotFound, K as CheckFailed, X as UniqueFailed, Y as ReferenceFailed } from "./migrator-B25prc9n.js";
-import { C as asCondition, _ as Expr, g as Embed, l as IMPLICIT_FIELDS, r as columnName, s as computedFieldOf } from "./model-Dc3HunKb.js";
-import { r as actionsOf } from "./policies-KsqmlX67.js";
+import { U as toKind, V as object, W as validate, q as ValidationError } from "./validation-C3MCRBQO.js";
+import { X as ReferenceFailed, Y as NotFound, Z as UniqueFailed, q as CheckFailed } from "./migrator-vvvKa0Vk.js";
+import { C as asCondition, _ as Expr, g as Embed, l as IMPLICIT_FIELDS, r as columnName, s as computedFieldOf } from "./model-6pJBqqGd.js";
+import { r as actionsOf } from "./policies-C_oiSgmY.js";
 import { n as RESERVED, t as LOOKUPS } from "./syntax-CrUZFrS7.js";
 //#region src/api/fail.ts
 /**
@@ -199,13 +199,15 @@ var Route = class {
 	anonymous;
 	handler;
 	platform;
-	constructor(method, path, input, anonymous, handler, platform = false) {
+	upload;
+	constructor(method, path, input, anonymous, handler, platform = false, upload) {
 		this.method = method;
 		this.path = path;
 		this.input = input;
 		this.anonymous = anonymous;
 		this.handler = handler;
 		this.platform = platform;
+		this.upload = upload;
 	}
 };
 function declare(method) {
@@ -214,7 +216,7 @@ function declare(method) {
 		const handler = typeof second === "function" ? second : third;
 		if (!handler) throw new TypeError(`isai: ${method} ${path} has no handler`);
 		if (!path.startsWith("/")) throw new TypeError(`isai: a route's path starts with "/" (${method} ${path})`);
-		return new Route(method, path, options.input ?? {}, options.anonymous ?? false, handler, options.platform ?? false);
+		return new Route(method, path, options.input ?? {}, options.anonymous ?? false, handler, options.platform ?? false, options.upload);
 	}
 	return define;
 }

package/dist/{tables-DgSwge7s.js → tables-DjW96Ubl.js}

@@ -1,4 +1,4 @@
-import { a as defineModel, t as Model } from "./model-Dc3HunKb.js";
+import { a as defineModel, t as Model } from "./model-6pJBqqGd.js";
 //#region src/db/schema/builtins.ts
 /**
 * Built-in tables: sets of models a part of isai owns, switched on

package/dist/testing/index.d.ts

@@ -1,5 +1,5 @@
 import { a as DatabaseDriver, g as Storage } from "../index-Ce5p2-EB.js";
-import { I as Clock, L as FixedClock, R as fixedClock, V as AnyModel, i as Row, l as Overrides, p as Database, s as Makers, u as Seed } from "../types-BgOkJy5d.js";
+import { I as Clock, L as FixedClock, R as fixedClock, V as AnyModel, i as Row, l as Overrides, p as Database, s as Makers, u as Seed } from "../types-D5SIVeej.js";
 //#region src/testing/conformance/database.d.ts
 /**
  * Makes the driver under test. Every call must return a driver on an **empty** database:

package/dist/testing/index.js

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
-import { F as dialectFor, H as fixedClock, L as PLATFORM, R as TENANT, W as utc, a as currentRelease, b as Database, c as rollback, i as acquireLock, j as keyCondition, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, o as holdOf, p as generateMigration, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, y as MigrationError } from "../migrator-B25prc9n.js";
-import { L as toBase64url, t as Model } from "../model-Dc3HunKb.js";
-import { t as createDataLayer } from "../data-layer-C5oJZ8V1.js";
-import { d as forgetGoogleKeys, r as authOf, s as GOOGLE, t as makers, y as seedAs } from "../makers-P9kg68C8.js";
+import { G as utc, I as dialectFor, R as PLATFORM, U as fixedClock, a as currentRelease, b as Database, c as rollback, i as acquireLock, j as keyCondition, l as setReleaseStatus, m as emptySnapshot, n as migrateFresh, o as holdOf, p as generateMigration, r as sync, s as releaseLock, t as migrate, u as startRelease, v as dataStep, y as MigrationError, z as TENANT } from "../migrator-vvvKa0Vk.js";
+import { L as toBase64url, t as Model } from "../model-6pJBqqGd.js";
+import { t as createDataLayer } from "../data-layer-BOVkYESH.js";
+import { d as forgetGoogleKeys, r as authOf, s as GOOGLE, t as makers, y as seedAs } from "../makers-DjkBP74P.js";
 import { describe, expect, it } from "vitest";
 //#region src/testing/conformance/database.ts
 /**