@fictjs/runtime 0.0.11 → 0.0.13

package/src/signal.ts

@@ -2,6 +2,11 @@ import { beginFlushGuard, beforeEffectRunGuard, endFlushGuard } from './cycle-gu
 import { getDevtoolsHook } from './devtools'
 import { registerRootCleanup } from './lifecycle'
 
+const isDev =
+  typeof __DEV__ !== 'undefined'
+    ? __DEV__
+    : typeof process === 'undefined' || process.env?.NODE_ENV !== 'production'
+
 // ============================================================================
 // Type Definitions
 // ============================================================================
@@ -208,6 +213,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 +328,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 +590,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 +715,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 +928,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 +986,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 +1055,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 +1094,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 +1123,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)
@@ -1141,21 +1182,28 @@ export function endBatch(): void {
  */
 export function batch<T>(fn: () => T): T {
   ++batchDepth
-  let _error: unknown
-  let hasError = false
+  let result!: T
+  let error: unknown
   try {
-    return fn()
+    result = fn()
   } catch (e) {
-    _error = e
-    hasError = true
-    throw e
+    error = e
   } finally {
     --batchDepth
-    // Only flush if no error occurred to avoid interfering with error propagation
-    if (!hasError && batchDepth === 0) {
-      flush()
+    if (batchDepth === 0) {
+      try {
+        flush()
+      } catch (flushErr) {
+        if (error === undefined) {
+          error = flushErr
+        }
+      }
     }
   }
+  if (error !== undefined) {
+    throw error
+  }
+  return result
 }
 /**
  * Get the current active subscriber
@@ -1203,14 +1251,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 +1268,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 +1278,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 +1288,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)
@@ -1290,43 +1347,51 @@ export default {
 }
 export const $state = signal as <T>(value: T) => T
 
-let devtoolsSignalId = 0
-let devtoolsEffectId = 0
-
 interface DevtoolsIdentifiable {
   __id?: number
 }
 
-function registerSignalDevtools(value: unknown, node: SignalNode): number | undefined {
-  const hook = getDevtoolsHook()
-  if (!hook) return undefined
-  const id = ++devtoolsSignalId
-  hook.registerSignal(id, value)
-  ;(node as SignalNode & DevtoolsIdentifiable).__id = id
-  return id
-}
+let registerSignalDevtools: (value: unknown, node: SignalNode) => number | undefined = () =>
+  undefined
+let updateSignalDevtools: (node: SignalNode, value: unknown) => void = () => {}
+let registerEffectDevtools: (node: EffectNode) => number | undefined = () => undefined
+let effectRunDevtools: (node: EffectNode) => void = () => {}
+
+if (isDev) {
+  let devtoolsSignalId = 0
+  let devtoolsEffectId = 0
+
+  registerSignalDevtools = (value, node) => {
+    const hook = getDevtoolsHook()
+    if (!hook) return undefined
+    const id = ++devtoolsSignalId
+    hook.registerSignal(id, value)
+    ;(node as SignalNode & DevtoolsIdentifiable).__id = id
+    return id
+  }
 
-function updateSignalDevtools(node: SignalNode, value: unknown): void {
-  const hook = getDevtoolsHook()
-  if (!hook) return
-  const id = (node as SignalNode & DevtoolsIdentifiable).__id
-  if (id) hook.updateSignal(id, value)
-}
+  updateSignalDevtools = (node, value) => {
+    const hook = getDevtoolsHook()
+    if (!hook) return
+    const id = (node as SignalNode & DevtoolsIdentifiable).__id
+    if (id) hook.updateSignal(id, value)
+  }
 
-function registerEffectDevtools(node: EffectNode): number | undefined {
-  const hook = getDevtoolsHook()
-  if (!hook) return undefined
-  const id = ++devtoolsEffectId
-  hook.registerEffect(id)
-  ;(node as EffectNode & DevtoolsIdentifiable).__id = id
-  return id
-}
+  registerEffectDevtools = node => {
+    const hook = getDevtoolsHook()
+    if (!hook) return undefined
+    const id = ++devtoolsEffectId
+    hook.registerEffect(id)
+    ;(node as EffectNode & DevtoolsIdentifiable).__id = id
+    return id
+  }
 
-function effectRunDevtools(node: EffectNode): void {
-  const hook = getDevtoolsHook()
-  if (!hook) return
-  const id = (node as EffectNode & DevtoolsIdentifiable).__id
-  if (id) hook.effectRun(id)
+  effectRunDevtools = node => {
+    const hook = getDevtoolsHook()
+    if (!hook) return
+    const id = (node as EffectNode & DevtoolsIdentifiable).__id
+    if (id) hook.effectRun(id)
+  }
 }
 
 // ============================================================================

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 {