@operato/layout 10.29.46 → 10.29.49

package/test/entity360-companion.test.ts

@@ -0,0 +1,110 @@
+import { expect, fixture, elementUpdated } from '@open-wc/testing'
+import { css, html, LitElement } from 'lit'
+import { setViewport } from '@web/test-runner-commands'
+import '../src/index.js'
+import { appendViewpart, removeViewpart, showEntity360, hideEntity360, VIEWPART_POSITION, VIEWPART_LEVEL, type OxEntity360Dock } from '../src/index.js'
+
+class CompanionProbe extends LitElement {
+  static styles = css`:host { display: flex; flex-direction: column; width: 420px; height: 100%; }`
+  connections = 0
+  connectedCallback() { super.connectedCallback(); this.connections++ }
+  render() { return html`<textarea aria-label="Conversation"></textarea><button>Send</button>` }
+}
+customElements.define('test-companion-probe', CompanionProbe)
+const owner = {}
+const labels = { close:'Close', expand:'Expand', collapse:'Collapse', resize:'Resize', back:'Back' }
+const settle = () => new Promise(resolve => setTimeout(resolve, 60))
+let bar: HTMLElement, companion: CompanionProbe, dock: OxEntity360Dock
+const input = () => dock.shadowRoot!.querySelector('ox-entity360-content')!.shadowRoot!.querySelector('input')!
+const textarea = () => companion.shadowRoot!.querySelector('textarea')!
+const openCompanion = () => appendViewpart({ name:'test-companion', position:VIEWPART_POSITION.ASIDEBAR, viewpart:{ show:true, persistent:true, level:VIEWPART_LEVEL.TOPMOST, expansionCompanion:{labelKey:'test.conversation',defaultLabel:'Conversation'}, template:html`${companion}` } })
+
+describe('expanded entity workspace with a supporting dock', () => {
+  beforeEach(async () => {
+    await setViewport({ width:1440,height:900 })
+    bar = await fixture(html`<ox-aside-bar></ox-aside-bar>`)
+    companion = document.createElement('test-companion-probe') as CompanionProbe
+    openCompanion()
+    showEntity360(owner, { key:'one', title:'Contract', context:'same subject', labels, content:html`<input value="initial">`, onClose:()=>hideEntity360(owner) })
+    await settle()
+    dock = bar.shadowRoot!.querySelector('ox-entity360-dock') as OxEntity360Dock
+  })
+  afterEach(async () => { hideEntity360(owner); removeViewpart('test-companion'); await setViewport({width:800,height:600}) })
+
+  it('shares the expanded width without recreating either editor or changing its values', async () => {
+    const originalInput = input(), originalChat = textarea(), connections = companion.connections
+    originalInput.value='allocation draft'; originalChat.value='question draft'
+    dock.expanded=true; await settle()
+    expect(bar.hasAttribute('shared-fullscreen')).to.equal(true)
+    expect(bar.getAttribute('aria-modal')).to.equal('true')
+    expect(dock.shadowRoot!.querySelector('[aria-modal]')).to.equal(null)
+    const main = dock.getBoundingClientRect(), chat = companion.getBoundingClientRect()
+    expect(main.width).to.equal(1020); expect(chat.width).to.equal(420)
+    expect(main.right).to.equal(chat.left)
+    dock.expanded=false; await settle()
+    expect(input()).to.equal(originalInput); expect(textarea()).to.equal(originalChat)
+    expect(originalInput.value).to.equal('allocation draft'); expect(originalChat.value).to.equal('question draft')
+    expect(companion.connections).to.equal(connections)
+    expect(bar.hasAttribute('shared-fullscreen')).to.equal(false)
+  })
+
+  it('Tab crosses from the last main control into the conversation and returns with Shift+Tab', async () => {
+    dock.expanded=true; await settle()
+    input().focus()
+    input().dispatchEvent(new KeyboardEvent('keydown',{key:'Tab',bubbles:true,composed:true,cancelable:true}))
+    expect(companion.shadowRoot!.activeElement).to.equal(textarea())
+    textarea().dispatchEvent(new KeyboardEvent('keydown',{key:'Tab',shiftKey:true,bubbles:true,composed:true,cancelable:true}))
+    expect(input().getRootNode() instanceof ShadowRoot && (input().getRootNode() as ShadowRoot).activeElement).to.equal(input())
+  })
+
+  it('narrowing keeps the focused conversation visible, then switches panes without disconnecting it', async () => {
+    dock.expanded=true; await settle()
+    textarea().value='still writing'; textarea().focus()
+    expect((bar as any).pane).to.equal('companion', 'focused pane remembered')
+    const connections=companion.connections
+    await setViewport({width:390,height:844}); await settle()
+    expect(companion.getBoundingClientRect().width).to.equal(390)
+    expect(dock.getBoundingClientRect().width).to.equal(0)
+    const switches=bar.shadowRoot!.querySelectorAll<HTMLButtonElement>('.workspace-switch button')
+    switches[0].click(); await settle()
+    expect(dock.getBoundingClientRect().width).to.equal(390)
+    expect(companion.getBoundingClientRect().width).to.equal(0)
+    switches[1].click(); await settle()
+    expect(textarea().value).to.equal('still writing')
+    expect(companion.connections).to.equal(connections)
+    await setViewport({width:1440,height:900}); await settle()
+    expect(dock.getBoundingClientRect().width).to.equal(1020)
+  })
+
+  it('closing the companion gives the full width back; expansion does not open it again', async () => {
+    dock.expanded=true; await settle()
+    removeViewpart('test-companion'); await settle()
+    expect(dock.contained).to.equal(false)
+    expect(dock.getBoundingClientRect().width).to.equal(1440)
+    dock.expanded=false; await elementUpdated(dock)
+    dock.expanded=true; await settle()
+    expect(bar.shadowRoot!.querySelector('test-companion-probe')).to.equal(null)
+  })
+
+  it('explicitly opening a companion in a narrow expanded workspace reveals it', async () => {
+    removeViewpart('test-companion'); await settle()
+    dock.expanded=true
+    await setViewport({width:390,height:844}); await settle()
+    openCompanion(); await settle()
+    expect(companion.getBoundingClientRect().width).to.equal(390)
+    expect(dock.getBoundingClientRect().width).to.equal(0)
+    expect(bar.shadowRoot!.activeElement).to.equal(bar.shadowRoot!.querySelectorAll('.workspace-switch button')[1])
+  })
+
+  it('a modal above the shared workspace keeps ownership of Tab and Escape', async () => {
+    dock.expanded=true; await settle()
+    const state=history.state
+    history.replaceState({...state,overlay:{name:'confirmation'}},'')
+    const tab=new KeyboardEvent('keydown',{key:'Tab',bubbles:true,composed:true,cancelable:true})
+    input().dispatchEvent(tab)
+    expect(tab.defaultPrevented).to.equal(false)
+    input().dispatchEvent(new KeyboardEvent('keydown',{key:'Escape',bubbles:true,composed:true,cancelable:true}))
+    expect(dock.isConnected).to.equal(true)
+    history.replaceState(state,'')
+  })
+})

package/test/entity360-kind.test.ts

@@ -1,5 +1,6 @@
 import { expect, fixture } from '@open-wc/testing'
-import { html, render } from 'lit'
+import { html, render, LitElement } from 'lit'
+import { OxPrompt } from '@operato/popup/ox-prompt.js'
 import { store, UPDATE_CONTEXT } from '@operato/shell'
 import '../src/index.js'
 import {
@@ -7,8 +8,10 @@ import {
   entity360Link,
   onEntity360Change,
   openEntity360Kind,
-  redrawEntity360,
   registerEntity360Kind,
+  registerEntity360Section,
+  setEntity360Value,
+  ENTITY360_UNKEPT,
   type Entity360Subject,
   type OxEntity360Dock
 } from '../src/index.js'
@@ -29,6 +32,15 @@ const back = (go: () => void = () => history.back()) =>
     go()
   })
 let bar: HTMLElement
+/**
+ * Links drawn straight into the page. `fixture` waits for an animation frame, and a page the runner keeps in the
+ * background (files run side by side) may not get one before the test times out.
+ */
+const drawn = (template: unknown) => {
+  const host = document.body.appendChild(document.createElement('div'))
+  render(template, host)
+  return host
+}
 const dock = () => bar.shadowRoot!.querySelector('ox-entity360-dock') as OxEntity360Dock
 const subject = () => (store.getState() as any).route?.context?.subject
 const address = () => new URLSearchParams(location.search).get('f')
@@ -36,8 +48,29 @@ const address = () => new URLSearchParams(location.search).get('f')
 registerEntity360Kind({ kind: 'kx-order', typenames: [], title: s => `order ${s.id}`, assistantSubject: true })
 registerEntity360Kind({ kind: 'kx-place', typenames: [], title: s => `place ${s.id}`, assistantSubject: true })
 registerEntity360Kind({ kind: 'kx-quiet', typenames: [], title: s => `quiet ${s.id}` })
-let late = ''
-registerEntity360Kind({ kind: 'kx-late', typenames: [], title: s => late || s.id })
+registerEntity360Kind({ kind: 'kx-late', typenames: [], title: s => s.value.name || s.id })
+
+/* A kind whose one identifier is its name, the way a lot is (ADR-0067 decision 6). */
+registerEntity360Kind({ kind: 'kx-lot', typenames: ['KxLot'], id: value => value.name, title: s => s.value.name || s.id })
+
+/** A section the way modules write one: it takes the subject and reads whenever the subject changes. */
+const reads: { section: Element; subject: Entity360Subject }[] = []
+class KxSection extends LitElement {
+  static properties = { subject: { attribute: false } }
+  subject?: Entity360Subject
+  createRenderRoot() {
+    return this
+  }
+  updated(changed: Map<string, unknown>) {
+    if (changed.has('subject') && this.subject) reads.push({ section: this, subject: this.subject })
+  }
+  render() {
+    return html`<input />`
+  }
+}
+customElements.define('kx-section', KxSection)
+registerEntity360Section('kx-lot', { name: 'facts', render: subject => html`<kx-section .subject=${subject}></kx-section>` })
+const section = () => dock().shadowRoot!.querySelector('ox-entity360-content')!.shadowRoot!.querySelector('kx-section') as KxSection
 
 describe('entity 360 by kind', () => {
   beforeEach(async () => {
@@ -58,7 +91,7 @@ describe('entity 360 by kind', () => {
   })
 
   it('★ a click on the link opens that kind with that id', async () => {
-    const host = await fixture(html`<div>${entity360Link('kx-order', 'SO-2')}</div>`)
+    const host = drawn(html`${entity360Link('kx-order', 'SO-2')}`)
     ;(host.querySelector('a') as HTMLElement).click()
     await settle()
 
@@ -151,22 +184,123 @@ describe('entity 360 by kind', () => {
     expect(address()).to.equal(null)
   })
 
-  it('redraw reads the title again - for a title its section learns later', async () => {
-    late = ''
+  it('★ what a section reads names the subject: the heading is drawn from it, the sections stay', async () => {
+    openEntity360Kind('kx-lot', { id: 'L-9', name: 'L-9' })
+    await settle()
+    expect(dock().view!.title).to.equal('L-9')
+    const first = section()
+
+    setEntity360Value({ kind: 'kx-lot', id: 'L-9' }, { name: 'L-9', definitionId: 'M-1' })
     openEntity360Kind('kx-late', { id: 'X-9' })
     await settle()
     expect(dock().view!.title).to.equal('X-9')
-
-    late = 'named later'
-    redrawEntity360()
+    setEntity360Value({ kind: 'kx-late', id: 'X-9' }, { name: 'named later' })
     await settle()
     expect(dock().view!.title).to.equal('named later')
+    expect(first.isConnected).to.equal(false)
+  })
+
+  it('★ a kind that declares its identifier: a typed value, a link and the address all open the same subject', async () => {
+    reads.length = 0
+    const host = drawn(html`${entity360Link('kx-lot', 'L-1')}`)
+    ;(host.querySelector('a') as HTMLElement).click()
+    await settle()
+    expect(address()).to.equal('kx-lot:L-1')
+    dock().view!.onClose()
+    await settle()
+
+    openEntity360Kind('kx-lot', { __typename: 'KxLot', id: '0c9e-uuid', name: 'L-1' })
+    await settle()
+    expect(address()).to.equal('kx-lot:L-1')
+    expect(reads.map(read => read.subject.id)).to.deep.equal(['L-1', 'L-1'])
+  })
+
+  it('★ a shared link brings only the id - the sections still read by it', async () => {
+    reads.length = 0
+    const url = new URL(location.href)
+    url.searchParams.set('f', 'kx-lot:L-shared')
+    history.pushState(null, '', url)
+    window.dispatchEvent(new PopStateEvent('popstate', { state: null }))
+    await settle()
+    expect(dock().view!.title).to.equal('L-shared')
+    expect(reads[reads.length - 1]?.subject).to.deep.include({ kind: 'kx-lot', id: 'L-shared' })
+    expect(reads[reads.length - 1]?.subject.value).to.deep.equal({ id: 'L-shared' })
+  })
+
+  it('★ refresh gives the sections a new subject of the same id; they read again and are not made anew', async () => {
+    openEntity360Kind('kx-lot', { id: 'L-2', name: 'L-2' })
+    await settle()
+    const before = section()
+    const input = before.querySelector('input')!
+    input.value = 'typed'
+    reads.length = 0
+    dock().view!.onRefresh!()
+    await settle()
+    expect(section()).to.equal(before)
+    expect(input.value).to.equal('typed')
+    expect(reads.length).to.equal(1)
+    expect(reads[0].subject.id).to.equal('L-2')
+  })
+
+  it('★ leaving a subject whose entry no draft keeps is asked about; keeping it stays put', async () => {
+    const open = OxPrompt.open
+    let asked = 0
+    let answer = false
+    ;(OxPrompt as any).open = async () => (asked++, answer)
+    try {
+      openEntity360Kind('kx-lot', { id: 'L-3', name: 'L-3' })
+      await settle()
+      const input = section().querySelector('input')!
+      input.dispatchEvent(new CustomEvent(ENTITY360_UNKEPT, { bubbles: true, composed: true, detail: { unkept: true } }))
+
+      openEntity360Kind('kx-lot', { id: 'L-4', name: 'L-4' })
+      await settle()
+      expect(asked).to.equal(1)
+      expect(address()).to.equal('kx-lot:L-3')
+      expect(input.isConnected).to.equal(true)
+
+      answer = true
+      openEntity360Kind('kx-lot', { id: 'L-4', name: 'L-4' })
+      await settle()
+      expect(asked).to.equal(2)
+      expect(address()).to.equal('kx-lot:L-4')
+    } finally {
+      ;(OxPrompt as any).open = open
+    }
+  })
+
+  it('★ opening the subject already shown does not hand the sections a new subject', async () => {
+    const url = new URL(location.href)
+    url.searchParams.set('f', 'kx-lot:L-7')
+    history.pushState(null, '', url)
+    window.dispatchEvent(new PopStateEvent('popstate', { state: null }))
+    await settle()
+    reads.length = 0
+    openEntity360Kind('kx-lot', { id: 'L-7', name: 'L-7' })
+    await settle()
+    expect(reads.length).to.equal(0)
+  })
+
+  it('a kept entry - or none - is left without a question', async () => {
+    const open = OxPrompt.open
+    let asked = 0
+    ;(OxPrompt as any).open = async () => (asked++, false)
+    try {
+      openEntity360Kind('kx-lot', { id: 'L-5', name: 'L-5' })
+      await settle()
+      openEntity360Kind('kx-lot', { id: 'L-6', name: 'L-6' })
+      await settle()
+      expect(asked).to.equal(0)
+      expect(address()).to.equal('kx-lot:L-6')
+    } finally {
+      ;(OxPrompt as any).open = open
+    }
   })
 
   it('a link carries more for the sections, beside the id', async () => {
     const heard: (Entity360Subject | undefined)[] = []
     const stop = onEntity360Change(subject => heard.push(subject))
-    const host = await fixture(html`<div>${entity360Link('kx-order', 'SO-10', undefined, { instanceId: 'twin-2' })}</div>`)
+    const host = drawn(html`${entity360Link('kx-order', 'SO-10', undefined, { instanceId: 'twin-2' })}`)
     ;(host.querySelector('a') as HTMLElement).click()
     await settle()
     stop()

package/test/entity360-section.test.ts

@@ -1,7 +1,7 @@
 import { expect, fixture } from '@open-wc/testing'
 import { html } from 'lit'
 import '../src/index.js'
-import { readEntity360Door, type OxEntity360Section } from '../src/index.js'
+import { askEntity360Door, Entity360Reads, readEntity360Door, type OxEntity360Section } from '../src/index.js'
 
 /**
  * A 360 section says what its door answered (ADR-0067): something, nothing, may-not-see, or failed.
@@ -11,6 +11,39 @@ import { readEntity360Door, type OxEntity360Section } from '../src/index.js'
 const refused = { data: null, errors: [{ message: 'not allowed', extensions: { code: 'FORBIDDEN' } }] }
 
 describe('entity 360 door', () => {
+  it('★ a request that throws is failed, with its own message - never left loading (ADR-0067 decision 7)', async () => {
+    const answer = await askEntity360Door(Promise.reject(new Error('Failed to fetch')), d => d?.items)
+    expect(answer).to.deep.equal({ state: 'failed', message: 'Failed to fetch' })
+  })
+
+  it('★ a client that throws on a refusal still says forbidden', async () => {
+    const thrown = Object.assign(new Error('not allowed'), { graphQLErrors: refused.errors })
+    expect((await askEntity360Door(Promise.reject(thrown), d => d?.items)).state).to.equal('forbidden')
+  })
+
+  it('★ only the newest read answers - a second read of the same id drops the first', async () => {
+    const reads = new Entity360Reads()
+    let release!: (value: any) => void
+    const first = reads.ask(() => new Promise(resolve => (release = resolve)), d => d.items)
+    const second = reads.ask(() => Promise.resolve({ data: { items: [2] } }), d => d.items)
+    release({ data: { items: [1] } })
+    expect(await first).to.equal(undefined)
+    expect((await second)?.data).to.deep.equal([2])
+  })
+
+  it('a read that throws synchronously still ends failed; forget drops one on its way', async () => {
+    const reads = new Entity360Reads()
+    expect((await reads.ask(() => { throw new Error('no client') }, d => d))?.state).to.equal('failed')
+    const pending = reads.ask(() => Promise.resolve({ data: { items: [1] } }), d => d.items)
+    reads.forget()
+    expect(await pending).to.equal(undefined)
+  })
+
+  it('a request that answers is read as readEntity360Door reads it', async () => {
+    expect((await askEntity360Door(Promise.resolve({ data: { items: [] } }), d => d.items)).state).to.equal('none')
+    expect((await askEntity360Door(Promise.resolve({ data: { items: [1] } }), d => d.items)).data).to.deep.equal([1])
+  })
+
   it('★ a refusal is forbidden, not none - even when data came back empty beside it', () => {
     expect(readEntity360Door(refused, d => d?.items).state).to.equal('forbidden')
     expect(readEntity360Door({ ...refused, data: { items: [] } }, d => d.items).state).to.equal('forbidden')

package/test/entity360.test.ts

@@ -1,7 +1,7 @@
 import { expect, fixture, elementUpdated } from '@open-wc/testing'
 import { html } from 'lit'
 import '../src/index.js'
-import { showEntity360, hideEntity360, navigateEntity360, canGoBackEntity360, type OxEntity360Dock, type Entity360View } from '../src/index.js'
+import { showEntity360, hideEntity360, isEntity360Unkept, navigateEntity360, canGoBackEntity360, ENTITY360_UNKEPT, type OxEntity360Dock, type Entity360View } from '../src/index.js'
 
 const owner = {}
 const labels = { close: 'Close', expand: 'Expand', collapse: 'Collapse', resize: 'Resize', back: 'Back' }
@@ -38,20 +38,45 @@ describe('shared nonmodal entity 360 dock', () => {
     expect(original.shadowRoot!.textContent).to.contain('Approval after · Revision 2')
   })
 
-  it('refreshes all content while keeping the dock and its read context', async () => {
-    showEntity360(owner, view())
+  it('★ refresh reads again and keeps the contents - what is being written stays (ADR-0067 decision 8)', async () => {
+    let refreshed = 0
+    showEntity360(owner, { ...view(), onRefresh: () => refreshed++ })
     await settle()
     const original = dock()
     original.expanded = true
     const content = original.shadowRoot!.querySelector('ox-entity360-content') as HTMLElement
     const input = content.shadowRoot!.querySelector('input')!
+    input.value = 'typed, not saved'
     ;(original.shadowRoot!.querySelector('[data-action="refresh"]') as HTMLElement).click()
     await settle()
+    expect(refreshed).to.equal(1)
     expect(dock()).to.equal(original)
     expect(original.expanded).to.equal(true)
-    expect(original.view!.key).to.equal('Revision 1')
-    expect(content.shadowRoot!.querySelector('input')).not.to.equal(input)
-    expect(content.shadowRoot!.querySelector('input')!.value).to.equal('Revision 1')
+    expect(content.shadowRoot!.querySelector('input')).to.equal(input)
+    expect(input.value).to.equal('typed, not saved')
+  })
+
+  it('a dock that cannot read again draws no refresh button', async () => {
+    showEntity360(owner, view())
+    await settle()
+    expect(dock().shadowRoot!.querySelector('[data-action="refresh"]')).to.equal(null)
+  })
+
+  it('★ a section holding an entry no draft keeps makes the dock unkept, until it says otherwise', async () => {
+    showEntity360(owner, view())
+    await settle()
+    const content = dock().shadowRoot!.querySelector('ox-entity360-content') as HTMLElement
+    const input = content.shadowRoot!.querySelector('input')!
+    const tell = (unkept: boolean) => input.dispatchEvent(new CustomEvent(ENTITY360_UNKEPT, { bubbles: true, composed: true, detail: { unkept } }))
+    expect(isEntity360Unkept(owner)).to.equal(false)
+    tell(true)
+    expect(isEntity360Unkept(owner)).to.equal(true)
+    tell(false)
+    expect(isEntity360Unkept(owner)).to.equal(false)
+    tell(true)
+    showEntity360(owner, view('Revision 2'))
+    await settle()
+    expect(isEntity360Unkept(owner)).to.equal(false)
   })
 
   it('uses compact header controls and the shared scrollbar theme without local overrides', async () => {

package/test/id-lens.test.ts

@@ -0,0 +1,198 @@
+import { expect, fixture } from '@open-wc/testing'
+import { html } from 'lit'
+import '../src/index.js'
+import '../src/components/ox-id-lens.js'
+import {
+  askIdLensDoors,
+  foldIdLensAnswers,
+  idLensAnswerOf,
+  idLensHitToOpen,
+  lookupText,
+  registerEntity360Kind,
+  type IdLensDoor
+} from '../src/index.js'
+import type { OxIdLensResults } from '../src/components/ox-id-lens.js'
+
+/**
+ * The ID Lens (ADR-0133): the products give the doors, the lens asks, folds and opens. These are the rules every
+ * product's lens shares, and the guard that keeps any product's words out of the shared code.
+ */
+
+const a = { kind: 'idlens-test-a', id: 'X-1', name: 'X-1' }
+const b = { kind: 'idlens-test-b', id: 'X-1', name: 'X-1', status: 'open' }
+const registered = (kind: string) => kind === a.kind || kind === b.kind
+
+const door = (kind: string, ask: IdLensDoor['ask'], label = kind.toUpperCase()): IdLensDoor => ({ kind, label: () => label, ask })
+
+describe('ID Lens rules', () => {
+  it('only the ends are trimmed - case, prefixes and digits stay as typed', () => {
+    expect(lookupText('  wo-2609-041 \n')).to.equal('wo-2609-041')
+    expect(lookupText('(01)08801234567890(10)A1')).to.equal('(01)08801234567890(10)A1')
+    expect(lookupText(undefined)).to.equal('')
+  })
+
+  it('one hit of a registered kind, every door answered - its 360 opens', () => {
+    const outcome = foldIdLensAnswers('X-1', [
+      { kind: a.kind, state: 'ready', hit: a },
+      { kind: b.kind, state: 'none' }
+    ])
+    expect(idLensHitToOpen(outcome, registered)).to.deep.equal(a)
+  })
+
+  it('the same identifier in two kinds is a choice for the person - the first is never picked', () => {
+    const outcome = foldIdLensAnswers('X-1', [
+      { kind: a.kind, state: 'ready', hit: a },
+      { kind: b.kind, state: 'ready', hit: b }
+    ])
+    expect(outcome.hits).to.have.length(2)
+    expect(idLensHitToOpen(outcome, registered)).to.equal(undefined)
+  })
+
+  it('a door that failed might have held another hit - the one hit is shown, not opened', () => {
+    const outcome = foldIdLensAnswers('X-1', [
+      { kind: a.kind, state: 'ready', hit: a },
+      { kind: b.kind, state: 'failed', message: 'timeout' }
+    ])
+    expect(idLensHitToOpen(outcome, registered)).to.equal(undefined)
+    expect(outcome.failed).to.deep.equal([{ kind: b.kind, message: 'timeout' }])
+  })
+
+  it('a kind this person may not read is named by kind only and does not stop the open', () => {
+    const outcome = foldIdLensAnswers('X-1', [
+      { kind: a.kind, state: 'forbidden' },
+      { kind: b.kind, state: 'ready', hit: b }
+    ])
+    expect(outcome.forbidden).to.deep.equal([a.kind])
+    expect(idLensHitToOpen(outcome, registered)).to.deep.equal(b)
+  })
+
+  it('a hit whose kind has no 360 is listed, never opened', () => {
+    const outcome = foldIdLensAnswers('X-1', [{ kind: 'idlens-test-none', state: 'ready', hit: { kind: 'idlens-test-none', id: 'X-1', name: 'X-1' } }])
+    expect(idLensHitToOpen(outcome, registered)).to.equal(undefined)
+  })
+
+  it('a door that threw did not answer - it is failed, not none, and the other doors still count', async () => {
+    const outcome = await askIdLensDoors(
+      [
+        door(a.kind, async () => ({ state: 'ready', hit: a })),
+        door(b.kind, async () => {
+          throw new Error('offline')
+        })
+      ],
+      'X-1'
+    )
+    expect(outcome.hits).to.deep.equal([a])
+    expect(outcome.failed).to.deep.equal([{ kind: b.kind, message: 'offline' }])
+  })
+
+  it("a door's response reads as the 360 doors do: refused is forbidden, nothing is none", () => {
+    const hitOf = (row: { name: string }) => ({ kind: a.kind, id: row.name, name: row.name })
+    expect(idLensAnswerOf({ data: { row: { name: 'X-1' } } }, data => data.row, hitOf)).to.deep.equal({ state: 'ready', hit: a })
+    expect(idLensAnswerOf({ data: { row: null } }, data => data.row, hitOf).state).to.equal('none')
+    expect(idLensAnswerOf({ errors: [{ extensions: { code: 'FORBIDDEN' } }] }, data => data.row, hitOf).state).to.equal('forbidden')
+    /* A product that finds the row but does not count it as a hit says so with undefined. */
+    expect(idLensAnswerOf({ data: { row: { name: 'X-1' } } }, data => data.row, () => undefined).state).to.equal('none')
+  })
+})
+
+describe('ID Lens results', () => {
+  before(() => registerEntity360Kind({ kind: a.kind, typenames: [], title: subject => subject.id }))
+
+  it('kinds are said in the words the product gave its doors', async () => {
+    const doors = [door(a.kind, async () => ({ state: 'none' }), 'Kind A'), door(b.kind, async () => ({ state: 'none' }), 'Kind B')]
+    const outcome = foldIdLensAnswers('X-1', [
+      { kind: a.kind, state: 'forbidden' },
+      { kind: b.kind, state: 'failed' }
+    ])
+    const results = await fixture<OxIdLensResults>(html`<ox-id-lens-results .outcome=${outcome} .doors=${doors}></ox-id-lens-results>`)
+    const text = results.shadowRoot!.textContent!
+    expect(text).to.contain('Kind A')
+    expect(text).to.contain('Kind B')
+  })
+
+  it('a hit with a 360 or a work screen is a button; one with neither stays text and says so', async () => {
+    let opened = ''
+    const screen = { kind: 'idlens-test-screen', id: 'S-1', name: 'S-1', open: () => (opened = 'S-1') }
+    const bare = { kind: 'idlens-test-bare', id: 'B-1', name: 'B-1' }
+    const outcome = foldIdLensAnswers('X', [
+      { kind: a.kind, state: 'ready', hit: a },
+      { kind: screen.kind, state: 'ready', hit: screen },
+      { kind: bare.kind, state: 'ready', hit: bare }
+    ])
+    const picked: string[] = []
+    const results = await fixture<OxIdLensResults>(
+      html`<ox-id-lens-results .outcome=${outcome} .onPick=${(hit: any) => (picked.push(hit.id), hit.open?.())}></ox-id-lens-results>`
+    )
+    const buttons = Array.from(results.shadowRoot!.querySelectorAll('button.hit')) as HTMLButtonElement[]
+    expect(buttons).to.have.length(2)
+    buttons.forEach(button => button.click())
+    expect(picked).to.deep.equal(['X-1', 'S-1'])
+    expect(opened).to.equal('S-1')
+    expect(results.shadowRoot!.querySelector('div.hit')!.textContent).to.contain('B-1')
+  })
+})
+
+describe('ID Lens field', () => {
+  it('a placeholder given as a function is read at render - a band registered once follows the language', async () => {
+    let word = 'first'
+    const lens = await fixture<HTMLElement & { requestUpdate(): void; updateComplete: Promise<boolean> }>(
+      html`<ox-id-lens .placeholder=${() => word}></ox-id-lens>`
+    )
+    const field = () => lens.shadowRoot!.querySelector('ox-input-barcode')!.getAttribute('placeholder')
+    expect(field()).to.equal('first')
+    word = 'second'
+    lens.requestUpdate()
+    await lens.updateComplete
+    expect(field()).to.equal('second')
+  })
+})
+
+describe('ID Lens element source', () => {
+  /* What the lens does is read from its source, as it was in operato-plant before the lens moved here. */
+  const lensSource = async () => (await (await fetch('/src/components/ox-id-lens.ts')).text()).replace(/\/\*[\s\S]*?\*\//g, '')
+
+  it('asks the 360 registry what opens - the doors say nothing about 360s', async () => {
+    const lens = await lensSource()
+    expect(lens).to.match(/idLensHitToOpen\(outcome, entity360KindRegistered\)/)
+    expect(lens).to.match(/openEntity360Kind\(/)
+  })
+
+  it('reuses ox-input-barcode and listens to no page-wide keys; a page scanner is not the lens', async () => {
+    const lens = await lensSource()
+    expect(lens).to.match(/<ox-input-barcode /)
+    expect(lens).not.to.match(/window\.addEventListener|document\.addEventListener|key === 'Enter'|@keydown/)
+    for (const scanRule of ['listenForScans', 'classifyScan', 'parseGs1']) expect(lens.includes(scanRule), scanRule).to.equal(false)
+  })
+
+  it('leaving the field is not a request to look - only Enter or a scan, which keep focus in the lens', async () => {
+    const lens = await lensSource()
+    expect(lens).to.match(/@change=\$\{this\.committed\}/)
+    expect(lens).to.match(/if \(this\.matches\(':focus-within'\)\) this\.find\(\)/)
+  })
+
+  it('the front mark follows the camera: with one, the magnifier finds; without, the QR mark', async () => {
+    const lens = await lensSource()
+    expect(lens).to.match(/class="find"[^>]*@click=\$\{\(\) => this\.find\(\)\}>\s*<md-icon aria-hidden="true">search<\/md-icon>/)
+    expect(lens).to.match(/class="scan"[^>]*@click=\$\{\(\) => this\.field\?\.input\?\.focus\(\)\}>\s*<md-icon aria-hidden="true">qr_code_scanner<\/md-icon>/)
+    expect(lens).to.match(/\.lens:has\(> ox-input-barcode\[scannable\]\) \.scan,\s*\.lens:not\(:has\(> ox-input-barcode\[scannable\]\)\) \.find \{\s*display: none;/)
+    expect(lens).not.to.match(/without-scan-button/)
+    expect(lens).to.match(/--barcodescan-input-button-icon-size: auto 15px;/)
+  })
+})
+
+describe('ID Lens holds no product', () => {
+  /*
+   * ADR-0133 2-1: the shared lens owns no kind's name, rule or privilege. A product word here means a product's
+   * knowledge moved into the shared code - the doors are where it belongs (architect ruling 2026-10-23).
+   */
+  const words = /\b(plant|warehouse|lots?|job-?orders?|sscc|sgln|gtin|locations?|pallets?|orders?|tasks?)\b|로트|작업지시|창고|공장/i
+
+  for (const file of ['/src/actions/id-lens.ts', '/src/components/ox-id-lens.ts']) {
+    it(`${file} names no product's kinds`, async () => {
+      const source = await (await fetch(file)).text()
+      expect(source.length, `${file} was not read`).to.be.greaterThan(1000)
+      const found = source.match(words)
+      expect(found?.[0], `${file} says "${found?.[0]}"`).to.equal(undefined)
+    })
+  }
+})