@poveste/shared 0.2.1 → 0.3.1

package/dist/state.d.ts

@@ -1,4 +1,27 @@
 export declare function clone(data: any): any;
 export declare function omit(data: any, keys: string[]): {};
-export declare function applyState(target: any, state: any, override?: boolean): void;
+/**
+ * Structural comparison, deliberately narrow: it recurses into plain objects and
+ * arrays and compares everything else by `Object.is`.
+ *
+ * That narrowness is the point. Anything with a prototype of its own — a `Date`,
+ * a `Map`, a class instance, a DOM node — carries state that own enumerable keys
+ * do not describe, and two distinct `Date`s would otherwise compare equal on an
+ * empty key list. Reporting "not equivalent" for those is the safe answer: the
+ * caller writes, which is what it did before this existed.
+ *
+ * `Object.is` is not an arbitrary choice either — it is exactly the predicate
+ * Vue's `hasChanged` uses, so a value this reports as equivalent is a value Vue
+ * would have refused to trigger on anyway.
+ */
+export declare function isEquivalent(a: any, b: any, seen?: WeakMap<object, WeakSet<object>>): boolean;
+/**
+ * Copies `state` onto `target`, and reports whether it wrote anything.
+ *
+ * The return value is what the state syncs in `plugin-vue`, `plugin-svelte` and
+ * the sandbox bridge use to decide whether to expect an echo. Each of them holds
+ * a flag meaning "the next firing is mine, ignore it", and that flag is only
+ * safe to set when a firing is actually coming. See #95.
+ */
+export declare function applyState(target: any, state: any, override?: boolean): boolean;
 //# sourceMappingURL=state.d.ts.map

package/dist/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,IAAI,KAAA,OAczB;AAED,wBAAgB,IAAI,CAAC,IAAI,KAAA,EAAE,IAAI,EAAE,MAAM,EAAE,MAQxC;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,UAAQ,QAenE"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../src/state.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,IAAI,KAAA,OAczB;AAED,wBAAgB,IAAI,CAAC,IAAI,KAAA,EAAE,IAAI,EAAE,MAAM,EAAE,MAQxC;AAWD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAsC7F;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,UAAQ,WAiEnE"}

package/dist/state.js

@@ -22,19 +22,119 @@ export function omit(data, keys) {
     }
     return copy;
 }
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Structural comparison, deliberately narrow: it recurses into plain objects and
+ * arrays and compares everything else by `Object.is`.
+ *
+ * That narrowness is the point. Anything with a prototype of its own — a `Date`,
+ * a `Map`, a class instance, a DOM node — carries state that own enumerable keys
+ * do not describe, and two distinct `Date`s would otherwise compare equal on an
+ * empty key list. Reporting "not equivalent" for those is the safe answer: the
+ * caller writes, which is what it did before this existed.
+ *
+ * `Object.is` is not an arbitrary choice either — it is exactly the predicate
+ * Vue's `hasChanged` uses, so a value this reports as equivalent is a value Vue
+ * would have refused to trigger on anyway.
+ */
+export function isEquivalent(a, b, seen) {
+    if (Object.is(a, b)) {
+        return true;
+    }
+    const bothArrays = Array.isArray(a) && Array.isArray(b);
+    if (!bothArrays && !(isPlainObject(a) && isPlainObject(b))) {
+        return false;
+    }
+    if (bothArrays && a.length !== b.length) {
+        return false;
+    }
+    // State is user data and can be cyclic. A pair already on the stack is
+    // assumed equivalent — the usual co-inductive treatment, and it terminates.
+    const visited = seen ?? new WeakMap();
+    let peers = visited.get(a);
+    if (peers?.has(b)) {
+        return true;
+    }
+    if (!peers) {
+        peers = new WeakSet();
+        visited.set(a, peers);
+    }
+    peers.add(b);
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+        return false;
+    }
+    return keys.every(key => Object.hasOwn(b, key) && isEquivalent(a[key], b[key], visited));
+}
+/**
+ * Copies `state` onto `target`, and reports whether it wrote anything.
+ *
+ * The return value is what the state syncs in `plugin-vue`, `plugin-svelte` and
+ * the sandbox bridge use to decide whether to expect an echo. Each of them holds
+ * a flag meaning "the next firing is mine, ignore it", and that flag is only
+ * safe to set when a firing is actually coming. See #95.
+ */
 export function applyState(target, state, override = false) {
+    let wrote = false;
     for (const key in state) {
+        const current = target[key];
+        // Skip writes that cannot change anything. Vue drops a re-assigned primitive
+        // on its own, but never an object: `state` here has always been rebuilt by a
+        // `toRawDeep`/`clone` on the way in, so assigning one lands a fresh identity
+        // over an equal-but-distinct old one, and triggers every watcher on it.
+        //
+        // Those spurious triggers were load-bearing, which is the whole of #95 — the
+        // syncs counted on them to keep their flags alternating. Skipping them is
+        // both the efficiency win and the thing that makes `wrote` mean something.
+        //
+        // The key has to exist first. `undefined` is equivalent to `undefined`, so a
+        // key the target does not have yet and whose incoming value is `undefined`
+        // would otherwise never be created — and a story that declares its shape
+        // upfront (`initState: () => ({ pending: undefined })`) would get no control
+        // for it, because the panel lists the keys the state actually has.
+        if (Object.hasOwn(target, key) && isEquivalent(current, state[key])) {
+            continue;
+        }
         // iframe sync needs to update properties without overriding them
-        if (!override && target[key] && !key.startsWith('_h') && typeof target[key] === 'object' && !Array.isArray(target[key])) {
-            Object.assign(target[key], state[key]);
+        if (!override && current && !key.startsWith('_h') && typeof current === 'object' && !Array.isArray(current)) {
+            // Not `Object.assign`, because the reason the two are not equivalent may
+            // be a key that `current` has and `state[key]` does not — a removal, which
+            // this merge cannot express. Assigning the rest would then change nothing
+            // while still looking like a write, and a caller that took that for a
+            // write would wait for an echo that never comes. Compare per key and
+            // report only what actually moved.
+            let merged = false;
+            for (const nested in state[key]) {
+                if (isEquivalent(current[nested], state[key][nested])) {
+                    continue;
+                }
+                try {
+                    current[nested] = state[key][nested];
+                    merged = true;
+                }
+                catch {
+                    // noop
+                }
+            }
+            if (!merged) {
+                continue;
+            }
         }
         else {
             try {
                 target[key] = state[key];
             }
-            catch (e) {
+            catch {
                 // noop
             }
         }
+        wrote = true;
     }
+    return wrote;
 }

package/dist/types/prompt.d.ts

@@ -16,5 +16,5 @@ export interface SelectPrompt extends PromptBase<string> {
     type: 'select';
     options: SelectPromptOption[] | ((search: string, answers: Record<string, any>) => Awaitable<SelectPromptOption[]>);
 }
-export type Prompt<TValue = any> = TextPrompt | SelectPrompt;
+export type Prompt = TextPrompt | SelectPrompt;
 //# sourceMappingURL=prompt.d.ts.map

package/dist/types/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/types/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,WAAW,UAAU,CAAC,MAAM;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,MAAM,CAAC,CAAA;CACnE;AAED,MAAM,WAAW,UAAW,SAAQ,UAAU,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,YAAa,SAAQ,UAAU,CAAC,MAAM,CAAC;IACtD,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,SAAS,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAA;CACpH;AAED,MAAM,MAAM,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI,UAAU,GACzC,YAAY,CAAA"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/types/prompt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,WAAW,UAAU,CAAC,MAAM;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,MAAM,CAAC,CAAA;CACnE;AAED,MAAM,WAAW,UAAW,SAAQ,UAAU,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,YAAa,SAAQ,UAAU,CAAC,MAAM,CAAC;IACtD,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,SAAS,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAA;CACpH;AAKD,MAAM,MAAM,MAAM,GAAG,UAAU,GAC3B,YAAY,CAAA"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@poveste/shared",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Shared utilities for Poveste",
   "author": {
     "name": "Sorin Gitlan"
@@ -25,7 +25,7 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "peerDependencies": {
-    "vite": "^7.0.0 || ^8.0.0"
+    "vite": "^8.0.0"
   },
   "dependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -34,14 +34,17 @@
     "pathe": "^1.1.2",
     "picocolors": "^1.1.1",
     "unhead": "^3.1.0",
-    "@poveste/vendors": "^0.2.1"
+    "@poveste/vendors": "^0.3.1"
   },
   "devDependencies": {
     "typescript": "5.6.3",
-    "vite": "^7.3.0"
+    "vite": "^8.2.0",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "rimraf dist && tsc",
-    "watch": "tsc -w --sourceMap"
+    "watch": "tsc -w --sourceMap",
+    "test": "vitest run",
+    "test:dev": "vitest"
   }
 }

package/src/__tests__/state.spec.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it } from 'vitest'
+import { applyState, isEquivalent } from '../state.js'
+
+describe('isEquivalent', () => {
+  it('compares primitives the way Vue decides whether to trigger', () => {
+    expect(isEquivalent(1, 1)).toBe(true)
+    expect(isEquivalent('a', 'a')).toBe(true)
+    expect(isEquivalent(null, null)).toBe(true)
+    expect(isEquivalent(undefined, undefined)).toBe(true)
+    // `Object.is`, not `===`: matches Vue's `hasChanged` on both of its oddities.
+    expect(isEquivalent(Number.NaN, Number.NaN)).toBe(true)
+    expect(isEquivalent(0, -0)).toBe(false)
+    expect(isEquivalent(1, '1')).toBe(false)
+    expect(isEquivalent(0, false)).toBe(false)
+  })
+
+  it('recurses into plain objects and arrays', () => {
+    expect(isEquivalent({ a: 1, b: { c: [1, 2] } }, { a: 1, b: { c: [1, 2] } })).toBe(true)
+    expect(isEquivalent({ a: 1, b: { c: [1, 2] } }, { a: 1, b: { c: [1, 3] } })).toBe(false)
+    expect(isEquivalent([1, 2], [1, 2, 3])).toBe(false)
+    expect(isEquivalent({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+    expect(isEquivalent({ a: 1, b: 2 }, { a: 1 })).toBe(false)
+    // Same key count, different keys.
+    expect(isEquivalent({ a: 1 }, { b: 1 })).toBe(false)
+    // An array and an object are never equivalent, however similar.
+    expect(isEquivalent([], {})).toBe(false)
+  })
+
+  it('refuses to compare anything with a prototype of its own', () => {
+    // Both would report an empty key list, so a structural walk would call them
+    // equal. Reporting "different" makes the caller write, which is what it did
+    // before this guard existed.
+    expect(isEquivalent(new Date(0), new Date(1))).toBe(false)
+    expect(isEquivalent(new Date(0), new Date(0))).toBe(false)
+    expect(isEquivalent(new Map([['a', 1]]), new Map())).toBe(false)
+    expect(isEquivalent(new Set([1]), new Set([2]))).toBe(false)
+    expect(isEquivalent(/a/, /b/)).toBe(false)
+
+    class Point { constructor(public x = 1) {} }
+    expect(isEquivalent(new Point(), new Point())).toBe(false)
+    // ...but the identical instance is still identical.
+    const point = new Point()
+    expect(isEquivalent(point, point)).toBe(true)
+  })
+
+  it('terminates on cyclic state', () => {
+    const a: any = { name: 'a' }
+    a.self = a
+    const b: any = { name: 'a' }
+    b.self = b
+
+    expect(isEquivalent(a, b)).toBe(true)
+
+    const c: any = { name: 'c' }
+    c.self = c
+    expect(isEquivalent(a, c)).toBe(false)
+  })
+
+  it('handles objects created without a prototype', () => {
+    const bare = Object.create(null)
+    bare.a = 1
+    expect(isEquivalent(bare, { a: 1 })).toBe(true)
+  })
+})
+
+describe('applyState', () => {
+  it('copies values across', () => {
+    const target: any = { a: 1 }
+    applyState(target, { a: 2, b: 3 })
+    expect(target).toEqual({ a: 2, b: 3 })
+  })
+
+  it('merges into an existing object rather than replacing it', () => {
+    const nested = { a: 1, b: 2 }
+    const target: any = { nested }
+    applyState(target, { nested: { a: 9 } })
+    // Same object, updated in place — the sandbox bridge depends on this.
+    expect(target.nested).toBe(nested)
+    expect(target.nested).toEqual({ a: 9, b: 2 })
+  })
+
+  it('replaces the object when override is set', () => {
+    const nested = { a: 1, b: 2 }
+    const target: any = { nested }
+    applyState(target, { nested: { a: 9 } }, true)
+    expect(target.nested).not.toBe(nested)
+    expect(target.nested).toEqual({ a: 9 })
+  })
+
+  it('leaves identity alone when the incoming value is equivalent', () => {
+    // The behaviour #95 turns on. `toRawDeep` rebuilds every object on its way
+    // through the state sync, so without this the assignment below would land a
+    // new identity over an equal one and trigger every watcher on it.
+    const list = [1, 2, 3]
+    const nested = { a: 1 }
+    const target: any = { list, nested, count: 0 }
+
+    applyState(target, { list: [1, 2, 3], nested: { a: 1 }, count: 0 })
+
+    expect(target.list).toBe(list)
+    expect(target.nested).toBe(nested)
+  })
+
+  it('creates a key the target does not have, even when the value is undefined', () => {
+    // `undefined` is equivalent to `undefined`, so the skip has to check that
+    // the key exists before it trusts that. A story is allowed to declare its
+    // shape upfront — `initState: () => ({ text: 'hi', pending: undefined })` —
+    // and the controls panel lists the keys the state actually has.
+    const target: any = {}
+    applyState(target, { text: 'hi', pending: undefined })
+
+    expect(Object.keys(target)).toEqual(['text', 'pending'])
+    expect('pending' in target).toBe(true)
+  })
+
+  it('still skips an existing key whose value is already undefined', () => {
+    const target: any = { pending: undefined }
+    expect(applyState(target, { pending: undefined })).toBe(false)
+  })
+
+  it('still writes when only part of an equivalent-looking value differs', () => {
+    const target: any = { nested: { a: 1, b: 2 } }
+    applyState(target, { nested: { a: 1, b: 3 } })
+    expect(target.nested).toEqual({ a: 1, b: 3 })
+  })
+
+  it('swallows writes to read-only properties', () => {
+    const target: any = {}
+    Object.defineProperty(target, 'ro', { get: () => 1, enumerable: true })
+    expect(() => applyState(target, { ro: 2 })).not.toThrow()
+    expect(target.ro).toBe(1)
+  })
+
+  it('cannot express a key removal', () => {
+    // Not a wish list — every state sync in the repo is built around knowing
+    // this. `applyState` iterates the incoming keys, so a key the source has
+    // dropped is simply never visited and survives on the target.
+    const target: any = { a: 1, gone: 2 }
+    applyState(target, { a: 1 })
+    expect(target.gone).toBe(2)
+  })
+})
+
+// Every state sync in the repo holds a flag meaning "ignore the next firing, it
+// is the echo of my own write", and clears it when that firing arrives. This
+// return value is what tells them whether a firing is coming at all. Report
+// `true` when nothing moved and the flag stays set forever, swallowing the next
+// real edit — which is #95.
+describe('applyState reporting whether it wrote', () => {
+  it('reports a write', () => {
+    expect(applyState({ a: 1 }, { a: 2 })).toBe(true)
+    expect(applyState({}, { a: 1 })).toBe(true)
+    expect(applyState({ list: [1] }, { list: [1, 2] })).toBe(true)
+  })
+
+  it('reports nothing for a state that already matches', () => {
+    expect(applyState({ a: 1 }, { a: 1 })).toBe(false)
+    expect(applyState({ nested: { a: 1 } }, { nested: { a: 1 } })).toBe(false)
+    expect(applyState({ list: [1, 2] }, { list: [1, 2] })).toBe(false)
+    expect(applyState({ a: 1 }, {})).toBe(false)
+  })
+
+  it('reports nothing when a merge only drops keys it cannot drop', () => {
+    // The exact shape of #95, and the case that makes the naive answer wrong.
+    // `{ a: 1, b: 2 }` and `{ a: 1 }` are not equivalent, so this reaches the
+    // merge — but merging leaves the target byte for byte as it was, because
+    // the only difference is a key the merge has no way to remove.
+    const target: any = { items: { a: 1, b: 2 } }
+    expect(applyState(target, { items: { a: 1 } })).toBe(false)
+    expect(target.items).toEqual({ a: 1, b: 2 })
+  })
+
+  it('reports a write when a merge does change something', () => {
+    const target: any = { items: { a: 1, b: 2 } }
+    expect(applyState(target, { items: { a: 9 } })).toBe(true)
+    expect(target.items).toEqual({ a: 9, b: 2 })
+  })
+
+  it('reports a write it could not actually make', () => {
+    // Known and deliberately left alone: a setter that silently drops the value
+    // — Vue's read-only `computed` is the one that occurs in practice — still
+    // counts. Getting this right means reading back after every write, and the
+    // consequence of being wrong here is the pre-existing behaviour rather than
+    // a new failure.
+    const target: any = {}
+    Object.defineProperty(target, 'ro', { get: () => 1, enumerable: true, configurable: true })
+    expect(applyState(target, { ro: 2 })).toBe(true)
+  })
+})

package/src/state.ts

@@ -24,19 +24,140 @@ export function omit(data, keys: string[]) {
   return copy
 }
 
+function isPlainObject(value: any) {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+/**
+ * Structural comparison, deliberately narrow: it recurses into plain objects and
+ * arrays and compares everything else by `Object.is`.
+ *
+ * That narrowness is the point. Anything with a prototype of its own — a `Date`,
+ * a `Map`, a class instance, a DOM node — carries state that own enumerable keys
+ * do not describe, and two distinct `Date`s would otherwise compare equal on an
+ * empty key list. Reporting "not equivalent" for those is the safe answer: the
+ * caller writes, which is what it did before this existed.
+ *
+ * `Object.is` is not an arbitrary choice either — it is exactly the predicate
+ * Vue's `hasChanged` uses, so a value this reports as equivalent is a value Vue
+ * would have refused to trigger on anyway.
+ */
+export function isEquivalent(a: any, b: any, seen?: WeakMap<object, WeakSet<object>>): boolean {
+  if (Object.is(a, b)) {
+    return true
+  }
+
+  const bothArrays = Array.isArray(a) && Array.isArray(b)
+
+  if (!bothArrays && !(isPlainObject(a) && isPlainObject(b))) {
+    return false
+  }
+
+  if (bothArrays && a.length !== b.length) {
+    return false
+  }
+
+  // State is user data and can be cyclic. A pair already on the stack is
+  // assumed equivalent — the usual co-inductive treatment, and it terminates.
+  const visited = seen ?? new WeakMap<object, WeakSet<object>>()
+  let peers = visited.get(a)
+
+  if (peers?.has(b)) {
+    return true
+  }
+
+  if (!peers) {
+    peers = new WeakSet<object>()
+    visited.set(a, peers)
+  }
+
+  peers.add(b)
+
+  const keys = Object.keys(a)
+
+  if (keys.length !== Object.keys(b).length) {
+    return false
+  }
+
+  return keys.every(key => Object.hasOwn(b, key) && isEquivalent(a[key], b[key], visited))
+}
+
+/**
+ * Copies `state` onto `target`, and reports whether it wrote anything.
+ *
+ * The return value is what the state syncs in `plugin-vue`, `plugin-svelte` and
+ * the sandbox bridge use to decide whether to expect an echo. Each of them holds
+ * a flag meaning "the next firing is mine, ignore it", and that flag is only
+ * safe to set when a firing is actually coming. See #95.
+ */
 export function applyState(target: any, state: any, override = false) {
+  let wrote = false
+
   for (const key in state) {
+    const current = target[key]
+
+    // Skip writes that cannot change anything. Vue drops a re-assigned primitive
+    // on its own, but never an object: `state` here has always been rebuilt by a
+    // `toRawDeep`/`clone` on the way in, so assigning one lands a fresh identity
+    // over an equal-but-distinct old one, and triggers every watcher on it.
+    //
+    // Those spurious triggers were load-bearing, which is the whole of #95 — the
+    // syncs counted on them to keep their flags alternating. Skipping them is
+    // both the efficiency win and the thing that makes `wrote` mean something.
+    //
+    // The key has to exist first. `undefined` is equivalent to `undefined`, so a
+    // key the target does not have yet and whose incoming value is `undefined`
+    // would otherwise never be created — and a story that declares its shape
+    // upfront (`initState: () => ({ pending: undefined })`) would get no control
+    // for it, because the panel lists the keys the state actually has.
+    if (Object.hasOwn(target, key) && isEquivalent(current, state[key])) {
+      continue
+    }
+
     // iframe sync needs to update properties without overriding them
-    if (!override && target[key] && !key.startsWith('_h') && typeof target[key] === 'object' && !Array.isArray(target[key])) {
-      Object.assign(target[key], state[key])
+    if (!override && current && !key.startsWith('_h') && typeof current === 'object' && !Array.isArray(current)) {
+      // Not `Object.assign`, because the reason the two are not equivalent may
+      // be a key that `current` has and `state[key]` does not — a removal, which
+      // this merge cannot express. Assigning the rest would then change nothing
+      // while still looking like a write, and a caller that took that for a
+      // write would wait for an echo that never comes. Compare per key and
+      // report only what actually moved.
+      let merged = false
+
+      for (const nested in state[key]) {
+        if (isEquivalent(current[nested], state[key][nested])) {
+          continue
+        }
+
+        try {
+          current[nested] = state[key][nested]
+          merged = true
+        }
+        catch {
+          // noop
+        }
+      }
+
+      if (!merged) {
+        continue
+      }
     }
     else {
       try {
         target[key] = state[key]
       }
-      catch (e) {
+      catch {
         // noop
       }
     }
+
+    wrote = true
   }
+
+  return wrote
 }

package/src/types/prompt.ts

@@ -18,5 +18,8 @@ export interface SelectPrompt extends PromptBase<string> {
   options: SelectPromptOption[] | ((search: string, answers: Record<string, any>) => Awaitable<SelectPromptOption[]>)
 }
 
-export type Prompt<TValue = any> = TextPrompt
+// No type parameter: both members fix their value type to `string` via
+// `PromptBase<string>`, so the `<TValue = any>` this used to carry never
+// reached anything and no caller ever passed one.
+export type Prompt = TextPrompt
   | SelectPrompt

package/tsconfig.json

@@ -10,7 +10,7 @@
     "baseUrl": ".",
     "rootDir": "src",
     "module": "ESNext",
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     // Alias
     "paths": {
       "floating-vue": ["node_modules/@poveste/vendors/floating-vue"],