@bespokeagentics/microdots-host 0.1.0 → 0.1.2

package/src/slotResize.ts

@@ -0,0 +1,367 @@
+/**
+ * Drag-resize for slots that declare a `resize` axis.
+ *
+ * The host owns placement, so the host owns the splitters: a MicroDot must
+ * not reach into sibling panes, and a handle inside a tabbed slot would
+ * vanish when that tab is hidden. Each handle is therefore attached to the
+ * chrome ancestor that is a direct child of the section — the grid-area box
+ * — and writes a CSS custom property on the section. Overrides survive a
+ * reload in the same tab through sessionStorage. Named layout presets clear
+ * both representations; neither is ever written back to the topology (the
+ * Platform must not rewrite the screen it is standing on).
+ *
+ * Prototype clamps (`MicroDots Wiring.dc.html:774-783`): drawer 300–980,
+ * pane 46–(shell − 190). Copy on the handle is the prototype's
+ * "Drag to resize".
+ */
+import type { SlotResizeAxis, SlotSpec } from './slots.ts'
+
+export const SLOT_RESIZE_HANDLE_CLASS = 'slot-resize-handle'
+
+export const slotSizeVar = (slotId: string): string => `--slot-size-${slotId}`
+
+const RESIZED_DATASET = 'resized'
+const AXIS_X = 'x'
+const AXIS_Y = 'y'
+const X_MIN = 300
+const X_MAX = 980
+const Y_MIN = 46
+const Y_HEADROOM = 190
+const KEY_STEP = 8
+const KEY_STEP_FAST = 40
+const STORAGE_VERSION = 1
+const STORAGE_PREFIX = 'microdots-slot-resize-v1:'
+
+export type SlotResizeStorage = Pick<
+  Storage,
+  'getItem' | 'removeItem' | 'setItem'
+>
+
+type StoredSlotSize = {
+  readonly slotId: string
+  readonly axis: SlotResizeAxis
+  readonly px: number
+}
+
+const isAxis = (value: string): value is SlotResizeAxis =>
+  value === AXIS_X || value === AXIS_Y
+
+const clamp = (value: number, lo: number, hi: number): number =>
+  Math.min(hi, Math.max(lo, value))
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null
+
+export const slotResizeStorageKey = (sectionId: string): string =>
+  `${STORAGE_PREFIX}${sectionId}`
+
+const storageFor = (
+  supplied: SlotResizeStorage | null | undefined,
+): SlotResizeStorage | undefined => {
+  if (supplied !== undefined) return supplied ?? undefined
+  try {
+    return typeof window === 'undefined' ? undefined : window.sessionStorage
+  } catch {
+    return undefined
+  }
+}
+
+const storageKeyFor = (section: HTMLElement): string | undefined =>
+  section.id === '' ? undefined : slotResizeStorageKey(section.id)
+
+const decodeStoredSizes = (
+  raw: string | null,
+): ReadonlyArray<StoredSlotSize> => {
+  if (raw === null) return []
+  try {
+    const decoded: unknown = JSON.parse(raw)
+    if (
+      !isRecord(decoded) ||
+      decoded['version'] !== STORAGE_VERSION ||
+      !Array.isArray(decoded['sizes'])
+    ) {
+      return []
+    }
+    return decoded['sizes'].flatMap((candidate): Array<StoredSlotSize> => {
+      if (!isRecord(candidate)) return []
+      const slotId = candidate['slotId']
+      const axis = candidate['axis']
+      const px = candidate['px']
+      return typeof slotId === 'string' &&
+        slotId !== '' &&
+        typeof axis === 'string' &&
+        isAxis(axis) &&
+        typeof px === 'number' &&
+        Number.isFinite(px)
+        ? [{ slotId, axis, px }]
+        : []
+    })
+  } catch {
+    return []
+  }
+}
+
+const readStoredSizes = (
+  section: HTMLElement,
+  supplied: SlotResizeStorage | null | undefined,
+): ReadonlyArray<StoredSlotSize> => {
+  const storage = storageFor(supplied)
+  const key = storageKeyFor(section)
+  if (storage === undefined || key === undefined) return []
+  try {
+    return decodeStoredSizes(storage.getItem(key))
+  } catch {
+    return []
+  }
+}
+
+const writeStoredSizes = (
+  section: HTMLElement,
+  sizes: ReadonlyArray<StoredSlotSize>,
+  supplied: SlotResizeStorage | null | undefined,
+): void => {
+  const storage = storageFor(supplied)
+  const key = storageKeyFor(section)
+  if (storage === undefined || key === undefined) return
+  try {
+    storage.setItem(key, JSON.stringify({ version: STORAGE_VERSION, sizes }))
+  } catch {
+    // Storage can be disabled, full, or denied by an embedding sandbox. The
+    // live CSS override remains useful even when persistence is unavailable.
+  }
+}
+
+const removeStoredSizes = (
+  section: HTMLElement,
+  supplied: SlotResizeStorage | null | undefined,
+): void => {
+  const storage = storageFor(supplied)
+  const key = storageKeyFor(section)
+  if (storage === undefined || key === undefined) return
+  try {
+    storage.removeItem(key)
+  } catch {
+    // A preset still clears the DOM override when storage is unavailable.
+  }
+}
+
+/**
+ * The grid-area box: walk from the slot to the section's direct child.
+ * Nested tab panes (`#wiring-inspector-slot` inside `.wiring-drawer`)
+ * resize the drawer, not the hidden tab.
+ */
+export const chromeOfSlot = (
+  slot: HTMLElement,
+  section: HTMLElement,
+): HTMLElement => {
+  let node: HTMLElement | null = slot
+  while (node !== null && node.parentElement !== section) {
+    node = node.parentElement
+  }
+  return node ?? slot
+}
+
+const minFor = (axis: SlotResizeAxis): number =>
+  axis === AXIS_X ? X_MIN : Y_MIN
+
+const maxFor = (axis: SlotResizeAxis, section: HTMLElement): number =>
+  axis === AXIS_X ? X_MAX : Math.max(Y_MIN, section.clientHeight - Y_HEADROOM)
+
+const resizedAxesOf = (section: HTMLElement): ReadonlyArray<SlotResizeAxis> => {
+  const raw = section.dataset[RESIZED_DATASET]
+  if (raw === undefined || raw === '') return []
+  return raw.split(/\s+/).filter(isAxis)
+}
+
+const writeResized = (
+  section: HTMLElement,
+  axes: ReadonlyArray<SlotResizeAxis>,
+): void => {
+  if (axes.length === 0) {
+    delete section.dataset[RESIZED_DATASET]
+    return
+  }
+  const ordered: Array<SlotResizeAxis> = []
+  if (axes.includes(AXIS_X)) ordered.push(AXIS_X)
+  if (axes.includes(AXIS_Y)) ordered.push(AXIS_Y)
+  section.dataset[RESIZED_DATASET] = ordered.join(' ')
+}
+
+export const applySlotSize = (
+  section: HTMLElement,
+  slotId: string,
+  axis: SlotResizeAxis,
+  px: number,
+  storage?: SlotResizeStorage | null,
+): number => {
+  const next = clamp(Math.round(px), minFor(axis), maxFor(axis, section))
+  section.style.setProperty(slotSizeVar(slotId), `${String(next)}px`)
+  const axes = resizedAxesOf(section)
+  writeResized(section, axes.includes(axis) ? axes : [...axes, axis])
+  const stored = readStoredSizes(section, storage).filter(
+    entry => entry.slotId !== slotId,
+  )
+  writeStoredSizes(section, [...stored, { slotId, axis, px: next }], storage)
+  return next
+}
+
+/** Restore only entries that still name a declared resizable slot and axis. */
+export const restoreSlotResize = (
+  section: HTMLElement,
+  slots: ReadonlyArray<SlotSpec>,
+  storage?: SlotResizeStorage | null,
+): void => {
+  const declared = new Map(
+    slots.flatMap(slot =>
+      slot.resize === undefined ? [] : [[slot.id, slot.resize] as const],
+    ),
+  )
+  readStoredSizes(section, storage).forEach(entry => {
+    if (declared.get(entry.slotId) !== entry.axis) return
+    const rounded = Math.round(entry.px)
+    const maximum =
+      entry.axis === AXIS_Y && section.clientHeight === 0
+        ? Math.max(Y_MIN, rounded)
+        : maxFor(entry.axis, section)
+    const next = clamp(rounded, minFor(entry.axis), maximum)
+    section.style.setProperty(slotSizeVar(entry.slotId), `${String(next)}px`)
+    const axes = resizedAxesOf(section)
+    writeResized(
+      section,
+      axes.includes(entry.axis) ? axes : [...axes, entry.axis],
+    )
+  })
+}
+
+export const clearSlotResize = (
+  section: HTMLElement,
+  slots: ReadonlyArray<SlotSpec>,
+  storage?: SlotResizeStorage | null,
+): void => {
+  slots.forEach(slot => {
+    if (slot.resize === undefined) return
+    section.style.removeProperty(slotSizeVar(slot.id))
+  })
+  delete section.dataset[RESIZED_DATASET]
+  removeStoredSizes(section, storage)
+}
+
+type Drag = {
+  readonly axis: SlotResizeAxis
+  readonly slotId: string
+  readonly startPointer: number
+  readonly startSize: number
+}
+
+export const attachSlotResize = (input: {
+  readonly section: HTMLElement
+  readonly slots: ReadonlyArray<SlotSpec>
+  readonly storage?: SlotResizeStorage | null
+}): { readonly detach: () => void } => {
+  const { section, slots, storage } = input
+  restoreSlotResize(section, slots, storage)
+  const handles: Array<HTMLButtonElement> = []
+  const attached = new WeakMap<HTMLElement, Set<SlotResizeAxis>>()
+  let drag: Drag | undefined
+  let previousUserSelect = ''
+
+  const onPointerMove = (event: PointerEvent): void => {
+    if (drag === undefined) return
+    const pointer = drag.axis === AXIS_X ? event.clientX : event.clientY
+    applySlotSize(
+      section,
+      drag.slotId,
+      drag.axis,
+      drag.startSize - (pointer - drag.startPointer),
+      storage,
+    )
+  }
+
+  const stopDrag = (): void => {
+    if (drag === undefined) return
+    drag = undefined
+    document.body.style.userSelect = previousUserSelect
+    document.removeEventListener('pointermove', onPointerMove)
+    document.removeEventListener('pointerup', stopDrag)
+    document.removeEventListener('pointercancel', stopDrag)
+  }
+
+  slots.forEach(slot => {
+    const axis = slot.resize
+    if (axis === undefined) return
+    const slotEl = document.getElementById(slot.id)
+    if (slotEl === null) return
+    const chrome = chromeOfSlot(slotEl, section)
+    const seen = attached.get(chrome)
+    if (seen?.has(axis) === true) return
+    const nextSeen = seen ?? new Set<SlotResizeAxis>()
+    nextSeen.add(axis)
+    attached.set(chrome, nextSeen)
+
+    if (getComputedStyle(chrome).position === 'static') {
+      chrome.style.position = 'relative'
+    }
+
+    const handle = document.createElement('button')
+    handle.type = 'button'
+    handle.className = SLOT_RESIZE_HANDLE_CLASS
+    handle.dataset['axis'] = axis
+    handle.title = 'Drag to resize'
+    handle.setAttribute('aria-label', 'Drag to resize')
+    handle.setAttribute(
+      'aria-orientation',
+      axis === AXIS_X ? 'vertical' : 'horizontal',
+    )
+
+    handle.addEventListener('pointerdown', event => {
+      if (event.button !== 0) return
+      event.preventDefault()
+      const startSize =
+        axis === AXIS_X ? chrome.offsetWidth : chrome.offsetHeight
+      drag = {
+        axis,
+        slotId: slot.id,
+        startPointer: axis === AXIS_X ? event.clientX : event.clientY,
+        startSize,
+      }
+      previousUserSelect = document.body.style.userSelect
+      document.body.style.userSelect = 'none'
+      document.addEventListener('pointermove', onPointerMove)
+      document.addEventListener('pointerup', stopDrag)
+      document.addEventListener('pointercancel', stopDrag)
+      if (typeof handle.setPointerCapture === 'function') {
+        handle.setPointerCapture(event.pointerId)
+      }
+    })
+
+    handle.addEventListener('keydown', event => {
+      const step = event.shiftKey ? KEY_STEP_FAST : KEY_STEP
+      const grow =
+        axis === AXIS_X ? event.key === 'ArrowLeft' : event.key === 'ArrowUp'
+      const shrink =
+        axis === AXIS_X ? event.key === 'ArrowRight' : event.key === 'ArrowDown'
+      if (!grow && !shrink) return
+      event.preventDefault()
+      const current = axis === AXIS_X ? chrome.offsetWidth : chrome.offsetHeight
+      applySlotSize(
+        section,
+        slot.id,
+        axis,
+        current + (grow ? step : -step),
+        storage,
+      )
+    })
+
+    chrome.insertBefore(handle, chrome.firstChild)
+    handles.push(handle)
+  })
+
+  return {
+    detach: () => {
+      stopDrag()
+      handles.forEach(handle => {
+        handle.remove()
+      })
+    },
+  }
+}

package/src/slots.test.ts

@@ -34,6 +34,25 @@ describe('HostSlotManifest', () => {
     expect(decodeManifest(parsed)).toEqual(Option.some(parsed))
   })
 
+  test('an absent layouts key stays absent — hosts without presets do not invent four', () => {
+    const parsed: unknown = JSON.parse(JSON.stringify(RAW_MANIFEST))
+    const decoded = decodeManifest(parsed)
+    expect(Option.isSome(decoded)).toBe(true)
+    if (Option.isSome(decoded)) {
+      expect('layouts' in decoded.value).toBe(false)
+    }
+  })
+
+  test('decodes named layout presets without inventing a hint', () => {
+    const parsed: unknown = JSON.parse(
+      JSON.stringify({
+        ...RAW_MANIFEST,
+        layouts: [{ id: 'split' }, { id: 'map', hint: 'Map — canvas full height' }],
+      }),
+    )
+    expect(decodeManifest(parsed)).toEqual(Option.some(parsed))
+  })
+
   test('rejects a slot whose kind is not bar, band, rail or grid', () => {
     const parsed: unknown = JSON.parse(
       JSON.stringify({
@@ -43,4 +62,38 @@ describe('HostSlotManifest', () => {
     )
     expect(Option.isNone(decodeManifest(parsed))).toBe(true)
   })
+
+  test('an absent resize key stays absent — a slot is not resizable by default', () => {
+    const parsed: unknown = JSON.parse(JSON.stringify(RAW_MANIFEST))
+    const decoded = decodeManifest(parsed)
+    expect(Option.isSome(decoded)).toBe(true)
+    if (Option.isSome(decoded)) {
+      decoded.value.slots.forEach(slot => {
+        expect('resize' in slot).toBe(false)
+      })
+    }
+  })
+
+  test('decodes a resize axis without inventing the other', () => {
+    const parsed: unknown = JSON.parse(
+      JSON.stringify({
+        ...RAW_MANIFEST,
+        slots: [
+          { id: 'app-list-slot', kind: 'rail', row: 2, width: '280px', resize: 'x' },
+          { id: 'hero-band', kind: 'band', row: 1, resize: 'y' },
+        ],
+      }),
+    )
+    expect(decodeManifest(parsed)).toEqual(Option.some(parsed))
+  })
+
+  test('rejects a resize axis that is not x or y', () => {
+    const parsed: unknown = JSON.parse(
+      JSON.stringify({
+        theme: RAW_MANIFEST.theme,
+        slots: [{ id: 'app-list-slot', kind: 'rail', row: 2, resize: 'both' }],
+      }),
+    )
+    expect(Option.isNone(decodeManifest(parsed))).toBe(true)
+  })
 })

package/src/slots.ts

@@ -27,13 +27,25 @@ import { Schema as S } from 'effect'
 export const SlotKind = S.Literals(['bar', 'band', 'rail', 'grid'])
 export type SlotKind = typeof SlotKind.Type
 
+/**
+ * Which edge of a slot the host may drag. `x` is the inline axis (a trailing
+ * rail's inner edge — the Wiring drawer); `y` is the block axis (a bottom
+ * band's top edge — the Wiring table pane). Absent means the slot is not
+ * resizable. The handle sits on the start edge of the chrome ancestor, which
+ * is the inner edge of a trailing pane; a leading rail does not set this
+ * until an edge field exists.
+ */
+export const SlotResizeAxis = S.Literals(['x', 'y'])
+export type SlotResizeAxis = typeof SlotResizeAxis.Type
+
 /**
  * One declared slot. `row` is the vertical band the slot occupies — slots
  * sharing a row sit side by side (the fixture's sidebar / main / aside).
  * `width` is a CSS length for a fixed `rail` (`'280px'`); `capacity` is how
- * many placements the slot is meant to hold. Both `optionalKey` (not
- * `optional`) so the decoded Type is exact-optional under
- * `exactOptionalPropertyTypes`, matching the rest of the topology schemas.
+ * many placements the slot is meant to hold. `resize` is the drag axis, if
+ * any. All three of those are `optionalKey` (not `optional`) so the decoded
+ * Type is exact-optional under `exactOptionalPropertyTypes`, matching the
+ * rest of the topology schemas.
  */
 export const SlotSpec = S.Struct({
   id: S.String,
@@ -41,6 +53,7 @@ export const SlotSpec = S.Struct({
   row: S.Number,
   width: S.optionalKey(S.String),
   capacity: S.optionalKey(S.Number),
+  resize: S.optionalKey(SlotResizeAxis),
 })
 export type SlotSpec = typeof SlotSpec.Type
 
@@ -51,8 +64,22 @@ export type SlotSpec = typeof SlotSpec.Type
  * degrade honestly — slot checks are reported unverifiable, never silently
  * green (see `./placementChecks.ts`).
  */
+/**
+ * A named layout preset the host may apply to a screen. `id` is the
+ * `data-layout` value; `hint` is chrome copy from the declaring host, not a
+ * human name for a MicroDot. Absent `layouts` is a host that has not
+ * declared presets — the Wiring toolbar hides the control rather than
+ * inventing four.
+ */
+export const SlotLayoutPreset = S.Struct({
+  id: S.String,
+  hint: S.optionalKey(S.String),
+})
+export type SlotLayoutPreset = typeof SlotLayoutPreset.Type
+
 export const HostSlotManifest = S.Struct({
   theme: S.Struct({ name: S.String, version: S.String }),
   slots: S.Array(SlotSpec),
+  layouts: S.optionalKey(S.Array(SlotLayoutPreset)),
 })
 export type HostSlotManifest = typeof HostSlotManifest.Type

package/src/topologyRegression.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vitest'
+
+import corpusInput from '../evals/topology-regressions.p5.v1.json' with { type: 'json' }
+import {
+  decodeTopologyRegressionCorpusSync,
+  observeTopologyRegressionCase,
+  topologyRegressionSurfaces,
+} from './topologyRegression.ts'
+
+describe('Phase 5 topology regression corpus', () => {
+  test('keeps the promoted layout and wire slices exact', () => {
+    const corpus = decodeTopologyRegressionCorpusSync(corpusInput)
+    const surfaces = topologyRegressionSurfaces(corpus)
+    expect(corpus.cases).toHaveLength(3)
+    for (const item of corpus.cases) {
+      expect(
+        observeTopologyRegressionCase({ item, surfaces }),
+        item.id,
+      ).toEqual(item.expected)
+    }
+  })
+
+  test('rejects arbitrary corpus and tool identity labels', () => {
+    expect(() =>
+      decodeTopologyRegressionCorpusSync({
+        ...corpusInput,
+        corpusVersion: 'p5.future',
+      }),
+    ).toThrow()
+    expect(() =>
+      decodeTopologyRegressionCorpusSync({
+        ...corpusInput,
+        toolVersion: 'compose-from-selection@99',
+      }),
+    ).toThrow()
+  })
+})

package/src/topologyRegression.ts

@@ -0,0 +1,143 @@
+import { Schema as S } from 'effect'
+
+import type { ManifestTag } from '@bespokeagentics/microdots-element'
+
+import {
+  type ComposeFromSelectionInput,
+  composeFromSelection,
+} from './composeFromSelection.ts'
+import { SlotKind } from './slots.ts'
+
+const WireValueType = S.Literals(['string', 'number', 'boolean', 'json'])
+const Ownership = S.Literals(['dot', 'host-input', 'environment'])
+
+export const TOPOLOGY_REGRESSION_CORPUS_ID =
+  'microdots.topology-regressions.p5' as const
+export const TOPOLOGY_REGRESSION_CORPUS_VERSION = 'p5.1' as const
+export const TOPOLOGY_REGRESSION_TOOL_VERSION =
+  'compose-from-selection@1' as const
+
+const TopologyRegressionSurfaceV1 = S.Struct({
+  tag: S.NonEmptyString,
+  attributes: S.Array(
+    S.Struct({ name: S.NonEmptyString, ownership: Ownership }),
+  ),
+  events: S.Array(
+    S.Struct({
+      name: S.NonEmptyString,
+      fields: S.Record(S.String, WireValueType),
+    }),
+  ),
+})
+
+const TopologyRegressionInputV1 = S.Struct({
+  brief: S.optionalKey(S.NonEmptyString),
+  hostId: S.NonEmptyString,
+  hostLabel: S.NonEmptyString,
+  tags: S.NonEmptyArray(S.NonEmptyString),
+  layout: S.Literals(['together', 'per-tag']),
+  slotKind: SlotKind,
+  wires: S.Array(
+    S.Struct({
+      from: S.NonEmptyString,
+      event: S.NonEmptyString,
+      field: S.NonEmptyString,
+      to: S.NonEmptyString,
+      input: S.NonEmptyString,
+    }),
+  ),
+})
+
+export const TopologyRegressionObservationV1 = S.Struct({
+  hostId: S.NonEmptyString,
+  hostLabel: S.NonEmptyString,
+  generateCount: S.Natural,
+  routePaths: S.Array(S.NonEmptyString),
+  mountedTags: S.Array(S.NonEmptyString),
+  slotKinds: S.Array(SlotKind),
+  wirePlain: S.Array(S.NonEmptyString),
+})
+export type TopologyRegressionObservationV1 =
+  typeof TopologyRegressionObservationV1.Type
+
+export const TopologyRegressionCaseV1 = S.Struct({
+  schemaVersion: S.Literal(1),
+  id: S.NonEmptyString,
+  title: S.NonEmptyString,
+  input: TopologyRegressionInputV1,
+  expected: TopologyRegressionObservationV1,
+})
+export type TopologyRegressionCaseV1 = typeof TopologyRegressionCaseV1.Type
+
+export const TopologyRegressionCorpusV1 = S.Struct({
+  schemaVersion: S.Literal(1),
+  id: S.Literal(TOPOLOGY_REGRESSION_CORPUS_ID),
+  corpusVersion: S.Literal(TOPOLOGY_REGRESSION_CORPUS_VERSION),
+  toolVersion: S.Literal(TOPOLOGY_REGRESSION_TOOL_VERSION),
+  surfaces: S.NonEmptyArray(TopologyRegressionSurfaceV1),
+  cases: S.NonEmptyArray(TopologyRegressionCaseV1),
+}).check(
+  S.makeFilter(
+    corpus =>
+      new Set(corpus.cases.map(item => item.id)).size === corpus.cases.length,
+    { expected: 'unique topology regression case ids' },
+  ),
+)
+export type TopologyRegressionCorpusV1 = typeof TopologyRegressionCorpusV1.Type
+
+export const decodeTopologyRegressionCorpusSync = S.decodeUnknownSync(
+  TopologyRegressionCorpusV1,
+  { onExcessProperty: 'error' },
+)
+
+export const topologyRegressionSurfaces = (
+  corpus: TopologyRegressionCorpusV1,
+): ReadonlyArray<ManifestTag> =>
+  corpus.surfaces.map(surface => ({
+    tag: surface.tag,
+    attributes: surface.attributes.map(attribute => ({
+      name: attribute.name,
+      type: 'string',
+      required: false,
+      live: true,
+      ownership: attribute.ownership,
+    })),
+    events: surface.events.map(event => ({
+      name: event.name,
+      payload: {
+        ref: `@microdots/topology-regression/contract#${event.name}`,
+        jsonSchema: {
+          dialect: 'draft-2020-12',
+          schema: {
+            type: 'object',
+            properties: Object.fromEntries(
+              Object.entries(event.fields).map(([name, type]) => [
+                name,
+                { type },
+              ]),
+            ),
+          },
+          definitions: {},
+        },
+      },
+    })),
+  }))
+
+export const observeTopologyRegressionCase = (input: {
+  readonly item: TopologyRegressionCaseV1
+  readonly surfaces: ReadonlyArray<ManifestTag>
+}): TopologyRegressionObservationV1 => {
+  const selection: ComposeFromSelectionInput = input.item.input
+  const spec = composeFromSelection(selection, input.surfaces)
+  return {
+    hostId: spec.topology.host.id,
+    hostLabel: spec.topology.host.label,
+    generateCount: spec.generate.length,
+    routePaths: spec.topology.routes.map(route => route.path),
+    mountedTags: spec.topology.routes.flatMap(route =>
+      route.mounts.map(mount => mount.tag),
+    ),
+    slotKinds: spec.topology.slotManifest?.slots.map(slot => slot.kind) ?? [],
+    wirePlain: spec.topology.wires.map(wire => wire.plain),
+  }
+}