@orbat-mapper/tactical-draw 0.2.0-alpha.7 → 0.2.0-alpha.9

package/dist/index.d.mts

@@ -518,10 +518,12 @@ interface EditSession {
    */
   readonly sizeAnchor: SizeAnchor;
   /**
-   * Resolve the outer `edit` promise with a `ControlMeasureSnapshot` of the
-   * current working state.
+   * Commit: returns the `ControlMeasureSnapshot` of the current working state
+   * and resolves the outer `edit` promise with the same value (the same
+   * reference — no double-bake of ground-anchored sizes). Returns `undefined`
+   * after the session has settled (idempotent no-op).
    */
-  close(): void;
+  close(): ControlMeasureSnapshot | undefined;
   /** Reject the outer `edit` promise with reason `"session"`. */
   abort(): void;
   /**
@@ -592,12 +594,22 @@ interface EditChangeEvent {
  * transform box's corner-scale / rotate / body-translate gestures, applied to
  * every member at once. See the Phase 3 ("Multi-select") slice of ADR-0017.
  *
- * `measures` is the immutable edit-start input, index-aligned with every
- * snapshot array this session or its change events produce. After the
- * session settles (`close` / `abort`), every method is a silent no-op.
+ * The member set is mutable via [[setMembers]] (#187): members can join or
+ * leave a live session without a session boundary. Because membership changes
+ * over the session's lifetime, snapshot arrays are keyed by **measure id**, not
+ * by index — a snapshot's identity is `snapshot.measure.id`. `measures` is a
+ * live view of the current members' join-time inputs; a `TransformChangeEvent`'s
+ * arrays are index-aligned with `session.measures` *as of that emission*. After
+ * the session settles (`close` / `abort` / an emptying `setMembers`), every
+ * method is a silent no-op.
  */
 interface TransformSession {
-  /** Immutable edit-start inputs, index-aligned with every snapshot array. */
+  /**
+   * Live view of the current members' join-time input measures — a fresh array
+   * on each read, in current membership order. Grows/shrinks as [[setMembers]]
+   * adds or removes members. Not stable across membership changes: key
+   * snapshots by `snapshot.measure.id` rather than relying on index alignment.
+   */
   readonly measures: readonly ControlMeasure[];
   /**
    * Live working control points for the member whose id is `measureId`, or
@@ -615,10 +627,53 @@ interface TransformSession {
   /** Switch the group's size anchor (ADR-0020). Takes effect on the next emitted snapshot and on `close()`. */
   setSizeAnchor(anchor: SizeAnchor): void;
   /**
-   * Resolve the outer `editMany` promise with index-aligned
-   * `ControlMeasureSnapshot[]` of the current working state.
-   */
-  close(): void;
+   * Replace the member set in place — the primitive behind shift-click toggle,
+   * marquee replace, and single-edit → group folding, without tearing the
+   * session down (#187). Members are matched to the current set by measure id:
+   *
+   * - **Retained** members (id in both the current and next sets) carry their
+   *   current working state forward; the passed measure object is ignored for
+   *   them. Their `dirty` baseline stays their original join-time input, so a
+   *   session that has already moved things stays dirty across the call.
+   * - **Removed** members (id in the current set, absent from the next) are
+   *   committed at their current working state.
+   * - **Added** members (id only in the next set) join at their passed input
+   *   state; if currently on the graphics layer they are lifted off it exactly
+   *   like initial members.
+   *
+   * The transform box re-derives from the next member set at the session's
+   * current box angle. Session-scoped state (`sizeAnchor`, box angle,
+   * non-geometry dirty) is unchanged.
+   *
+   * **Return value** — the committed exit snapshots of the members removed *by
+   * this call*, built exactly like [[close]]'s snapshots (pixel size baked to
+   * ground unless `sizeAnchor` is `"screen"`, then cloned and rendered); an
+   * empty array when nothing was removed. The outer `editMany` promise resolves
+   * with the snapshots of the members in the set **at close time only**.
+   * Removed members are NOT written back to the graphics layer by the
+   * controller — the host folds the returned snapshots into its document and
+   * calls `td.render()`, the same contract as [[close]]. A removed member's
+   * exit snapshot is also delivered through [[onCommit]] — the recommended
+   * channel, since it covers this return value and the close-time promise
+   * resolution through a single subscription. Returns `undefined` (a silent
+   * no-op) after the session has settled.
+   *
+   * `setMembers([])` on a live session delegates to [[close]]: it commits every
+   * current member, resolves the promise with their snapshots, and returns that
+   * same array. Duplicate ids in `measures` throw `TypeError` synchronously,
+   * without mutating session state.
+   */
+  setMembers(measures: readonly ControlMeasure[]): ControlMeasureSnapshot[] | undefined;
+  /**
+   * Commit: returns the members' `ControlMeasureSnapshot[]` (the members in the
+   * set at close time) and resolves the outer `editMany` promise with the same
+   * value (the same reference — no double-bake of ground-anchored sizes). A
+   * member removed mid-session via [[setMembers]] is not included here; its exit
+   * snapshot was returned from that `setMembers` call (and delivered to
+   * [[onCommit]] at that time). Returns `undefined` after the session has
+   * settled (idempotent no-op).
+   */
+  close(): ControlMeasureSnapshot[] | undefined;
   /** Reject the outer `editMany` promise with reason `"session"`. */
   abort(): void;
   /**
@@ -634,17 +689,48 @@ interface TransformSession {
    * have run — mirrors `EditSession.onChange` (issue #49).
    */
   onChange(listener: (event: TransformChangeEvent) => void): () => void;
+  /**
+   * Subscribe to committed exit-snapshot batches — the single delivery channel
+   * for every `ControlMeasureSnapshot[]` this session ever commits (#191). Fires
+   * exactly once per batch:
+   *
+   * - The members [[setMembers]] removes, but only when that call actually
+   *   removed at least one member.
+   * - The close-time members on any commit path: [[close]], `setMembers([])`,
+   *   a click-away close, or `TransformChangeEvent.close()`.
+   *
+   * Never fires on an abort/reject path. Fires synchronously from within the
+   * `setMembers`/`close` call that produced the batch, before that call
+   * returns, and the array delivered here is the same reference that call
+   * returns (and, for the close batch, the same reference the `editMany`
+   * promise resolves with). This is the recommended single fold path for exit
+   * state — subscribe once in `onSession` and every committed snapshot, from
+   * either delivery site, arrives here exactly once; the `setMembers` return
+   * value and the promise resolution are unchanged and remain valid for
+   * backward compatibility.
+   *
+   * Listener exceptions are collected; after every listener has run, they are
+   * rethrown (one if single, `AggregateError` otherwise) — mirrors
+   * [[onChange]]. Returns an unsubscribe function; registering after the
+   * session has settled returns a no-op unsubscribe and the listener never
+   * fires.
+   */
+  onCommit(handler: (snapshots: ControlMeasureSnapshot[]) => void): () => void;
 }
 /**
  * Delivered to `TransformSession.onChange` listeners once per completed group
  * gesture. Both `measures` and `previous` are index-aligned with
- * `session.measures`. See `EditChangeEvent` for the identical emission
- * contract this mirrors.
+ * `session.measures` *as of this emission*. Key by `measure.id` rather than
+ * relying on index alignment across emissions. A `setMembers` call from within
+ * a listener takes effect immediately and supersedes this emission's
+ * `reject()` (the rollback baseline no longer matches the member set);
+ * `close()` and `abort()` still apply, against the new membership. See
+ * `EditChangeEvent` for the identical emission contract this mirrors.
  */
 interface TransformChangeEvent {
-  /** Working state after the completed gesture, index-aligned with `session.measures`. */
+  /** Working state after the completed gesture, index-aligned with `session.measures` as of this emission. */
   readonly measures: ControlMeasureSnapshot[];
-  /** State immediately before this gesture, index-aligned with `session.measures`. */
+  /** State immediately before this gesture, index-aligned with `session.measures` as of this emission. */
   readonly previous: ControlMeasureSnapshot[];
   /** The session the event belongs to. */
   readonly session: TransformSession;
@@ -652,7 +738,8 @@ interface TransformChangeEvent {
    * Roll every member's working preview back to `previous` after all
    * listeners have run. Multiple calls collapse to a single rollback.
    * Overridden by `close()` or `abort()` if either is also called during this
-   * emission.
+   * emission, and dropped if a listener called `session.setMembers` (the
+   * rollback baseline no longer matches the member set).
    */
   reject(): void;
   /** Shortcut for `event.session.close()`, deferred until the emission ends. */
@@ -945,6 +1032,14 @@ declare class TacticalDraw {
    * working copy. Empty while idle.
    */
   private excludedInteractionIds;
+  /**
+   * Live member ids of the active group transform, or `undefined` when none.
+   * Falls back to the session ref because `onSession` fires from inside the
+   * controller's attach, before `runWithSlot` has assigned `activeTransform` —
+   * the session ref is registered first (`trackTransformSession`), so a
+   * `render()` from inside `onSession` still sees live membership.
+   */
+  private transformMemberIds;
   /**
    * Reconcile the graphics layer against the authoritative list of measures.
    * Idempotent. Throws synchronously on duplicate measure ids *before*
@@ -1028,15 +1123,52 @@ declare class TacticalDraw {
    * (ADR-0017 "Multi-select" slice). Every member is lifted onto the shared
    * preview layer; the box (corner scale, rotate grip, drag-anywhere body
    * translate) applies rigidly to all of them at once. Returns a Promise that
-   * resolves with index-aligned `ControlMeasureSnapshot[]` on
-   * `session.close()` and rejects with `TacticalDrawAbortError` on
-   * signal / Escape / destroy / preempt / `session.abort()`.
+   * resolves with `ControlMeasureSnapshot[]` on `session.close()` and rejects
+   * with `TacticalDrawAbortError` on signal / Escape / destroy / preempt /
+   * `session.abort()`. Key the resolved snapshots by `snapshot.measure.id`:
+   * the member set is mutable (`session.setMembers`, #187) so snapshot arrays
+   * are id-keyed, not index-aligned with this input. The promise resolves with
+   * the members in the set at close time; a member removed mid-session had its
+   * exit snapshot returned from the `setMembers` call that removed it.
    *
    * `measures.length` must be >= 1; a single-element array behaves like an
    * `edit` with only `transform` mode. Throws `TypeError` synchronously (before
    * any preemption) for an empty array or duplicate ids.
+   *
+   * For a selection that changes over time (shift-click toggle, marquee
+   * replace), prefer [[syncTransformMembers]] over hand-rolling the
+   * live-session-vs-fresh-`editMany` branch, and subscribe to
+   * `TransformSession.onCommit` as the single fold path for exit snapshots.
    */
   editMany(measures: ControlMeasure[], options?: EditManyOptions): Promise<ControlMeasureSnapshot[]>;
+  /**
+   * One-call selection-sync: mutate the live group transform's member set in
+   * place, or start a fresh `editMany` when no transform is live (#191). This
+   * owns the "live session → `setMembers`, else → `editMany`" branch that every
+   * host otherwise hand-rolls against `activeTransformSession`.
+   *
+   * The facade knows session liveness synchronously — `activeTransformSessionRef`
+   * is cleared inside the settle path, before control returns to host code — so
+   * unlike a host's own `activeTransformSession ? setMembers : editMany` check,
+   * this can never observe a stale ref pointing at an already-settled session.
+   * The settled-race fall-through hosts had to hand-roll for that gap is owned
+   * here instead: a `setMembers` call that (implausibly) still returns
+   * `undefined` falls through to a fresh `editMany` rather than silently
+   * dropping the selection.
+   *
+   * `measures: []` closes any live session (committing every member) and is a
+   * no-op while idle. With a live session, `options` is ignored — session-scoped
+   * state (`sizeAnchor`, box angle, close-on-click-away policy) is sticky per
+   * `setMembers`'s contract; `options` applies only when this call starts a
+   * fresh `editMany`. Exit snapshots are delivered via the session's
+   * `onCommit` — subscribe once in `options.onSession`. The underlying
+   * `editMany` promise is owned by the facade; its abort rejections are
+   * swallowed here (non-abort errors surface as unhandled rejections). Throws
+   * `TypeError` synchronously on duplicate ids, from either path. Starting a
+   * fresh transform preempts any other in-flight draw/edit exactly like
+   * `editMany`.
+   */
+  syncTransformMembers(measures: readonly ControlMeasure[], options?: EditManyOptions): void;
   /**
    * Subscribe to picks on committed control measures.
    *

package/dist/index.mjs

@@ -699,7 +699,7 @@ function runInteraction(spec) {
 		clearLayers();
 	}
 	function commit(produce) {
-		if (settled) return;
+		if (settled) return void 0;
 		let value;
 		try {
 			value = produce();
@@ -714,6 +714,7 @@ function runInteraction(spec) {
 		teardown();
 		resolveFn(value);
 		if (onSettled) onSettled();
+		return value;
 	}
 	function fail(error) {
 		if (settled) return;
@@ -2259,8 +2260,7 @@ function runEdit(opts) {
 			return sizeAnchor;
 		},
 		close() {
-			if (ctx.settled) return;
-			ctx.commit(rebuildRendered);
+			return ctx.commit(rebuildRendered);
 		},
 		abort() {
 			if (ctx.settled) return;
@@ -2664,49 +2664,67 @@ const CLICK_SLOP_PX = 3;
 *    thin outline (its own fit at the same angle)
 *  - dirty tracking, close/abort/signal/preempt/destroy, click-away — same
 *    contracts as `runEdit`, scoped to the group
+*  - membership is mutable via `session.setMembers` (#187): members join/leave
+*    a live session without a session boundary
 */
 function runGroupTransform(opts) {
-	const { adapter, measures, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, wasOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
+	const { adapter, measures, graphicsLayer, previewLayer, handlesLayer, graphicsStyle, signal, closeOnClickAway = true, interactionStyle, onSession, handleIdPrefix, restoreOriginalToGraphics, isOnGraphicsLayer, onSettled, onClickAwayGraphicsPick } = opts;
 	const renderOpts = graphicsStyle ? { graphicsStyle } : void 0;
-	const memberIds = new Set(measures.map((m) => m.id));
 	let sizeAnchor = opts.sizeAnchor ?? "ground";
-	const editStartPointsByMember = measures.map((m) => m.controlPoints.map((p) => [...p]));
-	const workingPointsByMember = editStartPointsByMember.map((pts) => pts.map((p) => [...p]));
-	const counts = workingPointsByMember.map((pts) => pts.length);
+	/** Build a fresh working record for `measure`, snapshotting its edit-start points. */
+	function createMemberState(measure) {
+		const editStartPoints = measure.controlPoints.map((p) => [...p]);
+		return {
+			measure,
+			editStartPoints,
+			workingPoints: editStartPoints.map((p) => [...p]),
+			optionsOverride: null,
+			box: null,
+			lastPreviewFeatures: []
+		};
+	}
+	/** The single mutable source of truth for the current member set. */
+	let members = measures.map(createMemberState);
 	/**
-	* Per-member options patch, index-aligned with `measures`, applied on top of
-	* the member's own `options` when building its working/rendered measure.
-	* This exists solely to freeze orientation-derived option defaults (e.g.
-	* Battle Position's echelon anchor) the moment a group rotate gesture
-	* starts (ADR-0023) — there is no public per-member `setOptions` here, and
-	* the "no per-measure setOptions" contract for the group session still
-	* holds; a host cannot reach this array.
+	* `true` once any member has been lifted off the graphics layer (initial or a
+	* mid-session `setMembers` add). Gates the abort-path restore so a session
+	* that never touched the graphics layer doesn't rewrite it on abort.
 	*/
-	let optionsOverrideByMember = measures.map(() => null);
-	/** Effective options for member `i` against a given override array, merged onto its own options. */
-	function effectiveOptionsWith(i, overrides) {
-		const override = overrides[i];
-		if (!override) return measures[i].options;
+	let anyLiftedFromGraphics = false;
+	/** A member's own options merged with an override patch (a null override leaves them unchanged). */
+	function mergeOptions(base, override) {
+		if (!override) return base;
 		return {
-			...measures[i].options ?? {},
+			...base ?? {},
 			...override
 		};
 	}
-	/** Effective options for member `i`: its own options merged with the *live* override. */
+	/** Effective options for member `i`: its own options merged with its *live* override. */
 	function effectiveOptions(i) {
-		return effectiveOptionsWith(i, optionsOverrideByMember);
+		const member = members[i];
+		return mergeOptions(member.measure.options, member.optionsOverride);
 	}
-	/** The working measure for member `i` against a given override array, with live working points. */
-	function workingMeasureForWith(i, overrides) {
+	/** Build a member's committed snapshot with a given override, baking pixel size to ground unless "screen". */
+	function buildMemberSnapshot(member, override) {
+		const working = {
+			...member.measure,
+			options: mergeOptions(member.measure.options, override),
+			controlPoints: member.workingPoints.map((p) => [...p])
+		};
+		const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
 		return {
-			...measures[i],
-			options: effectiveOptionsWith(i, overrides),
-			controlPoints: workingPointsByMember[i].map((p) => [...p])
+			measure: cloneControlMeasure(committed),
+			render: renderMeasureForAdapter(adapter, committed, renderOpts)
 		};
 	}
 	/** The working measure for member `i`: original measure, live effective options, live working points. */
 	function workingMeasureFor(i) {
-		return workingMeasureForWith(i, optionsOverrideByMember);
+		const member = members[i];
+		return {
+			...member.measure,
+			options: effectiveOptions(i),
+			controlPoints: member.workingPoints.map((p) => [...p])
+		};
 	}
 	let dirty = false;
 	/**
@@ -2719,26 +2737,27 @@ function runGroupTransform(opts) {
 	/** Same click-away suppression role as `edit-controller.ts`'s flag of the same name. */
 	let suppressClickAway = false;
 	const changeListeners = /* @__PURE__ */ new Set();
+	const commitListeners = /* @__PURE__ */ new Set();
 	/** Session-scoped box rotation (ADR-0017 decision #2), shared by the whole group. */
 	let boxAngle = 0;
 	/** The group box fitted over every member's rendered geometry, or `null` when nothing projects this frame. */
 	let groupBox = null;
-	/** Each member's own fitted box (same angle as `groupBox`), index-aligned with `measures`. */
-	let memberBoxes = measures.map(() => null);
-	/** The features written to the preview layer for each member on the last paint. */
-	let lastPreviewFeaturesByMember = measures.map(() => []);
 	let ctx;
 	let driver;
 	const dragProjection = {
 		toPixel: (lonLat) => driver.toPixel(lonLat),
 		fromPixel: (pixel) => driver.fromPixel(pixel)
 	};
-	function liftOriginalsFromGraphics() {
-		measures.forEach((measure, i) => {
-			if (!wasOnGraphicsLayer[i]) return;
-			const ids = renderMeasureForAdapter(adapter, measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
-			if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
-		});
+	/**
+	* Lift `member` off the graphics layer when the host reports it currently
+	* there, flipping `anyLiftedFromGraphics` so the abort path knows to restore.
+	* Used for both initial and mid-session-added members.
+	*/
+	function liftMemberFromGraphics(member) {
+		if (!isOnGraphicsLayer(member.measure.id)) return;
+		const ids = renderMeasureForAdapter(adapter, member.measure, renderOpts).features.map((f) => f.id).filter((id) => typeof id === "string");
+		if (ids.length > 0) adapter.removeFeatures(graphicsLayer, ids);
+		anyLiftedFromGraphics = true;
 	}
 	function pixelsFor(features) {
 		const positions = [];
@@ -2755,7 +2774,7 @@ function runGroupTransform(opts) {
 		return activeBoxDrag ? activeBoxDrag.lastSnapshot.box.angle : boxAngle;
 	}
 	/**
-	* Re-fit `groupBox` and every `memberBoxes[i]` from `lastPreviewFeaturesByMember`.
+	* Re-fit `groupBox` and every member's `box` from their `lastPreviewFeatures`.
 	* While a box gesture is in flight, `groupBox` itself is not touched here —
 	* `renderHandlesLayer` paints the drag's own rigidly-transformed box instead
 	* (matching `edit-controller.ts`'s `refitBox`) — but the member outlines are
@@ -2766,18 +2785,18 @@ function runGroupTransform(opts) {
 		const angle = currentAngle();
 		const padding = interactionStyle?.boxPadding ?? 0;
 		const allPixels = [];
-		memberBoxes = lastPreviewFeaturesByMember.map((features) => {
-			const pixels = pixelsFor(features);
+		for (const member of members) {
+			const pixels = pixelsFor(member.lastPreviewFeatures);
 			allPixels.push(...pixels);
-			return fitTransformBox(pixels, angle, padding);
-		});
+			member.box = fitTransformBox(pixels, angle, padding);
+		}
 		if (activeBoxDrag) return;
 		groupBox = fitTransformBox(allPixels, boxAngle, padding);
 	}
 	function renderAllPreviews() {
 		if (ctx.settled) return;
 		const allFeatures = [];
-		lastPreviewFeaturesByMember = measures.map((_measure, i) => {
+		members.forEach((member, i) => {
 			const working = workingMeasureFor(i);
 			let features;
 			try {
@@ -2785,17 +2804,17 @@ function runGroupTransform(opts) {
 			} catch {
 				features = [];
 			}
+			member.lastPreviewFeatures = features;
 			allFeatures.push(...features);
-			return features;
 		});
 		ctx.writeLayer(previewLayer, allFeatures);
 		refitBoxes();
 	}
 	function rescaleOnViewChange() {
 		if (ctx.settled) return;
-		if (measures.some((m) => measureUsesAdapterResolution({
-			kind: m.kind,
-			options: m.options
+		if (members.some((m) => measureUsesAdapterResolution({
+			kind: m.measure.kind,
+			options: m.measure.options
 		}))) renderAllPreviews();
 		else refitBoxes();
 		renderHandlesLayer();
@@ -2821,59 +2840,62 @@ function runGroupTransform(opts) {
 			features.push(boxOutlineFeature(liveGroupBox, dragProjection.fromPixel, `${handleIdPrefix}:box-outline`, groupOutlineStyle()));
 			features.push(...toFeatures(boxToHandles(liveGroupBox, dragProjection.fromPixel), handleIdPrefix, interactionStyle));
 		}
-		measures.forEach((measure, i) => {
-			const memberBox = memberBoxes[i];
-			if (!memberBox) return;
-			features.push(boxOutlineFeature(memberBox, dragProjection.fromPixel, `${handleIdPrefix}:member-outline:${measure.id}`, interactionStyle?.boxOutline));
-		});
+		for (const member of members) {
+			const memberBox = member.box;
+			if (!memberBox) continue;
+			features.push(boxOutlineFeature(memberBox, dragProjection.fromPixel, `${handleIdPrefix}:member-outline:${member.measure.id}`, interactionStyle?.boxOutline));
+		}
 		ctx.writeLayer(handlesLayer, features);
 	}
 	/**
 	* Builds every member's committed snapshot against a given override array
-	* rather than the live `optionsOverrideByMember` — used to render a
-	* gesture's pre-freeze "previous" snapshot when a rotate has already
-	* mutated the live overrides by the time the commit runs.
+	* rather than the live per-member override — used to render a gesture's
+	* pre-freeze "previous" snapshot when a rotate has already mutated the live
+	* overrides by the time the commit runs. Index-aligned with `members`, which
+	* is sound because membership cannot change within a gesture emission.
 	*/
 	function rebuildRenderedAllWith(overrides) {
-		return measures.map((_measure, i) => {
-			const working = workingMeasureForWith(i, overrides);
-			const committed = sizeAnchor === "screen" ? working : bakePixelSizeToGround(working, adapter);
-			return {
-				measure: cloneControlMeasure(committed),
-				render: renderMeasureForAdapter(adapter, committed, renderOpts)
-			};
-		});
+		return members.map((member, i) => buildMemberSnapshot(member, overrides[i] ?? null));
 	}
 	function rebuildRenderedAll() {
-		return rebuildRenderedAllWith(optionsOverrideByMember);
+		return members.map((member) => buildMemberSnapshot(member, member.optionsOverride));
 	}
 	function recomputeDirty() {
-		dirty = nonGeometryDirty || workingPointsByMember.some((pts, i) => !pointsEqualWithinTolerance(pts, editStartPointsByMember[i], DIRTY_EPSILON));
+		dirty = nonGeometryDirty || members.some((m) => !pointsEqualWithinTolerance(m.workingPoints, m.editStartPoints, DIRTY_EPSILON));
 	}
-	/** Split `points` (the concatenation of every member's control points) back per member and write them into `workingPointsByMember`. */
+	/** Split `points` (the concatenation of every member's control points) back per member. */
 	function applyConcatenatedPoints(points) {
 		const rounded = roundControlPoints(points);
 		let offset = 0;
-		for (let i = 0; i < counts.length; i++) {
-			const c = counts[i];
+		for (const member of members) {
+			const c = member.workingPoints.length;
 			const slice = rounded.slice(offset, offset + c);
-			workingPointsByMember[i].splice(0, workingPointsByMember[i].length, ...slice);
+			member.workingPoints.splice(0, member.workingPoints.length, ...slice);
 			offset += c;
 		}
 	}
 	function concatWorkingPoints() {
 		const out = [];
-		for (const pts of workingPointsByMember) out.push(...pts.map((p) => [...p]));
+		for (const member of members) out.push(...member.workingPoints.map((p) => [...p]));
 		return out;
 	}
 	function clonePointsByMember() {
-		return workingPointsByMember.map((pts) => pts.map((p) => [...p]));
+		return members.map((m) => m.workingPoints.map((p) => [...p]));
 	}
 	function restorePointsByMember(snapshot) {
-		for (let i = 0; i < workingPointsByMember.length; i++) workingPointsByMember[i].splice(0, workingPointsByMember[i].length, ...snapshot[i]);
+		members.forEach((member, i) => {
+			member.workingPoints.splice(0, member.workingPoints.length, ...snapshot[i]);
+		});
 	}
 	function cloneOptionsOverrideByMember() {
-		return optionsOverrideByMember.map((o) => o ? { ...o } : null);
+		return members.map((m) => m.optionsOverride ? { ...m.optionsOverride } : null);
+	}
+	/** Write a per-member override snapshot back onto the live members (index-aligned; gesture-scoped). */
+	function applyOptionsOverrides(overrides) {
+		members.forEach((member, i) => {
+			const o = overrides[i];
+			member.optionsOverride = o ? { ...o } : null;
+		});
 	}
 	/**
 	* Pin orientation-derived option defaults (e.g. Battle Position's echelon
@@ -2882,10 +2904,10 @@ function runGroupTransform(opts) {
 	* per-member since the group has no single working-options set.
 	*/
 	function freezeOrientationForRotate() {
-		measures.forEach((measure, i) => {
-			const patch = freezeOrientationOptions(measure.kind, workingPointsByMember[i].map((p) => [...p]), effectiveOptions(i));
-			if (patch) optionsOverrideByMember[i] = {
-				...optionsOverrideByMember[i] ?? {},
+		members.forEach((member, i) => {
+			const patch = freezeOrientationOptions(member.measure.kind, member.workingPoints.map((p) => [...p]), effectiveOptions(i));
+			if (patch) member.optionsOverride = {
+				...member.optionsOverride ?? {},
 				...patch
 			};
 		});
@@ -2915,6 +2937,7 @@ function runGroupTransform(opts) {
 				abortRequested = true;
 			}
 		};
+		const membersAtEmission = members;
 		const errors = [];
 		for (const listener of [...changeListeners]) try {
 			listener(event);
@@ -2922,12 +2945,12 @@ function runGroupTransform(opts) {
 			errors.push(err);
 		}
 		if (abortRequested) ctx.fail(new TacticalDrawAbortError("session"));
-		else if (closeRequested) ctx.commit(rebuildRenderedAll);
-		else if (rejectRequested && !ctx.settled) {
+		else if (closeRequested) commitClose();
+		else if (rejectRequested && !ctx.settled && members === membersAtEmission) {
 			restorePointsByMember(previousPointsByMember);
 			sizeAnchor = previousSizeAnchor;
 			nonGeometryDirty = previousNonGeometryDirty;
-			optionsOverrideByMember = previousOptionsOverrideByMember.map((o) => o ? { ...o } : null);
+			applyOptionsOverrides(previousOptionsOverrideByMember);
 			renderAllPreviews();
 			renderHandlesLayer();
 			recomputeDirty();
@@ -2935,6 +2958,35 @@ function runGroupTransform(opts) {
 		if (errors.length === 1) throw errors[0];
 		if (errors.length > 1) throw new AggregateError(errors, "TransformSession.onChange listener errors");
 	}
+	/**
+	* Deliver a committed exit-snapshot batch to every `onCommit` listener — the
+	* single delivery channel for both the `setMembers`-removed batch and the
+	* close-time batch (#191). Same exception-collection contract as `emitChange`.
+	*/
+	function emitCommit(snapshots) {
+		const errors = [];
+		for (const listener of [...commitListeners]) try {
+			listener(snapshots);
+		} catch (err) {
+			errors.push(err);
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "TransformSession.onCommit listener errors");
+	}
+	/**
+	* Commit via `ctx.commit` and emit the close batch to `onCommit` listeners.
+	* The emission happens after the interaction core has settled (teardown and
+	* `onSettled` already ran inside `ctx.commit`), so a listener that calls
+	* `td.render()` sees these members no longer excluded from reconcile — the
+	* fold-then-render pattern works from inside the handler. `undefined` covers
+	* both an already-settled session and a `produce` throw (the promise
+	* rejects); neither emits.
+	*/
+	function commitClose() {
+		const snapshots = ctx.commit(rebuildRenderedAll);
+		if (snapshots !== void 0) emitCommit(snapshots);
+		return snapshots;
+	}
 	function commitGesture(nextConcatPoints, preGestureOptionsOverrideByMember) {
 		if (ctx.settled) return;
 		const previousPointsByMember = clonePointsByMember();
@@ -2968,12 +3020,64 @@ function runGroupTransform(opts) {
 		dirty = true;
 		emitChange(previousRendered, previousPointsByMember, previousSizeAnchor, previousNonGeometryDirty, previousOptionsOverrideByMember, currentRendered);
 	}
+	/**
+	* Cancel an in-flight box drag without committing it: restore the pre-drag
+	* geometry and option overrides, re-enable drag pan, and clear the drag. Used
+	* by `setMembers` so a membership change never bakes a half-finished drag; the
+	* caller is responsible for the follow-up repaint (`renderAllPreviews` /
+	* `renderHandlesLayer` / `recomputeDirty`), so this leaves the paint to it
+	* rather than rendering the outgoing member set only to redo it immediately.
+	*/
+	function cancelActiveBoxDrag() {
+		if (!activeBoxDrag) return;
+		const { preDragPoints, preDragOptionsOverrideByMember } = activeBoxDrag;
+		activeBoxDrag = null;
+		driver.setDragPanEnabled(true);
+		applyConcatenatedPoints(preDragPoints);
+		applyOptionsOverrides(preDragOptionsOverrideByMember);
+		dragInFlight = false;
+	}
+	function setMembers(next) {
+		if (ctx.settled) return void 0;
+		const seen = /* @__PURE__ */ new Set();
+		for (const m of next) {
+			if (seen.has(m.id)) throw new TypeError(`TransformSession.setMembers: duplicate control measure id "${m.id}"`);
+			seen.add(m.id);
+		}
+		if (next.length === 0) return close();
+		cancelActiveBoxDrag();
+		const nextIds = new Set(next.map((m) => m.id));
+		const currentById = new Map(members.map((m) => [m.measure.id, m]));
+		const removedSnapshots = [];
+		for (const member of members) if (!nextIds.has(member.measure.id)) removedSnapshots.push(buildMemberSnapshot(member, member.optionsOverride));
+		const nextMembers = [];
+		for (const measure of next) {
+			const existing = currentById.get(measure.id);
+			if (existing) nextMembers.push(existing);
+			else {
+				const member = createMemberState(measure);
+				liftMemberFromGraphics(member);
+				nextMembers.push(member);
+			}
+		}
+		members = nextMembers;
+		renderAllPreviews();
+		renderHandlesLayer();
+		recomputeDirty();
+		if (removedSnapshots.length > 0) emitCommit(removedSnapshots);
+		return removedSnapshots;
+	}
+	function close() {
+		return commitClose();
+	}
 	const session = {
-		measures,
+		get measures() {
+			return members.map((m) => m.measure);
+		},
 		controlPointsFor(measureId) {
-			const index = measures.findIndex((m) => m.id === measureId);
-			if (index < 0) return void 0;
-			return workingPointsByMember[index].map((p) => [...p]);
+			const member = members.find((m) => m.measure.id === measureId);
+			if (!member) return void 0;
+			return member.workingPoints.map((p) => [...p]);
 		},
 		get dirty() {
 			return dirty;
@@ -2984,10 +3088,8 @@ function runGroupTransform(opts) {
 		setSizeAnchor(next) {
 			setSizeAnchor(next);
 		},
-		close() {
-			if (ctx.settled) return;
-			ctx.commit(rebuildRenderedAll);
-		},
+		setMembers,
+		close,
 		abort() {
 			if (ctx.settled) return;
 			ctx.fail(new TacticalDrawAbortError("session"));
@@ -2998,6 +3100,13 @@ function runGroupTransform(opts) {
 			return () => {
 				changeListeners.delete(listener);
 			};
+		},
+		onCommit(listener) {
+			if (ctx.settled) return () => {};
+			commitListeners.add(listener);
+			return () => {
+				commitListeners.delete(listener);
+			};
 		}
 	};
 	let activeBoxDrag = null;
@@ -3100,12 +3209,13 @@ function runGroupTransform(opts) {
 			return;
 		}
 		if (localPreview || localHandles) return;
-		if (localGraphics && !memberIds.has(localGraphics.id)) {
-			ctx.commit(rebuildRenderedAll);
+		const isMember = localGraphics ? members.some((m) => m.measure.id === localGraphics.id) : false;
+		if (localGraphics && !isMember) {
+			commitClose();
 			if (onClickAwayGraphicsPick) onClickAwayGraphicsPick(localGraphics);
 			return;
 		}
-		ctx.commit(rebuildRenderedAll);
+		commitClose();
 	};
 	const core = runInteraction({
 		adapter,
@@ -3116,7 +3226,7 @@ function runGroupTransform(opts) {
 		attach(c) {
 			ctx = c;
 			driver = adapter.createEditPointerDriver();
-			liftOriginalsFromGraphics();
+			for (const member of members) liftMemberFromGraphics(member);
 			const unsubDown = driver.onPointerDown(onDriverDown);
 			const unsubMove = driver.onPointerMove(onDriverMove);
 			const unsubUp = driver.onPointerUp(onDriverUp);
@@ -3124,7 +3234,6 @@ function runGroupTransform(opts) {
 			const unsubPickHandles = adapter.onPick(handlesLayer, handlePickHandles);
 			const unsubPickGraphics = adapter.onPick(graphicsLayer, handlePickGraphics);
 			adapter.on("click", handleClick);
-			const anyWasOnGraphicsLayer = wasOnGraphicsLayer.some(Boolean);
 			c.onTeardown(() => {
 				adapter.off("click", handleClick);
 				unsubPickPreview();
@@ -3139,7 +3248,9 @@ function runGroupTransform(opts) {
 					dragInFlight = false;
 				}
 				driver.dispose();
-			}, anyWasOnGraphicsLayer ? restoreOriginalToGraphics : void 0);
+			}, () => {
+				if (anyLiftedFromGraphics) restoreOriginalToGraphics();
+			});
 			renderAllPreviews();
 			renderHandlesLayer();
 			recomputeDirty();
@@ -3151,7 +3262,9 @@ function runGroupTransform(opts) {
 		get settled() {
 			return core.settled;
 		},
-		measureIds: measures.map((m) => m.id),
+		get measureIds() {
+			return members.map((m) => m.measure.id);
+		},
 		abort(reason, cause) {
 			core.abort(reason, cause);
 		}
@@ -3297,10 +3410,21 @@ var TacticalDraw = class {
 	excludedInteractionIds() {
 		const ids = /* @__PURE__ */ new Set();
 		if (this.activeEdit) ids.add(this.activeEdit.measureId);
-		if (this.activeTransform) for (const id of this.activeTransform.measureIds) ids.add(id);
+		for (const id of this.transformMemberIds() ?? []) ids.add(id);
 		return ids;
 	}
 	/**
+	* Live member ids of the active group transform, or `undefined` when none.
+	* Falls back to the session ref because `onSession` fires from inside the
+	* controller's attach, before `runWithSlot` has assigned `activeTransform` —
+	* the session ref is registered first (`trackTransformSession`), so a
+	* `render()` from inside `onSession` still sees live membership.
+	*/
+	transformMemberIds() {
+		if (this.activeTransform) return this.activeTransform.measureIds;
+		return this.activeTransformSessionRef?.measures.map((m) => m.id);
+	}
+	/**
 	* Reconcile the graphics layer against the authoritative list of measures.
 	* Idempotent. Throws synchronously on duplicate measure ids *before*
 	* mutating any layer. An empty list before any prior render is a no-op.
@@ -3339,7 +3463,7 @@ var TacticalDraw = class {
 			externalEdited = measures.find((m) => m.id === editedId);
 			editedRemoved = externalEdited === void 0;
 		}
-		const transformIds = this.activeTransform?.measureIds;
+		const transformIds = this.transformMemberIds();
 		const transformMemberRemoved = transformIds ? transformIds.some((id) => !seen.has(id)) : false;
 		const excluded = this.excludedInteractionIds();
 		const visible = excluded.size > 0 ? measures.filter((m) => !excluded.has(m.id)) : measures;
@@ -3355,10 +3479,14 @@ var TacticalDraw = class {
 				editHandle.abort("removed");
 			});
 		}
-		if (transformMemberRemoved && this.activeTransform) {
-			const transformHandle = this.activeTransform;
+		if (transformMemberRemoved) {
+			const sessionRef = this.activeTransformSessionRef;
 			queueMicrotask(() => {
-				transformHandle.abort("removed");
+				const handle = this.activeTransform;
+				if (!handle || handle.settled) return;
+				if (this.activeTransformSessionRef !== sessionRef) return;
+				const rendered = new Set(this.lastRenderedMeasures.map((m) => m.id));
+				if (handle.measureIds.some((id) => !rendered.has(id))) handle.abort("removed");
 			});
 		}
 	}
@@ -3564,13 +3692,22 @@ var TacticalDraw = class {
 	* (ADR-0017 "Multi-select" slice). Every member is lifted onto the shared
 	* preview layer; the box (corner scale, rotate grip, drag-anywhere body
 	* translate) applies rigidly to all of them at once. Returns a Promise that
-	* resolves with index-aligned `ControlMeasureSnapshot[]` on
-	* `session.close()` and rejects with `TacticalDrawAbortError` on
-	* signal / Escape / destroy / preempt / `session.abort()`.
+	* resolves with `ControlMeasureSnapshot[]` on `session.close()` and rejects
+	* with `TacticalDrawAbortError` on signal / Escape / destroy / preempt /
+	* `session.abort()`. Key the resolved snapshots by `snapshot.measure.id`:
+	* the member set is mutable (`session.setMembers`, #187) so snapshot arrays
+	* are id-keyed, not index-aligned with this input. The promise resolves with
+	* the members in the set at close time; a member removed mid-session had its
+	* exit snapshot returned from the `setMembers` call that removed it.
 	*
 	* `measures.length` must be >= 1; a single-element array behaves like an
 	* `edit` with only `transform` mode. Throws `TypeError` synchronously (before
 	* any preemption) for an empty array or duplicate ids.
+	*
+	* For a selection that changes over time (shift-click toggle, marquee
+	* replace), prefer [[syncTransformMembers]] over hand-rolling the
+	* live-session-vs-fresh-`editMany` branch, and subscribe to
+	* `TransformSession.onCommit` as the single fold path for exit snapshots.
 	*/
 	editMany(measures, options) {
 		this.assertAlive();
@@ -3582,7 +3719,7 @@ var TacticalDraw = class {
 		}
 		const preempt = this.guardAndPreempt();
 		if (preempt) return preempt;
-		const wasOnGraphicsLayer = measures.map((m) => this.lastRenderedMeasures.some((rendered) => rendered.id === m.id));
+		const isOnGraphicsLayer = (id) => this.lastRenderedMeasures.some((m) => m.id === id);
 		const restoreOriginalToGraphics = () => {
 			this.renderMeasuresToGraphics(this.lastRenderedMeasures);
 		};
@@ -3608,7 +3745,7 @@ var TacticalDraw = class {
 			handleIdPrefix,
 			sizeAnchor: options?.sizeAnchor,
 			restoreOriginalToGraphics,
-			wasOnGraphicsLayer,
+			isOnGraphicsLayer,
 			onSettled,
 			onClickAwayGraphicsPick
 		}), (handle) => {
@@ -3619,6 +3756,42 @@ var TacticalDraw = class {
 		}, extraSettle);
 	}
 	/**
+	* One-call selection-sync: mutate the live group transform's member set in
+	* place, or start a fresh `editMany` when no transform is live (#191). This
+	* owns the "live session → `setMembers`, else → `editMany`" branch that every
+	* host otherwise hand-rolls against `activeTransformSession`.
+	*
+	* The facade knows session liveness synchronously — `activeTransformSessionRef`
+	* is cleared inside the settle path, before control returns to host code — so
+	* unlike a host's own `activeTransformSession ? setMembers : editMany` check,
+	* this can never observe a stale ref pointing at an already-settled session.
+	* The settled-race fall-through hosts had to hand-roll for that gap is owned
+	* here instead: a `setMembers` call that (implausibly) still returns
+	* `undefined` falls through to a fresh `editMany` rather than silently
+	* dropping the selection.
+	*
+	* `measures: []` closes any live session (committing every member) and is a
+	* no-op while idle. With a live session, `options` is ignored — session-scoped
+	* state (`sizeAnchor`, box angle, close-on-click-away policy) is sticky per
+	* `setMembers`'s contract; `options` applies only when this call starts a
+	* fresh `editMany`. Exit snapshots are delivered via the session's
+	* `onCommit` — subscribe once in `options.onSession`. The underlying
+	* `editMany` promise is owned by the facade; its abort rejections are
+	* swallowed here (non-abort errors surface as unhandled rejections). Throws
+	* `TypeError` synchronously on duplicate ids, from either path. Starting a
+	* fresh transform preempts any other in-flight draw/edit exactly like
+	* `editMany`.
+	*/
+	syncTransformMembers(measures, options) {
+		this.assertAlive();
+		const session = this.activeTransformSessionRef;
+		if (session) {
+			if (session.setMembers(measures) !== void 0) return;
+		}
+		if (measures.length === 0) return;
+		this.editMany([...measures], options).catch(ignoreAbort);
+	}
+	/**
 	* Subscribe to picks on committed control measures.
 	*
 	* The graphics layer is pre-bound, and `event.id` is the originating control

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw",
-  "version": "0.2.0-alpha.7",
+  "version": "0.2.0-alpha.9",
   "description": "Engine-agnostic draw/edit core for tactical control measures (MIL-STD-2525 / APP-6). The MapAdapter ABI and bring-your-own-engine entry point for the tactical-draw package family.",
   "license": "MIT",
   "author": "Orbat Mapper",