@rlabs-inc/signals 1.2.1 → 1.4.0

package/dist/index.mjs

@@ -63,6 +63,9 @@ var UNINITIALIZED = Symbol.for("rlabs.signals.uninitialized");
 var STALE_REACTION = Symbol.for("rlabs.signals.stale_reaction");
 var STATE_SYMBOL = Symbol.for("rlabs.signals.state");
 var REACTIVE_MARKER = Symbol.for("rlabs.signals.reactive");
+var BINDING_SYMBOL = Symbol.for("rlabs.signals.binding");
+var LINKED_SYMBOL = Symbol.for("rlabs.signals.linked");
+var SOURCE = 1 << 0;
 var STATUS_MASK = ~(DIRTY | MAYBE_DIRTY | CLEAN);
 
 // src/core/globals.ts
@@ -187,6 +190,9 @@ function setUpdateEffectImpl(impl) {
 function flushEffects() {
   const roots = clearQueuedRootEffects();
   for (const root of roots) {
+    if ((root.f & INERT) !== 0) {
+      continue;
+    }
     if (isDirty(root)) {
       updateEffectImpl(root);
     }
@@ -197,7 +203,7 @@ function processEffectTree(effect) {
   let child = effect.first;
   while (child !== null) {
     const next = child.next;
-    if (isDirty(child)) {
+    if ((child.f & INERT) === 0 && isDirty(child)) {
       updateEffectImpl(child);
     }
     if (child.first !== null) {
@@ -210,6 +216,9 @@ function flushPendingReactions() {
   const reactions = [...pendingReactions];
   clearPendingReactions();
   for (const reaction of reactions) {
+    if ((reaction.f & INERT) !== 0) {
+      continue;
+    }
     if (isDirty(reaction)) {
       if ("parent" in reaction) {
         updateEffectImpl(reaction);
@@ -241,6 +250,9 @@ function flushSync(fn) {
         continue;
       }
       for (const root of roots) {
+        if ((root.f & INERT) !== 0) {
+          continue;
+        }
         if (isDirty(root)) {
           updateEffectImpl(root);
         }
@@ -287,13 +299,63 @@ function get(signal) {
     }
   }
   if ((signal.f & DERIVED) !== 0) {
-    const derived = signal;
-    if (isDirty(derived)) {
-      updateDerived(derived);
-    }
+    updateDerivedChain(signal);
   }
   return signal.v;
 }
+var updateCycleId = 0;
+var processedInCycle = new WeakMap;
+function updateDerivedChain(target) {
+  if ((target.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+    return;
+  }
+  const cycleId = ++updateCycleId;
+  const chain = [target];
+  processedInCycle.set(target, cycleId);
+  let idx = 0;
+  while (idx < chain.length) {
+    const current = chain[idx];
+    idx++;
+    if ((current.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+      continue;
+    }
+    const deps = current.deps;
+    if (deps !== null) {
+      for (let i = 0;i < deps.length; i++) {
+        const dep = deps[i];
+        if ((dep.f & DERIVED) !== 0 && (dep.f & (DIRTY | MAYBE_DIRTY)) !== 0 && processedInCycle.get(dep) !== cycleId) {
+          chain.push(dep);
+          processedInCycle.set(dep, cycleId);
+        }
+      }
+    }
+  }
+  for (let i = chain.length - 1;i >= 0; i--) {
+    const current = chain[i];
+    if ((current.f & (DIRTY | MAYBE_DIRTY)) === 0) {
+      continue;
+    }
+    if ((current.f & DIRTY) !== 0) {
+      updateDerived(current);
+    } else {
+      const deps = current.deps;
+      let needsUpdate = false;
+      if (deps !== null) {
+        for (let j = 0;j < deps.length; j++) {
+          if (deps[j].wv > current.wv) {
+            needsUpdate = true;
+            break;
+          }
+        }
+      }
+      if (needsUpdate) {
+        updateDerived(current);
+      } else {
+        setSignalStatus(current, CLEAN);
+      }
+    }
+  }
+}
 function set(signal, value) {
   if (activeReaction !== null && (activeReaction.f & DERIVED) !== 0) {
     throw new Error("Cannot write to signals inside a derived. " + "Deriveds should be pure computations with no side effects.");
@@ -309,20 +371,24 @@ function set(signal, value) {
   return value;
 }
 function markReactions(signal, status) {
-  const reactions = signal.reactions;
-  if (reactions === null)
-    return;
-  for (let i = 0;i < reactions.length; i++) {
-    const reaction = reactions[i];
-    const flags = reaction.f;
-    const notDirty = (flags & DIRTY) === 0;
-    if (notDirty) {
-      setSignalStatus(reaction, status);
-    }
-    if ((flags & DERIVED) !== 0) {
-      markReactions(reaction, MAYBE_DIRTY);
-    } else if (notDirty) {
-      scheduleEffect(reaction);
+  const stack = [{ signal, status }];
+  while (stack.length > 0) {
+    const { signal: currentSignal, status: currentStatus } = stack.pop();
+    const reactions = currentSignal.reactions;
+    if (reactions === null)
+      continue;
+    for (let i = 0;i < reactions.length; i++) {
+      const reaction = reactions[i];
+      const flags = reaction.f;
+      const notDirty = (flags & DIRTY) === 0;
+      if (notDirty) {
+        setSignalStatus(reaction, currentStatus);
+      }
+      if ((flags & DERIVED) !== 0) {
+        stack.push({ signal: reaction, status: MAYBE_DIRTY });
+      } else if (notDirty) {
+        scheduleEffect(reaction);
+      }
     }
   }
 }
@@ -333,22 +399,66 @@ function isDirty(reaction) {
   if ((reaction.f & DIRTY) !== 0) {
     return true;
   }
-  if ((reaction.f & MAYBE_DIRTY) !== 0) {
-    const deps = reaction.deps;
-    if (deps !== null) {
-      for (let i = 0;i < deps.length; i++) {
-        const dep = deps[i];
-        if ((dep.f & DERIVED) !== 0) {
-          if (isDirty(dep)) {
-            updateDerived(dep);
-          }
+  if ((reaction.f & MAYBE_DIRTY) === 0) {
+    return false;
+  }
+  const toCheck = [reaction];
+  const toUpdate = [];
+  let idx = 0;
+  while (idx < toCheck.length) {
+    const current = toCheck[idx];
+    idx++;
+    if ((current.f & DIRTY) !== 0) {
+      continue;
+    }
+    if ((current.f & MAYBE_DIRTY) === 0) {
+      continue;
+    }
+    const deps2 = current.deps;
+    if (deps2 !== null) {
+      for (let i = 0;i < deps2.length; i++) {
+        const dep = deps2[i];
+        if ((dep.f & DERIVED) !== 0 && (dep.f & (DIRTY | MAYBE_DIRTY)) !== 0) {
+          toCheck.push(dep);
         }
-        if (dep.wv > reaction.wv) {
-          return true;
+      }
+    }
+  }
+  for (let i = toCheck.length - 1;i >= 0; i--) {
+    const current = toCheck[i];
+    if ((current.f & DERIVED) === 0) {
+      continue;
+    }
+    if ((current.f & DIRTY) !== 0) {
+      updateDerived(current);
+    } else if ((current.f & MAYBE_DIRTY) !== 0) {
+      const deps2 = current.deps;
+      let needsUpdate = false;
+      if (deps2 !== null) {
+        for (let j = 0;j < deps2.length; j++) {
+          if (deps2[j].wv > current.wv) {
+            needsUpdate = true;
+            break;
+          }
         }
       }
+      if (needsUpdate) {
+        updateDerived(current);
+      } else {
+        setSignalStatus(current, CLEAN);
+      }
+    }
+  }
+  if ((reaction.f & DIRTY) !== 0) {
+    return true;
+  }
+  const deps = reaction.deps;
+  if (deps !== null) {
+    for (let i = 0;i < deps.length; i++) {
+      if (deps[i].wv > reaction.wv) {
+        return true;
+      }
     }
-    setSignalStatus(reaction, CLEAN);
   }
   return false;
 }
@@ -452,6 +562,7 @@ function updateReaction(reaction) {
 }
 
 // src/primitives/signal.ts
+var SOURCE_SYMBOL = Symbol("signal.source");
 function source(initialValue, options) {
   return {
     f: 0,
@@ -465,9 +576,13 @@ function source(initialValue, options) {
 function mutableSource(initialValue) {
   return source(initialValue, { equals: safeEquals });
 }
+var signalCleanup = new FinalizationRegistry((src) => {
+  src.reactions = null;
+});
 function signal(initialValue, options) {
   const src = source(initialValue, options);
-  return {
+  const sig = {
+    [SOURCE_SYMBOL]: src,
     get value() {
       return get(src);
     },
@@ -475,6 +590,11 @@ function signal(initialValue, options) {
       set(src, newValue);
     }
   };
+  signalCleanup.register(sig, src);
+  return sig;
+}
+function getSource(sig) {
+  return sig[SOURCE_SYMBOL];
 }
 var proxyFn = null;
 function setProxyFn(fn) {
@@ -491,10 +611,21 @@ function stateRaw(initialValue) {
 }
 
 // src/deep/proxy.ts
+var proxyCache = new WeakMap;
+var proxyCleanup = new FinalizationRegistry((data) => {
+  data.version.reactions = null;
+  for (const src of data.sources.values()) {
+    src.reactions = null;
+  }
+  data.sources.clear();
+});
 function shouldProxy(value) {
   if (value === null || typeof value !== "object") {
     return false;
   }
+  if (BINDING_SYMBOL in value) {
+    return false;
+  }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === Array.prototype || proto === null;
 }
@@ -509,6 +640,10 @@ function proxy(value) {
   if (!shouldProxy(value) || isProxy(value)) {
     return value;
   }
+  const cached = proxyCache.get(value);
+  if (cached) {
+    return cached;
+  }
   const sources = new Map;
   const version = source(0);
   const isArray = Array.isArray(value);
@@ -528,7 +663,7 @@ function proxy(value) {
       setActiveReaction(prevReaction);
     }
   };
-  const getSource = (prop, initialValue) => {
+  const getSource2 = (prop, initialValue) => {
     let s = sources.get(prop);
     if (s === undefined) {
       s = withParent(() => {
@@ -551,7 +686,7 @@ function proxy(value) {
         return currentValue.bind(proxyObj);
       }
       if (exists || isWritable(target, prop)) {
-        const s = getSource(prop, currentValue);
+        const s = getSource2(prop, currentValue);
         const val = get(s);
         if (val === UNINITIALIZED) {
           return;
@@ -560,7 +695,7 @@ function proxy(value) {
       }
       return currentValue;
     },
-    set(target, prop, newValue, receiver) {
+    set(target, prop, newValue) {
       const exists = prop in target;
       let s = sources.get(prop);
       if (s === undefined) {
@@ -570,29 +705,35 @@ function proxy(value) {
         s = withParent(() => source(undefined));
         sources.set(prop, s);
       }
-      const proxied = withParent(() => shouldProxy(newValue) ? proxy(newValue) : newValue);
+      let proxied;
+      if (shouldProxy(newValue)) {
+        proxied = withParent(() => proxy(newValue));
+      } else {
+        proxied = newValue;
+      }
       set(s, proxied);
-      Reflect.set(target, prop, newValue, receiver);
-      if (isArray && prop === "length") {
-        const oldLength = s.v;
-        const newLength = newValue;
-        for (let i = newLength;i < oldLength; i++) {
-          const indexKey = String(i);
-          const indexSource = sources.get(indexKey);
-          if (indexSource !== undefined) {
-            set(indexSource, UNINITIALIZED);
-          } else if (i in target) {
-            const deletedSource = withParent(() => source(UNINITIALIZED));
-            sources.set(indexKey, deletedSource);
+      target[prop] = newValue;
+      if (isArray) {
+        if (prop === "length") {
+          const oldLength = s.v;
+          const newLength = newValue;
+          for (let i = newLength;i < oldLength; i++) {
+            const indexKey = String(i);
+            const indexSource = sources.get(indexKey);
+            if (indexSource !== undefined) {
+              set(indexSource, UNINITIALIZED);
+            } else if (i in target) {
+              const deletedSource = withParent(() => source(UNINITIALIZED));
+              sources.set(indexKey, deletedSource);
+            }
           }
-        }
-      }
-      if (isArray && typeof prop === "string") {
-        const index = Number(prop);
-        if (Number.isInteger(index) && index >= 0) {
-          const lengthSource = sources.get("length");
-          if (lengthSource !== undefined && index >= lengthSource.v) {
-            set(lengthSource, index + 1);
+        } else if (typeof prop === "string") {
+          const index = Number(prop);
+          if (Number.isInteger(index) && index >= 0) {
+            const lengthSource = sources.get("length");
+            if (lengthSource !== undefined && index >= lengthSource.v) {
+              set(lengthSource, index + 1);
+            }
           }
         }
       }
@@ -613,7 +754,7 @@ function proxy(value) {
         }
         set(version, get(version) + 1);
       }
-      return Reflect.deleteProperty(target, prop);
+      return delete target[prop];
     },
     has(target, prop) {
       if (prop === STATE_SYMBOL) {
@@ -651,6 +792,8 @@ function proxy(value) {
       return Reflect.getOwnPropertyDescriptor(target, prop);
     }
   });
+  proxyCleanup.register(proxyObj, { sources, version });
+  proxyCache.set(value, proxyObj);
   return proxyObj;
 }
 function toRaw(value) {
@@ -663,6 +806,18 @@ function isReactive(value) {
   return isProxy(value);
 }
 // src/primitives/derived.ts
+var derivedCleanup = new FinalizationRegistry((d) => {
+  removeReactions(d, 0);
+  d.deps = null;
+  d.reactions = null;
+  const effects = d.effects;
+  if (effects !== null) {
+    d.effects = null;
+    for (let i = 0;i < effects.length; i++) {
+      destroyEffectImpl(effects[i]);
+    }
+  }
+});
 function createDerived(fn, options) {
   let flags = DERIVED | DIRTY;
   const parentDerived = activeReaction !== null && (activeReaction.f & DERIVED) !== 0 ? activeReaction : null;
@@ -713,11 +868,13 @@ function destroyDerivedEffects(derived) {
 }
 function derived(fn, options) {
   const d = createDerived(fn, options);
-  return {
+  const wrapper = {
     get value() {
       return get(d);
     }
   };
+  derivedCleanup.register(wrapper, d);
+  return wrapper;
 }
 derived.by = derived;
 function disconnectDerived(derived2) {
@@ -726,6 +883,123 @@ function disconnectDerived(derived2) {
   derived2.reactions = null;
   destroyDerivedEffects(derived2);
 }
+// src/primitives/scope.ts
+var activeScope = null;
+function getCurrentScope() {
+  return activeScope;
+}
+function setActiveScope(scope) {
+  const prev = activeScope;
+  activeScope = scope;
+  return prev;
+}
+
+class EffectScopeImpl {
+  _active = true;
+  _paused = false;
+  effects = [];
+  cleanups = [];
+  parent = null;
+  scopes = null;
+  constructor(detached = false) {
+    this.parent = activeScope;
+    if (!detached && this.parent) {
+      if (this.parent.scopes === null) {
+        this.parent.scopes = [];
+      }
+      this.parent.scopes.push(this);
+    }
+  }
+  get active() {
+    return this._active;
+  }
+  get paused() {
+    return this._paused;
+  }
+  run(fn) {
+    if (!this._active) {
+      return;
+    }
+    const prevScope = setActiveScope(this);
+    try {
+      return fn();
+    } finally {
+      setActiveScope(prevScope);
+    }
+  }
+  stop() {
+    if (!this._active)
+      return;
+    for (const effect of [...this.effects]) {
+      destroyEffect(effect);
+    }
+    this.effects.length = 0;
+    for (const cleanup of this.cleanups) {
+      try {
+        cleanup();
+      } catch {}
+    }
+    this.cleanups.length = 0;
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.stop();
+      }
+      this.scopes.length = 0;
+    }
+    if (this.parent?.scopes) {
+      const idx = this.parent.scopes.indexOf(this);
+      if (idx !== -1) {
+        this.parent.scopes.splice(idx, 1);
+      }
+    }
+    this._active = false;
+  }
+  pause() {
+    if (!this._active || this._paused)
+      return;
+    this._paused = true;
+    for (const effect of this.effects) {
+      effect.f |= INERT;
+    }
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.pause();
+      }
+    }
+  }
+  resume() {
+    if (!this._active || !this._paused)
+      return;
+    this._paused = false;
+    for (const effect of this.effects) {
+      effect.f &= ~INERT;
+      if ((effect.f & DIRTY) !== 0) {
+        scheduleEffect(effect);
+      }
+    }
+    if (this.scopes) {
+      for (const scope of this.scopes) {
+        scope.resume();
+      }
+    }
+  }
+}
+function effectScope(detached) {
+  return new EffectScopeImpl(detached);
+}
+function onScopeDispose(fn) {
+  if (activeScope) {
+    activeScope.cleanups.push(fn);
+  } else {
+    console.warn("onScopeDispose() called outside of scope context");
+  }
+}
+function registerEffectWithScope(effect) {
+  if (activeScope) {
+    activeScope.effects.push(effect);
+  }
+}
+
 // src/primitives/effect.ts
 function createEffect(type, fn, sync, push = true) {
   const parent = activeEffect;
@@ -741,6 +1015,7 @@ function createEffect(type, fn, sync, push = true) {
     next: null,
     wv: 0
   };
+  registerEffectWithScope(effect);
   if (sync) {
     updateEffect(effect);
     effect.f |= EFFECT_RAN;
@@ -850,7 +1125,9 @@ effect.tracking = function effectTracking() {
   return activeEffect !== null;
 };
 // src/primitives/bind.ts
-var BINDING_SYMBOL = Symbol("binding");
+var bindingCleanup = new FinalizationRegistry((internalSource) => {
+  internalSource.reactions = null;
+});
 function isBinding(value) {
   return value !== null && typeof value === "object" && BINDING_SYMBOL in value;
 }
@@ -870,10 +1147,13 @@ function bind(source2) {
     };
   }
   let actualSource;
+  let internalSource = null;
   if (isBinding(source2) || isSignal(source2)) {
     actualSource = source2;
   } else {
-    actualSource = signal(source2);
+    const sig = signal(source2);
+    actualSource = sig;
+    internalSource = getSource(sig) ?? null;
   }
   const binding = {
     [BINDING_SYMBOL]: true,
@@ -884,6 +1164,9 @@ function bind(source2) {
       actualSource.value = v;
     }
   };
+  if (internalSource !== null) {
+    bindingCleanup.register(binding, internalSource);
+  }
   return binding;
 }
 function bindReadonly(source2) {
@@ -930,7 +1213,140 @@ function untrack(fn) {
   }
 }
 var peek = untrack;
+
+// src/primitives/linked.ts
+function linkedSignal(config) {
+  let sourceFn;
+  let computation;
+  let equalsFn = Object.is;
+  if (typeof config === "function") {
+    const fn = config;
+    sourceFn = fn;
+    computation = (s) => s;
+  } else {
+    sourceFn = config.source;
+    computation = config.computation;
+    if (config.equal) {
+      equalsFn = config.equal;
+    }
+  }
+  let prevSource = undefined;
+  let prevValue = undefined;
+  let initialized = false;
+  const valueSignal = signal(undefined, { equals: equalsFn });
+  const sourceTracker = derived(() => {
+    const newSource = sourceFn();
+    return newSource;
+  });
+  let manualOverride = false;
+  let lastKnownSource = undefined;
+  const dispose = effect.pre(() => {
+    const currentSource = sourceTracker.value;
+    const sourceChanged = initialized && !Object.is(lastKnownSource, currentSource);
+    if (!initialized || sourceChanged) {
+      const previous = initialized ? { source: prevSource, value: prevValue } : undefined;
+      const newValue = computation(currentSource, previous);
+      prevSource = currentSource;
+      prevValue = newValue;
+      lastKnownSource = currentSource;
+      initialized = true;
+      manualOverride = false;
+      untrack(() => {
+        valueSignal.value = newValue;
+      });
+    }
+  });
+  const accessor = {
+    [LINKED_SYMBOL]: true,
+    get value() {
+      sourceTracker.value;
+      const currentSource = untrack(() => sourceTracker.value);
+      if (initialized && !Object.is(lastKnownSource, currentSource)) {
+        flushSync();
+      }
+      return valueSignal.value;
+    },
+    set value(newValue) {
+      manualOverride = true;
+      prevValue = newValue;
+      valueSignal.value = newValue;
+    },
+    get peek() {
+      return untrack(() => valueSignal.value);
+    }
+  };
+  return accessor;
+}
+function isLinkedSignal(value) {
+  return value !== null && typeof value === "object" && LINKED_SYMBOL in value;
+}
+// src/primitives/selector.ts
+function createSelector(source2, fn = (k, v) => k === v) {
+  const subscribers = new Map;
+  const reactionKeys = new WeakMap;
+  let prevValue;
+  let initialized = false;
+  effect.pre(() => {
+    const value = source2();
+    if (initialized && !Object.is(prevValue, value)) {
+      for (const [key, reactions] of subscribers) {
+        const wasSelected = fn(key, prevValue);
+        const isSelected = fn(key, value);
+        if (wasSelected !== isSelected) {
+          const toRemove = [];
+          for (const reaction of reactions) {
+            if ((reaction.f & DESTROYED) !== 0) {
+              toRemove.push(reaction);
+              continue;
+            }
+            setSignalStatus(reaction, DIRTY);
+            if ((reaction.f & EFFECT) !== 0 && (reaction.f & DERIVED) === 0) {
+              scheduleEffect(reaction);
+            }
+          }
+          for (const r of toRemove) {
+            reactions.delete(r);
+          }
+        }
+      }
+    }
+    prevValue = value;
+    initialized = true;
+  });
+  return (key) => {
+    const currentValue = prevValue;
+    if (activeReaction !== null) {
+      const reaction = activeReaction;
+      if ((reaction.f & DESTROYED) === 0) {
+        let keySubscribers = subscribers.get(key);
+        if (!keySubscribers) {
+          keySubscribers = new Set;
+          subscribers.set(key, keySubscribers);
+        }
+        if (!keySubscribers.has(reaction)) {
+          keySubscribers.add(reaction);
+          let keys = reactionKeys.get(reaction);
+          if (!keys) {
+            keys = new Set;
+            reactionKeys.set(reaction, keys);
+          }
+          keys.add(key);
+        }
+      }
+    }
+    return fn(key, currentValue);
+  };
+}
 // src/collections/map.ts
+var mapCleanup = new FinalizationRegistry((data) => {
+  data.version.reactions = null;
+  data.size.reactions = null;
+  for (const sig of data.keySignals.values()) {
+    sig.reactions = null;
+  }
+  data.keySignals.clear();
+});
+
 class ReactiveMap extends Map {
   #keySignals = new Map;
   #version = source(0);
@@ -938,6 +1354,11 @@ class ReactiveMap extends Map {
   constructor(entries) {
     super(entries);
     this.#size = source(super.size);
+    mapCleanup.register(this, {
+      keySignals: this.#keySignals,
+      version: this.#version,
+      size: this.#size
+    });
   }
   #getKeySignal(key) {
     let sig = this.#keySignals.get(key);
@@ -1048,6 +1469,15 @@ class ReactiveMap extends Map {
   }
 }
 // src/collections/set.ts
+var setCleanup = new FinalizationRegistry((data) => {
+  data.version.reactions = null;
+  data.size.reactions = null;
+  for (const sig of data.itemSignals.values()) {
+    sig.reactions = null;
+  }
+  data.itemSignals.clear();
+});
+
 class ReactiveSet extends Set {
   #itemSignals = new Map;
   #version = source(0);
@@ -1055,6 +1485,11 @@ class ReactiveSet extends Set {
   constructor(values) {
     super(values);
     this.#size = source(super.size);
+    setCleanup.register(this, {
+      itemSignals: this.#itemSignals,
+      version: this.#version,
+      size: this.#size
+    });
   }
   #getItemSignal(item) {
     let sig = this.#itemSignals.get(item);
@@ -1412,10 +1847,13 @@ export {
   readVersion,
   proxy,
   peek,
+  onScopeDispose,
   neverEquals,
   mutableSource,
   markReactions,
+  linkedSignal,
   isReactive,
+  isLinkedSignal,
   isDirty,
   isBinding,
   incrementWriteVersion,
@@ -1423,15 +1861,18 @@ export {
   incrementBatchDepth,
   getWriteVersion,
   getReadVersion,
+  getCurrentScope,
   getBatchDepth,
   get,
   flushSync,
   equals,
+  effectScope,
   effect,
   disconnectDerived,
   destroyEffect,
   derived,
   decrementBatchDepth,
+  createSelector,
   createEquals,
   createEffect,
   createDerived,
@@ -1455,6 +1896,7 @@ export {
   REACTIVE_MARKER,
   REACTION_IS_UPDATING,
   MAYBE_DIRTY,
+  LINKED_SYMBOL,
   INERT,
   EFFECT_RAN,
   EFFECT_PRESERVED,
@@ -1465,5 +1907,6 @@ export {
   DERIVED,
   CLEAN,
   BRANCH_EFFECT,
-  BLOCK_EFFECT
+  BLOCK_EFFECT,
+  BINDING_SYMBOL
 };