@barefootjs/client 0.10.0 → 0.11.0

package/src/profiler-events.ts

@@ -0,0 +1,89 @@
+/**
+ * Profiler event collection (#1690, SR2).
+ *
+ * The reactive runtime (`reactive.ts`) reports raw instrumentation through a
+ * `ProfilerEventSink` (SR1). This module turns that callback stream into a
+ * flat, ordered, **turn-stamped** event log — the normalized SR2 contract the
+ * analyses (hot subscribers / wasted re-runs / batch advisor) and the SR4 IR
+ * join consume.
+ *
+ * The collector is the one place that knows the *current turn*: it tracks the
+ * `beginTurn`/`endTurn` stack (SR3) and stamps every event with the handler id
+ * in scope when it fired, so per-turn metrics (batch savings, runs/turn) need
+ * no microtask guesswork.
+ *
+ * Dev-only (SR8): nothing here runs unless `setProfilerSink` is handed a
+ * recording sink, which only the instrumented/profile build does.
+ */
+
+import type { ProfilerEventSink } from "./reactive.ts"
+import type { ProfilerEvent } from '@barefootjs/shared'
+
+// The event wire contract lives in `@barefootjs/shared` (built first, depended
+// on by both this runtime and the jsx analyses) — see that module for why.
+export type { ProfilerEvent, ProfilerEventType } from '@barefootjs/shared'
+
+export interface RecordingSink {
+  /** The sink to hand to `setProfilerSink(...)`. */
+  sink: ProfilerEventSink
+  /** The collected event log, in emission order. */
+  events: ProfilerEvent[]
+  /** Clear the log and the internal turn stack (start a fresh scenario). */
+  reset(): void
+}
+
+/**
+ * Build a recording sink (SR2). Hand `.sink` to `setProfilerSink`, drive a
+ * scenario, then read `.events` — a turn-stamped, ordered log ready for the
+ * SR4 join and the analyses. Turns may nest (a handler that dispatches another
+ * handler); the stack's top is the attributed turn.
+ */
+export function createRecordingSink(): RecordingSink {
+  const events: ProfilerEvent[] = []
+  // Each entry is one turn *invocation*: its handler id + a unique instance seq,
+  // so repeated calls of the same handler are distinct turns.
+  const turnStack: { handlerId: string; turnSeq: number }[] = []
+  let seq = 0
+  let turnCounter = 0
+
+  const top = () => (turnStack.length > 0 ? turnStack[turnStack.length - 1] : null)
+
+  const push = (e: Omit<ProfilerEvent, 'seq' | 'turn' | 'turnSeq'>): void => {
+    const t = top()
+    events.push({ seq: seq++, turn: t?.handlerId ?? null, turnSeq: t?.turnSeq ?? null, ...e })
+  }
+
+  const sink: ProfilerEventSink = {
+    signalSet: (id, batched) => push({ type: 'signalSet', signal: id, batched }),
+    subscribeAdd: (signal, subscriber) => push({ type: 'subscribeAdd', signal, subscriber }),
+    subscribeRemove: (signal, subscriber) => push({ type: 'subscribeRemove', signal, subscriber }),
+    effectCreate: (id, kind) => push({ type: 'effectCreate', subscriber: id, kind }),
+    effectEnter: (id) => push({ type: 'effectEnter', subscriber: id }),
+    effectExit: (id, dur) => push({ type: 'effectExit', subscriber: id, dur }),
+    effectOutput: (id, changed) => push({ type: 'effectOutput', subscriber: id, changed }),
+    effectDispose: (id) => push({ type: 'effectDispose', subscriber: id }),
+    batchBegin: (depth) => push({ type: 'batchBegin', depth }),
+    batchFlush: (flushed) => push({ type: 'batchFlush', flushed }),
+    turnBegin: (handlerId, loc) => {
+      // Record before pushing so the marker carries the *parent* turn, then
+      // open the new turn (a fresh invocation instance) for everything that follows.
+      push({ type: 'turnBegin', handlerId, loc })
+      turnStack.push({ handlerId, turnSeq: ++turnCounter })
+    },
+    turnEnd: () => {
+      turnStack.pop()
+      push({ type: 'turnEnd' })
+    },
+  }
+
+  return {
+    sink,
+    events,
+    reset() {
+      events.length = 0
+      turnStack.length = 0
+      seq = 0
+      turnCounter = 0
+    },
+  }
+}

package/src/reactive.ts

@@ -23,14 +23,136 @@ export type CleanupFn = () => void
 export type EffectFn = () => void | CleanupFn
 export type Memo<T> = Reactive<() => T>
 
+// -- Dev-only instrumentation (SR1 / SR8, #1690) ------------------------------
+//
+// A single, gated sink the reactive choke points call when profiling is on.
+// When `profilerSink` is null (the production default) every choke point is a
+// single null-check branch with no allocation, and the sink + id params
+// dead-code-eliminate from prod builds since they are never set (#1690).
+// The sink, its state, and the identity bookkeeping all live in this module
+// because `reactive.ts` is published as one physical entry
+// (`@barefootjs/client/reactive`); splitting the sink into a sibling file
+// would bundle a second copy into this entry and break the live binding.
+
+export type SubscriberKind = 'effect' | 'memo' | 'root'
+
+/**
+ * Reactive measurement hooks. Every method is a measurement-only notification —
+ * implementations MUST NOT mutate reactive state or throw (a throw would change
+ * `set()`'s synchronous semantics). Ids are stable handles; `''` means the
+ * node was created while profiling was off. The compiler will later emit
+ * IR-aligned ids (SR3); until then ids are runtime-assigned counters.
+ */
+export interface ProfilerEventSink {
+  /** A signal's value changed (post `Object.is` bail). `batched` = inside `batch()`. */
+  signalSet(signalId: string, batched: boolean): void
+  /** A subscriber began reading a signal (dependency edge added). */
+  subscribeAdd(signalId: string, subscriberId: string): void
+  /** A subscriber stopped reading a signal (edge removed on re-run / dispose). */
+  subscribeRemove(signalId: string, subscriberId: string): void
+  /** An effect / memo / root scope was created. */
+  effectCreate(subscriberId: string, kind: SubscriberKind): void
+  /** An effect/memo body is about to run. */
+  effectEnter(subscriberId: string): void
+  /** An effect/memo body finished. `durationMs` is wall time. */
+  effectExit(subscriberId: string, durationMs: number): void
+  /**
+   * An effect/memo run produced an output fingerprint (#1690, §4.2.2).
+   * `changed` is `true` when the run produced new output (a memo value that
+   * differs by `Object.is`, or a DOM write that changed the node) and `false`
+   * when it recomputed but produced output identical to its previous run — a
+   * *wasted* re-run. Emitted at most once per run, only for runs whose output
+   * is fingerprintable (memo recompute / instrumented DOM write); a run that
+   * reports no output emits no event and isn't counted as wasted.
+   *
+   * Optional: it was added after the initial sink contract, so a pre-existing
+   * custom sink that omits it stays valid (the call site guards with `?.`). A
+   * sink without it simply opts out of the wasted-re-runs analysis.
+   */
+  effectOutput?(subscriberId: string, changed: boolean): void
+  /** An effect / memo / root scope was disposed. */
+  effectDispose(subscriberId: string): void
+  /** A `batch()` block opened at the given (post-increment) depth. */
+  batchBegin(depth: number): void
+  /** A batch flush ran `flushed` effects. */
+  batchFlush(flushed: number): void
+  /**
+   * A user interaction (one event handler invocation) began. Compiler-emitted
+   * `beginTurn(...)` wraps the handler body so subsequent events in this turn
+   * are attributed to `handlerId`. `loc` is the optional source location.
+   */
+  turnBegin(handlerId: string, loc?: string): void
+  /** The current turn ended (handler returned). */
+  turnEnd(): void
+}
+
+/** A signal's subscriber set, tagged with the signal's id for edge-removal events. */
+type SubscriberSet = Set<EffectContext> & { __bfSignalId?: string }
+
+let profilerSink: ProfilerEventSink | null = null
+let signalSeq = 0
+let subscriberSeq = 0
+
+/**
+ * Install (or clear) the dev-only reactive measurement sink. Pass `null` to
+ * disable. Calling this before a scenario runs lets `bf debug profile` collect
+ * the event stream; production code never calls it, so the sink stays null and
+ * the choke points stay free (dev-only instrumentation, #1690).
+ */
+export function setProfilerSink(sink: ProfilerEventSink | null): void {
+  profilerSink = sink
+}
+
+/**
+ * Mark the start of a user-interaction turn (#1690, SR3). Compiler-emitted in
+ * profile mode at every event-handler boundary as
+ * `beginTurn(handlerId, loc); try { … } finally { endTurn() }`. Measurement
+ * only — it does not change `set()`'s synchronous semantics; it just stamps a
+ * turn onto the events emitted between begin and end. No-op when profiling is
+ * off.
+ */
+export function beginTurn(handlerId: string, loc?: string): void {
+  if (profilerSink) profilerSink.turnBegin(handlerId, loc)
+}
+
+/** Mark the end of the current interaction turn (#1690, SR3). */
+export function endTurn(): void {
+  if (profilerSink) profilerSink.turnEnd()
+}
+
+/**
+ * Report the current run's output fingerprint (#1690, §4.2.2). Called from the
+ * places that produce an effect's observable output — a memo recompute (the
+ * written value's `Object.is` identity) and instrumented DOM writes (whether the
+ * node actually changed). Accumulated onto the running effect (`Owner`) and
+ * flushed as one `effectOutput` event at run exit, so several writes in one run
+ * collapse to a single "did this run change anything" verdict.
+ *
+ * No-op when profiling is off or called outside a run — the wasted-re-runs
+ * analysis is the only consumer and it lives behind the dev-only sink (SR8).
+ */
+export function __bfReportOutput(changed: boolean): void {
+  if (!profilerSink || !Owner) return
+  Owner.outputReported = true
+  if (changed) Owner.outputChanged = true
+}
+
 type EffectContext = {
   fn: EffectFn
   cleanup: CleanupFn | null
-  dependencies: Set<Set<EffectContext>>
+  dependencies: Set<SubscriberSet>
   owner: EffectContext | null   // Parent scope for hierarchical disposal
   children: EffectContext[]     // Owned child effects/roots
   disposed: boolean
   runCount: number              // Per-effect re-entry counter for circular dependency detection
+  id: string                    // Dev instrumentation id ('' when profiling is off)
+  kind: SubscriberKind          // effect | memo | root
+  // Per-run output fingerprint accumulator (SR1, §4.2.2). Reset at the start of
+  // every run; set by `__bfReportOutput` (memo recompute / DOM write) during the
+  // body; flushed as one `effectOutput` event at exit. Dev-only — untouched when
+  // profiling is off.
+  outputReported: boolean
+  outputChanged: boolean
 }
 
 let Owner: EffectContext | null = null
@@ -52,14 +174,19 @@ const PendingEffects = new Set<EffectContext>()
  * setCount(5)          // Update to 5
  * setCount(n => n + 1) // Update with function (becomes 6)
  */
-export function createSignal<T>(initialValue: T): Signal<T> {
+export function createSignal<T>(initialValue: T, __bfId?: string): Signal<T> {
   let value = initialValue
-  const subscribers = new Set<EffectContext>()
+  const subscribers: SubscriberSet = new Set<EffectContext>()
+  // Tag the subscriber set so edge-removal events (which only see the set) can
+  // name the signal. Resolved once per creation; '' when profiling is off.
+  const id = __bfId ?? (profilerSink ? `s${++signalSeq}` : '')
+  subscribers.__bfSignalId = id
 
   const get = () => {
     if (Listener) {
       subscribers.add(Listener)
       Listener.dependencies.add(subscribers)
+      if (profilerSink) profilerSink.subscribeAdd(id, Listener.id)
     }
     return value
   }
@@ -75,6 +202,8 @@ export function createSignal<T>(initialValue: T): Signal<T> {
 
     value = newValue
 
+    if (profilerSink) profilerSink.signalSet(id, BatchDepth > 0)
+
     if (BatchDepth > 0) {
       for (const effect of subscribers) {
         PendingEffects.add(effect)
@@ -102,7 +231,7 @@ export function createSignal<T>(initialValue: T): Signal<T> {
  * })
  * setCount(1)  // Logs "count changed: 1"
  */
-export function createEffect(fn: EffectFn): void {
+export function createEffect(fn: EffectFn, __bfId?: string, __bfKind: SubscriberKind = 'effect'): void {
   // Note: Nested effects are now allowed. runEffect() properly saves/restores
   // prevEffect, so nested effects correctly track their own dependencies.
   // This enables synchronous component initialization in reconcileList.
@@ -115,8 +244,14 @@ export function createEffect(fn: EffectFn): void {
     children: [],
     disposed: false,
     runCount: 0,
+    id: __bfId ?? (profilerSink ? `e${++subscriberSeq}` : ''),
+    kind: __bfKind,
+    outputReported: false,
+    outputChanged: false,
   }
 
+  if (profilerSink) profilerSink.effectCreate(effect.id, effect.kind)
+
   // Register with parent owner for hierarchical disposal
   if (Owner) Owner.children.push(effect)
 
@@ -132,6 +267,14 @@ function runEffect(effect: EffectContext): void {
     throw new Error(`Circular dependency detected: effect re-entered itself ${MAX_EFFECT_RUNS} times.`)
   }
 
+  // `effectEnter` is emitted *before* cleanup so the whole run — cleanup
+  // included — is bracketed by enter/exit. A `set()` performed inside a cleanup
+  // is then recorded at effect-stack depth > 0 (a cascade write) rather than
+  // depth 0 (a direct handler write), which keeps the batch advisor's write
+  // gate sound (#1865). Dev-only: in production `profilerSink` is null and this
+  // is a no-op, so the run is byte-identical to the un-instrumented path.
+  if (profilerSink) profilerSink.effectEnter(effect.id)
+
   if (effect.cleanup) {
     effect.cleanup()
     effect.cleanup = null
@@ -139,6 +282,7 @@ function runEffect(effect: EffectContext): void {
 
   for (const dep of effect.dependencies) {
     dep.delete(effect)
+    if (profilerSink) profilerSink.subscribeRemove(dep.__bfSignalId ?? '', effect.id)
   }
   effect.dependencies.clear()
 
@@ -147,6 +291,14 @@ function runEffect(effect: EffectContext): void {
   Owner = effect
   Listener = effect
 
+  // Fresh output fingerprint for this run (§4.2.2); `__bfReportOutput` fills it.
+  effect.outputReported = false
+  effect.outputChanged = false
+
+  // `start` stays here (after cleanup) so the reported duration measures the
+  // effect body only, unchanged by moving `effectEnter` above.
+  const start = profilerSink ? performance.now() : 0
+
   try {
     const result = effect.fn()
     if (typeof result === 'function') {
@@ -156,6 +308,10 @@ function runEffect(effect: EffectContext): void {
     Owner = prevOwner
     Listener = prevListener
     effect.runCount--
+    if (profilerSink) {
+      profilerSink.effectExit(effect.id, performance.now() - start)
+      if (effect.outputReported) profilerSink.effectOutput?.(effect.id, effect.outputChanged)
+    }
   }
 }
 
@@ -181,9 +337,12 @@ function disposeSubtree(effect: EffectContext): void {
 
   for (const dep of effect.dependencies) {
     dep.delete(effect)
+    if (profilerSink) profilerSink.subscribeRemove(dep.__bfSignalId ?? '', effect.id)
   }
   effect.dependencies.clear()
 
+  if (profilerSink) profilerSink.effectDispose(effect.id)
+
   effect.owner = null
 }
 
@@ -226,8 +385,14 @@ export function createRoot<T>(fn: (dispose: () => void) => T): T {
     children: [],
     disposed: false,
     runCount: 0,
+    id: profilerSink ? `r${++subscriberSeq}` : '',
+    kind: 'root',
+    outputReported: false,
+    outputChanged: false,
   }
 
+  if (profilerSink) profilerSink.effectCreate(root.id, 'root')
+
   if (Owner) Owner.children.push(root)
 
   const prevOwner = Owner
@@ -249,7 +414,7 @@ export function createRoot<T>(fn: (dispose: () => void) => T): T {
  *
  * @returns A dispose function that stops the effect and removes it from all signal dependencies.
  */
-export function createDisposableEffect(fn: EffectFn): () => void {
+export function createDisposableEffect(fn: EffectFn, __bfId?: string): () => void {
   let disposed = false
 
   const effect: EffectContext = {
@@ -263,8 +428,14 @@ export function createDisposableEffect(fn: EffectFn): () => void {
     children: [],
     disposed: false,
     runCount: 0,
+    id: __bfId ?? (profilerSink ? `e${++subscriberSeq}` : ''),
+    kind: 'effect',
+    outputReported: false,
+    outputChanged: false,
   }
 
+  if (profilerSink) profilerSink.effectCreate(effect.id, effect.kind)
+
   if (Owner) Owner.children.push(effect)
 
   runEffect(effect)
@@ -342,6 +513,7 @@ export function untrack<T>(fn: () => T): T {
  */
 export function batch<T>(fn: () => T): T {
   BatchDepth++
+  if (profilerSink) profilerSink.batchBegin(BatchDepth)
   try {
     return fn()
   } finally {
@@ -356,6 +528,7 @@ function flushEffects(): void {
   while (PendingEffects.size > 0) {
     const effects = [...PendingEffects]
     PendingEffects.clear()
+    if (profilerSink) profilerSink.batchFlush(effects.length)
     for (const effect of effects) {
       runEffect(effect)
     }
@@ -398,13 +571,28 @@ export function onMount(fn: () => void): void {
  * setCount(5)
  * doubled()    // 10
  */
-export function createMemo<T>(fn: () => T): Memo<T> {
-  const [value, setValue] = createSignal<T>(undefined as T)
+export function createMemo<T>(fn: () => T, __bfId?: string): Memo<T> {
+  // A memo is an effect that writes a private signal. Share one id across both
+  // so the profiler's IR join can collapse the effect-run + signal-set pair
+  // back into a single memo node (#1690).
+  const id = __bfId ?? (profilerSink ? `m${++subscriberSeq}` : '')
+  const [value, setValue] = createSignal<T>(undefined as T, id)
+
+  // Memo output fingerprint (§4.2.2): a recompute that yields an `Object.is`-equal
+  // value is a wasted re-run. Tracked here (not via the private signal's bail)
+  // so the first run reads as a genuine output, never as "unchanged".
+  let prev: T
+  let hasPrev = false
 
   createEffect(() => {
     const result = fn()
+    if (profilerSink) {
+      __bfReportOutput(!hasPrev || !Object.is(prev, result))
+      prev = result
+      hasPrev = true
+    }
     setValue(() => result)
-  })
+  }, id, 'memo')
 
   return value
 }

package/src/runtime/dynamic-text.ts

@@ -10,6 +10,11 @@
  * returned by `createComponent`. Stringifying it produced
  * `"[object HTMLElement]"` (and clobbered the server-rendered subtree).
  *
+ * Profiler note (#1690, §4.2.2): each write reports an output fingerprint via
+ * `__bfReportOutput` — `false` when the slot already held the same text/node, so
+ * the wasted-re-runs analysis can flag a text binding that re-ran without
+ * changing the DOM. Dev-only: `__bfReportOutput` is a no-op when profiling is off.
+ *
  * `__bfText` mirrors `__bfSlot` (the branch-template equivalent): when the
  * value is a `Node`, it replaces the slot region with that node by identity;
  * otherwise it behaves exactly like the previous text assignment. It returns
@@ -17,22 +22,32 @@
  * reactive re-runs (the previous node is detached once replaced).
  */
 
+import { __bfReportOutput } from '@barefootjs/client/reactive'
+
 const END_MARKER = '/'
 
 /** Remove every sibling between `start` (the `<!--bf:sX-->` comment) and the
  *  matching `<!--/-->` end comment, leaving both markers in place. When `keep`
  *  is supplied that node is left in place (used when writing a primitive
- *  through a text anchor that must survive while stale siblings are cleared). */
-function clearSlotRegion(start: Node, keep?: Node): void {
+ *  through a text anchor that must survive while stale siblings are cleared).
+ *  Returns whether it actually removed any node, so the profiler fingerprint
+ *  (§4.2.2) can treat a stale-element cleanup as a real DOM change even when the
+ *  written text is unchanged. */
+function clearSlotRegion(start: Node, keep?: Node): boolean {
+  let removed = false
   let n = start.nextSibling
   while (
     n &&
     !(n.nodeType === Node.COMMENT_NODE && (n as Comment).nodeValue === END_MARKER)
   ) {
     const next = n.nextSibling
-    if (n !== keep) n.parentNode?.removeChild(n)
+    if (n !== keep) {
+      n.parentNode?.removeChild(n)
+      removed = true
+    }
     n = next
   }
+  return removed
 }
 
 /** Walk back from `node` to the nearest preceding comment marker (the slot's
@@ -49,8 +64,12 @@ export function __bfText(current: Node | null, value: unknown): Node | null {
   if (value != null && (value as { __isSlot?: boolean }).__isSlot) return current
 
   if (typeof Node !== 'undefined' && value instanceof Node) {
-    if (value === current) return current
+    if (value === current) {
+      __bfReportOutput(false) // same node already in the slot — nothing changed
+      return current
+    }
     const start = current.previousSibling
+    __bfReportOutput(true)
     if (start && start.nodeType === Node.COMMENT_NODE) {
       clearSlotRegion(start)
       start.parentNode?.insertBefore(value, start.nextSibling)
@@ -63,6 +82,7 @@ export function __bfText(current: Node | null, value: unknown): Node | null {
 
   const text = String(value ?? '')
   if (current.nodeType === Node.TEXT_NODE) {
+    const textChanged = current.nodeValue !== text
     current.nodeValue = text
     // The conditional-slot path re-resolves the anchor via `$t()` on every
     // run, which can hand back a freshly created text node sitting *before* a
@@ -70,12 +90,17 @@ export function __bfText(current: Node | null, value: unknown): Node | null {
     // siblings up to the end marker so switching JSX → text doesn't render
     // both the old element and the new text.
     const start = slotStart(current)
-    if (start && start.nodeType === Node.COMMENT_NODE) clearSlotRegion(start, current)
+    const clearedStale =
+      start != null && start.nodeType === Node.COMMENT_NODE && clearSlotRegion(start, current)
+    // Removing a stale element is a real DOM change even when the text matched,
+    // so the run isn't wasted in that case (§4.2.2).
+    __bfReportOutput(textChanged || clearedStale)
     return current
   }
 
   // Switching back from a Node value to text: drop the element and restore a
   // text node in the slot region.
+  __bfReportOutput(true)
   const start = current.previousSibling
   const textNode = (current.ownerDocument ?? document).createTextNode(text)
   if (start && start.nodeType === Node.COMMENT_NODE) {

package/src/runtime/index.ts

@@ -18,13 +18,26 @@ export {
   onMount,
   untrack,
   batch,
+  setProfilerSink,
+  beginTurn,
+  endTurn,
+  __bfReportOutput,
   type Reactive,
   type Signal,
   type Memo,
   type CleanupFn,
   type EffectFn,
+  type ProfilerEventSink,
+  type SubscriberKind,
 } from '@barefootjs/client/reactive'
 
+export {
+  createRecordingSink,
+  type ProfilerEvent,
+  type ProfilerEventType,
+  type RecordingSink,
+} from '../profiler-events.ts'
+
 export { splitProps } from '../split-props.ts'
 export { __slot, type SlotMarker } from '../slot.ts'
 export { forwardProps } from '../forward-props.ts'

package/src/runtime/insert.ts

@@ -182,7 +182,8 @@ export function insert(
   id: string,
   conditionFn: () => boolean,
   whenTrue: BranchConfig,
-  whenFalse: BranchConfig
+  whenFalse: BranchConfig,
+  bfId?: string
 ): void {
   if (!scope) return
 
@@ -325,7 +326,7 @@ export function insert(
 
     // Auto-focus elements with autofocus attribute (for dynamically created elements)
     autoFocusConditionalElement(region, id)
-  })
+  }, bfId)
 }
 
 

package/src/runtime/map-array.ts

@@ -222,6 +222,7 @@ export function mapArray<T>(
   getKey: ((item: T, index: number) => string) | null,
   renderItem: (item: () => T, index: number, existing?: HTMLElement) => HTMLElement,
   markerId?: string,
+  bfId?: string,
 ): void {
   if (!container) return
 
@@ -389,7 +390,7 @@ export function mapArray<T>(
         insertScope(scope, container, anchor)
       }
     }
-  })
+  }, bfId)
 }
 
 // ---------------------------------------------------------------------------
@@ -521,6 +522,7 @@ export function mapArrayAnchored<T>(
   getKey: ((item: T, index: number) => string) | null,
   renderItem: (item: () => T, index: number, existing?: Comment) => DocumentFragment | Comment,
   markerId?: string,
+  bfId?: string,
 ): void {
   if (!container) return
 
@@ -615,5 +617,5 @@ export function mapArrayAnchored<T>(
         placeAnchorScope(scope, container, end, end)
       }
     }
-  })
+  }, bfId)
 }