@poveste/shared 0.5.3 → 0.6.0

package/dist/state.d.ts

@@ -18,10 +18,67 @@ export declare function isEquivalent(a: any, b: any, seen?: WeakMap<object, Weak
 /**
  * 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.
+ * The return value is what the syncs in `plugin-svelte` and the sandbox bridge
+ * use to decide whether to expect an echo. Each 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.
+ *
+ * `plugin-vue` no longer needs it: `createStateBaseline` recognises an echo by
+ * it not being a change, so there is no flag left to keep honest. The two are
+ * the same idea at different strengths, and the others can move across (#96).
  */
 export declare function applyState(target: any, state: any, override?: boolean): boolean;
+/**
+ * The subset of `next` that differs from `baseline`, shaped so `applyState` can
+ * copy it faithfully: a key it will merge is narrowed to the nested keys that
+ * moved, and everything else is carried whole. `null` when nothing changed.
+ *
+ * The narrowing is what lets two sides edit one object at once without either
+ * clobbering the other — whatever is not sent cannot be overwritten — so it has
+ * to line up with how `applyState` writes, exactly. Both ask `mergesNested`.
+ * A key it refuses, `_h`-prefixed ones included, crosses whole, so concurrent
+ * edits *inside* one of those still race; ordinary story state does not live
+ * there.
+ *
+ * Only keys `next` has are considered. A key `baseline` has and `next` does not
+ * is a removal, which `applyState` cannot express, so reporting it would produce
+ * a write that changes nothing — and, worse, one the baseline would go on
+ * reporting forever. Removals stay unmirrored, exactly as they were.
+ */
+export declare function diffState(baseline: any, next: any): Record<string, any> | null;
+/**
+ * Tracks the last state both sides of a sync agreed on.
+ *
+ * The syncs used to mirror whole state objects and coordinate with a boolean
+ * meaning "the next firing is my own echo, ignore it". That has two costs. An
+ * echo is only distinguishable from a genuine edit by counting firings, which
+ * is what made the flag load-bearing and fragile (#95). And a side that mirrors
+ * everything it holds also mirrors the keys it did *not* change, stale by one
+ * edit if the far side changed them in the same tick — so the second firing
+ * reverted the first side's edit and it was lost from both (#96).
+ *
+ * A baseline answers both. Ask it for what a side changed and it reports that
+ * side's own edits, never the far side's; an echo diffs to nothing and needs no
+ * flag to recognise, because it is not a change.
+ */
+export declare function createStateBaseline(): {
+    /**
+     * What `next` changed since both sides last agreed, or `null` for nothing.
+     * The changes count as agreed from here, so ask once per firing and mirror
+     * what you get.
+     */
+    take(next: any): Record<string, any> | null;
+    /**
+     * Take `changes` as agreed without reporting them.
+     *
+     * What a peer just sent is by definition something both sides now hold, and
+     * it must not come back the other way. Two sides sharing one baseline —
+     * `plugin-vue`, where both watchers run in one context — never need this,
+     * because `take` on either side records for both. Two sides holding a
+     * baseline each — the sandbox bridge, split across a `postMessage` — do:
+     * the receiver has to record what arrived, or its own watcher will read the
+     * applied write as a local edit and echo it straight back.
+     */
+    record(changes: any): void;
+};
 //# 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;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"}
+{"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;AA4BD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,UAAQ,WAiEnE;AA2BD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CA4B9E;AA4DD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB;IAI/B;;;;OAIG;eACQ,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI;IAU3C;;;;;;;;;;OAUG;oBACa,GAAG;EAItB"}

package/dist/state.js

@@ -72,13 +72,42 @@ export function isEquivalent(a, b, seen) {
     }
     return keys.every(key => Object.hasOwn(b, key) && isEquivalent(a[key], b[key], visited));
 }
+/**
+ * Whether a key's value is merged one level rather than replaced whole.
+ *
+ * One rule, stated once, because it has to hold in three places at once:
+ * `applyState` writes by it, `diffState` narrows by it — sending less than the
+ * whole object is only safe as far as the write will merge — and the baseline in
+ * `createStateBaseline` records by it. They drifted apart when it was three
+ * copies, and the `_h` clause was the one that went missing.
+ *
+ * `_h`-prefixed keys are never merged: the sandbox needs those replaced outright
+ * so a nested key the story dropped actually disappears.
+ *
+ * Both sides have to be objects worth merging. `existing` is loose about how it
+ * got its prototype, because a target may hold anything a story put there; the
+ * incoming value must be a plain object, because merging a primitive or an array
+ * into an object writes nothing useful — `for (const nested in 5)` iterates
+ * nothing at all, and the assignment is then skipped entirely.
+ */
+function mergesNested(key, existing, incoming) {
+    return !key.startsWith('_h')
+        && isPlainObject(incoming)
+        && existing != null
+        && typeof existing === 'object'
+        && !Array.isArray(existing);
+}
 /**
  * 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.
+ * The return value is what the syncs in `plugin-svelte` and the sandbox bridge
+ * use to decide whether to expect an echo. Each 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.
+ *
+ * `plugin-vue` no longer needs it: `createStateBaseline` recognises an echo by
+ * it not being a change, so there is no flag left to keep honest. The two are
+ * the same idea at different strengths, and the others can move across (#96).
  */
 export function applyState(target, state, override = false) {
     let wrote = false;
@@ -102,7 +131,7 @@ export function applyState(target, state, override = false) {
             continue;
         }
         // iframe sync needs to update properties without overriding them
-        if (!override && current && !key.startsWith('_h') && typeof current === 'object' && !Array.isArray(current)) {
+        if (!override && mergesNested(key, current, state[key])) {
             // 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
@@ -138,3 +167,160 @@ export function applyState(target, state, override = false) {
     }
     return wrote;
 }
+/**
+ * The nested keys of `after` that differ from `before`, or `null` for none.
+ *
+ * One level, and no deeper, because that is exactly how far `applyState` merges:
+ * it walks the keys of a nested object and assigns each, so a value handed to it
+ * at depth two is written whole. Narrow past that and the write lands the narrow
+ * subset *as* the object and takes its siblings with it.
+ *
+ * Whether a key gets here at all is `mergesNested`'s call, not this function's.
+ */
+function narrowState(before, after) {
+    let changes = null;
+    for (const key in after) {
+        if (Object.hasOwn(before, key) && isEquivalent(before[key], after[key])) {
+            continue;
+        }
+        changes ??= {};
+        changes[key] = after[key];
+    }
+    return changes;
+}
+/**
+ * The subset of `next` that differs from `baseline`, shaped so `applyState` can
+ * copy it faithfully: a key it will merge is narrowed to the nested keys that
+ * moved, and everything else is carried whole. `null` when nothing changed.
+ *
+ * The narrowing is what lets two sides edit one object at once without either
+ * clobbering the other — whatever is not sent cannot be overwritten — so it has
+ * to line up with how `applyState` writes, exactly. Both ask `mergesNested`.
+ * A key it refuses, `_h`-prefixed ones included, crosses whole, so concurrent
+ * edits *inside* one of those still race; ordinary story state does not live
+ * there.
+ *
+ * Only keys `next` has are considered. A key `baseline` has and `next` does not
+ * is a removal, which `applyState` cannot express, so reporting it would produce
+ * a write that changes nothing — and, worse, one the baseline would go on
+ * reporting forever. Removals stay unmirrored, exactly as they were.
+ */
+export function diffState(baseline, next) {
+    let changes = null;
+    for (const key in next) {
+        const before = baseline[key];
+        const after = next[key];
+        const known = Object.hasOwn(baseline, key);
+        if (known && isEquivalent(before, after)) {
+            continue;
+        }
+        let value = after;
+        if (known && mergesNested(key, before, after)) {
+            value = narrowState(before, after);
+            // Only a removal, then. Nothing to send.
+            if (value === null) {
+                continue;
+            }
+        }
+        changes ??= {};
+        changes[key] = value;
+    }
+    return changes;
+}
+/**
+ * A structural copy, narrow in exactly the way `isEquivalent` is: plain objects
+ * and arrays get fresh containers, everything else is carried by reference —
+ * which is right, because those are the values `isEquivalent` compares by
+ * `Object.is`, so a reference is the identity the comparison is about.
+ */
+function copyState(value, seen = new WeakMap()) {
+    if (!Array.isArray(value) && !isPlainObject(value)) {
+        return value;
+    }
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    const copy = Array.isArray(value) ? [] : {};
+    seen.set(value, copy);
+    for (const key in value) {
+        copy[key] = copyState(value[key], seen);
+    }
+    return copy;
+}
+/**
+ * Records `changes` — the shape `diffState` returns — into `baseline`, on the
+ * same terms `applyState` writes it: `mergesNested` decides, the one narrowed
+ * level is merged, everything under it taken whole. Keys the diff did not
+ * mention survive, which is what keeps a removal the far side could not mirror
+ * from being replayed.
+ *
+ * Getting that predicate wrong here is quiet and permanent. Merge an `_h` key
+ * that the write replaced and the baseline keeps a nested key the real state has
+ * dropped — it can never match again, so every later pass reports the same
+ * phantom change, forever.
+ *
+ * Copies on the way in. The same `changes` object goes to `applyState`, which
+ * assigns its values straight into a reactive state; sharing them would let a
+ * later write through that state's proxy mutate the baseline as well, and a
+ * baseline that tracks a live side reports every one of that side's edits as
+ * already agreed — which is to say, drops them.
+ */
+function recordState(baseline, changes) {
+    for (const key in changes) {
+        const value = changes[key];
+        if (mergesNested(key, baseline[key], value)) {
+            for (const nested in value) {
+                baseline[key][nested] = copyState(value[nested]);
+            }
+        }
+        else {
+            baseline[key] = copyState(value);
+        }
+    }
+}
+/**
+ * Tracks the last state both sides of a sync agreed on.
+ *
+ * The syncs used to mirror whole state objects and coordinate with a boolean
+ * meaning "the next firing is my own echo, ignore it". That has two costs. An
+ * echo is only distinguishable from a genuine edit by counting firings, which
+ * is what made the flag load-bearing and fragile (#95). And a side that mirrors
+ * everything it holds also mirrors the keys it did *not* change, stale by one
+ * edit if the far side changed them in the same tick — so the second firing
+ * reverted the first side's edit and it was lost from both (#96).
+ *
+ * A baseline answers both. Ask it for what a side changed and it reports that
+ * side's own edits, never the far side's; an echo diffs to nothing and needs no
+ * flag to recognise, because it is not a change.
+ */
+export function createStateBaseline() {
+    const baseline = {};
+    return {
+        /**
+         * What `next` changed since both sides last agreed, or `null` for nothing.
+         * The changes count as agreed from here, so ask once per firing and mirror
+         * what you get.
+         */
+        take(next) {
+            const changes = diffState(baseline, next);
+            if (changes) {
+                recordState(baseline, changes);
+            }
+            return changes;
+        },
+        /**
+         * Take `changes` as agreed without reporting them.
+         *
+         * What a peer just sent is by definition something both sides now hold, and
+         * it must not come back the other way. Two sides sharing one baseline —
+         * `plugin-vue`, where both watchers run in one context — never need this,
+         * because `take` on either side records for both. Two sides holding a
+         * baseline each — the sandbox bridge, split across a `postMessage` — do:
+         * the receiver has to record what arrived, or its own watcher will read the
+         * applied write as a local edit and echo it straight back.
+         */
+        record(changes) {
+            recordState(baseline, changes);
+        },
+    };
+}

package/dist/types/config.d.ts

@@ -42,6 +42,7 @@ export interface PovesteConfig {
     storyMatch: string[];
     /**
      * Glob patterns to ignore files while searching for story files.
+     * Added to the defaults (`node_modules`, `dist`), not a replacement for them.
      */
     storyIgnored: string[];
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EACV,UAAU,IAAI,UAAU,EACxB,SAAS,IAAI,aAAa,EAC3B,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5D,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,MAAM,CAAA;AACnD,MAAM,MAAM,SAAS,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AACpG,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,OAAO,CAAA;CAC5C;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,aAAa,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IACd;;OAEG;IACH,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB;;OAEG;IACH,YAAY,EAAE,mBAAmB,EAAE,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACvB;;OAEG;IACH,IAAI,EAAE;QACJ;;;;WAIG;QACH,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI,EAAE,cAAc,KAAK,MAAM,EAAE,CAAC,CAAA;QAC9D,KAAK,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,CAAA;QAClD,MAAM,CAAC,EAAE,eAAe,EAAE,CAAA;KAC3B,CAAA;IACD;;OAEG;IACH,KAAK,EAAE;QACL;;WAEG;QACH,KAAK,CAAC,EAAE,MAAM,CAAA;QACd;;;;WAIG;QACH,IAAI,CAAC,EAAE;YACL;;eAEG;YACH,MAAM,CAAC,EAAE,MAAM,CAAA;YACf;;eAEG;YACH,KAAK,CAAC,EAAE,MAAM,CAAA;YACd;;eAEG;YACH,IAAI,CAAC,EAAE,MAAM,CAAA;SACd,CAAA;QACD;;;;WAIG;QACH,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB;;;;;;WAMG;QACH,MAAM,CAAC,EAAE;aACN,GAAG,IAAI,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,MAAM,GAAG;iBAChD,GAAG,IAAI,aAAa,CAAC,CAAC,EAAE,MAAM;aAChC,GAAG;iBACD,GAAG,IAAI,SAAS,CAAC,CAAC,EAAE,MAAM;aAC5B;SACF,CAAA;QACD;;WAEG;QACH,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB;;WAEG;QACH,kBAAkB,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;QAC9C;;WAEG;QACH,qBAAqB,CAAC,EAAE,OAAO,CAAA;QAC/B;;WAEG;QACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;QAC1B;;WAEG;QACH,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,CAAA;IACD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG;QACnB;;WAEG;QACH,OAAO,EAAE,MAAM,CAAA;KAChB,GAAG;QACF;;WAEG;QACH,MAAM,EAAE,MAAM,CAAA;KACf,GAAG;QACF;;WAEG;QACH,OAAO,EAAE,MAAM,CAAA;QACf;;WAEG;QACH,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IACD;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB;;OAEG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACtC;;OAEG;IACH,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAA;IACtC;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,iBAAiB,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAA;IAC5E;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,UAAU,KAAK,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IAC/D;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,GAAG,MAAM,CAAA;IAC/B;;OAEG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,aAAa,KAAK,IAAI,GAAG,UAAU,GAAG,OAAO,CAAC,IAAI,GAAG,UAAU,CAAC,CAAC,CAAA;IAChH;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;OAEG;IACH,kBAAkB,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACxC;;OAEG;IACH,qBAAqB,CAAC,EAAE;QACtB;;;;;WAKG;QACH,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;QACd;;;;;;WAMG;QACH,GAAG,CAAC,EAAE,MAAM,EAAE,CAAA;KACf,CAAA;IACD;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAE;QACN;;;WAGG;QACH,uBAAuB,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;KAC9C,CAAA;CACF;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,KAAK,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/types/config.ts"],"names":[],"mappings":"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"}

package/dist/types/story.d.ts

@@ -13,10 +13,19 @@ export interface StoryFile {
 export type StoryLayout = {
     type: 'single';
     iframe?: boolean;
+    /**
+     * Give every render of this story a fresh sandbox document instead of
+     * reusing a warm one. Style isolation is the same either way; this is for
+     * stories that leave JS state behind — patched globals, leaked timers —
+     * that the next occupant of the realm must not see.
+     */
+    isolate?: boolean;
 } | {
     type: 'grid';
     width?: number | string;
     iframeGrid?: boolean;
+    /** See the single layout's `isolate`. */
+    isolate?: boolean;
 };
 export interface CommonProps {
     id?: string;

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

@@ -1 +1 @@
-{"version":3,"file":"story.d.ts","sourceRoot":"","sources":["../../src/types/story.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,eAAe,EAAE,MAAM,CAAA;IACvB,SAAS,EAAE,GAAG,CAAA;IACd,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,MAAM,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAC3C;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,GAAG;IACF,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAA;IACpC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED,MAAM,WAAW,YAAa,SAAQ,WAAW,EAAE,cAAc;CAEhE;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW,EAAE,cAAc;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,MAAM,WAAW,UAAU;CAAG;AAE9B,MAAM,WAAW,SAAU,SAAQ,UAAU;IAC3C;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,GAAG,CAAA;IACjB,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB;AAED,MAAM,WAAW,WAAY,SAAQ,UAAU;CAAG;AAElD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAA;IACpC,KAAK,CAAC,EAAE,MAAM;QAAE,OAAO,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,GAAG,CAAC;QAAC,MAAM,EAAE,GAAG,CAAA;KAAE,CAAA;IAC1D,KAAK,EAAE,GAAG,CAAA;IACV,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,IAAI,CAAC,EAAE,WAAW,CAAA;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,cAAc,EAAE,CAAA;CACxB;AAID,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB;;OAEG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;OAEG;IACH,YAAY,CAAC,EAAE,kBAAkB,CAAA;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,OAAO,CAAA;IACzB,WAAW,CAAC,EAAE,GAAG,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,SAAS,CAAA;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,WAAW,CAAA;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,CAAC,gBAAgB,GAAG,cAAc,CAAC,EAAE,CAAA;CAChD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,IAAI,CAAA;IACX,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,CAAC,gBAAgB,GAAG,cAAc,CAAC,EAAE,CAAA;CAChD;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,eAAe,GAAG,gBAAgB,GAAG,cAAc,CAAC,EAAE,CAAA;AAEhF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,eAAe,CAAA;IACrB,SAAS,EAAE,WAAW,EAAE,CAAA;IACxB,EAAE,EAAE,WAAW,CAAA;CAChB"}
+{"version":3,"file":"story.d.ts","sourceRoot":"","sources":["../../src/types/story.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@poveste/shared",
   "type": "module",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Shared utilities for Poveste",
   "author": {
     "name": "Sorin Gitlan"
@@ -34,7 +34,7 @@
     "pathe": "^1.1.2",
     "picocolors": "^1.1.1",
     "unhead": "^3.1.0",
-    "@poveste/vendors": "^0.5.3"
+    "@poveste/vendors": "^0.6.0"
   },
   "devDependencies": {
     "typescript": "5.6.3",

package/src/__tests__/state.spec.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { applyState, isEquivalent } from '../state.js'
+import { applyState, createStateBaseline, diffState, isEquivalent } from '../state.js'
 
 describe('isEquivalent', () => {
   it('compares primitives the way Vue decides whether to trigger', () => {
@@ -124,6 +124,21 @@ describe('applyState', () => {
     expect(target.nested).toEqual({ a: 1, b: 3 })
   })
 
+  it('replaces an object with a value it cannot merge into it', () => {
+    // The merge branch used to be chosen from the *target*'s type alone, so an
+    // incoming primitive met `for (const nested in 5)` — no iterations, nothing
+    // written, and the write silently dropped. A story swapping an object for a
+    // scalar is ordinary; a sync that records the write as done while the far
+    // side never got it then reverts that edit on the next pass.
+    const target: any = { config: { a: 1 }, list: { a: 1 } }
+
+    expect(applyState(target, { config: 5 })).toBe(true)
+    expect(target.config).toBe(5)
+
+    expect(applyState(target, { list: [1, 2] })).toBe(true)
+    expect(target.list).toEqual([1, 2])
+  })
+
   it('swallows writes to read-only properties', () => {
     const target: any = {}
     Object.defineProperty(target, 'ro', { get: () => 1, enumerable: true })
@@ -141,11 +156,12 @@ describe('applyState', () => {
   })
 })
 
-// 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.
+// `plugin-svelte` and the sandbox bridge hold a flag meaning "ignore the next
+// firing, it is the echo of my own write", and clear 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. (`plugin-vue` has since dropped
+// the flag for a baseline; see `createStateBaseline` below.)
 describe('applyState reporting whether it wrote', () => {
   it('reports a write', () => {
     expect(applyState({ a: 1 }, { a: 2 })).toBe(true)
@@ -187,3 +203,151 @@ describe('applyState reporting whether it wrote', () => {
     expect(applyState(target, { ro: 2 })).toBe(true)
   })
 })
+
+describe('diffState', () => {
+  it('reports nothing when the two match', () => {
+    expect(diffState({ a: 1 }, { a: 1 })).toBeNull()
+    expect(diffState({ nested: { a: 1 } }, { nested: { a: 1 } })).toBeNull()
+    expect(diffState({ list: [1, 2] }, { list: [1, 2] })).toBeNull()
+  })
+
+  it('reports only the keys that moved', () => {
+    expect(diffState({ a: 1, b: 2 }, { a: 1, b: 3 })).toEqual({ b: 3 })
+  })
+
+  it('reports a key the baseline has never seen', () => {
+    expect(diffState({}, { a: 1 })).toEqual({ a: 1 })
+    expect(diffState({}, { a: undefined })).toEqual({ a: undefined })
+  })
+
+  it('narrows a nested object to its own changed keys', () => {
+    // The point of the whole exercise: what is not sent cannot be clobbered, so
+    // the far side keeps its concurrent edit to `b`.
+    expect(diffState({ items: { a: 1, b: 2 } }, { items: { a: 9, b: 2 } })).toEqual({ items: { a: 9 } })
+  })
+
+  it('narrows one level and no further, which is as far as applyState merges', () => {
+    // `applyState` assigns what it finds at depth two, so a narrowed object there
+    // would land as the whole value and drop `y`.
+    expect(diffState({ deep: { inner: { x: 1, y: 2 } } }, { deep: { inner: { x: 9, y: 2 } } }))
+      .toEqual({ deep: { inner: { x: 9, y: 2 } } })
+  })
+
+  it('carries an `_h` key whole, because applyState replaces rather than merges it', () => {
+    // The sandbox bridge needs those replaced outright, so `applyState` sends
+    // them down the assignment branch. Narrowing one would empty it.
+    expect(diffState({ _hPropState: { a: 1, b: 2 } }, { _hPropState: { a: 9, b: 2 } }))
+      .toEqual({ _hPropState: { a: 9, b: 2 } })
+  })
+
+  it('carries an array whole', () => {
+    // `applyState` assigns arrays rather than merging them, so a partial one
+    // would be read as the entire new value.
+    expect(diffState({ list: [1, 2] }, { list: [1, 2, 3] })).toEqual({ list: [1, 2, 3] })
+  })
+
+  it('carries a value whole when the two sides are not both plain objects', () => {
+    expect(diffState({ a: 1 }, { a: { b: 2 } })).toEqual({ a: { b: 2 } })
+    expect(diffState({ a: { b: 2 } }, { a: 1 })).toEqual({ a: 1 })
+  })
+
+  it('ignores a removal, at any depth', () => {
+    // Deliberate, and the reason the baseline stays usable. `applyState` cannot
+    // express a removal, so reporting one produces a write that changes nothing
+    // — and one the baseline would go on reporting on every later pass.
+    expect(diffState({ a: 1, gone: 2 }, { a: 1 })).toBeNull()
+    expect(diffState({ items: { a: 1, gone: 2 } }, { items: { a: 1 } })).toBeNull()
+  })
+})
+
+describe('createStateBaseline', () => {
+  it('reports everything the first time, since it has agreed to nothing yet', () => {
+    const baseline = createStateBaseline()
+    expect(baseline.take({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 })
+  })
+
+  it('reports nothing for a repeat, which is what makes an echo recognisable', () => {
+    const baseline = createStateBaseline()
+    baseline.take({ a: 1 })
+    expect(baseline.take({ a: 1 })).toBeNull()
+  })
+
+  it('reports each side only its own change', () => {
+    // #96 in miniature. Both sides changed a different key in the same tick, so
+    // each holds one fresh value and one stale one — and is asked about the
+    // fresh one alone.
+    const baseline = createStateBaseline()
+    baseline.take({ a: 0, b: 0 })
+
+    expect(baseline.take({ a: 1, b: 0 })).toEqual({ a: 1 })
+    expect(baseline.take({ a: 1, b: 1 })).toEqual({ b: 1 })
+    expect(baseline.take({ a: 1, b: 1 })).toBeNull()
+  })
+
+  it('stops reporting an `_h` key once the far side holds the shrunk value', () => {
+    // `_h` keys are replaced whole rather than merged, so the baseline has to
+    // record them the same way. Merging instead leaves behind a nested key the
+    // real state has dropped, and the baseline can never match again — every
+    // later pass reports the same phantom change, forever. Every Vue story
+    // carries `_hPropState`, so "forever" means every story whose auto-props
+    // ever shrink.
+    const baseline = createStateBaseline()
+    baseline.take({ _hPropState: { a: 1, b: 2 } })
+
+    expect(baseline.take({ _hPropState: { a: 9 } })).toEqual({ _hPropState: { a: 9 } })
+    expect(baseline.take({ _hPropState: { a: 9 } })).toBeNull()
+  })
+
+  it('keeps a key the far side removed rather than replaying it', () => {
+    const baseline = createStateBaseline()
+    baseline.take({ a: 1, gone: 2 })
+
+    expect(baseline.take({ a: 1 })).toBeNull()
+    // Still agreed as far as the side that kept it is concerned, so it does not
+    // come back the next time that side is asked.
+    expect(baseline.take({ a: 1, gone: 2 })).toBeNull()
+  })
+
+  it('does not keep a reference to what it was handed', () => {
+    // The caller passes the same object on to `applyState`, which assigns it
+    // into a reactive state. Sharing it would let a later write land in the
+    // baseline too, and an edit the baseline already knows is an edit dropped.
+    const baseline = createStateBaseline()
+    const next: any = { list: [1, 2], nested: { a: 1 } }
+    baseline.take(next)
+
+    next.list.push(3)
+    next.nested.a = 9
+
+    expect(baseline.take({ list: [1, 2, 3], nested: { a: 9 } }))
+      .toEqual({ list: [1, 2, 3], nested: { a: 9 } })
+  })
+
+  it('survives a cyclic state', () => {
+    const baseline = createStateBaseline()
+    const next: any = { name: 'a' }
+    next.self = next
+
+    expect(() => baseline.take(next)).not.toThrow()
+    expect(baseline.take(next)).toBeNull()
+  })
+
+  it('survives a cyclic state that changes', () => {
+    // The harder half. `isEquivalent` short-circuits an unchanged cycle before
+    // the diff ever recurses; a changed one gets past it, and then meets the
+    // same pair on every lap.
+    const baseline = createStateBaseline()
+    const first: any = { name: 'a' }
+    first.self = first
+    baseline.take(first)
+
+    const second: any = { name: 'b' }
+    second.self = second
+
+    // `self.name` did genuinely move, so it is reported at that path too. The
+    // walk terminates because it stops after one level, not because a cycle is
+    // detected — below that the value is carried whole, cycle and all.
+    expect(baseline.take(second)).toEqual({ name: 'b', self: { name: 'b', self: second } })
+    expect(baseline.take(second)).toBeNull()
+  })
+})

package/src/state.ts

@@ -87,13 +87,43 @@ export function isEquivalent(a: any, b: any, seen?: WeakMap<object, WeakSet<obje
   return keys.every(key => Object.hasOwn(b, key) && isEquivalent(a[key], b[key], visited))
 }
 
+/**
+ * Whether a key's value is merged one level rather than replaced whole.
+ *
+ * One rule, stated once, because it has to hold in three places at once:
+ * `applyState` writes by it, `diffState` narrows by it — sending less than the
+ * whole object is only safe as far as the write will merge — and the baseline in
+ * `createStateBaseline` records by it. They drifted apart when it was three
+ * copies, and the `_h` clause was the one that went missing.
+ *
+ * `_h`-prefixed keys are never merged: the sandbox needs those replaced outright
+ * so a nested key the story dropped actually disappears.
+ *
+ * Both sides have to be objects worth merging. `existing` is loose about how it
+ * got its prototype, because a target may hold anything a story put there; the
+ * incoming value must be a plain object, because merging a primitive or an array
+ * into an object writes nothing useful — `for (const nested in 5)` iterates
+ * nothing at all, and the assignment is then skipped entirely.
+ */
+function mergesNested(key: string, existing: any, incoming: any) {
+  return !key.startsWith('_h')
+    && isPlainObject(incoming)
+    && existing != null
+    && typeof existing === 'object'
+    && !Array.isArray(existing)
+}
+
 /**
  * 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.
+ * The return value is what the syncs in `plugin-svelte` and the sandbox bridge
+ * use to decide whether to expect an echo. Each 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.
+ *
+ * `plugin-vue` no longer needs it: `createStateBaseline` recognises an echo by
+ * it not being a change, so there is no flag left to keep honest. The two are
+ * the same idea at different strengths, and the others can move across (#96).
  */
 export function applyState(target: any, state: any, override = false) {
   let wrote = false
@@ -120,7 +150,7 @@ export function applyState(target: any, state: any, override = false) {
     }
 
     // iframe sync needs to update properties without overriding them
-    if (!override && current && !key.startsWith('_h') && typeof current === 'object' && !Array.isArray(current)) {
+    if (!override && mergesNested(key, current, state[key])) {
       // 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
@@ -161,3 +191,184 @@ export function applyState(target: any, state: any, override = false) {
 
   return wrote
 }
+
+/**
+ * The nested keys of `after` that differ from `before`, or `null` for none.
+ *
+ * One level, and no deeper, because that is exactly how far `applyState` merges:
+ * it walks the keys of a nested object and assigns each, so a value handed to it
+ * at depth two is written whole. Narrow past that and the write lands the narrow
+ * subset *as* the object and takes its siblings with it.
+ *
+ * Whether a key gets here at all is `mergesNested`'s call, not this function's.
+ */
+function narrowState(before: any, after: any): Record<string, any> | null {
+  let changes: Record<string, any> | null = null
+
+  for (const key in after) {
+    if (Object.hasOwn(before, key) && isEquivalent(before[key], after[key])) {
+      continue
+    }
+
+    changes ??= {}
+    changes[key] = after[key]
+  }
+
+  return changes
+}
+
+/**
+ * The subset of `next` that differs from `baseline`, shaped so `applyState` can
+ * copy it faithfully: a key it will merge is narrowed to the nested keys that
+ * moved, and everything else is carried whole. `null` when nothing changed.
+ *
+ * The narrowing is what lets two sides edit one object at once without either
+ * clobbering the other — whatever is not sent cannot be overwritten — so it has
+ * to line up with how `applyState` writes, exactly. Both ask `mergesNested`.
+ * A key it refuses, `_h`-prefixed ones included, crosses whole, so concurrent
+ * edits *inside* one of those still race; ordinary story state does not live
+ * there.
+ *
+ * Only keys `next` has are considered. A key `baseline` has and `next` does not
+ * is a removal, which `applyState` cannot express, so reporting it would produce
+ * a write that changes nothing — and, worse, one the baseline would go on
+ * reporting forever. Removals stay unmirrored, exactly as they were.
+ */
+export function diffState(baseline: any, next: any): Record<string, any> | null {
+  let changes: Record<string, any> | null = null
+
+  for (const key in next) {
+    const before = baseline[key]
+    const after = next[key]
+    const known = Object.hasOwn(baseline, key)
+
+    if (known && isEquivalent(before, after)) {
+      continue
+    }
+
+    let value = after
+
+    if (known && mergesNested(key, before, after)) {
+      value = narrowState(before, after)
+
+      // Only a removal, then. Nothing to send.
+      if (value === null) {
+        continue
+      }
+    }
+
+    changes ??= {}
+    changes[key] = value
+  }
+
+  return changes
+}
+
+/**
+ * A structural copy, narrow in exactly the way `isEquivalent` is: plain objects
+ * and arrays get fresh containers, everything else is carried by reference —
+ * which is right, because those are the values `isEquivalent` compares by
+ * `Object.is`, so a reference is the identity the comparison is about.
+ */
+function copyState(value: any, seen = new WeakMap<object, any>()) {
+  if (!Array.isArray(value) && !isPlainObject(value)) {
+    return value
+  }
+
+  if (seen.has(value)) {
+    return seen.get(value)
+  }
+
+  const copy: any = Array.isArray(value) ? [] : {}
+  seen.set(value, copy)
+
+  for (const key in value) {
+    copy[key] = copyState(value[key], seen)
+  }
+
+  return copy
+}
+
+/**
+ * Records `changes` — the shape `diffState` returns — into `baseline`, on the
+ * same terms `applyState` writes it: `mergesNested` decides, the one narrowed
+ * level is merged, everything under it taken whole. Keys the diff did not
+ * mention survive, which is what keeps a removal the far side could not mirror
+ * from being replayed.
+ *
+ * Getting that predicate wrong here is quiet and permanent. Merge an `_h` key
+ * that the write replaced and the baseline keeps a nested key the real state has
+ * dropped — it can never match again, so every later pass reports the same
+ * phantom change, forever.
+ *
+ * Copies on the way in. The same `changes` object goes to `applyState`, which
+ * assigns its values straight into a reactive state; sharing them would let a
+ * later write through that state's proxy mutate the baseline as well, and a
+ * baseline that tracks a live side reports every one of that side's edits as
+ * already agreed — which is to say, drops them.
+ */
+function recordState(baseline: any, changes: any) {
+  for (const key in changes) {
+    const value = changes[key]
+
+    if (mergesNested(key, baseline[key], value)) {
+      for (const nested in value) {
+        baseline[key][nested] = copyState(value[nested])
+      }
+    }
+    else {
+      baseline[key] = copyState(value)
+    }
+  }
+}
+
+/**
+ * Tracks the last state both sides of a sync agreed on.
+ *
+ * The syncs used to mirror whole state objects and coordinate with a boolean
+ * meaning "the next firing is my own echo, ignore it". That has two costs. An
+ * echo is only distinguishable from a genuine edit by counting firings, which
+ * is what made the flag load-bearing and fragile (#95). And a side that mirrors
+ * everything it holds also mirrors the keys it did *not* change, stale by one
+ * edit if the far side changed them in the same tick — so the second firing
+ * reverted the first side's edit and it was lost from both (#96).
+ *
+ * A baseline answers both. Ask it for what a side changed and it reports that
+ * side's own edits, never the far side's; an echo diffs to nothing and needs no
+ * flag to recognise, because it is not a change.
+ */
+export function createStateBaseline() {
+  const baseline: Record<string, any> = {}
+
+  return {
+    /**
+     * What `next` changed since both sides last agreed, or `null` for nothing.
+     * The changes count as agreed from here, so ask once per firing and mirror
+     * what you get.
+     */
+    take(next: any): Record<string, any> | null {
+      const changes = diffState(baseline, next)
+
+      if (changes) {
+        recordState(baseline, changes)
+      }
+
+      return changes
+    },
+
+    /**
+     * Take `changes` as agreed without reporting them.
+     *
+     * What a peer just sent is by definition something both sides now hold, and
+     * it must not come back the other way. Two sides sharing one baseline —
+     * `plugin-vue`, where both watchers run in one context — never need this,
+     * because `take` on either side records for both. Two sides holding a
+     * baseline each — the sandbox bridge, split across a `postMessage` — do:
+     * the receiver has to record what arrived, or its own watcher will read the
+     * applied write as a local edit and echo it straight back.
+     */
+    record(changes: any) {
+      recordState(baseline, changes)
+    },
+  }
+}

package/src/types/config.ts

@@ -52,6 +52,7 @@ export interface PovesteConfig {
   storyMatch: string[]
   /**
    * Glob patterns to ignore files while searching for story files.
+   * Added to the defaults (`node_modules`, `dist`), not a replacement for them.
    */
   storyIgnored: string[]
   /**

package/src/types/story.ts

@@ -12,10 +12,19 @@ export interface StoryFile {
 export type StoryLayout = {
   type: 'single'
   iframe?: boolean
+  /**
+   * Give every render of this story a fresh sandbox document instead of
+   * reusing a warm one. Style isolation is the same either way; this is for
+   * stories that leave JS state behind — patched globals, leaked timers —
+   * that the next occupant of the realm must not see.
+   */
+  isolate?: boolean
 } | {
   type: 'grid'
   width?: number | string
   iframeGrid?: boolean
+  /** See the single layout's `isolate`. */
+  isolate?: boolean
 }
 
 export interface CommonProps {