@bespokeagentics/microdots-host 0.1.0 → 0.1.1

package/src/index.ts

@@ -74,12 +74,102 @@ export {
   WireValueType,
 } from './wire.ts'
 
+/**
+ * The composition IR a spec-filler emits and `compileComposition` consumes.
+ * Surface-derived JSON Schema is the smaller prompt: legal tags/events/attrs
+ * are unrepresentable to invent. See
+ * `wiki/plans/active/microdots-specialist-spec-filler.md`.
+ */
+export {
+  type CompositionIssue,
+  type JsonSchema,
+  CompositionSpec,
+  CompositionSpecV1,
+  CompositionSpecV2,
+  CompositionSpecVersioned,
+  GenerateDotSpec,
+  GenerateDotSpecV1,
+  catalogLocksEqual,
+  compositionJsonSchema,
+  decodeCompositionSpec,
+  decodeCompositionSpecSync,
+  decodeCompositionSpecVersioned,
+  decodeCompositionSpecVersionedSync,
+  encodeCompositionSpecV2Sync,
+  encodeTopologyJson,
+  migrateCompositionSpecV1,
+  validateComposition,
+  validateExistingSurfaceComposition,
+} from './compositionSpec.ts'
+
+/**
+ * Constrained-decode a CompositionSpec from a brief. The JSON Schema is the
+ * prompt; `complete` is the model seam. See
+ * `wiki/plans/active/microdots-specialist-spec-filler.md`.
+ */
+export {
+  type CompleteCompositionJson,
+  type FillCompositionFailure,
+  type FillCompositionOptions,
+  FillCompositionError,
+  compositionPrompt,
+  compositionVocabulary,
+  extractCompositionJson,
+  fillComposition,
+  liveFillPrompt,
+} from './fillComposition.ts'
+
+/**
+ * Catalog-picker → CompositionSpec. `generate[]` is always empty; unknown
+ * tags cannot be represented. See
+ * `wiki/plans/active/microdots-specialist-spec-filler.md`.
+ */
+export {
+  type CompositionLayout,
+  type CompositionWirePick,
+  type ComposeFromSelectionInput,
+  composeExistingSurfacesFromSelection,
+  composeFromSelection,
+  eventFieldsOf,
+  wireableAttributesOf,
+} from './composeFromSelection.ts'
+
+export {
+  TopologyRegressionCaseV1,
+  TopologyRegressionCorpusV1,
+  TopologyRegressionObservationV1,
+  decodeTopologyRegressionCorpusSync,
+  observeTopologyRegressionCase,
+  topologyRegressionSurfaces,
+  type TopologyRegressionCaseV1 as TopologyRegressionCase,
+  type TopologyRegressionCorpusV1 as TopologyRegressionCorpus,
+  type TopologyRegressionObservationV1 as TopologyRegressionObservation,
+} from './topologyRegression.ts'
+
 /**
  * The host slot manifest — Phase 5 work item 1: a host declaring, as data and
  * versioned by theme, where MicroDots may go. Lives inside
  * `host-topology.json` as `HostTopology.slotManifest`.
  */
-export { HostSlotManifest, SlotKind, SlotSpec } from './slots.ts'
+export {
+  HostSlotManifest,
+  SlotKind,
+  SlotLayoutPreset,
+  SlotResizeAxis,
+  SlotSpec,
+} from './slots.ts'
+
+/**
+ * Acquiring a topology at RUNTIME rather than importing it at build — Phase A
+ * of `wiki/plans/active/wiring-live-placement-on-a-remote-host.md`. The decode
+ * is unchanged; only WHEN it runs moves, which is why the failure had to become
+ * a typed error a shell can render rather than a throw at import.
+ */
+export {
+  type TopologyFailureReason,
+  TopologyUnavailable,
+  acquireTopology,
+} from './topologySource.ts'
 
 /**
  * Rules, THE matcher, and the reading-B resolution — Phase 5 work item 3.
@@ -107,7 +197,42 @@ export {
  * tag as the pending list is built, never after) and `mountOverridesFor`
  * (resume overrides dropped when empty BEFORE the merge).
  */
-export { mountOverridesFor, pendingMounts } from './mounting.ts'
+export {
+  type MountedRegistry,
+  makeMountedRegistry,
+  mountOverridesFor,
+  pendingMounts,
+} from './mounting.ts'
+
+/**
+ * Containers for placements the build never knew about — Phase B of
+ * `wiki/plans/active/wiring-live-placement-on-a-remote-host.md`. Markup wins;
+ * these are the fallback for a slot a FETCHED topology added after the page was
+ * built.
+ */
+export {
+  ensureSection,
+  ensureSlot,
+  pruneGeneratedContainers,
+} from './slotDom.ts'
+
+/**
+ * Drag-resize for slots that declare a `resize` axis — the remaining half of
+ * the slot-manifest generalisation in
+ * `wiki/plans/active/wiring-visual-parity-with-the-prototype.md`. Handles are
+ * host chrome; sizes are CSS variables on the section, never a topology write.
+ */
+export {
+  attachSlotResize,
+  chromeOfSlot,
+  clearSlotResize,
+  applySlotSize,
+  restoreSlotResize,
+  SLOT_RESIZE_HANDLE_CLASS,
+  type SlotResizeStorage,
+  slotResizeStorageKey,
+  slotSizeVar,
+} from './slotResize.ts'
 
 /**
  * The placement checks engine — Phase 5 work item 4: six of the spec's seven
@@ -138,7 +263,20 @@ export {
   type WireSkipReason,
   type WireTrace,
   type WireWrite,
+  WIRE_TRACE_EVENT,
   applyTransform,
   attachWireEngine,
   planWires,
 } from './wireEngine.ts'
+
+/**
+ * Host-document POST of engine traces — the seam Watch/Trace poll when the
+ * selected host is not this page. Empty url/key is a no-op (fail closed).
+ */
+export {
+  type PostedWireTrace,
+  type TracePublisher,
+  type TracePublisherOptions,
+  postWireTraces,
+  startTracePublisher,
+} from './tracePublisher.ts'

package/src/mountedRegistry.test.ts

@@ -0,0 +1,196 @@
+import { Option } from 'effect'
+import { beforeEach, describe, expect, test } from 'vitest'
+
+import { makeMountedRegistry, pendingMounts } from './mounting.ts'
+import type { ResolvedPlacement } from './rules.ts'
+
+/**
+ * The unmount half of `activate`, and specifically the window that did not
+ * exist before it.
+ *
+ * `mounting.ts` exists because `filter`-then-`forEach` double-mounted: the
+ * whole predicate pass ran before anything latched, so one tag resolved twice
+ * survived twice. Adding an unmount path creates the MIRROR of that defect — a
+ * tag released while its mount is still awaiting, whose element then appends
+ * after the removal — and a MicroDot that comes back after the user deleted it
+ * is worse than one that never left. Every test below either pins the old
+ * behaviour that must survive or pins that window shut.
+ */
+
+/**
+ * A resolved placement, spelled out rather than produced by `resolvePlacements`
+ * — `pendingMounts` reads only `tag` and `state`, and a literal keeps this
+ * suite about the registry instead of about the resolution.
+ */
+const placement = (tag: string): ResolvedPlacement => ({
+  id: `route:${tag}@${tag}-slot#0`,
+  tag,
+  slotId: `${tag}-slot`,
+  source: { _tag: 'route' },
+  condition: { who: 'any', device: 'any', locale: 'any' },
+  envs: ['dev', 'preview', 'prod'],
+  values: {},
+  span: Option.none(),
+  order: Option.none(),
+  state: 'active',
+  overriddenBy: [],
+})
+
+/**
+ * A mounted element, in a slot, IN THE DOCUMENT.
+ *
+ * `isConnected` is the assertion that matters — "was this actually removed from
+ * the page" — and it is false for any detached tree, so a helper that builds
+ * one off-document would make every removal assertion pass for the wrong
+ * reason.
+ */
+const element = (): Element => {
+  const slot = document.createElement('div')
+  document.body.appendChild(slot)
+  const child = document.createElement('span')
+  slot.appendChild(child)
+  return child
+}
+
+beforeEach(() => {
+  document.body.replaceChildren()
+})
+
+describe('makeMountedRegistry', () => {
+  test('a latched tag is no longer pending — the claim survives the await', () => {
+    const mounted = makeMountedRegistry()
+    const resolved = [placement('a'), placement('b')]
+
+    expect(
+      pendingMounts(resolved, mounted.mountedTags()).map(p => p.tag),
+    ).toEqual(['a', 'b'])
+
+    mounted.latch('a')
+
+    expect(
+      pendingMounts(resolved, mounted.mountedTags()).map(p => p.tag),
+    ).toEqual(['b'])
+  })
+
+  test('retainOnly removes the element and reports what went', () => {
+    const mounted = makeMountedRegistry()
+    const a = element()
+    mounted.latch('a')
+    mounted.adopt('a', a, 'a-slot')
+
+    expect(a.isConnected).toBe(true)
+
+    const gone = mounted.retainOnly(new Map([['b', 'b-slot']]))
+
+    expect(gone).toEqual(['a'])
+    expect(a.isConnected).toBe(false)
+    expect(mounted.mountedTags().has('a')).toBe(false)
+  })
+
+  test('a tag still in `keep` is untouched — navigation must not unmount', () => {
+    const mounted = makeMountedRegistry()
+    const a = element()
+    mounted.latch('a')
+    mounted.adopt('a', a, 'a-slot')
+
+    expect(mounted.retainOnly(new Map([['a', 'a-slot']]))).toEqual([])
+    expect(a.isConnected).toBe(true)
+  })
+
+  test('THE MIRROR BUG: a tag released mid-mount does not append when its mount lands', () => {
+    const mounted = makeMountedRegistry()
+    mounted.latch('a')
+
+    // The topology changed while `mountMicroDot('a')` was still awaiting.
+    expect(mounted.retainOnly(new Map())).toEqual(['a'])
+
+    // ...and now the in-flight mount completes and hands over its element.
+    const late = element()
+    const adopted = mounted.adopt('a', late, 'a-slot')
+
+    expect(adopted).toBe(false)
+    expect(late.isConnected).toBe(false)
+    expect(mounted.mountedTags().has('a')).toBe(false)
+  })
+
+  test('re-appearing after an unmount mounts cleanly — no stale element, no double latch', () => {
+    const mounted = makeMountedRegistry()
+    const first = element()
+    mounted.latch('a')
+    mounted.adopt('a', first, 'a-slot')
+    mounted.retainOnly(new Map())
+
+    // The tag comes back: it is pending again, and adopting a second element
+    // must not leave the first one anywhere.
+    expect(
+      pendingMounts([placement('a')], mounted.mountedTags()).map(p => p.tag),
+    ).toEqual(['a'])
+
+    const second = element()
+    mounted.latch('a')
+
+    expect(mounted.adopt('a', second, 'a-slot')).toBe(true)
+    expect(first.isConnected).toBe(false)
+    expect(second.isConnected).toBe(true)
+    expect([...mounted.mountedTags()]).toEqual(['a'])
+  })
+
+  test('a released tag is pending again, so a FAILED mount retries', () => {
+    const mounted = makeMountedRegistry()
+    mounted.latch('a')
+    mounted.release('a')
+
+    expect(
+      pendingMounts([placement('a')], mounted.mountedTags()).map(p => p.tag),
+    ).toEqual(['a'])
+  })
+
+  test('mountedTags is a copy — a caller cannot mutate the registry through it', () => {
+    const mounted = makeMountedRegistry()
+    mounted.latch('a')
+
+    const snapshot = mounted.mountedTags()
+    mounted.latch('b')
+
+    expect(snapshot.has('b')).toBe(false)
+    expect(mounted.mountedTags().has('b')).toBe(true)
+  })
+
+  test('a placement that MOVES SLOTS is unmounted, so the next pass re-mounts it', () => {
+    const mounted = makeMountedRegistry()
+    const first = element()
+    mounted.latch('a')
+    mounted.adopt('a', first, 'a-slot')
+
+    // Same tag, still placed — but the topology now puts it somewhere else.
+    // A registry keyed on tag alone would see nothing to do here, and the dot
+    // would never move, which reads to a user as the edit being ignored.
+    const moved = mounted.retainOnly(new Map([['a', 'somewhere-else-slot']]))
+
+    expect(moved).toEqual(['a'])
+    expect(first.isConnected).toBe(false)
+    expect(
+      pendingMounts([placement('a')], mounted.mountedTags()).map(p => p.tag),
+    ).toEqual(['a'])
+  })
+
+  test('a tag still in the SAME slot is not disturbed by a topology change', () => {
+    const mounted = makeMountedRegistry()
+    const a = element()
+    mounted.latch('a')
+    mounted.adopt('a', a, 'a-slot')
+
+    expect(mounted.retainOnly(new Map([['a', 'a-slot']]))).toEqual([])
+    expect(a.isConnected).toBe(true)
+  })
+
+  test('a tag still MID-MOUNT is judged on presence alone — it has no slot yet', () => {
+    const mounted = makeMountedRegistry()
+    mounted.latch('a')
+
+    // Present in the new topology, slot unknown: keep the claim rather than
+    // tearing down a mount that has not landed.
+    expect(mounted.retainOnly(new Map([['a', 'anywhere-slot']]))).toEqual([])
+    expect(mounted.mountedTags().has('a')).toBe(true)
+  })
+})

package/src/mounting.test.ts

@@ -69,8 +69,8 @@ describe('pendingMounts', () => {
   test('a tag resolved twice in one list is pending ONCE', () => {
     const topology = topologyOf([
       route('/price', [
-        { tag: 'price-ticker', slotId: 'price-slot' },
-        { tag: 'price-ticker', slotId: 'compare-slot' },
+        { tag: 'readout-view', slotId: 'price-slot' },
+        { tag: 'readout-view', slotId: 'compare-slot' },
       ]),
     ])
     const resolved = resolvePlacements(topology, '/price', 'dev')
@@ -95,7 +95,7 @@ describe('pendingMounts', () => {
       ],
       [
         patternRule('r1', '/*', [
-          { tag: 'price-ticker', slotId: 'price-slot' },
+          { tag: 'readout-view', slotId: 'price-slot' },
         ]),
       ],
     )
@@ -103,7 +103,7 @@ describe('pendingMounts', () => {
 
     expect(resolved.length).toBe(6)
     expect(pendingMounts(resolved, new Set()).map(item => item.tag)).toEqual([
-      'price-ticker',
+      'readout-view',
     ])
   })
 
@@ -111,8 +111,8 @@ describe('pendingMounts', () => {
     // Live today without any rules: the union is over routes, so one tag on
     // two of them is in it twice.
     const topology = topologyOf([
-      route('/price', [{ tag: 'price-ticker', slotId: 'price-slot' }]),
-      route('/all', [{ tag: 'price-ticker', slotId: 'price-slot' }]),
+      route('/price', [{ tag: 'readout-view', slotId: 'price-slot' }]),
+      route('/all', [{ tag: 'readout-view', slotId: 'price-slot' }]),
     ])
     const resolved = overviewUnion(topology)
 
@@ -141,14 +141,14 @@ describe('pendingMounts', () => {
   test('skips a tag already latched by an earlier activation', () => {
     const topology = topologyOf([
       route('/price', [
-        { tag: 'price-ticker', slotId: 'price-slot' },
+        { tag: 'readout-view', slotId: 'price-slot' },
         { tag: 'fleet-health', slotId: 'fleet-slot' },
       ]),
     ])
     const resolved = resolvePlacements(topology, '/price', 'dev')
 
     expect(
-      pendingMounts(resolved, new Set(['price-ticker'])).map(item => item.tag),
+      pendingMounts(resolved, new Set(['readout-view'])).map(item => item.tag),
     ).toEqual(['fleet-health'])
   })
 

package/src/mounting.ts

@@ -88,3 +88,119 @@ export const mountOverridesFor = (
     Object.entries(resume).filter(([, value]) => value !== ''),
   ),
 })
+
+/**
+ * Which tags this shell has mounted, and the element each one produced.
+ *
+ * Until Phase B of `wiki/plans/active/wiring-live-placement-on-a-remote-host.md`
+ * both shells tracked this as a bare `Set<string>` that only ever grew, and
+ * that was deliberate and documented: "a MicroDot is mounted the FIRST time a
+ * route asks for it and never again, so an explicit *Unmount ticker* survives
+ * navigating away and back." **That stays true for ROUTE changes.** What a
+ * grow-only set cannot express is a TOPOLOGY change — a placement that has
+ * left the record entirely — and "appear, disappear, re-appear" is the whole
+ * proof.
+ *
+ * Two structures on purpose:
+ *
+ * - `latched` is every tag CLAIMED, whether its mount is in flight or done. It
+ *   is what `pendingMounts` must see, so a claim made before an await cannot be
+ *   claimed twice.
+ * - `elements` is the subset whose element exists and can be removed.
+ *
+ * **The in-flight window is the whole reason this is a type and not a Map.**
+ * `mounting.ts` already exists because `filter`-then-`forEach` double-mounted
+ * (2026-08-18 review, finding 1); an unmount path introduces the mirror of that
+ * defect — a tag released while its mount is still awaiting would append its
+ * element AFTER the removal, and a dot the user just deleted would silently
+ * come back. `adopt` refuses that append and cleans up, which is why a mount
+ * must hand its element here rather than appending and forgetting.
+ */
+export type MountedRegistry = {
+  /**
+   * The claimed tags, for `pendingMounts`. Derived per call rather than kept
+   * as a third structure, because a cached copy is one more thing that can
+   * disagree with the other two.
+   */
+  readonly mountedTags: () => ReadonlySet<string>
+  /** Claim a tag BEFORE its mount is awaited. */
+  readonly latch: (tag: string) => void
+  /**
+   * Hand over the element a completed mount produced, and the slot it went
+   * into.
+   *
+   * The slot is recorded because a placement can MOVE: a topology edit that
+   * puts an already-mounted tag in a different slot leaves the tag placed, so
+   * a registry keyed on tag alone sees nothing to do and the dot never moves.
+   * That reads to a user as the edit being ignored.
+   *
+   * Returns `false` — and removes the element — when the tag was released
+   * while the mount was in flight. A caller may ignore the result; the
+   * cleanup has already happened.
+   */
+  readonly adopt: (tag: string, element: Element, slotId: string) => boolean
+  /** Give up a claim whose mount FAILED, so the next activation retries it. */
+  readonly release: (tag: string) => void
+  /**
+   * Unmount every claimed tag that the topology no longer places THERE, and
+   * report which went.
+   *
+   * `keep` maps tag to the slot it is currently placed in, and is "placed
+   * ANYWHERE in the current topology", never "placed on the current route" —
+   * passing the latter would unmount on navigation and undo the documented
+   * behaviour above.
+   *
+   * A tag goes when it is absent from `keep` (deleted) OR when its slot has
+   * changed (moved). A moved tag is unmounted here and re-mounted by the very
+   * next `pendingMounts` pass, which is what makes a move look like a move
+   * rather than like nothing happening. A tag still mid-mount has no recorded
+   * slot yet and is judged on presence alone.
+   */
+  readonly retainOnly: (
+    keep: ReadonlyMap<string, string>,
+  ) => ReadonlyArray<string>
+}
+
+export const makeMountedRegistry = (): MountedRegistry => {
+  const latched = new Set<string>()
+  const elements = new Map<string, Element>()
+  const slots = new Map<string, string>()
+
+  return {
+    mountedTags: () => new Set(latched),
+    latch: tag => {
+      latched.add(tag)
+    },
+    adopt: (tag, element, slotId) => {
+      if (!latched.has(tag)) {
+        element.remove()
+        return false
+      }
+      elements.set(tag, element)
+      slots.set(tag, slotId)
+      return true
+    },
+    release: tag => {
+      latched.delete(tag)
+      elements.delete(tag)
+      slots.delete(tag)
+    },
+    retainOnly: keep => {
+      const removed = Array.filter(Array.fromIterable(latched), tag => {
+        const wanted = keep.get(tag)
+        if (wanted === undefined) return true
+        // Mid-mount: no slot recorded yet, so presence is all there is to go
+        // on. The in-flight guard in `adopt` covers the rest.
+        const where = slots.get(tag)
+        return where !== undefined && where !== wanted
+      })
+      removed.forEach(tag => {
+        elements.get(tag)?.remove()
+        elements.delete(tag)
+        slots.delete(tag)
+        latched.delete(tag)
+      })
+      return removed
+    },
+  }
+}

package/src/placementChecks.test.ts

@@ -215,9 +215,9 @@ describe('checkPlacements — check 2: slot not in the theme', () => {
 describe('checkPlacements — check 3: required attribute unset', () => {
   test('warns when a required dot-owned attribute has no supplied value', () => {
     const report = checkPlacements(
-      [placed('p1', 'price-ticker', 'hero-slot')],
+      [placed('p1', 'readout-view', 'hero-slot')],
       contextOf([
-        manifestOf('price', ['price-ticker'], {
+        manifestOf('price', ['readout-view'], {
           attributes: [requiredAttribute('symbol', 'dot')],
         }),
       ]),
@@ -236,12 +236,12 @@ describe('checkPlacements — check 3: required attribute unset', () => {
   test('does not warn when the resolved placement supplies the value', () => {
     const report = checkPlacements(
       [
-        placed('p1', 'price-ticker', 'hero-slot', {
+        placed('p1', 'readout-view', 'hero-slot', {
           values: { symbol: 'FOLD' },
         }),
       ],
       contextOf([
-        manifestOf('price', ['price-ticker'], {
+        manifestOf('price', ['readout-view'], {
           attributes: [requiredAttribute('symbol', 'dot')],
         }),
       ]),
@@ -251,9 +251,9 @@ describe('checkPlacements — check 3: required attribute unset', () => {
 
   test('exempts environment- and host-owned attributes — the loader and the host supply those', () => {
     const report = checkPlacements(
-      [placed('p1', 'price-ticker', 'hero-slot')],
+      [placed('p1', 'readout-view', 'hero-slot')],
       contextOf([
-        manifestOf('price', ['price-ticker'], {
+        manifestOf('price', ['readout-view'], {
           attributes: [
             requiredAttribute('api-url', 'environment'),
             requiredAttribute('interview-id', 'host-input'),
@@ -542,7 +542,7 @@ describe('checkPlacements — the reading-B override qualifier', () => {
     // two firing conditions, zero issues, because it renders for nobody.
     const report = checkPlacements(
       [
-        placed('loser', 'price-ticker', 'ghost-slot', {
+        placed('loser', 'readout-view', 'ghost-slot', {
           state: 'overridden',
           overriddenBy: [
             {
@@ -553,12 +553,12 @@ describe('checkPlacements — the reading-B override qualifier', () => {
             },
           ],
         }),
-        placed('winner', 'price-ticker', 'hero-slot', {
+        placed('winner', 'readout-view', 'hero-slot', {
           values: { symbol: 'FOLD' },
         }),
       ],
       contextOf([
-        manifestOf('price', ['price-ticker'], {
+        manifestOf('price', ['readout-view'], {
           attributes: [requiredAttribute('symbol', 'dot')],
         }),
       ]),
@@ -569,7 +569,7 @@ describe('checkPlacements — the reading-B override qualifier', () => {
   test('a partially overridden placement is still checked — it still renders for somebody', () => {
     const report = checkPlacements(
       [
-        placed('loser', 'price-ticker', 'ghost-slot', {
+        placed('loser', 'readout-view', 'ghost-slot', {
           state: 'partially-overridden',
           overriddenBy: [
             {
@@ -580,11 +580,11 @@ describe('checkPlacements — the reading-B override qualifier', () => {
             },
           ],
         }),
-        placed('winner', 'price-ticker', 'hero-slot', {
+        placed('winner', 'readout-view', 'hero-slot', {
           condition: { who: 'any', device: 'any', locale: 'fr' },
         }),
       ],
-      contextOf([manifestOf('price', ['price-ticker'])]),
+      contextOf([manifestOf('price', ['readout-view'])]),
     )
     expect(
       issuesFor(report, 'slot-not-in-theme').map(issue => issue.placementId),

package/src/rules.test.ts

@@ -122,7 +122,7 @@ describe('ruleMatches', () => {
 describe('resolvePlacements', () => {
   test('a no-rules topology resolves a single mount to the fully-defaulted identity', () => {
     const topology = topologyOf([
-      route('/price', [{ tag: 'price-ticker', slotId: 'price-slot' }]),
+      route('/price', [{ tag: 'readout-view', slotId: 'price-slot' }]),
     ])
     // The whole record, pinned: defaults made explicit (condition axes to
     // 'any', envs to all three, values to {}), route provenance, and the
@@ -130,8 +130,8 @@ describe('resolvePlacements', () => {
     // issues depend on that id never changing shape.
     expect(resolvePlacements(topology, '/price', 'dev')).toEqual([
       {
-        id: '/price|0|route:price-ticker@price-slot#0',
-        tag: 'price-ticker',
+        id: '/price|0|route:readout-view@price-slot#0',
+        tag: 'readout-view',
         slotId: 'price-slot',
         source: { _tag: 'route' },
         condition: { who: 'any', device: 'any', locale: 'any' },
@@ -147,7 +147,7 @@ describe('resolvePlacements', () => {
 
   test('a no-rules topology resolves to exactly the route’s own mounts — the Phase-4 identity', () => {
     const mounts: ReadonlyArray<TopologyPlacement> = [
-      { tag: 'price-ticker', slotId: 'price-slot' },
+      { tag: 'readout-view', slotId: 'price-slot' },
       { tag: 'fleet-health', slotId: 'fleet-slot' },
     ]
     const topology = topologyOf([route('/all', mounts)])

package/src/rules.ts

@@ -214,7 +214,7 @@ export type ResolvedState = 'active' | 'partially-overridden' | 'overridden'
  *
  * It is the declared id when the record has one AND that id is declared
  * exactly once in this resolution; otherwise it is (or is qualified by) a
- * synthesized fallback — `/price|0|route:price-ticker@main-slot#0`: route
+ * synthesized fallback — `/price|0|route:readout-view@main-slot#0`: route
  * path, layer, source key, tag, slot, index within its layer. See
  * `resolvedIdOf` for the collision rule.
  */