From 8b263cb611ff48a611a918952fab8f5a98e73994 Mon Sep 17 00:00:00 2001 From: raythurnvoid <53383860+raythurnvoid@users.noreply.github.com> Date: Sun, 1 Jun 2025 19:35:10 +0100 Subject: [PATCH] add comments and logs --- .../src/internal/client/dom/blocks/if.js | 28 +- packages/svelte/src/internal/client/proxy.js | 5 + .../src/internal/client/reactivity/effects.js | 379 +++++++++++++++++- .../src/internal/client/reactivity/sources.js | 11 + packages/svelte/src/internal/client/render.js | 1 + .../svelte/src/internal/client/runtime.js | 78 +++- 6 files changed, 498 insertions(+), 4 deletions(-) diff --git a/packages/svelte/src/internal/client/dom/blocks/if.js b/packages/svelte/src/internal/client/dom/blocks/if.js index bf1098c3f4..c0424195d4 100644 --- a/packages/svelte/src/internal/client/dom/blocks/if.js +++ b/packages/svelte/src/internal/client/dom/blocks/if.js @@ -10,7 +10,13 @@ import { set_hydrating } from '../hydration.js'; import { block, branch, pause_effect, resume_effect } from '../../reactivity/effects.js'; -import { HYDRATION_START, HYDRATION_START_ELSE, UNINITIALIZED } from '../../../../constants.js'; +import { + FILENAME, + HYDRATION_START, + HYDRATION_START_ELSE, + UNINITIALIZED +} from '../../../../constants.js'; +import { DEV } from 'esm-env'; /** * @param {TemplateNode} node @@ -50,6 +56,16 @@ export function if_block(node, fn, [root_index, hydrate_index] = [0, 0]) { /** @type {boolean | null} */ new_condition, /** @type {null | ((anchor: Node, elseif?: [number,number]) => void)} */ fn ) => { + // if (DEV && new Error().stack?.includes('NestedComponent')) { + // console.debug('update_branch', new_condition, { + // previousCondition: condition, + // conditionChanged: condition !== new_condition, + // hasConsequentEffect: !!consequent_effect, + // hasAlternateEffect: !!alternate_effect, + // fn + // }); + // } + if (condition === (condition = new_condition)) return; /** Whether or not there was a hydration mismatch. Needs to be a `let` or else it isn't treeshaken out */ @@ -86,6 +102,10 @@ export function if_block(node, fn, [root_index, hydrate_index] = [0, 0]) { } } + // if (new Error().stack?.includes('NestedComponent')) { + // // debugger; + // } + if (condition) { if (consequent_effect) { resume_effect(consequent_effect); @@ -106,6 +126,12 @@ export function if_block(node, fn, [root_index, hydrate_index] = [0, 0]) { } if (consequent_effect) { + // if (DEV) { + // // HERE is the deletion of the dom text node + // if (new Error().stack?.includes('NestedComponent')) { + // // debugger; + // } + // } pause_effect(consequent_effect, () => { consequent_effect = null; }); diff --git a/packages/svelte/src/internal/client/proxy.js b/packages/svelte/src/internal/client/proxy.js index fd5706eaf2..532aab0db2 100644 --- a/packages/svelte/src/internal/client/proxy.js +++ b/packages/svelte/src/internal/client/proxy.js @@ -21,6 +21,8 @@ import { tracing_mode_flag } from '../flags/index.js'; * @returns {T} */ export function proxy(value) { + // console.debug('proxy', value); + // if non-proxyable, or is already a proxy, return `value` if (typeof value !== 'object' || value === null || STATE_SYMBOL in value) { return value; @@ -46,12 +48,14 @@ export function proxy(value) { */ var with_parent = (fn) => { var previous_reaction = active_reaction; + // var previous_reaction_sources = reaction_sources; set_active_reaction(reaction); /** @type {T} */ var result = fn(); set_active_reaction(previous_reaction); + // set_active_reaction_sources(previous_reaction_sources); return result; }; @@ -128,6 +132,7 @@ export function proxy(value) { var s = sources.get(prop); var exists = prop in target; + // BREAKPOINT // create a source, but only if it's an own property and not a prototype property if (s === undefined && (!exists || get_descriptor(target, prop)?.writable)) { s = with_parent(() => source(proxy(exists ? target[prop] : UNINITIALIZED), stack)); diff --git a/packages/svelte/src/internal/client/reactivity/effects.js b/packages/svelte/src/internal/client/reactivity/effects.js index 36be1ecd04..e9e00e9498 100644 --- a/packages/svelte/src/internal/client/reactivity/effects.js +++ b/packages/svelte/src/internal/client/reactivity/effects.js @@ -1,4 +1,4 @@ -/** @import { ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */ +/** @import { ComponentContext, ComponentContextLegacy, Derived, Effect, Reaction, TemplateNode, TransitionManager } from '#client' */ import { check_dirtiness, active_effect, @@ -32,7 +32,10 @@ import { HEAD_EFFECT, MAYBE_DIRTY, EFFECT_HAS_DERIVED, - BOUNDARY_EFFECT + BOUNDARY_EFFECT, + EFFECT_IS_UPDATING, + DISCONNECTED, + LEGACY_DERIVED_PROP } from '#client/constants'; import { set } from './sources.js'; import * as e from '../errors.js'; @@ -41,6 +44,372 @@ import { define_property } from '../../shared/utils.js'; import { get_next_sibling } from '../dom/operations.js'; import { derived } from './deriveds.js'; import { component_context, dev_current_component_function } from '../context.js'; +import { FILENAME } from '../../../constants.js'; + +/** + * Get human-readable information about an effect for debugging + * @param {Effect | null} effect + * @returns {{ + * type: string, + * typeFlags: string, + * typeNumeric: number, + * typeBinary: string, + * status: string, + * parent: string, + * parentChain: string, + * component: string, + * hasChildren: boolean, + * hasDeps: number, + * hasNodes: boolean + * }} + */ +export function get_effect_debug_info(effect) { + if (!effect) + return { + type: 'NO_EFFECT', + typeFlags: '0x0 (0)', + typeNumeric: 0, + typeBinary: '00000000', + status: 'NONE', + parent: 'NO_PARENT', + parentChain: 'NONE', + component: 'NO_COMPONENT', + hasChildren: false, + hasDeps: 0, + hasNodes: false + }; + + const flags = effect.f; + + // Core effect types + const effectTypes = []; + const statusFlags = []; + + // Core effect types + if (flags & DERIVED) effectTypes.push('DERIVED'); + if (flags & EFFECT) effectTypes.push('EFFECT'); + if (flags & RENDER_EFFECT) effectTypes.push('RENDER_EFFECT'); + if (flags & BLOCK_EFFECT) effectTypes.push('BLOCK_EFFECT'); + if (flags & BRANCH_EFFECT) effectTypes.push('BRANCH_EFFECT'); + if (flags & ROOT_EFFECT) effectTypes.push('ROOT_EFFECT'); + if (flags & BOUNDARY_EFFECT) effectTypes.push('BOUNDARY_EFFECT'); + if (flags & INSPECT_EFFECT) effectTypes.push('INSPECT_EFFECT'); + if (flags & HEAD_EFFECT) effectTypes.push('HEAD_EFFECT'); + + // Status flags + if (flags & UNOWNED) statusFlags.push('UNOWNED'); + if (flags & DISCONNECTED) statusFlags.push('DISCONNECTED'); + if (flags & CLEAN) statusFlags.push('CLEAN'); + if (flags & DIRTY) statusFlags.push('DIRTY'); + if (flags & MAYBE_DIRTY) statusFlags.push('MAYBE_DIRTY'); + if (flags & INERT) statusFlags.push('INERT'); + if (flags & DESTROYED) statusFlags.push('DESTROYED'); + if (flags & EFFECT_RAN) statusFlags.push('EFFECT_RAN'); + if (flags & EFFECT_TRANSPARENT) statusFlags.push('EFFECT_TRANSPARENT'); + if (flags & LEGACY_DERIVED_PROP) statusFlags.push('LEGACY_DERIVED_PROP'); + if (flags & EFFECT_HAS_DERIVED) statusFlags.push('EFFECT_HAS_DERIVED'); + if (flags & EFFECT_IS_UPDATING) statusFlags.push('EFFECT_IS_UPDATING'); + + // Build parent chain + const parentChain = []; + let current = effect.parent; + let depth = 0; + + while (current && depth < 5) { + // Limit depth to prevent infinite loops + const parentTypes = []; + const parentFlags = current.f; + + if (parentFlags & DERIVED) parentTypes.push('DERIVED'); + if (parentFlags & EFFECT) parentTypes.push('EFFECT'); + if (parentFlags & RENDER_EFFECT) parentTypes.push('RENDER'); + if (parentFlags & BLOCK_EFFECT) parentTypes.push('BLOCK'); + if (parentFlags & BRANCH_EFFECT) parentTypes.push('BRANCH'); + if (parentFlags & ROOT_EFFECT) parentTypes.push('ROOT'); + if (parentFlags & BOUNDARY_EFFECT) parentTypes.push('BOUNDARY'); + if (parentFlags & INSPECT_EFFECT) parentTypes.push('INSPECT'); + if (parentFlags & HEAD_EFFECT) parentTypes.push('HEAD'); + + parentChain.push(parentTypes.length > 0 ? parentTypes.join('+') : 'UNKNOWN'); + current = current.parent; + depth++; + } + + return { + type: effectTypes.length > 0 ? effectTypes.join(' + ') : 'UNKNOWN', + typeFlags: `0x${flags.toString(16)} (${flags})`, + typeNumeric: flags, + typeBinary: flags.toString(2).padStart(8, '0'), + status: statusFlags.join(' + ') || 'NONE', + parent: effect.parent ? 'HAS_PARENT' : 'NO_PARENT', + parentChain: parentChain.length > 0 ? parentChain.join(' → ') : 'NO_PARENTS', + component: effect.component_function?.name || 'NO_COMPONENT', + hasChildren: !!effect.first, + hasDeps: effect.deps ? effect.deps.length : 0, + hasNodes: !!effect.nodes_start + }; +} + +/** + * Decode reaction/effect flags (the 'f' property) into human-readable format + * The 'f' property contains bitwise flags that represent: + * - Type of effect (RENDER_EFFECT, BRANCH_EFFECT, etc.) + * - Status flags (DIRTY, CLEAN, MAYBE_DIRTY, etc.) + * - Behavior flags (UNOWNED, INERT, etc.) + * + * @param {number} flags - The flags value (reaction.f or effect.f) + * @returns {{ + * numeric: number, + * hex: string, + * binary: string, + * types: string[], + * status: string[], + * behavior: string[], + * all: string[], + * summary: string + * }} + */ +export function decode_reaction_flags(flags) { + const types = []; + const status = []; + const behavior = []; + + // Core effect/reaction types + if (flags & DERIVED) types.push('DERIVED'); + if (flags & EFFECT) types.push('EFFECT'); + if (flags & RENDER_EFFECT) types.push('RENDER_EFFECT'); + if (flags & BLOCK_EFFECT) types.push('BLOCK_EFFECT'); + if (flags & BRANCH_EFFECT) types.push('BRANCH_EFFECT'); + if (flags & ROOT_EFFECT) types.push('ROOT_EFFECT'); + if (flags & BOUNDARY_EFFECT) types.push('BOUNDARY_EFFECT'); + if (flags & INSPECT_EFFECT) types.push('INSPECT_EFFECT'); + if (flags & HEAD_EFFECT) types.push('HEAD_EFFECT'); + + // Status flags (mutually exclusive in some cases) + if (flags & CLEAN) status.push('CLEAN'); + if (flags & DIRTY) status.push('DIRTY'); + if (flags & MAYBE_DIRTY) status.push('MAYBE_DIRTY'); + if (flags & DESTROYED) status.push('DESTROYED'); + if (flags & EFFECT_RAN) status.push('EFFECT_RAN'); + if (flags & EFFECT_IS_UPDATING) status.push('EFFECT_IS_UPDATING'); + + // Behavior flags + if (flags & UNOWNED) behavior.push('UNOWNED'); + if (flags & DISCONNECTED) behavior.push('DISCONNECTED'); + if (flags & INERT) behavior.push('INERT'); + if (flags & EFFECT_TRANSPARENT) behavior.push('EFFECT_TRANSPARENT'); + if (flags & LEGACY_DERIVED_PROP) behavior.push('LEGACY_DERIVED_PROP'); + if (flags & EFFECT_HAS_DERIVED) behavior.push('EFFECT_HAS_DERIVED'); + + const all = [...types, ...status, ...behavior]; + + return { + numeric: flags, + hex: `0x${flags.toString(16).toUpperCase()}`, + binary: flags.toString(2).padStart(24, '0'), // 24 bits for better readability + types, + status, + behavior, + all, + summary: all.length > 0 ? all.join(' + ') : 'NO_FLAGS' + }; +} + +/** + * Log the operation being performed on reaction flags for debugging + * Usage: log_flag_operation(reaction, 'f ^= EFFECT_IS_UPDATING', EFFECT_IS_UPDATING) + * + * @param {any} reaction - The reaction/effect object + * @param {string} operation - Description of the operation (e.g., 'f ^= EFFECT_IS_UPDATING') + * @param {number} flagValue - The flag value being operated on + */ +export function log_flag_operation(reaction, operation, flagValue) { + if (!DEV) return; + + const beforeFlags = decode_reaction_flags(reaction.f); + const operationFlag = decode_reaction_flags(flagValue); + + // Create flags string with format "FLAG_NAME (number) + FLAG_NAME (number)" + const flagsString = + beforeFlags.all + .map((flag) => { + const flagNumeric = getFlagNumericValue(flag); + return `${flag} (${flagNumeric})`; + }) + .join(' + ') || 'NO_FLAGS (0)'; + + // Create operation description + const operationType = operation.includes('^=') + ? 'toggle flag' + : operation.includes('|=') + ? 'add flag' + : operation.includes('&=') + ? 'remove flag' + : 'set flag'; + + console.debug(`Flag operation: ${operation}`, { + flags: flagsString, + operation: `(${operation}) ${operationType}`, + operationFlag: `${operationFlag.summary} (${flagValue})` + }); +} + +/** + * Helper to get numeric value for a flag name + * @param {string} flagName + * @returns {number} + */ +function getFlagNumericValue(flagName) { + const flagMap = /** @type {Record} */ ({ + DERIVED: DERIVED, + EFFECT: EFFECT, + RENDER_EFFECT: RENDER_EFFECT, + BLOCK_EFFECT: BLOCK_EFFECT, + BRANCH_EFFECT: BRANCH_EFFECT, + ROOT_EFFECT: ROOT_EFFECT, + BOUNDARY_EFFECT: BOUNDARY_EFFECT, + INSPECT_EFFECT: INSPECT_EFFECT, + HEAD_EFFECT: HEAD_EFFECT, + CLEAN: CLEAN, + DIRTY: DIRTY, + MAYBE_DIRTY: MAYBE_DIRTY, + DESTROYED: DESTROYED, + EFFECT_RAN: EFFECT_RAN, + EFFECT_IS_UPDATING: EFFECT_IS_UPDATING, + UNOWNED: UNOWNED, + DISCONNECTED: DISCONNECTED, + INERT: INERT, + EFFECT_TRANSPARENT: EFFECT_TRANSPARENT, + LEGACY_DERIVED_PROP: LEGACY_DERIVED_PROP, + EFFECT_HAS_DERIVED: EFFECT_HAS_DERIVED + }); + return flagMap[flagName] || 0; +} + +/** + * Log effect processing information in a simplified format + * @param {Effect} effect - The effect being processed + */ +export function get_effect_info(effect) { + if (!DEV) return; + + const flags = effect.f; + const effectInfo = decode_reaction_flags(flags); + + return { + effectType: effectInfo.summary, + component: effect.component_function?.[FILENAME] || 'NO_COMPONENT', + effect: effect + }; +} + +/** + * Build a tree representation of effects starting from a root effect + * @param {Effect} root - The root effect to start traversal from + * @returns {{effectType: string, component: string, effect: Effect, children: any[]} | null} Tree representation + */ +export function get_effect_tree(root) { + if (!root) return null; + + const map = new Map(); + + // Create root object + const rootObj = { + effectType: decode_reaction_flags(root.f).summary, + component: root.component_function?.[FILENAME] || 'NO_COMPONENT', + effect: root, + children: [] + }; + map.set(root, rootObj); + + // Start traversal from root's first child + let effect = root.first; + + while (effect != null) { + // Create object for current effect + const effectObj = { + effectType: decode_reaction_flags(effect.f).summary, + component: effect.component_function?.[FILENAME] || 'NO_COMPONENT', + effect: effect, + children: [] + }; + map.set(effect, effectObj); + + // Add to parent's children array + if (effect.parent && map.has(effect.parent)) { + const parentObj = map.get(effect.parent); + parentObj.children.push(effectObj); + } + + // Navigate to children first (depth-first traversal) + const child = effect.first; + if (child !== null) { + effect = child; + continue; + } + + // Then navigate to siblings + let parent = effect.parent; + effect = effect.next; + + // If no sibling, go up to parent and try its sibling + while (effect === null && parent !== null) { + effect = parent.next; + parent = parent.parent; + } + } + + return rootObj; +} + +/** + * Get all parent effects of a given effect in an array + * @param {Effect} effect - The effect to get parents for + * @returns {Array<{effectType: string, component: string, effect: Effect}>} Array of parent effects + */ +export function get_effect_parents(effect) { + if (!effect) return []; + + const parents = []; + let current = effect.parent; + + while (current != null) { + const parentObj = { + effectType: decode_reaction_flags(current.f).summary, + component: current.component_function?.[FILENAME] || 'NO_COMPONENT', + effect: current + }; + parents.push(parentObj); + current = current.parent; + } + + return parents; +} + +/** + * Comprehensive effect debugging information combining all logging utilities + * @param {Effect} effect - The effect to get debugging info for + * @returns {{ + * info: {effectType: string, component: string, effect: Effect} | null, + * tree: {effectType: string, component: string, effect: Effect, children: any[]} | null, + * parents: Array<{effectType: string, component: string, effect: Effect}> + * }} Combined debugging information + */ +export function get_comprehensive_effect_info(effect) { + if (!DEV || !effect) { + return { + info: null, + tree: null, + parents: [] + }; + } + + return { + info: get_effect_info(effect) || null, + tree: get_effect_tree(effect), + parents: get_effect_parents(effect) + }; +} /** * @param {'$effect' | '$effect.pre' | '$inspect'} rune @@ -109,6 +478,12 @@ function create_effect(type, fn, sync, push = true) { wv: 0 }; + if (DEV) { + // if (effect.component_function?.[FILENAME].includes('NestedComponent')) { + // console.debug('create_effect', get_comprehensive_effect_info(effect)); + // } + } + if (DEV) { effect.component_function = dev_current_component_function; } diff --git a/packages/svelte/src/internal/client/reactivity/sources.js b/packages/svelte/src/internal/client/reactivity/sources.js index 9d2ad2baee..426eeda214 100644 --- a/packages/svelte/src/internal/client/reactivity/sources.js +++ b/packages/svelte/src/internal/client/reactivity/sources.js @@ -35,6 +35,7 @@ import { get_stack } from '../dev/tracing.js'; import { component_context, is_runes } from '../context.js'; import { proxy } from '../proxy.js'; import { execute_derived } from './deriveds.js'; +import { get_comprehensive_effect_info } from './effects.js'; export let inspect_effects = new Set(); export const old_values = new Map(); @@ -180,6 +181,15 @@ export function internal_set(source, value) { source.wv = increment_write_version(); + // if (DEV && new Error().stack?.includes('service.svelte.ts')) { + // console.debug('internal_set', source, value); + // source.reactions?.forEach((reaction) => { + // const reaction_as_any = /** @type {any} */ (reaction); + // const reaction_as_effect = /** @type {Effect} */ (reaction_as_any); + // console.debug('internal_set reaction', get_comprehensive_effect_info(reaction_as_effect)); + // }); + // // debugger; + // } mark_reactions(source, DIRTY); // It's possible that the current reaction might not have up-to-date dependencies @@ -261,6 +271,7 @@ function mark_reactions(signal, status) { var runes = is_runes(); var length = reactions.length; + // BREAKPOINT for (var i = 0; i < length; i++) { var reaction = reactions[i]; var flags = reaction.f; diff --git a/packages/svelte/src/internal/client/render.js b/packages/svelte/src/internal/client/render.js index 3256fe8274..48cb5ad839 100644 --- a/packages/svelte/src/internal/client/render.js +++ b/packages/svelte/src/internal/client/render.js @@ -49,6 +49,7 @@ export function set_should_intro(value) { * @returns {void} */ export function set_text(text, value) { + // debugger; // For objects, we apply string coercion (which might make things like $state array references in the template reactive) before diffing var str = value == null ? '' : typeof value === 'object' ? value + '' : value; // @ts-expect-error diff --git a/packages/svelte/src/internal/client/runtime.js b/packages/svelte/src/internal/client/runtime.js index d790c0ad14..36bac75560 100644 --- a/packages/svelte/src/internal/client/runtime.js +++ b/packages/svelte/src/internal/client/runtime.js @@ -5,7 +5,10 @@ import { destroy_block_effect_children, destroy_effect_children, execute_effect_teardown, - unlink_effect + unlink_effect, + decode_reaction_flags, + log_flag_operation, + get_comprehensive_effect_info } from './reactivity/effects.js'; import { EFFECT, @@ -76,6 +79,11 @@ export let untracking = false; /** @param {null | Reaction} reaction */ export function set_active_reaction(reaction) { + const reaction_as_any = /** @type {any} */ (reaction); + const reaction_as_effect = /** @type {Effect} */ (reaction_as_any); + if (DEV && reaction_as_effect?.component_function?.[FILENAME].includes('App_15870.svelte')) { + console.trace('set_active_reaction', get_comprehensive_effect_info(reaction_as_effect)); + } active_reaction = reaction; } @@ -97,6 +105,17 @@ export let reaction_sources = null; /** @param {Value} value */ export function push_reaction_value(value) { if (active_reaction !== null && active_reaction.f & EFFECT_IS_UPDATING) { + if (DEV && new Error().stack?.includes('NestedComponent')) { + const active_reaction_as_any = /** @type {any} */ (active_reaction); + const active_reaction_as_effect = /** @type {Effect} */ (active_reaction_as_any); + console.debug('push_reaction_value value', value); + console.debug( + 'push_reaction_value active_reaction', + get_comprehensive_effect_info(active_reaction_as_effect) + ); + debugger; + } + if (reaction_sources === null) { reaction_sources = [value]; } else { @@ -403,6 +422,18 @@ export function update_reaction(reaction) { (flags & UNOWNED) !== 0 && (untracking || !is_updating_effect || active_reaction === null); active_reaction = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) === 0 ? reaction : null; + const active_reaction_as_any = /** @type {any} */ (active_reaction); + const active_reaction_as_effect = /** @type {Effect} */ (active_reaction_as_any); + if ( + DEV && + active_reaction_as_effect?.component_function?.[FILENAME].includes('NestedComponent.svelte') + ) { + console.debug( + 'update_reaction active_reaction', + get_comprehensive_effect_info(active_reaction_as_effect) + ); + } + reaction_sources = null; set_component_context(reaction.ctx); untracking = false; @@ -411,9 +442,20 @@ export function update_reaction(reaction) { reaction.f |= EFFECT_IS_UPDATING; try { + if (DEV) { + const reaction_as_any = /** @type {any} */ (reaction); + const reaction_as_an_effect = /** @type {Effect} */ (reaction_as_any); + + if (reaction_as_an_effect.component_function?.[FILENAME].includes('NestedComponent')) { + console.debug('update_reaction', get_comprehensive_effect_info(reaction_as_an_effect)); + // debugger; + } + } + var result = /** @type {Function} */ (0, reaction.fn)(); var deps = reaction.deps; + // BREAKPOINT if (new_deps !== null) { var i; @@ -774,6 +816,14 @@ function process_effects(root) { var is_branch = (flags & (BRANCH_EFFECT | ROOT_EFFECT)) !== 0; var is_skippable_branch = is_branch && (flags & CLEAN) !== 0; + // Log each effect being processed + if (DEV) { + if (effect.component_function?.[FILENAME].includes('NestedComponent')) { + console.debug('process_effects', get_comprehensive_effect_info(effect)); + // debugger; + } + } + if (!is_skippable_branch && (flags & INERT) === 0) { if ((flags & EFFECT) !== 0) { effects.push(effect); @@ -864,8 +914,34 @@ export function get(signal) { captured_signals.add(signal); } + if (DEV && new Error().stack?.includes('NestedComponent')) { + // console.debug('get() signal', signal); + // const active_reaction_as_any = /** @type {any} */ (active_reaction); + // const active_reaction_as_effect = /** @type {Effect} */ (active_reaction_as_any); + // console.debug( + // 'get() signal active_reaction', + // get_comprehensive_effect_info(active_reaction_as_effect) + // ); + // reaction_sources?.forEach((reaction) => { + // const reaction_as_any = /** @type {any} */ (reaction); + // const reaction_as_effect = /** @type {Effect} */ (reaction_as_any); + // console.debug('get() signal reaction', get_comprehensive_effect_info(reaction_as_effect)); + // }); + // debugger; + } + // Register the dependency on the current reaction signal. if (active_reaction !== null && !untracking) { + const active_reaction_as_any = /** @type {any} */ (active_reaction); + const active_reaction_as_effect = /** @type {Effect} */ (active_reaction_as_any); + if (DEV) { + // console.debug( + // 'get() signal active_reaction', + // get_comprehensive_effect_info(active_reaction_as_effect) + // ); + } + + // BREAKPOINT if (!reaction_sources?.includes(signal)) { var deps = active_reaction.deps; if (signal.rv < read_version) {