@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/floorplan/site-plan/street-name.ts

@@ -0,0 +1,302 @@
+/**
+ * Street names compared the way the Postal Service reads an address (USPS
+ * Publication 28): a name is its directional, its core and its street type,
+ * each spelling brought to the standard abbreviation. "4121 NW 34th St" and
+ * OSM's "Northwest 34th Street" are one street; "Northwest 34th Terrace" is
+ * another — the type is part of the name, and so is the quadrant.
+ */
+
+/**
+ * USPS Publication 28, Appendix C1 — street suffixes: the standard
+ * abbreviation, then every spelling the Postal Service lists for it (lower
+ * case, periods dropped).
+ */
+const PUB28_SUFFIXES: Record<string, readonly string[]> = {
+  aly: ['allee', 'alley', 'ally', 'aly'],
+  anx: ['anex', 'annex', 'annx', 'anx'],
+  arc: ['arc', 'arcade'],
+  ave: ['av', 'ave', 'aven', 'avenu', 'avenue', 'avn', 'avnue'],
+  byu: ['bayoo', 'bayou'],
+  bch: ['bch', 'beach'],
+  bnd: ['bend', 'bnd'],
+  blf: ['blf', 'bluf', 'bluff'],
+  blfs: ['bluffs'],
+  btm: ['bot', 'btm', 'bottm', 'bottom'],
+  blvd: ['blvd', 'boul', 'boulevard', 'boulv'],
+  br: ['br', 'brnch', 'branch'],
+  brg: ['brdge', 'brg', 'bridge'],
+  brk: ['brk', 'brook'],
+  brks: ['brooks'],
+  bg: ['burg'],
+  bgs: ['burgs'],
+  byp: ['byp', 'bypa', 'bypas', 'bypass', 'byps'],
+  cp: ['camp', 'cp', 'cmp'],
+  cyn: ['canyn', 'canyon', 'cnyn'],
+  cpe: ['cape', 'cpe'],
+  cswy: ['causeway', 'causwa', 'cswy'],
+  ctr: ['cen', 'cent', 'center', 'centr', 'centre', 'cnter', 'cntr', 'ctr'],
+  ctrs: ['centers'],
+  cir: ['cir', 'circ', 'circl', 'circle', 'crcl', 'crcle'],
+  cirs: ['circles'],
+  clf: ['clf', 'cliff'],
+  clfs: ['clfs', 'cliffs'],
+  clb: ['clb', 'club'],
+  cmn: ['common'],
+  cmns: ['commons'],
+  cor: ['cor', 'corner'],
+  cors: ['corners', 'cors'],
+  crse: ['course', 'crse'],
+  ct: ['court', 'ct'],
+  cts: ['courts', 'cts'],
+  cv: ['cove', 'cv'],
+  cvs: ['coves'],
+  crk: ['creek', 'crk'],
+  cres: ['crescent', 'cres', 'crsent', 'crsnt'],
+  crst: ['crest'],
+  xing: ['crossing', 'crssng', 'xing'],
+  xrd: ['crossroad'],
+  xrds: ['crossroads'],
+  curv: ['curve'],
+  dl: ['dale', 'dl'],
+  dm: ['dam', 'dm'],
+  dv: ['div', 'divide', 'dv', 'dvd'],
+  dr: ['dr', 'driv', 'drive', 'drv'],
+  drs: ['drives'],
+  est: ['est', 'estate'],
+  ests: ['estates', 'ests'],
+  expy: ['exp', 'expr', 'express', 'expressway', 'expw', 'expy'],
+  ext: ['ext', 'extension', 'extn', 'extnsn'],
+  exts: ['exts'],
+  fall: ['fall'],
+  fls: ['falls', 'fls'],
+  fry: ['ferry', 'frry', 'fry'],
+  fld: ['field', 'fld'],
+  flds: ['fields', 'flds'],
+  flt: ['flat', 'flt'],
+  flts: ['flats', 'flts'],
+  frd: ['ford', 'frd'],
+  frds: ['fords'],
+  frst: ['forest', 'forests', 'frst'],
+  frg: ['forg', 'forge', 'frg'],
+  frgs: ['forges'],
+  frk: ['fork', 'frk'],
+  frks: ['forks', 'frks'],
+  ft: ['fort', 'frt', 'ft'],
+  fwy: ['freeway', 'freewy', 'frway', 'frwy', 'fwy'],
+  gdn: ['garden', 'gardn', 'grden', 'grdn'],
+  gdns: ['gardens', 'gdns', 'grdns'],
+  gtwy: ['gateway', 'gatewy', 'gatway', 'gtway', 'gtwy'],
+  gln: ['glen', 'gln'],
+  glns: ['glens'],
+  grn: ['green', 'grn'],
+  grns: ['greens'],
+  grv: ['grov', 'grove', 'grv'],
+  grvs: ['groves'],
+  hbr: ['harb', 'harbor', 'harbr', 'hbr', 'hrbor'],
+  hbrs: ['harbors'],
+  hvn: ['haven', 'hvn'],
+  hts: ['ht', 'hts'],
+  hwy: ['highway', 'highwy', 'hiway', 'hiwy', 'hway', 'hwy'],
+  hl: ['hill', 'hl'],
+  hls: ['hills', 'hls'],
+  holw: ['hllw', 'hollow', 'hollows', 'holw', 'holws'],
+  inlt: ['inlt'],
+  is: ['is', 'island', 'islnd'],
+  iss: ['islands', 'islnds', 'iss'],
+  isle: ['isle', 'isles'],
+  jct: ['jct', 'jction', 'jctn', 'junction', 'junctn', 'juncton'],
+  jcts: ['jctns', 'jcts', 'junctions'],
+  ky: ['key', 'ky'],
+  kys: ['keys', 'kys'],
+  knl: ['knl', 'knol', 'knoll'],
+  knls: ['knls', 'knolls'],
+  lk: ['lk', 'lake'],
+  lks: ['lks', 'lakes'],
+  land: ['land'],
+  lndg: ['landing', 'lndg', 'lndng'],
+  ln: ['lane', 'ln'],
+  lgt: ['lgt', 'light'],
+  lgts: ['lights'],
+  lf: ['lf', 'loaf'],
+  lck: ['lck', 'lock'],
+  lcks: ['lcks', 'locks'],
+  ldg: ['ldg', 'ldge', 'lodg', 'lodge'],
+  loop: ['loop', 'loops'],
+  mall: ['mall'],
+  mnr: ['mnr', 'manor'],
+  mnrs: ['manors', 'mnrs'],
+  mdw: ['meadow'],
+  mdws: ['mdw', 'mdws', 'meadows', 'medows'],
+  mews: ['mews'],
+  ml: ['mill'],
+  mls: ['mills'],
+  msn: ['missn', 'mssn'],
+  mtwy: ['motorway'],
+  mt: ['mnt', 'mt', 'mount'],
+  mtn: ['mntain', 'mntn', 'mountain', 'mountin', 'mtin', 'mtn'],
+  mtns: ['mntns', 'mountains'],
+  nck: ['nck', 'neck'],
+  orch: ['orch', 'orchard', 'orchrd'],
+  oval: ['oval', 'ovl'],
+  opas: ['overpass'],
+  park: ['park', 'prk', 'parks'],
+  pkwy: ['parkway', 'parkwy', 'pkway', 'pkwy', 'pky', 'parkways', 'pkwys'],
+  pass: ['pass'],
+  psge: ['passage'],
+  path: ['path', 'paths'],
+  pike: ['pike', 'pikes'],
+  pne: ['pine'],
+  pnes: ['pines', 'pnes'],
+  pl: ['pl', 'place'],
+  pln: ['plain', 'pln'],
+  plns: ['plains', 'plns'],
+  plz: ['plaza', 'plz', 'plza'],
+  pt: ['point', 'pt'],
+  pts: ['points', 'pts'],
+  prt: ['port', 'prt'],
+  prts: ['ports', 'prts'],
+  pr: ['pr', 'prairie', 'prr'],
+  radl: ['rad', 'radial', 'radiel', 'radl'],
+  ramp: ['ramp'],
+  rnch: ['ranch', 'ranches', 'rnch', 'rnchs'],
+  rpd: ['rapid', 'rpd'],
+  rpds: ['rapids', 'rpds'],
+  rst: ['rest', 'rst'],
+  rdg: ['rdg', 'rdge', 'ridge'],
+  rdgs: ['rdgs', 'ridges'],
+  riv: ['riv', 'river', 'rvr', 'rivr'],
+  rd: ['rd', 'road'],
+  rds: ['roads', 'rds'],
+  rte: ['route'],
+  row: ['row'],
+  rue: ['rue'],
+  run: ['run'],
+  shl: ['shl', 'shoal'],
+  shls: ['shls', 'shoals'],
+  shr: ['shoar', 'shore', 'shr'],
+  shrs: ['shoars', 'shores', 'shrs'],
+  skwy: ['skyway'],
+  spg: ['spg', 'spng', 'spring', 'sprng'],
+  spgs: ['spgs', 'spngs', 'springs', 'sprngs'],
+  spur: ['spur', 'spurs'],
+  sq: ['sq', 'sqr', 'sqre', 'squ', 'square'],
+  sqs: ['sqrs', 'squares'],
+  sta: ['sta', 'station', 'statn', 'stn'],
+  stra: ['stra', 'strav', 'straven', 'stravenue', 'stravn', 'strvn', 'strvnue'],
+  strm: ['stream', 'streme', 'strm'],
+  st: ['street', 'strt', 'st', 'str'],
+  sts: ['streets'],
+  smt: ['smt', 'sumit', 'sumitt', 'summit'],
+  ter: ['ter', 'terr', 'terrace'],
+  trwy: ['throughway'],
+  trce: ['trace', 'traces', 'trce'],
+  trak: ['track', 'tracks', 'trak', 'trk', 'trks'],
+  trfy: ['trafficway'],
+  trl: ['trail', 'trails', 'trl', 'trls'],
+  trlr: ['trailer', 'trlr', 'trlrs'],
+  tunl: ['tunel', 'tunl', 'tunls', 'tunnel', 'tunnels', 'tunnl'],
+  tpke: ['trnpk', 'turnpike', 'turnpk'],
+  upas: ['underpass'],
+  un: ['un', 'union'],
+  uns: ['unions'],
+  vly: ['valley', 'vally', 'vlly', 'vly'],
+  vlys: ['valleys', 'vlys'],
+  via: ['vdct', 'via', 'viadct', 'viaduct'],
+  vw: ['view', 'vw'],
+  vws: ['views', 'vws'],
+  vlg: ['vill', 'villag', 'village', 'villg', 'villiage', 'vlg'],
+  vlgs: ['villages', 'vlgs'],
+  vl: ['ville', 'vl'],
+  vis: ['vis', 'vist', 'vista', 'vst', 'vsta'],
+  walk: ['walk', 'walks'],
+  wall: ['wall'],
+  way: ['wy', 'way'],
+  ways: ['ways'],
+  wl: ['well'],
+  wls: ['wells', 'wls'],
+}
+
+/** Any listed spelling of a street type → its Pub. 28 abbreviation. */
+const SUFFIX: ReadonlyMap<string, string> = new Map(
+  Object.entries(PUB28_SUFFIXES).flatMap(([abbr, spellings]) =>
+    spellings.map((s) => [s, abbr] as const),
+  ),
+)
+
+/** Pub. 28 directionals, spelled out or abbreviated → the abbreviation. */
+const DIRECTIONAL: ReadonlyMap<string, string> = new Map([
+  ['n', 'n'],
+  ['s', 's'],
+  ['e', 'e'],
+  ['w', 'w'],
+  ['ne', 'ne'],
+  ['nw', 'nw'],
+  ['se', 'se'],
+  ['sw', 'sw'],
+  ['north', 'n'],
+  ['south', 's'],
+  ['east', 'e'],
+  ['west', 'w'],
+  ['northeast', 'ne'],
+  ['northwest', 'nw'],
+  ['southeast', 'se'],
+  ['southwest', 'sw'],
+])
+
+export interface StreetName {
+  /** The directional before the name ("nw"), '' when none. */
+  pre: string
+  /** The name itself, lower case ("34th", "castro"). */
+  name: string
+  /** The street type as its Pub. 28 abbreviation ("st", "ter"), '' when the name carries none. */
+  type: string
+  /** The directional after the type ("n" in "1st St N"), '' when none. */
+  post: string
+}
+
+/**
+ * A street line read into its parts: the house number dropped, the type and
+ * the directionals standardised. A word is only read as a type or a
+ * directional when a name is left beside it ("North St" is the street named
+ * North).
+ */
+export function parseStreetName(s: string | null | undefined): StreetName {
+  const words = String(s ?? '')
+    .toLowerCase()
+    .replace(/\./g, '')
+    .replace(/^\s*\d+[a-z]?(?:-\d+[a-z]?)?\s+/, '')
+    .replace(/[^a-z0-9]+/g, ' ')
+    .trim()
+    .split(' ')
+    .filter(Boolean)
+  let post = ''
+  let type = ''
+  let pre = ''
+  if (words.length >= 2 && DIRECTIONAL.has(words[words.length - 1] as string))
+    post = DIRECTIONAL.get(words.pop() as string) as string
+  if (words.length >= 2 && SUFFIX.has(words[words.length - 1] as string))
+    type = SUFFIX.get(words.pop() as string) as string
+  if (words.length >= 2 && DIRECTIONAL.has(words[0] as string))
+    pre = DIRECTIONAL.get(words.shift() as string) as string
+  return { pre, name: words.join(' '), type, post }
+}
+
+/**
+ * Do two street lines name the same street? The names must agree, and so
+ * must the street types and the directionals wherever both lines give one:
+ * "NW 34th St" is "Northwest 34th Street" (and "34th Street"), never
+ * "Northwest 34th Terrace" or "SW 34th St". A line with no name matches
+ * nothing.
+ */
+export function sameStreet(
+  a: string | StreetName | null | undefined,
+  b: string | StreetName | null | undefined,
+): boolean {
+  const x = typeof a === 'object' && a !== null ? a : parseStreetName(a)
+  const y = typeof b === 'object' && b !== null ? b : parseStreetName(b)
+  if (!x.name || x.name !== y.name) return false
+  if (x.type && y.type && x.type !== y.type) return false
+  const dx = [x.pre, x.post].filter(Boolean).join(' ')
+  const dy = [y.pre, y.post].filter(Boolean).join(' ')
+  return !dx || !dy || dx === dy
+}

package/src/lib/floorplan/site-plan/yards.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from 'bun:test'
+import { castYardDimensionsOriented } from '@pascal-app/core'
+import { castYardDimensions, type Pt } from './geometry'
+
+// 20 m × 30 m lot centred on the origin, y south
+const LOT: Pt[] = [
+  [-10, -15],
+  [10, -15],
+  [10, 15],
+  [-10, 15],
+]
+const box = (w: number, d: number, cx: number, cz: number, yaw: number): Pt[] => {
+  const c = Math.cos(yaw)
+  const s = Math.sin(yaw)
+  const corners: Pt[] = [
+    [-w / 2, -d / 2],
+    [w / 2, -d / 2],
+    [w / 2, d / 2],
+    [-w / 2, d / 2],
+  ]
+  return corners.map(([lx, lz]) => [cx + c * lx + s * lz, cz - s * lx + c * lz])
+}
+const by = (yards: ReturnType<typeof castYardDimensions>) =>
+  Object.fromEntries(yards.map((y) => [y.side, Math.round(y.distance * 1000) / 1000]))
+
+describe('castYardDimensionsOriented', () => {
+  test('with no rotation it is the axis-aligned cast', () => {
+    const house = box(8, 10, 0, -2, 0)
+    const oriented = castYardDimensionsOriented(LOT, [house], 0)
+    const bbox = castYardDimensions(LOT, { minX: -4, minY: -7, maxX: 4, maxY: 3 })
+    expect(by(oriented)).toEqual(by(bbox))
+    expect(by(oriented)).toEqual({ north: 8, south: 12, west: 6, east: 6 })
+  })
+
+  test('a house turned 90° measures square to its own faces', () => {
+    // 8 wide × 10 deep, turned a quarter: its 10 m side now runs east-west
+    const house = box(8, 10, 0, -2, Math.PI / 2)
+    const yards = by(castYardDimensionsOriented(LOT, [house], Math.PI / 2))
+    expect(yards).toEqual({ north: 9, south: 13, west: 5, east: 5 })
+  })
+
+  test('a house on a diagonal reads its true yards, not the bbox ones', () => {
+    // a 10 × 10 house turned 45° at the origin: its corners reach 7.07 m out,
+    // its faces 5 m — the axis-aligned bbox would put the north yard at 7.93
+    const house = box(10, 10, 0, 0, Math.PI / 4)
+    const oriented = castYardDimensionsOriented(LOT, [house], Math.PI / 4)
+    for (const y of oriented) {
+      // each face midpoint sits 5 m from the centre; the ray runs diagonally to the lot line
+      const fromDist = Math.hypot(y.from[0], y.from[1])
+      expect(fromDist).toBeCloseTo(5, 9)
+    }
+    const bbox = castYardDimensions(LOT, { minX: -7.071, minY: -7.071, maxX: 7.071, maxY: 7.071 })
+    expect(by(bbox).north).toBeCloseTo(7.929, 3)
+    expect(oriented.length).toBe(4)
+  })
+
+  test('no footprint, no yards', () => {
+    expect(castYardDimensionsOriented(LOT, [], 0.3)).toEqual([])
+    expect(
+      castYardDimensionsOriented(
+        [
+          [0, 0],
+          [1, 0],
+        ],
+        [box(1, 1, 0, 0, 0)],
+        0,
+      ),
+    ).toEqual([])
+  })
+})

package/src/lib/floorplan/types.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, ItemNode, Point2D, StairNode, StairSegmentNode } from '@pascal-app/core'
+import type { AnyNode, ItemNode, Point2D } from '@pascal-app/core'
 
 export type FloorplanNodeTransform = {
   position: Point2D
@@ -21,27 +21,6 @@ export type FloorplanItemEntry = {
   depth: number
 }
 
-export type FloorplanStairSegmentEntry = {
-  centerLine: FloorplanLineSegment | null
-  innerPolygon: Point2D[]
-  segment: StairSegmentNode
-  polygon: Point2D[]
-  treadBars: Point2D[][]
-  treadThickness: number
-}
-
-export type FloorplanStairArrowEntry = {
-  head: Point2D[]
-  polyline: Point2D[]
-}
-
-export type FloorplanStairEntry = {
-  arrow: FloorplanStairArrowEntry | null
-  hitPolygons: Point2D[][]
-  stair: StairNode
-  segments: FloorplanStairSegmentEntry[]
-}
-
 export type FloorplanSelectionBounds = {
   minX: number
   maxX: number
@@ -49,9 +28,4 @@ export type FloorplanSelectionBounds = {
   maxY: number
 }
 
-export type StairSegmentTransform = {
-  position: [number, number, number]
-  rotation: number
-}
-
 export type LevelDescendantMap = ReadonlyMap<string, AnyNode>

package/src/lib/follow-pascal-exterior.test-fixture.ts

@@ -0,0 +1,17 @@
+import type { AnyNode } from '@pascal-app/core'
+
+// What the nodes package declares as `capabilities.exterior` for its wall, door and window, written
+// out for the tests that register their own throw-away kinds (`packages/editor` does not import
+// `@pascal-app/nodes`).
+
+/** A wall with an outdoor face. */
+export const wallExterior = (node: AnyNode) =>
+  node.type === 'wall' && (node.frontSide === 'exterior' || node.backSide === 'exterior')
+
+/** An opening in a roof segment or in such a wall. */
+export const openingExterior = (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) => {
+  if (node.type !== 'door' && node.type !== 'window') return false
+  if (node.roofSegmentId) return true
+  const host = nodes[node.wallId ?? node.parentId ?? '']
+  return host ? wallExterior(host) : false
+}

package/src/lib/follow-pascal-exterior.test.ts

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  BuildingNode,
+  type Capabilities,
+  DoorNode,
+  ItemNode,
+  LevelNode,
+  loadPlugin,
+  nodeRegistry,
+  RoofNode,
+  RoofSegmentNode,
+  SiteNode,
+  WallNode,
+} from '@pascal-app/core'
+import { anyExterior, isExteriorNode } from './follow-pascal-exterior'
+import { openingExterior, wallExterior } from './follow-pascal-exterior.test-fixture'
+
+// The kinds are the nodes package's (it declares `capabilities.exterior` on them); fixtures of the
+// same kind stand in for them here, and plugin-style kinds that declare the same fields are held to
+// the same rules.
+const kind = (type: string, schema: unknown, exterior?: Capabilities['exterior']) =>
+  ({
+    kind: type,
+    schemaVersion: 1,
+    schema,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: exterior === undefined ? {} : { exterior },
+    geometry: () => null,
+  }) as unknown as AnyNodeDefinition
+
+let restoreRegistry: () => void = () => {}
+beforeAll(async () => {
+  restoreRegistry = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+  await loadPlugin({
+    id: 'fixture:exterior',
+    apiVersion: 1,
+    nodes: [
+      kind('site', SiteNode, true),
+      kind('building', BuildingNode, false),
+      kind('level', LevelNode, false),
+      kind('roof', RoofNode, true),
+      kind('roof-segment', RoofSegmentNode, true),
+      kind('wall', WallNode, wallExterior),
+      kind('door', DoorNode, openingExterior),
+      kind('item', ItemNode),
+      // A plugin's own kinds: outdoors, outdoors by a field, and saying nothing.
+      kind('fixture:deck', ItemNode, true),
+      kind('fixture:cover', ItemNode, (node) => (node.name === 'seen' ? true : undefined)),
+      kind('fixture:cable', ItemNode),
+    ],
+  })
+})
+afterAll(() => restoreRegistry())
+
+function scene() {
+  const site = SiteNode.parse({ id: 'site_x' })
+  const building = BuildingNode.parse({ id: 'building_x', parentId: site.id })
+  const level = LevelNode.parse({ id: 'level_x', parentId: building.id, level: 0 })
+  const outer = WallNode.parse({
+    id: 'wall_outer',
+    parentId: level.id,
+    start: [0, 0],
+    end: [4, 0],
+    frontSide: 'interior',
+    backSide: 'exterior',
+  })
+  const inner = WallNode.parse({
+    id: 'wall_inner',
+    parentId: level.id,
+    start: [0, 2],
+    end: [4, 2],
+    frontSide: 'interior',
+    backSide: 'interior',
+  })
+  const onOuter = DoorNode.parse({ id: 'door_outer', parentId: outer.id, wallId: outer.id })
+  const onInner = DoorNode.parse({ id: 'door_inner', parentId: inner.id, wallId: inner.id })
+  const sofa = ItemNode.parse({
+    id: 'item_sofa',
+    parentId: level.id,
+    asset: {
+      id: 'sofa',
+      category: 'furniture',
+      name: 'Sofa',
+      thumbnail: '',
+      src: '/sofa.glb',
+      dimensions: [2, 1, 1],
+    },
+  })
+  const bench = ItemNode.parse({ ...sofa, id: 'item_bench', parentId: site.id })
+  const segment = RoofSegmentNode.parse({ id: 'rseg_x', parentId: 'roof_x' })
+  const roof = RoofNode.parse({ id: 'roof_x', parentId: level.id, children: [segment.id] })
+  // Only their kind, name and parent matter here.
+  const plugin = (id: string, type: string, parentId: string, name?: string) =>
+    ({ id, type, parentId, name }) as unknown as AnyNode
+  const deck = plugin('deck_x', 'fixture:deck', site.id)
+  const deckOnLevel = plugin('deck_level', 'fixture:deck', level.id)
+  const underDeck = plugin('cable_deck', 'fixture:cable', deckOnLevel.id)
+  const underRoof = plugin('cable_roof', 'fixture:cable', roof.id)
+  const cableInRoom = plugin('cable_room', 'fixture:cable', level.id)
+  const seen = plugin('cover_seen', 'fixture:cover', level.id, 'seen')
+  const unseen = plugin('cover_unseen', 'fixture:cover', level.id)
+  const coverOnSite = plugin('cover_site', 'fixture:cover', site.id)
+  return Object.fromEntries(
+    [
+      site,
+      building,
+      level,
+      outer,
+      inner,
+      onOuter,
+      onInner,
+      sofa,
+      bench,
+      roof,
+      segment,
+      deck,
+      deckOnLevel,
+      underDeck,
+      underRoof,
+      cableInRoom,
+      seen,
+      unseen,
+      coverOnSite,
+    ].map((node) => [node.id, node as AnyNode]),
+  )
+}
+
+describe('what a change is seen from', () => {
+  const nodes = scene()
+
+  test('a wall with an exterior face, and an opening in it, are seen from outside', () => {
+    expect(isExteriorNode(nodes, 'wall_outer')).toBe(true)
+    expect(isExteriorNode(nodes, 'door_outer')).toBe(true)
+  })
+
+  test('an interior wall, an opening in it and furniture are looked at through a cutaway', () => {
+    expect(isExteriorNode(nodes, 'wall_inner')).toBe(false)
+    expect(isExteriorNode(nodes, 'door_inner')).toBe(false)
+    expect(isExteriorNode(nodes, 'item_sofa')).toBe(false)
+  })
+
+  test('a roof and what stands on it, the ground, and furnishing standing in no storey are outside', () => {
+    for (const id of ['roof_x', 'rseg_x', 'deck_x', 'item_bench'])
+      expect(isExteriorNode(nodes, id)).toBe(true)
+  })
+
+  // A kind that declares what the built-ins declare is treated as the built-in is.
+  test('a plugin kind is outdoors as its definition says: always, by a field, or by what holds it', () => {
+    expect(isExteriorNode(nodes, 'deck_level')).toBe(true)
+    expect(isExteriorNode(nodes, 'cover_seen')).toBe(true)
+    expect(isExteriorNode(nodes, 'cover_unseen')).toBe(false)
+    expect(isExteriorNode(nodes, 'cable_deck')).toBe(true)
+    expect(isExteriorNode(nodes, 'cable_roof')).toBe(true)
+    expect(isExteriorNode(nodes, 'cable_room')).toBe(false)
+    expect(isExteriorNode(nodes, 'cover_site')).toBe(true)
+  })
+
+  test('a node that is not in the scene is nothing', () => {
+    expect(isExteriorNode(nodes, 'wall_gone')).toBe(false)
+  })
+
+  test('a group is outside when any of its nodes is', () => {
+    expect(anyExterior(nodes, ['item_sofa', 'door_outer'])).toBe(true)
+    expect(anyExterior(nodes, ['item_sofa', 'wall_inner'])).toBe(false)
+    expect(anyExterior(nodes, [])).toBe(false)
+  })
+})

package/src/lib/follow-pascal-exterior.ts

@@ -0,0 +1,39 @@
+import { type AnyNode, type AnyNodeId, findLevelAncestorId, nodeRegistry } from '@pascal-app/core'
+
+type Nodes = Readonly<Record<string, AnyNode>>
+
+/** What a kind says about a node (`capabilities.exterior`): outdoors, never, or nothing. */
+function declaredExterior(node: AnyNode, nodes: Nodes): boolean | undefined {
+  const exterior = nodeRegistry.get(node.type)?.capabilities?.exterior
+  return typeof exterior === 'function' ? exterior(node, nodes) : exterior
+}
+
+/**
+ * Whether a change to this node is seen from outside, as its kind declares (`capabilities.exterior`:
+ * a roof, a wall with an exterior face and an opening in it, a fence). A node whose kind says nothing
+ * is outdoors when what holds it is (a chimney's cap), or when it stands in no building's storey
+ * (outdoor furnishing, plants). A sofa, an interior wall and a finish inside are not: they are looked
+ * at through a cutaway.
+ */
+export function isExteriorNode(nodes: Nodes, id: string): boolean {
+  const node = nodes[id]
+  if (!node) return false
+  const own = declaredExterior(node, nodes)
+  if (own !== undefined) return own
+  // Standing under a node that is outdoors, up to the first one that never is (a storey).
+  for (
+    let at = node.parentId ? nodes[node.parentId] : undefined, guard = 0;
+    at && guard < 16;
+    at = at.parentId ? nodes[at.parentId] : undefined, guard += 1
+  ) {
+    const held = nodeRegistry.get(at.type)?.capabilities?.exterior
+    if (held === true) return true
+    if (held === false) break
+  }
+  return findLevelAncestorId(id as AnyNodeId, nodes as never) === null
+}
+
+/** Whether any of `ids` is a change seen from outside. */
+export function anyExterior(nodes: Nodes, ids: readonly string[]): boolean {
+  return ids.some((id) => isExteriorNode(nodes, id))
+}