lecodes-sdk 2.0.7 → 2.0.9

package/src/server/db/fields.ts

@@ -7,9 +7,10 @@
  */
 
 import type { JsonValue } from "./marci/query"
+import type { StoredFile, StoredImage } from "../files/models"
 
 export type ScalarKind = "string" | "int" | "float" | "bool" | "date" | "uuid" | ""
-export type FieldKind = "scalar" | "json" | "enum" | "struct" | "one" | "many" | "list"
+export type FieldKind = "scalar" | "json" | "enum" | "struct" | "one" | "many" | "list" | "file"
 export type OnDelete = "cascade" | "setNull" | "restrict"
 
 /** Phantom metadata — the type-level twin of `FieldDef`. */
@@ -48,6 +49,8 @@ export type FieldDef = {
   fields?: Record<string, Field<any, any>>
   /** one / many / list */
   model?: string
+  /** file: a picture (`t.image()`) — `max` is the most its longer side may be, px. */
+  image?: { max: number }
   /** many: the field on the related model that holds the reference (`@bind`); resolved by defineDb when omitted. */
   back?: string
 }
@@ -126,6 +129,23 @@ export const t = {
   /** Reverse side of a `t.one()` on `model` (the field is inferred when unambiguous). Read-only list. */
   many:   <N extends string>(model: N, backField?: string) =>
             create<never, Meta<{ kind: "many", model: N }>>(base("many", { model, back: backField })),
+  /**
+   * A stored file: written as a `File` (an upload — an endpoint's parameter), read as
+   * `{ url, name, type, size, width?, height? }`. `.optional()` = may be empty, `.array()` = an ordered
+   * list of files. It is deleted with its row — or when the field is given another file, or `null`.
+   */
+  file:   () => create<StoredFile, Meta<{ kind: "file" }>>(base("file")),
+  /**
+   * A stored PICTURE — a `t.file()` that takes images only and keeps them fit to show: turned the way
+   * the camera meant, without its metadata (a photo's place and time), as WebP, and no larger than
+   * `max` px on its longer side (2048 when not said; a picture is never enlarged).
+   * Read as a `StoredFile` whose `width` and `height` are always there. A GIF is kept as it is.
+   */
+  image:  (options: { max?: number } = {}) => {
+    const max = options.max ?? 2048
+    if (!Number.isInteger(max) || max < 1) throw new Error(`t.image({ max }): a whole number of pixels is expected, got ${max}`)
+    return create<StoredImage, Meta<{ kind: "file" }>>(base("file", { image: { max } }))
+  },
   /** Ordered relation list stored inline (`@list`) — hand-arranged collections, duplicates allowed. */
   list:   <N extends string>(model: N) => create<never, Meta<{ kind: "list", model: N }>>(base("list", { model })),
 }

package/src/server/db/httpTransport.ts

@@ -69,7 +69,7 @@ export const marciRequest = async (
 
 export const marciHttpTransport = (baseUrl: string, options: MarciHttpOptions = {}): MarciTransport => {
   const url = baseUrl.replace(/\/+$/, "")
-  const call = (path: string, body?: unknown) => marciRequest(`${url}/${path}`, { body, token: options.token, fetch: options.fetch })
+  const call = (path: string, body?: unknown, method?: string) => marciRequest(`${url}/${path}`, { body, method, token: options.token, fetch: options.fetch })
   return {
     exec(op: MarciOp) {
       switch (op.action) {
@@ -83,6 +83,14 @@ export const marciHttpTransport = (baseUrl: string, options: MarciHttpOptions =
         case "deleteMany": return call(`${op.model}/deleteMany`, op.query ?? {})
         case "count":      return call(`${op.model}/count`, op.query ?? {})
         case "aggregate":  return call(`${op.model}/aggregate`, op.query ?? {})
+        // a journal of the model's changes: create, read (`after` confirms), drop
+        case "$journalOpen": return call(`${op.model}/$journal/${op.journal!.name}`, { on: op.journal!.on })
+        case "$journalRead": {
+          const { name, after, limit, wait } = op.journal!
+          const params = [after !== undefined && `after=${after}`, limit !== undefined && `limit=${limit}`, wait && `wait=${wait}`].filter(Boolean).join("&")
+          return call(`${op.model}/$journal/${name}${params ? "?" + params : ""}`, undefined, "GET")
+        }
+        case "$journalDrop": return call(`${op.model}/$journal/${op.journal!.name}`, undefined, "DELETE")
         default: return Promise.reject(new Error(`marcidb: unknown action '${op.action}'`))
       }
     },

package/src/server/db/marci/query.ts

@@ -7,7 +7,7 @@
 // per-model type bags and MODELS metadata this file is parametrised by.
 //
 // Keep it dependency-free: besides shipping in `marcidb-client/runtime`, this file is vendored verbatim
-// into the lecodes SDK (`sdk/src/server/db/marci/query.ts`, `bun run sync:marcidb` there), which
+// into the lecodes SDK (`packages/sdk/src/server/db/marci/query.ts`, `bun run sync:marcidb` there), which
 // derives its model types from TS builders instead of codegen and plugs them into the same generics.
 
 // ───────────────────────────── query language types ─────────────────────────────
@@ -177,7 +177,9 @@ export type Op<T> = PromiseLike<T> & { readonly [__op]: T }
 
 // A transport-neutral operation descriptor and the pluggable transport that runs it. The HTTP transport
 // is selected by passing a URL string; marcidb-embedded provides an in-process FFI transport.
-export type MarciOp = { model: string, action: string, query?: any, data?: any, id?: any }
+export type MarciOp = { model: string, action: string, query?: any, data?: any, id?: any, journal?: JournalArgs }
+/** The arguments of a journal action (`$journalOpen` / `$journalRead` / `$journalDrop`). `wait` is in seconds. */
+export type JournalArgs = { name: string, on?: readonly JournalOp[], after?: number, limit?: number, wait?: number }
 export type MarciTransport = {
   exec(op: MarciOp): Promise<any>
   batch(ops: MarciOp[]): Promise<any[]>
@@ -275,8 +277,35 @@ export interface Query<T extends ModelTypes, Sel = T["scalars"]> extends Promise
   findFirst<Q extends T["query"] = {}>(query?: Q): Op<Rows<T, Q> | null>
 }
 
-/** `db.<model>`: the root query, plus `reindex()` for models with a `@custom` (vector / full-text) index. */
-export type Collection<T extends ModelTypes> = Query<T> & (T["reindex"] extends true ? { reindex(): Op<{ ok: boolean, indexed: number }> } : {})
+// ───────────────────────────── journals ─────────────────────────────
+
+/** What a journal can record. Only deletes so far. */
+export type JournalOp = "delete"
+/** One recorded change. `row` is the row as it last was: its id and every scalar field. */
+export type JournalEntry<T extends ModelTypes, O extends JournalOp = JournalOp> = { seq: number, op: O, row: Rows<T, T["scalars"]> }
+export type JournalOptions<O extends JournalOp> = {
+  /** The operations to record. A journal that exists with other ones is an error, not a redefinition. */
+  on: O | readonly O[]
+  /** `false`: the loop ends when the journal is read through. By default it waits for the next entry. */
+  wait?: boolean
+}
+/**
+ * A named, durable log of a model's changes. It starts recording when it is first asked for and keeps
+ * every entry until the loop that reads it has moved past it — an entry whose loop body threw, or that
+ * was never reached, is delivered again to the next reader of the same name.
+ */
+export interface Journal<T extends ModelTypes, O extends JournalOp = JournalOp> extends AsyncIterable<JournalEntry<T, O>> {
+  /** Drops the journal with whatever it still holds; the model's writes stop paying for it. */
+  drop(): Promise<void>
+}
+
+/**
+ * `db.<model>`: the root query, plus `reindex()` for models with a `@custom` (vector / full-text) index and
+ * `$journal(name, { on })` — the journal of this model's changes under that name, created on first use.
+ */
+export type Collection<T extends ModelTypes> = Query<T>
+  & (T["reindex"] extends true ? { reindex(): Op<{ ok: boolean, indexed: number }> } : {})
+  & { $journal<O extends JournalOp>(name: string, options: JournalOptions<O>): Journal<T, O> }
 
 // ───────────────────────────── builder runtime ─────────────────────────────
 
@@ -345,6 +374,43 @@ export function createQueryLayer(options: QueryLayerOptions): { op: (descriptor:
     return out;
   };
 
+  // `db.<model>.$journal(name, { on })`. The journal is opened at once — what happens between this call
+  // and the first read is already recorded. Reading confirms: each request carries the seq of the last
+  // entry the loop got past, which is what lets the engine drop it.
+  const journal = (model: string, name: string, options: { on: any; wait?: boolean }): any => {
+    const on = Array.isArray(options.on) ? options.on : [options.on];
+    const wait = options.wait === false ? 0 : 30;
+    const opened = run({ model, action: "$journalOpen", journal: { name, on } });
+    opened.catch(() => {}); // reported by the first read, not as an unhandled rejection
+    const read = (after: number | undefined, limit: number, wait: number): Promise<any[]> =>
+      run({ model, action: "$journalRead", journal: { name, after, limit, wait } });
+    return {
+      async *[Symbol.asyncIterator]() {
+        await opened;
+        let done: number | undefined;      // the last entry the loop body finished
+        let confirmed: number | undefined; // the last one a request has carried
+        try {
+          for (;;) {
+            const entries = await read(done, 100, wait);
+            confirmed = done;
+            if (entries.length === 0) {
+              if (wait === 0) return;
+              continue;
+            }
+            for (const entry of entries) {
+              yield entry;
+              done = entry.seq;
+            }
+          }
+        } finally {
+          // Left mid-batch (`break`, a throw): confirm what was finished, so it is not delivered again.
+          if (done !== undefined && done !== confirmed) await read(done, 1, 0).catch(() => {});
+        }
+      },
+      drop: () => opened.catch(() => {}).then(() => run({ model, action: "$journalDrop", journal: { name } })).then(() => {}),
+    };
+  };
+
   // `db.<model>` — an immutable builder; each clause returns a new one over the same `run`.
   const collection = (model: string): any => {
     const make = (st: QueryState): any => {
@@ -400,6 +466,7 @@ export function createQueryLayer(options: QueryLayerOptions): { op: (descriptor:
           return op({ model, action: "deleteMany", query: whereOnly() });
         },
         reindex: () => op({ model, action: "$reindex" }),
+        $journal: (name: string, options: { on: any; wait?: boolean }) => journal(model, name, options),
 
         findMany: (query?: Record<string, any>) => op({ model, action: "findMany", query: build(query) }),
         findFirst: (query?: Record<string, any>) => op({ model, action: "findFirst", query: build(query) }),

package/src/server/db/types.ts

@@ -9,6 +9,7 @@
 
 import type { Field, FieldMeta } from "./fields"
 import type { IdentityPublicFields, SessionPublicFields } from "../auth/models"
+import type { FileField, StoredFile, UploadedFile as File } from "../files/models"
 import type {
   CompareNumValue, CompareRefListValue, CompareRefValue, CompareStrValue, CompareValue, CustomSearchValue,
   FullTextSearch, JsonCondition, JsonPathWhere, Op, PrimitiveListUpdate, Query as MarciQuery, RefListUpdate,
@@ -49,13 +50,16 @@ type FieldRow<S, Fld, M extends FieldMeta = MetaOf<Fld>> =
   M["kind"] extends "one" ? Nullable<M, Row<S, ModelName<S, Fld>>>
   : M["kind"] extends "many" | "list" ? Row<S, ModelName<S, Fld>>[]
   : M["kind"] extends "struct" ? Nullable<M, StructRow<S, StructFieldsOf<Fld>>>
-  : Nullable<M, Arr<M, TsOf<Fld>>>
+  : Nullable<M, Arr<M, TsOf<Fld>>>            // a file too: `StoredFile`, `| null`, or a list
 
 /** Full row type of a model (relations included) — the `TModel` marcidb's `GetResult` selects from. */
 export type Row<S, N extends keyof S> = Id<S, N> & { [K in Exclude<keyof FieldsOf<S[N]>, IdKeys<FieldsOf<S[N]>>>]: FieldRow<S, FieldsOf<S[N]>[K]> }
 type StructRow<S, F extends Fields> = { [K in keyof F]: FieldRow<S, F[K]> }
 
-type ScalarKeys<F extends Fields> = { [K in keyof F]: MetaOf<F[K]>["kind"] extends "scalar" | "enum" | "json" ? K : never }[keyof F]
+/** What a query without a selection returns besides the id: the scalars, and the files. */
+type ScalarKeys<F extends Fields> = { [K in keyof F]: MetaOf<F[K]>["kind"] extends "scalar" | "enum" | "json" | "file" ? K : never }[keyof F]
+/** The fields a row is ordered and aggregated by. */
+type ValueKeys<F extends Fields> = { [K in keyof F]: MetaOf<F[K]>["kind"] extends "scalar" | "enum" | "json" ? K : never }[keyof F]
 type NumKeys<F extends Fields> = { [K in keyof F]: IsNum<MetaOf<F[K]>> extends true ? (MetaOf<F[K]>["array"] extends true ? never : K) : never }[keyof F]
 /** What an empty select returns: id + every scalar field. */
 export type Scalars<S, N extends keyof S> = Pick<Row<S, N>, (ScalarKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & keyof Row<S, N>>
@@ -68,6 +72,7 @@ type FieldInsert<S, Fld, M extends FieldMeta = MetaOf<Fld>> =
   M["kind"] extends "one" ? Nullable<M, Id<S, ModelName<S, Fld>>>
   : M["kind"] extends "many" | "list" ? Id<S, ModelName<S, Fld>>[]
   : M["kind"] extends "struct" ? Nullable<M, StructInsert<S, StructFieldsOf<Fld>>>
+  : M["kind"] extends "file" ? Nullable<M, Arr<M, File>>      // a new row takes uploads
   : Nullable<M, Arr<M, TsOf<Fld>>>
 
 type RequiredKeys<F extends Fields> = {
@@ -75,6 +80,7 @@ type RequiredKeys<F extends Fields> = {
     : MetaOf<F[K]>["optional"] extends true ? never
     : MetaOf<F[K]>["hasDefault"] extends true ? never
     : MetaOf<F[K]>["kind"] extends "many" | "list" ? never
+    : MetaOf<F[K]>["kind"] extends "file" ? (MetaOf<F[K]>["array"] extends true ? never : K)
     : K
 }[keyof F]
 type Simplify<T> = { [K in keyof T]: T[K] } & {}
@@ -92,6 +98,8 @@ type FieldUpdate<S, Fld, M extends FieldMeta = MetaOf<Fld>> =
   : M["kind"] extends "many" ? RefListUpdate<Id<S, ModelName<S, Fld>>>
   : M["kind"] extends "list" ? RefListUpdateOrdered<Id<S, ModelName<S, Fld>>>
   : M["kind"] extends "struct" ? RefUpdateStruct<StructInsert<S, StructFieldsOf<Fld>>, UpdateOf<S, StructFieldsOf<Fld>>> | null
+  // an upload replaces; the stored file the field holds, handed back, keeps it; null / a shorter list deletes
+  : M["kind"] extends "file" ? Nullable<M, Arr<M, File | StoredFile>>
   : M["array"] extends true ? TsOf<Fld>[] | PrimitiveListUpdate<TsOf<Fld>>
   : Nullable<M, TsOf<Fld> | (IsNum<M> extends true ? UpdateNumValue : never)>
 
@@ -120,6 +128,7 @@ type FieldWhere<S, Fld, M extends FieldMeta = MetaOf<Fld>> =
   : M["kind"] extends "many" | "list" ? CompareRefListValue<Where<S, ModelName<S, Fld>>>
   : M["kind"] extends "struct" ? CompareRefValue<WhereValue<StructWhereFields<S, StructFieldsOf<Fld>>> | null>
   : M["kind"] extends "json" ? JsonPathWhere | JsonCondition
+  : M["kind"] extends "file" ? never             // a row is not found by its file
   : M["array"] extends true ? TsOf<Fld>[]          // the whole array, equal — the engine has no filter by an item
   : ScalarWhere<TsOf<Fld>, M> | CustomSearchValue<FullTextSearch> | CustomSearchValue<VectorSearch>
 
@@ -128,7 +137,7 @@ type IdWhere<S, N extends keyof S> = { [K in keyof Id<S, N> as K extends keyof F
 export type Where<S, N extends keyof S> = WhereValue<WhereFieldsOf<S, FieldsOf<S[N]>> & IdWhere<S, N>>
 type StructWhereFields<S, F extends Fields> = WhereFieldsOf<S, F>
 
-type OrderKeys<S, N extends keyof S> = (ScalarKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & keyof Row<S, N>
+type OrderKeys<S, N extends keyof S> = (ValueKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & keyof Row<S, N>
 /** ONE field and its direction: the engine sorts by a single field, so a second key is a type error. */
 export type Order<S, N extends keyof S> = {
   [K in OrderKeys<S, N>]: { [P in K]: "asc" | "desc" } & { [P in Exclude<OrderKeys<S, N>, K>]?: never }
@@ -148,8 +157,8 @@ export type AggregateQuery<S, N extends keyof S> = {
   $count?: true
   $sum?: NumKeys<FieldsOf<S[N]>> & string
   $avg?: NumKeys<FieldsOf<S[N]>> & string
-  $min?: (ScalarKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & string
-  $max?: (ScalarKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & string
+  $min?: (ValueKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & string
+  $max?: (ValueKeys<FieldsOf<S[N]>> | keyof Id<S, N>) & string
 }
 
 // ───────────────────────────── query / db ─────────────────────────────
@@ -197,6 +206,8 @@ type DbBase<S extends Schema> = {
   /** @internal */ readonly $models: Record<string, Model>
   /** @internal the collections sign-in works on; null = a db without `withAuth`. */
   readonly $auth: AuthBinding | null
+  /** @internal the schema's `t.file()` fields (../files/models.ts). */
+  readonly $files: FileField[]
 }
 
 export type Db<S extends Schema> = DbBase<S> & {

package/src/server/files/db.ts

@@ -0,0 +1,182 @@
+/**
+ * The db layer's half of stored files (./models.ts): what turns a file FIELD — a value in a row — into
+ * operations on the platform's `File` model, and back.
+ *
+ *   read    the field is selected as the reverse relation it is (the `File` rows that point at the
+ *           row, in order) and comes back as a `StoredFile`, or a list of them
+ *   insert  the row is inserted without the field; each upload's `File` row is then pointed at it
+ *           (`ref` to the insert's id) — one transaction
+ *   update  the row's files that are no longer listed are deleted, the uploads are pointed at it —
+ *           one transaction with the update itself
+ *
+ * An upload written to a `t.image()` field is first made a picture fit to show (the host's work,
+ * ./host.ts): that is why a plan is awaited. What it became — its type, its size — goes to its row
+ * in the operation that attaches it.
+ *
+ * A file is written from the FILE's side (its reference to the owner): that is the side the database
+ * cascades over. Only an upload of the current request is ever attached: a `StoredFile` the app hands
+ * back means "keep this one", and one of another row is not moved — a client that knows the url of
+ * someone else's file cannot take it.
+ */
+
+import type { MarciOp } from "../db/marci/query"
+import { FILE_MODEL, fileUrl, filesSeam, storedFileId, type FileField, type StoredFile } from "./models"
+
+type Plan = { op: MarciOp, after: MarciOp[] }
+
+export type FileLayer = {
+  /** The operation as the database runs it, and the ones that follow it in the same transaction.
+   *  `index` is the operation's place in that transaction (what `ref` counts from). */
+  plan(op: MarciOp, index: number): Promise<Plan>
+  /** The database's answer to a planned operation, as the project reads it. */
+  result(op: MarciOp, value: any): any
+}
+
+const FILE_SELECT = { id: true, name: true, type: true, size: true, width: true, height: true, $order: { position: "asc" } }
+
+const stored = (row: any): StoredFile => {
+  const out: StoredFile = { url: fileUrl(row.id, row.name), name: row.name, type: row.type, size: row.size }
+  if (row.width != null) out.width = row.width
+  if (row.height != null) out.height = row.height
+  return out
+}
+
+/**
+ * `fields`: the schema's `t.file()` fields. `relations`: model → relation field → its target model.
+ * `scalars`: model → what a query without a selection returns (file fields included).
+ */
+export const createFileLayer = (
+  fields: FileField[],
+  relations: Record<string, Record<string, string>>,
+  scalars: Record<string, string[]>,
+): FileLayer => {
+  const byModel: Record<string, Record<string, FileField>> = {}
+  for (const f of fields) (byModel[f.model] ??= {})[f.key] = f
+  const hasFiles = (model: string) => model in byModel
+
+  // ── read ──
+
+  /** The query with every selected file field as the relation select it is. */
+  const select = (model: string, query: Record<string, any>): Record<string, any> => {
+    const out: Record<string, any> = {}
+    for (const key in query) {
+      const value = query[key]
+      if (key.charCodeAt(0) === 36 /* $ */) { out[key] = value; continue }
+      if (byModel[model]?.[key]) { if (value) out[key] = FILE_SELECT; continue }
+      const target = relations[model]?.[key]
+      if (!target || !value) { out[key] = value; continue }
+      // `relation: true` is "its scalars" to the engine, which knows no file among them
+      if (value === true) out[key] = hasFiles(target) ? select(target, Object.fromEntries(scalars[target].map(k => [k, true]))) : true
+      else out[key] = typeof value === "object" ? select(target, value) : value
+    }
+    return out
+  }
+
+  const rows = (model: string, query: Record<string, any>, value: any): any => {
+    if (Array.isArray(value)) { for (const row of value) rows(model, query, row); return value }
+    if (value === null || typeof value !== "object") return value
+    for (const key in query) {
+      if (key.charCodeAt(0) === 36) continue
+      const field = byModel[model]?.[key]
+      if (field) {
+        const list = Array.isArray(value[key]) ? value[key].map(stored) : []
+        value[key] = field.array ? list : list[0] ?? null
+        continue
+      }
+      const target = relations[model]?.[key]
+      if (target && query[key] && typeof query[key] === "object") rows(target, query[key], value[key])
+    }
+    return value
+  }
+
+  // ── write ──
+
+  /** The row's data without its file fields, and those fields' values as lists. */
+  const split = (model: string, data: any): { data: any, files: [FileField, unknown[]][] } => {
+    const own = byModel[model]
+    if (!own || data === null || typeof data !== "object") return { data, files: [] }
+    const rest: Record<string, unknown> = {}
+    const files: [FileField, unknown[]][] = []
+    for (const key in data) {
+      const field = own[key]
+      if (!field) { rest[key] = data[key]; continue }
+      const value = data[key]
+      if (value === undefined) continue
+      if (field.array && !Array.isArray(value)) throw new Error(`${model}.${key}: a list of files is expected`)
+      files.push([field, field.array ? value : value === null ? [] : [value]])
+    }
+    return { data: rest, files }
+  }
+
+  const attach = async (field: FileField, id: string, owner: unknown, position: number): Promise<MarciOp> => {
+    const facts = field.image ? await filesSeam()!.image(id, field.image) : {}
+    return { model: FILE_MODEL, action: "update", id: { id }, data: { ...facts, [field.owner]: { $connect: owner }, position } }
+  }
+
+  const insert = async (op: MarciOp, index: number): Promise<Plan> => {
+    const { data, files } = split(op.model, op.data)
+    const after: MarciOp[] = []
+    for (const [field, values] of files) {
+      for (let position = 0; position < values.length; position++) {
+        const id = filesSeam()?.uploaded(values[position])
+        if (!id) throw new Error(`${op.model}.${field.key}: a new row takes uploaded files only — a file that is already stored belongs to its row`)
+        after.push(await attach(field, id, { $ref: String(index) }, position))
+      }
+    }
+    return { op: { ...op, data }, after }
+  }
+
+  const update = async (op: MarciOp): Promise<Plan> => {
+    const { data, files } = split(op.model, op.data)
+    const after: MarciOp[] = []
+    for (const [field, values] of files) {
+      const keep: string[] = []
+      const then: MarciOp[] = []
+      for (let position = 0; position < values.length; position++) {
+        const value = values[position]
+        const upload = filesSeam()?.uploaded(value)
+        const id = upload ?? storedFileId(value)
+        if (!id) throw new Error(`${op.model}.${field.key}: a file is expected — an upload, or the stored file the field already holds`)
+        keep.push(id)
+        if (upload) then.push(await attach(field, upload, op.id, position))
+        // one that stays: its place in the list — and only where it IS this row's file
+        else if (field.array) then.push({ model: FILE_MODEL, action: "updateMany", query: { $where: { id, [field.owner]: op.id } }, data: { position } })
+      }
+      // what the field held and no longer lists is deleted, with its bytes
+      after.push({ model: FILE_MODEL, action: "deleteMany", query: { $where: { [field.owner]: op.id, ...(keep.length ? { id: { $notIn: keep } } : {}) } } }, ...then)
+    }
+    return { op: { ...op, data }, after }
+  }
+
+  return {
+    async plan(op, index) {
+      switch (op.action) {
+        case "findMany": case "findFirst":
+          return { op: { ...op, query: select(op.model, op.query ?? {}) }, after: [] }
+        case "count": case "aggregate":
+          return { op, after: [] }
+      }
+      // rows of File go when a row is deleted (itself, or by a cascade) and when a field is rewritten
+      const dirty = () => { const seam = filesSeam(); if (seam) seam.dirty = true }
+      switch (op.action) {
+        case "insert": return insert(op, index)
+        case "update": {
+          const plan = await update(op)
+          if (plan.after.length) dirty()
+          return plan
+        }
+        case "delete": case "deleteMany":
+          dirty()
+          break
+        case "updateMany":
+          for (const key in byModel[op.model] ?? {}) {
+            if (op.data && key in op.data) throw new Error(`${op.model}.${key}: a file is written to one row — update(id, …), not updateMany`)
+          }
+      }
+      return { op, after: [] }
+    },
+    result(op, value) {
+      return op.action === "findMany" || op.action === "findFirst" ? rows(op.model, op.query ?? {}, value) : value
+    },
+  }
+}