@erclx/canon 5.27.0 → 5.28.0

package/src/canvas/client/state.ts

@@ -22,6 +22,11 @@ export interface TokenSource {
 
 export type LeftTab = 'pages' | 'theme'
 
+export type Tool = 'move' | 'pan'
+
+/** A Space pan held, and whether a drag has moved the view while it was. */
+export type SpacePan = 'held' | 'dragged'
+
 /** One property change to the selected element, as the inspector posts it. */
 export interface PendingEdit {
   readonly key: string
@@ -45,11 +50,19 @@ export interface SelectionRef extends FrameRef {
   readonly element?: ElementRef
 }
 
+/** A frame a session says it is editing, until the stamp it expires at. */
+export interface EditingRef extends FrameRef {
+  readonly by: string
+  readonly until: string
+}
+
 export interface PagesRecord {
   readonly pages: readonly Page[]
   readonly tokens: TokenSource
   /** Absent when nothing is selected or the selected frame is gone. */
   readonly selection?: SelectionRef | null
+  /** The live marks, which a server older than the mark leaves out. */
+  readonly editing?: readonly EditingRef[]
 }
 
 export interface ChangeEvent {
@@ -101,6 +114,9 @@ export const hoveredElement = signal<
   { readonly key: string; readonly index: number } | undefined
 >(undefined)
 
+/** Each marked frame's mark by frame key, dropped at its `until`. */
+export const editingFrames = signal<ReadonlyMap<string, EditingRef>>(new Map())
+
 /** Frame keys whose layers are open in the pages panel. */
 export const expandedFrames = signal<ReadonlySet<string>>(new Set())
 
@@ -112,6 +128,16 @@ export const writeError = signal<string | undefined>(undefined)
 
 export const leftTab = signal<LeftTab>('pages')
 
+/** The tool the strip has lit, which a Space pan overrides while held. */
+export const activeTool = signal<Tool>('move')
+
+export const spacePan = signal<SpacePan | undefined>(undefined)
+
+/** The tool in effect, so Space shows Pan lit and releasing it restores it. */
+export const shownTool = computed<Tool>(() =>
+  spacePan.value ? 'pan' : activeTool.value,
+)
+
 /** The edit in flight, which holds its field until the server answers. */
 export const pendingEdit = signal<PendingEdit | undefined>(undefined)
 
@@ -193,10 +219,62 @@ export function toggleLayers(key: string): void {
   expandedFrames.value = next
 }
 
+/*
+ * An expiry writes no file and raises no change event, so nothing rereads the
+ * page list when a mark lapses. One timer, set for the earliest `until`, drops
+ * it instead, and every record resets it.
+ */
+let editingTimer: ReturnType<typeof setTimeout> | undefined
+
+/*
+ * The longest delay a timer holds. A longer one fires at once, so an `until`
+ * far out would reschedule on every tick rather than wait.
+ */
+const MAX_TIMER_MS = 2 ** 31 - 1
+
+function liveMarks(
+  marks: Iterable<readonly [string, EditingRef]>,
+  now: number,
+): ReadonlyMap<string, EditingRef> {
+  return new Map([...marks].filter(([, mark]) => Date.parse(mark.until) > now))
+}
+
+function scheduleExpiry(): void {
+  clearTimeout(editingTimer)
+  editingTimer = undefined
+  const next = Math.min(
+    ...[...editingFrames.value.values()].map((mark) => Date.parse(mark.until)),
+  )
+  if (!Number.isFinite(next)) return
+  editingTimer = setTimeout(
+    () => {
+      editingFrames.value = liveMarks(editingFrames.value, Date.now())
+      scheduleExpiry()
+    },
+    Math.min(MAX_TIMER_MS, Math.max(0, next - Date.now())),
+  )
+}
+
+/** Keys each mark by the file of the frame it names, as the surface reads. */
+function applyEditing(
+  all: readonly Page[],
+  marks: readonly EditingRef[],
+): void {
+  const keyed = marks.flatMap((mark) => {
+    const frame = all
+      .find((candidate) => candidate.name === mark.page)
+      ?.frames.find((candidate) => candidate.name === mark.frame)
+    return frame ? [[frameKey(mark.page, frame), mark] as const] : []
+  })
+  editingFrames.value = liveMarks(keyed, Date.now())
+  scheduleExpiry()
+}
+
 export function applyRecord(record: PagesRecord): void {
   pages.value = record.pages
   tokens.value = record.tokens
   selection.value = record.selection ?? undefined
+  applyEditing(record.pages, record.editing ?? [])
   loadError.value = undefined
   isLoaded.value = true
 }
@@ -487,11 +565,19 @@ export function panBy(dx: number, dy: number): void {
   view.value = { ...current, x: current.x + dx, y: current.y + dy }
 }
 
-/** Fits every frame on the current page into a viewport of the given size. */
-export function fitView(width: number, height: number, padding = 48): void {
+/**
+ * Fits every frame on the current page into a viewport of the given size,
+ * clear of `insetLeft` pixels of chrome floating over its left edge.
+ */
+export function fitView(
+  width: number,
+  height: number,
+  padding = 48,
+  insetLeft = 0,
+): void {
   const frames = currentPage.value?.frames ?? []
   if (frames.length === 0 || width <= 0 || height <= 0) {
-    view.value = { x: padding, y: padding, zoom: 0.5 }
+    view.value = { x: insetLeft + padding, y: padding, zoom: 0.5 }
     return
   }
   const left = Math.min(...frames.map((frame) => frame.x))
@@ -500,14 +586,14 @@ export function fitView(width: number, height: number, padding = 48): void {
   const bottom = Math.max(...frames.map((frame) => frame.y + frame.height))
   const zoom = clampZoom(
     Math.min(
-      (width - padding * 2) / (right - left),
+      (width - insetLeft - padding * 2) / (right - left),
       (height - padding * 2) / (bottom - top),
       1,
     ),
   )
   view.value = {
     zoom,
-    x: padding - left * zoom,
+    x: insetLeft + padding - left * zoom,
     y: padding - top * zoom,
   }
 }
@@ -537,10 +623,15 @@ export function resetState(): void {
   selection.value = undefined
   frameDocuments.value = new Map()
   hoveredElement.value = undefined
+  editingFrames.value = new Map()
+  clearTimeout(editingTimer)
+  editingTimer = undefined
   expandedFrames.value = new Set()
   draggingFrame.value = undefined
   writeError.value = undefined
   leftTab.value = 'pages'
+  activeTool.value = 'move'
+  spacePan.value = undefined
   pendingEdit.value = undefined
   savedEdit.value = undefined
   editRefusal.value = undefined

package/src/canvas/client/surface.tsx

@@ -3,9 +3,12 @@ import type { JSX, RefObject } from 'preact'
 import { useEffect, useRef, useState } from 'preact/hooks'
 import { addressOf, documentElements, elementAt } from '@/canvas/address'
 import type { Frame } from '@/canvas/content'
+import { type SurfaceAction, surfaceAction } from '@/canvas/client/keys'
 import {
+  activeTool,
   currentPage,
   draggingFrame,
+  editingFrames,
   fitView,
   type FrameRef,
   frameDocuments,
@@ -23,6 +26,8 @@ import {
   selectElement,
   selectFrame,
   selection,
+  shownTool,
+  spacePan,
   type Theme,
   toggleFrameTheme,
   view,
@@ -34,6 +39,7 @@ import {
   type OverlayBox,
   SelectionOverlay,
 } from '@/canvas/client/selection'
+import { ToolStrip } from '@/canvas/client/tools'
 
 /** One wheel notch or one button press. */
 const ZOOM_STEP = 1.2
@@ -82,6 +88,37 @@ function asElement(target: EventTarget | null): Element | undefined {
   return node?.nodeType === 1 ? (node as Element) : undefined
 }
 
+/**
+ * Whether a key belongs to the element it was typed in rather than to the
+ * canvas: any key in a field, and Space on a control it activates. A frame's
+ * draft can hold its own fields, and their keys arrive through the forwarding.
+ */
+function isOwnedByTarget(event: KeyboardEvent, action: SurfaceAction): boolean {
+  const target = asElement(event.target)
+  if (!target) return false
+  if ((target as HTMLElement).isContentEditable) return true
+  if (target.closest('input, textarea, select')) return true
+  return (
+    action === 'pan-hold' && target.closest('button, a[href], summary') !== null
+  )
+}
+
+/**
+ * A press read as a second click selects a word or a whole frame even while
+ * panning, so no selection may start in the shell or a frame then.
+ */
+function blockSelectionWhilePanning(event: Event): void {
+  if (shownTool.value === 'pan') event.preventDefault()
+}
+
+/** Drops any selection in the shell and in every loaded frame document. */
+function clearSelections(): void {
+  document.getSelection()?.removeAllRanges()
+  for (const doc of frameDocuments.value.values()) {
+    doc.getSelection()?.removeAllRanges()
+  }
+}
+
 /** A computed length in pixels, or the fallback for one that is not. */
 function pixels(value: string, fallback: number): number {
   const parsed = Number.parseFloat(value)
@@ -211,10 +248,12 @@ function FrameView({
   page,
   frame,
   onWheelTurn,
+  onKey,
 }: {
   readonly page: string
   readonly frame: Frame
   readonly onWheelTurn: (turn: WheelTurn) => void
+  readonly onKey: (event: KeyboardEvent) => void
 }): JSX.Element {
   const key = frameKey(page, frame)
   const version = frameVersions.value.get(key) ?? 0
@@ -227,6 +266,7 @@ function FrameView({
   /* Bumped when the frame document scrolls, so the outlines follow it. */
   const [, setScrolled] = useState(0)
   const doc = frameDocuments.value.get(key)
+  const editing = editingFrames.value.get(key)
 
   useEffect(() => {
     applyFrameTheme(iframe.current, value)
@@ -277,6 +317,16 @@ function FrameView({
       },
       { passive: false },
     )
+    /*
+     * A click inside the frame moves focus into its window, so the surface
+     * hears no key after the first pick unless the frame passes it on.
+     */
+    loaded.addEventListener('keydown', onKey)
+    loaded.addEventListener('keyup', onKey)
+    loaded.addEventListener('selectstart', blockSelectionWhilePanning)
+    loaded.defaultView?.addEventListener('blur', () => {
+      spacePan.value = undefined
+    })
   }
 
   const picked =
@@ -298,6 +348,8 @@ function FrameView({
 
   const handlePointerDown = (event: PointerEvent) => {
     if (event.button !== 0) return
+    /* A pan drag starting on the label belongs to the surface behind it. */
+    if (shownTool.value === 'pan') return
     if ((event.target as HTMLElement | null)?.closest('.frame-theme')) return
     gesture.current = {
       startX: event.clientX,
@@ -346,7 +398,7 @@ function FrameView({
    */
   const handleKeyDown = (event: KeyboardEvent) => {
     if (event.target !== event.currentTarget) return
-    if (event.key === 'Enter' || event.key === ' ') {
+    if (event.key === 'Enter') {
       event.preventDefault()
       select()
       return
@@ -368,6 +420,16 @@ function FrameView({
     void moveFrameTo(ref, frame.x + delta.x * step, frame.y + delta.y * step)
   }
 
+  /*
+   * Space held pans, so it selects on release instead, and only when no drag
+   * moved the view while it was down. This runs before the surface's own
+   * release clears the pan.
+   */
+  const handleKeyUp = (event: KeyboardEvent) => {
+    if (event.target !== event.currentTarget || event.key !== ' ') return
+    if (spacePan.value !== 'dragged') select()
+  }
+
   const frameBox = (): OverlayBox => ({
     x: frame.x,
     y: frame.y,
@@ -383,10 +445,12 @@ function FrameView({
       data-selected={isSelected ? 'true' : undefined}
       data-picked={picked ? 'true' : undefined}
       data-dragging={draggingFrame.value === frame.name ? 'true' : undefined}
+      data-editing={editing ? 'true' : undefined}
       tabIndex={0}
-      aria-label={`${frame.name}, ${frame.width} by ${frame.height}`}
+      aria-label={`${frame.name}, ${frame.width} by ${frame.height}${editing ? `, ${editing.by} editing` : ''}`}
       aria-current={isSelected ? 'true' : undefined}
       onKeyDown={handleKeyDown}
+      onKeyUp={handleKeyUp}
       style={{
         left: `${frame.x}px`,
         top: `${frame.y}px`,
@@ -407,6 +471,10 @@ function FrameView({
         <span class="frame-size">
           {frame.width} × {frame.height}
         </span>
+        {/* Rendered empty while unmarked, so a mark landing is announced. */}
+        <span class="frame-editing" aria-live="polite">
+          {editing ? `${editing.by} editing` : ''}
+        </span>
         <button
           type="button"
           class="frame-theme"
@@ -461,18 +529,35 @@ function viewportSize(viewport: RefObject<HTMLDivElement | null>): {
   return { width: rect?.width ?? 0, height: rect?.height ?? 0 }
 }
 
+/** The zoom toolbar's actions, which its keys call as well. */
+function zoomCentered(
+  viewport: RefObject<HTMLDivElement | null>,
+  factor: number,
+): void {
+  const { width, height } = viewportSize(viewport)
+  zoomAt(factor, width / 2, height / 2)
+}
+
+/** Fits the page clear of the tool strip floating over the viewport's left. */
+function fitViewport(viewport: RefObject<HTMLDivElement | null>): void {
+  const rect = viewport.current?.getBoundingClientRect()
+  const strip = viewport.current?.parentElement
+    ?.querySelector('.tools')
+    ?.getBoundingClientRect()
+  const inset = rect && strip ? Math.max(0, strip.right - rect.left) : 0
+  fitView(rect?.width ?? 0, rect?.height ?? 0, undefined, inset)
+}
+
 function Toolbar({ viewportRef }: SurfaceProps): JSX.Element {
-  const zoomCentered = (factor: number) => {
-    const { width, height } = viewportSize(viewportRef)
-    zoomAt(factor, width / 2, height / 2)
-  }
   return (
     <div class="toolbar" role="toolbar" aria-label="Zoom">
       <button
         type="button"
         class="icon-button"
         aria-label="Zoom out"
-        onClick={() => zoomCentered(1 / ZOOM_STEP)}
+        aria-keyshortcuts="-"
+        title="Zoom out (-)"
+        onClick={() => zoomCentered(viewportRef, 1 / ZOOM_STEP)}
       >
         −
       </button>
@@ -483,17 +568,18 @@ function Toolbar({ viewportRef }: SurfaceProps): JSX.Element {
         type="button"
         class="icon-button"
         aria-label="Zoom in"
-        onClick={() => zoomCentered(ZOOM_STEP)}
+        aria-keyshortcuts="+"
+        title="Zoom in (+)"
+        onClick={() => zoomCentered(viewportRef, ZOOM_STEP)}
       >
         +
       </button>
       <button
         type="button"
         class="text-button"
-        onClick={() => {
-          const { width, height } = viewportSize(viewportRef)
-          fitView(width, height)
-        }}
+        aria-keyshortcuts="Shift+1"
+        title="Fit (Shift+1)"
+        onClick={() => fitViewport(viewportRef)}
       >
         Fit
       </button>
@@ -507,8 +593,7 @@ export function Surface({ viewportRef }: SurfaceProps): JSX.Element {
 
   /* Fits a page once when it opens, never on a reload of the same page. */
   useEffect(() => {
-    const { width, height } = viewportSize(viewportRef)
-    fitView(width, height)
+    fitViewport(viewportRef)
   }, [page?.name])
 
   const handleWheelTurn = (turn: WheelTurn) => {
@@ -536,9 +621,68 @@ export function Surface({ viewportRef }: SurfaceProps): JSX.Element {
     })
   }
 
+  /* A pan held when the window loses focus never hears its Space come up. */
+  useEffect(() => {
+    const endPan = () => {
+      spacePan.value = undefined
+    }
+    window.addEventListener('blur', endPan)
+    document.addEventListener('selectstart', blockSelectionWhilePanning)
+    return () => {
+      window.removeEventListener('blur', endPan)
+      document.removeEventListener('selectstart', blockSelectionWhilePanning)
+    }
+  }, [])
+
+  const runAction = (action: SurfaceAction) => {
+    switch (action) {
+      case 'tool-move':
+        activeTool.value = 'move'
+        return
+      case 'tool-pan':
+        activeTool.value = 'pan'
+        return
+      case 'zoom-in':
+        zoomCentered(viewportRef, ZOOM_STEP)
+        return
+      case 'zoom-out':
+        zoomCentered(viewportRef, 1 / ZOOM_STEP)
+        return
+      case 'zoom-fit':
+        fitViewport(viewportRef)
+        return
+      case 'pan-hold':
+        spacePan.value ??= 'held'
+        return
+      case 'pan-release':
+        spacePan.value = undefined
+    }
+  }
+
+  /*
+   * The surface's one key handler, which every frame document feeds too. The
+   * default is prevented only for a key press it takes, so Space stops
+   * scrolling a frame it pans and every other key keeps its own meaning. A
+   * release always ends the pan and never claims the keyup, since a button
+   * fires its Space activation there.
+   */
+  const handleKey = (event: KeyboardEvent) => {
+    const action = surfaceAction(event)
+    if (!action) return
+    if (action === 'pan-release') {
+      runAction(action)
+      return
+    }
+    if (isOwnedByTarget(event, action)) return
+    event.preventDefault()
+    runAction(action)
+  }
+
   const handlePointerDown = (event: PointerEvent) => {
     const target = event.target as HTMLElement | null
-    if (target?.closest('.frame, .toolbar')) return
+    if (shownTool.value !== 'pan' && target?.closest('.frame')) return
+    /* A selection left over would paint over every frame the pan crosses. */
+    if (shownTool.value === 'pan') clearSelections()
     drag.current = { x: event.clientX, y: event.clientY }
     viewportRef.current?.setPointerCapture?.(event.pointerId)
   }
@@ -546,22 +690,53 @@ export function Surface({ viewportRef }: SurfaceProps): JSX.Element {
   const handlePointerMove = (event: PointerEvent) => {
     const start = drag.current
     if (!start) return
-    panBy(event.clientX - start.x, event.clientY - start.y)
+    const dx = event.clientX - start.x
+    const dy = event.clientY - start.y
+    panBy(dx, dy)
     drag.current = { x: event.clientX, y: event.clientY }
+    if (spacePan.value === 'held' && (dx !== 0 || dy !== 0)) {
+      spacePan.value = 'dragged'
+    }
+  }
+
+  /*
+   * A press selects text by default, a word or a whole frame when it reads as
+   * a second click, and neither `selectstart` nor a clear at pointer down
+   * reaches that. Under a held Space, focus stays where it was so the frame
+   * still hears the release. Under the Pan tool the press takes focus itself,
+   * as the default would have, so a field it leaves commits and the next key
+   * reaches the layer.
+   */
+  const handleMouseDown = (event: MouseEvent) => {
+    if (shownTool.value !== 'pan') return
+    event.preventDefault()
+    if (!spacePan.value) {
+      const surface = (event.currentTarget as HTMLElement).closest('main')
+      surface?.focus({ preventScroll: true })
+    }
   }
 
   const handlePointerUp = () => {
+    if (drag.current && shownTool.value === 'pan') clearSelections()
     drag.current = undefined
   }
 
   const { x, y, zoom } = view.value
   return (
-    <main class="surface" aria-label="Canvas">
+    <main
+      class="surface"
+      aria-label="Canvas"
+      tabIndex={0}
+      data-tool={shownTool.value}
+      onKeyDown={handleKey}
+      onKeyUp={handleKey}
+    >
       <div
         ref={viewportRef}
         class="viewport"
         onWheel={handleWheel}
         onPointerDown={handlePointerDown}
+        onMouseDown={handleMouseDown}
         onPointerMove={handlePointerMove}
         onPointerUp={handlePointerUp}
         onPointerCancel={handlePointerUp}
@@ -580,10 +755,12 @@ export function Surface({ viewportRef }: SurfaceProps): JSX.Element {
               page={page.name}
               frame={frame}
               onWheelTurn={handleWheelTurn}
+              onKey={handleKey}
             />
           ))}
         </div>
       </div>
+      <ToolStrip />
       <Toolbar viewportRef={viewportRef} />
     </main>
   )

package/src/canvas/client/tools.tsx

@@ -0,0 +1,64 @@
+/** @jsxImportSource preact */
+import type { JSX } from 'preact'
+import { activeTool, shownTool, type Tool } from '@/canvas/client/state'
+
+interface ToolButton {
+  readonly tool: Tool
+  readonly name: string
+  readonly key: string
+  readonly icon: JSX.Element
+}
+
+const TOOLS: readonly ToolButton[] = [
+  {
+    tool: 'move',
+    name: 'Move',
+    key: 'V',
+    icon: (
+      <svg viewBox="0 0 16 16" aria-hidden="true">
+        <path d="M3.5 2.5l9 4.2-3.9 1.2-1.4 3.8z" />
+      </svg>
+    ),
+  },
+  {
+    tool: 'pan',
+    name: 'Pan',
+    key: 'H',
+    icon: (
+      <svg viewBox="0 0 16 16" aria-hidden="true">
+        <path d="M5.5 8.5V4a1 1 0 0 1 2 0v3.5M7.5 7V2.8a1 1 0 0 1 2 0V7M9.5 7V3.6a1 1 0 0 1 2 0V8M11.5 7.5a1 1 0 0 1 2 0v2.2A4.8 4.8 0 0 1 8.7 14.5h-.6a4.3 4.3 0 0 1-3.2-1.4L2.6 10.6a1 1 0 0 1 1.5-1.4l1.4 1.3" />
+      </svg>
+    ),
+  },
+]
+
+/** The tool strip floating at the surface's left edge, one button a tool. */
+export function ToolStrip(): JSX.Element {
+  const shown = shownTool.value
+  return (
+    <div
+      class="tools"
+      role="toolbar"
+      aria-label="Tools"
+      aria-orientation="vertical"
+    >
+      {TOOLS.map(({ tool, name, key, icon }) => (
+        <button
+          key={tool}
+          type="button"
+          class="tool-button"
+          aria-label={`${name} (${key})`}
+          aria-keyshortcuts={key}
+          aria-pressed={shown === tool ? 'true' : 'false'}
+          title={`${name} (${key})`}
+          data-tool={tool}
+          onClick={() => {
+            activeTool.value = tool
+          }}
+        >
+          {icon}
+        </button>
+      ))}
+    </div>
+  )
+}

package/src/canvas/content.ts

@@ -18,7 +18,7 @@ import {
   resolveAddress,
   type SourceElement,
 } from '@/canvas/address'
-import { recordDir } from '@/record-root'
+import { recordDir } from '@/roots/record'
 
 /**
  * The content format. A page is a folder under the record root's `canvas/`, a

package/src/canvas/edit.ts

@@ -27,6 +27,10 @@ export const STYLE_PROPERTIES = [
   'background-color',
   'font-size',
   'font-weight',
+  'font-family',
+  'line-height',
+  'letter-spacing',
+  'text-align',
   'width',
   'height',
   'padding',
@@ -133,10 +137,13 @@ function checkChange(change: EditChange): EditRefused | undefined {
   return undefined
 }
 
+const CHARACTER_REFERENCE = /&(?:#\d+|#x[0-9a-f]+|[a-z][a-z0-9]*);/iy
+
 /**
  * Splits a style attribute at each semicolon outside parentheses and quotes,
  * keeping every segment's own spacing so an untouched one is written back as
- * it was.
+ * it was. The rewriter hands the attribute over undecoded and writes a quote
+ * back as `"`, so a character reference's own semicolon never splits.
  */
 function declarations(style: string): string[] {
   const segments: string[] = []
@@ -145,7 +152,10 @@ function declarations(style: string): string[] {
   let start = 0
   for (let at = 0; at < style.length; at += 1) {
     const char = style[at]
-    if (quote) {
+    CHARACTER_REFERENCE.lastIndex = at
+    if (char === '&' && CHARACTER_REFERENCE.test(style)) {
+      at = CHARACTER_REFERENCE.lastIndex - 1
+    } else if (quote) {
       if (char === quote) quote = undefined
     } else if (char === '"' || char === "'") quote = char
     else if (char === '(') depth += 1

package/src/canvas/tokens.ts

@@ -13,7 +13,7 @@ import {
   namedFamilies,
   projectSheets,
 } from '@/design/project-fonts'
-import { isOwnCheckout } from '@/project-root'
+import { isOwnCheckout } from '@/roots/project'
 
 /**
  * The stylesheet injected into every frame, so a frame drawn with

package/src/claude/seeds.ts

@@ -2,9 +2,9 @@ import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname, join, relative } from 'node:path'
 import { copyPreservingMode } from '@/sync/copy'
-import { creationRel, isRecordEntry } from '@/record-root'
+import { creationRel, isRecordEntry } from '@/roots/record'
 import { rewritesOnInstall, stripSeedMarker } from '@/tooling/seed-marker'
-import { SURFACE_ENTRIES, surfaceDir } from '@/surface-root'
+import { SURFACE_ENTRIES, surfaceDir } from '@/roots/surface'
 
 const SEEDS_DIR = join('tooling', 'claude', 'seeds')
 const CLAUDE_DIR = '.claude'

package/src/claude/skills-reach.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { resolveSkillsCorpus } from '@/claude/skills-list'
-import { SURFACE_ROOTS } from '@/surface-root'
+import { SURFACE_ROOTS } from '@/roots/surface'
 
 /**
  * The authoring roots this repository owns and no install channel delivers.