@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/room-name-catalog.test.ts

@@ -8,6 +8,7 @@ import {
   roomNameSections,
   roomNameUseCount,
 } from './room-name-catalog'
+import { ROOM_NAME_MESSAGES, ROOM_NAME_SECTION_TITLES } from './room-name-messages'
 
 const square: [number, number][] = [
   [0, 0],
@@ -88,3 +89,10 @@ describe('room name catalog', () => {
     expect(ids(graph(zone('zone_room')), 'zone_room')).not.toContain('mezzanine')
   })
 })
+
+test('every catalog section and name has a translatable message', () => {
+  for (const section of [...ROOM_NAME_SECTIONS, MEZZANINE_NAME_SECTION]) {
+    expect(ROOM_NAME_SECTION_TITLES[section.id]?.message).toBe(section.title)
+    for (const name of section.names) expect(ROOM_NAME_MESSAGES[name]?.message).toBe(name)
+  }
+})

package/src/lib/room-name-catalog.ts

@@ -1,7 +1,14 @@
 import type { AnyNode } from '@pascal-app/core'
 
 /** A titled group of the room-name combobox. */
-export type RoomNameSection = { id: string; title: string; names: readonly string[] }
+export type RoomNameSection = {
+  id: string
+  title: string
+  /** Stored, matched and numbered as data: always the English catalog name. */
+  names: readonly string[]
+  /** What the combobox shows for each name, in the UI language; defaults to the name. */
+  labels?: readonly string[]
+}
 
 /** What the room reads as, which decides the section shown first. */
 export type RoomNameContext = 'room' | 'outdoor' | 'mezzanine'

package/src/lib/room-name-messages.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, type MessageDescriptor, ZoneNode } from '@pascal-app/core'
+import { roomNameOptions } from '../components/ui/panels/room-name-options'
+import { roomNameSections } from './room-name-catalog'
+import { displayRoomName, editedRoomName, localizedRoomNameSections } from './room-name-messages'
+
+const FRENCH: Record<string, string> = {
+  'editor.roomName.bedroom': 'Chambre',
+  'editor.roomName.kitchen': 'Cuisine',
+  'editor.roomName.livingRoom': 'Salon',
+  'editor.roomName.lounge': 'Salon',
+  'editor.roomName.section.sleeping': 'Nuit',
+}
+const french = { _: (d: MessageDescriptor) => FRENCH[d.id] ?? d.message ?? d.id }
+const english = { _: (d: MessageDescriptor) => d.message ?? d.id }
+
+function zone(id: string, name = '') {
+  return ZoneNode.parse({
+    id,
+    name,
+    spaceRole: 'room',
+    parentId: 'level_names',
+    polygon: [
+      [0, 0],
+      [4, 0],
+      [4, 4],
+      [0, 4],
+    ],
+    boundaryWallIds: ['wall_a'],
+  }) as AnyNode
+}
+
+describe('room-name suggestions in another UI language', () => {
+  const nodes = Object.fromEntries(
+    [zone('zone_existing', 'Bedroom'), zone('zone_new')].map((node) => [node.id, node]),
+  )
+
+  test('the rows show and match the translated labels', () => {
+    const sections = localizedRoomNameSections(roomNameSections(nodes, 'zone_new'), french)
+    const rows = roomNameOptions('chamb', sections).groups.flatMap((group) => group.options)
+    expect(rows.map((row) => [row.value, row.label])).toEqual([['Bedroom', 'Chambre']])
+    expect(sections.find((section) => section.id === 'sleeping')?.title).toBe('Nuit')
+  })
+
+  test('the typed row is offered unless the text is exactly an English name', () => {
+    const sections = localizedRoomNameSections(roomNameSections(nodes, 'zone_new'), french)
+    expect(roomNameOptions('Atelier de Marie', sections).typed?.value).toBe('Atelier de Marie')
+    expect(roomNameOptions('Chambre', sections).typed?.value).toBe('Chambre')
+    expect(roomNameOptions('Bedroom', sections).typed).toBeNull()
+  })
+
+  test('display translates catalog names and keeps their number; other names show as written', () => {
+    expect(displayRoomName('Bedroom 2', french)).toBe('Chambre 2')
+    expect(displayRoomName('Bedroom', french)).toBe('Chambre')
+    expect(displayRoomName('Bedroom 2', english)).toBe('Bedroom 2')
+    expect(displayRoomName('Bedroom of Marie', french)).toBe('Bedroom of Marie')
+    expect(displayRoomName('Atelier', french)).toBe('Atelier')
+    expect(displayRoomName('  Bedroom 2  ', french)).toBe('  Chambre 2  ')
+  })
+})
+
+describe('editing a translated name in the field', () => {
+  test("only the room's own name with a changed number stores English", () => {
+    expect(editedRoomName('Bedroom 2', 'Chambre 3', french)).toBe('Bedroom 3')
+    expect(editedRoomName('Bedroom 2', 'Chambre', french)).toBe('Bedroom')
+    expect(editedRoomName('Bedroom', 'Chambre 2', french)).toBe('Bedroom 2')
+    expect(editedRoomName('Bedroom 2', 'Bedroom 3', english)).toBe('Bedroom 3')
+  })
+
+  test('a shared translation keeps the room its own name', () => {
+    expect(editedRoomName('Lounge 2', 'Salon 3', french)).toBe('Lounge 3')
+    expect(editedRoomName('Living room 2', 'Salon 3', french)).toBe('Living room 3')
+  })
+
+  test('anything else is stored exactly as typed', () => {
+    // A different catalog name's translation, a free-text room, other text, case.
+    expect(editedRoomName('Bedroom 2', 'Cuisine', french)).toBe('Cuisine')
+    expect(editedRoomName('Atelier', 'Chambre 2', french)).toBe('Chambre 2')
+    expect(editedRoomName('Bedroom 2', 'Chambre de Marie', french)).toBe('Chambre de Marie')
+    expect(editedRoomName('Bedroom 2', 'chambre 3', french)).toBe('chambre 3')
+  })
+
+  test('surrounding spaces are kept as typed, as English keeps them', () => {
+    expect(editedRoomName('Bedroom 2', 'Chambre 3 ', french)).toBe('Bedroom 3 ')
+    expect(editedRoomName('Bedroom 2', 'Bedroom 3 ', english)).toBe('Bedroom 3 ')
+    expect(editedRoomName('  Bedroom 2  ', '  Chambre 3  ', french)).toBe('  Bedroom 3  ')
+  })
+})
+
+describe('a partly translated pack', () => {
+  // Only Bedroom is translated; Primary bedroom still shows in English.
+  const nodes = Object.fromEntries([zone('zone_new')].map((node) => [node.id, node]))
+  const sections = localizedRoomNameSections(roomNameSections(nodes, 'zone_new'), french)
+
+  test('typing the English name makes it active, with no typed row', () => {
+    const { options, typed, active } = roomNameOptions('Bedroom', sections)
+    expect(typed).toBeNull()
+    expect(options[active]).toMatchObject({
+      kind: 'suggestion',
+      value: 'Bedroom',
+      label: 'Chambre',
+    })
+    expect(options.map((row) => row.value)).toContain('Primary bedroom')
+  })
+
+  test('typing the translated name makes it active too', () => {
+    const { options, active } = roomNameOptions('chambre', sections)
+    expect(options[active]).toMatchObject({ value: 'Bedroom' })
+  })
+
+  test('without an exact name the first suggestion stays active', () => {
+    const { options, active } = roomNameOptions('prim', sections)
+    expect(options[active]).toMatchObject({ value: 'Primary bedroom' })
+  })
+
+  test('a label two names share is not an exact match', () => {
+    const { options, active } = roomNameOptions('salon', sections)
+    expect(options[active]?.kind).toBe('suggestion')
+    expect(options[active]?.value).toBe(options.find((row) => row.kind === 'suggestion')?.value)
+  })
+})
+
+describe('names that are object prototype keys', () => {
+  test.each(['constructor', 'toString', '__proto__', 'hasOwnProperty', 'valueOf 3'])(
+    '%s shows and stores as written',
+    (name) => {
+      expect(displayRoomName(name, french)).toBe(name)
+      expect(displayRoomName(name, english)).toBe(name)
+      expect(editedRoomName(name, `${name} 2`, french)).toBe(`${name} 2`)
+    },
+  )
+})

package/src/lib/room-name-messages.ts

@@ -0,0 +1,147 @@
+import type { MessageDescriptor } from '@pascal-app/core'
+import type { RoomNameSection } from './room-name-catalog'
+
+/**
+ * The room-name catalog in the UI language. The catalog stays English (it is
+ * matched, numbered and stored as data); the combobox and room labels show these.
+ * `room-name-catalog.test.ts` fails when a catalog name has no entry here.
+ */
+/** Anything that translates a descriptor: a `PascalI18n`, or a stand-in in tests. */
+export type DescriptorTranslator = { _(descriptor: MessageDescriptor): string }
+
+export const ROOM_NAME_SECTION_TITLES: Record<string, MessageDescriptor> = {
+  living: /* i18n */ { id: 'editor.roomName.section.living', message: 'Living' },
+  sleeping: /* i18n */ { id: 'editor.roomName.section.sleeping', message: 'Sleeping' },
+  bathrooms: /* i18n */ { id: 'editor.roomName.section.bathrooms', message: 'Bathrooms' },
+  work: /* i18n */ { id: 'editor.roomName.section.work', message: 'Work & hobbies' },
+  circulation: /* i18n */ { id: 'editor.roomName.section.circulation', message: 'Circulation' },
+  utility: /* i18n */ { id: 'editor.roomName.section.utility', message: 'Utility & storage' },
+  outdoor: /* i18n */ { id: 'editor.roomName.section.outdoor', message: 'Outdoor' },
+  mezzanine: /* i18n */ { id: 'editor.roomName.section.mezzanine', message: 'Mezzanine' },
+}
+
+export const ROOM_NAME_MESSAGES: Record<string, MessageDescriptor> = {
+  'Living room': /* i18n */ { id: 'editor.roomName.livingRoom', message: 'Living room' },
+  'Family room': /* i18n */ { id: 'editor.roomName.familyRoom', message: 'Family room' },
+  'Dining room': /* i18n */ { id: 'editor.roomName.diningRoom', message: 'Dining room' },
+  Kitchen: /* i18n */ { id: 'editor.roomName.kitchen', message: 'Kitchen' },
+  Kitchenette: /* i18n */ { id: 'editor.roomName.kitchenette', message: 'Kitchenette' },
+  Pantry: /* i18n */ { id: 'editor.roomName.pantry', message: 'Pantry' },
+  Lounge: /* i18n */ { id: 'editor.roomName.lounge', message: 'Lounge' },
+  Den: /* i18n */ { id: 'editor.roomName.den', message: 'Den' },
+  Library: /* i18n */ { id: 'editor.roomName.library', message: 'Library' },
+  Playroom: /* i18n */ { id: 'editor.roomName.playroom', message: 'Playroom' },
+  'Home cinema': /* i18n */ { id: 'editor.roomName.homeCinema', message: 'Home cinema' },
+  'Games room': /* i18n */ { id: 'editor.roomName.gamesRoom', message: 'Games room' },
+  Sunroom: /* i18n */ { id: 'editor.roomName.sunroom', message: 'Sunroom' },
+  Bedroom: /* i18n */ { id: 'editor.roomName.bedroom', message: 'Bedroom' },
+  'Primary bedroom': /* i18n */ {
+    id: 'editor.roomName.primaryBedroom',
+    message: 'Primary bedroom',
+  },
+  'Guest room': /* i18n */ { id: 'editor.roomName.guestRoom', message: 'Guest room' },
+  "Kids' room": /* i18n */ { id: 'editor.roomName.kidsRoom', message: "Kids' room" },
+  Nursery: /* i18n */ { id: 'editor.roomName.nursery', message: 'Nursery' },
+  'Dressing room': /* i18n */ { id: 'editor.roomName.dressingRoom', message: 'Dressing room' },
+  'Walk-in closet': /* i18n */ { id: 'editor.roomName.walkInCloset', message: 'Walk-in closet' },
+  Bathroom: /* i18n */ { id: 'editor.roomName.bathroom', message: 'Bathroom' },
+  'En-suite': /* i18n */ { id: 'editor.roomName.enSuite', message: 'En-suite' },
+  'Shower room': /* i18n */ { id: 'editor.roomName.showerRoom', message: 'Shower room' },
+  Toilet: /* i18n */ { id: 'editor.roomName.toilet', message: 'Toilet' },
+  'Powder room': /* i18n */ { id: 'editor.roomName.powderRoom', message: 'Powder room' },
+  Office: /* i18n */ { id: 'editor.roomName.office', message: 'Office' },
+  Study: /* i18n */ { id: 'editor.roomName.study', message: 'Study' },
+  Studio: /* i18n */ { id: 'editor.roomName.studio', message: 'Studio' },
+  Workshop: /* i18n */ { id: 'editor.roomName.workshop', message: 'Workshop' },
+  Gym: /* i18n */ { id: 'editor.roomName.gym', message: 'Gym' },
+  Entrance: /* i18n */ { id: 'editor.roomName.entrance', message: 'Entrance' },
+  Hallway: /* i18n */ { id: 'editor.roomName.hallway', message: 'Hallway' },
+  Corridor: /* i18n */ { id: 'editor.roomName.corridor', message: 'Corridor' },
+  Landing: /* i18n */ { id: 'editor.roomName.landing', message: 'Landing' },
+  Stairwell: /* i18n */ { id: 'editor.roomName.stairwell', message: 'Stairwell' },
+  Mudroom: /* i18n */ { id: 'editor.roomName.mudroom', message: 'Mudroom' },
+  Laundry: /* i18n */ { id: 'editor.roomName.laundry', message: 'Laundry' },
+  'Utility room': /* i18n */ { id: 'editor.roomName.utilityRoom', message: 'Utility room' },
+  Storage: /* i18n */ { id: 'editor.roomName.storage', message: 'Storage' },
+  Closet: /* i18n */ { id: 'editor.roomName.closet', message: 'Closet' },
+  'Boiler room': /* i18n */ { id: 'editor.roomName.boilerRoom', message: 'Boiler room' },
+  Cellar: /* i18n */ { id: 'editor.roomName.cellar', message: 'Cellar' },
+  Basement: /* i18n */ { id: 'editor.roomName.basement', message: 'Basement' },
+  Attic: /* i18n */ { id: 'editor.roomName.attic', message: 'Attic' },
+  Garage: /* i18n */ { id: 'editor.roomName.garage', message: 'Garage' },
+  Garden: /* i18n */ { id: 'editor.roomName.garden', message: 'Garden' },
+  Patio: /* i18n */ { id: 'editor.roomName.patio', message: 'Patio' },
+  Terrace: /* i18n */ { id: 'editor.roomName.terrace', message: 'Terrace' },
+  Balcony: /* i18n */ { id: 'editor.roomName.balcony', message: 'Balcony' },
+  Porch: /* i18n */ { id: 'editor.roomName.porch', message: 'Porch' },
+  Veranda: /* i18n */ { id: 'editor.roomName.veranda', message: 'Veranda' },
+  Deck: /* i18n */ { id: 'editor.roomName.deck', message: 'Deck' },
+  Courtyard: /* i18n */ { id: 'editor.roomName.courtyard', message: 'Courtyard' },
+  'Pool area': /* i18n */ { id: 'editor.roomName.poolArea', message: 'Pool area' },
+  Carport: /* i18n */ { id: 'editor.roomName.carport', message: 'Carport' },
+  'Garden shed': /* i18n */ { id: 'editor.roomName.gardenShed', message: 'Garden shed' },
+  Mezzanine: /* i18n */ { id: 'editor.roomName.mezzanine', message: 'Mezzanine' },
+  Loft: /* i18n */ { id: 'editor.roomName.loft', message: 'Loft' },
+  'Reading nook': /* i18n */ { id: 'editor.roomName.readingNook', message: 'Reading nook' },
+  Gallery: /* i18n */ { id: 'editor.roomName.gallery', message: 'Gallery' },
+}
+
+export function localizedRoomNameSections(
+  sections: readonly RoomNameSection[],
+  i18n: DescriptorTranslator,
+): RoomNameSection[] {
+  return sections.map((section) => {
+    const title = Object.hasOwn(ROOM_NAME_SECTION_TITLES, section.id)
+      ? ROOM_NAME_SECTION_TITLES[section.id]
+      : undefined
+    return {
+      ...section,
+      title: title ? i18n._(title) : section.title,
+      labels: section.names.map((name) => displayRoomName(name, i18n)),
+    }
+  })
+}
+
+/**
+ * A room name in the UI language. Catalog names stay English in the scene
+ * (numbering, MCP and exports read them); a catalog name with the number the
+ * picker adds shows translated with that number ("Bedroom 2" → "Chambre 2").
+ * Anything else the user typed shows as written.
+ */
+export function displayRoomName(name: string, i18n: DescriptorTranslator): string {
+  const { lead, base, number, trail } = roomNameParts(name)
+  const label = catalogLabel(base, i18n)
+  return label === undefined ? name : `${lead}${label}${number}${trail}`
+}
+
+/**
+ * What an edit of a room's name field stores. The field shows the room's own
+ * catalog name translated ("Lounge 2" as "Salon 2"); when the edit only
+ * changes, adds or removes that name's number ("Salon 3"), it stores the
+ * English name with the new number ("Lounge 3"), as editing it in English
+ * would. Any other text, an exact translation of a different name included, is
+ * stored exactly as typed.
+ */
+export function editedRoomName(stored: string, text: string, i18n: DescriptorTranslator): string {
+  const own = roomNameParts(stored).base
+  const label = catalogLabel(own, i18n)
+  const edited = roomNameParts(text)
+  if (label === undefined || edited.base !== label) return text
+  return `${edited.lead}${own}${edited.number}${edited.trail}`
+}
+
+function roomNameParts(name: string) {
+  const match = /^(\s*)(.*?)(\s+\d+)?(\s*)$/.exec(name)
+  return {
+    lead: match?.[1] ?? '',
+    base: match?.[2] ?? '',
+    number: match?.[3] ?? '',
+    trail: match?.[4] ?? '',
+  }
+}
+
+function catalogLabel(english: string, i18n: DescriptorTranslator): string | undefined {
+  // Own keys only: a room named "constructor" or "__proto__" is free text.
+  if (!(english && Object.hasOwn(ROOM_NAME_MESSAGES, english))) return undefined
+  return i18n._(ROOM_NAME_MESSAGES[english]!)
+}

package/src/lib/room-name-storage.test.ts

@@ -0,0 +1,334 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  applyZoneTransformPlan,
+  createI18n,
+  createZone,
+  duplicateZone,
+  LevelNode,
+  type PascalI18n,
+  registerMessages,
+  setLocale,
+  useScene,
+  ZoneNode,
+} from '@pascal-app/core'
+import { AGENT_OPERATIONS, applyAgentOutcome } from '@pascal-app/core/agent-operations'
+import { createAgentHost, liveSceneRuntime } from '@pascal-app/core/runtime'
+import {
+  commitRoomNameEdit,
+  commitRoomNamePick,
+  commitTreeRoomRename,
+  roomNameOptions,
+} from '../components/ui/panels/room-name-options'
+import { roomNameSections } from './room-name-catalog'
+import { displayRoomName, localizedRoomNameSections } from './room-name-messages'
+import { applyRoomPlan, renameRoom } from './room-structure-commands'
+import { copySelectedNodesToEditorClipboard, pasteEditorClipboardToLevel } from './scene-clipboard'
+
+/**
+ * Every path that writes a room name stores in a French UI what the same edit
+ * stores in English (what main stores): the UI only displays catalog names
+ * translated. The room panel is driven through the commit and pick functions
+ * its name field calls.
+ */
+
+const levelId = 'level_names' as LevelNode['id']
+const otherLevelId = 'level_names-paste' as LevelNode['id']
+const square = (x: number): [number, number][] => [
+  [x, 0],
+  [x + 4, 0],
+  [x + 4, 4],
+  [x, 4],
+]
+
+const seeded = new Set(['zone_existing', 'zone_new'])
+let english: PascalI18n
+let french: PascalI18n
+
+beforeAll(async () => {
+  // A reviewed French pack for the names these paths touch.
+  await registerMessages('fr', '', {
+    'editor.roomName.bedroom': 'Chambre',
+    'editor.roomName.kitchen': 'Cuisine',
+    // Shared labels, as in the French drafts.
+    'editor.roomName.livingRoom': 'Salon',
+    'editor.roomName.lounge': 'Salon',
+    'editor.roomName.office': 'Bureau',
+    'editor.roomName.study': 'Bureau',
+    'editor.roomName.section.sleeping': 'Nuit',
+  })
+  english = createI18n({ locale: 'en' })
+  french = createI18n({ locale: 'fr' })
+})
+afterAll(() => {
+  setLocale('en')
+  english.destroy()
+  french.destroy()
+})
+
+function seed() {
+  const level = LevelNode.parse({ id: levelId, children: ['zone_existing', 'zone_new'] })
+  const other = LevelNode.parse({ id: otherLevelId, level: 1 })
+  const zone = (id: string, name: string, x: number) =>
+    ZoneNode.parse({ id, name, spaceRole: 'room', parentId: levelId, polygon: square(x) })
+  const nodes = {
+    [level.id]: level,
+    [other.id]: other,
+    zone_existing: zone('zone_existing', 'Bedroom', 0),
+    zone_new: zone('zone_new', '', 10),
+  } as unknown as Record<string, AnyNode>
+  useScene.setState({ nodes, rootNodeIds: [level.id, other.id], materials: {} } as never)
+  useScene.temporal.getState().clear()
+}
+
+const nameOf = (id: string) => useScene.getState().nodes[id as AnyNodeId]?.name
+const zonesOn = (level: string) =>
+  Object.values(useScene.getState().nodes).filter(
+    (node) => node.type === 'zone' && node.parentId === level,
+  )
+
+/** Runs `write` with the UI in `locale` and returns the names it stored. */
+function storedBy(locale: 'en' | 'fr', write: (i18n: PascalI18n) => void) {
+  seed()
+  setLocale(locale)
+  write(locale === 'en' ? english : french)
+  setLocale('en')
+  // Seeded rooms by id; rooms a path creates get fresh ids, so they are listed by name.
+  const zones = Object.values(useScene.getState().nodes).filter((node) => node.type === 'zone')
+  return {
+    ...Object.fromEntries(
+      zones.filter((zone) => seeded.has(zone.id)).map((zone) => [zone.id, zone.name]),
+    ),
+    created: zones
+      .filter((zone) => !seeded.has(zone.id))
+      .map((zone) => zone.name ?? '')
+      .sort(),
+  } as Record<string, string | undefined> & { created: string[] }
+}
+
+function expectSameEnglish(write: (i18n: PascalI18n) => void) {
+  const inEnglish = storedBy('en', write)
+  const inFrench = storedBy('fr', write)
+  expect(inFrench).toEqual(inEnglish)
+  return inEnglish
+}
+
+const sectionsFor = (i18n: PascalI18n, zoneId: string) =>
+  localizedRoomNameSections(roomNameSections(useScene.getState().nodes, zoneId), i18n)
+
+/** Types `text` in the panel field and picks the suggestion shown as `label`. */
+const pick = (i18n: PascalI18n, zoneId: string, text: string, label = text) => {
+  const option = roomNameOptions(text, sectionsFor(i18n, zoneId)).options.find(
+    (row) => row.kind === 'suggestion' && row.label === label,
+  )
+  if (!option) throw new Error(`no suggestion shown as ${label}`)
+  commitRoomNamePick(zoneId, nameOf(zoneId) ?? '', option, i18n)
+}
+/** Types `text` in the panel field and clicks its 'Use "…"' row. */
+const useTyped = (i18n: PascalI18n, zoneId: string, text: string) => {
+  const typed = roomNameOptions(text, sectionsFor(i18n, zoneId)).typed
+  if (!typed) throw new Error(`no typed row for ${text}`)
+  commitRoomNamePick(zoneId, nameOf(zoneId) ?? '', typed, i18n)
+}
+/** Edits the field from what it shows, then blurs it or presses Enter on the typed row. */
+const edit = (i18n: PascalI18n, zoneId: string, draft: (shown: string) => string) => {
+  const stored = nameOf(zoneId) ?? ''
+  const shown = displayRoomName(stored, i18n)
+  commitRoomNameEdit(zoneId, stored, shown, draft(shown), i18n)
+}
+/** Types `text` in the panel field and presses Enter: the active row, as the field does. */
+const enter = (i18n: PascalI18n, zoneId: string, text: string) => {
+  const stored = nameOf(zoneId) ?? ''
+  const { options, active } = roomNameOptions(text, sectionsFor(i18n, zoneId), true, stored)
+  const chosen = options[active]
+  if (chosen?.kind === 'suggestion') commitRoomNamePick(zoneId, stored, chosen, i18n)
+  else commitRoomNameEdit(zoneId, stored, displayRoomName(stored, i18n), text, i18n)
+}
+const named = (zoneId: string, name: string) => renameRoom(zoneId, name)
+
+describe('room names are stored in English whatever the UI language', () => {
+  test('a suggestion pick', () => {
+    const names = expectSameEnglish((i18n) =>
+      pick(i18n, 'zone_new', i18n === french ? 'Chambre' : 'Bedroom'),
+    )
+    expect(names.zone_new).toBe('Bedroom 2')
+  })
+
+  test('editing the field: renumbering, removing or adding the number', () => {
+    const renumber = (i18n: PascalI18n) => {
+      named('zone_new', 'Bedroom 2')
+      edit(i18n, 'zone_new', (shown) => shown.replace(/2$/, '3'))
+    }
+    expect(expectSameEnglish(renumber).zone_new).toBe('Bedroom 3')
+    const unnumber = (i18n: PascalI18n) => {
+      named('zone_new', 'Bedroom 2')
+      edit(i18n, 'zone_new', (shown) => shown.replace(/ 2$/, ''))
+    }
+    expect(expectSameEnglish(unnumber).zone_new).toBe('Bedroom')
+    const number = (i18n: PascalI18n) => edit(i18n, 'zone_existing', (shown) => `${shown} 2`)
+    expect(expectSameEnglish(number).zone_existing).toBe('Bedroom 2')
+  })
+
+  test('a shared translation keeps the room its own name', () => {
+    // "Salon" is both Living room and Lounge; "Bureau" both Office and Study.
+    const lounge = (i18n: PascalI18n) => {
+      named('zone_new', 'Lounge 2')
+      edit(i18n, 'zone_new', (shown) => shown.replace(/2$/, '3'))
+    }
+    expect(expectSameEnglish(lounge).zone_new).toBe('Lounge 3')
+    const study = (i18n: PascalI18n) => {
+      named('zone_new', 'Study')
+      edit(i18n, 'zone_new', (shown) => `${shown} 2`)
+    }
+    expect(expectSameEnglish(study).zone_new).toBe('Study 2')
+  })
+
+  test('Enter on a shared label keeps the room its own entry', () => {
+    // "Salon" is shown for both Living room and Lounge; Enter on a Lounge keeps Lounge.
+    const lounge = (i18n: PascalI18n) => {
+      named('zone_new', 'Lounge')
+      enter(i18n, 'zone_new', displayRoomName('Lounge', i18n))
+    }
+    expect(expectSameEnglish(lounge).zone_new).toBe('Lounge')
+    const living = (i18n: PascalI18n) => {
+      named('zone_new', 'Living room')
+      enter(i18n, 'zone_new', displayRoomName('Living room', i18n))
+    }
+    expect(expectSameEnglish(living).zone_new).toBe('Living room')
+  })
+
+  test('free text, including an exact translation, is stored as typed', () => {
+    const atelier = (i18n: PascalI18n) => edit(i18n, 'zone_new', () => 'Atelier de Marie')
+    expect(expectSameEnglish(atelier).zone_new).toBe('Atelier de Marie')
+    const cuisine = (i18n: PascalI18n) => edit(i18n, 'zone_existing', () => 'Cuisine')
+    expect(expectSameEnglish(cuisine).zone_existing).toBe('Cuisine')
+    // Another room's translation with a number is not this room's name.
+    const salon = (i18n: PascalI18n) => edit(i18n, 'zone_existing', () => 'Salon 2')
+    expect(expectSameEnglish(salon).zone_existing).toBe('Salon 2')
+  })
+
+  test("clicking 'Use' stores the text as typed; an English name has no 'Use' row", () => {
+    expect(storedBy('fr', (i18n) => useTyped(i18n, 'zone_new', 'Chambre')).zone_new).toBe('Chambre')
+    expect(storedBy('en', (i18n) => useTyped(i18n, 'zone_new', 'Chambre')).zone_new).toBe('Chambre')
+    expect(storedBy('fr', (i18n) => useTyped(i18n, 'zone_new', 'Cuisine')).zone_new).toBe('Cuisine')
+    for (const i18n of [english, french]) {
+      expect(roomNameOptions('Bedroom', sectionsFor(i18n, 'zone_new')).typed).toBeNull()
+    }
+  })
+
+  test('surrounding spaces are stored as typed', () => {
+    const trailing = (i18n: PascalI18n) => {
+      named('zone_new', 'Bedroom 2')
+      edit(i18n, 'zone_new', (shown) => shown.replace(/2$/, '3 '))
+    }
+    expect(expectSameEnglish(trailing).zone_new).toBe('Bedroom 3 ')
+    const padded = (i18n: PascalI18n) => {
+      named('zone_new', '  Bedroom 2  ')
+      edit(i18n, 'zone_new', (shown) => shown.replace('2', '3'))
+    }
+    expect(expectSameEnglish(padded).zone_new).toBe('  Bedroom 3  ')
+  })
+
+  test('the layer tree rename edits the shown name and stores the English', () => {
+    /** The tree field shows `displayRoomName`, and passes the trimmed text or undefined. */
+    const treeEdit = (i18n: PascalI18n, zoneId: string, draft: (shown: string) => string) => {
+      const shown = displayRoomName(nameOf(zoneId) ?? '', i18n)
+      const text = draft(shown).trim()
+      if (text !== shown) commitTreeRoomRename(zoneId, text || undefined, i18n)
+    }
+    const renumber = (i18n: PascalI18n) => {
+      named('zone_new', 'Lounge 2')
+      treeEdit(i18n, 'zone_new', (shown) => shown.replace(/2$/, '3'))
+    }
+    expect(expectSameEnglish(renumber).zone_new).toBe('Lounge 3')
+    const padded = (i18n: PascalI18n) => {
+      named('zone_new', '  Kitchen ')
+      treeEdit(i18n, 'zone_new', (shown) => shown)
+    }
+    expect(expectSameEnglish(padded).zone_new).toBe('Kitchen')
+    const free = (i18n: PascalI18n) => treeEdit(i18n, 'zone_existing', () => ' Atelier ')
+    expect(expectSameEnglish(free).zone_existing).toBe('Atelier')
+    const cleared = (i18n: PascalI18n) => treeEdit(i18n, 'zone_existing', () => '')
+    expect(expectSameEnglish(cleared).zone_existing).toBeUndefined()
+  })
+
+  test('an unchanged field writes nothing', () => {
+    for (const name of ['Bedroom', '  Bedroom 2  ', 'Lounge 2', 'Atelier']) {
+      seed()
+      named('zone_existing', name)
+      const before = useScene.getState().nodes
+      edit(french, 'zone_existing', (shown) => shown)
+      expect(useScene.getState().nodes).toBe(before)
+    }
+  })
+
+  test('creating a room', () => {
+    const names = expectSameEnglish(() => {
+      let i = 0
+      const plan = createZone(useScene.getState().nodes, {
+        levelId,
+        polygon: square(20),
+        mintId: (kind: string) => `${kind}_created${++i}` as never,
+      })
+      expect(applyRoomPlan(plan)).toBe(true)
+    })
+    expect(names.created).toEqual(['Room'])
+  })
+
+  test('duplicating a room', () => {
+    const names = expectSameEnglish(() => {
+      let i = 0
+      const mintId = ((kind: string) => `${kind}_copy${++i}`) as never
+      // Duplicating needs an enclosed room: build one named as the panel stores it.
+      const created = createZone(useScene.getState().nodes, {
+        levelId,
+        polygon: square(30),
+        enclose: true,
+        name: 'Bedroom',
+        mintId,
+      })
+      expect(applyRoomPlan(created)).toBe(true)
+      const plan = duplicateZone(useScene.getState().nodes, {
+        zoneId: created.zoneId,
+        translate: [0, 10],
+        mintId,
+      })
+      expect(plan.conflicts).toBeUndefined()
+      applyZoneTransformPlan(plan)
+    })
+    expect(names.created.filter((name) => name.startsWith('Bedroom'))).toHaveLength(2)
+  })
+
+  test('copy and paste to another level', () => {
+    const names = expectSameEnglish(() => {
+      expect(copySelectedNodesToEditorClipboard(['zone_existing' as AnyNodeId])).toBe(true)
+      expect(pasteEditorClipboardToLevel(otherLevelId)?.pastedIds.length).toBeGreaterThan(0)
+      expect(zonesOn(otherLevelId).map((zone) => zone.name)).toEqual(['Bedroom'])
+    })
+    expect(names.created).toEqual(['Bedroom'])
+  })
+
+  test('MCP and agents: set_zone_intent stores the name as given', () => {
+    const names = expectSameEnglish(() => {
+      const host = createAgentHost(liveSceneRuntime)
+      const outcome = AGENT_OPERATIONS.set_zone_intent(
+        host.getNodes(),
+        { zoneId: 'zone_new', patch: { name: 'Kitchen' } },
+        {} as never,
+      )
+      applyAgentOutcome(outcome, host)
+    })
+    expect(names.zone_new).toBe('Kitchen')
+  })
+
+  test('undo restores the stored English', () => {
+    const names = expectSameEnglish((i18n) => {
+      renameRoom('zone_existing', 'Bedroom 4')
+      edit(i18n, 'zone_existing', (shown) => shown.replace(/4$/, '5'))
+      expect(nameOf('zone_existing')).toBe('Bedroom 5')
+      useScene.temporal.getState().undo()
+    })
+    expect(names.zone_existing).toBe('Bedroom 4')
+  })
+})