@things-factory/figure-service 10.1.205 → 10.1.207

package/server/service/figure/figure-inspect-db.test.ts

@@ -13,7 +13,6 @@ import {
   applyFigureAuthoring,
   createFigureAsset,
   placeholderType,
-  proposeFigureOccupancy,
   serializeFigureAsset
 } from '@hatiolab/figure-model'
 
@@ -37,11 +36,11 @@ function loadCompiled(modulePath: string): any {
   return require(resolved)
 }
 
-/** A figure that passes the gate on its own: a box standing on the floor, with its space declared. */
+/** A figure that passes the gate on its own: a box standing on the floor. */
 function sound(): string {
   let asset = createFigureAsset('Probe')
   asset = addFigureBox(asset, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
-  asset = applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(asset, { over: 'range' }), placement: 'floor' })
+  asset = applyFigureAuthoring(asset, { kind: 'set-placement', placement: 'floor' })
   return serializeFigureAsset(asset)
 }
 
@@ -102,12 +101,14 @@ describe('inspectFigureDraft — the verdict while editing', () => {
   it('judges the unsaved source, not the stored one, and still reads the row type', async () => {
     const figure = await save(placeholderType())
     let edited = createFigureAsset('Probe')
-    edited = addFigureBox(edited, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
+    edited = addFigureBox(edited, { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 150, z: 0 } })
+    /* Its bottom named as the face it is mounted on, 100 mm above the floor: a finding the stored one does not have. */
+    edited = applyFigureAuthoring(edited, { kind: 'set-mounting-face', part: 'body', face: 'bottom' })
 
     const inspection = await new FigureQuery().inspectFigureDraft(serializeFigureAsset(edited), context(), figure.id)
     const codes = inspection.findings.map((f: any) => f.code)
 
-    expect(codes).toContain('occupancy-undeclared')
+    expect(codes).toContain('parts-off-placement-face')
     expect(codes).toContain('type-is-placeholder')
   })
 

package/server/service/figure/figure-llm-smoke.test.ts

@@ -43,7 +43,7 @@ function mixerDraft(): FigureAsset {
     { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } },
     /* The body's front is its curved side: a point on it, by the outward normal there (ADR-0140 3.9; push Y, +Z is 270°). */
     { kind: 'attach', part: 'port', to: { part: 'body', surface: { around: 270, along: 'centre' } } },
-    { kind: 'fit-room', placement: 'floor' }
+    { kind: 'set-placement', placement: 'floor' }
   ] as any)
 }
 

package/server/service/figure/figure-mutation.ts

@@ -447,6 +447,8 @@ export class FigureMutation {
       state: 'released',
       updater: user,
       /* 판본 구독자가 이것들을 판본의 comment · assetFormat · kernelVersion · changes 로 옮긴다. Figure 의 칸이 아니다. */
+      /* The release's own copy, its size range written down; the figure keeps the author's (ADR-0087 decision 6). */
+      __releaseSource: record.source,
       __releaseComment: comment ?? null,
       __releaseFormat: record.format,
       __releaseKernel: record.kernel,

package/server/service/figure/figure-namespace-db.test.ts

@@ -10,7 +10,7 @@ const JSZip = require('jszip')
 const shell = require('@things-factory/shell')
 const authBase = require('@things-factory/auth-base')
 const settingBase = require('@things-factory/setting-base')
-const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy, readFigurePackage } = require('@hatiolab/figure-model')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, readFigurePackage } = require('@hatiolab/figure-model')
 
 let dataSource: DataSource | null = null
 let Figure: any
@@ -60,7 +60,7 @@ afterAll(async () => {
 const releasable = (label = 'Conveyor') => {
   let a = addFigureBox(createFigureAsset(label), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
-  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
+  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' }))
 }
 
 let seq = 0

package/server/service/figure/figure-propose-steps.test.ts

@@ -5,7 +5,7 @@
  * the step the kernel refuses, and the gate findings the steps bring in, go back to the model; after three attempts
  * the proposer says it could not make it, and nothing half made comes back.
  */
-import { FIGURE_PROPOSAL_GRAMMAR, addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, inspectFigureAsset, proposeFigureOccupancy } from '@hatiolab/figure-model'
+import { FIGURE_PROPOSAL_GRAMMAR, addFigureBox, applyFigureAuthoring, applyFigureProposal, createFigureAsset, inspectFigureAsset } from '@hatiolab/figure-model'
 import { AIAnswerNotJSON, type AIClient } from '@things-factory/ai-client-base'
 
 import { ProposeFigureFailure, WORKED_EXAMPLE, judgeFigureAnswer, proposalFailureForPerson, proposeFigureSteps, rulesPromptFigure } from './figure-propose-steps'
@@ -38,10 +38,10 @@ const liftTable = [
   { kind: 'attach', part: 'base', to: { plane: 'mounting-plane' } },
   { kind: 'attach', part: 'column', to: { part: 'base', face: 'top' } },
   { kind: 'attach', part: 'top', to: { part: 'column', face: 'top' } },
-  { kind: 'set-material', target: 'top', material: { token: 'palette.accent' }, palette: { 'palette.accent': '#d08a2c' } },
-  { kind: 'fit-room', placement: 'floor' }
+  { kind: 'set-material', target: 'top', material: { token: 'palette.accent' }, palette: { 'palette.accent': '#d08a2c' } }
 ]
-const withoutRoom = liftTable.slice(0, -1)
+/* The table's top named as the face it is mounted on: a finding the draft has, its face 740 mm off the plane. */
+const offFace = [...liftTable, { kind: 'set-mounting-face', part: 'top', face: 'top' }]
 const wrongFace = liftTable.map((s, i) => (i === 4 ? { ...s, face: 'left' } : s))
 
 describe('the model is told the kernel\'s commands and the open draft', () => {
@@ -74,7 +74,6 @@ describe('the model is told the kernel\'s commands and the open draft', () => {
     expect(judged.source!.appearance.map(a => a.target)).toEqual(['frame', 'support', 'roller'])
     const kinds = WORKED_EXAMPLE.map(step => step.kind)
     expect(kinds).toContain('make-repeat')
-    expect(kinds.at(-1)).toBe('fit-room')
     expect(WORKED_EXAMPLE.filter(step => step.kind === 'attach' && 'plane' in (step as any).to).every(step => !('facing' in step))).toBe(true)
   })
 
@@ -117,15 +116,9 @@ describe('the steps are held to the kernel and the gate', () => {
     expect(said).toMatch(/SCHEMA: steps\[4\]: attach: column: face is a word attach does not take/)
   })
 
-  it('a new figure must come out whole: a list that leaves the room undeclared is sent back', async () => {
-    const client = stubClient([{ steps: withoutRoom }, { steps: liftTable }])
-    const made = await proposeFigureSteps({ client, prompt: '리프트 테이블', name: 'Lift table' })
-    expect(made.attempts).toBe(2)
-    expect(client.sent[1]!.at(-1)!.content).toMatch(/OCCUPANCY_UNDECLARED/)
-  })
-
   it('a revision is not blamed for what the draft already had', async () => {
-    const draft = applyFigureProposal(createFigureAsset('Lift table'), withoutRoom as any)
+    const draft = applyFigureProposal(createFigureAsset('Lift table'), offFace as any)
+    expect(inspectFigureAsset(draft).violations.map(v => v.code)).toEqual(['PARTS_OFF_PLACEMENT_FACE'])
     const client = stubClient([{ steps: [{ kind: 'rename', name: 'Lift' }] }])
     const made = await proposeFigureSteps({ client, prompt: '이름', base: draft })
     expect(made.attempts).toBe(1)
@@ -227,28 +220,30 @@ describe('reference pictures go with the task', () => {
 
 /*
   A revision is not blamed for a finding the draft already had -- but the same finding made worse is the answer's.
-  Matching by code, part and axis alone excused a part pushed further out of the declared room.
+  Matching by code, part and axis alone excused a part pushed further out of the declared room; the room is computed
+  now (ADR-0145), and a mounting face further off its plane is the same case.
 */
 describe('a finding the draft had is excused only while it is no worse', () => {
   const outside = (() => {
     let asset = addFigureBox(createFigureAsset('Mixer'), { id: 'body', size: { x: 300, y: 400, z: 300 }, position: { x: 0, y: 200, z: 0 } })
-    asset = applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(asset), placement: 'floor' })
-    return addFigureBox(asset, { id: 'sign', size: { x: 100, y: 100, z: 40 }, position: { x: 300, y: 200, z: 0 } })
+    asset = applyFigureAuthoring(asset, { kind: 'set-placement', placement: 'floor' })
+    asset = addFigureBox(asset, { id: 'sign', size: { x: 100, y: 100, z: 40 }, position: { x: 300, y: 250, z: 0 } })
+    return applyFigureAuthoring(asset, { kind: 'set-mounting-face', part: 'sign', face: 'bottom' })
   })()
 
   it('the draft has the finding to begin with', () => {
-    expect(inspectFigureAsset(outside).violations.map(v => `${v.code} ${v.part} ${v.axis} ${v.mm}`)).toEqual(['PART_OUTSIDE_OCCUPANCY sign x 200'])
+    expect(inspectFigureAsset(outside).violations.map(v => `${v.code} ${v.part} ${v.axis} ${v.mm}`)).toEqual(['PARTS_OFF_PLACEMENT_FACE sign y 200'])
   })
 
   it('left as it was, or made smaller, it is excused', () => {
     expect(judgeFigureAnswer(outside, { steps: [{ kind: 'rename', name: 'Mixer 2' }] }, true).reasons).toEqual([])
-    expect(judgeFigureAnswer(outside, { steps: [{ kind: 'nudge-part', part: 'sign', by: { x: -20 } }] }, true).reasons).toEqual([])
+    expect(judgeFigureAnswer(outside, { steps: [{ kind: 'nudge-part', part: 'sign', by: { y: -20 } }] }, true).reasons).toEqual([])
   })
 
   it('pushed further out, it is sent back as the answer\'s', () => {
-    const judged = judgeFigureAnswer(outside, { steps: [{ kind: 'nudge-part', part: 'sign', by: { x: 100 } }] }, true)
+    const judged = judgeFigureAnswer(outside, { steps: [{ kind: 'nudge-part', part: 'sign', by: { y: 100 } }] }, true)
     expect(judged.source).toBeUndefined()
-    expect(judged.reasons).toEqual([expect.stringMatching(/^PART_OUTSIDE_OCCUPANCY \(sign\): .*worse than the 200 mm the figure already had/)])
+    expect(judged.reasons).toEqual([expect.stringMatching(/^PARTS_OFF_PLACEMENT_FACE \(sign\): .*worse than the 200 mm the figure already had/)])
   })
 })
 

package/server/service/figure/figure-propose-steps.ts

@@ -92,8 +92,7 @@ export const WORKED_EXAMPLE: FigureProposalStep[] = [
   { kind: 'add-part', part: { id: 'roller', kind: 'box', dimensions: { width: 60, height: 60, depth: 560 } } },
   { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } },
   { kind: 'make-repeat', part: 'roller', axis: 'x', pitch: 160 },
-  { kind: 'set-material', target: 'frame', material: { token: 'palette.frame' }, palette: { 'palette.frame': '#5b6770' } },
-  { kind: 'fit-room', placement: 'floor' }
+  { kind: 'set-material', target: 'frame', material: { token: 'palette.frame' }, palette: { 'palette.frame': '#5b6770' } }
 ] as FigureProposalStep[]
 
 /** The rules and the words, all from figure-model's constants. */
@@ -114,8 +113,7 @@ export function rulesPromptFigure(): string {
     '{ kind: "set-material", target, material: { token }, palette: { [token]: "#rrggbb" } }.',
     'When the request says a measure is the same as, matches or follows another part or the figure, write link-dimension:',
     'a copied number stays the same when the other one is resized.',
-    'Declare the sizes the figure may be placed at before any measure follows the figure. End with fit-room when parts,',
-    'their fastenings or motions changed.',
+    'Declare the sizes the figure may be placed at before any measure follows the figure.',
     'When revising, write only the commands the request needs. Everything not touched stays as it is.',
     '',
     'The commands (shape, then what it means):',
@@ -216,7 +214,7 @@ function partsAtRefusedStep(base: FigureAsset, steps: FigureProposalStep[], erro
 /**
  * Applies an answer on a copy of the base and returns the figure, or the reasons it was not accepted: the step the
  * kernel refused, or the gate findings the steps brought in. When revising, a finding the draft already had is not the
- * answer's; a new figure has none to excuse, so it must come out whole (its room declared, its parts inside it).
+ * answer's; a new figure has none to excuse, so it must come out whole.
  */
 export function judgeFigureAnswer(
   base: FigureAsset,

package/server/service/figure/figure-public-db.test.ts

@@ -12,7 +12,7 @@ const shell = require('@things-factory/shell')
 const authBase = require('@things-factory/auth-base')
 const settingBase = require('@things-factory/setting-base')
 const attachmentBase = require('@things-factory/attachment-base')
-const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy, readFigurePackage } = require('@hatiolab/figure-model')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, readFigurePackage } = require('@hatiolab/figure-model')
 
 let dataSource: DataSource | null = null
 let Figure: any
@@ -65,7 +65,7 @@ afterAll(async () => {
 const releasable = (label = 'Mixer') => {
   let a = addFigureBox(createFigureAsset(label), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
-  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
+  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' }))
 }
 
 let seq = 0

package/server/service/figure/figure-query.ts

@@ -442,8 +442,9 @@ async function releaseNumbered(figure: Figure, version: number): Promise<{ figur
 /**
  * Finds the released source of a type in one domain, or null.
  *
- * A released row gives its own source; a draft row gives the source of its latest released history.
- * A figure that was never released gives null, because drafts never reach consumers.
+ * Always the latest release's own copy, from history: it carries the size range written down at release (ADR-0087
+ * decision 6), and the figure's row -- released or a draft -- keeps only the ends its author narrowed. A figure that
+ * was never released gives null, because drafts never reach consumers.
  */
 async function releasedSourceOf(
   domainId: string,
@@ -452,10 +453,6 @@ async function releasedSourceOf(
   const figure = await getRepository(Figure).findOne({ where: { domain: { id: domainId }, type } })
   if (!figure) return null
 
-  if (figure.state === 'released' && figure.source) {
-    return { figure, source: figure.source, version: figure.version }
-  }
-
   const latestReleased = await getRepository(FigureHistory).findOne({
     where: { domain: { id: domainId }, originalId: figure.id, state: 'released' },
     order: { version: 'DESC' }

package/server/service/figure/figure-release-check.test.ts

@@ -3,14 +3,14 @@
  * reader's words, and their findings join the gate's -- a blocking one blocks, a said one does not; a check that
  * throws blocks by name rather than being skipped; one taken off is gone.
  */
-import { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy } from '@hatiolab/figure-model'
+import { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring } from '@hatiolab/figure-model'
 
 import { inspectSource, registerFigureReleaseCheck } from './figure-format'
 
 const source = () => {
   let asset = addFigureBox(createFigureAsset('Mixer'), { id: 'body', size: { x: 100, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
-  return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(asset, { over: 'range' }), placement: 'floor' }))
+  return serializeFigureAsset(applyFigureAuthoring(asset, { kind: 'set-placement', placement: 'floor' }))
 }
 const codes = (inspection: { findings: { code: string; blocking: boolean }[] }) => inspection.findings.map(f => [f.code, f.blocking])
 

package/server/service/figure/figure-release-record-db.test.ts

@@ -8,7 +8,7 @@ const { DataSource: TypeOrmDataSource } = require('typeorm')
 const shell = require('@things-factory/shell')
 const authBase = require('@things-factory/auth-base')
 const settingBase = require('@things-factory/setting-base')
-const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, proposeFigureOccupancy, palletizerRobotFigure, FIGURE_KERNEL_VERSION } = require('@hatiolab/figure-model')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, palletizerRobotFigure, FIGURE_KERNEL_VERSION } = require('@hatiolab/figure-model')
 
 let FigureNamespace: any
 let dataSource: DataSource | null = null
@@ -69,7 +69,7 @@ async function release(extra: Record<string, unknown>) {
 
 describe('a release record on its history row', () => {
   it('keeps the format and the changes as they were', async () => {
-    const changes = [{ code: 'occupancy-changed', blocking: false, values: { before: 'x -50…50', after: 'x -150…150' }, detail: 'declared room changed' }]
+    const changes = [{ code: 'size-changed', blocking: false, values: { before: 'x -50…50', after: 'x -150…150' }, detail: 'size changed' }]
     const row = await release({ __releaseFormat: 'figure-asset-1', __releaseChanges: changes })
     expect(row.assetFormat).toBe('figure-asset-1')
     expect(JSON.parse(row.changes)).toEqual(changes)
@@ -90,9 +90,9 @@ describe('releaseFigure records it', () => {
   const releasable = (width: number) => {
     let a = addFigureBox(createFigureAsset('Mixer'), { id: 'body', size: { x: width, y: 100, z: 100 }, position: { x: 0, y: 50, z: 0 } })
     a = applyFigureAuthoring(a, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
-    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'declare-occupancy', proposal: proposeFigureOccupancy(a, { over: 'range' }), placement: 'floor' }))
+    return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' }))
   }
-  it('first release: [], the second: the wider room', async () => {
+  it('first release: [], the second: the wider body', async () => {
     const domain = await namespaced(await dataSource!.getRepository(shell.Domain).save({ name: 'release-door', subdomain: 'release-door' }))
     const tx = dataSource!.manager
     const context = { state: { domain, user: undefined, tx } }
@@ -106,9 +106,10 @@ describe('releaseFigure records it', () => {
     /* Each release names the kernel that measured it (ADR-0109 C1). */
     expect(rows.map((r: any) => r.kernelVersion)).toEqual([FIGURE_KERNEL_VERSION, FIGURE_KERNEL_VERSION])
     const codes = JSON.parse(rows[1].changes).map((c: any) => c.code)
-    expect(codes).toContain('occupancy-changed')
+    expect(codes).toEqual(expect.arrayContaining(['size-changed', 'motion-range-changed']))
     /* What each release measured, and its plan from above, are on its own row. */
-    expect(JSON.parse(rows[0].metrics)).toEqual({ origin: { centred: true, off: [] } })
+    const box = { x: { min: -50, max: 50 }, y: { min: 0, max: 100 }, z: { min: -50, max: 50 } }
+    expect(JSON.parse(rows[0].metrics)).toEqual({ body: box, motionRange: box })
     expect(JSON.parse(rows[1].topView).shapes.map((s: any) => s.id)).toEqual(['body'])
   })
 })

package/server/service/figure/figure-release-size-db.test.ts

@@ -0,0 +1,156 @@
+/**
+ * The size range a board reads is the release's own copy (ADR-0087 decision 10, user 2026-10-21). The figure's row keeps
+ * only the ends its author narrowed; a release writes the rest down as far as the parts allow, on its history row. Every
+ * door a release leaves by -- one figure for a board, several by full name, the package another server imports -- hands
+ * out that copy, never the row. A release made a draft again opens what the release wrote down.
+ */
+import type { DataSource } from 'typeorm'
+
+const { DataSource: TypeOrmDataSource } = require('typeorm')
+const { createHash } = require('crypto')
+const JSZip = require('jszip')
+const shell = require('@things-factory/shell')
+const authBase = require('@things-factory/auth-base')
+const settingBase = require('@things-factory/setting-base')
+const { createFigureAsset, addFigureBox, serializeFigureAsset, applyFigureAuthoring, readFigurePackage } = require('@hatiolab/figure-model')
+
+let dataSource: DataSource | null = null
+let Figure: any
+let FigureMutation: any
+let FigureQuery: any
+let figurePackageOf: any
+let revertKeepingDraft: any
+let FigureHistory: any
+let FigureNamespace: any
+
+function loadCompiled(modulePath: string): any {
+  const { existsSync } = require('fs')
+  const { join } = require('path')
+  const resolved = join(__dirname, '..', '..', '..', 'dist-server', `${modulePath}.js`)
+  if (!existsSync(resolved))
+    throw new Error(`figure-service 산출물이 없다: ${resolved}\n먼저 빌드할 것:\n  yarn workspace @things-factory/figure-service build:server`)
+  return require(resolved)
+}
+
+beforeAll(async () => {
+  Figure = loadCompiled('service/figure/figure').Figure
+  FigureHistory = loadCompiled('service/figure/figure-history').FigureHistory
+  FigureNamespace = loadCompiled('service/figure/figure-namespace-entity').FigureNamespace
+  const FigureReplacedDraft = loadCompiled('service/figure/figure-replaced-draft').FigureReplacedDraft
+  const Subscriber = loadCompiled('service/figure/event-subscriber').FigureHistoryEntitySubscriber
+  ;({ FigureMutation } = loadCompiled('service/figure/figure-mutation'))
+  ;({ FigureQuery } = loadCompiled('service/figure/figure-query'))
+  ;({ figurePackageOf } = loadCompiled('service/figure/figure-package-export'))
+  ;({ revertKeepingDraft } = loadCompiled('service/figure/figure-revert'))
+  dataSource = new TypeOrmDataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    synchronize: true,
+    dropSchema: true,
+    namingStrategy: new shell.NamingStrategy(),
+    entities: [...shell.entities, ...authBase.entities, ...settingBase.entities, Figure, FigureHistory, FigureNamespace, FigureReplacedDraft],
+    subscribers: [Subscriber],
+    logging: false
+  })
+  await dataSource.initialize()
+  shell.addDataSource('default', dataSource)
+  shell.addDataSource('tx', dataSource)
+})
+
+afterAll(async () => {
+  await dataSource?.destroy()
+  dataSource = null
+})
+
+/*
+  The user's figure (2026-10-21): a box that follows the figure's size, with a cavity ticked on it. Below twice its wall it
+  has no inside, so its width has a smallest size its parts set; nothing limits how large it grows. The height is
+  narrowed by the author, 50 to 400 mm.
+*/
+const buttonBox = () => {
+  let a = addFigureBox(createFigureAsset('Button box'), { id: 'box', size: { x: 120, y: 60, z: 80 }, position: { x: 0, y: 30, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'box', to: { plane: 'mounting-plane' } })
+  a = applyFigureAuthoring(a, { kind: 'follow-size', part: 'box' })
+  a = applyFigureAuthoring(a, { kind: 'set-cavity', part: 'box', cavity: { wall: 10, start: { closed: 10 }, end: 'open' } })
+  a = applyFigureAuthoring(a, { kind: 'declare-instance-size', range: { y: { min: 50, max: 400 } }, replace: true })
+  return serializeFigureAsset(applyFigureAuthoring(a, { kind: 'set-placement', placement: 'floor' }))
+}
+const sizeOf = (source: string | object, axis: 'x' | 'y' | 'z') => {
+  const asset = typeof source === 'string' ? JSON.parse(source) : source
+  const { min, max } = asset.document.model.inputs.find((i: any) => i.id === `size.${axis}`)
+  return { min, max }
+}
+/** The width's smallest size as the parts set it: twice the wall, and the kernel's numerical step above it. */
+const widthFloor = (min: number | undefined) => typeof min === 'number' && min > 20 && min < 20.001
+
+let seq = 0
+async function domainWith(namespace: string) {
+  const name = `size-${++seq}`
+  const domain = await dataSource!.getRepository(shell.Domain).save({ name, subdomain: name })
+  await dataSource!.getRepository(FigureNamespace).save({ domain, name: namespace, state: 'active', isDefault: true })
+  return { domain, context: { state: { domain, user: undefined, tx: dataSource!.manager } } }
+}
+const creationId = () => require('crypto').randomUUID()
+
+async function released(type: string) {
+  const ns = `size-${++seq}.hatiolab.com`
+  const { domain, context } = await domainWith(ns)
+  const saved = await new FigureMutation().saveFigure(buttonBox(), context, undefined, undefined, creationId(), undefined, type, undefined, undefined)
+  await new FigureMutation().releaseFigure(saved.id, 'first', context)
+  const figure = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: saved.id } })
+  const history = await dataSource!.getRepository(FigureHistory).findOneOrFail({ where: { originalId: saved.id, version: 1 } })
+  return { ns, domain, context, figure, history }
+}
+
+describe('the size range a release carries', () => {
+  it('is written on the release, and the figure keeps only what its author narrowed', async () => {
+    const { figure, history } = await released('button-box')
+    expect(figure.state).toBe('released')
+    expect(sizeOf(figure.source, 'x')).toEqual({ min: undefined, max: undefined })
+    expect(sizeOf(figure.source, 'y')).toEqual({ min: 50, max: 400 })
+    const x = sizeOf(history.source, 'x')
+    expect(widthFloor(x.min)).toBe(true)
+    expect(x.max).toBeUndefined()
+    expect(sizeOf(history.source, 'y')).toEqual({ min: 50, max: 400 })
+  })
+
+  it('is what every door a release leaves by hands out: one for a board, several by full name, a package', async () => {
+    const { ns, domain, context, history } = await released('button-box')
+    const one = await new FigureQuery().figureBlueprint('button-box', context)
+    expect(widthFloor(sizeOf(one.asset, 'x').min)).toBe(true)
+    const pinned = await new FigureQuery().figureBlueprint('button-box', context, 1)
+    expect(widthFloor(sizeOf(pinned.asset, 'x').min)).toBe(true)
+    const several = await new FigureQuery().figureBlueprints([`${ns}/button-box`], context)
+    expect(widthFloor(sizeOf(several.items[0].asset, 'x').min)).toBe(true)
+
+    const { bytes } = await figurePackageOf({
+      refs: [`${ns}/button-box@1`],
+      domain,
+      exportedBy: 'author',
+      sourceUrl: 'https://figure.hatiolab.com',
+      files: { put: async () => ({}), send: async () => {}, read: async () => Buffer.alloc(0) }
+    })
+    const zip = await JSZip.loadAsync(bytes)
+    const files = new Map<string, Uint8Array>()
+    for (const path of Object.keys(zip.files)) if (!zip.files[path].dir) files.set(path, await zip.files[path].async('uint8array'))
+    const read = readFigurePackage(files, (b: Uint8Array) => createHash('sha256').update(b).digest('hex'))
+    expect(read.releases[0].source).toBe(history.source)
+  })
+
+  it('released again unchanged, nothing is said to have narrowed', async () => {
+    const { figure, context } = await released('button-box')
+    await dataSource!.getRepository(Figure).save({ ...figure, state: 'draft' })
+    await new FigureMutation().releaseFigure(figure.id, 'again', context)
+    const second = await dataSource!.getRepository(FigureHistory).findOneOrFail({ where: { originalId: figure.id, version: 2 } })
+    expect(JSON.parse(second.changes)).toEqual([])
+  })
+
+  it('made a draft again by a revert, what the release wrote down is opened and the author keeps theirs', async () => {
+    const { figure, domain } = await released('button-box')
+    const draft = await dataSource!.getRepository(Figure).save({ ...figure, state: 'draft' })
+    await dataSource!.transaction(tx => revertKeepingDraft(tx, domain, undefined, { id: figure.id, version: 1, requestId: creationId(), expectedSource: draft.source }))
+    const back = await dataSource!.getRepository(Figure).findOneOrFail({ where: { id: figure.id } })
+    expect(sizeOf(back.source, 'x')).toEqual({ min: undefined, max: undefined })
+    expect(sizeOf(back.source, 'y')).toEqual({ min: 50, max: 400 })
+  })
+})

package/server/service/figure/figure-revert.ts

@@ -5,7 +5,7 @@ import { GraphQLError } from 'graphql'
 import { Figure } from './figure.js'
 import { FigureHistory } from './figure-history.js'
 import { FigureReplacedDraft } from './figure-replaced-draft.js'
-import { parseSource } from './figure-format.js'
+import { draftSourceOfRelease, parseSource } from './figure-format.js'
 import { sourceConflict } from './figure-write.js'
 
 /*
@@ -77,7 +77,7 @@ export async function revertKeepingDraft(
   })
   if (!history) throw refused('FIGURE_VERSION_NOT_FOUND', `Figure '${figure.type}' 에 ${request.version} 판이 없습니다.`)
   /* The format is checked again: an old version may break today's rules, and is not let in quietly. */
-  const { source, derived, violations } = parseSource(history.source)
+  const { source, derived, violations } = parseSource(draftSourceOfRelease(history.source!))
 
   const record = await keep(kept, {
     domain: { id: domain.id },

package/server/service/figure/figure-tools.test.ts

@@ -42,11 +42,11 @@ function stubRepository(rows: any[]) {
 const MINE = { id: 'domain-mine' }
 const THEIRS = { id: 'domain-theirs' }
 
-/** A stored figure: one body on the floor, its room declared. */
+/** A stored figure: one body on the floor. */
 const SOURCE = (() => {
   const model = require('@hatiolab/figure-model')
   let asset = model.addFigureBox(model.createFigureAsset('Mixer'), { id: 'body', size: { x: 300, y: 400, z: 300 }, position: { x: 0, y: 200, z: 0 } })
-  asset = model.applyFigureAuthoring(asset, { kind: 'declare-occupancy', proposal: model.proposeFigureOccupancy(asset), placement: 'floor' })
+  asset = model.applyFigureAuthoring(asset, { kind: 'set-placement', placement: 'floor' })
   return asset
 })()
 

package/server/service/figure/figure-type.ts

@@ -176,7 +176,7 @@ export class FigureRevertResult {
  */
 @ObjectType({ description: 'One finding from the release gate.' })
 export class FigureGateFinding {
-  @Field({ description: 'Stable code of the gate finding, for example part-outside-occupancy or parts-split-on-resize.' })
+  @Field({ description: 'Stable code of the gate finding, for example parts-off-placement-face or parts-split-on-resize.' })
   code: string
 
   @Field({ description: 'Human-readable message.' })

package/translations/en.json

@@ -1,14 +1,6 @@
 {
   "error.figure-proposal-failed": "The figure could not be made.",
   "error.figure-release-does-not-compile": "the released source of {type} (version {version}) does not compile. open it in the modeller, fix it and release it again before it draws on a board.",
-  "figure.gate.occupancy-empty-axis.message": "The space the figure takes is empty on {axis}.",
-  "figure.gate.occupancy-undeclared.how": "Use \"fit to parts\" to set the space the figure takes from the parts as they are now.",
-  "figure.gate.occupancy-undeclared.how-no-parts": "Add a shape first, then use \"fit to parts\" to set the space the figure takes from it.",
-  "figure.gate.occupancy-undeclared.message": "The space this figure takes is not set yet.",
-  "figure.gate.occupancy-undeclared.why": "The space a figure takes sets the scale it is placed at on a board.",
-  "figure.gate.part-outside-occupancy.how": "Use \"fit to parts\" to fit the space the figure takes to the parts again, or move '{part}' {mm} mm inward on {axis}.",
-  "figure.gate.part-outside-occupancy.message": "'{part}' goes {mm} mm past the space the figure takes on {axis}.",
-  "figure.gate.part-outside-occupancy.why": "The space the figure takes sets the scale it is placed at. What lies past it is left out of that scale, so on a board this part lands outside the place given to the figure.",
   "figure.gate.parts-off-placement-face.how": "Move '{part}' {mm} mm on Y so the face meets the plane, or choose a different mounting face.",
   "figure.gate.parts-off-placement-face.message": "The mounting face of '{part}' is {mm} mm off the plane the figure stands on.",
   "figure.gate.parts-off-placement-face.why": "The figure is declared to stand on that face. If the face does not reach the plane, the figure floats on the board by that much, and whatever is placed on it floats too.",
@@ -21,9 +13,6 @@
   "figure.gate.placement-face-tilted.how": "Choose a mounting face parallel to the plane, or turn '{part}' upright.",
   "figure.gate.placement-face-tilted.message": "The mounting face of '{part}' is tilted {degrees}° from the plane the figure stands on.",
   "figure.gate.placement-face-tilted.why": "A tilted face cannot lie on the plane, so how the figure stands is not settled.",
-  "figure.gate.state-range-sampled.how": "To cover the whole range, re-author what could not be proven.",
-  "figure.gate.state-range-sampled.message": "The whole range of sizes and motion could not be proven, so {states} combinations of size and pose were checked.",
-  "figure.gate.state-range-sampled.why": "Between the combinations that were checked, a part may still go past the space the figure takes.",
   "figure.gate.type-is-placeholder.how": "Set the type in the type field, then publish.",
   "figure.gate.type-is-placeholder.message": "'{type}' is a temporary type given when the figure was first saved.",
   "figure.gate.type-is-placeholder.why": "Boards call a figure by its type, and it cannot change once the figure is published.",
@@ -66,8 +55,10 @@
   "figure.gate.contract.capability-gone.why": "Scenes attach behaviour by this name. Placed instances lose what it did.",
   "figure.gate.contract.capability-added.message": "The capability '{name}' is new.",
   "figure.gate.contract.capability-added.why": "It adds what the figure can do. Placed instances stand as they are.",
-  "figure.gate.contract.occupancy-changed.message": "The room the figure takes changed: {before} → {after}.",
-  "figure.gate.contract.occupancy-changed.why": "A consumer places the figure by this room. One that moves to this release sees it take the new room.",
+  "figure.gate.contract.size-changed.message": "The figure's size changed: {before} → {after}.",
+  "figure.gate.contract.size-changed.why": "A board gives the figure a box of this size. One that moves to this release sees its box change.",
+  "figure.gate.contract.motion-range-changed.message": "The room the figure sweeps as it moves changed: {before} → {after}.",
+  "figure.gate.contract.motion-range-changed.why": "It is what the figure reaches when it moves. One that moves to this release sees it reach differently.",
   "figure.gate.contract.contact-face-changed.message": "The face the figure is mounted by changed.",
   "figure.gate.contract.contact-face-changed.why": "A consumer that moves to this release sees it stand on the new face.",
   "figure.gate.contract.public-input-gone.message": "'{input}' is no longer set on a board.",
@@ -94,9 +85,6 @@
   "figure.gate.contract.joint-list-unread.message": "The last release's joint list could not be read, so its joints were not compared: {reason}",
   "figure.gate.contract.joint-list-unread.why": "Whether this release changes what a controller's values move has not been checked. The last release was made by a kernel that did not measure joints.",
   "error.figure-release-not-found": "{type} has no release {version}. its latest release is {latest}.",
-  "figure.gate.origin-off-centre.message": "The origin is off the middle of the declared room: {off}.",
-  "figure.gate.origin-off-centre.why": "A drawing that places figures by the middle of their room puts this one that far from where it is drawn.",
-  "figure.gate.origin-off-centre.how": "Keep it when the figure is fastened there, as a door at its hinge. Move the origin to the middle to place it by its room.",
   "figure.gate.off-mounting-plane.floor.clear.message": "'{part}' is {mm} mm above the floor.",
   "figure.gate.off-mounting-plane.floor.through.message": "'{part}' goes {mm} mm below the floor.",
   "figure.gate.off-mounting-plane.floor.beyond.message": "Every part is below the floor.",

package/translations/es.json

@@ -1,14 +1,6 @@
 {
   "error.figure-proposal-failed": "No se pudo crear la figura.",
   "error.figure-release-does-not-compile": "el código fuente publicado de {type} (versión {version}) no compila. Ábralo en el modelador, corríjalo y vuelva a publicarlo para que se dibuje en un tablero.",
-  "figure.gate.occupancy-empty-axis.message": "El espacio declarado está vacío en {axis}.",
-  "figure.gate.occupancy-undeclared.how": "Use «ajustar a las piezas» para declarar el espacio a partir de las piezas tal como están ahora.",
-  "figure.gate.occupancy-undeclared.how-no-parts": "Añada primero una forma y luego use «ajustar a las piezas» para declarar el espacio a partir de ella.",
-  "figure.gate.occupancy-undeclared.message": "Esta figura no ha declarado el espacio que ocupa.",
-  "figure.gate.occupancy-undeclared.why": "Sin un espacio declarado no se puede fijar la escala con la que se coloca una figura.",
-  "figure.gate.part-outside-occupancy.how": "Use «ajustar a las piezas» para volver a declarar el espacio a partir de las piezas, o mueva '{part}' {mm} mm hacia dentro en {axis}.",
-  "figure.gate.part-outside-occupancy.message": "'{part}' sobrepasa {mm} mm el espacio declarado en {axis}.",
-  "figure.gate.part-outside-occupancy.why": "El espacio declarado fija la escala con la que se coloca una figura. Lo que queda fuera no entra en esa escala, así que en un tablero esta pieza queda fuera del lugar asignado a la figura.",
   "figure.gate.parts-off-placement-face.how": "Mueva '{part}' {mm} mm en Y para que la cara toque el plano, o elija otra cara de montaje.",
   "figure.gate.parts-off-placement-face.message": "La cara de montaje de '{part}' está a {mm} mm del plano sobre el que se apoya la figura.",
   "figure.gate.parts-off-placement-face.why": "La figura está declarada para apoyarse sobre esa cara. Si la cara no llega al plano, la figura flota esa distancia en el tablero, y lo que se coloque sobre ella también flota.",
@@ -21,9 +13,6 @@
   "figure.gate.placement-face-tilted.how": "Elija una cara de montaje paralela al plano o ponga '{part}' en posición vertical.",
   "figure.gate.placement-face-tilted.message": "La cara de montaje de '{part}' está inclinada {degrees}° respecto al plano sobre el que se apoya la figura.",
   "figure.gate.placement-face-tilted.why": "Una cara inclinada no puede apoyarse sobre el plano, por lo que no queda definida la postura de la figura.",
-  "figure.gate.state-range-sampled.how": "Para cubrir todo el rango, vuelva a diseñar lo que no se pudo demostrar.",
-  "figure.gate.state-range-sampled.message": "No se pudo demostrar todo el rango de tamaños y movimientos, así que se comprobaron {states} combinaciones de tamaño y postura.",
-  "figure.gate.state-range-sampled.why": "Entre las combinaciones comprobadas, una pieza aún podría sobrepasar el espacio declarado.",
   "figure.gate.type-is-placeholder.how": "Defina el tipo en el campo de tipo y luego publique.",
   "figure.gate.type-is-placeholder.message": "'{type}' es un tipo provisional asignado cuando se guardó la figura por primera vez.",
   "figure.gate.type-is-placeholder.why": "Los tableros llaman a una figura por su tipo, y no se puede cambiar una vez publicada la figura.",
@@ -66,8 +55,10 @@
   "figure.gate.contract.capability-gone.why": "Las escenas asocian comportamientos mediante este nombre. Las instancias colocadas pierden lo que hacía.",
   "figure.gate.contract.capability-added.message": "La capacidad '{name}' es nuevo.",
   "figure.gate.contract.capability-added.why": "Amplía lo que puede hacer la figura. Las instancias colocadas se quedan como están.",
-  "figure.gate.contract.occupancy-changed.message": "Cambió el espacio que ocupa la figura: {before} → {after}.",
-  "figure.gate.contract.occupancy-changed.why": "Quien usa la figura la coloca según este espacio. Quien pase a esta publicación verá que ocupa el nuevo espacio.",
+  "figure.gate.contract.size-changed.message": "El tamaño de la figura cambió: {before} → {after}.",
+  "figure.gate.contract.size-changed.why": "Un tablero le da a la figura una caja de este tamaño. Al pasar a esta versión, su caja cambia.",
+  "figure.gate.contract.motion-range-changed.message": "El espacio que la figura recorre al moverse cambió: {before} → {after}.",
+  "figure.gate.contract.motion-range-changed.why": "Es lo que la figura alcanza al moverse. Al pasar a esta versión, alcanza otro espacio.",
   "figure.gate.contract.contact-face-changed.message": "Cambió la cara por la que se monta la figura.",
   "figure.gate.contract.contact-face-changed.why": "Quien pase a esta publicación verá que se apoya sobre la nueva cara.",
   "figure.gate.contract.public-input-gone.message": "'{input}' ya no se define en un tablero.",
@@ -94,9 +85,6 @@
   "figure.gate.contract.joint-list-unread.message": "No se pudo leer la lista de articulaciones de la última publicación, por lo que no se compararon sus articulaciones: {reason}",
   "figure.gate.contract.joint-list-unread.why": "No se ha comprobado si esta publicación cambia lo que mueven los valores de un controlador. La última publicación se generó con un núcleo que no medía las articulaciones.",
   "error.figure-release-not-found": "{type} no tiene la publicación {version}. Su última publicación es {latest}.",
-  "figure.gate.origin-off-centre.message": "El origen está desplazado del centro del espacio declarado: {off}.",
-  "figure.gate.origin-off-centre.why": "Un plano que coloca las figuras por el centro de su espacio sitúa esta a esa distancia de donde está dibujada.",
-  "figure.gate.origin-off-centre.how": "Manténgalo si la figura se fija en ese punto, como una puerta por su bisagra. Mueva el origen al centro para colocarla por su espacio.",
   "figure.gate.off-mounting-plane.floor.clear.message": "'{part}' está {mm} mm por encima del suelo.",
   "figure.gate.off-mounting-plane.floor.through.message": "'{part}' baja {mm} mm por debajo del suelo.",
   "figure.gate.off-mounting-plane.floor.beyond.message": "Todas las piezas están por debajo del suelo.",