fix: unconstrained liveArrays handle inserts and deletes from their own subscription

[jimmy-phantom]

What was broken

A liveArray declared without constraints never gained or lost rows in response to its own query's subscribe. Updates to rows already in the list did apply, which made the failure easy to miss: values changed, but nothing was ever added or removed.

Event from the query's subscribe	Before	After
update to a row already in the list	applies	applies
update that changes the sort field	re-sorts	re-sorts
update for a row not in the list	ignored	inserts
create for a row not in the list	ignored	inserts
delete	ignored	removes

This is the shape a paginated list with a live stream wants: fetch a page over REST, then keep it current from a subscription.

Why

A live collection is registered against the entity that owns it. For a query result that owner is the result's root entity, but a query's subscribe tagged its events with the query key instead. The two are derived from different inputs, so the tag matched no collection and membership events were dropped.

Row updates still worked because they take the entity merge path, which doesn't depend on that tag.

The fix

Tag events with the root entity's key, which is what the collection is actually registered under. Entity __subscribe already works this way, so this makes the query path consistent with it.

Nothing else changes. Constrained collections, entity subscriptions, and external mutation events behave exactly as before, and an unconstrained collection still ignores everything except its own source.

Tests

• Membership events from the query's own subscription: an unseen update and a create insert, delete removes, sort order is maintained throughout.
• Scoping, two ways: same query with different params, and two different queries with identical params. In both cases an event reaches only the collection belonging to the query that emitted it.

Full suite passes: 1247 passed, 2 skipped, 65 files.

Implementation notes

createLiveCollection gives an unconstrained collection the default constraint [[EVENT_SOURCE_FIELD, parent.key]], meaning "events originating from my own source." reconcileSubscription set __eventSource to queryKey (a hash of the query definition and raw params), while the root entity's key comes from the injected QUERY_ID (a hash of extracted params). ConstraintMatcher.routeEvent therefore computed a hash matching no registered binding.

rootEntity is undefined until the first apply, and reconcileSubscription deliberately runs before the first fetch so stream-resolved adapters are subscribed in time. Events in that window leave the source undefined, which skips collection routing while still merging into the entity store. There is no collection to route into yet, and __eventSource is already optional on all three event types.

No changes were needed below the routing layer. LiveArrayInstance.onEvent already handles create, update when the key is absent, and delete, with _keys guards making both directions idempotent.

Supersedes #44, which pinned the previous behavior.

🤖 Generated with Claude Code