@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/plate-paint-affected.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  DoorNode,
+  LevelNode,
+  reconcileSceneStructure,
+  SlabNode,
+  WallNode,
+  ZoneNode,
+} from '@pascal-app/core'
+import { paintScopeRole, resolvePaintScopeTargets } from './paint-scope'
+import {
+  mergePaintSurfaces,
+  paintSurfaceMeshes,
+  plateAffectedSurfaces,
+  platePreviewSurfaces,
+} from './plate-paint-affected'
+
+const square = (x: number): [number, number][] => [
+  [x, 0],
+  [x + 4, 0],
+  [x + 4, 4],
+  [x, 4],
+]
+const level = LevelNode.parse({ id: 'level_paint' })
+const kitchen = ZoneNode.parse({
+  id: 'zone_kitchen',
+  name: 'Kitchen',
+  parentId: level.id,
+  spaceRole: 'room',
+  polygon: square(0),
+})
+const hall = ZoneNode.parse({
+  id: 'zone_hall',
+  name: 'Hall',
+  parentId: level.id,
+  spaceRole: 'room',
+  polygon: square(4),
+  floorStepFinish: 'library:oak',
+  floorEdgeFinish: 'library:stone',
+})
+const base = SlabNode.parse({
+  id: 'slab_base',
+  parentId: level.id,
+  boundary: 'auto',
+  plateRole: 'base',
+  polygon: [
+    [0, 0],
+    [8, 0],
+    [8, 4],
+    [0, 4],
+  ],
+  zoneIds: [kitchen.id, hall.id],
+})
+const platform = SlabNode.parse({
+  id: 'slab_platform',
+  parentId: level.id,
+  boundary: 'auto',
+  plateRole: 'platform',
+  polygon: square(4),
+  zoneIds: [hall.id],
+})
+const manual = SlabNode.parse({ id: 'slab_manual', parentId: level.id, polygon: square(20) })
+const nodes = Object.fromEntries(
+  [level, kitchen, hall, base, platform, manual].map((n) => [n.id, n]),
+) as Record<string, AnyNode>
+
+const keys = (surfaces: ReturnType<typeof plateAffectedSurfaces>) =>
+  (surfaces ?? []).map((s) => `${s.nodeId}:${s.role}`).sort()
+
+describe('what one paint click changes on the floor plates (point 7)', () => {
+  test('a room’s steps are one finish on every plate of the level', () => {
+    expect(keys(plateAffectedSurfaces(nodes, base, 'step:zone_kitchen'))).toEqual([
+      'slab_base:step:zone_kitchen',
+      'slab_platform:step:zone_kitchen',
+    ])
+  })
+
+  test('a room floor with painted steps or a region paint stands alone', () => {
+    expect(keys(plateAffectedSurfaces(nodes, platform, 'room:zone_hall'))).toEqual([
+      'slab_base:room:zone_hall',
+      'slab_platform:room:zone_hall',
+    ])
+    expect(keys(plateAffectedSurfaces(nodes, base, 'room:zone_kitchen/region_1'))).toEqual([
+      'slab_base:room:zone_kitchen/region_1',
+      'slab_platform:room:zone_kitchen/region_1',
+    ])
+  })
+
+  test('the footprint edge band carries the edges of its rooms that have no edge finish', () => {
+    expect(keys(plateAffectedSurfaces(nodes, base, 'edge'))).toEqual([
+      'slab_base:edge',
+      'slab_base:edge:zone_kitchen',
+      'slab_platform:edge:zone_kitchen',
+    ])
+  })
+
+  test('other plate faces are just themselves; a hand-drawn slab keeps its own path', () => {
+    expect(keys(plateAffectedSurfaces(nodes, base, 'riser'))).toEqual(['slab_base:riser'])
+    expect(plateAffectedSurfaces(nodes, manual, 'surface')).toBeNull()
+  })
+})
+
+/** A | B | C in a row, a door in each dividing wall, B raised: one step per door. */
+function doorwayRow(): Record<string, AnyNode> {
+  const ring = (x0: number, x1: number): [number, number][] => [
+    [x0, 0],
+    [x1, 0],
+    [x1, 4],
+    [x0, 4],
+  ]
+  const outline = ring(0, 12)
+  const walls = outline.map((start, i) =>
+    WallNode.parse({ parentId: 'level_row', start, end: outline[(i + 1) % 4], thickness: 0.2 }),
+  )
+  const doors = ['door_ab', 'door_bc'].map((id) =>
+    DoorNode.parse({
+      id,
+      parentId: `wall_${id}`,
+      wallId: `wall_${id}`,
+      width: 1,
+      height: 2,
+      position: [2, 1, 0],
+    }),
+  )
+  const dividers = [4, 8].map((x, i) =>
+    WallNode.parse({
+      id: `wall_${doors[i]!.id}`,
+      parentId: 'level_row',
+      start: [x, 0],
+      end: [x, 4],
+      thickness: 0.2,
+      children: [doors[i]!.id],
+    }),
+  )
+  const zones = ['a', 'b', 'c'].map((name, i) =>
+    ZoneNode.parse({
+      id: `zone_${name}`,
+      parentId: 'level_row',
+      name,
+      spaceRole: 'room',
+      enclosureStatus: 'enclosed',
+      polygon: ring(i * 4, (i + 1) * 4),
+      floor: { elevation: i === 1 ? 0.3 : 0.05 },
+    }),
+  )
+  const children = [...walls, ...dividers, ...zones]
+  const level = LevelNode.parse({ id: 'level_row', height: 3, children: children.map((n) => n.id) })
+  let minted = 0
+  return reconcileSceneStructure({
+    nodes: Object.fromEntries([level, ...children, ...doors].map((n) => [n.id, n])),
+    mintId: (kind) => `${kind}_row${++minted}`,
+  }).nodes as Record<string, AnyNode>
+}
+
+// B is raised between A and C, a door on each side: B owns one step per door.
+describe('doorway steps: hover, preview and commit are the same set', () => {
+  const row = doorwayRow()
+  const plates = Object.values(row).filter(
+    (node): node is SlabNode => node.type === 'slab' && node.boundary === 'auto',
+  )
+  const plate = plates.find((slab) => slab.plateRole === 'platform')!
+  const onPlates = (...roles: string[]) =>
+    plates.flatMap((slab) => roles.map((role) => `${slab.id}:${role}`)).sort()
+  type Obj = {
+    userData: Record<string, unknown>
+    isMesh?: boolean
+    traverse: (visit: (o: Obj) => void) => void
+  }
+  const mesh = (paintRole: string): Obj => ({
+    isMesh: true,
+    userData: { paintRole, __fromGeometry: true },
+    traverse(visit) {
+      visit(this)
+    },
+  })
+  const floorB = mesh('room:zone_b')
+  const stepAB = mesh('step:zone_b/door_ab')
+  const stepBC = mesh('step:zone_b/door_bc')
+  const root: Obj = {
+    userData: {},
+    traverse(visit) {
+      for (const child of [floorB, stepAB, stepBC]) visit(child)
+    },
+  }
+  const outlined = (surfaces: ReturnType<typeof plateAffectedSurfaces>) =>
+    paintSurfaceMeshes(surfaces!, (id) => (id === plate.id ? root : null))
+  const targets = (role: string, scope: 'single' | 'room') =>
+    resolvePaintScopeTargets({
+      node: plate,
+      role,
+      scope,
+      nodes: row,
+      spaces: {},
+      slotRolesOf: () => [],
+    })
+      .map((target) => `${target.nodeId}:${target.role}`)
+      .sort()
+
+  test('one step: that doorway only, on every plate', () => {
+    const role = 'step:zone_b/door_bc'
+    expect(paintScopeRole(plate, role, 'single')).toBe(role)
+    expect(targets(role, 'single')).toEqual(onPlates(role))
+    const affected = plateAffectedSurfaces(row, plate, role)
+    expect(keys(affected)).toEqual(onPlates(role))
+    expect(outlined(affected)).toEqual([stepBC])
+  })
+
+  test('the room scope: every step of the room', () => {
+    const role = paintScopeRole(plate, 'step:zone_b/door_bc', 'room')
+    expect(role).toBe('step:zone_b')
+    expect(targets('step:zone_b/door_bc', 'room')).toEqual(onPlates(role))
+    expect(outlined(plateAffectedSurfaces(row, plate, role))).toEqual([stepAB, stepBC])
+  })
+
+  test('a floor paint carries only the steps that follow the floor', () => {
+    expect(keys(plateAffectedSurfaces(row, plate, 'room:zone_b'))).toEqual(
+      onPlates('room:zone_b', 'step:zone_b/door_ab', 'step:zone_b/door_bc'),
+    )
+    const painted = {
+      ...row,
+      zone_b: { ...row.zone_b!, floorStepOverrides: [{ key: 'door_bc', finish: 'library:x' }] },
+    } as Record<string, AnyNode>
+    const affected = plateAffectedSurfaces(painted, plate, 'room:zone_b')
+    expect(keys(affected)).toEqual(onPlates('room:zone_b', 'step:zone_b/door_ab'))
+    expect(outlined(affected)).toEqual([floorB, stepAB])
+    // The preview is the click targets plus the fallbacks, once each.
+    expect(mergePaintSurfaces([{ nodeId: plate.id, role: 'room:zone_b' }], affected)).toHaveLength(
+      affected!.length,
+    )
+  })
+})
+
+describe('the whole room: what it paints, erases, and where it previews', () => {
+  const row = doorwayRow()
+  const plates = Object.values(row).filter(
+    (node): node is SlabNode => node.type === 'slab' && node.boundary === 'auto',
+  )
+  const plate = plates.find((slab) => slab.plateRole === 'platform')!
+  const onPlates = (...roles: string[]) =>
+    plates.flatMap((slab) => roles.map((role) => `${slab.id}:${role}`)).sort()
+  const zoneB = row.zone_b as ZoneNode
+  const withB = (patch: Partial<ZoneNode>) =>
+    ({ ...row, zone_b: { ...zoneB, ...patch } }) as Record<string, AnyNode>
+
+  test('painted, the whole room is its floor, its painted parts and the steps that follow it', () => {
+    const rug = withB({
+      floor: {
+        ...zoneB.floor,
+        regions: [{ id: 'rug', polygon: square(4), finish: 'library:red' }],
+      },
+    } as Partial<ZoneNode>)
+    expect(keys(plateAffectedSurfaces(rug, plate, 'room:zone_b/*'))).toEqual(
+      onPlates('room:zone_b', 'room:zone_b/rug', 'step:zone_b/door_ab', 'step:zone_b/door_bc'),
+    )
+    const nodes = withB({ floorStepOverrides: [{ key: 'door_bc', finish: 'library:x' }] })
+    expect(keys(plateAffectedSurfaces(nodes, plate, 'room:zone_b/*'))).toEqual(
+      onPlates('room:zone_b', 'step:zone_b/door_ab'),
+    )
+    // A room step finish holds the steps: the floor goes alone.
+    expect(
+      keys(plateAffectedSurfaces(withB({ floorStepFinish: 'library:y' }), plate, 'room:zone_b/*')),
+    ).toEqual(onPlates('room:zone_b'))
+  })
+
+  test('erased, it also clears its painted parts and its edge; doorway paint stays', () => {
+    const nodes = withB({
+      floorStepFinish: 'library:y',
+      floorEdgeFinish: 'library:stone',
+      floorStepOverrides: [{ key: 'door_bc', finish: 'library:x' }],
+      floor: {
+        ...zoneB.floor,
+        finish: 'library:oak',
+        regions: [{ id: 'rug', polygon: square(4), finish: 'library:red' }],
+      },
+    } as Partial<ZoneNode>)
+    expect(keys(plateAffectedSurfaces(nodes, plate, 'room:zone_b/*', { erasing: true }))).toEqual(
+      onPlates('edge:zone_b', 'room:zone_b', 'room:zone_b/rug', 'step:zone_b/door_ab'),
+    )
+  })
+
+  test('a floor previews on every plate; its steps are drawn by that preview', () => {
+    expect(keys(platePreviewSurfaces(row, plate, 'room:zone_b'))).toEqual(onPlates('room:zone_b'))
+    expect(keys(platePreviewSurfaces(row, plate, 'room:zone_b/*'))).toEqual(
+      onPlates('room:zone_b/*'),
+    )
+    expect(keys(platePreviewSurfaces(row, plate, 'step:zone_b'))).toEqual(onPlates('step:zone_b'))
+  })
+})
+
+describe("a footprint's edge band previews where its rooms' edges are drawn", () => {
+  test('the band itself, and the plates drawing the edges that carry it', () => {
+    expect(keys(platePreviewSurfaces(nodes, base, 'edge'))).toEqual([
+      'slab_base:edge',
+      'slab_platform:edge',
+    ])
+    expect(keys(platePreviewSurfaces(nodes, base, 'foundation'))).toEqual(['slab_base:foundation'])
+    expect(platePreviewSurfaces(nodes, manual, 'surface')).toBeNull()
+  })
+})

package/src/lib/plate-paint-affected.ts

@@ -0,0 +1,177 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  floorStepKeysOf,
+  floorStepOverrideFor,
+  floorStepRole,
+  floorStepRoleCovers,
+  parseCeilingRegionRole,
+  parseFloorStepRole,
+  parseRoomFinishRole,
+  roomFinishRole,
+  type SlabNode,
+  type ZoneNode,
+} from '@pascal-app/core'
+import { create } from 'zustand'
+import { roomFootprint } from './floor-footprints'
+
+export type PaintSurface = { nodeId: AnyNodeId; role: string }
+
+const isFloorPlate = (node: AnyNode | undefined): node is SlabNode =>
+  node?.type === 'slab' && node.boundary === 'auto'
+
+/**
+ * Every floor-plate surface one paint click changes: the painted surface and
+ * the surfaces whose finish falls back to it. A room's floor carries its steps
+ * until they are painted on their own (room-wide or per doorway); the
+ * footprint's edge band carries the edges of the rooms on it that have no edge
+ * finish; a step paints its doorway, or in the room scope (`step:<zoneId>`)
+ * every step of the room, wherever they are drawn. A region paint changes only
+ * the region. The whole room (`room:<zoneId>/*`) paints its floor, its painted
+ * parts and the steps that follow it; erased, it also clears its steps and edge.
+ *
+ * This set is the hover outline; `platePreviewSurfaces` previews it, so what
+ * lights up is exactly what the click changes. Null for anything but a floor
+ * plate.
+ */
+export function plateAffectedSurfaces(
+  nodes: Readonly<Record<string, AnyNode>>,
+  node: AnyNode,
+  role: string,
+  options: { erasing?: boolean } = {},
+): PaintSurface[] | null {
+  if (!isFloorPlate(node)) return null
+  const plates = Object.values(nodes).filter(
+    (other): other is SlabNode => isFloorPlate(other) && other.parentId === node.parentId,
+  )
+  const onEveryPlate = (paintRole: string) =>
+    plates.map((plate) => ({ nodeId: plate.id as AnyNodeId, role: paintRole }))
+  const zoneOf = (zoneId: string) => {
+    const zone = nodes[zoneId]
+    return zone?.type === 'zone' ? zone : null
+  }
+  // The room's steps that no doorway paint holds: the ones its floor carries.
+  const followingSteps = (zone: ZoneNode) => {
+    const zones = Object.values(nodes).filter(
+      (other): other is ZoneNode => other.type === 'zone' && other.parentId === zone.parentId,
+    )
+    return floorStepKeysOf(nodes, zone.parentId ?? '', zone.id)
+      .filter((key) => !floorStepOverrideFor(zone, key, null, zones))
+      .flatMap((key) => onEveryPlate(floorStepRole(zone.id, key)))
+  }
+
+  if (parseFloorStepRole(role)) return onEveryPlate(role)
+
+  const floor = parseRoomFinishRole(role)
+  if (floor) {
+    const zone = zoneOf(floor.zoneId)
+    if (floor.regionId === '*') {
+      const surfaces = onEveryPlate(roomFinishRole(floor.zoneId))
+      if (!zone) return surfaces
+      for (const region of zone.floor?.regions ?? [])
+        surfaces.push(...onEveryPlate(roomFinishRole(zone.id, region.id)))
+      if (!options.erasing)
+        return zone.floorStepFinish ? surfaces : [...surfaces, ...followingSteps(zone)]
+      surfaces.push(...followingSteps(zone))
+      if (zone.floorEdgeFinish) surfaces.push(...onEveryPlate(`edge:${zone.id}`))
+      return surfaces
+    }
+    const surfaces = onEveryPlate(role)
+    if (floor.regionId || !zone || zone.floorStepFinish) return surfaces
+    return [...surfaces, ...followingSteps(zone)]
+  }
+
+  if (role === 'edge' && node.plateRole === 'base') {
+    const surfaces: PaintSurface[] = [{ nodeId: node.id as AnyNodeId, role }]
+    for (const zone of Object.values(nodes)) {
+      if (zone.type !== 'zone' || zone.parentId !== node.parentId || zone.floorEdgeFinish) continue
+      if (roomFootprint(nodes as Record<string, AnyNode>, zone.id)?.id !== node.id) continue
+      surfaces.push(...onEveryPlate(`edge:${zone.id}`))
+    }
+    return surfaces
+  }
+
+  return [{ nodeId: node.id as AnyNodeId, role }]
+}
+
+/**
+ * The (plate, role) pairs whose paint preview draws `plateAffectedSurfaces`.
+ * A surface that follows another (a room's unpainted steps, the room edges on
+ * a footprint's band) is drawn by the preview of the surface it follows on the
+ * same plate: only that preview knows what the follower shows once its leader
+ * is erased. So a floor and a whole room preview on every plate, and a
+ * footprint's edge band on itself and on the plates drawing its rooms' edges.
+ */
+export function platePreviewSurfaces(
+  nodes: Readonly<Record<string, AnyNode>>,
+  node: AnyNode,
+  role: string,
+): PaintSurface[] | null {
+  if (!isFloorPlate(node)) return null
+  if (parseFloorStepRole(role) || parseRoomFinishRole(role))
+    return Object.values(nodes)
+      .filter((other) => isFloorPlate(other) && other.parentId === node.parentId)
+      .map((plate) => ({ nodeId: plate.id as AnyNodeId, role }))
+  if (role === 'edge' && node.plateRole === 'base')
+    return mergePaintSurfaces(
+      [{ nodeId: node.id as AnyNodeId, role }],
+      (plateAffectedSurfaces(nodes, node, role) ?? []).map((surface) => ({
+        nodeId: surface.nodeId,
+        role,
+      })),
+    )
+  return [{ nodeId: node.id as AnyNodeId, role }]
+}
+
+/** A ceiling's painted part: the click changes that region and nothing else. */
+export function ceilingAffectedSurfaces(node: AnyNode, role: string): PaintSurface[] | null {
+  return node.type === 'ceiling' && parseCeilingRegionRole(role)
+    ? [{ nodeId: node.id as AnyNodeId, role }]
+    : null
+}
+
+/** The targets a preview paints: the click's own targets plus what falls back to them. */
+export function mergePaintSurfaces(
+  first: readonly PaintSurface[],
+  second: readonly PaintSurface[] | null,
+): PaintSurface[] {
+  const merged = new Map<string, PaintSurface>()
+  for (const surface of [...first, ...(second ?? [])])
+    merged.set(`${surface.nodeId}:${surface.role}`, surface)
+  return [...merged.values()]
+}
+
+/**
+ * The meshes of `surfaces` under their registered roots: what the hover
+ * outline draws instead of the whole plate.
+ */
+export function paintSurfaceMeshes<
+  T extends { userData: Record<string, unknown>; traverse: (visit: (object: T) => void) => void },
+>(surfaces: readonly PaintSurface[], rootOf: (nodeId: AnyNodeId) => T | null | undefined): T[] {
+  const byNode = new Map<AnyNodeId, Set<string>>()
+  for (const { nodeId, role } of surfaces) {
+    const roles = byNode.get(nodeId) ?? new Set<string>()
+    roles.add(role)
+    byNode.set(nodeId, roles)
+  }
+  const meshes: T[] = []
+  for (const [nodeId, roles] of byNode) {
+    rootOf(nodeId)?.traverse((object) => {
+      const { paintRole, slotId, __fromGeometry } = object.userData as {
+        paintRole?: string
+        slotId?: string | null
+        __fromGeometry?: boolean
+      }
+      if ((object as { isMesh?: boolean }).isMesh !== true || __fromGeometry !== true) return
+      const role = paintRole ?? slotId
+      if (role && (roles.has(role) || [...roles].some((wide) => floorStepRoleCovers(wide, role))))
+        meshes.push(object)
+    })
+  }
+  return meshes
+}
+
+/** The floor-plate surfaces the paint hover outlines (null: outline the hovered node as usual). */
+export const usePaintOutline = create<{ surfaces: PaintSurface[] | null }>(() => ({
+  surfaces: null,
+}))

package/src/lib/plugin-chat.ts

@@ -0,0 +1,50 @@
+import type { ComponentType } from 'react'
+
+/**
+ * What a plugin's tool answers in a chat. Images travel by reference (a host-stored asset), never
+ * as bytes, so a transcript stays small; a refusal is `error` with its stable `code`.
+ */
+export type ChatToolOutput = {
+  text?: string
+  data?: Record<string, unknown>
+  images?: readonly { ref: string; alt?: string }[]
+  error?: string
+  code?: string
+}
+
+/**
+ * What a plugin's card renders for one of its tool calls, from the persisted call alone. `actions`
+ * are the host's: open one of the editor's views, select nodes, send a prompt to the chat.
+ */
+export type ChatToolCardProps = {
+  toolName: string
+  input: unknown
+  output: ChatToolOutput | undefined
+  state: 'running' | 'done' | 'error' | 'cancelled'
+  actions: {
+    openView(viewId: string, options?: { beside?: boolean }): void
+    select(nodeIds: readonly string[]): void
+    send(prompt: string): void
+  }
+}
+
+/**
+ * A plugin's contribution to a host's chat, exported from its browser entry beside its panels and
+ * views; its tool contracts are its `./agent-tools` export. Which tools a turn offers, and to whom,
+ * is the host's decision.
+ */
+export type PluginChatExtension = {
+  pluginId: string
+  /** Runs the plugin's `runsIn: 'editor'` tools in the editor tab. */
+  execute?: (
+    name: string,
+    input: unknown,
+    context: { projectId: string; signal: AbortSignal },
+  ) => Promise<ChatToolOutput>
+  /** A card per tool name, loaded lazily; a tool without one shows as a plain tool row. */
+  cards?: Readonly<Record<string, () => Promise<{ default: ComponentType<ChatToolCardProps> }>>>
+  /** Entries for the composer's `/` menu: picking one sends `prompt`. */
+  actions?: readonly { id: string; label: string; hint: string; prompt: string }[]
+  /** File extensions or MIME types the plugin's tools read, which the composer then accepts. */
+  accepts?: readonly string[]
+}

package/src/lib/plugin-panels.test.ts

@@ -3,7 +3,9 @@ import {
   type EditorHostPanel,
   editorHostPanelRegistry,
   managedPluginIds,
+  pluginInstallLocks,
   registerEditorHostPanel,
+  setPluginInstallLocks,
   showsPluginManager,
 } from './plugin-panels'
 
@@ -108,3 +110,26 @@ describe('showsPluginManager', () => {
     }
   })
 })
+
+describe('pluginInstallLocks', () => {
+  afterEach(() => setPluginInstallLocks({}))
+
+  test('replaces the whole lock set and notifies subscribers with a new snapshot', () => {
+    let notified = 0
+    const unsubscribe = pluginInstallLocks.subscribe(() => {
+      notified += 1
+    })
+    const before = pluginInstallLocks.getSnapshot()
+    setPluginInstallLocks({
+      'pascal:architect': { actionLabel: 'Upgrade', onAction: () => {}, reason: 'Pro plan' },
+    })
+    const after = pluginInstallLocks.getSnapshot()
+
+    expect(after).not.toBe(before)
+    expect(Object.keys(after)).toEqual(['pascal:architect'])
+    setPluginInstallLocks({})
+    expect(pluginInstallLocks.getSnapshot()).toEqual({})
+    expect(notified).toBe(2)
+    unsubscribe()
+  })
+})

package/src/lib/plugin-panels.ts

@@ -17,6 +17,48 @@ export type EditorHostPanel = {
   }
   pluginUrl?: string
   defaultInstalled?: boolean
+  /** Short label shown next to the plugin name in the manager, e.g. "Pro". */
+  badge?: string
+  /** Directory grouping, e.g. "Outdoor & site". Uncategorised plugins list under "Other". */
+  category?: string
+  /** One line for the directory card; `description` is the full text on its detail. */
+  summary?: string
+  /** What the plugin reaches beyond the editor — the host's policy, shown before install. */
+  access?: readonly PluginAccess[]
+}
+
+/** One thing a plugin can reach once installed: a host service, an outside account, shared data. */
+export type PluginAccess = {
+  /** Picks the glyph: AI calls, media models, data pulls, an outside account, sharing. */
+  kind: 'ai' | 'media' | 'data' | 'account' | 'sharing'
+  label: string
+  detail: string
+  /** Calls spend the project's credits; the card sums these into one "Uses credits" chip. */
+  usesCredits?: boolean
+  /** Card chip for an access that spends no credits, e.g. "Mint account". Defaults to `label`. */
+  chip?: string
+}
+
+/**
+ * Host-owned facts about the open project that the plugin directory shows: its
+ * name, the credits plugin calls spend, and the house rules under the
+ * categories ("Installing is free", …).
+ */
+export type PluginDirectoryContext = {
+  projectName?: string
+  credits?: { remaining: number } | { unlimited: true } | null
+  notes?: readonly string[]
+}
+
+/**
+ * A host-owned reason why a plugin cannot be installed right now (a plan the
+ * account doesn't have, for instance). The manager swaps its Install button
+ * for `actionLabel`; uninstalling is never locked.
+ */
+export type PluginInstallLock = {
+  reason: string
+  actionLabel: string
+  onAction: () => void
 }
 
 function isDevMode(): boolean {
@@ -86,6 +128,58 @@ class EditorHostPanelRegistryImpl {
 
 export const editorHostPanelRegistry = new EditorHostPanelRegistryImpl()
 
+class PluginInstallLocksImpl {
+  private locks: Readonly<Record<string, PluginInstallLock>> = {}
+  private readonly listeners = new Set<() => void>()
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): Readonly<Record<string, PluginInstallLock>> => this.locks
+
+  set(locks: Record<string, PluginInstallLock>): void {
+    this.locks = { ...locks }
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const pluginInstallLocks = new PluginInstallLocksImpl()
+
+class PluginDirectoryContextImpl {
+  private context: PluginDirectoryContext = {}
+  private readonly listeners = new Set<() => void>()
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): PluginDirectoryContext => this.context
+
+  set(context: PluginDirectoryContext): void {
+    this.context = context
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const pluginDirectoryContext = new PluginDirectoryContextImpl()
+
+/** Replaces what the plugin directory knows about the open project. */
+export function setPluginDirectoryContext(context: PluginDirectoryContext): void {
+  pluginDirectoryContext.set(context)
+}
+
+/** Replaces every install lock, keyed by `pluginId`. Pass `{}` to clear. */
+export function setPluginInstallLocks(locks: Record<string, PluginInstallLock>): void {
+  pluginInstallLocks.set(locks)
+}
+
 export function registerEditorHostPanel(panel: EditorHostPanel): void {
   editorHostPanelRegistry.registerPanel(panel)
 }

package/src/lib/print-shell-compiler.ts

@@ -131,6 +131,7 @@ function preparedWallHeight(
     node.supportSlabId ?? null,
     undefined,
     node.supportOffset,
+    node.justification,
   )
   const hasDisplacedBase =
     Math.abs(support.baseElevation - support.elevation) > 1e-5 ||

package/src/lib/registered-draft-snap.ts

@@ -0,0 +1,12 @@
+import { nodeRegistry } from '@pascal-app/core'
+
+export const REGISTERED_DRAFT_SNAP_EXTENSION = 'pascal:editor/draft-snap'
+
+export function snapRegisteredDraftPoint<TArgs, TResult>(
+  kind: string,
+  args: TArgs,
+  fallback: TResult,
+): TResult {
+  const snap = nodeRegistry.get(kind)?.extensions?.[REGISTERED_DRAFT_SNAP_EXTENSION]
+  return typeof snap === 'function' ? (snap as (args: TArgs) => TResult)(args) : fallback
+}