Framework initialization cannot find the specified root DOM element. Check that your mount target exists in the HTML before calling wildflower.start().

A configuration attribute carries a value the framework does not recognize, so the default is used instead. The warning names the attribute and the accepted values (for example data-error-handling accepts log, throw, or silent). Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A definition or markup uses a capability this build tier excludes, so it silently does nothing: tick() defined in a build without the frame loop (pool module excluded), or scoped-slot read bindings in the nano tier. Switch to a build that includes the capability, or remove the usage. The warning names the specific capability and the tier boundary. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A component's init() method or setup logic threw an exception. Check the browser console for the underlying error.

Attempting to access a component that doesn't exist in the registry. Verify the component name matches its data-component attribute and that it has been registered.

A component's context object is missing when required. This usually indicates the component was destroyed or not fully initialized.

A parent component's event handler threw an exception when invoked by a child. Check the parent's method for errors.

A component called .text() on a data-bind node, .html() on a data-bind-html or data-list node, or .remove() on a managed node through the $el() helper. The engine keeps those nodes current, so the manual write will be overwritten by the next update or leave the engine tracking a removed node. Update state instead and let the binding do the writing. Unmanaged nodes stay free, and .val() on a data-model input is the sanctioned bridge. Warning severity (console.warn, never throws); fires when debug mode is on (the default in development builds).

destroyComponent() ran while the component's element was still connected, so the next scan will auto-resurrect it as a fresh instance with init() re-fired. For a real teardown remove the element as well (instance.element.remove()); if you wanted a reset, re-initialize state instead. Removing the element without calling destroy is always safe: the engine garbage-collects instances whose elements leave the document. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A definition lists a key in uses: that nothing ever registered, so the $name accessor is never attached and reads of it are undefined. Register the provider with wildflower.provide('name', value) before components that use it initialize, or fix the key if it is a typo. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A directive or plugin was registered under a name that already exists, and the new registration replaced the original. If both registrations are intentional (hot reload, deliberate override) the warning can be ignored; otherwise rename one. Note the asymmetry with components and stores, where a conflicting re-registration keeps the original instead (WF-215). Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A computed property function threw an exception during evaluation. Check that all referenced state properties exist and have expected types.

Two or more computed properties reference each other, creating an infinite loop. Restructure your computed properties to break the cycle.

The reactive proxy's set trap encountered an error. This can happen when assigning invalid values or when the state object has been corrupted.

The reactive proxy's delete trap encountered an error when removing a state property.

Failed to read persisted state from localStorage or sessionStorage. The stored data may be corrupted or the storage quota exceeded.

Failed to persist state to localStorage or sessionStorage. Check that the storage quota has not been exceeded and that the data is serializable.

A state update method received an argument of the wrong type. Verify you're passing the correct data type.

Retired in v1.3. This code was reserved for reads of undefined computed properties but never fired from any code path. Misspelled computed and state references are caught by binding validation in development builds, which warns with a did-you-mean at bind time. The code number is not reused.

A computed property was defined as a value instead of a function. Computed properties must be functions that return a value.

A dotted path like user.profile.name contains an invalid segment. Check for typos or undefined intermediate objects.

A user-provided subscription callback threw an exception. Check the function passed to subscribe().

Retired in v1.3. Pool aggregates (pool.length, pool.size) are reactive on demand as of v1.3: a computed reading them re-evaluates when entities are added, removed, or cleared, so the trap this warning guarded no longer exists and the warning was removed. On v1.2 and earlier, aggregates bypass reactivity and a computed reading them evaluates once and goes silently stale; the workaround there is mirroring the count into reactive state inside a tick(). The code number is not reused.

A watcher or subscription registered a path like items.0.name. This is an anti-pattern: reactivity tracks items by object identity, so the index in a change path reflects the item's position when it was first observed — after a splice, removal, or reorder the watcher fires for the wrong slot or goes silent. Watch the array (or a computed over it) and track items by id instead, e.g. watch: { items() { ... } } or a computed like activeItem() { return this.items.find(i => i.id === this.selectedId) }. Warning severity (logged via console.warn, never throws); dev-mode only, stripped from production builds.

A computed referenced inside a data-list row template was declared with no parameters, and its body reads this.<prop> where <prop> is not on the component's state or computeds but is a property of the current list item. Zero-arg computeds evaluate at component scope, so that read silently resolves undefined. Item-level computeds receive the item as their first argument: declare it, e.g. priceLabel(item) { return '$' + item.price }. A zero-arg computed that reads only component state is legitimate inside a row and never triggers this warning. Fires once per component and computed; warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A component or store was registered under a name that already exists, and the incoming definition differs from the stored one. Registration is first-write-wins, so the original is kept and the new definition is ignored. This is almost always an accidental collision (two components sharing a name, a hot reload without teardown). To replace a definition intentionally, call wildflower.unregister('<name>') first, then re-register; or give the new one a distinct name. The comparison hashes method source, so two definitions that share method names but differ in a method body are still flagged; an identical re-registration (the same definition scanned twice) does not warn. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

One state property is being read through the reactive facade at hot-loop rates, sustained across animation frames. A facade read costs roughly 100x a plain property read; that is proxy physics, and every fine-grained framework pays it. The fix is one line: hoist the value to a local before the loop (const speed = this.state.speed) and read the local inside it. For per-entity hot data, pool entities are plain objects with zero proxy cost. One-shot sweeps (building a large structure once during init) do not trigger this warning; it fires only for reads that recur frame after frame, and only once per property name. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A computed mutated tracked state while it was being evaluated, including an in-place sort or reverse. Computeds must be pure. The mutation invalidates the computed while it runs, and anything bound to it (a data-list, a binding) can silently render empty or stale. Copy before mutating (return [...items].sort(...)), or move the write into a method. Writes inside untrack() are the sanctioned escape and stay silent. Warned once per computed. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The same name is defined in more than one bucket of a definition: a method colliding with a state key or a computed, or a key defined in both state and computed. One of them is shadowed wherever the bare name resolves. For state/computed collisions the computed wins everywhere except explicit this.state.key reads. Rename one. Warned once per definition. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A top-level key in a component, store, plugin, or pool entity definition is not a function and is not part of the definition contract, so it was ignored. State values belong inside state: {}; only methods live at the top level, never in a methods or actions block. Underscore-prefixed keys are the deliberate stash and stay silent. Warned once per definition with a hint for the specific key. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

Computed properties are read-only derived values. The assignment was ignored and the property keeps computing from its inputs. Store the value in state instead, or rename the computed if you meant a state field. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

wildflower.batch(fn) groups writes into one flush and requires a function argument; the call was a no-op. Pass the writes inside a function: wildflower.batch(() => { ... }). Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

Context data resolution failed during binding evaluation. The bound property path may be invalid or the data structure has changed unexpectedly.

A context operation requires a component instance but none is available. The component may have been destroyed.

The context update process encountered an exception. This is typically caused by invalid data or a corrupted context state.

Failed to notify dependent contexts of a data change. A dependent binding or computed property may have an error.

A data-list element resolved no item template. The development build names the cause it found: row markup written as direct children instead of inside a <template>, a container inside <svg> where the HTML parser removes <template> elements before any script runs, or no template in any searched source (inline child, data-use-template reference, inherited templates). Add a <template> child, or for SVG bind a fixed set of elements instead.

The list rendering process threw an exception. Check that the list data is a valid array and that template bindings reference valid item properties.

Updating an existing list item's bindings failed. The item data may have an unexpected structure.

Removing a list item from the DOM failed. The element may have already been removed or detached.

The optimized append path for adding items to the end of a list encountered an error. The framework will fall back to a full re-render.

The optimized swap path for reordering list items encountered an error. The framework will fall back to a full re-render.

The optimized sparse update path (updating a subset of list items) encountered an error. The framework will fall back to a full re-render.

A data-pool container names a pool that does not appear in the component's declared pools: {} block. Pool names must match exactly; code that populates getPool('items') never reaches a container written as data-pool="itmes", so the container renders nothing. This is almost always a typo, and the warning suggests the closest declared name. A markup-only pool (no declaration, populated programmatically by the exact same name) is legitimate and stays silent. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A data-pool container and its template are wired correctly, but nothing was ever added to the pool by the time the page settled, so nothing renders. Populate it from the component with this.getPool('name').add({ id: 1, ... }) or through the pools.name handle. If the pool fills later by design (for example on user interaction), this note can be ignored; it fires once and only in development builds.

Two spawn paths in one pool produced entities with different fields or a different field order. V8 gives a pool one fast hidden class only when every entity shares the same shape; once shapes diverge, every hot-loop read in the pool slows down. This is platform physics rather than a framework rule. Make all spawn paths build entities with the same fields in the same order: initialize missing fields up front (null or 0), or split differently-shaped entities into separate pools. Fields filled by entity.state defaults count as normalized and stay silent. Fires once per pool, showing both shapes. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A pool that declares entity.computed properties reached 200 entities. Entity computeds are uncached by contract (they re-evaluate on every read, roughly 60us per entity per flush measured), so on a per-frame pool this cost lands on every animation frame. For per-frame pools at this scale, store the derived value as a plain data field updated on mutation, or mark non-animating entities static with data-pool-static="prop". Passive pools (data-pool-static on the container) never flush per frame and stay silent. Fires once per pool. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A template lookup by name or type found nothing to render, or found something unusable: a configurable template missing from the hierarchy with no fallback, a target component that does not exist, a polymorphic item type with no matching data-type template and no default, a template with empty content, or duplicate item-template names (the first wins). The warning names the template or type it searched for. Check the name against the defining component, or add a fallback/default template. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

Pools use swap-with-last storage, so positions reshuffle on every removal and index-based operations would hit a different entity than intended. In dev builds pool.splice(), pool.pop(), pool.indexOf(), and pool.slice() exist as throwing stubs that explain this, and mutating pool.items directly is caught by a consistency check at the next API call. Iterate pool.items freely; mutate only through the pool API (add/remove), use remove(key) to delete and at(i) for stable DOM-order access. Production keeps the raw array (pull mode's zero-overhead contract). Dev-mode only.

An entity added to a keyed pool is missing the declared key property, or carries a key the pool already holds; the entity is not registered. Give every entity a unique value for the pool's key property before adding it. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A data-bind expression failed to evaluate. Check for typos in property names or invalid JavaScript expressions. Also emitted as a warning when store shorthand ($store.path) is used in data-model.

A data-bind-class expression failed to evaluate. Check that the expression returns a valid string or object.

Creating a context for a data-bind-html binding failed. Check that the binding path is valid.

Updating a data-show or data-render conditional context failed. Check that the bound expression evaluates to a boolean-like value.

A data-bind-class binding received a value that is not a string. The element-level path expects a space-separated class string. Inline expressions can use the {'class-name': condition} object form, but a computed property should return the resolved string itself. The framework coerces the value (truthy keys joined to a string, or the value stringified) so the page keeps rendering, but the underlying mismatch should be fixed in your code.

Wrong: computed: { classes() { return { 'is-active': this.active }; } }
Right: computed: { classes() { return this.active ? 'is-active' : ''; } }

A data-prop-* (or data-props) value looked like a path, resolved to undefined, and was still absent from the parent's state, computed properties, and methods after the page settled. A typo'd path is indistinguishable from a real prop at resolution time, so the check waits out the init window first; a parent that sets the key in init() stays silent, as does a prop whose declared default absorbed the miss. The warning suggests the closest matching parent name. If the parent genuinely provides the value later (for example after a fetch), the note can be ignored. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A data-prop-* attribute (or a key inside data-props) was passed to a component that never declared that prop, so the value is never read. Only declared props are consumed; this is the prop-name sibling of WF-507's path typo (data-prop-titel against a declared title, or data-prop-user-id against userId). When the component declares props, the warning suggests the closest declared name; when the component has no props block at all, every prop attribute on it is dead and the warning shows the declaration to add (props: { title: { type: String } }). Fix the attribute name or declare the prop. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A binding references a name that does not resolve: a data-bind/data-model/data-show/data-render path, an identifier inside a class or style binding expression, a nested path segment, a type hint that does not match the value, or a data-action method that does not exist on the component. The development build warns at bind time with a did-you-mean and the list of available names. On by default in development builds; disable with debug: false. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The bulk data-props attribute could not be parsed as JSON, so no props were passed. Common causes are single quotes instead of double quotes around keys and strings, or unescaped quotes inside values. For dynamic values, prefer individual data-prop-* attributes with paths. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A data-action handler method threw an exception. Check the method referenced in your data-action attribute.

A component method execution failed. Check the method for runtime errors such as accessing undefined properties.

emit() was called but the component instance could not be located. Ensure the component is mounted and initialized.

A data-action points at init, tick, destroy, or another lifecycle hook. Lifecycle names run on the framework's schedule, not on events: tick() runs every animation frame, destroy() tears the component down, and with the element still in the DOM the next scan auto-resurrects it. Rename the handler to a specific verb (increment, handleClick, refresh). Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

An action fired before init() finished was queued and replayed afterward, and the handler then called preventDefault(), stopPropagation(), or stopImmediatePropagation() on the original event. By replay time the browser has already processed the event, so the call is a no-op. Put data-event-prevent on the element to block the default reliably; the framework intercepts before user code runs. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

$entity.path is a read accessor for external state and cannot name an action handler; actions are component-locked by design. To delegate to another entity's method, define a one-line wrapper on the component: bump() { this.getStore('name').bump(); }. The warning shows the exact wrapper for the path you wrote. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

emit() was called but the component's context is unavailable. The component may have been destroyed.

Navigation attempted to access a route that hasn't been defined. Check your route configuration.

A route alias points to a target route that doesn't exist. Verify the alias target matches a defined route path.

A navigation guard function (beforeEnter, beforeLeave, etc.) threw an exception. Check the guard function for errors.

The navigation queue has exceeded its maximum retry attempts. This usually indicates a redirect loop in your route guards.

Navigation by name references a route that doesn't exist. Check the name property in your route definitions.

A route definition has an invalid structure. Routes require at minimum a path property.

Attempting to initialize the router more than once. The router should only be configured and started once per application.

No route pattern matches the requested URL path. Consider adding a catch-all route (path: '*') for 404 handling.

A route's handler function threw an exception during execution.

An async/lazy-loaded route component failed to load. Check the network request and module path.

The scroll restoration or positioning function threw an exception after navigation.

A route lifecycle hook (beforeEnter, afterEnter, etc.) threw an exception.

Server-side rendered component activation failed. The server-rendered HTML may not match the expected component structure.

Hydrating server-rendered HTML encountered an error. Ensure the server-rendered markup matches the client component's expected structure.

wildflower.store() was called with a non-string first argument. The store name must be a string.

wildflower.store() was called with a non-object second argument. The store definition must be a plain object.

A store's init() lifecycle hook threw an exception. Check the store's initialization logic.

The store creation process failed. Check the store definition for structural errors.

external() failed when accessing a store. Verify the store name and property path are correct.

A store subscription callback threw an exception. Check the function passed to the store's subscribe() method.

Automatic creation of the default application store failed. This is an internal initialization error.

An onStoreUpdate handler wrote the store path it was being notified for, which would loop forever. The engine drops the nested notification and keeps the write, so the cycle cannot hang the page; the warning names the store and path. Derive the value with a computed instead, or write a different path. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A component subscribes to, watches, or path-subscribes a store name that nothing ever registered. The miss is reported (error severity for subscribe:, warning for watchers) and init continues best-effort so the rest of the component works. Fix the name, or register the store before the component initializes. Dev-mode only, stripped from production builds.

A subscribed store exists but did not become ready within the wait window (default 5000ms; per-component override via subscribeTimeout in the definition). The component's onError hook receives the timeout and init continues best-effort. Check the store's async init() for work that never resolves. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A field on a query's backing store (rows, isLoading, isStale, error, syncError, lastSync) was assigned from application code. Query stores are engine-owned: the fetch pipeline rewrites them on every sync, so an application write survives only until the next refresh replaces it. The supported pattern is to mutate the data source, then call wildflower.getQuery('name').invalidate(). The write still lands, since a deliberate optimistic update is legitimate; the warning fires once per store. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A second wildflower.query() call used a name that is already registered. The second registration is ignored and the existing query's handle is returned, so config changes in the second call never apply. Declare each query once, at module scope. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

Queries and stores share one entity namespace, because every query is backed by a store of the same name. A wildflower.query() call whose name matches an existing store is refused (null is returned) rather than silently taking over the store's data. Pick a name no store uses. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The from option must be a URL string or a function returning the data (or a Promise of it). Registration is refused (null is returned). There are no other source types: anything beyond a URL is expressed as a function. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A numeric refresh rung below 1 is almost always a units mistake: poll values are seconds, so 0.5 means twice per second (120 requests per minute against the source), where the author usually meant "every 30 seconds". The rung still runs as declared. If sub-second polling is genuinely intended, the warning can be ignored. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

Fires in two shapes that share this code: a data-query attribute in markup names a query that was never declared (the element is left untransformed and never activates), or getQuery('name') is called for an unregistered name (returns undefined). Register the query with wildflower.query('name', { from: ... }) before the markup mounts, and check for typos between the attribute and the declaration. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A data-seed attribute on an adopted row or query element could not be parsed as a JSON object, so its fields were ignored; the row keeps only what the display text parse recovered. Common causes are single quotes inside the JSON, unquoted keys, or a non-object value (arrays are ignored by design). Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The 'sse' rung opens an EventSource, which requires a URL. When from is a URL string it doubles as the stream endpoint, but when from is a function there is nothing to connect to, so the rung is skipped (other declared rungs still run). Add a stream: option naming the SSE endpoint. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The stream contract: a JSON message body is applied as the new result, an empty message is an invalidation signal (conditional refetch). A non-empty message that fails to parse as JSON fits neither, so the engine degrades it to an invalidation and refetches, keeping data correct at the cost of one extra request. Fix the server to send JSON bodies or empty invalidation pings. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

A record-shaped query's source resolved to null or undefined. This is a valid empty context by design: bound fields render empty and nothing throws, matching "no result yet" states like a logged-out session. The warning exists because a permanently null record often means the source returns a wrapper shape ({ data: {...} }) rather than the record itself. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

An append refresh (refresh({ params, append: true })) received rows that lack the query's declared key field. Accumulation identifies rows by key to dedupe and merge, so keyless rows would duplicate endlessly; the engine applies the result as a plain replace instead and warns. Give appended rows the declared key, or declare the key the source actually returns. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

refresh() takes an options object with exactly two recognized fields, params and append. Any other key is almost always request parameters passed directly (refresh({ status: 'open' })), which the engine cannot distinguish from an option name and therefore never sends. Nest them: refresh({ params: { status: 'open' } }). Keeping parameters inside params is what guarantees no request parameter can ever collide with an option name. The refresh still runs, without the stray values. Warning severity (console.warn, never throws); dev-mode only, stripped from production builds.

The CSP-safe expression parser encountered syntax it cannot parse. Simplify your binding expression or check for syntax errors.

The expression contains a syntax construct not supported by the CSP-safe expression parser. The parser supports literals, identifiers, member access, binary/logical/unary/conditional expressions, array expressions, and function calls. Anything else (arrow functions, template literals, object literals, destructuring, assignment, etc.) triggers this error. Simplify the expression or move the logic into a computed property or component method.

CSP security policy blocked one of: (1) a blocked global identifier (window, document, eval, Function, fetch, setTimeout, and others); (2) a blocked property access (__proto__, prototype, constructor); or (3) a function call other than external(). In CSP mode, only external() is permitted as a function call in binding expressions.

A binding tried to write a value the security layer refuses by design: a javascript: or vbscript: URL, a scriptable data: URI in a URL attribute (raster image formats are allowed), or a blacklisted attribute such as inline event handlers. The write is dropped in every build; the warning fires in dev builds. This is a policy outcome, not an error. If you control the value, use a safe scheme; if the value is user-supplied, the block is doing its job.

A router outlet is rendering HTML with no sanitizer configured. If the HTML can ever include user-supplied content, configure one with wildflower.setHtmlSanitizer() (for example DOMPurify) to prevent XSS. For fully static, author-controlled HTML the notice can be ignored. Warning severity (console.warn, never throws).

The render effect system failed to resolve a binding path during a reactive update. The bound property may not exist on the component's state.