@contember/bindx 0.1.51 → 0.1.53

package/src/store/HasManyStore.ts

@@ -1,115 +1,45 @@
-import { parentKeyFromOwnerPrefix, parentKeyFromRelationKey } from './relationKey.js'
+import { entityTypeFromRelationKey, fieldFromRelationKey, parentKeyFromOwnerPrefix, parentKeyFromRelationKey } from './relationKey.js'
 import { PlannedDeleteIndex } from './PlannedDeleteIndex.js'
 import { RelationEdgeIndex } from './RelationEdgeIndex.js'
 import { RelationOwnerIndex } from './RelationOwnerIndex.js'
-
-type ReconciliationResult = 'applied' | 'conflict'
-
-function setsEqual<T>(a: Set<T>, b: Set<T>): boolean {
-	if (a.size !== b.size) return false
-	for (const item of a) {
-		if (!b.has(item)) return false
-	}
-	return true
-}
-
-function arraysEqual(a: string[], b: string[]): boolean {
-	if (a.length !== b.length) return false
-	for (let i = 0; i < a.length; i++) {
-		if (a[i] !== b[i]) return false
-	}
-	return true
-}
-
-/**
- * Removal type for has-many items
- */
-export type HasManyRemovalType = 'disconnect' | 'delete'
-
-/**
- * Kind of a planned has-many addition:
- *   - 'created': a newly created entity (via add())
- *   - 'connected': an existing persisted entity being connected (via connect())
- */
-export type HasManyAdditionKind = 'created' | 'connected'
-
-export interface SentHasManyAddition {
-	itemId: string
-	kind: HasManyAdditionKind
-}
-
-export interface SentHasManyRemoval {
-	itemId: string
-	type: HasManyRemovalType
-}
-
-export interface SentHasManyDelta {
-	additions: readonly SentHasManyAddition[]
-	removals: readonly SentHasManyRemoval[]
-}
-
-/**
- * Has-many list state stored in SnapshotStore
- */
-export interface StoredHasManyState {
-	/** IDs of items from server */
-	serverIds: Set<string>
-	/** Explicit ordered list of item IDs, null means use default order (serverIds + plannedAdditions) */
-	orderedIds: string[] | null
-	/** Planned removals (disconnect or delete) keyed by entity ID */
-	plannedRemovals: Map<string, HasManyRemovalType>
-	/**
-	 * Planned additions (IDs to add to the list) keyed by entity ID, with the
-	 * value distinguishing newly CREATED entities (add()) from existing PERSISTED
-	 * entities being CONNECTED (connect()). The keys are exactly the connections;
-	 * the keys whose value is 'created' are exactly the created entities, so the
-	 * "created ⊆ connections" invariant is structural.
-	 */
-	plannedAdditions: Map<string, HasManyAdditionKind>
-	version: number
-}
-
-function cloneHasManyState(state: StoredHasManyState): StoredHasManyState {
-	return {
-		serverIds: new Set(state.serverIds),
-		orderedIds: state.orderedIds ? [...state.orderedIds] : null,
-		plannedRemovals: new Map(state.plannedRemovals),
-		plannedAdditions: new Map(state.plannedAdditions),
-		version: state.version,
-	}
-}
+import {
+	additionFoldTargets,
+	additionRendersIn,
+	arraysEqual,
+	cloneHasManyState,
+	computeViewOrderedIds,
+	createHasManyView,
+	emptyHasManyState,
+	liveHasManyChildIds,
+	plannedDeleteChildIds,
+	reconcileHasManyState,
+	setsEqual,
+	toRelationProjection,
+	toViewProjection,
+	viewOrderedIds,
+	type HasManyRelationProjection,
+	type HasManyRemovalType,
+	type HasManyViewMembership,
+	type HasManyViewProjection,
+	type PlannedHasManyAddition,
+	type ReconciliationResult,
+	type SentHasManyDelta,
+	type StoredHasManyState,
+} from './hasManyState.js'
 
 /**
- * Computes the default ordered IDs for a has-many relation.
- * Order is: serverIds (minus removals) + plannedAdditions
- */
-export function computeDefaultOrderedIds(state: StoredHasManyState): string[] {
-	const result: string[] = []
-
-	for (const id of state.serverIds) {
-		if (!state.plannedRemovals.has(id)) {
-			result.push(id)
-		}
-	}
-
-	for (const id of state.plannedAdditions.keys()) {
-		if (!result.includes(id)) {
-			result.push(id)
-		}
-	}
-
-	return result
-}
-
-/**
- * Owns has-many list state ("parentType:parentId:fieldName" → {@link StoredHasManyState}).
+ * Owns has-many relation state ("parentType:parentId:fieldName" → {@link StoredHasManyState}).
+ *
+ * The key's last segment is always the SCHEMA FIELD NAME; an args-view's alias
+ * addresses a view INSIDE the state, never a key of its own. See the module doc of
+ * `hasManyState.ts` for why reads are per view and writes are not.
  *
  * Has its own monotonic {@link mutationVersion} bumped on every actual write
  * (funnelled through {@link writeHasMany} plus the delete/clear paths); the
  * facade sums this with the has-one counter for {@link ReachabilityAnalyzer}.
  */
 export class HasManyStore {
-	/** Has-many list states keyed by "parentType:parentId:fieldName" */
+	/** Has-many relation states keyed by "parentType:parentId:fieldName" */
 	private readonly hasManyStates = new Map<string, StoredHasManyState>()
 	private readonly owners = new RelationOwnerIndex()
 
@@ -191,178 +121,154 @@ export class HasManyStore {
 	}
 
 	/**
-	 * Gets or creates has-many list state.
+	 * Membership declared for an args-view, keyed by "entityType:fieldName:alias" — one
+	 * entry per distinct selection in the application, so it does not grow with the data.
+	 * The alias alone would not do: two fields, or two entities' fields of the same name,
+	 * may carry the same explicit `as`.
+	 *
+	 * Only the caller that selected the relation knows its params, and the alias is a
+	 * hash it cannot reconstruct them from. {@link EntityHandle} declares them before
+	 * it hands out a handle, which is strictly before any path can materialize the view.
 	 */
-	getOrCreateHasMany(key: string, serverIds?: string[]): StoredHasManyState {
-		const existing = this.hasManyStates.get(key)
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(serverIds ?? []),
-				orderedIds: null,
-				plannedRemovals: new Map(),
-				plannedAdditions: new Map(),
-				version: 0,
-			})
-		} else if (serverIds !== undefined) {
-			const newServerIds = new Set(serverIds)
-			if (!setsEqual(existing.serverIds, newServerIds)) {
-				this.writeHasMany(key, {
-					...existing,
-					serverIds: newServerIds,
-					orderedIds: null,
-					version: existing.version + 1,
-				})
-			}
-		}
+	private readonly declaredMembership = new Map<string, HasManyViewMembership>()
 
-		return cloneHasManyState(this.hasManyStates.get(key)!)
+	declareViewMembership(
+		entityType: string,
+		fieldName: string,
+		alias: string,
+		membership: HasManyViewMembership,
+	): void {
+		this.declaredMembership.set(`${entityType}:${fieldName}:${alias}`, membership)
 	}
 
 	/**
-	 * Gets has-many list state.
+	 * A view addressed by the field name itself is the unparameterized selection, so
+	 * its args cannot exclude any member of the relation. Anything else needs a
+	 * declaration; without one the view is assumed filtered, which is the safe
+	 * direction — the client then never claims membership it cannot prove.
 	 */
-	getHasMany(key: string): StoredHasManyState | undefined {
-		const state = this.hasManyStates.get(key)
-		return state ? cloneHasManyState(state) : undefined
+	private viewMembership(key: string, alias: string): HasManyViewMembership {
+		const fieldName = fieldFromRelationKey(key)
+		if (alias === fieldName) return 'total'
+		return this.declaredMembership.get(`${entityTypeFromRelationKey(key)}:${fieldName}:${alias}`) ?? 'partial'
 	}
 
 	/**
-	 * Sets server IDs for a has-many relation.
+	 * Starts an edit: a deep copy of the current state (or a fresh one), with the
+	 * addressed view materialized. Every mutator builds on this, so no path can hand
+	 * {@link writeHasMany} a state sharing mutable structure with the live one — which
+	 * SnapshotStore's dirty-version memo and the undo journal's images both rely on.
 	 */
-	setHasManyServerIds(key: string, serverIds: string[]): void {
+	private editableState(key: string, alias?: string): StoredHasManyState {
 		const existing = this.hasManyStates.get(key)
-
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(serverIds),
-				orderedIds: null,
-				plannedRemovals: new Map(),
-				plannedAdditions: new Map(),
-				version: 0,
-			})
-		} else {
-			this.writeHasMany(key, {
-				...existing,
-				serverIds: new Set(serverIds),
-				orderedIds: null,
-				version: existing.version + 1,
-			})
+		const state = existing ? cloneHasManyState(existing) : emptyHasManyState()
+		if (alias !== undefined && !state.views.has(alias)) {
+			state.views.set(alias, createHasManyView(this.viewMembership(key, alias)))
 		}
+		return state
 	}
 
-	/**
-	 * Plans a removal for a has-many item.
-	 */
-	planHasManyRemoval(key: string, itemId: string, type: HasManyRemovalType): void {
+	private commitEdit(key: string, state: StoredHasManyState): void {
 		const existing = this.hasManyStates.get(key)
-
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(),
-				orderedIds: null,
-				plannedRemovals: new Map([[itemId, type]]),
-				plannedAdditions: new Map(),
-				version: 0,
-			})
-		} else {
-			const newPlannedRemovals = new Map(existing.plannedRemovals)
-			newPlannedRemovals.set(itemId, type)
-			const newPlannedAdditions = new Map(existing.plannedAdditions)
-			newPlannedAdditions.delete(itemId)
-			let newOrderedIds = existing.orderedIds
-			if (newOrderedIds !== null) {
-				newOrderedIds = newOrderedIds.filter(id => id !== itemId)
-			}
-			this.writeHasMany(key, {
-				...existing,
-				orderedIds: newOrderedIds,
-				plannedRemovals: newPlannedRemovals,
-				plannedAdditions: newPlannedAdditions,
-				version: existing.version + 1,
-			})
-		}
-		this.editableWriteVersion++
+		state.version = existing ? existing.version + 1 : 0
+		this.writeHasMany(key, state)
 	}
 
 	/**
-	 * Plans a connection for a has-many item.
+	 * Gets or creates the relation state and the addressed view, refreshing that
+	 * view's server baseline when one is supplied.
 	 */
-	planHasManyConnection(key: string, itemId: string): void {
-		const existing = this.hasManyStates.get(key)
+	getOrCreateHasMany(key: string, alias: string, serverIds?: string[]): void {
+		const view = this.hasManyStates.get(key)?.views.get(alias)
+		if (view && (serverIds === undefined || setsEqual(view.serverIds, new Set(serverIds)))) {
+			return
+		}
 
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(),
-				orderedIds: null,
-				plannedRemovals: new Map(),
-				plannedAdditions: new Map([[itemId, 'connected']]),
-				version: 0,
-			})
-		} else {
-			const newPlannedAdditions = new Map(existing.plannedAdditions)
-			// Do not downgrade an existing 'created' addition to 'connected'.
-			if (newPlannedAdditions.get(itemId) !== 'created') {
-				newPlannedAdditions.set(itemId, 'connected')
-			}
-			const newPlannedRemovals = new Map(existing.plannedRemovals)
-			newPlannedRemovals.delete(itemId)
-			let newOrderedIds = existing.orderedIds
-			if (newOrderedIds !== null && !newOrderedIds.includes(itemId)) {
-				newOrderedIds = [...newOrderedIds, itemId]
-			}
-			this.writeHasMany(key, {
-				...existing,
-				orderedIds: newOrderedIds,
-				plannedAdditions: newPlannedAdditions,
-				plannedRemovals: newPlannedRemovals,
-				version: existing.version + 1,
-			})
+		const state = this.editableState(key, alias)
+		if (serverIds !== undefined) {
+			const next = state.views.get(alias)!
+			next.serverIds = new Set(serverIds)
+			// A refreshed baseline invalidates only THIS view's manual ordering.
+			next.orderedIds = null
 		}
-		this.editableWriteVersion++
+		this.commitEdit(key, state)
 	}
 
-	/**
-	 * Commits has-many state after successful persist.
-	 */
-	commitHasMany(key: string, newServerIds: string[]): void {
-		const existing = this.hasManyStates.get(key)
+	/** Relation state, deep-copied. For the export / undo paths that move whole states. */
+	getHasMany(key: string): StoredHasManyState | undefined {
+		const state = this.hasManyStates.get(key)
+		return state ? cloneHasManyState(state) : undefined
+	}
+
+	/** What persistence, dirty tracking and error paths see: one relation, no views. */
+	getRelationProjection(key: string): HasManyRelationProjection | undefined {
+		const state = this.hasManyStates.get(key)
+		return state ? toRelationProjection(state) : undefined
+	}
 
-		this.writeHasMany(key, {
-			serverIds: new Set(newServerIds),
-			orderedIds: null,
-			plannedRemovals: new Map(),
-			plannedAdditions: new Map(),
-			version: (existing?.version ?? 0) + 1,
-		})
+	/** What one mounted has-many handle sees. */
+	getViewProjection(key: string, alias: string): HasManyViewProjection {
+		return toViewProjection(this.hasManyStates.get(key), alias)
+	}
+
+	/** Whether the relation carries writes the next persist would send. */
+	hasPendingWrites(key: string): boolean {
+		const state = this.hasManyStates.get(key)
+		if (!state) return false
+		return state.plannedRemovals.size > 0 || state.plannedAdditions.size > 0
+	}
+
+	/** Whether one view carries an order its user arranged rather than the default one. */
+	hasExplicitOrder(key: string, alias: string): boolean {
+		const orderedIds = this.hasManyStates.get(key)?.views.get(alias)?.orderedIds
+		return orderedIds !== null && orderedIds !== undefined
 	}
 
 	/**
-	 * Advances the server baseline by the confirmed sent delta and rebases local
-	 * edits made after the request started onto that new baseline.
+	 * Per-view server baselines by reference, for callers that only read them.
+	 *
+	 * Not cloned, deliberately: every mutator builds on {@link editableState}, so a
+	 * stored Set is never mutated in place — only replaced. A handed-out reference can
+	 * therefore go stale but can never be written through.
 	 */
-	reconcileSentDelta(key: string, delta: SentHasManyDelta): ReconciliationResult {
-		const existing = this.hasManyStates.get(key)
-		if (!existing) return 'conflict'
+	collectViewServerIds(key: string): ReadonlyMap<string, ReadonlySet<string>> {
+		const byView = new Map<string, ReadonlySet<string>>()
+		const state = this.hasManyStates.get(key)
+		if (state) {
+			for (const [alias, view] of state.views) byView.set(alias, view.serverIds)
+		}
+		return byView
+	}
 
-		const next = reconcileHasManyState(existing, delta)
-		this.writeHasMany(key, next.state)
-		return next.result
+	/** Replaces one view's server baseline. */
+	setHasManyServerIds(key: string, alias: string, serverIds: string[]): void {
+		const state = this.editableState(key, alias)
+		const view = state.views.get(alias)!
+		view.serverIds = new Set(serverIds)
+		view.orderedIds = null
+		this.commitEdit(key, state)
 	}
 
 	/**
-	 * Resets has-many state to server state (clears planned operations).
+	 * Plans a removal. Relation-level: the item stops being a member of the relation,
+	 * so it leaves every view's ordering too.
 	 */
-	resetHasMany(key: string): void {
-		const existing = this.hasManyStates.get(key)
-		if (!existing) return
+	planHasManyRemoval(key: string, itemId: string, type: HasManyRemovalType): void {
+		const state = this.editableState(key)
+		state.plannedRemovals.set(itemId, type)
+		state.plannedAdditions.delete(itemId)
+		this.dropFromEveryExplicitOrder(state, itemId)
+		this.commitEdit(key, state)
+		this.editableWriteVersion++
+	}
 
-		this.writeHasMany(key, {
-			serverIds: existing.serverIds,
-			orderedIds: null,
-			plannedRemovals: new Map(),
-			plannedAdditions: new Map(),
-			version: existing.version + 1,
-		})
+	/**
+	 * Plans a connection of an existing entity, rendered in the view it was made in.
+	 */
+	planHasManyConnection(key: string, alias: string, itemId: string): void {
+		const state = this.editableState(key, alias)
+		this.recordAddition(state, alias, itemId, 'connected')
+		this.commitEdit(key, state)
 		this.editableWriteVersion++
 	}
 
@@ -370,29 +276,14 @@ export class HasManyStore {
 	 * Adds a newly created entity to a has-many relation.
 	 * Used by HasManyListHandle.add() for inline entity creation.
 	 */
-	addToHasMany(key: string, itemId: string): void {
-		const existing = this.hasManyStates.get(key)
-
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(),
-				orderedIds: [itemId],
-				plannedRemovals: new Map(),
-				plannedAdditions: new Map([[itemId, 'created']]),
-				version: 0,
-			})
-		} else {
-			const newPlannedAdditions = new Map(existing.plannedAdditions)
-			newPlannedAdditions.set(itemId, 'created')
-			const currentOrderedIds = existing.orderedIds ?? computeDefaultOrderedIds(existing)
-			const newOrderedIds = [...currentOrderedIds, itemId]
-			this.writeHasMany(key, {
-				...existing,
-				orderedIds: newOrderedIds,
-				plannedAdditions: newPlannedAdditions,
-				version: existing.version + 1,
-			})
-		}
+	addToHasMany(key: string, alias: string, itemId: string): void {
+		const state = this.editableState(key, alias)
+		// The order is materialized BEFORE the addition is recorded, so the append
+		// cannot duplicate an id the default order would by then already contain.
+		const order = viewOrderedIds(state, alias)
+		this.recordAddition(state, alias, itemId, 'created')
+		state.views.get(alias)!.orderedIds = [...order, itemId]
+		this.commitEdit(key, state)
 		this.editableWriteVersion++
 	}
 
@@ -401,45 +292,92 @@ export class HasManyStore {
 	 * Unlike addToHasMany, records the addition as 'connected' (not 'created') —
 	 * used for materializing embedded connect references to existing entities.
 	 */
-	connectExistingToHasMany(key: string, itemId: string): void {
-		const existing = this.hasManyStates.get(key)
+	connectExistingToHasMany(key: string, alias: string, itemId: string): void {
+		const fresh = !this.hasManyStates.has(key)
+		const state = this.editableState(key, alias)
+		this.recordAddition(state, alias, itemId, 'connected')
+		if (fresh) {
+			state.views.get(alias)!.orderedIds = [itemId]
+		}
+		this.commitEdit(key, state)
+		this.editableWriteVersion++
+	}
 
-		if (!existing) {
-			this.writeHasMany(key, {
-				serverIds: new Set(),
-				orderedIds: [itemId],
-				plannedRemovals: new Map(),
-				plannedAdditions: new Map([[itemId, 'connected']]),
-				version: 0,
-			})
-		} else {
-			const newPlannedAdditions = new Map(existing.plannedAdditions)
-			// Do not downgrade an existing 'created' addition to 'connected'.
-			if (newPlannedAdditions.get(itemId) !== 'created') {
-				newPlannedAdditions.set(itemId, 'connected')
+	/**
+	 * Records an addition and the view it renders in. Never downgrades an existing
+	 * 'created' addition to 'connected', and cancels a pending removal of the same
+	 * item — leaving both recorded would hide a listed item from the live-edge index.
+	 */
+	private recordAddition(
+		state: StoredHasManyState,
+		alias: string,
+		itemId: string,
+		kind: 'created' | 'connected',
+	): void {
+		const existing = state.plannedAdditions.get(itemId)
+		const addition = existing ?? { kind, origins: new Set<string>() }
+		addition.origins.add(alias)
+		if (kind === 'created') addition.kind = 'created'
+		state.plannedAdditions.set(itemId, addition)
+		state.plannedRemovals.delete(itemId)
+		this.appendToShowingExplicitOrders(state, itemId, addition)
+	}
+
+	/**
+	 * An explicit order replaces the default one, which is where additions otherwise
+	 * appear, so every view that shows the item must list it — not only the view it was
+	 * made in. That includes a view whose own server rows hold it: a removal dropped it
+	 * from every explicit order, and re-connecting it must give it back. Guards against
+	 * re-appending an id that is already listed: the connect paths re-run whenever an
+	 * embedded reference is re-materialized.
+	 */
+	private appendToShowingExplicitOrders(
+		state: StoredHasManyState,
+		itemId: string,
+		addition: PlannedHasManyAddition,
+	): void {
+		for (const [alias, view] of state.views) {
+			if (view.orderedIds === null || view.orderedIds.includes(itemId)) continue
+			if (view.serverIds.has(itemId) || additionRendersIn(state.views, alias, addition)) {
+				view.orderedIds = [...view.orderedIds, itemId]
 			}
-			// Only touch an explicit order — the default order already derives from
-			// plannedAdditions (see computeDefaultOrderedIds). Guard against
-			// re-appending an id that is already listed: this path re-runs whenever an
-			// embedded connect reference is re-materialized, and an unconditional
-			// append would surface the same item twice (mirrors planHasManyConnection).
-			// A re-connect cancels a pending removal of the same item (mirrors
-			// planHasManyConnection); leaving both recorded hides the item from the
-			// live-edge index while it is still listed.
-			const newPlannedRemovals = new Map(existing.plannedRemovals)
-			newPlannedRemovals.delete(itemId)
-			let newOrderedIds = existing.orderedIds
-			if (newOrderedIds !== null && !newOrderedIds.includes(itemId)) {
-				newOrderedIds = [...newOrderedIds, itemId]
+		}
+	}
+
+	private dropFromEveryExplicitOrder(state: StoredHasManyState, itemId: string): void {
+		for (const view of state.views.values()) {
+			if (view.orderedIds !== null) {
+				view.orderedIds = view.orderedIds.filter(id => id !== itemId)
 			}
-			this.writeHasMany(key, {
-				...existing,
-				orderedIds: newOrderedIds,
-				plannedAdditions: newPlannedAdditions,
-				plannedRemovals: newPlannedRemovals,
-				version: existing.version + 1,
-			})
 		}
+	}
+
+	/**
+	 * Advances the server baseline by the confirmed sent delta and rebases local
+	 * edits made after the request started onto that new baseline.
+	 */
+	reconcileSentDelta(key: string, delta: SentHasManyDelta): ReconciliationResult {
+		const existing = this.hasManyStates.get(key)
+		if (!existing) return 'conflict'
+
+		const next = reconcileHasManyState(existing, delta, fieldFromRelationKey(key))
+		this.writeHasMany(key, next.state)
+		return next.result
+	}
+
+	/**
+	 * Resets has-many state to server state (clears planned operations).
+	 * Relation-level: planned removals carry no view, so a per-view reset could not
+	 * know which of them to drop.
+	 */
+	resetHasMany(key: string): void {
+		if (!this.hasManyStates.has(key)) return
+
+		const state = this.editableState(key)
+		state.plannedRemovals.clear()
+		state.plannedAdditions.clear()
+		for (const view of state.views.values()) view.orderedIds = null
+		this.commitEdit(key, state)
 		this.editableWriteVersion++
 	}
 
@@ -453,52 +391,40 @@ export class HasManyStore {
 		const existing = this.hasManyStates.get(key)
 		if (!existing) return false
 
-		const isCreatedEntity = existing.plannedAdditions.get(itemId) === 'created'
-
-		if (isCreatedEntity) {
-			const newPlannedAdditions = new Map(existing.plannedAdditions)
-			newPlannedAdditions.delete(itemId)
-			let newOrderedIds = existing.orderedIds
-			if (newOrderedIds !== null) {
-				newOrderedIds = newOrderedIds.filter(id => id !== itemId)
-			}
+		if (existing.plannedAdditions.get(itemId)?.kind !== 'created') {
+			// planHasManyRemoval bumps editableWriteVersion itself.
+			this.planHasManyRemoval(key, itemId, removalType)
+			return true
+		}
 
-			const newState: StoredHasManyState = {
-				...existing,
-				orderedIds: newOrderedIds,
-				plannedAdditions: newPlannedAdditions,
-				version: existing.version + 1,
-			}
+		// Cancelling a pending create cancels it in every view at once: the entity is
+		// going away, so leaving it listed elsewhere would show a row nothing persists.
+		const state = this.editableState(key)
+		state.plannedAdditions.delete(itemId)
+		this.dropFromEveryExplicitOrder(state, itemId)
 
-			if (
-				newPlannedAdditions.size === 0 &&
-				existing.plannedRemovals.size === 0 &&
-				newOrderedIds !== null
-			) {
-				const defaultOrder = computeDefaultOrderedIds(newState)
-				if (arraysEqual(newOrderedIds, defaultOrder)) {
-					newState.orderedIds = null
+		if (state.plannedAdditions.size === 0 && state.plannedRemovals.size === 0) {
+			for (const [alias, view] of state.views) {
+				if (view.orderedIds !== null && arraysEqual(view.orderedIds, computeViewOrderedIds(state, alias))) {
+					view.orderedIds = null
 				}
 			}
-
-			this.writeHasMany(key, newState)
-			this.editableWriteVersion++
-			return true
-		} else {
-			// planHasManyRemoval bumps editableWriteVersion itself.
-			this.planHasManyRemoval(key, itemId, removalType)
-			return true
 		}
+
+		this.commitEdit(key, state)
+		this.editableWriteVersion++
+		return true
 	}
 
 	/**
-	 * Moves an item within a has-many relation from one index to another.
+	 * Moves an item within one view of a has-many relation. Ordering is presentation
+	 * only — nothing persists it — so it stays per view.
 	 */
-	moveInHasMany(key: string, fromIndex: number, toIndex: number): void {
+	moveInHasMany(key: string, alias: string, fromIndex: number, toIndex: number): void {
 		const existing = this.hasManyStates.get(key)
 		if (!existing) return
 
-		const currentOrderedIds = existing.orderedIds ?? computeDefaultOrderedIds(existing)
+		const currentOrderedIds = viewOrderedIds(existing, alias)
 
 		if (fromIndex < 0 || fromIndex >= currentOrderedIds.length) return
 		if (toIndex < 0 || toIndex >= currentOrderedIds.length) return
@@ -509,26 +435,19 @@ export class HasManyStore {
 		if (movedItem === undefined) return
 		newOrderedIds.splice(toIndex, 0, movedItem)
 
-		this.writeHasMany(key, {
-			...existing,
-			orderedIds: newOrderedIds,
-			version: existing.version + 1,
-		})
+		const state = this.editableState(key, alias)
+		state.views.get(alias)!.orderedIds = newOrderedIds
+		this.commitEdit(key, state)
 		this.editableWriteVersion++
 	}
 
 	/**
-	 * Gets the ordered list of item IDs for a has-many relation.
+	 * Gets the ordered list of item IDs shown by one view.
 	 */
-	getHasManyOrderedIds(key: string): string[] {
+	getHasManyOrderedIds(key: string, alias: string): string[] {
 		const existing = this.hasManyStates.get(key)
 		if (!existing) return []
-
-		if (existing.orderedIds !== null) {
-			return [...existing.orderedIds]
-		}
-
-		return computeDefaultOrderedIds(existing)
+		return viewOrderedIds(existing, alias)
 	}
 
 	/**
@@ -583,38 +502,39 @@ export class HasManyStore {
 	 *
 	 * `pendingItems` (by relation key) names planned additions/removals that were NOT
 	 * sent — they stay planned instead of being folded into the server baseline.
+	 *
+	 * A confirmed removal leaves every view; a confirmed addition joins the views it
+	 * renders in. Only the views that actually changed lose their manual ordering —
+	 * an untouched sibling view keeps the order its user arranged.
 	 */
 	commitAllRelations(keyPrefix: string, pendingItems?: ReadonlyMap<string, ReadonlySet<string>>): void {
-		for (const [key, state] of this.hasManyStates) {
+		for (const [key, existing] of this.hasManyStates) {
 			if (!key.startsWith(keyPrefix)) continue
 
 			const pending = pendingItems?.get(key)
-			const newServerIds = new Set(state.serverIds)
-			const keptRemovals = new Map<string, HasManyRemovalType>()
-			const keptAdditions = new Map<string, HasManyAdditionKind>()
-
-			for (const [removedId, type] of state.plannedRemovals) {
-				if (pending?.has(removedId)) {
-					keptRemovals.set(removedId, type)
-				} else {
-					newServerIds.delete(removedId)
+			const state = cloneHasManyState(existing)
+			const touched = new Set<string>()
+
+			for (const removedId of existing.plannedRemovals.keys()) {
+				if (pending?.has(removedId)) continue
+				state.plannedRemovals.delete(removedId)
+				for (const [alias, view] of state.views) {
+					if (view.serverIds.delete(removedId)) touched.add(alias)
 				}
 			}
-			for (const [addedId, kind] of state.plannedAdditions) {
-				if (pending?.has(addedId)) {
-					keptAdditions.set(addedId, kind)
-				} else {
-					newServerIds.add(addedId)
+			for (const [addedId, addition] of existing.plannedAdditions) {
+				if (pending?.has(addedId)) continue
+				state.plannedAdditions.delete(addedId)
+				for (const alias of additionFoldTargets(existing, addition)) {
+					state.views.get(alias)!.serverIds.add(addedId)
+					touched.add(alias)
 				}
 			}
 
-			this.writeHasMany(key, {
-				serverIds: newServerIds,
-				orderedIds: null,
-				plannedRemovals: keptRemovals,
-				plannedAdditions: keptAdditions,
-				version: state.version + 1,
-			})
+			for (const alias of touched) state.views.get(alias)!.orderedIds = null
+
+			state.version = existing.version + 1
+			this.writeHasMany(key, state)
 		}
 	}
 
@@ -664,13 +584,9 @@ export class HasManyStore {
 	importHasManyStates(states: Map<string, StoredHasManyState>): string[] {
 		const keys: string[] = []
 		for (const [key, state] of states) {
-			this.writeHasMany(key, {
-				serverIds: new Set(state.serverIds),
-				orderedIds: state.orderedIds ? [...state.orderedIds] : null,
-				plannedRemovals: new Map(state.plannedRemovals),
-				plannedAdditions: new Map(state.plannedAdditions),
-				version: state.version + 1,
-			})
+			const imported = cloneHasManyState(state)
+			imported.version = state.version + 1
+			this.writeHasMany(key, imported)
 			keys.push(key)
 		}
 		return keys
@@ -678,58 +594,47 @@ export class HasManyStore {
 
 	/**
 	 * Replaces all occurrences of oldId with newId across has-many states
-	 * (serverIds, orderedIds, plannedAdditions, plannedRemovals).
+	 * (every view's serverIds/orderedIds, plannedAdditions, plannedRemovals).
 	 */
 	replaceEntityId(oldId: string, newId: string): void {
-		for (const [key, state] of this.hasManyStates) {
+		for (const [key, existing] of this.hasManyStates) {
 			let changed = false
+			const state = cloneHasManyState(existing)
 
-			let serverIds = state.serverIds
-			if (serverIds.has(oldId)) {
-				serverIds = new Set(serverIds)
-				serverIds.delete(oldId)
-				serverIds.add(newId)
-				changed = true
-			}
-
-			let orderedIds = state.orderedIds
-			if (orderedIds) {
-				const idx = orderedIds.indexOf(oldId)
-				if (idx !== -1) {
-					orderedIds = [...orderedIds]
-					orderedIds[idx] = newId
+			for (const view of state.views.values()) {
+				if (view.serverIds.delete(oldId)) {
+					view.serverIds.add(newId)
 					changed = true
 				}
+				if (view.orderedIds) {
+					const idx = view.orderedIds.indexOf(oldId)
+					if (idx !== -1) {
+						view.orderedIds[idx] = newId
+						changed = true
+					}
+				}
 			}
 
-			let plannedAdditions = state.plannedAdditions
-			if (plannedAdditions.has(oldId)) {
-				plannedAdditions = new Map(plannedAdditions)
-				plannedAdditions.delete(oldId)
+			const addition = state.plannedAdditions.get(oldId)
+			if (addition) {
+				state.plannedAdditions.delete(oldId)
 				// The id only changes when the item was persisted, so a still-planned
 				// 'created' addition (the item went out on its own, not nested in this
 				// parent) must now connect the server row rather than create a second one.
-				plannedAdditions.set(newId, 'connected')
+				state.plannedAdditions.set(newId, { kind: 'connected', origins: addition.origins })
 				changed = true
 			}
 
-			let plannedRemovals = state.plannedRemovals
-			if (plannedRemovals.has(oldId)) {
-				const removalType = plannedRemovals.get(oldId)!
-				plannedRemovals = new Map(plannedRemovals)
-				plannedRemovals.delete(oldId)
-				plannedRemovals.set(newId, removalType)
+			const removalType = state.plannedRemovals.get(oldId)
+			if (removalType !== undefined) {
+				state.plannedRemovals.delete(oldId)
+				state.plannedRemovals.set(newId, removalType)
 				changed = true
 			}
 
 			if (changed) {
-				this.writeHasMany(key, {
-					serverIds,
-					orderedIds,
-					plannedRemovals,
-					plannedAdditions,
-					version: state.version + 1,
-				})
+				state.version = existing.version + 1
+				this.writeHasMany(key, state)
 			}
 		}
 	}
@@ -763,84 +668,3 @@ export class HasManyStore {
 		this.mutationVersion++
 	}
 }
-
-/**
- * The single liveness predicate for has-many membership: effective members are
- * (serverIds ∪ plannedAdditions) minus plannedRemovals. Defined once and consumed
- * by the write chokepoint so the forward/reverse index can never drift from it.
- */
-function liveHasManyChildIds(state: StoredHasManyState | undefined): Set<string> {
-	const live = new Set<string>()
-	if (!state) return live
-	for (const id of state.serverIds) {
-		if (!state.plannedRemovals.has(id)) live.add(id)
-	}
-	for (const id of state.plannedAdditions.keys()) {
-		if (!state.plannedRemovals.has(id)) live.add(id)
-	}
-	return live
-}
-
-function plannedDeleteChildIds(state: StoredHasManyState | undefined): Set<string> {
-	const ids = new Set<string>()
-	if (!state) return ids
-	for (const [id, type] of state.plannedRemovals) {
-		if (type === 'delete') ids.add(id)
-	}
-	return ids
-}
-
-interface HasManyReconciliation {
-	state: StoredHasManyState
-	result: ReconciliationResult
-}
-
-function reconcileHasManyState(
-	existing: StoredHasManyState,
-	delta: SentHasManyDelta,
-): HasManyReconciliation {
-	const currentLive = liveHasManyChildIds(existing)
-	const serverIds = new Set(existing.serverIds)
-	const plannedAdditions = new Map(existing.plannedAdditions)
-	const plannedRemovals = new Map(existing.plannedRemovals)
-	let result: ReconciliationResult = 'applied'
-
-	for (const addition of delta.additions) {
-		serverIds.add(addition.itemId)
-		plannedAdditions.delete(addition.itemId)
-		plannedRemovals.delete(addition.itemId)
-		if (!currentLive.has(addition.itemId)) {
-			plannedRemovals.set(
-				addition.itemId,
-				addition.kind === 'created' ? 'delete' : 'disconnect',
-			)
-		}
-	}
-
-	for (const removal of delta.removals) {
-		serverIds.delete(removal.itemId)
-		const currentRemoval = plannedRemovals.get(removal.itemId)
-		if (currentRemoval === removal.type) plannedRemovals.delete(removal.itemId)
-
-		if (!currentLive.has(removal.itemId)) {
-			if (removal.type === 'delete') plannedRemovals.delete(removal.itemId)
-			continue
-		}
-		if (removal.type === 'delete') {
-			result = 'conflict'
-		} else if (!plannedAdditions.has(removal.itemId)) {
-			plannedAdditions.set(removal.itemId, 'connected')
-		}
-	}
-
-	return {
-		state: {
-			serverIds,
-			orderedIds: existing.orderedIds ? [...existing.orderedIds] : null,
-			plannedRemovals,
-			plannedAdditions,
-			version: existing.version + 1,
-		},
-		result,
-	}
-}