@fictjs/runtime 0.0.10 → 0.0.12

package/src/signal.ts

@@ -96,6 +96,10 @@ export interface EffectNode extends BaseNode {
   deps: Link | undefined
   /** Last dependency link */
   depsTail: Link | undefined
+  /** Optional cleanup runner to be called before checkDirty */
+  runCleanup?: () => void
+  /** Devtools ID */
+  __id?: number | undefined
 }
 
 /**
@@ -202,6 +206,13 @@ const enqueueMicrotask =
     : (fn: () => void) => {
         Promise.resolve().then(fn)
       }
+// Flag to indicate cleanup is running - signal reads should return currentValue without updating
+let inCleanup = false
+// This ensures type detection works correctly even after minification
+const SIGNAL_MARKER = Symbol.for('fict:signal')
+const COMPUTED_MARKER = Symbol.for('fict:computed')
+const EFFECT_MARKER = Symbol.for('fict:effect')
+const EFFECT_SCOPE_MARKER = Symbol.for('fict:effectScope')
 export const ReactiveFlags = {
   None: 0,
   Mutable,
@@ -312,13 +323,21 @@ export function createReactiveSystem({
           dirty = true
         }
       } else if ((depFlags & MutablePending) === MutablePending) {
-        if (link.nextSub !== undefined || link.prevSub !== undefined) {
-          stack = { value: link, prev: stack }
+        if (!dep.deps) {
+          const nextDep = link.nextDep
+          if (nextDep !== undefined) {
+            link = nextDep
+            continue
+          }
+        } else {
+          if (link.nextSub !== undefined || link.prevSub !== undefined) {
+            stack = { value: link, prev: stack }
+          }
+          link = dep.deps
+          sub = dep
+          ++checkDepth
+          continue
         }
-        link = dep.deps!
-        sub = dep
-        ++checkDepth
-        continue
       }
 
       if (!dirty) {
@@ -566,13 +585,22 @@ function checkDirty(firstLink: Link, sub: ReactiveNode): boolean {
         dirty = true
       }
     } else if ((depFlags & MutablePending) === MutablePending) {
-      if (link.nextSub !== undefined || link.prevSub !== undefined) {
-        stack = { value: link, prev: stack }
+      if (!dep.deps) {
+        // No dependencies to check, skip this node
+        const nextDep = link.nextDep
+        if (nextDep !== undefined) {
+          link = nextDep
+          continue
+        }
+      } else {
+        if (link.nextSub !== undefined || link.prevSub !== undefined) {
+          stack = { value: link, prev: stack }
+        }
+        link = dep.deps
+        sub = dep
+        ++checkDepth
+        continue
       }
-      link = dep.deps!
-      sub = dep
-      ++checkDepth
-      continue
     }
 
     if (!dirty) {
@@ -682,8 +710,12 @@ function disposeNode(node: ReactiveNode): void {
   node.depsTail = undefined
   node.flags = 0
   purgeDeps(node)
-  const sub = node.subs
-  if (sub !== undefined) unlink(sub, node)
+  let sub = node.subs
+  while (sub !== undefined) {
+    const next = sub.nextSub
+    unlink(sub)
+    sub = next
+  }
 }
 /**
  * Update a signal node
@@ -735,7 +767,16 @@ function updateComputed<T>(c: ComputedNode<T>): boolean {
  */
 function runEffect(e: EffectNode): void {
   const flags = e.flags
-  if (flags & Dirty || (flags & Pending && e.deps && checkDirty(e.deps, e))) {
+  // Run cleanup BEFORE checkDirty so cleanup sees previous signal values
+  if (flags & Dirty) {
+    if (e.runCleanup) {
+      inCleanup = true
+      try {
+        e.runCleanup()
+      } finally {
+        inCleanup = false
+      }
+    }
     ++cycle
     effectRunDevtools(e)
     e.depsTail = undefined
@@ -752,6 +793,36 @@ function runEffect(e: EffectNode): void {
       e.flags = Watching
       throw err
     }
+  } else if (flags & Pending && e.deps) {
+    // Run cleanup before checkDirty which commits signal values
+    if (e.runCleanup) {
+      inCleanup = true
+      try {
+        e.runCleanup()
+      } finally {
+        inCleanup = false
+      }
+    }
+    if (checkDirty(e.deps, e)) {
+      ++cycle
+      effectRunDevtools(e)
+      e.depsTail = undefined
+      e.flags = WatchingRunning
+      const prevSub = activeSub
+      activeSub = e
+      try {
+        e.fn()
+        activeSub = prevSub
+        e.flags = Watching
+        purgeDeps(e)
+      } catch (err) {
+        activeSub = prevSub
+        e.flags = Watching
+        throw err
+      }
+    } else {
+      e.flags = Watching
+    }
   } else {
     e.flags = Watching
   }
@@ -852,7 +923,9 @@ export function signal<T>(initialValue: T): SignalAccessor<T> {
     __id: undefined as number | undefined,
   }
   registerSignalDevtools(initialValue, s)
-  return signalOper.bind(s) as SignalAccessor<T>
+  const accessor = signalOper.bind(s) as SignalAccessor<T> & Record<symbol, boolean>
+  accessor[SIGNAL_MARKER] = true
+  return accessor as SignalAccessor<T>
 }
 function signalOper<T>(this: SignalNode<T>, value?: T): T | void {
   if (arguments.length > 0) {
@@ -870,7 +943,8 @@ function signalOper<T>(this: SignalNode<T>, value?: T): T | void {
   }
 
   const flags = this.flags
-  if (flags & Dirty) {
+  // During cleanup, don't update signal - return currentValue as-is
+  if (flags & Dirty && !inCleanup) {
     if (updateSignal(this)) {
       const subs = this.subs
       if (subs !== undefined) shallowPropagate(subs)
@@ -907,7 +981,9 @@ export function computed<T>(getter: (oldValue?: T) => T): ComputedAccessor<T> {
     flags: 0,
     getter,
   }
-  const bound = (computedOper as (this: ComputedNode<T>) => T).bind(c)
+  const bound = (computedOper as (this: ComputedNode<T>) => T).bind(c) as ComputedAccessor<T> &
+    Record<symbol, boolean>
+  bound[COMPUTED_MARKER] = true
   return bound as ComputedAccessor<T>
 }
 function computedOper<T>(this: ComputedNode<T>): T {
@@ -974,8 +1050,50 @@ export function effect(fn: () => void): EffectDisposer {
     e.flags &= ~Running
   }
 
-  return effectOper.bind(e) as EffectDisposer
+  const disposer = effectOper.bind(e) as EffectDisposer & Record<symbol, boolean>
+  disposer[EFFECT_MARKER] = true
+  return disposer as EffectDisposer
+}
+
+/**
+ * Create a reactive effect with a custom cleanup runner
+ * The cleanup runner is called BEFORE signal values are committed, allowing
+ * cleanup functions to access the previous values of signals.
+ * @param fn - The effect function
+ * @param cleanupRunner - Function to run cleanups before signal value commit
+ * @returns An effect disposer function
+ */
+export function effectWithCleanup(fn: () => void, cleanupRunner: () => void): EffectDisposer {
+  const e: EffectNode = {
+    fn,
+    subs: undefined,
+    subsTail: undefined,
+    deps: undefined,
+    depsTail: undefined,
+    flags: WatchingRunning,
+    runCleanup: cleanupRunner,
+    __id: undefined as number | undefined,
+  }
+
+  registerEffectDevtools(e)
+
+  const prevSub = activeSub
+  if (prevSub !== undefined) link(e, prevSub, 0)
+  activeSub = e
+
+  try {
+    effectRunDevtools(e)
+    fn()
+  } finally {
+    activeSub = prevSub
+    e.flags &= ~Running
+  }
+
+  const disposer = effectOper.bind(e) as EffectDisposer & Record<symbol, boolean>
+  disposer[EFFECT_MARKER] = true
+  return disposer as EffectDisposer
 }
+
 function effectOper(this: EffectNode): void {
   disposeNode(this)
 }
@@ -1000,7 +1118,9 @@ export function effectScope(fn: () => void): EffectScopeDisposer {
     activeSub = prevSub
   }
 
-  return effectScopeOper.bind(e) as EffectScopeDisposer
+  const disposer = effectScopeOper.bind(e) as EffectScopeDisposer & Record<symbol, boolean>
+  disposer[EFFECT_SCOPE_MARKER] = true
+  return disposer as EffectScopeDisposer
 }
 function effectScopeOper(this: EffectScopeNode): void {
   disposeNode(this)
@@ -1119,14 +1239,16 @@ export function untrack<T>(fn: () => T): T {
 export function peek<T>(accessor: () => T): T {
   return untrack(accessor)
 }
-// Type detection - Fixed: using Function.name
+// This ensures correct detection even after minification
 /**
  * Check if a function is a signal accessor
  * @param fn - The function to check
  * @returns True if the function is a signal accessor
  */
 export function isSignal(fn: unknown): fn is SignalAccessor<unknown> {
-  return typeof fn === 'function' && fn.name === 'bound signalOper'
+  return (
+    typeof fn === 'function' && (fn as unknown as Record<symbol, boolean>)[SIGNAL_MARKER] === true
+  )
 }
 /**
  * Check if a function is a computed accessor
@@ -1134,7 +1256,9 @@ export function isSignal(fn: unknown): fn is SignalAccessor<unknown> {
  * @returns True if the function is a computed accessor
  */
 export function isComputed(fn: unknown): fn is ComputedAccessor<unknown> {
-  return typeof fn === 'function' && fn.name === 'bound computedOper'
+  return (
+    typeof fn === 'function' && (fn as unknown as Record<symbol, boolean>)[COMPUTED_MARKER] === true
+  )
 }
 /**
  * Check if a function is an effect disposer
@@ -1142,7 +1266,9 @@ export function isComputed(fn: unknown): fn is ComputedAccessor<unknown> {
  * @returns True if the function is an effect disposer
  */
 export function isEffect(fn: unknown): fn is EffectDisposer {
-  return typeof fn === 'function' && fn.name === 'bound effectOper'
+  return (
+    typeof fn === 'function' && (fn as unknown as Record<symbol, boolean>)[EFFECT_MARKER] === true
+  )
 }
 /**
  * Check if a function is an effect scope disposer
@@ -1150,7 +1276,10 @@ export function isEffect(fn: unknown): fn is EffectDisposer {
  * @returns True if the function is an effect scope disposer
  */
 export function isEffectScope(fn: unknown): fn is EffectScopeDisposer {
-  return typeof fn === 'function' && fn.name === 'bound effectScopeOper'
+  return (
+    typeof fn === 'function' &&
+    (fn as unknown as Record<symbol, boolean>)[EFFECT_SCOPE_MARKER] === true
+  )
 }
 // ============================================================================
 // Transition Context (for priority scheduling)

package/src/suspense.ts

@@ -103,7 +103,9 @@ export function Suspense(props: SuspenseProps): FictNode {
       popRoot(prev)
       flushOnMount(root)
       destroyRoot(root)
-      handleError(err, { source: 'render' })
+      if (!handleError(err, { source: 'render' }, hostRoot)) {
+        throw err
+      }
       return
     }
     popRoot(prev)
@@ -143,18 +145,33 @@ export function Suspense(props: SuspenseProps): FictNode {
     if (thenable) {
       thenable.then(
         () => {
-          if (epoch !== tokenEpoch) return
-          pending(Math.max(0, pending() - 1))
-          if (pending() === 0) {
+          // This prevents stale token resolutions from affecting state after
+          // a reset. The order is important: check epoch first, then update state.
+          if (epoch !== tokenEpoch) {
+            // Token is stale (from before a reset), ignore it completely
+            return
+          }
+          // Use Math.max as a defensive measure - pending should never go below 0,
+          // but this protects against edge cases where a token might resolve twice
+          // or after the component has been reset.
+          const newPending = Math.max(0, pending() - 1)
+          pending(newPending)
+          if (newPending === 0) {
             switchView(props.children ?? null)
             onResolveMaybe()
           }
         },
         err => {
-          if (epoch !== tokenEpoch) return
-          pending(Math.max(0, pending() - 1))
+          // Same epoch check - ignore stale tokens
+          if (epoch !== tokenEpoch) {
+            return
+          }
+          const newPending = Math.max(0, pending() - 1)
+          pending(newPending)
           props.onReject?.(err)
-          handleError(err, { source: 'render' }, hostRoot)
+          if (!handleError(err, { source: 'render' }, hostRoot)) {
+            throw err
+          }
         },
       )
       return true

package/src/transition.ts

@@ -71,8 +71,11 @@ export function useTransition(): [() => boolean, (fn: () => void) => void] {
   const pending = signal(false)
 
   const start = (fn: () => void) => {
-    pending(true)
+    // Both pending(true) and pending(false) are now low-priority updates,
+    // preventing the race condition where isPending() could be inconsistent
+    // with the actual transition execution state.
     startTransition(() => {
+      pending(true)
       try {
         fn()
       } finally {