@mmstack/primitives 22.2.2 → 22.4.0

package/fesm2022/mmstack-primitives.mjs

@@ -633,6 +633,38 @@ function provideForwardingTransitionScope() {
 function getTransitionScope(injector) {
     return injector.get(TRANSITION_SCOPE, null);
 }
+/**
+ * @internal Transaction-attributed pending for `startTransition`/`startTransaction`: like
+ * `scope.pending`, but loads already in flight when the tracker is created are NOT attributed —
+ * a pre-existing background load can neither settle the transaction early nor block its settle
+ * forever. A pre-existing flight is excluded only until it first settles; a later re-trigger of
+ * the same resource (e.g. the transaction's write changed its request) counts as the
+ * transaction's own work.
+ */
+function createAttributedPending(scope) {
+    const isInFlight = (ref) => {
+        const s = untracked(ref.status);
+        return s === 'loading' || s === 'reloading';
+    };
+    const preexisting = new Set(untracked(scope.resources).filter(isInFlight));
+    return computed(() => {
+        let pending = false;
+        for (const ref of scope.resources()) {
+            const s = ref.status();
+            const loading = s === 'loading' || s === 'reloading';
+            if (preexisting.has(ref)) {
+                // deletes are monotonic, so this stays sound under re-computation
+                if (loading)
+                    continue;
+                preexisting.delete(ref);
+                continue;
+            }
+            if (loading)
+                pending = true;
+        }
+        return pending;
+    });
+}
 /**
  * Returns a register function bound to the nearest transition scope: it adds a resource
  * to the scope and removes it when the caller's injection context is destroyed. Pass any
@@ -670,38 +702,43 @@ function registerResource(res, opt) {
 function injectStartTransition() {
     const scope = injectTransitionScope();
     const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
     const onServer = isPlatformServer(inject(PLATFORM_ID, { optional: true }) ?? 'browser');
     return (fn) => {
+        // attributed: loads already in flight when the transition starts are not ours —
+        // they can neither settle this transition early nor block it forever
+        const pending = createAttributedPending(scope);
         untracked(fn);
         let sawPending = false;
         const done = new Promise((resolve) => {
+            const settle = () => {
+                releaseDestroy();
+                watcher.destroy();
+                resolve();
+            };
             const watcher = effect(() => {
-                const p = scope.pending();
+                const p = pending();
                 if (p)
                     sawPending = true;
                 // settle: requests went in flight and then drained
-                if (sawPending && !p) {
-                    watcher.destroy();
-                    resolve();
-                }
+                if (sawPending && !p)
+                    settle();
             }, { ...(ngDevMode ? { debugName: "watcher" } : /* istanbul ignore next */ {}), injector });
+            // a destroy mid-flight kills the watcher — resolve so awaiters never hang
+            const releaseDestroy = destroyRef.onDestroy(settle);
             if (onServer) {
-                if (!untracked(scope.pending)) {
-                    watcher.destroy();
-                    resolve();
-                }
+                if (!untracked(pending))
+                    settle();
                 return;
             }
             // no-async fallback: once the reactive system has processed the writes (afterNextRender),
             // if nothing ever went in flight, the transition is already complete.
             afterNextRender(() => {
-                if (!sawPending && !untracked(scope.pending)) {
-                    watcher.destroy();
-                    resolve();
-                }
+                if (!sawPending && !untracked(pending))
+                    settle();
             }, { injector });
         });
-        return { pending: scope.pending, done };
+        return { pending, done };
     };
 }
 
@@ -774,8 +811,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.2", ngImpor
         }] });
 /**
  * Unscoped suspense boundary — **reads the ambient scope** instead of providing one. For cases where
- * the resources to coordinate are registered *above* the boundary (e.g. an app-builder page whose
- * manifests/connectors register at a higher injector), so the boundary observes that outer scope
+ * the resources to coordinate are registered *above* the boundary so the boundary observes that outer scope
  * rather than opening a fresh one. Pair with a `provideTransitionScope()` (or another boundary) in an
  * ancestor.
  */
@@ -840,9 +876,13 @@ function runInTransaction(txn, fn) {
 function injectStartTransaction() {
     const scope = injectTransitionScope();
     const injector = inject(Injector);
+    const destroyRef = inject(DestroyRef);
     const onServer = isPlatformServer(inject(PLATFORM_ID, { optional: true }) ?? 'browser');
     return (fn) => {
         const txn = createTransaction();
+        // attributed: loads already in flight when the transaction starts are not ours —
+        // they can neither commit this transaction early nor block its settle forever
+        const pending = createAttributedPending(scope);
         // Hold BEFORE the writes, so the display freezes at pre-transaction values.
         scope.beginHold();
         let finished = false;
@@ -859,6 +899,7 @@ function injectStartTransaction() {
             if (finished)
                 return;
             finished = true;
+            releaseDestroy();
             watcher?.destroy();
             if (restore)
                 txn.restore();
@@ -867,6 +908,10 @@ function injectStartTransaction() {
             scope.endHold();
             resolveDone();
         };
+        // The scope may outlive the calling context (a component transacting on an ancestor
+        // boundary): a destroy mid-flight kills the settle watcher, so without this the hold
+        // would leak and freeze the surviving scope forever. Keep the writes — they landed live.
+        const releaseDestroy = destroyRef.onDestroy(() => finish(false));
         try {
             runInTransaction(txn, fn);
         }
@@ -876,25 +921,25 @@ function injectStartTransaction() {
         }
         let sawPending = false;
         watcher = effect(() => {
-            const p = scope.pending();
+            const p = pending();
             if (p)
                 sawPending = true;
             if (sawPending && !p)
                 finish(false);
         }, { injector });
         if (onServer) {
-            if (!untracked(scope.pending))
+            if (!untracked(pending))
                 finish(false);
         }
         else {
             // no-async fallback: if nothing ever went in flight, settle once the writes are processed.
             afterNextRender(() => {
-                if (!sawPending && !untracked(scope.pending))
+                if (!sawPending && !untracked(pending))
                     finish(false);
             }, { injector });
         }
         return {
-            pending: scope.pending,
+            pending,
             done,
             abort: () => finish(true),
         };
@@ -2919,13 +2964,21 @@ const IDLE = {
     pointerId: null,
     modifiers: { shift: false, alt: false, ctrl: false, meta: false },
     button: -1,
+    pointerType: '',
+    origin: null,
+    cancelled: false,
 };
+/** Terminal state of an aborted gesture — same idle shape, `cancelled: true`. */
+const CANCELLED = { ...IDLE, cancelled: true };
 function stateEqual(a, b) {
     return (a.active === b.active &&
+        a.cancelled === b.cancelled &&
         a.pointerId === b.pointerId &&
         a.current.x === b.current.x &&
         a.current.y === b.current.y &&
         a.button === b.button &&
+        a.pointerType === b.pointerType &&
+        a.origin === b.origin &&
         a.modifiers.shift === b.modifiers.shift &&
         a.modifiers.alt === b.modifiers.alt &&
         a.modifiers.ctrl === b.modifiers.ctrl &&
@@ -2959,7 +3012,7 @@ function createPointerDrag(opt) {
         return base;
     }
     const hostRef = inject((ElementRef), { optional: true });
-    const { target = hostRef?.nativeElement, coordinateSpace = 'client', activationThreshold = 3, throttle = 16, handleSelector, buttons = [0], debugName = 'pointerDrag', } = opt ?? {};
+    const { target = hostRef?.nativeElement, coordinateSpace = 'client', activationThreshold = 3, throttle = 16, handleSelector, buttons = [0], stopPropagation = false, debugName = 'pointerDrag', } = opt ?? {};
     const resolve = (t) => {
         if (!t)
             return null;
@@ -2980,9 +3033,12 @@ function createPointerDrag(opt) {
         equal: stateEqual,
         debugName,
     });
+    const threshold2 = activationThreshold * activationThreshold;
     let startPoint = { x: 0, y: 0 };
     let activePointerId = null;
     let activeButton = -1;
+    let activePointerType = '';
+    let activeOrigin = null;
     let activated = false;
     let gesture = null;
     const coord = (e) => coordinateSpace === 'page'
@@ -2994,22 +3050,24 @@ function createPointerDrag(opt) {
         ctrl: e.ctrlKey,
         meta: e.metaKey,
     });
-    const end = () => {
+    const end = (cancelled = false) => {
         gesture?.abort();
         gesture = null;
         activePointerId = null;
         activeButton = -1;
+        activePointerType = '';
+        activeOrigin = null;
         activated = false;
-        state.set(IDLE);
-        state.flush(); // terminal transition: reflect IDLE now, not on the trailing edge
+        state.set(cancelled ? CANCELLED : IDLE);
+        state.flush(); // terminal transition: reflect idle now, not on the trailing edge
     };
     const onMove = (e) => {
         if (e.pointerId !== activePointerId)
             return;
         const current = coord(e);
         const delta = { x: current.x - startPoint.x, y: current.y - startPoint.y };
-        if (!activated && Math.hypot(delta.x, delta.y) >= activationThreshold) {
-            activated = true;
+        if (!activated && delta.x * delta.x + delta.y * delta.y >= threshold2) {
+            activated = true; // squared compare — no sqrt on the pre-activation path
         }
         state.set({
             active: activated,
@@ -3019,6 +3077,9 @@ function createPointerDrag(opt) {
             pointerId: activePointerId,
             modifiers: mods(e),
             button: activeButton, // pointermove button is -1; keep the down-button
+            pointerType: activePointerType,
+            origin: activeOrigin,
+            cancelled: false,
         });
     };
     const onUp = (e) => {
@@ -3027,22 +3088,28 @@ function createPointerDrag(opt) {
     };
     const onCancel = (e) => {
         if (e.pointerId === activePointerId)
-            end();
+            end(true);
     };
     const onKey = (e) => {
         if (e.key === 'Escape' && activePointerId !== null)
-            end();
+            end(true);
     };
     const onDown = (el) => (e) => {
         if (activePointerId !== null)
             return;
         if (!buttons.includes(e.button))
             return;
-        if (handleSelector && !e.target?.closest?.(handleSelector)) {
-            return;
-        }
+        const matched = handleSelector
+            ? e.target?.closest?.(handleSelector)
+            : el;
+        if (!matched)
+            return; // handleSelector set but pointerdown landed outside a handle
+        if (stopPropagation)
+            e.stopPropagation(); // claim it: an outer sensor won't also start
         activePointerId = e.pointerId;
         activeButton = e.button;
+        activePointerType = e.pointerType;
+        activeOrigin = matched;
         activated = false;
         startPoint = coord(e);
         try {
@@ -3068,6 +3135,9 @@ function createPointerDrag(opt) {
             pointerId: e.pointerId,
             modifiers: mods(e),
             button: e.button,
+            pointerType: activePointerType,
+            origin: activeOrigin,
+            cancelled: false,
         });
     };
     const attach = (el) => {
@@ -3077,7 +3147,7 @@ function createPointerDrag(opt) {
         });
         return () => {
             controller.abort();
-            end();
+            end(true); // teardown mid-gesture is an abort, not a drop
         };
     };
     if (isSignal(target)) {
@@ -3095,7 +3165,7 @@ function createPointerDrag(opt) {
     }
     const base = state.asReadonly();
     base.unthrottled = state.original;
-    base.cancel = end;
+    base.cancel = () => end(true);
     return base;
 }
 
@@ -3626,17 +3696,14 @@ function isLeaf(value) {
 
 const IS_STORE = Symbol('@mmstack/primitives::store/IS_STORE');
 const SCOPE_PARENT = Symbol('@mmstack/primitives::store/SCOPE_PARENT');
+const STORE_SHARED_GLOBALS = Symbol('@mmstack/primitives::store/STORE_SHARED_GLOBALS');
+const STORE_SHARED_OPTIONS = Symbol('@mmstack/primitives::store/STORE_SHARED_OPTIONS');
 /**
  * @internal Brand carrying a store's writability ('mutable' | 'writable' | 'readonly'), stamped
  * on every store proxy. Read by `extendStore` instead of re-deriving via `isWritableSignal`,
  * which would mis-classify a readonly scoped store (its backing `toWritable` still has a `set`).
  */
 const STORE_KIND = Symbol('@mmstack/primitives::store/STORE_KIND');
-/**
- * @internal Brand exposing the injector a store was built with, so `extendStore` inherits it the
- * same way `store.extend(...)` does (via closure) — no injection context needed at the call site.
- */
-const STORE_INJECTOR = Symbol('@mmstack/primitives::store/STORE_INJECTOR');
 const SIGNAL_FN_PROP = new Set([
     'set',
     'update',
@@ -3644,21 +3711,20 @@ const SIGNAL_FN_PROP = new Set([
     'inline',
     'asReadonly',
 ]);
-/**
- * @internal
- * Test-only handle on the proxy cache (deliberately NOT re-exported from the public barrel).
- * Maps a store's backing signal to its lazily-built child proxies, each held via a `WeakRef`.
- */
-const PROXY_CACHE = new WeakMap();
-/**
- * @internal
- * Test-only handle on the finalization registry (deliberately NOT re-exported from the public
- * barrel). Prunes a cache entry once its proxy is reclaimed by the GC.
- */
-const PROXY_CLEANUP = new FinalizationRegistry(({ target, prop }) => {
-    const storeCache = PROXY_CACHE.get(target);
-    if (storeCache)
-        storeCache.delete(prop);
+const PROXY_CACHE_TOKEN = new InjectionToken('@mmstack/primitives:store-proxy-cache', {
+    providedIn: 'root',
+    factory: () => new WeakMap(),
+});
+const PROXY_CLEANUP_TOKEN = new InjectionToken('@mmstack/primitives:store-proxy-cleanup', {
+    providedIn: 'root',
+    factory: () => {
+        const cache = inject(PROXY_CACHE_TOKEN);
+        return new FinalizationRegistry(({ target, prop }) => {
+            const store = cache.get(target);
+            if (store)
+                store.delete(prop);
+        });
+    },
 });
 /**
  * @internal
@@ -3675,11 +3741,11 @@ function isStore(value) {
  * holding it via a `WeakRef` and registering it for finalizer-driven cache pruning. The cache
  * is keyed per backing signal, so child identity is stable across repeat reads.
  */
-function getCachedChild(target, prop, build) {
-    let storeCache = PROXY_CACHE.get(target);
+function getCachedChild(target, prop, build, cache, cleanupRegistry) {
+    let storeCache = cache.get(target);
     if (!storeCache) {
         storeCache = new Map();
-        PROXY_CACHE.set(target, storeCache);
+        cache.set(target, storeCache);
     }
     const cachedRef = storeCache.get(prop);
     if (cachedRef) {
@@ -3687,42 +3753,47 @@ function getCachedChild(target, prop, build) {
         if (cached)
             return cached;
         storeCache.delete(prop);
-        PROXY_CLEANUP.unregister(cachedRef);
+        cleanupRegistry.unregister(cachedRef);
     }
     const proxy = build();
     const ref = new WeakRef(proxy);
     storeCache.set(prop, ref);
-    PROXY_CLEANUP.register(proxy, { target, prop }, ref);
+    cleanupRegistry.register(proxy, { target, prop }, ref);
     return proxy;
 }
+/**
+ * @internal Whether a mutable parent's child value must always re-notify: in-place mutation
+ * keeps an object child's reference stable, so `Object.is` would swallow the change. Decided
+ * per-VALUE (not snapshotted at build) so a union child that becomes an object later still
+ * propagates parent-level mutations.
+ */
+function mutableChildEqual(a, b) {
+    if (typeof a === 'object' && a !== null)
+        return false;
+    return Object.is(a, b);
+}
 /**
  * @internal Builds the derived child signal for `prop` and wraps it as an array/object substore.
- * A record parent reads the key directly; any other container goes through the fallback `from`/
- * `onChange` path. Shared verbatim by the array and object proxies — the only place a child node
- * is constructed.
+ * Both the read (`v?.[prop]`) and the write (`createFallbackOnChange` copies by the container's
+ * LIVE shape) are shape-adaptive, so a child cached before an array↔record↔null union flip stays
+ * correct after it. The only place a child node is constructed — shared by every container kind.
  */
-function buildChildNode(target, prop, isMutableSource, injector, vivify, noUnionLeaves) {
+function buildChildNode(target, prop, isMutableSource, options) {
     const value = untracked(target);
-    const valueIsRecord = isRecord(value);
-    const valueIsArray = Array.isArray(value);
-    const nodeVivify = resolveVivify(value, vivify);
+    const nodeVivify = resolveVivify(value, options.vivify);
     const vivifyFn = createVivify(nodeVivify);
-    const equalFn = (valueIsRecord || valueIsArray) &&
-        isMutableSource &&
-        typeof value[prop] === 'object'
-        ? () => false
+    const equalFn = isMutableSource && (isRecord(value) || Array.isArray(value))
+        ? mutableChildEqual
         : undefined;
-    const computation = valueIsRecord
-        ? derived(target, prop, { equal: equalFn, vivify: nodeVivify })
-        : derived(target, {
-            from: (v) => v?.[prop],
-            onChange: createFallbackOnChange(target, prop, vivifyFn, isMutableSource),
-            equal: equalFn,
-        });
+    const computation = derived(target, {
+        from: (v) => v?.[prop],
+        onChange: createFallbackOnChange(target, prop, vivifyFn, isMutableSource),
+        equal: equalFn,
+    });
     const childSample = untracked(computation);
-    const childVivify = resolveVivify(childSample, vivify);
-    const proxy = toStore(computation, injector, childVivify, noUnionLeaves);
-    markAsLeaf(proxy, computation, childVivify !== false, noUnionLeaves);
+    const childVivify = resolveVivify(childSample, options.vivify);
+    const proxy = toStore(computation, options);
+    markAsLeaf(proxy, computation, childVivify !== false, options.noUnionLeaves);
     return proxy;
 }
 /**
@@ -3740,7 +3811,7 @@ function buildChildNode(target, prop, isMutableSource, injector, vivify, noUnion
  * const state = store({ user: { name: 'John' } });
  * const nameSignal = state.user.name; // WritableSignal<string>
  */
-function toStore(source, injector, vivify = false, noUnionLeaves = false) {
+function toStore(source, { injector, vivify = false, noUnionLeaves = false, ...rest } = {}) {
     if (isStore(source))
         return source;
     if (!injector)
@@ -3761,6 +3832,16 @@ function toStore(source, injector, vivify = false, noUnionLeaves = false) {
         return 'primitive';
     }, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "kind" }] : /* istanbul ignore next */ []));
+    const STORE_OPTIONS = {
+        injector,
+        vivify,
+        noUnionLeaves,
+        [STORE_SHARED_GLOBALS]: {
+            cache: rest[STORE_SHARED_GLOBALS]?.cache ?? injector.get(PROXY_CACHE_TOKEN),
+            registry: rest[STORE_SHARED_GLOBALS]?.registry ??
+                injector.get(PROXY_CLEANUP_TOKEN),
+        },
+    };
     // built lazily so non-array nodes never allocate it
     let length;
     const arrayLength = () => (length ??= computed(() => {
@@ -3814,21 +3895,23 @@ function toStore(source, injector, vivify = false, noUnionLeaves = false) {
             return { enumerable: true, configurable: true };
         },
         get(target, prop, receiver) {
-            if (prop === IS_STORE)
-                return true;
-            if (prop === STORE_KIND)
-                return isMutableSource
-                    ? 'mutable'
-                    : isWritableSource
-                        ? 'writable'
-                        : 'readonly';
-            if (prop === STORE_INJECTOR)
-                return injector;
+            if (typeof prop === 'symbol') {
+                if (prop === IS_STORE)
+                    return true;
+                if (prop === STORE_KIND)
+                    return isMutableSource
+                        ? 'mutable'
+                        : isWritableSource
+                            ? 'writable'
+                            : 'readonly';
+                if (prop === STORE_SHARED_OPTIONS)
+                    return STORE_OPTIONS;
+            }
             if (prop === 'asReadonlyStore')
                 return () => {
                     if (!isWritableSource)
                         return s;
-                    return untracked(() => toStore(source.asReadonly(), injector, vivify, noUnionLeaves));
+                    return untracked(() => toStore(source.asReadonly(), { injector, vivify, noUnionLeaves }));
                 };
             const k = untracked(kind);
             if (prop === 'extend' && k !== 'array')
@@ -3836,7 +3919,7 @@ function toStore(source, injector, vivify = false, noUnionLeaves = false) {
                     ? 'mutable'
                     : isWritableSource
                         ? 'writable'
-                        : 'readonly', injector);
+                        : 'readonly', STORE_OPTIONS);
             if (k === 'array') {
                 if (prop === 'length')
                     return arrayLength();
@@ -3853,7 +3936,7 @@ function toStore(source, injector, vivify = false, noUnionLeaves = false) {
                 return target[prop];
             if (k === 'array' && !isIndexProp(prop))
                 return Reflect.get(target, prop, receiver);
-            return getCachedChild(target, prop, () => buildChildNode(target, k === 'array' ? +prop : prop, isMutableSource, injector, vivify, noUnionLeaves));
+            return getCachedChild(target, prop, () => buildChildNode(target, k === 'array' ? +prop : prop, isMutableSource, STORE_OPTIONS), STORE_OPTIONS[STORE_SHARED_GLOBALS].cache, STORE_OPTIONS[STORE_SHARED_GLOBALS].registry);
         },
     });
     return s;
@@ -3867,14 +3950,14 @@ function toStore(source, injector, vivify = false, noUnionLeaves = false) {
  * identity + two-way), while local keys never propagate upward. A merged `computed` is derived
  * only for whole-object reads / `has` / iteration — never for routing.
  */
-function scopedStore(parent, seed, kind, injector) {
+function scopedStore(parent, seed, kind, options) {
     const local = isSignal(seed)
-        ? toStore(seed, injector)
+        ? toStore(seed, options)
         : kind === 'mutable'
-            ? mutableStore(seed, { injector })
+            ? mutableStore(seed, options)
             : kind === 'readonly'
-                ? store(seed, { injector }).asReadonlyStore()
-                : store(seed, { injector });
+                ? store(seed, options).asReadonlyStore()
+                : store(seed, options);
     const localValue = () => untracked(local);
     const parentValue = () => untracked(parent);
     const view = computed(() => ({
@@ -3906,18 +3989,20 @@ function scopedStore(parent, seed, kind, injector) {
     }
     const scope = new Proxy(base, {
         get(target, prop) {
-            if (prop === IS_STORE)
-                return true;
-            if (prop === STORE_KIND)
-                return kind;
-            if (prop === STORE_INJECTOR)
-                return injector;
-            if (prop === SCOPE_PARENT)
-                return parent;
+            if (typeof prop === 'symbol') {
+                if (prop === IS_STORE)
+                    return true;
+                if (prop === STORE_KIND)
+                    return kind;
+                if (prop === SCOPE_PARENT)
+                    return parent;
+                if (prop === STORE_SHARED_OPTIONS)
+                    return options;
+            }
             if (prop === 'extend')
-                return (childSeed) => scopedStore(scope, childSeed, kind, injector);
+                return (childSeed) => scopedStore(scope, childSeed, kind, options);
             if (prop === 'asReadonlyStore')
-                return () => toStore(computed(() => ({ ...parent(), ...local() })), injector);
+                return () => toStore(computed(() => ({ ...parent(), ...local() })), options);
             if (typeof prop === 'symbol' || SIGNAL_FN_PROP.has(prop))
                 return target[prop];
             // Route by consulting both signals: local first, then parent, else local (new → local).
@@ -3963,22 +4048,34 @@ function storeKind(s) {
  * scoped.count.set(1); // writes through to base
  * scoped.label.set('x'); // stays local
  */
-function extendStore(store, source, injector) {
-    return scopedStore(store, source, storeKind(store), injector ?? store[STORE_INJECTOR] ?? inject(Injector));
+function extendStore(store, source, options) {
+    const opt = {
+        ...store[STORE_SHARED_OPTIONS],
+        ...options,
+    };
+    return scopedStore(store, source, storeKind(store), opt);
 }
 /**
  * Creates a WritableSignalStore from a value.
  * @see {@link toStore}
  */
 function store(value, opt) {
-    return toStore(signal(value, opt), opt?.injector, opt?.vivify ?? false, opt?.noUnionLeaves ?? false);
+    return toStore(signal(value, opt), {
+        vivify: false,
+        noUnionLeaves: false,
+        ...opt,
+    });
 }
 /**
  * Creates a MutableSignalStore from a value.
  * @see {@link toStore}
  */
 function mutableStore(value, opt) {
-    return toStore(mutable(value, opt), opt?.injector, opt?.vivify ?? false, opt?.noUnionLeaves ?? false);
+    return toStore(mutable(value, opt), {
+        vivify: false,
+        noUnionLeaves: false,
+        ...opt,
+    });
 }
 
 function isPlainRecord(value) {
@@ -4040,7 +4137,13 @@ function forkStore(base, opt) {
     const merge = reconcile;
     const staged = linkedSignal({ ...(ngDevMode ? { debugName: "staged" } : /* istanbul ignore next */ {}), source: () => base(),
         computation: (theirs, prev) => prev === undefined ? theirs : merge(prev.source, prev.value, theirs) });
-    const store = toStore(staged, opt?.injector, opt?.vivify, opt?.noUnionLeaves);
+    // Inherit the base's shared options (injector, vivify, noUnionLeaves + the
+    // proxy cache/registry), same as extendStore — a fork should vivify like its
+    // base and share its injector-scoped cache. `opt` overrides (advanced use).
+    const store = toStore(staged, {
+        ...base[STORE_SHARED_OPTIONS],
+        ...opt,
+    });
     return {
         store,
         commit: () => base.set(untracked(staged)),
@@ -4576,5 +4679,5 @@ function withHistory(sourceOrValue, opt) {
  * Generated bundle index. Do not edit.
  */
 
-export { MmActivity, PAUSABLE_OPTIONS, SuspenseBoundary, SuspenseBoundaryBase, UnscopedSuspenseBoundary, activeTransaction, batteryStatus, chunked, clipboard, combineWith, createForwardingScope, createTransaction, createTransitionScope, debounce, debounced, derived, distinct, elementSize, elementVisibility, extendStore, filter, filterWith, focusWithin, forkStore, geolocation, getTransitionScope, holdUntilReady, idle, indexArray, injectPaused, injectRegisterResource, injectStartTransaction, injectStartTransition, injectTransitionScope, isDerivation, isLeaf, isMutable, isOpaque, isStore, keepPrevious, keyArray, map, mapArray, mapObject, mediaQuery, merge3, mousePosition, mutable, mutableStore, nestedEffect, networkStatus, opaque, orientation, pageVisibility, pairwise, pausableComputed, pausableEffect, pausableSignal, pipeable, piped, pointerDrag, pooled, pooledArray, pooledMap, pooledSet, prefersDarkMode, prefersReducedMotion, provideForwardingTransitionScope, providePausableOptions, providePaused, provideTransitionScope, registerResource, resolvePause, scan, scrollPosition, select, sensor, sensors, signalFromEvent, startWith, store, stored, tabSync, tap, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toStore, toWritable, until, windowSize, withHistory };
+export { MmActivity, PAUSABLE_OPTIONS, SuspenseBoundary, SuspenseBoundaryBase, UnscopedSuspenseBoundary, activeTransaction, batteryStatus, chunked, clipboard, combineWith, createAttributedPending, createForwardingScope, createTransaction, createTransitionScope, debounce, debounced, derived, distinct, elementSize, elementVisibility, extendStore, filter, filterWith, focusWithin, forkStore, geolocation, getTransitionScope, holdUntilReady, idle, indexArray, injectPaused, injectRegisterResource, injectStartTransaction, injectStartTransition, injectTransitionScope, isDerivation, isLeaf, isMutable, isOpaque, isStore, keepPrevious, keyArray, map, mapArray, mapObject, mediaQuery, merge3, mousePosition, mutable, mutableStore, nestedEffect, networkStatus, opaque, orientation, pageVisibility, pairwise, pausableComputed, pausableEffect, pausableSignal, pipeable, piped, pointerDrag, pooled, pooledArray, pooledMap, pooledSet, prefersDarkMode, prefersReducedMotion, provideForwardingTransitionScope, providePausableOptions, providePaused, provideTransitionScope, registerResource, resolvePause, scan, scrollPosition, select, sensor, sensors, signalFromEvent, startWith, store, stored, tabSync, tap, throttle, throttled, toFakeDerivation, toFakeSignalDerivation, toStore, toWritable, until, windowSize, withHistory };
 //# sourceMappingURL=mmstack-primitives.mjs.map