foldkit-remote 0.20.0 → 0.22.0

package/dist/mutation.js

@@ -0,0 +1,612 @@
+import { own, put } from "./record.js";
+import { refParts } from "./relation.js";
+import { emptyStore, entityKey, tombstone, writeEntities } from "./store.js";
+import { holderOf } from "./held.js";
+import { Data, Effect, Match, Option, Record, Schema } from "effect";
+import { Derivation, Entity, Held, Write } from "foldkit-entity";
+// src/mutation.ts
+/**
+* Mutation status and idempotent reconciliation.
+*
+* A mutation result is reconciled into the store **at most once per
+* `requestId`**, so a transport retry cannot apply the same change twice. An
+* unknown or already-applied result is a no-op.
+*/
+const emptyMutationState = {
+	pending: /* @__PURE__ */ new Set(),
+	applied: /* @__PURE__ */ new Set(),
+	failed: /* @__PURE__ */ new Set(),
+	errors: /* @__PURE__ */ new Map(),
+	operations: /* @__PURE__ */ new Map(),
+	writes: /* @__PURE__ */ new Map(),
+	sequence: 0,
+	order: /* @__PURE__ */ new Map(),
+	settled: /* @__PURE__ */ new Map()
+};
+/**
+* How many settled request ids a mutation state retains. A retry settles well
+* inside this window, so bounding the ledger stops a long-lived application
+* from growing it without limit; a retry older than the window would re-apply
+* its entities.
+*/
+const MUTATION_ID_WINDOW = 1024;
+/** Records `id` as most recent, evicting the oldest once the window is full. */
+const remember = (ids, id) => {
+	const next = new Set(ids);
+	next.delete(id);
+	next.add(id);
+	if (next.size <= MUTATION_ID_WINDOW) return next;
+	return new Set([...next].slice(next.size - MUTATION_ID_WINDOW));
+};
+const beginMutation = (state, requestId, write) => ({
+	...state,
+	pending: /* @__PURE__ */ new Set([...state.pending, requestId]),
+	writes: write === void 0 ? state.writes : new Map([...state.writes, [requestId, write]]),
+	sequence: state.sequence + 1,
+	order: new Map([...state.order, [requestId, state.sequence + 1]])
+});
+const failMutation = (state, requestId, error, operation) => {
+	if (!state.pending.has(requestId)) return state;
+	const pending = new Set(state.pending);
+	pending.delete(requestId);
+	const failed = remember(state.failed, requestId);
+	const errors = new Map([...state.errors, [requestId, error]]);
+	const operations = new Map([...state.operations, [requestId, operation]]);
+	const writes = new Map(state.writes);
+	for (const id of errors.keys()) if (!failed.has(id)) errors.delete(id);
+	for (const id of operations.keys()) if (!failed.has(id)) operations.delete(id);
+	for (const id of writes.keys()) if (!failed.has(id) && !pending.has(id)) writes.delete(id);
+	return {
+		...state,
+		pending,
+		failed,
+		errors,
+		operations,
+		writes,
+		...ordered(state, requestId, [])
+	};
+};
+/**
+* `order` without a request that settled, and `settled` with what its answer
+* wrote (`marks`), each kept only while a request started before it is pending.
+*/
+const ordered = (state, requestId, marks) => {
+	const at = state.order.get(requestId);
+	const order = new Map(state.order);
+	order.delete(requestId);
+	const earliest = Math.min(...order.values());
+	const settled = /* @__PURE__ */ new Map();
+	for (const [mark, by] of state.settled) if (by > earliest) settled.set(mark, by);
+	if (at !== void 0 && at > earliest) for (const mark of marks) settled.set(mark, at);
+	return {
+		order,
+		settled
+	};
+};
+/** The ledger with a request's failure forgotten: its id, error, operation and write. */
+const forgetFailure = (state, requestId) => {
+	const without = (map) => {
+		if (!map.has(requestId)) return map;
+		const next = new Map(map);
+		next.delete(requestId);
+		return next;
+	};
+	return {
+		...state,
+		failed: state.failed.has(requestId) ? new Set([...state.failed].filter((id) => id !== requestId)) : state.failed,
+		errors: without(state.errors),
+		operations: without(state.operations),
+		writes: without(state.writes)
+	};
+};
+const mutationStatus = (state, requestId) => {
+	if (state.pending.has(requestId)) return { _tag: "Pending" };
+	if (state.applied.has(requestId)) return { _tag: "Applied" };
+	const error = state.errors.get(requestId);
+	return error === void 0 ? { _tag: "Unknown" } : {
+		_tag: "Failed",
+		error
+	};
+};
+/**
+* What requests started after `requestId` already settled, which its answer
+* leaves alone. The server applied requests in the order they started, so a
+* later one's answer is newer: `newer` holds of a field it wrote (its mark)
+* and of a row it deleted (its key), `rewritten` of a row it wrote any field
+* of. An answer of a request no longer pending (after `forget`, or a failure)
+* has no order, and nothing is newer than it.
+*/
+const settledLater = (state, requestId) => {
+	const at = state.order.get(requestId) ?? Infinity;
+	return {
+		newer: (mark) => (state.settled.get(mark) ?? -Infinity) > at,
+		rewritten: (key) => [...state.settled].some(([mark, by]) => by > at && mark.startsWith(`${key}\u0000`))
+	};
+};
+/**
+* Applies a mutation result once and marks the request settled. A second call
+* with the same `requestId` (a retry, or a live event describing the same change)
+* does not re-apply the entities, but still clears `pending`.
+*/
+const reconcileMutation = (store, state, requestId, answer) => {
+	const repeated = state.applied.has(requestId);
+	if (repeated && !state.pending.has(requestId) && !state.failed.has(requestId)) return {
+		store,
+		state
+	};
+	const { newer, rewritten } = settledLater(state, requestId);
+	const writes = repeated ? [] : answer.entities.flatMap((entity) => {
+		const key = entityKey(entity.entity, entity.id);
+		if (newer(key)) return [];
+		const values = Object.fromEntries(Object.entries(entity.values).filter(([field]) => !newer(`${key}\u0000${field}`)));
+		return Object.keys(values).length === 0 ? [] : [{
+			key,
+			values
+		}];
+	});
+	const deleted = repeated ? [] : (answer.deleted ?? []).map((gone) => entityKey(gone.entity, gone.id)).filter((key) => !rewritten(key));
+	const next = deleted.reduce(tombstone, writeEntities(store, writes, answer.now));
+	const applied = remember(state.applied, requestId);
+	const pending = new Set(state.pending);
+	pending.delete(requestId);
+	const marks = [...writes.flatMap((write) => Object.keys(write.values).map((field) => `${write.key}\u0000${field}`)), ...deleted];
+	return {
+		store: next,
+		state: {
+			...forgetFailure(state, requestId),
+			applied,
+			pending,
+			...ordered(state, requestId, marks)
+		}
+	};
+};
+const conflict = Schema.TaggedStruct("Conflict", {});
+const unmet = Schema.TaggedStruct("Unmet", {});
+/**
+* Another row already holds the id an insert names: its Entity and that id,
+* both the caller's own, and nothing of the row, which may be hidden from them.
+*/
+const taken = Schema.TaggedStruct("Taken", {
+	entity: Schema.String,
+	id: Schema.String
+});
+/**
+* The row the write would leave breaks one of its Entity's invariants: which
+* one (its Entity and its id, since an id is unique only within one), what to
+* tell the author, and the fields to show it beside. None and empty when the
+* invariant reads a member hidden from whoever asked.
+*/
+const invalid = Schema.TaggedStruct("Invalid", {
+	entity: Schema.OptionFromOptionalNullOr(Schema.String),
+	rule: Schema.OptionFromNullOr(Schema.String),
+	message: Schema.String,
+	path: Schema.Array(Schema.String)
+});
+const conflictOrInvalid = Schema.Union([conflict, invalid]);
+const conflictUnmetOrInvalid = Schema.Union([
+	conflict,
+	unmet,
+	invalid
+]);
+const takenOrInvalid = Schema.Union([taken, invalid]);
+/** What the constructors typed a write by: its kind, and whether it holds a `when`. */
+const refusalOfWrite = (write) => {
+	const moved = () => Option.isSome(write.when) ? conflictUnmetOrInvalid : conflictOrInvalid;
+	return Match.value(write).pipe(Match.tagsExhaustive({
+		Insert: () => takenOrInvalid,
+		Update: moved,
+		Delete: moved
+	}));
+};
+const anyField = Schema.TaggedStruct("Field", {
+	key: Schema.String,
+	reason: Schema.Unknown
+});
+/** Refusals a form or an editor knows how to show. */
+const Refusal = {
+	/** One input key was refused, for `reason`, which a form shows beside that key. */
+	field: (key, reason) => Schema.TaggedStruct("Field", {
+		key: Schema.Literal(key),
+		reason
+	}),
+	/** The row moved on since the client read it; the author decides what wins. */
+	conflict,
+	/** The row does not hold what the write's `when` asks of it, where it would commit. */
+	unmet,
+	/** The id an insert names is taken: another create made it, or a retry the server could not tell. */
+	taken,
+	/** The row the write would leave breaks an invariant of its Entity. */
+	invalid,
+	/** Whether a refusal, of whatever mutation, is a `Refusal.field`. */
+	isField: Schema.is(anyField),
+	/** Whether a refusal, of whatever mutation, is `Refusal.conflict`. */
+	isConflict: Schema.is(conflict),
+	/** Whether a refusal, of whatever mutation, is `Refusal.unmet`. */
+	isUnmet: Schema.is(unmet),
+	/** Whether a refusal, of whatever mutation, is `Refusal.taken`. */
+	isTaken: Schema.is(taken),
+	/** Whether a refusal, of whatever mutation, is `Refusal.invalid`. */
+	isInvalid: Schema.is(invalid),
+	/**
+	* Whether a refusal is `Refusal.invalid` naming this invariant, by its
+	* Entity and its id: the declaration `Entity.invariant` returned, once
+	* attached, or one `Entity.invariants` reads. An invariant over a member
+	* hidden from the asker names none, so it matches nothing.
+	*/
+	isInvalidBy: (refusal, invariant) => Schema.is(invalid)(refusal) && Option.contains(refusal.entity, invariant.entity) && Option.contains(refusal.rule, invariant.id)
+};
+/** The codec itself, or a `Schema.Struct` over the fields. */
+const schemaOf = (shape) => Schema.isSchema(shape) ? shape : Schema.Struct(shape);
+/**
+* A bound write as the store patches it: its fields as they are, and each
+* relation it points as the ref key the store holds (`'User:u1'`), or null.
+*/
+const patchOfWrite = (bound) => ({
+	entity: bound.entity,
+	id: bound.id,
+	values: {
+		...bound.values,
+		...Record.map(bound.links, (link) => Option.match(link, {
+			onNone: () => null,
+			onSome: (ref) => entityKey(ref.entity, ref.id)
+		}))
+	}
+});
+/**
+* One member of a row as `store` holds it, for a path from the viewer: a row
+* known gone reaches no row (null), and a row or a field never read is unheld.
+*/
+const heldIn = (store) => (row, key) => {
+	const entry = store[entityKey(row.entity, row.id)];
+	if (entry === void 0) return Effect.succeed(Held.unheld(`${row.entity} ${row.id} is not held`));
+	if (entry.tombstone) return Effect.succeed(Held.of(null));
+	return Effect.succeed(entry.present.has(key) ? Held.of(entry.values[key]) : Held.unheld(`${row.entity}.${key} of ${row.id} is not held`));
+};
+/**
+* A write bound to its input, with what its Entity sets from the context
+* (`Entity.sets`) as `context` gives it: who asks (`Remote.make`'s viewer),
+* what their row holds (read from `store`), and when the reader acted
+* (`Data.mutate`'s `now`). A member with no value to give is left out of the
+* prediction, and the answer brings it.
+*/
+const contextBound = (write, input, keys, context, store) => {
+	const bound = Write.bind(write, input, keys);
+	const set = Effect.runSync(Write.contextValues(write, context, heldIn(store)));
+	return {
+		...bound,
+		values: {
+			...bound.values,
+			...set.values
+		},
+		links: {
+			...bound.links,
+			...set.links
+		}
+	};
+};
+const nobody = {
+	viewer: Option.none(),
+	now: Option.none()
+};
+/**
+* What a declared write shows before the server answers: an update's or an
+* insert's row as a patch (an update's only for the keys named, when some
+* are), and an update's increments and computed fields, worked out over the
+* row the store holds when it is read. A delete shows its row deleted. What
+* the context sets is filled from `context` and `store`, where it can be.
+*/
+const optimisticOfWrite = (write, input, keys, context = nobody, store = emptyStore) => Match.value(write).pipe(Match.tagsExhaustive({
+	Update: () => {
+		const bound = contextBound(write, input, keys, context, store);
+		return [{
+			...patchOfWrite(bound),
+			...Object.keys(bound.increments).length === 0 ? {} : { adds: bound.increments },
+			...Object.keys(bound.assignments).length === 0 ? {} : { computes: bound.assignments }
+		}];
+	},
+	Insert: () => {
+		const patch = patchOfWrite(contextBound(write, input, void 0, context, store));
+		return [{
+			...patch,
+			values: {
+				id: patch.id,
+				...patch.values
+			}
+		}];
+	},
+	Delete: () => {
+		const { entity, id } = Write.bind(write, input);
+		return [{
+			_tag: "Delete",
+			entity,
+			id
+		}];
+	}
+}));
+const DerivedBy = Data.taggedEnum();
+/**
+* The derived members a declared write moves, as pending patches of the rows
+* its row points at. A count: an insert adds one where it points, a delete
+* takes one away where the row pointed, and a relink does both. An exists:
+* a row now pointing here and at `viewer` is found (its id), and a row the
+* store shows as found by this one is no longer, once the write deletes it or
+* points it elsewhere.
+*
+* Where the row pointed before is read from `store`: the row as held, or,
+* when the store holds an exists found by this row, the row it is found on
+* and the viewer. When neither says, nothing is predicted and the answer
+* decides. A member is moved only on a row that `store` holds it on.
+*/
+const derivedOfWrite = (write, input, keys, derived, store, context) => {
+	if (derived.length === 0) return [];
+	const bound = contextBound(write, input, write._tag === "Update" ? keys : void 0, context, store);
+	const row = store[entityKey(bound.entity, bound.id)];
+	const held = row === void 0 || row.tombstone ? void 0 : row;
+	const viewerKey = Option.map(context.viewer, (ref) => entityKey(ref.entity, ref.id));
+	/** What a live row holds in `field`, as the store has it; none for a row gone or not held. */
+	const holding = (key, field) => Option.flatMap(Option.fromUndefinedOr(store[key]), (entry) => entry.tombstone ? Option.none() : Option.some(entry.values[field]));
+	const found = /* @__PURE__ */ new Map();
+	if (write._tag !== "Insert") for (const member of derived.filter(DerivedBy.$is("Exists"))) found.set(member, Object.keys(store).filter((key) => key.startsWith(`${member.owner}:`) && Option.contains(holding(key, member.field), bound.id)));
+	const before = (relation) => {
+		if (held !== void 0 && held.present.has(relation)) return Option.some(held.values[relation]);
+		for (const [member, rows] of found) {
+			if (rows.length === 0) continue;
+			if (member.relation === relation) return Option.some(rows[0]);
+			if (member.viewer === relation && Option.isSome(viewerKey)) return viewerKey;
+		}
+		return write._tag === "Insert" ? Option.some(null) : Option.none();
+	};
+	const patched = patchOfWrite(bound).values;
+	const after = (relation) => Match.value(write).pipe(Match.tagsExhaustive({
+		Delete: () => Option.some(null),
+		Insert: () => Option.some(Object.hasOwn(bound.links, relation) ? patched[relation] : null),
+		Update: () => Object.hasOwn(bound.links, relation) ? Option.some(patched[relation]) : before(relation)
+	}));
+	const moves = /* @__PURE__ */ new Map();
+	const at = (ref, owner) => {
+		const move = moves.get(ref) ?? {
+			owner,
+			values: {},
+			adds: {}
+		};
+		moves.set(ref, move);
+		return move;
+	};
+	const count = (ref, owner, field, by) => {
+		if (typeof ref !== "string") return;
+		if (!Option.exists(holding(ref, field), (value) => typeof value === "number")) return;
+		const move = at(ref, owner);
+		put(move.adds, field, (own(move.adds, field) ?? 0) + by);
+	};
+	for (const member of derived) DerivedBy.$match(member, {
+		Count: ({ relation, owner, field }) => {
+			const from = before(relation);
+			const to = after(relation);
+			if (Option.isNone(from) || Option.isNone(to) || from.value === to.value) return;
+			count(from.value, owner, field, -1);
+			count(to.value, owner, field, 1);
+		},
+		Exists: (exists) => {
+			const { relation, viewer: by, owner, field } = exists;
+			const pointed = after(relation);
+			const viewing = Option.flatMap(after(by), (ref) => Option.map(viewerKey, (key) => ref === key));
+			for (const ref of found.get(exists) ?? []) if (Option.exists(pointed, (to) => to !== ref) || Option.contains(viewing, false)) put(at(ref, owner).values, field, null);
+			if (!Option.contains(viewing, true) || Option.isNone(pointed)) return;
+			const to = pointed.value;
+			if (typeof to === "string" && Option.contains(holding(to, field), null)) put(at(to, owner).values, field, bound.id);
+		}
+	});
+	return [...moves].flatMap(([ref, { owner, values, adds }]) => {
+		const moved = Object.fromEntries(Object.entries(adds).filter(([, by]) => by !== 0));
+		return Object.keys(values).length === 0 && Object.keys(moved).length === 0 ? [] : [{
+			entity: owner,
+			id: refParts(ref).id,
+			values,
+			...Object.keys(moved).length === 0 ? {} : { adds: moved }
+		}];
+	});
+};
+/**
+* A new row's derived members over relations: each count 0 and each exists
+* none, since no row points at a row not yet made. A later pending write that
+* points at it moves them as it would any held row's.
+*/
+const freshDerived = (write, input, derived) => {
+	const entity = write.input.entity.name;
+	const values = {};
+	for (const members of derived.values()) for (const member of members) if (member.owner === entity) put(values, member.field, DerivedBy.$match(member, {
+		Count: () => 0,
+		Exists: () => null
+	}));
+	if (Object.keys(values).length === 0) return [];
+	const { id } = Write.bind(write, input);
+	return [{
+		entity,
+		id,
+		values
+	}];
+};
+/** Each supplied member of `entity` that says how a client foresees it, by key. */
+const predicted = /* @__PURE__ */ new WeakMap();
+const predictorsOf = (entity) => {
+	const known = predicted.get(entity);
+	if (known !== void 0) return known;
+	const derived = entity.derived;
+	const found = Object.entries(derived).flatMap(([key, member]) => Derivation.$match(member.derives, {
+		Supplied: ({ predict }) => Option.match(predict, {
+			onNone: () => [],
+			onSome: (run) => [[key, run]]
+		}),
+		Count: () => [],
+		Exists: () => []
+	}));
+	predicted.set(entity, found);
+	return found;
+};
+/**
+* The supplied members a write's row foresees (`Derived.make`'s `predict`),
+* judged over the row it leaves, held over the store with the write's values:
+* a member foreseen as none is left out, so the row waits for the answer.
+*/
+const suppliedOfWrite = (write, own, by, store) => {
+	const entity = write.input.entity;
+	const predictors = predictorsOf(entity);
+	if (predictors.length === 0) return [];
+	const holder = holderOf(store);
+	const row = holder.written(entity, own.id, own.values, [...Object.keys(own.adds ?? {}), ...Object.keys(own.computes ?? {})]);
+	const values = {};
+	for (const [key, predict] of predictors) Option.map(predict({
+		entity,
+		row,
+		rows: holder.rows,
+		context: by
+	}), (value) => {
+		put(values, key, value);
+	});
+	return Object.keys(values).length === 0 ? [] : [{
+		entity: entity.name,
+		id: own.id,
+		values
+	}];
+};
+/**
+* Everything a declared write shows before the server answers, from its
+* declarations alone: its own row (`optimisticOfWrite`), with what the
+* context sets filled from `viewer` and `now`, a new row's
+* derived members (`freshDerived`), what its supplied members foresee
+* (`suppliedOfWrite`, Guard's `may`), and the derived members it moves on
+* the rows it points at (`derivedOfWrite`). `derived` is the registry's, by
+* the pointing Entity; `store` is the store as shown, layers and all.
+*/
+const predictionOfWrite = (write, input, keys, context) => {
+	const by = {
+		viewer: context.viewer,
+		now: context.now
+	};
+	const own = optimisticOfWrite(write, input, keys, by, context.store);
+	return [
+		...Match.value(write).pipe(Match.tagsExhaustive({
+			Insert: () => freshDerived(write, input, context.derived),
+			Update: () => [],
+			Delete: () => []
+		})),
+		...own,
+		...own.flatMap((patch) => "_tag" in patch ? [] : suppliedOfWrite(write, patch, by, context.store)),
+		...derivedOfWrite(write, input, keys, context.derived.get(write.input.entity.name) ?? [], context.store, by)
+	];
+};
+/** The held fields of `row`, plain and encoded, as an invariant is judged over them. */
+const plainRow = (entity, row) => {
+	const plain = {};
+	for (const key of Object.keys(entity.fields)) Held.match(row.field(key), {
+		onHeld: (value) => {
+			put(plain, key, value);
+		},
+		onUnheld: () => void 0
+	});
+	return plain;
+};
+/**
+* The invariant a declared write's row would break, as the client holds it:
+* the store's row with the write's values over it, a field the write moves
+* (an increment, a computed value) not held, and for an update the row
+* before. Only a definite failure counts: an invariant over a field the
+* client lacks is undecided, and refuses nothing. A delete leaves no row.
+*/
+const brokenByWrite = (write, input, keys, context, store, operators) => {
+	const entity = write.input.entity;
+	const patch = optimisticOfWrite(write, input, keys, context, store).find((each) => !("_tag" in each));
+	if (patch === void 0) return Option.none();
+	const holder = holderOf(store);
+	const after = plainRow(entity, holder.written(entity, patch.id, patch.values, [...Object.keys(patch.adds ?? {}), ...Object.keys(patch.computes ?? {})]));
+	const before = Option.getOrUndefined(Option.map(holder.rows.row(entity, patch.id), (row) => plainRow(entity, row)));
+	const judged = Entity.judge(entity, write._tag === "Insert" || before === void 0 ? { after } : {
+		after,
+		before
+	}, operators);
+	return judged._tag === "Invalid" ? Option.fromUndefinedOr(judged.failures[0]) : Option.none();
+};
+/** Each supplied member of `entity` that says which write its value refuses, by key. */
+const forbidding = /* @__PURE__ */ new WeakMap();
+const forbiddersOf = (entity) => {
+	const known = forbidding.get(entity);
+	if (known !== void 0) return known;
+	const derived = entity.derived;
+	const found = Object.entries(derived).flatMap(([key, member]) => Derivation.$match(member.derives, {
+		Supplied: ({ forbids }) => Option.match(forbids, {
+			onNone: () => [],
+			onSome: (run) => [[key, run]]
+		}),
+		Count: () => [],
+		Exists: () => []
+	}));
+	forbidding.set(entity, found);
+	return found;
+};
+/**
+* Why a declared write is refused by what the client holds of its row: a
+* supplied member (Guard's `may`) whose value, as the store shows it, forbids
+* what the write does to the row. None where nothing held says so: an
+* insert, a row not held, or a member not held or not refusing.
+*/
+const forbiddenByWrite = (write, input, keys, store) => {
+	const entity = write.input.entity;
+	const forbidders = forbiddersOf(entity);
+	if (forbidders.length === 0) return Option.none();
+	const bound = Write.bind(write, input, keys);
+	const held = store[entityKey(entity.name, bound.id)];
+	if (held === void 0) return Option.none();
+	const surface = Match.valueTags(write, {
+		Insert: () => Option.none(),
+		Delete: () => Option.some({
+			kind: "Delete",
+			members: [],
+			relations: []
+		}),
+		Update: () => Option.some({
+			kind: "Update",
+			members: [
+				...Object.keys(bound.values),
+				...Object.keys(bound.increments),
+				...Object.keys(bound.assignments)
+			],
+			relations: Object.entries(bound.links).map(([relation, link]) => ({
+				relation,
+				interaction: Option.isSome(link) ? "Link" : "Unlink"
+			}))
+		})
+	});
+	return Option.flatMap(surface, (asked) => Option.firstSomeOf(forbidders.map(([key, forbids]) => held.present.has(key) ? forbids(held.values[key], asked) : Option.none())));
+};
+const Mutation = {
+	/**
+	* Declares a mutation. `Input` and `Output` are codecs, or the fields of the
+	* `Schema.Struct` they would be (`{ id: ProjectId, name: Schema.String }`).
+	* `Refusal`, when given, is what the server may refuse with: a codec, usually
+	* a union of `Refusal.field(...)` and `Refusal.conflict`.
+	*/
+	/**
+	* A mutation that is a declared `Write` (`update`, `insert` or `delete`): its
+	* input is the write's, and it answers nothing but the row it changed, as a
+	* patch, or its deletion. An insert may be refused as taken, when a row
+	* already holds its id; an update or a delete as a conflict, when it
+	* `expect`s a revision the row has moved past, and as unmet, when it has a
+	* `when`; and any as invalid, when the row it would leave breaks an invariant.
+	*/
+	write: (name, write) => ({
+		name,
+		Input: write.input.schema,
+		Output: Schema.Struct({}),
+		Refusal: refusalOfWrite(write),
+		write
+	}),
+	make: (name, config) => ({
+		name,
+		Input: schemaOf(config.Input),
+		Output: schemaOf(config.Output),
+		Refusal: config.Refusal ?? Schema.Never
+	})
+};
+export { DerivedBy, Mutation, Refusal, beginMutation, brokenByWrite, derivedOfWrite, emptyMutationState, failMutation, forbiddenByWrite, forgetFailure, mutationStatus, optimisticOfWrite, patchOfWrite, predictionOfWrite, reconcileMutation, schemaOf, settledLater };
+
+//# sourceMappingURL=mutation.js.map