@weasel-js/core 1.10.1 → 1.11.0

package/dist/core/scene/notifier.js

@@ -1,37 +1,48 @@
-import { createEmitter as e } from "@weasel-js/registry";
+import { createEmitter } from "@weasel-js/registry";
+
 //#region src/core/scene/notifier.ts
-function t() {
-	let t = e(), n = 0, r = 0, i = !1;
+function createNotifier() {
+	const changed = createEmitter();
+	let version = 0;
+	let held = 0;
+	let pending = false;
 	return {
 		notify() {
-			if (n++, r > 0) {
-				i = !0;
+			version++;
+			if (held > 0) {
+				pending = true;
 				return;
 			}
-			t.emit();
+			changed.emit();
 		},
-		version: () => n,
-		subscribe: t.subscribe,
-		deferred(e, n) {
-			r++;
+		version: () => version,
+		subscribe: changed.subscribe,
+		deferred(fn, settle) {
+			held++;
 			try {
-				return e();
+				return fn();
 			} finally {
-				r--, n?.(), r === 0 && i && (i = !1, t.emit());
+				held--;
+				settle?.();
+				if (held === 0 && pending) {
+					pending = false;
+					changed.emit();
+				}
 			}
 		},
-		muted(e) {
-			let t = i;
-			r++;
+		muted(fn) {
+			const was = pending;
+			held++;
 			try {
-				return e();
+				return fn();
 			} finally {
-				r--, i = t;
+				held--;
+				pending = was;
 			}
 		}
 	};
 }
-//#endregion
-export { t as createNotifier };
 
+//#endregion
+export { createNotifier };
 //# sourceMappingURL=notifier.js.map

package/dist/core/scene/notifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"notifier.js","names":["createNotifier","changed","createEmitter","version","held","pending","fn","settle","was"],"sources":["../../../src/core/scene/notifier.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\n\n/**\n * The scene's change notice: its version, its subscribers, and when a change\n * reaches them.\n */\nexport interface Notifier {\n  /** Count a change, and call the subscribers unless the call is held. */\n  notify(): void;\n  version(): number;\n  subscribe(listener: () => void): () => void;\n  /** Run `fn` with the calls it causes held, then make one for all of them\n   *  once the outermost holder is done. `settle` runs between the two: after\n   *  this holder has let go, before any subscriber is called. */\n  deferred<T>(fn: () => T, settle?: () => void): T;\n  /** Run `fn` with the calls it causes held and then dropped: its caller\n   *  notifies once itself. The version still counts each one. */\n  muted<T>(fn: () => T): T;\n}\n\nexport function createNotifier(): Notifier {\n  const changed = createEmitter();\n  let version = 0;\n  let held = 0;\n  let pending = false;\n\n  return {\n    notify() {\n      version++;\n      if (held > 0) {\n        pending = true;\n        return;\n      }\n      changed.emit();\n    },\n    version: () => version,\n    subscribe: changed.subscribe,\n    deferred(fn, settle) {\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        settle?.();\n        if (held === 0 && pending) {\n          pending = false;\n          changed.emit();\n        }\n      }\n    },\n    muted(fn) {\n      const was = pending;\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        pending = was;\n      }\n    },\n  };\n}\n"],"mappings":";;AAoBA,SAAgBA,IAA2B;CACzC,IAAMC,IAAUC,EAAc,GAC1BC,IAAU,GACVC,IAAO,GACPC,IAAU;CAEd,OAAO;EACL,SAAS;GAEP,IADA,KACID,IAAO,GAAG;IACZ,IAAU;IACV;GACF;GACA,EAAQ,KAAK;EACf;EACA,eAAeD;EACf,WAAWF,EAAQ;EACnB,SAAS,GAAI,GAAQ;GACnB;GACA,IAAI;IACF,OAAOK,EAAG;GACZ,UAAU;IAGR,AAFA,KACAC,IAAS,GACLH,MAAS,KAAKC,MAChB,IAAU,IACVJ,EAAQ,KAAK;GAEjB;EACF;EACA,MAAM,GAAI;GACR,IAAMO,IAAMH;GACZ;GACA,IAAI;IACF,OAAOC,EAAG;GACZ,UAAU;IAER,AADA,KACA,IAAUE;GACZ;EACF;CACF;AACF"}
+{"version":3,"file":"notifier.js","names":[],"sources":["../../../src/core/scene/notifier.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\n\n/**\n * The scene's change notice: its version, its subscribers, and when a change\n * reaches them.\n */\nexport interface Notifier {\n  /** Count a change, and call the subscribers unless the call is held. */\n  notify(): void;\n  version(): number;\n  subscribe(listener: () => void): () => void;\n  /** Run `fn` with the calls it causes held, then make one for all of them\n   *  once the outermost holder is done. `settle` runs between the two: after\n   *  this holder has let go, before any subscriber is called. */\n  deferred<T>(fn: () => T, settle?: () => void): T;\n  /** Run `fn` with the calls it causes held and then dropped: its caller\n   *  notifies once itself. The version still counts each one. */\n  muted<T>(fn: () => T): T;\n}\n\nexport function createNotifier(): Notifier {\n  const changed = createEmitter();\n  let version = 0;\n  let held = 0;\n  let pending = false;\n\n  return {\n    notify() {\n      version++;\n      if (held > 0) {\n        pending = true;\n        return;\n      }\n      changed.emit();\n    },\n    version: () => version,\n    subscribe: changed.subscribe,\n    deferred(fn, settle) {\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        settle?.();\n        if (held === 0 && pending) {\n          pending = false;\n          changed.emit();\n        }\n      }\n    },\n    muted(fn) {\n      const was = pending;\n      held++;\n      try {\n        return fn();\n      } finally {\n        held--;\n        pending = was;\n      }\n    },\n  };\n}\n"],"mappings":";;;AAoBA,SAAgB,iBAA2B;CACzC,MAAM,UAAU,cAAc;CAC9B,IAAI,UAAU;CACd,IAAI,OAAO;CACX,IAAI,UAAU;CAEd,OAAO;EACL,SAAS;GACP;GACA,IAAI,OAAO,GAAG;IACZ,UAAU;IACV;GACF;GACA,QAAQ,KAAK;EACf;EACA,eAAe;EACf,WAAW,QAAQ;EACnB,SAAS,IAAI,QAAQ;GACnB;GACA,IAAI;IACF,OAAO,GAAG;GACZ,UAAU;IACR;IACA,SAAS;IACT,IAAI,SAAS,KAAK,SAAS;KACzB,UAAU;KACV,QAAQ,KAAK;IACf;GACF;EACF;EACA,MAAM,IAAI;GACR,MAAM,MAAM;GACZ;GACA,IAAI;IACF,OAAO,GAAG;GACZ,UAAU;IACR;IACA,UAAU;GACZ;EACF;CACF;AACF"}

package/dist/core/scene/opTable.js

@@ -1,50 +1,56 @@
 //#region src/core/scene/opTable.ts
-function e(e) {
-	let t = /* @__PURE__ */ new Map();
-	function n(e) {
-		let n = t.get(e);
-		if (!n) throw Error(`Scene: no registered op for kind "${e}"`);
-		return n;
+function createOpTable(env) {
+	const handlers = /* @__PURE__ */ new Map();
+	function handlerFor(kind) {
+		const handler = handlers.get(kind);
+		if (!handler) throw new Error(`Scene: no registered op for kind "${kind}"`);
+		return handler;
 	}
-	function r(e, n) {
-		let r;
-		if (e.startsWith("kit:")) {
-			if (typeof n != "object" || !n) return;
-			let e = n;
-			r = typeof e.id == "string" ? e.id : typeof e.layer == "string" ? e.layer : void 0;
-		} else r = t.get(e)?.coalesceKey?.(n);
-		return r === void 0 ? void 0 : `${e}:${r}`;
+	/** Coalesce-grouping key. Kit ops are keyed by the node or layer they
+	*  address; a consumer kind only by the `coalesceKey` it declares. Keys
+	*  take effect only under `UseSceneOptions.coalesceWindowMs`. */
+	function coalesceKeyFor(kind, payload) {
+		let token;
+		if (kind.startsWith("kit:")) {
+			if (payload === null || typeof payload !== "object") return void 0;
+			const p = payload;
+			token = typeof p.id === "string" ? p.id : typeof p.layer === "string" ? p.layer : void 0;
+		} else token = handlers.get(kind)?.coalesceKey?.(payload);
+		return token === void 0 ? void 0 : `${kind}:${token}`;
 	}
-	function i(t, a, o = !0) {
-		return n(t), {
-			name: t,
-			args: a,
-			coalesceKey: r(t, a),
+	function op(kind, payload, forward = true) {
+		handlerFor(kind);
+		return {
+			name: kind,
+			args: payload,
+			coalesceKey: coalesceKeyFor(kind, payload),
 			apply: () => {
-				let r = () => {
-					let r = n(t);
-					if (e.skips(t, a, o)) return "noop";
-					(o ? r.apply : r.revert)(a), e.applied(t, a, !o);
+				const run = () => {
+					const handler = handlerFor(kind);
+					if (env.skips(kind, payload, forward)) return "noop";
+					(forward ? handler.apply : handler.revert)(payload);
+					env.applied(kind, payload, !forward);
 				};
-				if (e.driven()) return r();
-				let i;
-				return e.replayAlone(() => {
-					i = r();
-				}), i;
+				if (env.driven()) return run();
+				let result;
+				env.replayAlone(() => {
+					result = run();
+				});
+				return result;
 			},
-			invert: () => i(t, a, !o)
+			invert: () => op(kind, payload, !forward)
 		};
 	}
 	return {
-		handlers: t,
-		register: (e, n) => {
-			t.set(e, n);
+		handlers,
+		register: (kind, handler) => {
+			handlers.set(kind, handler);
 		},
-		run: (e, t) => n(e).apply(t),
-		op: (e, t) => i(e, t)
+		run: (kind, payload) => handlerFor(kind).apply(payload),
+		op: (kind, payload) => op(kind, payload)
 	};
 }
-//#endregion
-export { e as createOpTable };
 
+//#endregion
+export { createOpTable };
 //# sourceMappingURL=opTable.js.map

package/dist/core/scene/opTable.js.map

@@ -1 +1 @@
-{"version":3,"file":"opTable.js","names":["createOpTable","handlers","handlerFor","handler","kind","coalesceKeyFor","token","payload","p","op","run","env","forward","result"],"sources":["../../../src/core/scene/opTable.ts"],"sourcesContent":["/**\n * The scene's registered ops: the kit's own kinds and a consumer's, each a\n * pair of functions over a serializable payload, and the engine `Op` built\n * from one.\n */\nimport type { Op } from 'core/ops/types';\nimport type { RegisteredOp } from './types';\n\n/** What the table asks of the scene when one of its ops runs. */\nexport interface OpTableEnv {\n  /** Whether replaying this op would address a node that is no longer where\n   *  its entry left it; such an op reports a no-op. */\n  skips(kind: string, payload: unknown, forward: boolean): boolean;\n  /** Called after an op built by {@link OpTable.op} has applied, with the\n   *  direction it ran in. */\n  applied(kind: string, payload: unknown, reverted: boolean): void;\n  /** Whether an edit of the scene's is running. An op applied outside one\n   *  is a replay by a history the scene does not own: a mode journal's undo,\n   *  redo or cancel. */\n  driven(): boolean;\n  /** Run `step` as a replay step of its own, and notify. */\n  replayAlone(step: () => void): void;\n}\n\nexport interface OpTable {\n  handlers: ReadonlyMap<string, RegisteredOp<unknown>>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  /** Apply a kind's forward half. Throws when nothing is registered for it. */\n  run(kind: string, payload: unknown): void;\n  /** A registered op as an engine `Op`. `invert()` flips the direction with\n   *  the same payload, so undo replays `revert` and redo replays `apply`.\n   *  The handler is looked up at apply time, so a re-registered kind takes\n   *  effect on replay; that one exists is checked here, to fail at the call\n   *  site. */\n  op(kind: string, payload: unknown): Op;\n}\n\nexport function createOpTable(env: OpTableEnv): OpTable {\n  const handlers = new Map<string, RegisteredOp<unknown>>();\n\n  function handlerFor(kind: string): RegisteredOp<unknown> {\n    const handler = handlers.get(kind);\n    if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    return handler;\n  }\n\n  /** Coalesce-grouping key. Kit ops are keyed by the node or layer they\n   *  address; a consumer kind only by the `coalesceKey` it declares. Keys\n   *  take effect only under `UseSceneOptions.coalesceWindowMs`. */\n  function coalesceKeyFor(kind: string, payload: unknown): string | undefined {\n    let token: string | undefined;\n    if (kind.startsWith('kit:')) {\n      if (payload === null || typeof payload !== 'object') return undefined;\n      const p = payload as { id?: unknown; layer?: unknown };\n      token =\n        typeof p.id === 'string' ? p.id\n        : typeof p.layer === 'string' ? p.layer\n        : undefined;\n    } else {\n      token = handlers.get(kind)?.coalesceKey?.(payload);\n    }\n    return token === undefined ? undefined : `${kind}:${token}`;\n  }\n\n  function op(kind: string, payload: unknown, forward = true): Op {\n    handlerFor(kind);\n    return {\n      name: kind,\n      args: payload,\n      coalesceKey: coalesceKeyFor(kind, payload),\n      apply: () => {\n        const run = (): 'noop' | undefined => {\n          const handler = handlerFor(kind);\n          if (env.skips(kind, payload, forward)) return 'noop';\n          (forward ? handler.apply : handler.revert)(payload);\n          env.applied(kind, payload, !forward);\n          return undefined;\n        };\n        if (env.driven()) return run();\n        let result: 'noop' | undefined;\n        env.replayAlone(() => { result = run(); });\n        return result;\n      },\n      invert: () => op(kind, payload, !forward),\n    };\n  }\n\n  return {\n    handlers,\n    register: (kind, handler) => { handlers.set(kind, handler); },\n    run: (kind, payload) => handlerFor(kind).apply(payload),\n    op: (kind, payload) => op(kind, payload),\n  };\n}\n"],"mappings":";AAqCA,SAAgBA,EAAc,GAA0B;CACtD,IAAMC,oBAAW,IAAI,IAAmC;CAExD,SAASC,EAAW,GAAqC;EACvD,IAAMC,IAAUF,EAAS,IAAIG,CAAI;EACjC,IAAI,CAACD,GAAS,MAAU,MAAM,qCAAqCC,EAAK,EAAE;EAC1E,OAAOD;CACT;CAKA,SAASE,EAAe,GAAc,GAAsC;EAC1E,IAAIC;EACJ,IAAIF,EAAK,WAAW,MAAM,GAAG;GAC3B,IAAwB,OAAOG,KAAY,aAAvCA,GAAiD;GACrD,IAAMC,IAAID;GACV,IACE,OAAOC,EAAE,MAAO,WAAWA,EAAE,KAC3B,OAAOA,EAAE,SAAU,WAAWA,EAAE,QAChC,KAAA;EACN,OACE,IAAQP,EAAS,IAAIG,CAAI,CAAC,EAAE,cAAcG,CAAO;EAEnD,OAAOD,MAAU,KAAA,IAAY,KAAA,IAAY,GAAGF,EAAK,GAAGE;CACtD;CAEA,SAASG,EAAG,GAAc,GAAkB,IAAU,IAAU;EAE9D,OADAP,EAAWE,CAAI,GACR;GACL,MAAMA;GACN,MAAMG;GACN,aAAaF,EAAeD,GAAMG,CAAO;GACzC,aAAa;IACX,IAAMG,UAAgC;KACpC,IAAMP,IAAUD,EAAWE,CAAI;KAC/B,IAAIO,EAAI,MAAMP,GAAMG,GAASK,CAAO,GAAG,OAAO;KAE9C,CADCA,IAAUT,EAAQ,QAAQA,EAAQ,OAAA,CAAQI,CAAO,GAClDI,EAAI,QAAQP,GAAMG,GAAS,CAACK,CAAO;IAErC;IACA,IAAID,EAAI,OAAO,GAAG,OAAOD,EAAI;IAC7B,IAAIG;IAEJ,OADAF,EAAI,kBAAkB;KAAE,IAASD,EAAI;IAAG,CAAC,GAClCG;GACT;GACA,cAAcJ,EAAGL,GAAMG,GAAS,CAACK,CAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,GAAM,MAAY;GAAE,EAAS,IAAIR,GAAMD,CAAO;EAAG;EAC5D,MAAM,GAAM,MAAYD,EAAWE,CAAI,CAAC,CAAC,MAAMG,CAAO;EACtD,KAAK,GAAM,MAAYE,EAAGL,GAAMG,CAAO;CACzC;AACF"}
+{"version":3,"file":"opTable.js","names":[],"sources":["../../../src/core/scene/opTable.ts"],"sourcesContent":["/**\n * The scene's registered ops: the kit's own kinds and a consumer's, each a\n * pair of functions over a serializable payload, and the engine `Op` built\n * from one.\n */\nimport type { Op } from 'core/ops/types';\nimport type { RegisteredOp } from './types';\n\n/** What the table asks of the scene when one of its ops runs. */\nexport interface OpTableEnv {\n  /** Whether replaying this op would address a node that is no longer where\n   *  its entry left it; such an op reports a no-op. */\n  skips(kind: string, payload: unknown, forward: boolean): boolean;\n  /** Called after an op built by {@link OpTable.op} has applied, with the\n   *  direction it ran in. */\n  applied(kind: string, payload: unknown, reverted: boolean): void;\n  /** Whether an edit of the scene's is running. An op applied outside one\n   *  is a replay by a history the scene does not own: a mode journal's undo,\n   *  redo or cancel. */\n  driven(): boolean;\n  /** Run `step` as a replay step of its own, and notify. */\n  replayAlone(step: () => void): void;\n}\n\nexport interface OpTable {\n  handlers: ReadonlyMap<string, RegisteredOp<unknown>>;\n  register(kind: string, handler: RegisteredOp<unknown>): void;\n  /** Apply a kind's forward half. Throws when nothing is registered for it. */\n  run(kind: string, payload: unknown): void;\n  /** A registered op as an engine `Op`. `invert()` flips the direction with\n   *  the same payload, so undo replays `revert` and redo replays `apply`.\n   *  The handler is looked up at apply time, so a re-registered kind takes\n   *  effect on replay; that one exists is checked here, to fail at the call\n   *  site. */\n  op(kind: string, payload: unknown): Op;\n}\n\nexport function createOpTable(env: OpTableEnv): OpTable {\n  const handlers = new Map<string, RegisteredOp<unknown>>();\n\n  function handlerFor(kind: string): RegisteredOp<unknown> {\n    const handler = handlers.get(kind);\n    if (!handler) throw new Error(`Scene: no registered op for kind \"${kind}\"`);\n    return handler;\n  }\n\n  /** Coalesce-grouping key. Kit ops are keyed by the node or layer they\n   *  address; a consumer kind only by the `coalesceKey` it declares. Keys\n   *  take effect only under `UseSceneOptions.coalesceWindowMs`. */\n  function coalesceKeyFor(kind: string, payload: unknown): string | undefined {\n    let token: string | undefined;\n    if (kind.startsWith('kit:')) {\n      if (payload === null || typeof payload !== 'object') return undefined;\n      const p = payload as { id?: unknown; layer?: unknown };\n      token =\n        typeof p.id === 'string' ? p.id\n        : typeof p.layer === 'string' ? p.layer\n        : undefined;\n    } else {\n      token = handlers.get(kind)?.coalesceKey?.(payload);\n    }\n    return token === undefined ? undefined : `${kind}:${token}`;\n  }\n\n  function op(kind: string, payload: unknown, forward = true): Op {\n    handlerFor(kind);\n    return {\n      name: kind,\n      args: payload,\n      coalesceKey: coalesceKeyFor(kind, payload),\n      apply: () => {\n        const run = (): 'noop' | undefined => {\n          const handler = handlerFor(kind);\n          if (env.skips(kind, payload, forward)) return 'noop';\n          (forward ? handler.apply : handler.revert)(payload);\n          env.applied(kind, payload, !forward);\n          return undefined;\n        };\n        if (env.driven()) return run();\n        let result: 'noop' | undefined;\n        env.replayAlone(() => { result = run(); });\n        return result;\n      },\n      invert: () => op(kind, payload, !forward),\n    };\n  }\n\n  return {\n    handlers,\n    register: (kind, handler) => { handlers.set(kind, handler); },\n    run: (kind, payload) => handlerFor(kind).apply(payload),\n    op: (kind, payload) => op(kind, payload),\n  };\n}\n"],"mappings":";AAqCA,SAAgB,cAAc,KAA0B;CACtD,MAAM,2BAAW,IAAI,IAAmC;CAExD,SAAS,WAAW,MAAqC;EACvD,MAAM,UAAU,SAAS,IAAI,IAAI;EACjC,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,qCAAqC,KAAK,EAAE;EAC1E,OAAO;CACT;;;;CAKA,SAAS,eAAe,MAAc,SAAsC;EAC1E,IAAI;EACJ,IAAI,KAAK,WAAW,MAAM,GAAG;GAC3B,IAAI,YAAY,QAAQ,OAAO,YAAY,UAAU,OAAO;GAC5D,MAAM,IAAI;GACV,QACE,OAAO,EAAE,OAAO,WAAW,EAAE,KAC3B,OAAO,EAAE,UAAU,WAAW,EAAE,QAChC;EACN,OACE,QAAQ,SAAS,IAAI,IAAI,CAAC,EAAE,cAAc,OAAO;EAEnD,OAAO,UAAU,SAAY,SAAY,GAAG,KAAK,GAAG;CACtD;CAEA,SAAS,GAAG,MAAc,SAAkB,UAAU,MAAU;EAC9D,WAAW,IAAI;EACf,OAAO;GACL,MAAM;GACN,MAAM;GACN,aAAa,eAAe,MAAM,OAAO;GACzC,aAAa;IACX,MAAM,YAAgC;KACpC,MAAM,UAAU,WAAW,IAAI;KAC/B,IAAI,IAAI,MAAM,MAAM,SAAS,OAAO,GAAG,OAAO;KAC9C,CAAC,UAAU,QAAQ,QAAQ,QAAQ,OAAA,CAAQ,OAAO;KAClD,IAAI,QAAQ,MAAM,SAAS,CAAC,OAAO;IAErC;IACA,IAAI,IAAI,OAAO,GAAG,OAAO,IAAI;IAC7B,IAAI;IACJ,IAAI,kBAAkB;KAAE,SAAS,IAAI;IAAG,CAAC;IACzC,OAAO;GACT;GACA,cAAc,GAAG,MAAM,SAAS,CAAC,OAAO;EAC1C;CACF;CAEA,OAAO;EACL;EACA,WAAW,MAAM,YAAY;GAAE,SAAS,IAAI,MAAM,OAAO;EAAG;EAC5D,MAAM,MAAM,YAAY,WAAW,IAAI,CAAC,CAAC,MAAM,OAAO;EACtD,KAAK,MAAM,YAAY,GAAG,MAAM,OAAO;CACzC;AACF"}

package/dist/core/scene/outerOps.js

@@ -1,67 +1,73 @@
-import { rebuildOp as e } from "../ops/registry.js";
-import { bindOpToAdapter as t, bindOpToHistoryAdapter as n } from "./boundOps.js";
+import { rebuildOp } from "../ops/registry.js";
+import { bindOpToAdapter, bindOpToHistoryAdapter } from "./boundOps.js";
+
 //#region src/core/scene/outerOps.ts
-function r(e, t) {
-	let n = t === void 0 || e.coalesceKey === void 0 ? void 0 : `${t}>${e.coalesceKey}`;
+/** A kit op under the key of the outer op that caused it, so two edits merge
+*  when their outer ops would have. */
+function keyed(kit, outerKey) {
+	const key = outerKey === void 0 || kit.coalesceKey === void 0 ? void 0 : `${outerKey}>${kit.coalesceKey}`;
 	return {
-		name: e.name,
-		args: e.args,
-		coalesceKey: n,
-		apply: e.apply,
-		invert: e.invert
+		name: kit.name,
+		args: kit.args,
+		coalesceKey: key,
+		apply: kit.apply,
+		invert: kit.invert
 	};
 }
-function i(i) {
-	let a = null, o = i.getActiveJournal;
-	function s(e, t = e) {
-		if (e.caused) return e;
-		let n = [t];
+function createOuterOps(env) {
+	let historyAdapter = null;
+	let activeJournal = env.getActiveJournal;
+	function causing(op, given = op) {
+		if (op.caused) return op;
+		let caused = [given];
 		return {
 			get name() {
-				return e.name;
+				return op.name;
 			},
 			get args() {
-				return e.args;
+				return op.args;
 			},
-			label: e.label,
+			label: op.label,
 			get coalesceKey() {
-				return e.coalesceKey;
+				return op.coalesceKey;
 			},
-			elideNoop: e.elideNoop,
-			apply(a) {
-				let { result: o, ops: s } = i.recorder().capturing(() => t.apply(a));
-				return s.length > 0 && (n = s.map((t) => r(t, e.coalesceKey))), o;
+			elideNoop: op.elideNoop,
+			apply(adapter) {
+				const { result, ops } = env.recorder().capturing(() => given.apply(adapter));
+				if (ops.length > 0) caused = ops.map((kit) => keyed(kit, op.coalesceKey));
+				return result;
 			},
-			caused: () => n,
-			invert: () => t.invert()
+			caused: () => caused,
+			invert: () => given.invert()
 		};
 	}
 	return {
-		rebuild(t, r) {
-			let o = i.own(t, r);
-			if (o !== null) return o;
-			let s = e(t, r);
-			return s === null ? null : n(s, () => a);
+		rebuild(name, args) {
+			const own = env.own(name, args);
+			if (own !== null) return own;
+			const rebuilt = rebuildOp(name, args);
+			return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt, () => historyAdapter);
 		},
-		causing: (e) => s(e),
-		apply(e, n, r, a) {
-			if (i.recorder().joins()) return i.recorder().join(n, a);
-			let c = o?.() ?? null;
-			i.driving(() => {
-				let i = n.map((e) => s(e, t(e, a)));
-				c ? c.applyBatch(i, r) : e.applyOps(i, r);
+		causing: (op) => causing(op),
+		apply(engine, ops, label, adapter) {
+			if (env.recorder().joins()) return env.recorder().join(ops, adapter);
+			const journal = activeJournal?.() ?? null;
+			env.driving(() => {
+				const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));
+				if (journal) journal.applyBatch(bound, label);
+				else engine.applyOps(bound, label);
 			});
 		},
-		setHistoryAdapter(e) {
-			a = e;
+		setHistoryAdapter(fn) {
+			historyAdapter = fn;
 		},
-		setActiveJournalAccessor(e) {
-			o = e;
+		setActiveJournalAccessor(fn) {
+			activeJournal = fn;
 		},
-		activeJournal: () => o?.() ?? null
+		activeJournal: () => activeJournal?.() ?? null
 	};
 }
-//#endregion
-export { i as createOuterOps };
 
+//#endregion
+export { createOuterOps };
 //# sourceMappingURL=outerOps.js.map

package/dist/core/scene/outerOps.js.map

@@ -1 +1 @@
-{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp","keyed","key","outerKey","kit","createOuterOps","historyAdapter","activeJournal","env","causing","op","caused","given","adapter","ops","result","own","name","args","rebuilt","rebuildOp","bindOpToHistoryAdapter","journal","bound","bindOpToAdapter","label","engine","fn"],"sources":["../../../src/core/scene/outerOps.ts"],"sourcesContent":["/**\n * Ops built outside the scene and handed to `applyBatch` or `scene.history`.\n *\n * An undo entry holds the scene's own ops, so an outer op is recorded as the\n * kit ops it caused. One that wrote no scene state is recorded as itself, and\n * needs an adapter to replay through: the one it was applied with, or after a\n * reload the one `setHistoryAdapter` supplies.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { rebuildOp as rebuildGlobalOp } from 'core/ops/registry';\nimport { bindOpToAdapter, bindOpToHistoryAdapter } from './boundOps';\nimport type { Recorder } from './recorder';\n\n/** What the outer ops need from the scene they are applied to. */\nexport interface OuterOpsEnv {\n  /** The scene's own op for a kind it has registered, or `null`. */\n  own(name: string, args: unknown): Op | null;\n  /** The scene's recorder, built after this is. */\n  recorder(): Pick<Recorder, 'capturing' | 'joins' | 'join'>;\n  /** Run a step that applies ops through a history engine: all-or-nothing,\n   *  unrecorded by the scene, with subscribers called once after. */\n  driving(step: () => void): void;\n  /** Where `applyBatch` looks for an open journal until an accessor is set. */\n  getActiveJournal: (() => Journal | null) | null;\n}\n\nexport interface OuterOps {\n  /** The op a restored history names: the scene's own, or an outer op bound\n   *  to the adapter `setHistoryAdapter` supplies. `null` when nothing knows\n   *  the name, and the engine places its no-op placeholder. */\n  rebuild(name: string, args: unknown): Op | null;\n  /** `op` as an engine applies it: its entry records the kit ops it caused,\n   *  or the op itself when it caused none. */\n  causing(op: Op): Op;\n  /** Apply `ops` against `adapter` as one entry: part of the open `batch`\n   *  when there is one, else on the active journal, else on `engine`. */\n  apply(engine: History, ops: Op[], label: string, adapter: unknown): void;\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n  setActiveJournalAccessor(fn: (() => Journal | null) | null): void;\n  /** The journal edits go to now, or null for the scene's own history. */\n  activeJournal(): Journal | null;\n}\n\n/** A kit op under the key of the outer op that caused it, so two edits merge\n *  when their outer ops would have. */\nfunction keyed(kit: Op, outerKey: string | undefined): Op {\n  const key = outerKey === undefined || kit.coalesceKey === undefined ? undefined : `${outerKey}>${kit.coalesceKey}`;\n  return { name: kit.name, args: kit.args, coalesceKey: key, apply: kit.apply, invert: kit.invert };\n}\n\nexport function createOuterOps(env: OuterOpsEnv): OuterOps {\n  let historyAdapter: (() => unknown) | null = null;\n  let activeJournal = env.getActiveJournal;\n\n  function causing(op: Op, given: Op = op): Op {\n    if (op.caused) return op;\n    let caused: Op[] = [given];\n    return {\n      get name() { return op.name; },\n      get args() { return op.args; },\n      label: op.label,\n      // Read when asked: an arrange op has no key until it has applied.\n      get coalesceKey() { return op.coalesceKey; },\n      elideNoop: op.elideNoop,\n      apply(adapter) {\n        const { result, ops } = env.recorder().capturing(() => given.apply(adapter));\n        if (ops.length > 0) caused = ops.map((kit) => keyed(kit, op.coalesceKey));\n        return result;\n      },\n      caused: () => caused,\n      invert: () => given.invert(),\n    };\n  }\n\n  return {\n    rebuild(name, args) {\n      const own = env.own(name, args);\n      if (own !== null) return own;\n      const rebuilt = rebuildGlobalOp(name, args);\n      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt, () => historyAdapter);\n    },\n    causing: (op) => causing(op),\n    apply(engine, ops, label, adapter) {\n      if (env.recorder().joins()) return env.recorder().join(ops, adapter);\n      const journal = activeJournal?.() ?? null;\n      env.driving(() => {\n        // Neither engine was built with an adapter, so an op is bound to\n        // this call's before either applies or stores it.\n        const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));\n        if (journal) journal.applyBatch(bound, label);\n        else engine.applyOps(bound, label);\n      });\n    },\n    setHistoryAdapter(fn) {\n      historyAdapter = fn;\n    },\n    setActiveJournalAccessor(fn) {\n      activeJournal = fn;\n    },\n    activeJournal: () => activeJournal?.() ?? null,\n  };\n}\n"],"mappings":";;;AA8CA,SAASC,EAAM,GAAS,GAAkC;CACxD,IAAMC,IAAMC,MAAa,KAAA,KAAaC,EAAI,gBAAgB,KAAA,IAAY,KAAA,IAAY,GAAGD,EAAS,GAAGC,EAAI;CACrG,OAAO;EAAE,MAAMA,EAAI;EAAM,MAAMA,EAAI;EAAM,aAAaF;EAAK,OAAOE,EAAI;EAAO,QAAQA,EAAI;CAAO;AAClG;AAEA,SAAgBC,EAAe,GAA4B;CACzD,IAAIC,IAAyC,MACzCC,IAAgBC,EAAI;CAExB,SAASC,EAAQ,GAAQ,IAAYC,GAAQ;EAC3C,IAAIA,EAAG,QAAQ,OAAOA;EACtB,IAAIC,IAAe,CAACC,CAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAOF,EAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAOA,EAAG;GAAM;GAC7B,OAAOA,EAAG;GAEV,IAAI,cAAc;IAAE,OAAOA,EAAG;GAAa;GAC3C,WAAWA,EAAG;GACd,MAAM,GAAS;IACb,IAAM,EAAE,WAAQ,WAAQF,EAAI,SAAS,CAAC,CAAC,gBAAgBI,EAAM,MAAMC,CAAO,CAAC;IAE3E,OADIC,EAAI,SAAS,MAAG,IAASA,EAAI,KAAK,MAAQb,EAAMG,GAAKM,EAAG,WAAW,CAAC,IACjEK;GACT;GACA,cAAcJ;GACd,cAAcC,EAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,GAAM,GAAM;GAClB,IAAMI,IAAMR,EAAI,IAAIS,GAAMC,CAAI;GAC9B,IAAIF,MAAQ,MAAM,OAAOA;GACzB,IAAMG,IAAUnB,EAAgBiB,GAAMC,CAAI;GAC1C,OAAOC,MAAY,OAAO,OAAOE,EAAuBF,SAAeb,CAAc;EACvF;EACA,UAAU,MAAOG,EAAQC,CAAE;EAC3B,MAAM,GAAQ,GAAK,GAAO,GAAS;GACjC,IAAIF,EAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAOA,EAAI,SAAS,CAAC,CAAC,KAAKM,GAAKD,CAAO;GACnE,IAAMS,IAAUf,IAAgB,KAAK;GACrC,EAAI,cAAc;IAGhB,IAAMgB,IAAQT,EAAI,KAAK,MAAOL,EAAQC,GAAIc,EAAgBd,GAAIG,CAAO,CAAC,CAAC;IACvE,AAAIS,IAASA,EAAQ,WAAWC,GAAOE,CAAK,IACvCC,EAAO,SAASH,GAAOE,CAAK;GACnC,CAAC;EACH;EACA,kBAAkB,GAAI;GACpB,IAAiBE;EACnB;EACA,yBAAyB,GAAI;GAC3B,IAAgBA;EAClB;EACA,qBAAqBpB,IAAgB,KAAK;CAC5C;AACF"}
+{"version":3,"file":"outerOps.js","names":["rebuildGlobalOp"],"sources":["../../../src/core/scene/outerOps.ts"],"sourcesContent":["/**\n * Ops built outside the scene and handed to `applyBatch` or `scene.history`.\n *\n * An undo entry holds the scene's own ops, so an outer op is recorded as the\n * kit ops it caused. One that wrote no scene state is recorded as itself, and\n * needs an adapter to replay through: the one it was applied with, or after a\n * reload the one `setHistoryAdapter` supplies.\n */\nimport type { History, Journal } from '@weasel-js/history';\nimport type { Op } from 'core/ops/types';\nimport { rebuildOp as rebuildGlobalOp } from 'core/ops/registry';\nimport { bindOpToAdapter, bindOpToHistoryAdapter } from './boundOps';\nimport type { Recorder } from './recorder';\n\n/** What the outer ops need from the scene they are applied to. */\nexport interface OuterOpsEnv {\n  /** The scene's own op for a kind it has registered, or `null`. */\n  own(name: string, args: unknown): Op | null;\n  /** The scene's recorder, built after this is. */\n  recorder(): Pick<Recorder, 'capturing' | 'joins' | 'join'>;\n  /** Run a step that applies ops through a history engine: all-or-nothing,\n   *  unrecorded by the scene, with subscribers called once after. */\n  driving(step: () => void): void;\n  /** Where `applyBatch` looks for an open journal until an accessor is set. */\n  getActiveJournal: (() => Journal | null) | null;\n}\n\nexport interface OuterOps {\n  /** The op a restored history names: the scene's own, or an outer op bound\n   *  to the adapter `setHistoryAdapter` supplies. `null` when nothing knows\n   *  the name, and the engine places its no-op placeholder. */\n  rebuild(name: string, args: unknown): Op | null;\n  /** `op` as an engine applies it: its entry records the kit ops it caused,\n   *  or the op itself when it caused none. */\n  causing(op: Op): Op;\n  /** Apply `ops` against `adapter` as one entry: part of the open `batch`\n   *  when there is one, else on the active journal, else on `engine`. */\n  apply(engine: History, ops: Op[], label: string, adapter: unknown): void;\n  setHistoryAdapter(fn: (() => unknown) | null): void;\n  setActiveJournalAccessor(fn: (() => Journal | null) | null): void;\n  /** The journal edits go to now, or null for the scene's own history. */\n  activeJournal(): Journal | null;\n}\n\n/** A kit op under the key of the outer op that caused it, so two edits merge\n *  when their outer ops would have. */\nfunction keyed(kit: Op, outerKey: string | undefined): Op {\n  const key = outerKey === undefined || kit.coalesceKey === undefined ? undefined : `${outerKey}>${kit.coalesceKey}`;\n  return { name: kit.name, args: kit.args, coalesceKey: key, apply: kit.apply, invert: kit.invert };\n}\n\nexport function createOuterOps(env: OuterOpsEnv): OuterOps {\n  let historyAdapter: (() => unknown) | null = null;\n  let activeJournal = env.getActiveJournal;\n\n  function causing(op: Op, given: Op = op): Op {\n    if (op.caused) return op;\n    let caused: Op[] = [given];\n    return {\n      get name() { return op.name; },\n      get args() { return op.args; },\n      label: op.label,\n      // Read when asked: an arrange op has no key until it has applied.\n      get coalesceKey() { return op.coalesceKey; },\n      elideNoop: op.elideNoop,\n      apply(adapter) {\n        const { result, ops } = env.recorder().capturing(() => given.apply(adapter));\n        if (ops.length > 0) caused = ops.map((kit) => keyed(kit, op.coalesceKey));\n        return result;\n      },\n      caused: () => caused,\n      invert: () => given.invert(),\n    };\n  }\n\n  return {\n    rebuild(name, args) {\n      const own = env.own(name, args);\n      if (own !== null) return own;\n      const rebuilt = rebuildGlobalOp(name, args);\n      return rebuilt === null ? null : bindOpToHistoryAdapter(rebuilt, () => historyAdapter);\n    },\n    causing: (op) => causing(op),\n    apply(engine, ops, label, adapter) {\n      if (env.recorder().joins()) return env.recorder().join(ops, adapter);\n      const journal = activeJournal?.() ?? null;\n      env.driving(() => {\n        // Neither engine was built with an adapter, so an op is bound to\n        // this call's before either applies or stores it.\n        const bound = ops.map((op) => causing(op, bindOpToAdapter(op, adapter)));\n        if (journal) journal.applyBatch(bound, label);\n        else engine.applyOps(bound, label);\n      });\n    },\n    setHistoryAdapter(fn) {\n      historyAdapter = fn;\n    },\n    setActiveJournalAccessor(fn) {\n      activeJournal = fn;\n    },\n    activeJournal: () => activeJournal?.() ?? null,\n  };\n}\n"],"mappings":";;;;;;AA8CA,SAAS,MAAM,KAAS,UAAkC;CACxD,MAAM,MAAM,aAAa,UAAa,IAAI,gBAAgB,SAAY,SAAY,GAAG,SAAS,GAAG,IAAI;CACrG,OAAO;EAAE,MAAM,IAAI;EAAM,MAAM,IAAI;EAAM,aAAa;EAAK,OAAO,IAAI;EAAO,QAAQ,IAAI;CAAO;AAClG;AAEA,SAAgB,eAAe,KAA4B;CACzD,IAAI,iBAAyC;CAC7C,IAAI,gBAAgB,IAAI;CAExB,SAAS,QAAQ,IAAQ,QAAY,IAAQ;EAC3C,IAAI,GAAG,QAAQ,OAAO;EACtB,IAAI,SAAe,CAAC,KAAK;EACzB,OAAO;GACL,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,IAAI,OAAO;IAAE,OAAO,GAAG;GAAM;GAC7B,OAAO,GAAG;GAEV,IAAI,cAAc;IAAE,OAAO,GAAG;GAAa;GAC3C,WAAW,GAAG;GACd,MAAM,SAAS;IACb,MAAM,EAAE,QAAQ,QAAQ,IAAI,SAAS,CAAC,CAAC,gBAAgB,MAAM,MAAM,OAAO,CAAC;IAC3E,IAAI,IAAI,SAAS,GAAG,SAAS,IAAI,KAAK,QAAQ,MAAM,KAAK,GAAG,WAAW,CAAC;IACxE,OAAO;GACT;GACA,cAAc;GACd,cAAc,MAAM,OAAO;EAC7B;CACF;CAEA,OAAO;EACL,QAAQ,MAAM,MAAM;GAClB,MAAM,MAAM,IAAI,IAAI,MAAM,IAAI;GAC9B,IAAI,QAAQ,MAAM,OAAO;GACzB,MAAM,UAAUA,UAAgB,MAAM,IAAI;GAC1C,OAAO,YAAY,OAAO,OAAO,uBAAuB,eAAe,cAAc;EACvF;EACA,UAAU,OAAO,QAAQ,EAAE;EAC3B,MAAM,QAAQ,KAAK,OAAO,SAAS;GACjC,IAAI,IAAI,SAAS,CAAC,CAAC,MAAM,GAAG,OAAO,IAAI,SAAS,CAAC,CAAC,KAAK,KAAK,OAAO;GACnE,MAAM,UAAU,gBAAgB,KAAK;GACrC,IAAI,cAAc;IAGhB,MAAM,QAAQ,IAAI,KAAK,OAAO,QAAQ,IAAI,gBAAgB,IAAI,OAAO,CAAC,CAAC;IACvE,IAAI,SAAS,QAAQ,WAAW,OAAO,KAAK;SACvC,OAAO,SAAS,OAAO,KAAK;GACnC,CAAC;EACH;EACA,kBAAkB,IAAI;GACpB,iBAAiB;EACnB;EACA,yBAAyB,IAAI;GAC3B,gBAAgB;EAClB;EACA,qBAAqB,gBAAgB,KAAK;CAC5C;AACF"}

package/dist/core/scene/pathEffects/blend.js

@@ -0,0 +1,80 @@
+import { boundsOfPath, measurePath, multiply, prepareBlend, rotate, rotatePathAround, transformPath, translate } from "@weasel-js/geom";
+import { lerpFill, lerpStroke } from "@weasel-js/paint";
+
+//#region src/core/scene/pathEffects/blend.ts
+/**
+* A blend's steps: where each sits between its two sources — evenly by
+* count, or a fixed distance apart — and, with a spine, laid along it.
+*/
+var EPS = 1e-9;
+/** The fractions of the way from the first source to the second that the
+*  steps sit at, over a run `length` long. */
+function blendStations(effect, length) {
+	const out = [];
+	const d = effect.distance;
+	if (effect.spaceBy === "distance" && d !== void 0 && d > 0) {
+		if (!(length > 0)) return out;
+		for (let s = d; s < length - EPS * Math.max(length, 1); s += d) out.push(s / length);
+		return out;
+	}
+	const steps = Math.max(Math.floor(effect.steps), 0);
+	for (let i = 1; i <= steps; i++) out.push(i / (steps + 1));
+	return out;
+}
+/** The middle a source's steps are interpolated about: its turn's center
+*  where it is a turned box, else its outline's bounds' middle. */
+function middleOf(source) {
+	if (source.framed) return {
+		x: source.framed.cx,
+		y: source.framed.cy
+	};
+	const b = boundsOfPath(source.world);
+	return {
+		x: b.x + b.width / 2,
+		y: b.y + b.height / 2
+	};
+}
+/** The parts of `effect` between `a` and `b`, along `spine` when given.
+*  `null` when the spine has no length to measure. */
+function blendParts(effect, a, b, spine) {
+	const from = middleOf(a);
+	const to = middleOf(b);
+	const along = spine === void 0 ? null : measurePath(spine);
+	if (spine !== void 0 && along === null) return null;
+	const stations = blendStations(effect, along ? along.length : Math.hypot(to.x - from.x, to.y - from.y));
+	if (stations.length === 0) return [];
+	const turned = (effect.rotate ?? true) && a.framed !== void 0 && b.framed !== void 0 ? {
+		a: a.framed,
+		b: b.framed
+	} : null;
+	const blend = turned ? prepareBlend(turned.a.path, turned.b.path, effect) : prepareBlend(a.world, b.world, effect);
+	const turn = turned ? Math.atan2(Math.sin(turned.b.rotation - turned.a.rotation), Math.cos(turned.b.rotation - turned.a.rotation)) : 0;
+	const chord = Math.atan2(to.y - from.y, to.x - from.x);
+	return stations.map((t) => {
+		let path = blend.at(t);
+		if (turned) {
+			const cx = turned.a.cx + (turned.b.cx - turned.a.cx) * t;
+			const cy = turned.a.cy + (turned.b.cy - turned.a.cy) * t;
+			const rotation = turned.a.rotation + turn * t;
+			if (rotation !== 0) path = rotatePathAround(path, cx, cy, rotation);
+		}
+		if (along) {
+			const { point, tangent } = along.at(t * along.length);
+			const angle = effect.orient ? Math.atan2(tangent.y, tangent.x) - chord : 0;
+			const middle = {
+				x: from.x + (to.x - from.x) * t,
+				y: from.y + (to.y - from.y) * t
+			};
+			path = transformPath(path, multiply(translate(point.x, point.y), multiply(rotate(angle), translate(-middle.x, -middle.y))));
+		}
+		return {
+			path,
+			fill: lerpFill(a.fill, b.fill, t) ?? null,
+			stroke: lerpStroke(a.stroke, b.stroke, t) ?? null
+		};
+	});
+}
+
+//#endregion
+export { blendParts, blendStations };
+//# sourceMappingURL=blend.js.map

package/dist/core/scene/pathEffects/blend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blend.js","names":[],"sources":["../../../../src/core/scene/pathEffects/blend.ts"],"sourcesContent":["/**\n * A blend's steps: where each sits between its two sources — evenly by\n * count, or a fixed distance apart — and, with a spine, laid along it.\n */\nimport {\n  boundsOfPath, measurePath, multiply, prepareBlend, rotate, rotatePathAround, transformPath, translate,\n  type BlendPathsOptions, type Path, type PathMeasure,\n} from '@weasel-js/geom';\nimport { lerpFill, lerpStroke } from '@weasel-js/paint';\nimport type { DerivedPart } from '../derivedParts';\nimport type { EffectSource } from './source';\n\n/** Steps between two shapes. Its sources are `[from, to]`, or\n *  `[from, to, spine]` to lay the steps along a third path. */\nexport interface BlendEffect extends BlendPathsOptions {\n  kind: 'blend';\n  /** How many shapes stand between the two sources, spacing by count. */\n  steps: number;\n  /**\n   * How the steps are spaced. `'count'` puts `steps` of them evenly between\n   * the sources; `'distance'` puts one every `distance` along the run from\n   * the first source, as many as fit short of the second, so the last gap is\n   * whatever is left. Default `'count'`.\n   */\n  spaceBy?: 'count' | 'distance';\n  /** Distance from one shape's middle to the next, spacing by distance —\n   *  along the spine where there is one. Spacing by count when unset. */\n  distance?: number;\n  /**\n   * Interpolate each source's rotation as a turn about its middle, rather\n   * than moving every point in a straight line — so a shape turned 90° at\n   * one end turns through 45° halfway instead of shrinking there. Default\n   * `true`; it applies where both sources are turned boxes.\n   */\n  rotate?: boolean;\n  /** With a spine, turn each step by how far the spine's heading where it\n   *  sits differs from the straight run between the sources. Default\n   *  `false`, which only moves them. */\n  orient?: boolean;\n}\n\nconst EPS = 1e-9;\n\n/** The fractions of the way from the first source to the second that the\n *  steps sit at, over a run `length` long. */\nexport function blendStations(effect: BlendEffect, length: number): number[] {\n  const out: number[] = [];\n  const d = effect.distance;\n  if (effect.spaceBy === 'distance' && d !== undefined && d > 0) {\n    if (!(length > 0)) return out;\n    for (let s = d; s < length - EPS * Math.max(length, 1); s += d) out.push(s / length);\n    return out;\n  }\n  const steps = Math.max(Math.floor(effect.steps), 0);\n  for (let i = 1; i <= steps; i++) out.push(i / (steps + 1));\n  return out;\n}\n\n/** The middle a source's steps are interpolated about: its turn's center\n *  where it is a turned box, else its outline's bounds' middle. */\nfunction middleOf(source: EffectSource): { x: number; y: number } {\n  if (source.framed) return { x: source.framed.cx, y: source.framed.cy };\n  const b = boundsOfPath(source.world);\n  return { x: b.x + b.width / 2, y: b.y + b.height / 2 };\n}\n\n/** The parts of `effect` between `a` and `b`, along `spine` when given.\n *  `null` when the spine has no length to measure. */\nexport function blendParts(effect: BlendEffect, a: EffectSource, b: EffectSource, spine?: Path): DerivedPart[] | null {\n  const from = middleOf(a);\n  const to = middleOf(b);\n  const along: PathMeasure | null = spine === undefined ? null : measurePath(spine);\n  if (spine !== undefined && along === null) return null;\n  const stations = blendStations(effect, along ? along.length : Math.hypot(to.x - from.x, to.y - from.y));\n  if (stations.length === 0) return [];\n\n  const turned = (effect.rotate ?? true) && a.framed !== undefined && b.framed !== undefined\n    ? { a: a.framed, b: b.framed }\n    : null;\n  const blend = turned\n    ? prepareBlend(turned.a.path, turned.b.path, effect)\n    : prepareBlend(a.world, b.world, effect);\n  // The shorter way round, so a turn of 350° reads as -10°.\n  const turn = turned\n    ? Math.atan2(Math.sin(turned.b.rotation - turned.a.rotation), Math.cos(turned.b.rotation - turned.a.rotation))\n    : 0;\n  const chord = Math.atan2(to.y - from.y, to.x - from.x);\n  return stations.map((t) => {\n    let path: Path = blend.at(t);\n    if (turned) {\n      const cx = turned.a.cx + (turned.b.cx - turned.a.cx) * t;\n      const cy = turned.a.cy + (turned.b.cy - turned.a.cy) * t;\n      const rotation = turned.a.rotation + turn * t;\n      if (rotation !== 0) path = rotatePathAround(path, cx, cy, rotation);\n    }\n    if (along) {\n      const { point, tangent } = along.at(t * along.length);\n      const angle = effect.orient ? Math.atan2(tangent.y, tangent.x) - chord : 0;\n      const middle = { x: from.x + (to.x - from.x) * t, y: from.y + (to.y - from.y) * t };\n      path = transformPath(path, multiply(translate(point.x, point.y), multiply(rotate(angle), translate(-middle.x, -middle.y))));\n    }\n    return { path, fill: lerpFill(a.fill, b.fill, t) ?? null, stroke: lerpStroke(a.stroke, b.stroke, t) ?? null };\n  });\n}\n"],"mappings":";;;;;;;;AAyCA,IAAM,MAAM;;;AAIZ,SAAgB,cAAc,QAAqB,QAA0B;CAC3E,MAAM,MAAgB,CAAC;CACvB,MAAM,IAAI,OAAO;CACjB,IAAI,OAAO,YAAY,cAAc,MAAM,UAAa,IAAI,GAAG;EAC7D,IAAI,EAAE,SAAS,IAAI,OAAO;EAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,MAAM,KAAK,IAAI,QAAQ,CAAC,GAAG,KAAK,GAAG,IAAI,KAAK,IAAI,MAAM;EACnF,OAAO;CACT;CACA,MAAM,QAAQ,KAAK,IAAI,KAAK,MAAM,OAAO,KAAK,GAAG,CAAC;CAClD,KAAK,IAAI,IAAI,GAAG,KAAK,OAAO,KAAK,IAAI,KAAK,KAAK,QAAQ,EAAE;CACzD,OAAO;AACT;;;AAIA,SAAS,SAAS,QAAgD;CAChE,IAAI,OAAO,QAAQ,OAAO;EAAE,GAAG,OAAO,OAAO;EAAI,GAAG,OAAO,OAAO;CAAG;CACrE,MAAM,IAAI,aAAa,OAAO,KAAK;CACnC,OAAO;EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ;EAAG,GAAG,EAAE,IAAI,EAAE,SAAS;CAAE;AACvD;;;AAIA,SAAgB,WAAW,QAAqB,GAAiB,GAAiB,OAAoC;CACpH,MAAM,OAAO,SAAS,CAAC;CACvB,MAAM,KAAK,SAAS,CAAC;CACrB,MAAM,QAA4B,UAAU,SAAY,OAAO,YAAY,KAAK;CAChF,IAAI,UAAU,UAAa,UAAU,MAAM,OAAO;CAClD,MAAM,WAAW,cAAc,QAAQ,QAAQ,MAAM,SAAS,KAAK,MAAM,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,CAAC,CAAC;CACtG,IAAI,SAAS,WAAW,GAAG,OAAO,CAAC;CAEnC,MAAM,UAAU,OAAO,UAAU,SAAS,EAAE,WAAW,UAAa,EAAE,WAAW,SAC7E;EAAE,GAAG,EAAE;EAAQ,GAAG,EAAE;CAAO,IAC3B;CACJ,MAAM,QAAQ,SACV,aAAa,OAAO,EAAE,MAAM,OAAO,EAAE,MAAM,MAAM,IACjD,aAAa,EAAE,OAAO,EAAE,OAAO,MAAM;CAEzC,MAAM,OAAO,SACT,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,WAAW,OAAO,EAAE,QAAQ,GAAG,KAAK,IAAI,OAAO,EAAE,WAAW,OAAO,EAAE,QAAQ,CAAC,IAC3G;CACJ,MAAM,QAAQ,KAAK,MAAM,GAAG,IAAI,KAAK,GAAG,GAAG,IAAI,KAAK,CAAC;CACrD,OAAO,SAAS,KAAK,MAAM;EACzB,IAAI,OAAa,MAAM,GAAG,CAAC;EAC3B,IAAI,QAAQ;GACV,MAAM,KAAK,OAAO,EAAE,MAAM,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM;GACvD,MAAM,KAAK,OAAO,EAAE,MAAM,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM;GACvD,MAAM,WAAW,OAAO,EAAE,WAAW,OAAO;GAC5C,IAAI,aAAa,GAAG,OAAO,iBAAiB,MAAM,IAAI,IAAI,QAAQ;EACpE;EACA,IAAI,OAAO;GACT,MAAM,EAAE,OAAO,YAAY,MAAM,GAAG,IAAI,MAAM,MAAM;GACpD,MAAM,QAAQ,OAAO,SAAS,KAAK,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,QAAQ;GACzE,MAAM,SAAS;IAAE,GAAG,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK;IAAG,GAAG,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK;GAAE;GAClF,OAAO,cAAc,MAAM,SAAS,UAAU,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,OAAO,KAAK,GAAG,UAAU,CAAC,OAAO,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;EAC5H;EACA,OAAO;GAAE;GAAM,MAAM,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK;GAAM,QAAQ,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK;EAAK;CAC9G,CAAC;AACH"}

package/dist/core/scene/pathEffects/derive.js

@@ -0,0 +1,112 @@
+import { samePoseValue, snapshotPose } from "../poseSnapshot.js";
+import { derivedPartsOf, pathFromParts } from "../derivedParts.js";
+import { effectParts } from "./effects.js";
+import { boundsOfPath } from "@weasel-js/geom";
+
+//#region src/core/scene/pathEffects/derive.ts
+/**
+* A path effect as a scene node: a leaf whose `dependsOn` names its sources,
+* whose `data.pathEffect` says what to make of them, and whose path and pose
+* are both derived — the path to paint and pick, the pose as that path's
+* bounds, so selection chrome and marquee see where it is.
+*
+* Reading a source's outline and paint is its painter's business, which sits
+* above the scene, so the derivations are made from a reader:
+* `createPathEffectDerivations(read)`. The canvas layer makes the kit's, and
+* a scene that holds path effects registers them under {@link PATH_EFFECT}.
+*/
+/** The registry key both derivations go by, for `derivePath` and `derivePose`. */
+var PATH_EFFECT = "kit:pathEffect";
+/** A node's path effect, or `null` when its data holds none. */
+function pathEffectOf(node) {
+	const effect = (node?.data)?.pathEffect;
+	return effect && typeof effect === "object" && typeof effect.kind === "string" ? effect : null;
+}
+/** The derivations of a path effect whose sources `read` reads. */
+function createPathEffectDerivations(read) {
+	/** One result per effect node, shared by its two derivations: the pose is
+	*  the path's bounds, and working the effect out twice a frame would double
+	*  its cost. Checked against everything it read, by value for poses — a
+	*  drag's override mutates its pose in place. */
+	const results = /* @__PURE__ */ new WeakMap();
+	const derive = (node, deps) => {
+		const held = results.get(node);
+		if (held !== void 0 && current(held, node, deps)) return held;
+		const effect = pathEffectOf(node);
+		const parts = effect === null ? null : effectParts(effect, deps.map((d) => d === void 0 ? null : read(d)));
+		const result = {
+			data: node.data,
+			nodes: deps.map((d) => d?.node),
+			depData: deps.map((d) => d?.node.data),
+			poses: deps.map((d) => d === void 0 ? void 0 : snapshotPose(d.pose)),
+			paths: deps.map((d) => d?.path ?? null),
+			path: parts === null ? null : pathFromParts(parts)
+		};
+		results.set(node, result);
+		return result;
+	};
+	return {
+		derivePath: (node, deps) => derive(node, deps).path,
+		derivePose: (node, deps) => {
+			const path = derive(node, deps).path;
+			if (path === null) return null;
+			const { x, y, width, height } = boundsOfPath(path);
+			return {
+				x,
+				y,
+				width,
+				height
+			};
+		}
+	};
+}
+function current(held, node, deps) {
+	if (held.data !== node.data || held.nodes.length !== deps.length) return false;
+	for (let i = 0; i < deps.length; i++) {
+		const d = deps[i];
+		if (held.nodes[i] !== d?.node) return false;
+		if (d === void 0) continue;
+		if (held.depData[i] !== d.node.data || !samePoseValue(held.poses[i], d.pose)) return false;
+		if (held.paths[i] !== d.path) return false;
+	}
+	return true;
+}
+/** The parts a path-effect node paints, as its sources stand, or `null` when
+*  it has no derivation or nothing to paint. */
+function pathEffectParts(node, deps) {
+	if (typeof node.derivePath !== "function") return null;
+	return derivedPartsOf(node.derivePath(node, deps)) ?? null;
+}
+/** What to hand `Scene.add` (or an insert op) for a path-effect node over
+*  `sources`, in the order its kind reads them, deriving through
+*  `derivations` — the ones the scene registers under {@link PATH_EFFECT}. */
+function pathEffectNode(effect, sources, layer, derivations) {
+	return {
+		kind: "leaf",
+		layer,
+		pose: {
+			x: 0,
+			y: 0,
+			width: 0,
+			height: 0
+		},
+		data: { pathEffect: effect },
+		dependsOn: [...sources],
+		derivePath: derivations.derivePath,
+		derivePose: derivations.derivePose
+	};
+}
+/** The path-effect derivations `registry` holds under {@link PATH_EFFECT},
+*  or `null` when it holds none. */
+function registeredPathEffects(registry) {
+	const derivePath = registry.derivePath?.[PATH_EFFECT];
+	const derivePose = registry.derivePose?.[PATH_EFFECT];
+	return typeof derivePath === "function" && typeof derivePose === "function" ? {
+		derivePath,
+		derivePose
+	} : null;
+}
+
+//#endregion
+export { PATH_EFFECT, createPathEffectDerivations, pathEffectNode, pathEffectOf, pathEffectParts, registeredPathEffects };
+//# sourceMappingURL=derive.js.map

package/dist/core/scene/pathEffects/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","names":[],"sources":["../../../../src/core/scene/pathEffects/derive.ts"],"sourcesContent":["/**\n * A path effect as a scene node: a leaf whose `dependsOn` names its sources,\n * whose `data.pathEffect` says what to make of them, and whose path and pose\n * are both derived — the path to paint and pick, the pose as that path's\n * bounds, so selection chrome and marquee see where it is.\n *\n * Reading a source's outline and paint is its painter's business, which sits\n * above the scene, so the derivations are made from a reader:\n * `createPathEffectDerivations(read)`. The canvas layer makes the kit's, and\n * a scene that holds path effects registers them under {@link PATH_EFFECT}.\n */\nimport { boundsOfPath, type Path } from '@weasel-js/geom';\nimport { derivedPartsOf, pathFromParts, type DerivedPart } from '../derivedParts';\nimport { samePoseValue, snapshotPose } from '../poseSnapshot';\nimport type { DerivedDep, NodeId } from '../types';\nimport { effectParts, type PathEffect } from './effects';\nimport type { EffectSourceReader } from './source';\n\n/** The registry key both derivations go by, for `derivePath` and `derivePose`. */\nexport const PATH_EFFECT = 'kit:pathEffect';\n\n/** A node's path effect, or `null` when its data holds none. */\nexport function pathEffectOf(node: { data?: unknown } | undefined): PathEffect | null {\n  const effect = (node?.data as { pathEffect?: PathEffect } | null | undefined)?.pathEffect;\n  return effect && typeof effect === 'object' && typeof effect.kind === 'string' ? effect : null;\n}\n\n/** A path-effect node's two derivations. */\nexport interface PathEffectDerivations {\n  /** What it paints and picks by. */\n  derivePath(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Path | null;\n  /** The bounds of what it paints, or `null` — its authored pose — while it\n   *  paints nothing. */\n  derivePose(node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): { x: number; y: number; width: number; height: number } | null;\n}\n\ninterface Derived {\n  data: unknown;\n  nodes: unknown[];\n  depData: unknown[];\n  poses: unknown[];\n  paths: (Path | null)[];\n  path: Path | null;\n}\n\n/** The derivations of a path effect whose sources `read` reads. */\nexport function createPathEffectDerivations(read: EffectSourceReader): PathEffectDerivations {\n  /** One result per effect node, shared by its two derivations: the pose is\n   *  the path's bounds, and working the effect out twice a frame would double\n   *  its cost. Checked against everything it read, by value for poses — a\n   *  drag's override mutates its pose in place. */\n  const results = new WeakMap<object, Derived>();\n  const derive = (node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): Derived => {\n    const held = results.get(node);\n    if (held !== undefined && current(held, node, deps)) return held;\n    const effect = pathEffectOf(node);\n    const parts = effect === null\n      ? null\n      : effectParts(effect, deps.map((d) => (d === undefined ? null : read(d))));\n    const result: Derived = {\n      data: node.data,\n      nodes: deps.map((d) => d?.node),\n      depData: deps.map((d) => d?.node.data),\n      poses: deps.map((d) => (d === undefined ? undefined : snapshotPose(d.pose))),\n      paths: deps.map((d) => d?.path ?? null),\n      path: parts === null ? null : pathFromParts(parts),\n    };\n    results.set(node, result);\n    return result;\n  };\n  return {\n    derivePath: (node, deps) => derive(node, deps).path,\n    derivePose: (node, deps) => {\n      const path = derive(node, deps).path;\n      if (path === null) return null;\n      const { x, y, width, height } = boundsOfPath(path);\n      return { x, y, width, height };\n    },\n  };\n}\n\nfunction current(held: Derived, node: { data?: unknown }, deps: readonly (DerivedDep<unknown> | undefined)[]): boolean {\n  if (held.data !== node.data || held.nodes.length !== deps.length) return false;\n  for (let i = 0; i < deps.length; i++) {\n    const d = deps[i];\n    if (held.nodes[i] !== d?.node) return false;\n    if (d === undefined) continue;\n    if (held.depData[i] !== d.node.data || !samePoseValue(held.poses[i], d.pose)) return false;\n    if (held.paths[i] !== d.path) return false;\n  }\n  return true;\n}\n\n/** The parts a path-effect node paints, as its sources stand, or `null` when\n *  it has no derivation or nothing to paint. */\nexport function pathEffectParts(\n  node: { data?: unknown; derivePath?: unknown },\n  deps: readonly (DerivedDep<unknown> | undefined)[],\n): readonly DerivedPart[] | null {\n  if (typeof node.derivePath !== 'function') return null;\n  return derivedPartsOf((node.derivePath as PathEffectDerivations['derivePath'])(node, deps)) ?? null;\n}\n\n/** What to hand `Scene.add` (or an insert op) for a path-effect node over\n *  `sources`, in the order its kind reads them, deriving through\n *  `derivations` — the ones the scene registers under {@link PATH_EFFECT}. */\nexport function pathEffectNode<TLayer extends string>(\n  effect: PathEffect,\n  sources: readonly NodeId[],\n  layer: TLayer,\n  derivations: PathEffectDerivations,\n): {\n  kind: 'leaf';\n  layer: TLayer;\n  pose: { x: number; y: number; width: number; height: number };\n  data: { pathEffect: PathEffect };\n  dependsOn: readonly NodeId[];\n  derivePath: PathEffectDerivations['derivePath'];\n  derivePose: PathEffectDerivations['derivePose'];\n} {\n  return {\n    kind: 'leaf',\n    layer,\n    pose: { x: 0, y: 0, width: 0, height: 0 },\n    data: { pathEffect: effect },\n    dependsOn: [...sources],\n    derivePath: derivations.derivePath,\n    derivePose: derivations.derivePose,\n  };\n}\n\n/** The path-effect derivations `registry` holds under {@link PATH_EFFECT},\n *  or `null` when it holds none. */\nexport function registeredPathEffects(registry: {\n  derivePath?: Readonly<Record<string, unknown>>;\n  derivePose?: Readonly<Record<string, unknown>>;\n}): PathEffectDerivations | null {\n  const derivePath = registry.derivePath?.[PATH_EFFECT];\n  const derivePose = registry.derivePose?.[PATH_EFFECT];\n  return typeof derivePath === 'function' && typeof derivePose === 'function'\n    ? { derivePath, derivePose } as PathEffectDerivations\n    : null;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,cAAc;;AAG3B,SAAgB,aAAa,MAAyD;CACpF,MAAM,UAAU,MAAM,KAAA,EAAyD;CAC/E,OAAO,UAAU,OAAO,WAAW,YAAY,OAAO,OAAO,SAAS,WAAW,SAAS;AAC5F;;AAqBA,SAAgB,4BAA4B,MAAiD;;;;;CAK3F,MAAM,0BAAU,IAAI,QAAyB;CAC7C,MAAM,UAAU,MAA0B,SAAgE;EACxG,MAAM,OAAO,QAAQ,IAAI,IAAI;EAC7B,IAAI,SAAS,UAAa,QAAQ,MAAM,MAAM,IAAI,GAAG,OAAO;EAC5D,MAAM,SAAS,aAAa,IAAI;EAChC,MAAM,QAAQ,WAAW,OACrB,OACA,YAAY,QAAQ,KAAK,KAAK,MAAO,MAAM,SAAY,OAAO,KAAK,CAAC,CAAE,CAAC;EAC3E,MAAM,SAAkB;GACtB,MAAM,KAAK;GACX,OAAO,KAAK,KAAK,MAAM,GAAG,IAAI;GAC9B,SAAS,KAAK,KAAK,MAAM,GAAG,KAAK,IAAI;GACrC,OAAO,KAAK,KAAK,MAAO,MAAM,SAAY,SAAY,aAAa,EAAE,IAAI,CAAE;GAC3E,OAAO,KAAK,KAAK,MAAM,GAAG,QAAQ,IAAI;GACtC,MAAM,UAAU,OAAO,OAAO,cAAc,KAAK;EACnD;EACA,QAAQ,IAAI,MAAM,MAAM;EACxB,OAAO;CACT;CACA,OAAO;EACL,aAAa,MAAM,SAAS,OAAO,MAAM,IAAI,CAAC,CAAC;EAC/C,aAAa,MAAM,SAAS;GAC1B,MAAM,OAAO,OAAO,MAAM,IAAI,CAAC,CAAC;GAChC,IAAI,SAAS,MAAM,OAAO;GAC1B,MAAM,EAAE,GAAG,GAAG,OAAO,WAAW,aAAa,IAAI;GACjD,OAAO;IAAE;IAAG;IAAG;IAAO;GAAO;EAC/B;CACF;AACF;AAEA,SAAS,QAAQ,MAAe,MAA0B,MAA6D;CACrH,IAAI,KAAK,SAAS,KAAK,QAAQ,KAAK,MAAM,WAAW,KAAK,QAAQ,OAAO;CACzE,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,IAAI,KAAK;EACf,IAAI,KAAK,MAAM,OAAO,GAAG,MAAM,OAAO;EACtC,IAAI,MAAM,QAAW;EACrB,IAAI,KAAK,QAAQ,OAAO,EAAE,KAAK,QAAQ,CAAC,cAAc,KAAK,MAAM,IAAI,EAAE,IAAI,GAAG,OAAO;EACrF,IAAI,KAAK,MAAM,OAAO,EAAE,MAAM,OAAO;CACvC;CACA,OAAO;AACT;;;AAIA,SAAgB,gBACd,MACA,MAC+B;CAC/B,IAAI,OAAO,KAAK,eAAe,YAAY,OAAO;CAClD,OAAO,eAAgB,KAAK,WAAmD,MAAM,IAAI,CAAC,KAAK;AACjG;;;;AAKA,SAAgB,eACd,QACA,SACA,OACA,aASA;CACA,OAAO;EACL,MAAM;EACN;EACA,MAAM;GAAE,GAAG;GAAG,GAAG;GAAG,OAAO;GAAG,QAAQ;EAAE;EACxC,MAAM,EAAE,YAAY,OAAO;EAC3B,WAAW,CAAC,GAAG,OAAO;EACtB,YAAY,YAAY;EACxB,YAAY,YAAY;CAC1B;AACF;;;AAIA,SAAgB,sBAAsB,UAGL;CAC/B,MAAM,aAAa,SAAS,aAAa;CACzC,MAAM,aAAa,SAAS,aAAa;CACzC,OAAO,OAAO,eAAe,cAAc,OAAO,eAAe,aAC7D;EAAE;EAAY;CAAW,IACzB;AACN"}

package/dist/core/scene/pathEffects/effects.js

@@ -0,0 +1,40 @@
+import { blendParts } from "./blend.js";
+import { bendAlongPath, repeatAlongPath } from "@weasel-js/geom";
+
+//#region src/core/scene/pathEffects/effects.ts
+/**
+* The path effects, each as the parts it paints from its sources: a blend's
+* steps between two shapes, a shape bent along a spine, copies of a shape
+* along a path.
+*/
+/** The parts `effect` paints from `sources`, in its sources' order, or
+*  `null` when a source it needs is missing — a blend's spine among them,
+*  where it names one. */
+function effectParts(effect, sources) {
+	const [a, b] = sources;
+	if (!a || !b) return null;
+	switch (effect.kind) {
+		case "blend": {
+			if (sources.length < 3) return blendParts(effect, a, b);
+			const spine = sources[2];
+			return spine ? blendParts(effect, a, b, spine.world) : null;
+		}
+		case "bendAlong": {
+			const path = bendAlongPath(a.world, b.world, effect);
+			return path === null ? null : [{
+				path,
+				fill: a.fill,
+				stroke: a.stroke
+			}];
+		}
+		case "repeatAlong": return repeatAlongPath(a.world, b.world, effect).map((path) => ({
+			path,
+			fill: a.fill,
+			stroke: a.stroke
+		}));
+	}
+}
+
+//#endregion
+export { effectParts };
+//# sourceMappingURL=effects.js.map