@drhomet/mithaq 0.1.1 → 0.2.0

package/dist/asas/runner/steps.js

@@ -3,6 +3,7 @@ import { declaredFieldAccess } from '../../mithaq/rows.js';
 import { providerOf } from '../../base/rules.js';
 import { invalid } from './errors.js';
 import { snapshot } from './runtime.js';
+import { rawStepStore } from './store.js';
 // The assertion checks the list stays inside `OperationStep<never>`, not the direction it names.
 export const atEffect = (list) => list;
 // A map only this module writes: a tag on the function would let any function buy
@@ -17,6 +18,12 @@ const seal = (name, step) => {
 };
 /** What position this step holds, or nothing at all for a step of the app's own. */
 export const sealOf = (step) => seals.get(step);
+// Each copy of mithaq in the process lists its seals here, so a step a second install sealed is
+// named rather than miscounted. Anything can write this map, so its answer only ever refuses.
+const copies = (globalThis[Symbol.for('mithaq.copies')] ??= new Map());
+copies.set(import.meta.url, (step) => seals.get(step));
+/** Where the other copy of mithaq that sealed this step was loaded from, if one did. */
+export const foreignCopyOf = (step) => [...copies].find(([url, of]) => url !== import.meta.url && of(step))?.[0];
 /** Hold an operation's `output` function until `build` has the derived shapes. */
 export const holdOutput = (operation, of) => {
     outputs.set(operation, of);
@@ -51,7 +58,7 @@ export const audit = seal('audit', async (ctx, tools) => {
         operation: tools.operation,
         dataBefore: withoutSecrets(ctx.kayan, ctx.dataBefore),
         dataAfter: withoutSecrets(ctx.kayan, ctx.dataAfter ?? snapshot(ctx.data) ?? ctx.data),
-        store: 'store' in tools ? tools.store : undefined,
+        store: 'store' in tools ? rawStepStore(tools.store) : undefined,
         tx: ctx.tx,
         user: ctx.user,
     });
@@ -60,9 +67,9 @@ export const audit = seal('audit', async (ctx, tools) => {
 // A row's filter and a default read the same reference off the same actor, so they agree.
 const defaultOf = (field, ctx, tools) => {
     const value = field.rules?.defaultValue;
-    // Copied, so a step pushing onto one row's list never changes the next row's default.
+    // Copied whole, so a step changing one row's list or object never changes the next row's default.
     if (!isRef(value))
-        return Array.isArray(value) ? [...value] : value;
+        return typeof value === 'object' && value !== null ? structuredClone(value) : value;
     if (!ctx.user) {
         throw new Error(`Kayan "${ctx.kayan.name}" operation "${tools.operation}" field "${field.name}" defaults to "user.${value.$user}", and this write was given no actor. Pass one: create(data, { actor }).`);
     }
@@ -151,7 +158,7 @@ export const validate = seal('validate', (() => validate));
 const columns = (ctx) => Object.fromEntries(Object.entries(ctx.data).filter(([name]) => name in ctx.kayan.fields));
 /** Make the row, and what came back is what the rest of the list sees. */
 export const insert = seal('insert', async (ctx, tools) => {
-    const row = await tools.store.insert({ tx: ctx.tx, kayan: ctx.kayan.name, data: columns(ctx) });
+    const row = await tools.store.insert({ tx: ctx.tx, kayan: ctx.kayan, data: columns(ctx) });
     return { ...ctx, data: { ...ctx.data, ...row }, dataAfter: snapshot(row) };
 });
 /** Change the one row the id names; everything else in `data` is the change. An id alone is refused with a 400. */
@@ -168,12 +175,12 @@ export const update = seal('update', async (ctx, tools) => {
             params: { kayan: ctx.kayan.name, operation: tools.operation },
         });
     }
-    const row = await tools.store.update({ tx: ctx.tx, kayan: ctx.kayan.name, id: ctx.data.id, data: values, where: tools.where });
+    const row = await tools.store.update({ tx: ctx.tx, kayan: ctx.kayan, id: ctx.data.id, data: values, where: tools.where });
     return { ...ctx, data: { ...ctx.data, ...row }, dataAfter: snapshot(row) };
 });
 /** Remove the one row the id names, and hand back what was removed. */
 export const remove = seal('remove', async (ctx, tools) => {
-    const data = await tools.store.remove({ tx: ctx.tx, kayan: ctx.kayan.name, id: ctx.data.id, where: tools.where });
+    const data = await tools.store.remove({ tx: ctx.tx, kayan: ctx.kayan, id: ctx.data.id, where: tools.where });
     return { ...ctx, data, dataAfter: snapshot(data) };
 });
 // The seal and nothing else: `bulk` supplies `tools.many`.
@@ -254,11 +261,10 @@ export const resolveOperations = (declared, slots = {}) => {
         afterSteps: slots.afterSteps ?? [],
         afterCommit: slots.afterCommit ?? [],
     };
-    const record = typeof declared === 'function' ? declared(given) : declared;
-    if (!record)
+    if (!declared)
         return {};
     const resolved = Object.create(null);
-    for (const [name, declaration] of Object.entries(record)) {
+    for (const [name, declaration] of Object.entries(declared)) {
         if (declaration === undefined)
             continue;
         const held = declaration;

package/dist/asas/runner/store.d.ts

@@ -0,0 +1,4 @@
+import type { RawStepStore, StepStore } from '../../mithaq/language.ts';
+import type { RuntimeWriteTools, WriteTools } from './steps.ts';
+export declare const rawStepStore: (store: StepStore) => RawStepStore;
+export declare const stepTools: (tools: RuntimeWriteTools) => WriteTools;

package/dist/asas/runner/store.js

@@ -0,0 +1,21 @@
+import { invalid } from './errors.js';
+// Audit sinks still implement the adapter contract; no raw handle is a property a step can reach.
+const raw = new WeakMap();
+const declaredStore = (store) => {
+    const wrapped = Object.freeze(Object.fromEntries(Object.entries(store).map(([word, call]) => [word, (args) => {
+            const kayan = args.kayan;
+            if (!kayan || typeof kayan !== 'object' || typeof kayan.name !== 'string' || !kayan.fields || typeof kayan.fields !== 'object') {
+                throw invalid({ message: 'A step store call names its kayan by its declaration, not a string.', key: 'error.invalid.value' });
+            }
+            return call({ ...args, kayan: kayan.name });
+        }])));
+    raw.set(wrapped, store);
+    return wrapped;
+};
+export const rawStepStore = (store) => {
+    const held = raw.get(store);
+    if (!held)
+        throw new Error('The audit step needs the store handed to it by the runner.');
+    return held;
+};
+export const stepTools = (tools) => Object.freeze({ ...tools, store: declaredStore(tools.store) });

package/dist/asas/runner/tenant.d.ts

@@ -2,7 +2,7 @@ import { type AssignedResolver } from '../actor.ts';
 import { type Language, type Store } from '../../mithaq/language.ts';
 import type { ResolvedKayan } from '../../mithaq/types.ts';
 import { type Where } from '../../mithaq/where.ts';
-import type { OperationEffect, WriteTools } from './steps.ts';
+import type { OperationEffect, RuntimeWriteTools as WriteTools } from './steps.ts';
 import { type Authorize } from './write.ts';
 /** How far a read reaches past the active organization: every verified membership, or every tenant. */
 export type TenantReach = 'mine' | 'all';
@@ -47,7 +47,7 @@ export declare const tenancy: ({ language, assigned, onError, collection }: {
     scoped: (inner: Authorize) => Authorize;
     active: (actor: unknown) => string | undefined;
     sealWrites: ({ writes, find, kayanOf }: {
-        writes: WriteTools['store'];
+        writes: Omit<WriteTools['store'], 'hold'>;
         find: Store['find'];
         kayanOf: (name: string) => ResolvedKayan | undefined;
     }) => WriteTools['store'];

package/dist/asas/runner/tenant.js

@@ -2,10 +2,10 @@
 // access answers, so no row table, callback or authorizer can widen it.
 import { authActor, markAuthActor, resolveAssigned } from '../actor.js';
 import { isTenant } from '../../mithaq/language.js';
-import { combineWhere, same } from '../../mithaq/where.js';
-import { AsasError, denied, invalid } from './errors.js';
+import { combineWhere, compareValues, same } from '../../mithaq/where.js';
+import { AsasError, denied, invalid, missing } from './errors.js';
 import { running } from './runtime.js';
-import { assertReferences } from './write.js';
+import { assertStoreWhere, assertReferences } from './write.js';
 // The session must come from the one Better Auth kayan of the build, whose organizations the
 // tenant kayan holds: another instance's organization ids name no tenant here.
 const sessionOf = ({ actor, collection }) => {
@@ -89,8 +89,8 @@ export const tenancy = ({ language, assigned, onError, collection }) => {
         }
         if (reach === 'all') {
             const trusted = authActor(actor);
-            if (!trusted || !target.platform || (await target.platform({ user: actor })) !== true) {
-                throw refused('tenant "all" reads every organization, which only platform staff in the platform app may.');
+            if (!trusted || !target.backoffice || (await target.backoffice({ user: actor })) !== true) {
+                throw refused('tenant "all" reads every organization, which only backoffice staff in the backoffice app may.');
             }
             return { reach };
         }
@@ -173,13 +173,34 @@ export const tenancy = ({ language, assigned, onError, collection }) => {
      * organization's delete never reaches it.
      */
     const sealWrites = ({ writes, find, kayanOf }) => {
-        const references = async ({ name, data, tx }) => {
+        // A versions table or a join table holds no tenant field to seal by, so a step reaches neither.
+        const named = (name) => {
             const kayan = kayanOf(name);
-            if (kayan)
-                await assertReferences({ kayan, store: { find }, data, tenant: active(running.getStore()?.user), tx });
+            if (!kayan)
+                throw new Error(`A step wrote "${name}", which names no kayan, and a step writes a kayan's rows alone: versions and join rows are core's.`);
+            return kayan;
+        };
+        const declaredField = (name, key) => {
+            if (!Object.hasOwn(named(name).fields, key))
+                throw invalid({ message: `Kayan "${name}" declares no field "${key}".`, key: 'error.invalid.value', params: { kayan: name, field: key } });
+        };
+        const checked = (name, where) => {
+            if (!where)
+                return where;
+            try {
+                return assertStoreWhere(named(name), where);
+            }
+            catch (cause) {
+                throw invalid({ message: cause instanceof Error ? cause.message : 'Invalid store filter.', key: 'error.invalid.value', params: { kayan: name }, cause });
+            }
+        };
+        const references = async ({ name, data, tx }) => {
+            for (const key of Object.keys(data))
+                declaredField(name, key);
+            return assertReferences({ kayan: named(name), store: { find }, data, tenant: active(running.getStore()?.user), tx });
         };
         const sealed = (name, data) => {
-            const field = kayanOf(name)?.tenant;
+            const field = named(name).tenant;
             if (!field)
                 return undefined;
             const org = active(running.getStore()?.user);
@@ -189,24 +210,65 @@ export const tenancy = ({ language, assigned, onError, collection }) => {
                 throw new Error(`A step wrote field "${field}" of kayan "${name}", and a row is made in its organization by the runner alone and never leaves it.`);
             return { [field]: { equals: org } };
         };
+        const sealedFind = async (args) => {
+            if (args.args.lock && !args.tx)
+                throw new Error('Holding rows requires a transaction.');
+            declaredField(args.kayan, args.args.sort.field);
+            return find({ ...args, args: { ...args.args, where: combineWhere(checked(args.kayan, args.args.where), sealed(args.kayan)) } });
+        };
         return Object.freeze({
+            find: sealedFind,
+            sum: async (args) => {
+                declaredField(args.kayan, args.field);
+                return writes.sum({ ...args, where: combineWhere(checked(args.kayan, args.where), sealed(args.kayan)) });
+            },
+            hold: async ({ tx, kayan, ids, mode }) => {
+                if (!['update', 'noKeyUpdate', 'share', 'keyShare'].includes(mode))
+                    throw invalid({ message: 'Holding rows requires a valid lock mode.', key: 'error.invalid.value' });
+                if (!tx)
+                    throw new Error('Holding rows requires a transaction.');
+                const uuid = named(kayan).fields.id?.kind === 'uuid';
+                const ordered = [...new Set(ids.map((id) => uuid && typeof id === 'string' ? id.toLowerCase() : id))].sort((left, right) => compareValues({ left, right, direction: 'asc' }));
+                for (const id of ordered) {
+                    const { docs } = await sealedFind({ tx, kayan, args: { limit: 1, page: 1, sort: { field: 'id', direction: 'asc' }, lock: mode, where: { id: { equals: id } } } });
+                    if (!docs.length)
+                        throw missing({ message: `No "${kayan}" row found.`, key: 'error.not_found.row', params: { kayan } });
+                }
+            },
+            upsert: async (args) => {
+                const field = named(args.kayan).tenant;
+                const org = active(running.getStore()?.user);
+                if (field && (org === undefined || (Object.hasOwn(args.data, field) && args.data[field] !== org))) {
+                    throw new Error(`A step upserted kayan "${args.kayan}" in another organization than the active one.`);
+                }
+                const data = field ? { ...args.data, [field]: org } : args.data;
+                const kayan = named(args.kayan);
+                if (!args.on.length || new Set(args.on).size !== args.on.length || !(args.on.length === 1 && args.on[0] === 'id') && !kayan.indexes.some((index) => index.unique && index.fields.length === args.on.length && index.fields.every((field) => args.on.includes(field))) || args.on.some((key) => !Object.hasOwn(data, key) || (data[key] && typeof data[key] === 'object' && '$inc' in data[key]))) {
+                    throw invalid({ message: `Kayan "${args.kayan}" upsert needs plain key values for a declared unique index in "on".`, key: 'error.invalid.value', params: { kayan: args.kayan } });
+                }
+                for (const key of args.on)
+                    declaredField(args.kayan, key);
+                await references({ name: args.kayan, data, tx: args.tx });
+                return writes.upsert({ ...args, data, where: combineWhere(checked(args.kayan, args.where), sealed(args.kayan)) });
+            },
             insert: async (args) => {
-                const field = kayanOf(args.kayan)?.tenant;
+                const field = named(args.kayan).tenant;
+                const org = active(running.getStore()?.user);
                 if (field) {
-                    const org = active(running.getStore()?.user);
-                    if (org === undefined || args.data[field] !== org) {
+                    if (org === undefined || (Object.hasOwn(args.data, field) && args.data[field] !== org)) {
                         throw new Error(`A step made a row of kayan "${args.kayan}" in another organization than the active one, and a row is made in its own organization alone.`);
                     }
                 }
-                await references({ name: args.kayan, data: args.data, tx: args.tx });
-                return writes.insert(args);
+                const data = field ? { ...args.data, [field]: org } : args.data;
+                await references({ name: args.kayan, data, tx: args.tx });
+                return writes.insert({ ...args, data });
             },
             update: async (args) => {
-                const where = combineWhere(args.where, sealed(args.kayan, args.data));
+                const where = combineWhere(checked(args.kayan, args.where), sealed(args.kayan, args.data));
                 await references({ name: args.kayan, data: args.data, tx: args.tx });
                 return writes.update({ ...args, where });
             },
-            remove: (args) => writes.remove({ ...args, where: combineWhere(args.where, sealed(args.kayan)) }),
+            remove: async (args) => writes.remove({ ...args, where: combineWhere(checked(args.kayan, args.where), sealed(args.kayan)) }),
         });
     };
     return { open, scoped, active, sealWrites };

package/dist/asas/runner/write.d.ts

@@ -1,15 +1,15 @@
-import type { AdminAccess, LocalesOf, ResolvedKayan, RuntimeField, ServiceOf } from '../../mithaq/types.ts';
+import type { AdminAccess, LocalesOf, ResolvedField, ResolvedKayan, RuntimeField, ServiceOf } from '../../mithaq/types.ts';
 import type { BuiltTables } from '../../drizzle/index.ts';
 import { defaultKinds, type Kind } from '../../base/kinds.ts';
-import type { RichTextValue } from '../../rich-text/rich-text.ts';
+import type { RichTextValue } from '../../rich-text/value.ts';
 import type { Store } from '../../mithaq/language.ts';
 import type { LanguageOf } from '../../mithaq/define.ts';
 import type { InferInput, InferOutput, StandardSchemaV1 } from '../../mithaq/standard-schema.ts';
-import { type BulkResult, type Context, type ContextOf, type Ctx, type DerivedSchemas, type OperationEffect, type ResolvedOperation, type StepsOf, type Tools, type WriteTools, type WriteStep } from './steps.ts';
+import { type BulkResult, type Context, type ContextOf, type Ctx, type DerivedSchemas, type OperationEffect, type ResolvedOperation, type StepsOf, type Tools, type RuntimeWriteTools as WriteTools, type WriteStep } from './steps.ts';
 import { type Open } from './runtime.ts';
 import type { FindInput } from './read.ts';
 import { type TenantReach } from './tenant.ts';
-import type { FieldWhere, Operator, Where } from '../../mithaq/where.ts';
+import type { FieldWhere, Operator, Scalar, Where } from '../../mithaq/where.ts';
 /** The key of `Options` only the bulk runner sets. */
 export declare const ontoRow: unique symbol;
 /** The caller's own context, required where the project declared one. */
@@ -32,7 +32,7 @@ export type ReadOptions<Actor = unknown, Extra extends Record<string, unknown> =
     /**
      * How far the read reaches past the active organization: `'mine'` is every organization the
      * actor is a verified member of, each under the roles it holds there; `'all'` is every tenant,
-     * for platform staff in the platform app alone. A `where` on the tenant field only narrows it.
+     * for backoffice staff in the backoffice app alone. A `where` on the tenant field only narrows it.
      */
     tenant?: TenantReach;
 };
@@ -49,6 +49,8 @@ export type ManagedAdmin<Actor = unknown> = {
     access?: AdminAccess<Actor>;
     kayan?: string;
 };
+/** Raw store filters keep their adapter's value and empty-filter semantics; only declared paths are checked here. */
+export declare const assertStoreWhere: (kayan: ResolvedKayan, where: Where) => Where;
 export declare const assertFieldWhere: ({ said, key, kind, operators, value, valued }: {
     said: string;
     key: string;
@@ -59,8 +61,37 @@ export declare const assertFieldWhere: ({ said, key, kind, operators, value, val
 }) => FieldWhere;
 export declare const assertWhere: (kayan: ResolvedKayan, where: unknown) => Where;
 export declare const assertWhereGrammar: (kayan: ResolvedKayan, where: unknown) => Where;
+/**
+ * How large a caller's `where` may be: the values one `in` or `not_in` lists, and the fields, `and`s and
+ * `or`s it holds in all, however nested. Each is a condition the store runs, so past these a read is
+ * refused before it reaches the store rather than holding it for minutes.
+ */
+export declare const whereLimits: {
+    readonly values: 1000;
+    readonly nodes: 200;
+};
 export declare const aliveWhere: (kayan: ResolvedKayan) => Where | undefined;
 export declare const publishedWhere: (kayan: ResolvedKayan) => Where | undefined;
+/** A field of one kayan that points at rows of another, which a delete of one of those rows answers to. */
+export type Pointer = {
+    kayan: ResolvedKayan;
+    field: ResolvedField;
+};
+/** Every field of `kayans` whose `onDelete` keeps a row of `target` while it names it. */
+export declare const restrictingPointers: (kayans: readonly ResolvedKayan[], target: ResolvedKayan) => Pointer[];
+/**
+ * The ids of the rows of each kayan that name `id` through `pointers`, a row whose latest version
+ * names it among them, since the foreign key holds live rows alone and a pending draft would
+ * otherwise keep an id nothing answers for. A pointing kayan that is tenant-owned is read within
+ * `tenant` when one is given, so a count never reaches another organization's rows.
+ */
+export declare const referencingIds: ({ id, pointers, store, tenant, tx }: {
+    id: unknown;
+    pointers: readonly Pointer[];
+    store: Pick<Store, 'find'>;
+    tenant?: unknown;
+    tx?: unknown;
+}) => Promise<Map<ResolvedKayan, Set<string>>>;
 export declare const projectReadableFields: <Actor>({ kayan, row, actor, }: {
     kayan: ResolvedKayan;
     row: Record<string, unknown>;
@@ -77,11 +108,24 @@ export declare const publicResult: <Actor>({ kayan, row, actor, internalOutput,
 }) => Promise<Record<string, unknown>>;
 export declare const assertSingleConstrained: (kayan: ResolvedKayan, where: Where | undefined) => void;
 /**
- * Refuses a relationship value naming a row the write may not point at: one of another
- * organization than the written row's, or one `access` leaves out. A step's own raw write
- * passes no `access`, so it is held to the organization alone.
+ * The lock a write holds on a row it changes, as Postgres's own statement takes it: `FOR UPDATE` for a
+ * delete, or for an update naming a column of a unique index, which holds off a write naming the row
+ * `FOR KEY SHARE`, and `FOR NO KEY UPDATE` for any other update, which that write passes. A soft delete
+ * is an update of its mark, and asks no rows naming its row, so it has no reference to hold off. Taken
+ * whole when the row loads, before any value is compared: an UPDATE raising its lock later would wait on
+ * a writer that named the row in between while that writer waits on it, a deadlock.
+ *
+ * ponytail: publishing a latest draft's unique column can still raise this lock; take `update` for every
+ * non-draft update on a kayan with drafts and a unique index if that path needs to be covered.
+ * ponytail: an update step can raise its own row's lock by writing a unique column or hard-deleting the
+ * row; take `update` at load for an operation whose steps may do either if that path needs to be covered.
  */
-export declare const assertReferences: ({ kayan, store, data, tenant, access, tx }: {
+export declare const rowLock: ({ kayan, kind, data }: {
+    kayan: ResolvedKayan;
+    kind: string;
+    data: Record<string, unknown>;
+}) => "noKeyUpdate" | "update";
+export declare const assertReferences: ({ kayan, store, data, tenant, access, offered, tx }: {
     kayan: ResolvedKayan;
     store: Pick<Store, 'find'>;
     data: Record<string, unknown>;
@@ -89,6 +133,8 @@ export declare const assertReferences: ({ kayan, store, data, tenant, access, tx
     tenant: unknown;
     /** What else the target's row must meet: its read access for this actor. */
     access?: (target: ResolvedKayan) => Promise<Where | undefined>;
+    /** What one field's `filterOptions` offers this actor, which a managed write is held to. */
+    offered?: (field: ResolvedField) => Promise<Where | undefined>;
     tx?: unknown;
 }) => Promise<void>;
 export declare const defaultAccess: <Actor>(admin: ManagedAdmin<Actor> | undefined, actor: Actor | null) => Promise<boolean>;
@@ -126,7 +172,7 @@ export declare const runOutside: <Actor>({ kayan, tools, slot, list, start, arou
     };
 }) => Promise<Ctx>;
 export declare const drain: (queue: readonly (() => Promise<void>)[]) => Promise<void>;
-export declare const write: <Actor = unknown>({ kayan, declaration, tools, store, cap, authorize, admin, tenantOf, }: {
+export declare const write: <Actor = unknown>({ kayan, declaration, tools, store, cap, authorize, admin, tenantOf, pointers, }: {
     kayan: ResolvedKayan;
     declaration: ResolvedOperation;
     tools: WriteTools<unknown, Actor>;
@@ -136,6 +182,8 @@ export declare const write: <Actor = unknown>({ kayan, declaration, tools, store
     admin?: ManagedAdmin<Actor>;
     /** The organization the actor's session names, which a tenant-owned row is made in. */
     tenantOf: (actor: unknown) => string | undefined;
+    /** The fields that keep a row of this kayan while they name it, which a delete answers to. */
+    pointers?: readonly Pointer[];
 }) => (data?: Record<string, unknown>, options?: Options<Actor>) => Promise<Record<string, unknown>>;
 type Registry = readonly {
     name: string;
@@ -354,6 +402,120 @@ type InputOf<K, Name extends PropertyKey, Fields extends Record<string, RuntimeF
 type BoundOne<K, Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry, Mode extends 'read' | 'write'> = {
     [Name in keyof OwnOperations<K> as Mode extends 'write' ? Name : IsReadOperation<OwnOperation<K, Name>> extends true ? Name : never]: (...input: {} extends InputOf<K, Name, Fields, L, List> ? [input?: InputOf<K, Name, Fields, L, List>] : [input: InputOf<K, Name, Fields, L, List>]) => OperationResult<OwnOperation<K, Name>, Fields, L, List>;
 };
+type StoreFields<K extends Registry[number]> = {
+    [N in keyof K['fields'] as K['fields'][N] extends {
+        kind: 'join';
+    } ? never : N]: K['fields'][N];
+};
+type StoreNames<K extends Registry[number]> = keyof StoreFields<K> & string;
+type StoreNumeric<K extends Registry[number]> = string extends StoreNames<K> ? string : {
+    [N in StoreNames<K>]: K['fields'][N] extends {
+        kind: 'integer' | 'number' | 'decimal';
+    } ? N : never;
+}[StoreNames<K>];
+type StoreValue<K extends Registry[number], F> = ([Value<F, LanguageOf<K>, readonly [K]>] extends [never] ? F extends {
+    relationTo: string;
+} ? F extends {
+    hasMany: true;
+} ? (string | number)[] : string | number : never : Value<F, LanguageOf<K>, readonly [K]>) | (F extends {
+    rules: {
+        required: true;
+    };
+} ? never : null);
+type StoreData<K extends Registry[number], Increment extends boolean = false> = string extends StoreNames<K> ? Record<string, unknown> : {
+    [N in StoreNames<K>]?: (N extends 'id' ? StoreID<K> : StoreValue<K, K['fields'][N]>) | (Increment extends true ? K['fields'][N] extends {
+        kind: 'integer';
+    } ? {
+        $inc: number;
+    } : never : never);
+};
+type StorePath<K extends Registry[number]> = StoreNames<K> | {
+    [N in StoreNames<K>]: K['fields'][N] extends {
+        rules: {
+            localized: true;
+        };
+    } ? `${N}.${LocalesOf<LanguageOf<K>>}` : K['fields'][N] extends {
+        relationTo: () => infer Related extends Registry[number];
+    } ? `${N}.${keyof Related['fields'] & string}` : K['fields'][N] extends {
+        kind: 'json';
+    } ? `${N}.${string}` : never;
+}[StoreNames<K>];
+type StorePathValue<K extends Registry[number], Path extends string> = Path extends keyof K['fields'] ? StoreValue<K, K['fields'][Path]> : Path extends `${infer Name}.${infer Rest}` ? Name extends keyof K['fields'] ? K['fields'][Name] extends {
+    relationTo: () => infer Related extends Registry[number];
+} ? Rest extends keyof Related['fields'] ? StoreValue<Related, Related['fields'][Rest]> : never : K['fields'][Name] extends {
+    rules: {
+        localized: true;
+    };
+} ? KindCarried<K['fields'][Name], LanguageOf<K>, readonly [K]> | null : Scalar : never : never;
+type StoreCondition<Value> = {
+    [O in Operator]?: O extends 'exists' ? boolean : O extends 'in' | 'not_in' ? readonly Value[] : O extends 'like' ? Extract<Value, string> : O extends 'contains' ? Extract<Value, string> | (Value extends readonly (infer Item)[] ? Item : never) : Value;
+};
+type StoreWhere<K extends Registry[number]> = string extends StoreNames<K> ? Where : {
+    [P in StorePath<K>]?: StoreCondition<StorePathValue<K, P>>;
+} & {
+    and?: readonly StoreWhere<K>[];
+    or?: readonly StoreWhere<K>[];
+};
+type StoreResult<K extends Registry[number]> = StoredRow<StoreFields<K>, LanguageOf<K>, readonly [K]>;
+type StoreID<K extends Registry[number]> = string extends StoreNames<K> ? unknown : Exclude<Value<K['fields']['id'], LanguageOf<K>, readonly [K]>, null | undefined>;
+type StoreLock = NonNullable<Parameters<Store['find']>[0]['args']['lock']>;
+/** The declaration carries the language and fields, so a step needs no separate name registry. */
+export type DeclarationStore = {
+    insert<const K extends Registry[number]>(args: {
+        tx: unknown;
+        kayan: K;
+        data: StoreData<NoInfer<K>>;
+    }): Promise<StoreResult<K>>;
+    update<const K extends Registry[number]>(args: {
+        tx: unknown;
+        kayan: K;
+        id: StoreID<NoInfer<K>>;
+        data: StoreData<NoInfer<K>, true>;
+        where?: StoreWhere<NoInfer<K>>;
+    }): Promise<StoreResult<K>>;
+    upsert<const K extends Registry[number]>(args: {
+        tx: unknown;
+        kayan: K;
+        on: readonly StoreNames<NoInfer<K>>[];
+        data: StoreData<NoInfer<K>, true>;
+        where?: StoreWhere<NoInfer<K>>;
+    }): Promise<StoreResult<K>>;
+    remove<const K extends Registry[number]>(args: {
+        tx: unknown;
+        kayan: K;
+        id: StoreID<NoInfer<K>>;
+        where?: StoreWhere<NoInfer<K>>;
+    }): Promise<StoreResult<K>>;
+    find<const K extends Registry[number]>(args: {
+        tx?: unknown;
+        kayan: K;
+        args: {
+            limit: number;
+            page: number;
+            sort: {
+                field: StoreNames<NoInfer<K>>;
+                direction: 'asc' | 'desc';
+            };
+            lock?: StoreLock;
+            where?: StoreWhere<NoInfer<K>>;
+        };
+    }): Promise<{
+        docs: StoreResult<K>[];
+        totalDocs: number;
+    }>;
+    hold<const K extends Registry[number]>(args: {
+        tx: unknown;
+        kayan: K;
+        ids: readonly StoreID<NoInfer<K>>[];
+        mode: StoreLock;
+    }): Promise<void>;
+    sum<const K extends Registry[number]>(args: {
+        tx?: unknown;
+        kayan: K;
+        field: StoreNumeric<NoInfer<K>>;
+        where?: StoreWhere<NoInfer<K>>;
+    }): Promise<string>;
+};
 export type BoundOf<Mode extends 'read' | 'write'> = <const K extends Registry[number] & {
     single?: never;
 }>(kayan: K) => BoundOne<K, K['fields'], LanguageOf<K>, readonly [K], Mode>;
@@ -412,7 +574,7 @@ type GlobalOperations<K extends Registry[number], List extends Registry, L exten
     findOne(...args: CallArgs<L, Actor, {
         depth?: number;
     }>): Promise<Row<K['fields'], L, List> | null>;
-    update(...args: CallArgs<L, Actor, UpdateInput<K['fields'], L, List>>): Promise<Row<K['fields'], L, List>>;
+    update(...args: CallArgs<L, Actor, Omit<OperationData<OwnOperation<K, 'update'>, UpdateInput<K['fields'], L, List>>, 'id'>>): Promise<Row<K['fields'], L, List>>;
 };
 /** What `asas.global` holds: one built global per name, of the shape a kayan has. */
 export type Globals<GlobalList extends Registry, List extends Registry, L extends LanguageValues, Actor = unknown> = {