@fictjs/runtime 0.0.11 → 0.0.12

package/src/signal.ts

@@ -208,6 +208,11 @@ const enqueueMicrotask =
       }
 // 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,
@@ -318,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) {
@@ -572,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) {
@@ -688,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
@@ -897,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) {
@@ -953,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 {
@@ -1020,7 +1050,9 @@ 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
 }
 
 /**
@@ -1057,7 +1089,9 @@ export function effectWithCleanup(fn: () => void, cleanupRunner: () => void): Ef
     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
 }
 
 function effectOper(this: EffectNode): void {
@@ -1084,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)
@@ -1203,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
@@ -1218,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
@@ -1226,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
@@ -1234,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 {