@drhomet/mithaq 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,606 @@
+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/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 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, 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. */
+type ContextOption<Extra extends Record<string, unknown>> = [Record<string, unknown>] extends [Extra] ? {
+    context?: Extra;
+} : {
+    context: Extra;
+};
+/** The second argument of every write function. */
+export type Options<Actor = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Whoever is writing. A `user.<key>` default reads off it. */
+    actor?: Actor;
+    /** On a kayan that keeps drafts, save a version alone unless the write sends `_status: 'published'`; a read then reads each row's latest version. */
+    draft?: boolean;
+    /** With `draft`, overwrite the latest version in place where it is itself an autosave. */
+    autosave?: boolean;
+    [ontoRow]?: true;
+} & ContextOption<Extra>;
+export type ReadOptions<Actor = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = Options<Actor, Extra> & {
+    /**
+     * 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 backoffice staff in the backoffice app alone. A `where` on the tenant field only narrows it.
+     */
+    tenant?: TenantReach;
+};
+/**
+ * The keys this build's runner declared, which is what a caller of it has to
+ * send and what every step of it reads.
+ */
+type ContextExtra<L> = ContextOf<ServiceOf<L>>;
+/** The options a caller of this build passes every operation. */
+type CallOptions<L, Actor, Read extends boolean = false> = Read extends true ? ReadOptions<Actor, ContextExtra<L>> : Options<Actor, ContextExtra<L>>;
+type CallArgs<L, Actor, Input, Read extends boolean = false> = [Record<string, unknown>] extends [ContextExtra<L>] ? {} extends Input ? [input?: Input, options?: CallOptions<L, Actor, Read>] : [input: Input, options?: CallOptions<L, Actor, Read>] : [input: Input, options: CallOptions<L, Actor, Read>];
+/** The admin provider as the runner sees it: the kayan's name, and its gate. */
+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;
+    kind: string;
+    operators?: readonly Operator[];
+    value: unknown;
+    valued?: boolean;
+}) => 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>;
+    actor: Actor | null;
+}) => Promise<{
+    [x: string]: unknown;
+}>;
+export declare const publicResult: <Actor>({ kayan, row, actor, internalOutput, publicOutput, }: {
+    kayan: ResolvedKayan;
+    row: Record<string, unknown>;
+    actor: Actor | null;
+    internalOutput: StandardSchemaV1;
+    publicOutput?: StandardSchemaV1;
+}) => Promise<Record<string, unknown>>;
+export declare const assertSingleConstrained: (kayan: ResolvedKayan, where: Where | undefined) => void;
+/**
+ * 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 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>;
+    /** The organization the written row belongs to, or the active one where the row belongs to none. */
+    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>;
+export type Authorize = <Actor>(args: {
+    admin?: ManagedAdmin<Actor>;
+    actor: Actor | null;
+    data: Record<string, unknown>;
+    effect: OperationEffect;
+    kayan: ResolvedKayan;
+    kind?: Tools['kind'];
+    operation?: string;
+}) => Promise<Where | undefined>;
+export declare const defaultAuthorize: Authorize;
+export declare const beginWrite: <Actor = unknown>({ kayan, operation, store, cap, options, }: {
+    kayan: ResolvedKayan;
+    operation: string;
+    store: Store;
+    cap: number;
+    options?: Options<Actor>;
+}) => {
+    actor: NonNullable<Actor> | null;
+    context: Context;
+    entry: Open;
+    open: Map<any, any>;
+};
+export declare const runOutside: <Actor>({ kayan, tools, slot, list, start, around, }: {
+    kayan: ResolvedKayan;
+    tools: WriteTools<unknown, Actor>;
+    slot: 'afterCommit' | 'beforeTransaction';
+    list: readonly WriteStep[];
+    start: Ctx;
+    around: {
+        context: Context;
+        user: Actor | null;
+    };
+}) => 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, pointers, }: {
+    kayan: ResolvedKayan;
+    declaration: ResolvedOperation;
+    tools: WriteTools<unknown, Actor>;
+    store: Store;
+    cap: number;
+    authorize: Authorize;
+    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;
+    fields: Record<string, RuntimeField>;
+}[];
+type LanguageValues = {
+    kinds: Record<string, Kind>;
+    targets?: unknown;
+};
+type Registered<List extends Registry, Name> = Extract<List[number], {
+    name: Name;
+}>;
+type Related<F, List extends Registry> = F extends {
+    relationTo: infer Relation;
+} ? Relation extends string ? Registered<List, Relation> : Relation extends () => infer Target ? Target extends {
+    name: infer Name;
+} ? [Registered<List, Name>] extends [never] ? Target : Registered<List, Name> : never : never : never;
+type OverrideSchema<F, L extends LanguageValues> = ServiceOf<L> extends {
+    schema: infer Name extends string;
+} ? string extends Name ? never : F extends {
+    targets: infer Overrides;
+} ? Name extends keyof Overrides ? Overrides[Name] extends StandardSchemaV1 ? Overrides[Name] : never : never : never : never;
+type Localize<F, L extends LanguageValues, V> = F extends {
+    rules: {
+        localized: true;
+    };
+} ? Record<LocalesOf<L>, V> : V;
+type KindCarried<F, L extends LanguageValues, List extends Registry> = F extends {
+    kind: infer Name extends keyof L['kinds'];
+} ? L['kinds'][Name] extends {
+    pointsAtRow: true;
+} ? Related<F, List> extends {
+    fields: {
+        id: infer Id;
+    };
+} ? F extends {
+    hasMany: true;
+} ? Value<Id, L, List>[] : Value<Id, L, List> : never : L['kinds'][Name] extends Kind<infer V, string> ? V : never : never;
+type Value<F, L extends LanguageValues, List extends Registry> = [OverrideSchema<F, L>] extends [never] ? Localize<F, L, KindCarried<F, L, List>> : Exclude<InferOutput<OverrideSchema<F, L> & StandardSchemaV1>, undefined>;
+type InputValue<F, L extends LanguageValues, List extends Registry> = [OverrideSchema<F, L>] extends [never] ? Value<F, L, List> : InferInput<OverrideSchema<F, L> & StandardSchemaV1>;
+type Supplied<Fields, On extends 'create' | 'update'> = {
+    [K in keyof Fields as K extends 'id' ? K : Fields[K] extends {
+        rules: {
+            providedBy: Record<On, infer Provider>;
+        };
+    } ? [Provider] extends ['client'] ? K : never : K]: Fields[K];
+};
+/** Required, and nothing fills it for you. */
+type Needed<F> = F extends {
+    rules: {
+        required: true;
+    };
+} ? F extends {
+    rules: {
+        defaultValue: unknown;
+    };
+} | {
+    rules: {
+        defaultNow: true;
+    };
+} ? false : true : false;
+/** Optional columns accept null; required columns and ids never do. */
+type Settable<F, L extends LanguageValues, List extends Registry> = F extends {
+    rules: {
+        required: true;
+    };
+} ? InputValue<F, L, List> : InputValue<F, L, List> | null;
+type CreateInput<Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = CreateKeys<Supplied<Fields, 'create'>, L, List>;
+type CreateKeys<Fields, L extends LanguageValues, List extends Registry> = {
+    [K in keyof Fields as K extends 'id' ? never : Needed<Fields[K]> extends true ? K : never]: InputValue<Fields[K], L, List>;
+} & {
+    [K in keyof Fields as K extends 'id' ? K : Needed<Fields[K]> extends true ? never : K]?: K extends 'id' ? InputValue<Fields[K], L, List> : Settable<Fields[K], L, List>;
+};
+/** An update carries only what changes; each site that takes one adds the id beside it. */
+type UpdateInput<Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = {
+    [K in keyof Supplied<Fields, 'update'> as K extends 'id' ? never : K]?: Settable<Supplied<Fields, 'update'>[K], L, List>;
+};
+/**
+ * The id's type, and `never` for fields that name no id. `never` is reachable
+ * at the type level only: `buildAsas` refuses a kayan with no id field.
+ */
+type Id<Fields, L extends LanguageValues, List extends Registry> = Fields extends {
+    id: infer F;
+} ? InputValue<F, L, List> : never;
+type StoredRow<Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = {
+    [K in keyof Fields]: K extends 'id' ? Value<Fields[K], L, List> : Fields[K] extends {
+        rules: {
+            required: true;
+        };
+    } ? Value<Fields[K], L, List> : Value<Fields[K], L, List> | null;
+};
+type Opaque<F> = F extends {
+    kind: 'join';
+} ? F : F extends {
+    relationTo: unknown;
+} ? Omit<F, 'kind'> & {
+    kind: 'opaque';
+} : F;
+type DerivedFields<Fields extends Record<string, RuntimeField>> = {
+    [K in keyof Fields]: Opaque<Fields[K]>;
+};
+type Deriving<Schema extends string> = {
+    kinds: typeof defaultKinds & {
+        opaque: Kind<unknown>;
+        richText: Kind<RichTextValue>;
+    };
+    targets: {
+        service: {
+            capability: 'service';
+            schema: Schema;
+        };
+    };
+};
+/** Every field, with the id optional: what a target's derived create shape takes. */
+export type CreateOf<Fields extends Record<string, RuntimeField>, Schema extends string> = CreateInput<DerivedFields<Fields>, Deriving<Schema>, []>;
+/** What an addressed operation takes: the id, inside its input. */
+export type ByID<Fields, L extends LanguageValues, List extends Registry> = {
+    id: Id<Fields, L, List>;
+};
+/** The same shape partial, with the id required. */
+export type UpdateOf<Fields extends Record<string, RuntimeField>, Schema extends string> = UpdateInput<DerivedFields<Fields>, Deriving<Schema>, []> & ByID<DerivedFields<Fields>, Deriving<Schema>, []>;
+/** The id alone: what a target's derived id shape takes, and nothing beside it. */
+export type IdOf<Fields extends Record<string, RuntimeField>, Schema extends string> = ByID<DerivedFields<Fields>, Deriving<Schema>, []>;
+/** Every column, and a nullable one wherever nothing requires the field. */
+export type RowOf<Fields extends Record<string, RuntimeField>, Schema extends string> = StoredRow<DerivedFields<Fields>, Deriving<Schema>, []>;
+/** The row that comes back after field read access projection. */
+export type Row<Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = Omit<StoredRow<Fields, L, List>, {
+    [K in keyof Fields]: Fields[K] extends {
+        access: {
+            read: unknown;
+        };
+    } ? K : never;
+}[keyof Fields]> & Partial<Pick<StoredRow<Fields, L, List>, {
+    [K in keyof Fields]: Fields[K] extends {
+        access: {
+            read: unknown;
+        };
+    } ? K : never;
+}[keyof Fields]>>;
+type OperationInput<Operation> = Operation extends {
+    input: (...args: never[]) => infer Schema;
+} ? Schema extends StandardSchemaV1 ? InferInput<Schema> : never : never;
+/** The declared input where the operation has one, and the derived shape where it does not. */
+export type OperationData<Operation, Derived> = [OperationInput<Operation>] extends [never] ? Derived : OperationInput<Operation>;
+type OperationOutput<Operation> = Operation extends {
+    input: (...args: never[]) => infer Schema;
+} ? Schema extends StandardSchemaV1 ? InferOutput<Schema> : never : never;
+/** What a step is handed: the parsed shape where the operation declares one, the derived shape where it does not. */
+export type OperationParsed<Operation, Derived> = [OperationOutput<Operation>] extends [never] ? Derived : OperationOutput<Operation>;
+type SealOfStep<Held> = Held extends {
+    __seal: infer Name;
+} ? Name : never;
+type ActingSeal<Operation> = StepsOf<Operation> extends readonly (infer Held)[] ? Extract<SealOfStep<Held>, 'count' | 'find' | 'findOne' | 'insert' | 'remove' | 'update' | 'updateMany' | 'deleteMany' | 'findVersions' | 'findVersionByID' | 'restoreVersion'> : never;
+/** `many`, `one`, `count`, `versions`, `version`, or nothing at all for an operation that writes. */
+type ReadModeOf<Operation> = [ActingSeal<Operation>] extends [never] ? undefined : ActingSeal<Operation> extends 'find' ? 'many' : ActingSeal<Operation> extends 'findOne' ? 'one' : ActingSeal<Operation> extends 'count' ? 'count' : ActingSeal<Operation> extends 'findVersions' ? 'versions' : ActingSeal<Operation> extends 'findVersionByID' ? 'version' : undefined;
+type IsReadOperation<Operation> = [ReadModeOf<Operation>] extends [undefined] ? false : true;
+/**
+ * A kayan's operations, read off its own declaration alone: nothing is merged
+ * in, so the names a kayan answers are the keys it wrote.
+ */
+type OwnOperations<K> = K extends {
+    targets: {
+        service: {
+            operations: infer O;
+        };
+    };
+} ? O : Record<never, never>;
+type OwnOperation<K, Name extends PropertyKey> = Name extends keyof OwnOperations<K> ? OwnOperations<K>[Name] : never;
+export type DerivedInput<Operation, Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = ActingSeal<Operation> extends 'insert' ? CreateInput<Fields, L, List> : ActingSeal<Operation> extends 'updateMany' ? {
+    where: Where;
+    data: UpdateInput<Fields, L, List>;
+} : ActingSeal<Operation> extends 'deleteMany' ? {
+    where: Where;
+} : ActingSeal<Operation> extends 'findOne' ? ByID<Fields, L, List> & Pick<FindInput, 'depth'> : ActingSeal<Operation> extends 'remove' ? ByID<Fields, L, List> : ActingSeal<Operation> extends 'findVersionByID' | 'restoreVersion' ? {
+    id: string;
+} : ActingSeal<Operation> extends 'update' ? UpdateInput<Fields, L, List> & ByID<Fields, L, List> : ActingSeal<Operation> extends 'count' ? {
+    where?: Where;
+} : FindInput;
+/** One version as a version read answers it: its snapshot cut to the reader's field access and held to its kinds, so every column may be absent. */
+export type Version<Doc> = {
+    id: string;
+    parent: unknown;
+    latest: boolean;
+    autosave: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    version: Partial<Doc>;
+};
+type PaginatedRows<Doc> = {
+    docs: Doc[];
+    totalDocs: number;
+    limit: number;
+    page: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    nextPage: number | null;
+    prevPage: number | null;
+    pagingCounter: number;
+};
+type OutputRow<Operation> = Operation extends {
+    output: infer Given;
+} ? Given extends (...args: never[]) => infer Schema ? Schema extends StandardSchemaV1 ? InferOutput<Schema> : never : Given extends StandardSchemaV1 ? InferOutput<Given> : never : never;
+/** The custom output's row where the operation declares one, the kayan's row where it does not. */
+type ResultRow<Operation, Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = [
+    OutputRow<Operation>
+] extends [never] ? Row<Fields, L, List> : OutputRow<Operation>;
+type BulkOutput<Operation, Doc> = [OutputRow<Operation>] extends [never] ? BulkResult<Doc> : OutputRow<Operation>;
+type OperationResult<Operation, Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = [
+    ActingSeal<Operation>
+] extends [never] ? Promise<ResultRow<Operation, Fields, L, List>> : ActingSeal<Operation> extends 'updateMany' | 'deleteMany' ? Promise<BulkOutput<Operation, Row<Fields, L, List>>> : ReadModeOf<Operation> extends 'count' ? Promise<{
+    totalDocs: number;
+}> : ReadModeOf<Operation> extends 'versions' ? Promise<PaginatedRows<Version<Row<Fields, L, List>>>> : ReadModeOf<Operation> extends 'version' ? Promise<Version<Row<Fields, L, List>>> : ReadModeOf<Operation> extends 'many' ? Promise<PaginatedRows<ResultRow<Operation, Fields, L, List>>> : ReadModeOf<Operation> extends 'one' ? Promise<ResultRow<Operation, Fields, L, List>> : Promise<ResultRow<Operation, Fields, L, List>>;
+/** What one operation takes: its declared input, or the shape its seal implies. */
+type InputOf<K, Name extends PropertyKey, Fields extends Record<string, RuntimeField>, L extends LanguageValues, List extends Registry> = OperationData<OwnOperation<K, Name>, DerivedInput<OwnOperation<K, Name>, Fields, L, List>>;
+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>;
+export type BoundKayans<KayanList extends Registry, L extends LanguageValues, Mode extends 'read' | 'write' = 'write'> = {
+    [K in KayanList[number] as K['name']]: BoundOne<K, K['fields'], L, KayanList, Mode>;
+};
+type OwnService<K> = K extends {
+    targets: {
+        service: infer Service;
+    };
+} ? Service : unknown;
+type DefaultStoreOf<L> = ServiceOf<L> extends {
+    store: infer Name extends string;
+} ? Name : never;
+type StoreNameOf<K, L> = OwnService<K> extends {
+    store: infer Name extends string;
+} ? Name : DefaultStoreOf<L>;
+type SchemaNameOf<K, L> = OwnService<K> extends {
+    schema: infer Name extends string;
+} ? Name : ServiceOf<L> extends {
+    schema: infer Name extends string;
+} ? Name : never;
+type TargetNamed<L, Name> = L extends {
+    targets: infer Targets;
+} ? Name extends keyof Targets ? Targets[Name] : never : never;
+type FieldsOfKayan<K> = K extends {
+    fields: infer Fields extends Record<string, RuntimeField>;
+} ? Fields : never;
+type KayanOutputs<K, List extends Registry, L extends LanguageValues, Operations> = {
+    service: {
+        operations: Operations;
+    };
+} & {
+    [Name in SchemaNameOf<K, L>]: {
+        schemas: DerivedSchemas<TargetNamed<L, Name>, FieldsOfKayan<K>>;
+    };
+} & (TargetNamed<L, StoreNameOf<K, L>> extends {
+    tables: unknown;
+} ? K extends {
+    name: infer Name extends string;
+} ? {
+    [Named in StoreNameOf<K, L>]: {
+        table: BuiltTables<List, StoreNameOf<K, L>, DefaultStoreOf<L>, L['kinds']>[Name];
+    };
+} : {} : {});
+type Built<K, List extends Registry, L extends LanguageValues, Operations> = {
+    name: K extends {
+        name: infer Name;
+    } ? Name : string;
+    fields: FieldsOfKayan<K>;
+    /** The same object as `targets.service.operations`, which the service capability always publishes. */
+    operations: Operations;
+    targets: KayanOutputs<K, List, L, Operations>;
+};
+type GlobalOperations<K extends Registry[number], List extends Registry, L extends LanguageValues, Actor> = {
+    findOne(...args: CallArgs<L, Actor, {
+        depth?: number;
+    }>): Promise<Row<K['fields'], L, List> | null>;
+    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> = {
+    [K in GlobalList[number] as K['name']]: Built<K, List, L, GlobalOperations<K, List, L, Actor>>;
+};
+type KayanOperations<K extends Registry[number], List extends Registry, L extends LanguageValues, Actor> = {
+    [Name in keyof OwnOperations<K>]: (...args: CallArgs<L, Actor, InputOf<K, Name, K['fields'], L, List>, IsReadOperation<OwnOperation<K, Name>>>) => OperationResult<OwnOperation<K, Name>, K['fields'], L, List>;
+};
+/** What `asas.kayan` holds. A relationship may point at a global, so `List` holds both. */
+export type Writes<KayanList extends Registry, List extends Registry, L extends LanguageValues, Actor = unknown> = {
+    [K in KayanList[number] as K['name']]: Built<K, List, L, KayanOperations<K, List, L, Actor>>;
+};
+type Sent<Method> = Method extends (...args: infer Args) => infer Answer ? (input: Exclude<Args[0], undefined>) => Answer : never;
+/** Every operation of one bound kayan, as procedures. */
+type Procedural<Bound> = {
+    [Name in keyof Bound]: Sent<Bound[Name]>;
+};
+/** The static view of the operation table, keyed by kayan then operation: what each published operation takes and answers. */
+export type Procedures<KayanList extends Registry, GlobalList extends Registry, List extends Registry, L extends LanguageValues> = {
+    [K in KayanList[number] as K['name']]: Procedural<BoundOne<K, K['fields'], L, List, 'write'>>;
+} & {
+    [K in GlobalList[number] as K['name']]: {
+        findOne: (input: {
+            depth?: number;
+        }) => Promise<Row<K['fields'], L, List> | null>;
+        update: (input: UpdateInput<K['fields'], L, List>) => Promise<Row<K['fields'], L, List>>;
+    };
+};
+export {};