@pascal-app/core 1.0.3 → 1.0.5

package/dist/store/history-drafts.js

@@ -0,0 +1,403 @@
+/** Structural equality for node field values (plain data: arrays, objects, primitives). */
+function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    return aKeys.every((key) => sameValue(a[key], b[key]));
+}
+const sceneHistoryDrafts = new Map();
+const faceHostFields = ['roofSegmentId', 'roofFace', 'blockFaceId'];
+const childIdsOf = (node) => node && 'children' in node && Array.isArray(node.children) ? node.children : [];
+const attachmentsOf = (node) => node && 'attachments' in node && node.attachments && typeof node.attachments === 'object'
+    ? node.attachments
+    : undefined;
+/**
+ * Registers `id` as a carried draft; returns the call that ends it. A second holder of a node
+ * already carried (split view) shares its registration, which ends with its last holder.
+ */
+export function beginSceneHistoryDraft(id, original, nodes) {
+    const existing = sceneHistoryDrafts.get(id);
+    if (existing && !existing.ended) {
+        existing.refs += 1;
+        return releaseOnce(id, existing);
+    }
+    const parent = original?.parentId ? nodes[original.parentId] : undefined;
+    const draft = {
+        original,
+        parentIndex: childIdsOf(parent).indexOf(id),
+        attachment: attachmentsOf(parent)?.[id],
+        owned: new Map(),
+        hostEntries: new Map(),
+        refs: 1,
+        ended: false,
+        suspended: false,
+    };
+    sceneHistoryDrafts.set(id, draft);
+    return releaseOnce(id, draft);
+}
+function releaseOnce(id, draft) {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        draft.refs -= 1;
+        if (draft.refs > 0)
+            return;
+        draft.ended = true;
+        if (sceneHistoryDrafts.get(id) === draft)
+            sceneHistoryDrafts.delete(id);
+    };
+}
+/**
+ * Runs a gesture's committing write with `id` visible to history, so whichever co-owner of the
+ * gesture drops it (the 3D mover or the 2D move overlay) records the change.
+ */
+export function withSceneHistoryDraftSuspended(id, write) {
+    const draft = id ? sceneHistoryDrafts.get(id) : undefined;
+    if (!(id && draft))
+        return write();
+    // Visible to history for this write, but still the carry's: its own restore can revert it.
+    const wasSuspended = draft.suspended;
+    draft.suspended = true;
+    try {
+        return write();
+    }
+    finally {
+        draft.suspended = wasSuspended;
+    }
+}
+/** A host's attachment entry for `id`, or ABSENT. */
+const ABSENT = Symbol('absent');
+function hostEntry(nodes, hostId, id) {
+    const attachments = attachmentsOf(nodes[hostId]);
+    return attachments && Object.hasOwn(attachments, id) ? attachments[id] : ABSENT;
+}
+/** `host` with its attachment entry for `id` set to `value` (ABSENT removes it). */
+function withHostEntry(host, id, value) {
+    const { [id]: _previous, ...rest } = attachmentsOf(host) ?? {};
+    return {
+        ...host,
+        attachments: value === ABSENT ? rest : { ...rest, [id]: value },
+    };
+}
+function heldHostEntries(draft, id, nodes) {
+    return [...draft.hostEntries].filter(([hostId, entry]) => nodes[hostId] && sameValue(hostEntry(nodes, hostId, id), entry.carried));
+}
+export function hasSceneHistoryDrafts() {
+    return sceneHistoryDrafts.size > 0;
+}
+/**
+ * Records a carry's own write: each field it changed on an adopted draft is held with the value
+ * it had before (kept from an earlier carry write while the carry still held it) and the value
+ * the carry wrote. A write back to that earlier value ends the hold.
+ */
+export function noteSceneHistoryDraftWrite(before, after) {
+    for (const [id, draft] of sceneHistoryDrafts) {
+        const previous = before[id];
+        const next = after[id];
+        if (!(draft.original && previous && next))
+            continue;
+        const hosts = new Set([
+            previous.parentId,
+            next.parentId,
+            draft.original.parentId,
+            ...draft.hostEntries.keys(),
+        ].filter((hostId) => typeof hostId === 'string'));
+        for (const hostId of hosts) {
+            const was = hostEntry(before, hostId, id);
+            const now = hostEntry(after, hostId, id);
+            if (sameValue(was, now))
+                continue;
+            const held = draft.hostEntries.get(hostId);
+            const baseline = held && sameValue(held.carried, was) ? held.baseline : was;
+            if (sameValue(baseline, now))
+                draft.hostEntries.delete(hostId);
+            else
+                draft.hostEntries.set(hostId, { baseline, carried: now });
+        }
+        if (previous === next)
+            continue;
+        for (const key of new Set([...Object.keys(previous), ...Object.keys(next)])) {
+            if (sameValue(previous[key], next[key]))
+                continue;
+            const held = key === 'metadata'
+                ? heldFields(draft, before[id]).find(([name]) => name === key)?.[1]
+                : draft.owned.get(key);
+            const baseline = held && sameValue(held.carried, previous[key])
+                ? held.baseline
+                : { present: Object.hasOwn(previous, key), value: previous[key] };
+            if (baseline.present === Object.hasOwn(next, key) && sameValue(baseline.value, next[key])) {
+                draft.owned.delete(key);
+            }
+            else {
+                draft.owned.set(key, { baseline, carried: next[key] });
+            }
+        }
+    }
+}
+/**
+ * The fields the carry still holds on an adopted draft: those whose live value is still the
+ * carry's. A foreign write over one ends the hold (until the carry writes it again).
+ */
+function heldFields(draft, live) {
+    const values = live;
+    return [...draft.owned].flatMap(([key, field]) => {
+        if (sameValue(values[key], field.carried))
+            return [[key, field]];
+        if (key !== 'metadata')
+            return [];
+        const current = values[key];
+        const carried = field.carried;
+        const baseline = (field.baseline.present ? field.baseline.value : {});
+        if (!(current && carried && baseline))
+            return [];
+        // Metadata writers commonly spread the current record before adding their own key.
+        // Retain ownership of unchanged carry keys without masking that writer's additions.
+        const heldKeys = [...new Set([...Object.keys(baseline), ...Object.keys(carried)])].filter((name) => !sameValue(baseline[name], carried[name]) && sameValue(current[name], carried[name]));
+        if (heldKeys.length === 0)
+            return [];
+        const restored = { ...current };
+        for (const name of heldKeys) {
+            if (Object.hasOwn(baseline, name))
+                restored[name] = baseline[name];
+            else
+                delete restored[name];
+        }
+        return [[key, { baseline: { present: true, value: restored }, carried: current, heldKeys }]];
+    });
+}
+/**
+ * Updates that put an adopted draft's held fields back to their values before the carry,
+ * leaving everything others wrote. A parent that no longer exists is never restored.
+ */
+export function sceneHistoryDraftRevertUpdates(nodes, ids) {
+    const updates = [];
+    for (const id of ids) {
+        const draft = sceneHistoryDrafts.get(id);
+        const live = nodes[id];
+        if (!(draft?.original && live))
+            continue;
+        const data = {};
+        for (const [key, { baseline }] of heldFields(draft, live)) {
+            if (key === 'parentId' && baseline.value && !nodes[baseline.value])
+                continue;
+            data[key] = baseline.present ? baseline.value : undefined;
+        }
+        if (Object.keys(data).length > 0)
+            updates.push({ id, data });
+        for (const [hostId, { baseline }] of heldHostEntries(draft, id, nodes)) {
+            const pending = updates.find((update) => update.id === hostId);
+            const host = { ...nodes[hostId], ...(pending?.data ?? {}) };
+            const attachments = withHostEntry(host, id, baseline)
+                .attachments;
+            if (pending)
+                pending.data.attachments = attachments;
+            else
+                updates.push({ id: hostId, data: { attachments } });
+        }
+    }
+    return updates;
+}
+/**
+ * A drop committed these drafts' carried state: nothing the carry wrote is left to revert, so a
+ * co-holder's later cancel or cleanup (the 3D mover after a split-view 2D drop) keeps the drop.
+ */
+export function settleSceneHistoryDrafts(ids) {
+    for (const id of ids) {
+        const draft = sceneHistoryDrafts.get(id);
+        if (!draft)
+            continue;
+        draft.owned.clear();
+        draft.hostEntries.clear();
+    }
+}
+export function clearSceneHistoryDrafts() {
+    sceneHistoryDrafts.clear();
+}
+/** Created drafts: history excludes them (and their subtrees) like fresh-placement nodes. */
+export function createdSceneHistoryDraftIds() {
+    return [...sceneHistoryDrafts]
+        .filter(([, draft]) => !(draft.original || draft.suspended))
+        .map(([id]) => id);
+}
+/** Moves `id` from wherever it lives in `nodes` to `parentId` (at `index`), with `attachment`. */
+function placeChild(nodes, id, fromParentId, toParentId, index, attachment) {
+    const update = (parentId, edit) => {
+        const parent = nodes[parentId];
+        if (!parent)
+            return;
+        const next = { ...parent };
+        edit(next);
+        nodes[parentId] = next;
+    };
+    if (fromParentId && fromParentId !== toParentId) {
+        update(fromParentId, (parent) => {
+            const children = parent.children;
+            if (Array.isArray(children))
+                parent.children = children.filter((child) => child !== id);
+            const attachments = parent.attachments;
+            if (attachments && Object.hasOwn(attachments, id)) {
+                const { [id]: _removed, ...rest } = attachments;
+                parent.attachments = rest;
+            }
+        });
+    }
+    if (!toParentId)
+        return;
+    update(toParentId, (parent) => {
+        const children = parent.children;
+        if (Array.isArray(children) && !children.includes(id)) {
+            const next = [...children];
+            next.splice(index < 0 ? next.length : Math.min(index, next.length), 0, id);
+            parent.children = next;
+        }
+        const attachments = parent.attachments;
+        if (attachment === undefined) {
+            if (attachments && Object.hasOwn(attachments, id)) {
+                const { [id]: _removed, ...rest } = attachments;
+                parent.attachments = rest;
+            }
+        }
+        else if (attachments?.[id] !== attachment) {
+            parent.attachments = { ...(attachments ?? {}), [id]: attachment };
+        }
+    });
+}
+/**
+ * Records the carry-owned fields of adopted drafts as they were before the carry. The original
+ * parent link is restored only while that parent still exists. `historyNodes` may be `nodes`.
+ */
+export function withAdoptedDraftsAsOriginal(nodes, historyNodes) {
+    let result = null;
+    for (const [id, draft] of sceneHistoryDrafts) {
+        if (draft.suspended)
+            continue;
+        const live = nodes[id];
+        const held = draft.original && live ? heldFields(draft, live) : [];
+        const heldHosts = draft.original && live ? heldHostEntries(draft, id, nodes) : [];
+        if (!(draft.original && live) || held.length + heldHosts.length === 0)
+            continue;
+        const heldParent = held.find(([key]) => key === 'parentId')?.[1].baseline;
+        const originalParentId = heldParent?.value;
+        const restoreParent = Boolean(heldParent) && (!originalParentId || Boolean(nodes[originalParentId]));
+        const recorded = { ...live };
+        for (const [key, { baseline }] of held) {
+            if (key === 'parentId' && !restoreParent)
+                continue;
+            if (baseline.present)
+                recorded[key] = baseline.value;
+            else
+                delete recorded[key];
+        }
+        result ??= { ...historyNodes };
+        result[id] = recorded;
+        if (restoreParent) {
+            placeChild(result, id, live.parentId, originalParentId, originalParentId === draft.original.parentId ? draft.parentIndex : -1, originalParentId === draft.original.parentId ? draft.attachment : undefined);
+        }
+        for (const [hostId, { baseline }] of heldHosts) {
+            if (result[hostId])
+                result[hostId] = withHostEntry(result[hostId], id, baseline);
+        }
+    }
+    return result ?? historyNodes;
+}
+/**
+ * After an undo or redo, puts back what the carry holds: a created draft (and its subtree)
+ * whole, and on an adopted draft only its held fields, as they were just before the jump.
+ * Everything else keeps the jumped-to state. Returns null when nothing needs restoring.
+ */
+export function withDraftsRestored(before, after) {
+    let result = null;
+    for (const [id, draft] of sceneHistoryDrafts) {
+        if (draft.suspended)
+            continue;
+        const live = before[id];
+        if (!live)
+            continue;
+        if (draft.original) {
+            const jumped = after[id];
+            if (!jumped)
+                continue;
+            for (const [hostId, { carried }] of heldHostEntries(draft, id, before)) {
+                const host = (result ?? after)[hostId];
+                if (!host || sameValue(hostEntry(result ?? after, hostId, id), carried))
+                    continue;
+                result ??= { ...after };
+                result[hostId] = withHostEntry(host, id, carried);
+            }
+            const values = live;
+            const heldEntries = new Map(heldFields(draft, live));
+            const held = [...heldEntries]
+                .map(([key]) => key)
+                .filter((key) => !sameValue(values[key], jumped[key]));
+            if (held.length === 0)
+                continue;
+            result ??= { ...after };
+            const restored = { ...jumped };
+            const lostParent = live.parentId && !result[live.parentId];
+            for (const key of held) {
+                // A missing host's binding must not replace the jumped-to parent's valid binding.
+                if (lostParent && (key === 'parentId' || faceHostFields.includes(key)))
+                    continue;
+                const heldKeys = heldEntries.get(key)?.heldKeys;
+                if (heldKeys) {
+                    const metadata = { ...restored[key] };
+                    const carried = values[key];
+                    for (const name of heldKeys) {
+                        if (Object.hasOwn(carried, name))
+                            metadata[name] = carried[name];
+                        else
+                            delete metadata[name];
+                    }
+                    restored[key] = metadata;
+                    continue;
+                }
+                if (Object.hasOwn(values, key))
+                    restored[key] = values[key];
+                else
+                    delete restored[key];
+            }
+            result[id] = restored;
+            const parentId = live.parentId;
+            if (held.includes('parentId') && parentId && result[parentId]) {
+                const beforeParent = before[parentId];
+                placeChild(result, id, jumped.parentId, parentId, childIdsOf(beforeParent).indexOf(id), attachmentsOf(beforeParent)?.[id]);
+            }
+            continue;
+        }
+        const subtree = [id];
+        for (let index = 0; index < subtree.length; index++) {
+            for (const childId of childIdsOf(before[subtree[index]]))
+                subtree.push(childId);
+        }
+        if (subtree.every((nodeId) => after[nodeId] === before[nodeId]))
+            continue;
+        result ??= { ...after };
+        for (const nodeId of subtree)
+            result[nodeId] = before[nodeId];
+        let parentId = live.parentId;
+        const visited = new Set();
+        while (parentId && !result[parentId] && !visited.has(parentId)) {
+            visited.add(parentId);
+            parentId = before[parentId]?.parentId;
+        }
+        if (parentId !== live.parentId) {
+            const restored = { ...live, parentId: parentId ?? null };
+            for (const key of faceHostFields)
+                delete restored[key];
+            result[id] = restored;
+        }
+        const previousParentId = after[id]?.parentId;
+        const beforeParent = parentId ? before[parentId] : undefined;
+        placeChild(result, id, previousParentId, parentId, childIdsOf(beforeParent).indexOf(id), attachmentsOf(beforeParent)?.[id]);
+    }
+    return result;
+}

package/dist/store/history-invalidation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"history-invalidation.d.ts","sourceRoot":"","sources":["../../src/store/history-invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAG7D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,GAAG,CAAC,SAAS,CAAC,CAyEhB"}
+{"version":3,"file":"history-invalidation.d.ts","sourceRoot":"","sources":["../../src/store/history-invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAY,MAAM,WAAW,CAAA;AAG7D,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,GAAG,CAAC,SAAS,CAAC,CA0EhB"}

package/dist/store/history-invalidation.js

@@ -20,6 +20,7 @@ export function getHistoryDirtyNodeIds(before, after) {
             if (previous?.type !== 'wall' ||
                 next?.type !== 'wall' ||
                 previous.thickness !== next.thickness ||
+                previous.justification !== next.justification ||
                 previous.height !== next.height ||
                 previous.curveOffset !== next.curveOffset) {
                 changedHosts.add(id);

package/dist/store/item-interaction.d.ts

@@ -0,0 +1,28 @@
+import type { Interactive } from '../schema/nodes/item.js';
+import type { AnyNodeId } from '../schema/types.js';
+/**
+ * What E does on an item with toggles, in the editor walkthrough and the baked
+ * viewer alike: open or close its `open` clip; play or pause its first named
+ * clip when named clips are all it has; otherwise switch every toggle (a lamp,
+ * a catalog fan).
+ */
+export type ItemInteraction = {
+    kind: 'open';
+    control: number;
+} | {
+    kind: 'play';
+    control: number;
+    clip: string;
+} | {
+    kind: 'switch';
+};
+export declare function itemInteraction(interactive: Interactive): ItemInteraction;
+/** The walkthrough prompt for an item: "open Garage door", "play Princess twirl", "turn on Lamp". */
+export declare function itemPrompt(itemId: AnyNodeId, name: string, interactive: Interactive): {
+    label: string;
+    verb: string;
+    isOn: boolean;
+};
+/** E on an item, by the same rule as its prompt. */
+export declare function operateItem(itemId: AnyNodeId, interactive: Interactive): void;
+//# sourceMappingURL=item-interaction.d.ts.map

package/dist/store/item-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-interaction.d.ts","sourceRoot":"","sources":["../../src/store/item-interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEtB,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,CAYzE;AAED,qGAAqG;AACrG,wBAAgB,UAAU,CACxB,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,WAAW,GACvB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAahD;AAED,oDAAoD;AACpD,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,QAYtE"}

package/dist/store/item-interaction.js

@@ -0,0 +1,34 @@
+import { useInteractive } from './use-interactive.js';
+export function itemInteraction(interactive) {
+    const animations = interactive.effects.filter((effect) => effect.kind === 'animation');
+    const open = animations.find((effect) => effect.mode === 'open-close');
+    if (open?.control !== undefined)
+        return { kind: 'open', control: open.control };
+    const named = animations.find((effect) => effect.mode === 'ambient' && effect.control !== undefined && effect.clips.on);
+    if (named && !interactive.effects.some((effect) => effect.kind === 'light'))
+        return { kind: 'play', control: named.control, clip: named.clips.on };
+    return { kind: 'switch' };
+}
+/** The walkthrough prompt for an item: "open Garage door", "play Princess twirl", "turn on Lamp". */
+export function itemPrompt(itemId, name, interactive) {
+    const values = useInteractive.getState().items[itemId]?.controlValues;
+    const interaction = itemInteraction(interactive);
+    if (interaction.kind === 'switch') {
+        const isOn = interactive.controls.some((control, index) => control.kind === 'toggle' && Boolean(values?.[index]));
+        return { label: name, verb: isOn ? 'turn off' : 'turn on', isOn };
+    }
+    const isOn = Boolean(values?.[interaction.control]);
+    return interaction.kind === 'open'
+        ? { label: name, verb: isOn ? 'close' : 'open', isOn }
+        : { label: interaction.clip, verb: isOn ? 'pause' : 'play', isOn };
+}
+/** E on an item, by the same rule as its prompt. */
+export function operateItem(itemId, interactive) {
+    const state = useInteractive.getState();
+    const interaction = itemInteraction(interactive);
+    if (interaction.kind === 'switch') {
+        state.toggleItemToggles(itemId, interactive);
+        return;
+    }
+    state.setControlValue(itemId, interaction.control, !state.items[itemId]?.controlValues[interaction.control]);
+}

package/dist/store/registered-node-defaults.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Fills registered schema defaults on stored nodes before `setScene`, for kinds
+ * the scene loader does not own. Built-in kinds are left exactly as stored: the
+ * loader's migrations read what a stored node leaves out (a legacy slab without
+ * `thickness` occupies `[0, elevation]`, a level without `height` marks a legacy
+ * scene) and a zod parse would also strip legacy fields they consume. Parsing
+ * them here made the editor load legacy scenes differently from the viewer and
+ * the hosted authority.
+ */
+export declare function materializeRegisteredNodeDefaults(nodes: Readonly<Record<string, unknown>>): Record<string, unknown>;
+//# sourceMappingURL=registered-node-defaults.d.ts.map

package/dist/store/registered-node-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registered-node-defaults.d.ts","sourceRoot":"","sources":["../../src/store/registered-node-defaults.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/dist/store/registered-node-defaults.js

@@ -0,0 +1,25 @@
+import { nodeRegistry } from '../registry/registry.js';
+import { AnyNode, nodeKindOf } from '../schema/types.js';
+let builtinKinds;
+/**
+ * Fills registered schema defaults on stored nodes before `setScene`, for kinds
+ * the scene loader does not own. Built-in kinds are left exactly as stored: the
+ * loader's migrations read what a stored node leaves out (a legacy slab without
+ * `thickness` occupies `[0, elevation]`, a level without `height` marks a legacy
+ * scene) and a zod parse would also strip legacy fields they consume. Parsing
+ * them here made the editor load legacy scenes differently from the viewer and
+ * the hosted authority.
+ */
+export function materializeRegisteredNodeDefaults(nodes) {
+    builtinKinds ??= new Set(AnyNode.options.map(nodeKindOf));
+    const kinds = builtinKinds;
+    return Object.fromEntries(Object.entries(nodes).map(([id, value]) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return [id, value];
+        const type = value.type;
+        if (typeof type !== 'string' || kinds.has(type))
+            return [id, value];
+        const parsed = nodeRegistry.get(type)?.schema.safeParse(value);
+        return [id, parsed?.success ? parsed.data : value];
+    }));
+}