From a0a3eec87730e285b57c48abd3e752994c2bc1d1 Mon Sep 17 00:00:00 2001 From: AlexZ005 Date: Sat, 21 Nov 2026 19:16:18 +0200 Subject: [PATCH 1/8] =?UTF-8?q?feat(tags):=20object=20tags=20=E2=80=94=20I?= =?UTF-8?q?nspector=20chips,=20undo,=20replication;=20the=20selector=20res?= =?UTF-8?q?olver=20core=20(102b-flows=20row=201a)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit userData.tags (the field behaviours already read) gets a write path: an Inspector Tags section (chips, add on Enter, union over a multi-select as one undo step), its own 'tags' history kind, and objectParameters parameter 'tags' (validated, cleaned again on apply). selectorCore.js is the pure half of the many-target Object Selector: tag / group / name-pattern resolution, outermost match wins, scene order. Co-Authored-By: Claude Opus 5.5 --- src/components/menu/Inspector.svelte | 6 + .../menu/inspector/TagsSection.svelte | 133 +++++++++++++ src/lib/commandsHandler.svelte.js | 10 + src/lib/objectTags.js | 105 ++++++++++ src/lib/selectorCore.js | 186 ++++++++++++++++++ src/lib/wireValidate.js | 3 + tests/unit/selectorCore.test.js | 119 +++++++++++ 7 files changed, 562 insertions(+) create mode 100644 src/components/menu/inspector/TagsSection.svelte create mode 100644 src/lib/objectTags.js create mode 100644 src/lib/selectorCore.js create mode 100644 tests/unit/selectorCore.test.js diff --git a/src/components/menu/Inspector.svelte b/src/components/menu/Inspector.svelte index 1c08f58bd..c6a9e97fa 100644 --- a/src/components/menu/Inspector.svelte +++ b/src/components/menu/Inspector.svelte @@ -36,6 +36,7 @@ * @param {any} o @param {any} _tick */ const scatterHostOk = (o, _tick) => isMeshHost(o); import MeasureSection from './inspector/MeasureSection.svelte'; // 48 B2 + import TagsSection from './inspector/TagsSection.svelte'; // 102b-flows import ModelSourceSection from './inspector/ModelSourceSection.svelte'; // 59 T1/T2/T7a import { isReplaceableModel } from '$lib/modelTarget'; import HdriSection from './scene/HdriSection.svelte'; // 37-hdri @@ -3997,6 +3998,11 @@ {/if} + {#if insTargets.length} + + + {/if} + {#if isGroup}

diff --git a/src/components/menu/inspector/TagsSection.svelte b/src/components/menu/inspector/TagsSection.svelte new file mode 100644 index 000000000..91f1fa3d5 --- /dev/null +++ b/src/components/menu/inspector/TagsSection.svelte @@ -0,0 +1,133 @@ + + +

+
+ {#if chips.length} +
    + {#each chips as c (c.tag.toLowerCase())} +
  • + {c.tag} + {#if many && c.count < objects.length}{c.count}/{objects.length}{/if} + +
  • + {/each} +
+ {:else} +

No tags yet.

+ {/if} + + + {#each suggestions as s (s.tag.toLowerCase())}{/each} + +
+
+ + diff --git a/src/lib/commandsHandler.svelte.js b/src/lib/commandsHandler.svelte.js index 410ddff15..6833f1aa8 100644 --- a/src/lib/commandsHandler.svelte.js +++ b/src/lib/commandsHandler.svelte.js @@ -48,6 +48,7 @@ import { registerMetricSource, ingestVerdict, profileFor } from './sceneBudget'; import { globalRenderer } from '../stores/sceneStore.js'; // 33 (L4): the scene going away is when its modules may be left behind (a leaf) import { noteSceneLeaving } from './sceneScope'; +import { normalizeTags } from './selectorCore.js'; // 102b-flows: object tags //Access scene Store let scene = $state(); @@ -733,6 +734,15 @@ export async function objectParameters(data, from = 'peer') { else delete mesh.userData.fluidInteraction; pokeScene(); } + } else if (data.parameter == 'tags') { + // 102b-flows: an object's tags (what a tag-picking Object Selector finds). null = none. + let mesh = sceneObjects.getObjectByProperty('uuid', data.uuid); + if (mesh) { + const clean = normalizeTags(data.tags); + if (clean) mesh.userData.tags = clean; + else delete mesh.userData.tags; + pokeScene(); + } } else if (data.parameter == 'pick') { // 30 P2: click-through in the viewport. null = cleared (the default). let mesh = sceneObjects.getObjectByProperty('uuid', data.uuid); diff --git a/src/lib/objectTags.js b/src/lib/objectTags.js new file mode 100644 index 000000000..220f457b0 --- /dev/null +++ b/src/lib/objectTags.js @@ -0,0 +1,105 @@ +// 102b-flows row 1 — OBJECT TAGS: the write path. `userData.tags` (a short list of words) is what a +// tag-picking Object Selector looks for; the behaviours runtime already read the same field +// (behaviours/app.js tagsOfObject) but nothing outside code could set it. +// +// Scene data like userData.pick: one undo entry per object (its own `tags` history kind, kept out +// of objectActions' crowded 'props' handler), the existing `objectParameters` message with +// `parameter: 'tags'`, and it rides toJSON / GLTF extras into every save. ADDITIVE: no tags = no +// field, so an object that never had any serialises byte-identically; an older build keeps the +// field it does not know and ignores it. + +import { get } from 'svelte/store'; +import { objectsGroup, pokeScene } from '../stores/sceneStore'; +import { peers, showToast } from '../stores/appStore'; +import { registerHistoryKind, registerHistoryMerge, recordEntry, sameJson, beginHistoryBatch, endHistoryBatch } from './history'; +import { withWireBatch } from './wireBatch'; +import { normalizeTags, normalizeTag, tagsOf } from './selectorCore.js'; + +/** @param {string} uuid */ +function objectOf(uuid) { + return get(objectsGroup)?.getObjectByProperty('uuid', uuid) ?? null; +} + +/** apply + replicate, no history @param {any} object @param {string[] | null} tags */ +function writeTags(object, tags) { + if (tags) object.userData.tags = [...tags]; + else delete object.userData.tags; + /** @type {any} */ + const peer = get(peers); + peer?.send({ type: 'objectParameters', parameter: 'tags', uuid: object.uuid, tags: tags ? [...tags] : null }); + pokeScene(); +} + +/** + * Set an object's whole tag list (cleaned by normalizeTags; [] / null removes the field). + * @param {string} uuid @param {any} tags @returns {boolean} whether anything changed + */ +export function setObjectTags(uuid, tags) { + const object = objectOf(uuid); + if (!object) return false; + const before = normalizeTags(tagsOf(object)); + const after = normalizeTags(tags); + if (sameJson(before, after)) return false; + writeTags(object, after); + recordEntry({ kind: 'tags', uuid, before: { tags: before }, after: { tags: after } }); + return true; +} + +/** + * Add one tag to every object in `uuids` (ONE undo step and one wire batch for a set). + * @param {string[]} uuids @param {string} tag @returns {number} how many objects changed + */ +export function addTag(uuids, tag) { + const clean = normalizeTag(tag); + if (!clean) return 0; + return fan(uuids, `Tag "${clean}"`, (o) => [...tagsOf(o), clean]); +} + +/** + * Take one tag off every object in `uuids` (case-insensitive). + * @param {string[]} uuids @param {string} tag @returns {number} how many objects changed + */ +export function removeTag(uuids, tag) { + const want = normalizeTag(tag).toLowerCase(); + if (!want) return 0; + return fan(uuids, `Untag "${normalizeTag(tag)}"`, (o) => tagsOf(o).filter((t) => t.toLowerCase() !== want)); +} + +/** @param {string[]} uuids @param {string} label @param {(o: any) => string[]} next */ +function fan(uuids, label, next) { + const list = uuids.map(objectOf).filter(Boolean); + if (!list.length) return 0; + let changed = 0; + const run = () => { + for (const o of list) if (setObjectTags(o.uuid, next(o))) changed++; + }; + if (list.length === 1) run(); + else { + beginHistoryBatch(); + try { + withWireBatch(run); + } finally { + endHistoryBatch(`${label} (${list.length})`); + } + } + return changed; +} + +registerHistoryKind('tags', (entry, state) => { + const object = objectOf(entry.uuid); + if (!object) { + showToast('Cannot undo/redo: the object no longer exists'); + return false; + } + writeTags(object, normalizeTags(state?.tags)); + return true; +}); + +registerHistoryMerge('tags', { + merge(top, next) { + if (top.uuid !== next.uuid) return false; + top.after = next.after; + return true; + }, + noop: (e) => sameJson(e.before, e.after) +}); diff --git a/src/lib/selectorCore.js b/src/lib/selectorCore.js new file mode 100644 index 000000000..f5600eeb9 --- /dev/null +++ b/src/lib/selectorCore.js @@ -0,0 +1,186 @@ +// 102b-flows — ONE FLOW, MANY OBJECTS: the pure half of the many-target Object Selector and of +// object TAGS. No store, no runtime, no DOM: flowRuntime, the node card, flow lint, the agent tools +// and the unit tests all ask these functions the same question. +// +// An Object Selector has always named ONE object (`data.selected`, a uuid). It may now name a SET: +// pick: 'tag' match: a tag -> every object carrying that tag (userData.tags) +// pick: 'group' match: a group's uuid -> every object directly inside that group +// pick: 'name' match: a name pattern -> every object whose name matches (glob, see nameMatcher) +// `pick` absent (every selector saved before this) or 'object' is the old single target, byte for +// byte: nothing here runs for it. Additive in the save file: an older build reads `selected` only, +// so a many-target selector opens there as the single object it was last pointed at (or none). + +/** the ways a selector can pick; the first is the default and is never written */ +export const SELECTOR_PICKS = /** @type {const} */ (['object', 'tag', 'group', 'name']); +/** at most this many tags on one object, each at most MAX_TAG_LEN characters */ +export const MAX_TAGS = 16; +export const MAX_TAG_LEN = 32; +/** a selector's set is cut at this size (a runaway pattern on a 5,000-object scene) */ +export const MAX_SET = 1000; + +/** One tag, cleaned: trimmed, inner whitespace collapsed, cut to MAX_TAG_LEN. '' = no tag. @param {any} raw */ +export function normalizeTag(raw) { + if (typeof raw !== 'string' && typeof raw !== 'number') return ''; + return String(raw).replace(/\s+/g, ' ').trim().slice(0, MAX_TAG_LEN); +} + +/** + * An object's tag list, cleaned: each tag normalised, duplicates dropped (case-insensitive, the + * first spelling wins), at most MAX_TAGS. null when nothing is left — the caller then DELETES the + * field, so an object that never had tags serialises exactly as before. + * @param {any} list @returns {string[] | null} + */ +export function normalizeTags(list) { + if (!Array.isArray(list)) return null; + /** @type {string[]} */ + const out = []; + const seen = new Set(); + for (const raw of list) { + const tag = normalizeTag(raw); + const key = tag.toLowerCase(); + if (!tag || seen.has(key)) continue; + seen.add(key); + out.push(tag); + if (out.length >= MAX_TAGS) break; + } + return out.length ? out : null; +} + +/** the tags an object carries (never throws) @param {any} object @returns {string[]} */ +export function tagsOf(object) { + const tags = object?.userData?.tags; + return Array.isArray(tags) ? tags.filter((t) => typeof t === 'string') : []; +} + +/** does `object` carry `tag` (case-insensitive)? @param {any} object @param {string} tag */ +export function hasTag(object, tag) { + const want = normalizeTag(tag).toLowerCase(); + if (!want) return false; + return tagsOf(object).some((t) => t.toLowerCase() === want); +} + +/** the selector's pick, normalised ('object' for anything unknown or absent) @param {any} data */ +export function pickOf(data) { + const p = data?.pick; + return p === 'tag' || p === 'group' || p === 'name' ? p : 'object'; +} + +/** is this selector's data a MANY-target one (tag / group / name)? @param {any} data */ +export function isManySelector(data) { + return pickOf(data) !== 'object'; +} + +/** the selector's match text, trimmed ('' = not set yet) @param {any} data */ +export function matchOf(data) { + const m = data?.match; + return typeof m === 'string' ? m.trim().slice(0, 120) : ''; +} + +/** a key two selectors with the same question share (the runtime's per-tick memo) @param {any} data */ +export function selectorKey(data) { + return pickOf(data) + '\u0000' + matchOf(data).toLowerCase(); +} + +/** + * A name pattern as a test. Case-insensitive glob: `*` any run of characters, `?` exactly one. + * A pattern with neither is "the name CONTAINS this" (so `coin` finds Coin 1 … Coin 20). + * '' matches nothing. + * @param {string} pattern @returns {(name: string) => boolean} + */ +export function nameMatcher(pattern) { + const p = String(pattern ?? '').trim().toLowerCase(); + if (!p) return () => false; + if (!/[*?]/.test(p)) return (name) => String(name ?? '').toLowerCase().includes(p); + const source = p.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.'); + const re = new RegExp('^' + source + '$'); + return (name) => re.test(String(name ?? '').toLowerCase()); +} + +/** helpers and editor furniture are never members (the gizmo, a ping, an arch part's leaf) @param {any} o */ +function isMemberCandidate(o) { + const u = o?.userData; + return !!o && !u?.helper && !u?.archPart && !u?.transientHelper && !o.isLine2; +} + +/** + * The uuids a many-target selector resolves to under `root` (the scene's objects group), in + * scene order (depth-first, children in order) — every peer walks the same replicated tree, so + * every peer gets the same list. The OUTERMOST match wins: a model called "Star" is one member, + * not the model plus its inner "Star_mesh". A single-target selector returns its one object + * ([] for none) so callers can treat both alike. + * @param {any} data a selector's data @param {any} root @returns {string[]} + */ +export function resolveSelector(data, root) { + const pick = pickOf(data); + if (pick === 'object') { + const s = data?.selected; + return typeof s === 'string' && s && s !== '-None-' ? [s] : []; + } + const match = matchOf(data); + if (!root || !match) return []; + /** @type {string[]} */ + const out = []; + if (pick === 'group') { + const group = root.getObjectByProperty?.('uuid', match); + if (!group || group === root) return []; + for (const child of group.children ?? []) { + if (!isMemberCandidate(child)) continue; + out.push(child.uuid); + if (out.length >= MAX_SET) break; + } + return out; + } + const test = pick === 'tag' ? (/** @type {any} */ o) => hasTag(o, match) : ((m) => (/** @type {any} */ o) => m(o.name))(nameMatcher(match)); + /** @param {any} o */ + const walk = (o) => { + for (const child of o.children ?? []) { + if (out.length >= MAX_SET) return; + if (!isMemberCandidate(child)) continue; + if (test(child)) out.push(child.uuid); + else walk(child); + } + }; + walk(root); + return out; +} + +/** + * The words a card, the debugger and the agent tools use for a selector's question. + * @param {any} data @param {(uuid: string) => string | null} [nameOf] a group uuid -> its name + */ +export function describeSelector(data, nameOf) { + const pick = pickOf(data); + const match = matchOf(data); + if (pick === 'tag') return match ? `tagged "${match}"` : 'a tag (none chosen)'; + if (pick === 'name') return match ? `named like "${match}"` : 'a name pattern (none typed)'; + if (pick === 'group') return match ? `in group ${nameOf?.(match) ?? 'that is gone'}` : 'a group (none chosen)'; + return 'one object'; +} + +/** + * "12 objects: Star 1, Star 2, Star 3 and 9 more" — a resolved set in one short line. + * @param {string[]} uuids @param {(uuid: string) => string | null} nameOf @param {number} [shown] + */ +export function describeSet(uuids, nameOf, shown = 3) { + const n = uuids.length; + if (!n) return 'no objects'; + const names = uuids.slice(0, shown).map((u) => nameOf(u) || 'unnamed'); + const head = `${n} object${n === 1 ? '' : 's'}: ${names.join(', ')}`; + return n > shown ? `${head} and ${n - shown} more` : head; +} + +/** every distinct tag under `root`, sorted, with how many objects carry it @param {any} root @returns {{tag: string, count: number}[]} */ +export function sceneTags(root) { + /** @type {Map} */ + const map = new Map(); + root?.traverse?.((/** @type {any} */ o) => { + if (o === root) return; + for (const t of tagsOf(o)) { + const key = t.toLowerCase(); + const hit = map.get(key); + if (hit) hit.count++; + else map.set(key, { tag: t, count: 1 }); + } + }); + return [...map.values()].sort((a, b) => a.tag.localeCompare(b.tag)); +} diff --git a/src/lib/wireValidate.js b/src/lib/wireValidate.js index 4a5460207..d00b2fd5e 100644 --- a/src/lib/wireValidate.js +++ b/src/lib/wireValidate.js @@ -457,6 +457,9 @@ export const VALIDATORS = { // 36-water: `water` / `bubbles` are a plain object or null (the appliers spread nothing // else onto userData) objectParameters: (d) => { + // 102b-flows: an object's tags — a short list of short strings, or null (cleaned again on apply) + if (d.parameter === 'tags') + return isUuid(d.uuid) && (d.tags === null || (isArray(d.tags) && d.tags.length <= 64 && d.tags.every((/** @type {any} */ t) => typeof t === 'string' && t.length <= 200))); if (d.parameter === 'lod') return isUuid(d.uuid) && (d.lod === null || (!!d.lod && typeof d.lod === 'object' && isArray(d.lod.levels))); // 47 T1/T2: splat bytes are raw (ArrayBuffer / typed view) of exactly res² × 4, or null if (d.parameter === 'terrainSplat') { diff --git a/tests/unit/selectorCore.test.js b/tests/unit/selectorCore.test.js new file mode 100644 index 000000000..90cb37e4f --- /dev/null +++ b/tests/unit/selectorCore.test.js @@ -0,0 +1,119 @@ +import { describe, it, expect } from 'vitest'; +import * as THREE from 'three'; +import { + normalizeTag, + normalizeTags, + hasTag, + pickOf, + isManySelector, + nameMatcher, + resolveSelector, + describeSet, + sceneTags, + selectorKey, + MAX_TAGS, + MAX_TAG_LEN +} from '../../src/lib/selectorCore.js'; + +// 102b-flows row 1: the pure half of the many-target Object Selector and of object tags. + +/** @param {string} name @param {string[]} [tags] */ +function obj(name, tags) { + const o = new THREE.Mesh(); + o.name = name; + if (tags) o.userData.tags = tags; + return o; +} + +function scene() { + const root = new THREE.Group(); + const stars = new THREE.Group(); + stars.name = 'Stars'; + const s1 = obj('Star 1', ['star', 'Pickup']); + const s2 = obj('Star 2', ['star']); + const s3 = obj('star three'); + stars.add(s1, s2, s3); + const model = new THREE.Group(); + model.name = 'Star model'; + model.add(obj('Star_mesh')); + const coin = obj('Coin', ['pickup']); + const helper = obj('Star helper', ['star']); + helper.userData.helper = true; + root.add(stars, model, coin, helper); + return { root, stars, s1, s2, s3, model, coin }; +} + +describe('tags', () => { + it('cleans one tag', () => { + expect(normalizeTag(' red door ')).toBe('red door'); + expect(normalizeTag('')).toBe(''); + expect(normalizeTag(null)).toBe(''); + expect(normalizeTag('x'.repeat(50)).length).toBe(MAX_TAG_LEN); + }); + it('dedupes case-insensitively, first spelling wins, null when empty', () => { + expect(normalizeTags(['Star', 'star', ' STAR ', 'coin'])).toEqual(['Star', 'coin']); + expect(normalizeTags([])).toBe(null); + expect(normalizeTags(['', ' '])).toBe(null); + expect(normalizeTags('star')).toBe(null); + expect(normalizeTags(Array.from({ length: 40 }, (_, i) => 't' + i))?.length).toBe(MAX_TAGS); + }); + it('hasTag ignores case', () => { + expect(hasTag(obj('a', ['Pickup']), 'pickup')).toBe(true); + expect(hasTag(obj('a'), 'pickup')).toBe(false); + }); + it('sceneTags counts every tag once per object', () => { + const { root } = scene(); + expect(sceneTags(root)).toEqual([ + { tag: 'Pickup', count: 2 }, + { tag: 'star', count: 3 } + ]); + }); +}); + +describe('selector picks', () => { + it('absent / unknown pick = the old single object', () => { + expect(pickOf({ selected: 'x' })).toBe('object'); + expect(pickOf({ pick: 'regex' })).toBe('object'); + expect(isManySelector({ selected: 'x' })).toBe(false); + expect(isManySelector({ pick: 'tag', match: 'a' })).toBe(true); + expect(resolveSelector({ selected: 'abc' }, null)).toEqual(['abc']); + expect(resolveSelector({ selected: '-None-' }, null)).toEqual([]); + expect(resolveSelector({}, null)).toEqual([]); + }); + it('tag: every carrier in scene order, never a helper', () => { + const { root, s1, s2, coin } = scene(); + expect(resolveSelector({ pick: 'tag', match: 'star' }, root)).toEqual([s1.uuid, s2.uuid]); + expect(resolveSelector({ pick: 'tag', match: 'PICKUP' }, root)).toEqual([s1.uuid, coin.uuid]); + expect(resolveSelector({ pick: 'tag', match: '' }, root)).toEqual([]); + }); + it('group: the direct children of that group', () => { + const { root, stars, s1, s2, s3 } = scene(); + expect(resolveSelector({ pick: 'group', match: stars.uuid }, root)).toEqual([s1.uuid, s2.uuid, s3.uuid]); + expect(resolveSelector({ pick: 'group', match: 'gone' }, root)).toEqual([]); + expect(resolveSelector({ pick: 'group', match: root.uuid }, root)).toEqual([]); + }); + it('name: glob or contains, case-insensitive, the OUTERMOST match only', () => { + const { root, stars, s1, s2, s3, model } = scene(); + // "star" is contained in Stars (the group) — the group wins, its children are not repeated + expect(resolveSelector({ pick: 'name', match: 'star' }, root)).toEqual([stars.uuid, model.uuid]); + expect(resolveSelector({ pick: 'name', match: 'Star ?' }, root)).toEqual([s1.uuid, s2.uuid]); + expect(resolveSelector({ pick: 'name', match: 'star*' }, root)).toEqual([stars.uuid, model.uuid]); + expect(resolveSelector({ pick: 'name', match: '*three' }, root)).toEqual([s3.uuid]); + }); + it('nameMatcher escapes regex characters', () => { + expect(nameMatcher('a.b*')('a.b c')).toBe(true); + expect(nameMatcher('a.b*')('axb c')).toBe(false); + expect(nameMatcher('(1)')('Box (1)')).toBe(true); + expect(nameMatcher('')('anything')).toBe(false); + }); + it('the memo key folds case and whitespace', () => { + expect(selectorKey({ pick: 'tag', match: ' Star ' })).toBe(selectorKey({ pick: 'tag', match: 'star' })); + expect(selectorKey({ pick: 'tag', match: 'star' })).not.toBe(selectorKey({ pick: 'name', match: 'star' })); + }); + it('describeSet says the count and the first names', () => { + const names = /** @type {Record} */ ({ a: 'A', b: 'B', c: 'C', d: 'D' }); + expect(describeSet([], (u) => names[u])).toBe('no objects'); + expect(describeSet(['a'], (u) => names[u])).toBe('1 object: A'); + expect(describeSet(['a', 'b', 'c', 'd'], (u) => names[u])).toBe('4 objects: A, B, C and 1 more'); + }); +}); From e3db9287158388d4f9b3bb7f30453d1b8078f417 Mon Sep 17 00:00:00 2001 From: AlexZ005 Date: Sat, 21 Nov 2026 19:28:19 +0200 Subject: [PATCH 2/8] =?UTF-8?q?feat(flows):=20many-target=20Object=20Selec?= =?UTF-8?q?tor=20in=20the=20runtime=20=E2=80=94=20fan-out,=20set=20members?= =?UTF-8?q?hip,=20Fired=20Object=20(102b-flows=20row=201b)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An Object Selector with pick tag / group / name resolves to a set (memoised per tick per question). Every effect pair collection fans out over the set, with ONE resolveInputs per edge and a per-member key on the rising-edge maps (Play Animation, Set Expression, physics actions; sound and particle voices get a member id), so every member acts on the same pulse. Triggers fire for any member (reachesObjectSelector, hover, watched objects). A new Fired Object node says which member fired; the stamp carries an additive optional 'obj' field on nodetrigger only when something listens (older peers ignore it, the validator accepts absent). Physics props, jiggle and patrol read the set too. A selector without pick takes the old code path. Co-Authored-By: Claude Opus 5.5 --- .../menu/inspector/TagsSection.svelte | 4 +- src/lib/flowRuntime.js | 339 +++++++++++++----- src/lib/nodeDocs.js | 3 +- src/lib/nodes/families/scene.js | 25 ++ src/lib/pathCapture.js | 4 +- src/lib/peerHandler.svelte.js | 2 +- src/lib/physics.js | 6 +- src/lib/sim/jiggleRuntime.js | 6 +- src/lib/wireValidate.js | 4 +- tests/unit/nodeRegistry.test.js | 4 +- 10 files changed, 299 insertions(+), 98 deletions(-) diff --git a/src/components/menu/inspector/TagsSection.svelte b/src/components/menu/inspector/TagsSection.svelte index 91f1fa3d5..a8188dd24 100644 --- a/src/components/menu/inspector/TagsSection.svelte +++ b/src/components/menu/inspector/TagsSection.svelte @@ -59,7 +59,7 @@ aria-label="Remove tag {c.tag}" title="Remove the tag {c.tag}{many ? ' from every selected object' : ''}" {disabled} - onclick={() => removeTag(uuids, c.tag)}>