@hatiolab/figure-model 0.1.29 → 0.1.31

package/docs/prototypes/shapeassembly-probe-results.json

@@ -0,0 +1,325 @@
+{
+  "revision": "cc22bd84afb65e8e37c7d14bebd9a4a629b5d943",
+  "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]",
+  "torch": "2.8.0",
+  "numpy": "2.2.6",
+  "faiss": "1.12.0",
+  "units": "native abstract units, not Figure mm",
+  "results": [
+    {
+      "case": "lamp_fresh_replay_height_1",
+      "lines": [
+        "bbox = Cuboid(4, 1, 4, True)",
+        "body = Cuboid(1, 1, 1, True)",
+        "lamp = Cuboid(.2, .2, .2, True)",
+        "attach(body, bbox, .5, 0, .5, .5, 0, .5)",
+        "attach(lamp, body, .5, 0, .5, .5, 1, .5)"
+      ],
+      "result": {
+        "body": {
+          "size": [
+            1,
+            1,
+            1
+          ],
+          "center": [
+            0,
+            0,
+            0
+          ]
+        },
+        "lamp": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            0.6000000238418579,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0
+      ]
+    },
+    {
+      "case": "lamp_fresh_replay_height_2",
+      "lines": [
+        "bbox = Cuboid(4, 2, 4, True)",
+        "body = Cuboid(1, 2, 1, True)",
+        "lamp = Cuboid(.2, .2, .2, True)",
+        "attach(body, bbox, .5, 0, .5, .5, 0, .5)",
+        "attach(lamp, body, .5, 0, .5, .5, 1, .5)"
+      ],
+      "result": {
+        "body": {
+          "size": [
+            1,
+            2,
+            1
+          ],
+          "center": [
+            0,
+            0,
+            0
+          ]
+        },
+        "lamp": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            1.100000023841858,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0
+      ]
+    },
+    {
+      "case": "lamp_fresh_replay_height_4",
+      "lines": [
+        "bbox = Cuboid(4, 4, 4, True)",
+        "body = Cuboid(1, 4, 1, True)",
+        "lamp = Cuboid(.2, .2, .2, True)",
+        "attach(body, bbox, .5, 0, .5, .5, 0, .5)",
+        "attach(lamp, body, .5, 0, .5, .5, 1, .5)"
+      ],
+      "result": {
+        "body": {
+          "size": [
+            1,
+            4,
+            1
+          ],
+          "center": [
+            0,
+            0,
+            0
+          ]
+        },
+        "lamp": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            2.0999999046325684,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        1.1920928955078125e-7
+      ]
+    },
+    {
+      "case": "squeeze_height_0.5_aligned_True",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "beam = Cuboid(.2, 0.5, .2, True)",
+        "squeeze(beam, bbox, bbox, top, .5, .5)"
+      ],
+      "result": {
+        "beam": {
+          "size": [
+            0.20000000298023224,
+            0.5,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            0.25,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0,
+        0.5
+      ]
+    },
+    {
+      "case": "squeeze_height_2_aligned_True",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "beam = Cuboid(.2, 2, .2, True)",
+        "squeeze(beam, bbox, bbox, top, .5, .5)"
+      ],
+      "result": {
+        "beam": {
+          "size": [
+            0.20000000298023224,
+            2,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            -0.5,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0,
+        1
+      ]
+    },
+    {
+      "case": "squeeze_height_0.5_aligned_False",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "beam = Cuboid(.2, 0.5, .2, False)",
+        "squeeze(beam, bbox, bbox, top, .5, .5)"
+      ],
+      "result": {
+        "beam": {
+          "size": [
+            0.20000000298023224,
+            1,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            0,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0,
+        0
+      ]
+    },
+    {
+      "case": "squeeze_height_2_aligned_False",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "beam = Cuboid(.2, 2, .2, False)",
+        "squeeze(beam, bbox, bbox, top, .5, .5)"
+      ],
+      "result": {
+        "beam": {
+          "size": [
+            0.20000000298023224,
+            1,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            0,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0,
+        0
+      ]
+    },
+    {
+      "case": "direct_resize_after_attachment",
+      "lines": [
+        "bbox = Cuboid(4, 4, 4, True)",
+        "body = Cuboid(1, 1, 1, True)",
+        "lamp = Cuboid(.2, .2, .2, True)",
+        "attach(body, bbox, .5, 0, .5, .5, 0, .5)",
+        "attach(lamp, body, .5, 0, .5, .5, 1, .5)",
+        "body = Cuboid(1, 2, 1, True)"
+      ],
+      "result": {
+        "body": {
+          "size": [
+            1,
+            2,
+            1
+          ],
+          "center": [
+            0,
+            -1.5,
+            0
+          ]
+        },
+        "lamp": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            -0.8999999761581421,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0.5
+      ]
+    },
+    {
+      "case": "conflicting_same_point_reverse_False",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "part = Cuboid(.2, .2, .2, True)",
+        "attach(part, bbox, .5, 0, .5, .5, 0, .5)",
+        "attach(part, bbox, .5, 0, .5, .5, 1, .5)"
+      ],
+      "result": {
+        "part": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            -0.4000000059604645,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        0,
+        1
+      ]
+    },
+    {
+      "case": "conflicting_same_point_reverse_True",
+      "lines": [
+        "bbox = Cuboid(1, 1, 1, True)",
+        "part = Cuboid(.2, .2, .2, True)",
+        "attach(part, bbox, .5, 0, .5, .5, 1, .5)",
+        "attach(part, bbox, .5, 0, .5, .5, 0, .5)"
+      ],
+      "result": {
+        "part": {
+          "size": [
+            0.20000000298023224,
+            0.20000000298023224,
+            0.20000000298023224
+          ],
+          "center": [
+            0,
+            0.6000000238418579,
+            0
+          ]
+        }
+      },
+      "contact_point_residuals": [
+        1,
+        0
+      ]
+    }
+  ]
+}

package/docs/prototypes/shapeassembly-probe.py

@@ -0,0 +1,84 @@
+"""Independent research probe. Requires an external checkout; not product code.
+
+Usage: python shapeassembly-probe.py /path/to/ShapeAssembly
+No upstream source is copied or modified. No models are trained/downloaded.
+Reports observed behavior, not a claim that Figure or the paper is fully tested.
+"""
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+checkout = Path(sys.argv[1]).resolve()
+expected = 'cc22bd84afb65e8e37c7d14bebd9a4a629b5d943'
+revision = subprocess.check_output(['git', '-C', str(checkout), 'rev-parse', 'HEAD'], text=True).strip()
+if revision != expected:
+    raise RuntimeError(f'Expected {expected}, found {revision}')
+sys.path.insert(0, str(checkout / 'code'))
+import torch
+import numpy as np
+import faiss
+from ShapeAssembly import Program
+
+torch.set_num_threads(1)
+
+def point(p, name, xyz):
+    return p.cuboids[name].getPos(*(torch.tensor(float(v)) for v in xyz))
+
+def snapshot(p):
+    return {name: {'size': c.dims.tolist(), 'center': c.pos.tolist()}
+            for name, c in p.cuboids.items() if name != 'bbox'}
+
+def run(name, lines, contacts):
+    p = Program()
+    try:
+        for line in lines:
+            p.execute(line)
+        residuals = [float(torch.linalg.vector_norm(point(p,a,u)-point(p,b,v)))
+                     for a,u,b,v in contacts]
+        return {'case': name, 'lines': lines, 'result': snapshot(p),
+                'contact_point_residuals': residuals}
+    except Exception as exc:
+        return {'case': name, 'lines': lines, 'error': type(exc).__name__ + ': ' + str(exc)}
+
+results = []
+for height in [1, 2, 4]:
+    results.append(run(f'lamp_fresh_replay_height_{height}', [
+        f'bbox = Cuboid(4, {height}, 4, True)',
+        f'body = Cuboid(1, {height}, 1, True)',
+        'lamp = Cuboid(.2, .2, .2, True)',
+        'attach(body, bbox, .5, 0, .5, .5, 0, .5)',
+        'attach(lamp, body, .5, 0, .5, .5, 1, .5)'
+    ], [('lamp',(.5,0,.5),'body',(.5,1,.5))]))
+
+for aligned in ['True', 'False']:
+    for size in [.5, 2]:
+        results.append(run(f'squeeze_height_{size}_aligned_{aligned}', [
+            'bbox = Cuboid(1, 1, 1, True)',
+            f'beam = Cuboid(.2, {size}, .2, {aligned})',
+            'squeeze(beam, bbox, bbox, top, .5, .5)'
+        ], [('beam',(.5,1,.5),'bbox',(.5,1,.5)),
+            ('beam',(.5,0,.5),'bbox',(.5,0,.5))]))
+
+results.append(run('direct_resize_after_attachment', [
+    'bbox = Cuboid(4, 4, 4, True)',
+    'body = Cuboid(1, 1, 1, True)',
+    'lamp = Cuboid(.2, .2, .2, True)',
+    'attach(body, bbox, .5, 0, .5, .5, 0, .5)',
+    'attach(lamp, body, .5, 0, .5, .5, 1, .5)',
+    'body = Cuboid(1, 2, 1, True)'
+], [('lamp',(.5,0,.5),'body',(.5,1,.5))]))
+
+for reverse in [False, True]:
+    attach = ['attach(part, bbox, .5, 0, .5, .5, 0, .5)',
+              'attach(part, bbox, .5, 0, .5, .5, 1, .5)']
+    results.append(run(f'conflicting_same_point_reverse_{reverse}', [
+        'bbox = Cuboid(1, 1, 1, True)',
+        'part = Cuboid(.2, .2, .2, True)',
+        *(reversed(attach) if reverse else attach)
+    ], [('part',(.5,0,.5),'bbox',(.5,0,.5)),
+        ('part',(.5,0,.5),'bbox',(.5,1,.5))]))
+
+print(json.dumps({'revision': revision, 'python': sys.version,
+    'torch': torch.__version__, 'numpy': np.__version__, 'faiss': faiss.__version__,
+    'units': 'native abstract units, not Figure mm', 'results': results}, indent=2))

package/docs/prototypes/v3-asset-samples.mjs

@@ -0,0 +1,15 @@
+import * as dryroom from './v3-full-dryroom.mjs'
+import * as conveyor from './v3-full-conveyor.mjs'
+import * as robot from './v3-full-robot.mjs'
+import * as forklift from './v3-full-forklift.mjs'
+import {robotBinding,forkliftBindings} from './v3-capability-samples.mjs'
+export function sampleAsset(kind){
+ const modules={dryroom,conveyor,robot,forklift},sample=modules[kind]
+ if(!sample)throw Error('unknown sample')
+ const pair=kind==='robot'?robotBinding():kind==='forklift'?forkliftBindings():{model:sample.fullModel(),declaration:{version:'r3-capability-3',assetFrame:'world',bindings:[]}}
+ const designInputs={},stateDefaults={}
+ for(const i of pair.model.inputs)(i.role==='state'?stateDefaults:designInputs)[i.id]=sample.defaults[i.id]
+ return {version:'figure-v3-asset-experiment-1',name:sample.seed.type,document:{version:'figure-v3-prototype-1',model:pair.model,capabilities:pair.declaration},designInputs,stateDefaults,
+  palette:{'palette.primary':'#154473','palette.accent':'#f79c40','palette.neutral':'#96989b','palette.dark':'#27292c','palette.light':'#d6d7d9','palette.surface':'#56585b','palette.status-danger':'#f61b30','palette.status-warning':'#e68d1a','palette.status-info':'#158bde','palette.status-success':'#1cb648'},
+  appearance:sample.seed.parts.map(p=>({target:p.name,material:structuredClone(p.material??{token:'palette.neutral'}),...(p.primitive==='cylinder'?{segments:p.segments??8}:{}),...(p.capability?{legacyCapability:structuredClone(p.capability)}:{})}))}
+}

package/docs/prototypes/v3-asset-store.mjs

@@ -0,0 +1,52 @@
+// Single-process, isolated disk store. Not the product database or an authorization layer.
+import {readFile, open, rename, unlink} from 'node:fs/promises'
+import {join, resolve} from 'node:path'
+import {randomUUID, createHash} from 'node:crypto'
+import {parseAsset, serializeAsset} from './v3-asset.mjs'
+
+export class StoreError extends Error {
+ constructor(code,message){super(message);this.code=code}
+}
+const fail=(code,message)=>{throw new StoreError(code,message)}
+// Shared across store handles in this process; a multi-process deployment needs database CAS.
+const queues=new Map()
+async function exclusive(key,operation){
+ const previous=queues.get(key)||Promise.resolve()
+ const next=previous.catch(()=>{}).then(operation);queues.set(key,next)
+ try{return await next}finally{if(queues.get(key)===next)queues.delete(key)}
+}
+export function createAssetStore(directory){
+ const root=resolve(directory)
+ function file(scope,id){
+  for(const v of [scope,id])if(typeof v!=='string'||!v.trim()||v.length>200)fail('IDENTITY','scope and asset ID required')
+  return join(root,createHash('sha256').update(JSON.stringify([scope,id])).digest('hex')+'.json')
+ }
+ async function load(path,scope,id){
+  let raw;try{raw=await readFile(path,'utf8')}catch(e){if(e.code==='ENOENT')return null;throw e}
+  let record;try{record=JSON.parse(raw)}catch{fail('CORRUPT','stored record is not JSON')}
+  if(record?.format!=='v3-store-experiment-1'||record.scope!==scope||record.id!==id||typeof record.revision!=='string'||!record.revision)fail('CORRUPT','stored record identity or revision invalid')
+  // Stored content must pass the same semantic validation as incoming content.
+  parseAsset(record.text)
+  return record
+ }
+ return {
+  async read({scope,id}){const record=await load(file(scope,id),scope,id);if(!record)fail('NOT_FOUND','asset not found');return record},
+  async save({scope,id,expectedRevision,text}){
+   if(expectedRevision!==null&&(typeof expectedRevision!=='string'||!expectedRevision))fail('PRECONDITION','expectedRevision required; null means create only')
+   const path=file(scope,id),canonical=serializeAsset(parseAsset(text))
+   return exclusive(path,async()=>{
+    const current=await load(path,scope,id)
+    if((current?.revision??null)!==expectedRevision)fail('CONFLICT','asset changed; reload before saving')
+    const record={format:'v3-store-experiment-1',scope,id,revision:randomUUID(),text:canonical}
+    const temporary=path+'.'+randomUUID()+'.tmp';let handle
+    try{
+     handle=await open(temporary,'wx',0o600);await handle.writeFile(JSON.stringify(record));await handle.sync();await handle.close();handle=null
+     await rename(temporary,path)
+    }finally{
+     await handle?.close();await unlink(temporary).catch(e=>{if(e.code!=='ENOENT')throw e})
+    }
+    return record
+   })
+  }
+ }
+}

package/docs/prototypes/v3-asset-store.test.mjs

@@ -0,0 +1,59 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtemp,rm,readdir} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join} from 'node:path'
+import {execFile} from 'node:child_process'
+import {promisify} from 'node:util'
+import {createAssetStore} from './v3-asset-store.mjs'
+import {sampleAsset} from './v3-asset-samples.mjs'
+import {serializeAsset,parseAsset} from './v3-asset.mjs'
+import {createEditorWorkspace} from './v3-editor-workspace.mjs'
+async function fixture(t){const dir=await mkdtemp(join(tmpdir(),'v3-store-'));t.after(()=>rm(dir,{recursive:true,force:true}));return {dir,store:createAssetStore(dir)}}
+const body=()=>serializeAsset(sampleAsset('forklift'))
+const key={scope:'test-domain',id:'forklift'}
+test('disk save survives independent store handle; explicit create and scoped identity',async t=>{
+ const {dir,store}=await fixture(t),saved=await store.save({...key,expectedRevision:null,text:body()})
+ assert.deepEqual(await createAssetStore(dir).read(key),saved)
+ await assert.rejects(store.read({...key,scope:'other-domain'}),e=>e.code==='NOT_FOUND')
+ await assert.rejects(store.save({...key,expectedRevision:null,text:body()}),e=>e.code==='CONFLICT')
+ await assert.rejects(store.save({...key,text:body()}),e=>e.code==='PRECONDITION')
+ // Raw identifiers never become filesystem paths.
+ await store.save({scope:'../other',id:'../../escape',expectedRevision:null,text:body()})
+ assert.equal((await readdir(dir)).length,2)
+ assert.ok((await readdir(dir)).every(f=>/^[0-9a-f]{64}\.json$/.test(f)))
+})
+test('two writers cannot silently overwrite; content ABA still gets new revision',async t=>{
+ const {dir,store}=await fixture(t),a=await store.save({...key,expectedRevision:null,text:body()})
+ const asset=parseAsset(body());asset.designInputs.forkLength=1275;const changed=serializeAsset(asset)
+ const results=await Promise.allSettled([store,createAssetStore(dir)].map(s=>s.save({...key,expectedRevision:a.revision,text:changed})))
+ assert.equal(results.filter(r=>r.status==='fulfilled').length,1)
+ assert.equal(results.find(r=>r.status==='rejected').reason.code,'CONFLICT')
+ const b=await store.read(key),c=await store.save({...key,expectedRevision:b.revision,text:body()})
+ assert.notEqual(c.revision,a.revision)
+ await assert.rejects(store.save({...key,expectedRevision:a.revision,text:changed}),e=>e.code==='CONFLICT')
+})
+test('invalid source leaves prior snapshot intact and produces no temporary file',async t=>{
+ const {dir,store}=await fixture(t),a=await store.save({...key,expectedRevision:null,text:body()})
+ await assert.rejects(store.save({...key,expectedRevision:a.revision,text:'{"version":2}'}))
+ assert.deepEqual(await store.read(key),a);assert.equal((await readdir(dir)).length,1)
+})
+test('failed persistence does not clear editor dirty state',async t=>{
+ const {store}=await fixture(t),original=await store.save({...key,expectedRevision:null,text:body()})
+ const w=createEditorWorkspace(),v=w.open(original.text)
+ w.apply({context:v.context,origin:'ui',expectedRevision:0,changes:[{kind:'set-design',input:'forkLength',unit:'mm',value:1275}]})
+ const snapshot=w.export({context:v.context})
+ await store.save({...key,expectedRevision:original.revision,text:body()})
+ await assert.rejects(store.save({...key,expectedRevision:original.revision,text:snapshot.text}),e=>e.code==='CONFLICT')
+ assert.equal(w.read().dirty,true)
+ assert.equal(w.read().fields.find(f=>f.id==='forkLength').value,1275)
+})
+test('a separate Node process can restore the saved asset without editor memory',async t=>{
+ const {dir,store}=await fixture(t),asset=parseAsset(body());asset.designInputs.forkLength=1275
+ const saved=await store.save({...key,expectedRevision:null,text:serializeAsset(asset)})
+ const script=`import {createAssetStore} from ${JSON.stringify(new URL('./v3-asset-store.mjs',import.meta.url).href)};
+ const record=await createAssetStore(process.argv[1]).read(${JSON.stringify(key)});
+ console.log(JSON.stringify({revision:record.revision,length:JSON.parse(record.text).designInputs.forkLength}));`
+ const {stdout}=await promisify(execFile)(process.execPath,['--input-type=module','-e',script,dir])
+ assert.deepEqual(JSON.parse(stdout),{revision:saved.revision,length:1275})
+})

package/docs/prototypes/v3-asset.mjs

@@ -0,0 +1 @@
+export {compileV3Asset as compileAsset,parseV3Asset as parseAsset,serializeV3Asset as serializeAsset,captureV3AuthoredInputs as captureAuthoredInputs} from '../../src/v3-asset.ts'

package/docs/prototypes/v3-asset.schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Experimental V3 asset envelope; not a complete V2 migration contract",
+  "type": "object", "additionalProperties": false,
+  "required": ["version", "name", "document", "designInputs", "stateDefaults", "palette", "appearance"],
+  "properties": {
+    "version": {"const": "figure-v3-asset-experiment-1"},
+    "name": {"type": "string", "minLength": 1},
+    "document": {"$ref": "v3-document.schema.json"},
+    "designInputs": {"type": "object", "additionalProperties": {"type": "number"}},
+    "stateDefaults": {"type": "object", "additionalProperties": {"type": "number"}},
+    "palette": {"type": "object", "additionalProperties": {"type": "string", "pattern": "^#[0-9a-fA-F]{6}$"}},
+    "appearance": {"type": "array", "items": {"$ref": "#/definitions/appearance"}}
+  },
+  "definitions": {
+    "appearance": {
+      "type": "object", "additionalProperties": false, "required": ["target", "material"],
+      "properties": {
+        "target": {"type": "string", "minLength": 1},
+        "segments": {"enum": [8,12,16,24,32,48]},
+        "legacyCapability": {
+          "type": "object", "additionalProperties": false, "required": ["roles", "accepts", "capacity"],
+          "properties": {
+            "roles": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+            "accepts": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+            "capacity": {"type": "integer", "minimum": 1, "maximum": 9007199254740991}
+          }
+        },
+        "material": {
+          "type": "object", "additionalProperties": false, "required": ["token"],
+          "properties": {
+            "token": {"type": "string", "minLength": 1},
+            "preset": {"enum": ["default", "metal", "glass", "plastic", "wood", "ceramic", "rubber"]},
+            "transparent": {"type": "boolean"},
+            "emissive": {
+              "type": "object", "additionalProperties": false, "required": ["token", "intensity", "on"],
+              "properties": {"token": {"type": "string", "minLength": 1}, "intensity": {"type": "number", "minimum": 0, "maximum": 5}, "on": {"type": "boolean"}}
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/docs/prototypes/v3-asset.test.mjs

@@ -0,0 +1,68 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {compileAsset,serializeAsset,parseAsset,captureAuthoredInputs} from './v3-asset.mjs'
+import {sampleAsset} from './v3-asset-samples.mjs'
+import {createAuthoringSession} from './v3-authoring-session.mjs'
+import * as dryroom from './v3-full-dryroom.mjs'
+import * as conveyor from './v3-full-conveyor.mjs'
+import * as robot from './v3-full-robot.mjs'
+import * as forklift from './v3-full-forklift.mjs'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import Ajv from '../../../things-factory/node_modules/ajv/lib/ajv.js'
+const samples={dryroom,conveyor,robot,forklift}
+test('four complete sample assets round-trip: geometry, bindings, materials, quality and palette',()=>{
+ for(const [kind,sample] of Object.entries(samples)){
+  const asset=sampleAsset(kind),text=serializeAsset(asset),restored=parseAsset(text),a=compileAsset(asset).evaluate(),b=compileAsset(restored).evaluate()
+  assert.deepEqual(restored,asset);assert.deepEqual(a,b)
+  const expected=sample.evaluateFull()
+  for(const g of b.geometry){const source=expected.find(x=>x.id===g.id);assert.ok(source);assert.deepEqual(g.shape,source.shape);assert.deepEqual(g.pose,source.pose);assert.deepEqual(g.material,source.material);if(g.shape.provider==='cylinder')assert.equal(g.segments,source.segments??sample.seed.parts.find(p=>p.name===g.id)?.segments??16)}
+  console.log({asset:kind,bytes:Buffer.byteLength(text),meshes:b.geometry.length})
+ }
+ const r=compileAsset(parseAsset(serializeAsset(sampleAsset('robot')))).evaluate()
+ assert.deepEqual(r.geometry.find(g=>g.id==='tool-seat').legacyCapability,robot.seed.parts.find(p=>p.name==='tool-seat').capability)
+})
+test('save edited design but reset transient motion unless explicitly captured as defaults',()=>{
+ const asset=sampleAsset('forklift'),session=createAuthoringSession(asset.document,{...asset.designInputs,...asset.stateDefaults})
+ session.apply({origin:'ai',expectedRevision:0,changes:[{kind:'set-design',input:'forkLength',unit:'mm',value:1275},{kind:'set-state',input:'lift',unit:'mm',value:1000}]})
+ const saved=captureAuthoredInputs(asset,session.read().inputs),r=compileAsset(parseAsset(serializeAsset(saved))).evaluate()
+ assert.equal(r.inputs.forkLength,1275);assert.equal(r.inputs.lift,0)
+ assert.equal(r.bindings[0].pose.t[1],57)
+ const captured=captureAuthoredInputs(asset,session.read().inputs,{captureStateDefaults:true})
+ assert.equal(compileAsset(parseAsset(serializeAsset(captured))).evaluate().bindings[0].pose.t[1],1057)
+ assert.equal(asset.designInputs.forkLength,850);assert.equal(asset.stateDefaults.lift,0)
+})
+test('saved repeat appearance applies to every new occurrence after dimension edit',()=>{
+ const a=sampleAsset('conveyor');a.designInputs.length=4800
+ const r=compileAsset(parseAsset(serializeAsset(a))).evaluate({angle:37}),rollers=r.geometry.filter(g=>g.key)
+ assert.equal(rollers.length,30);assert.ok(rollers.every(g=>g.segments===12&&g.material.preset==='metal'))
+})
+test('unknown or missing appearance, unresolved palette, invalid quality and mismatched inputs reject',()=>{
+ const edits=[a=>a.appearance.pop(),a=>a.appearance.push(a.appearance[0]),a=>a.appearance[0].target='missing',a=>delete a.palette['palette.primary'],a=>a.appearance.find(x=>x.segments).segments=13,a=>a.designInputs.lift=1,a=>delete a.stateDefaults.lift,a=>a.stateDefaults.lift=2001,a=>a.appearance[0].material.extra=true]
+ for(const edit of edits){const a=sampleAsset('forklift');edit(a);assert.throws(()=>serializeAsset(a))}
+})
+test('runtime cannot override design or mutate saved defaults through returned data',()=>{
+ const asset=sampleAsset('forklift'),p=compileAsset(asset),first=p.evaluate()
+ assert.throws(()=>p.evaluate({forkLength:1700}))
+ first.palette['palette.primary']='#000000';first.geometry[0].material.token='invalid';asset.designInputs.forkLength=0
+ assert.equal(p.evaluate().inputs.forkLength,850);assert.equal(p.evaluate().palette['palette.primary'],'#154473')
+})
+test('asset parser retains duplicate-key and invalid JSON protections',()=>{
+ const text=serializeAsset(sampleAsset('robot'))
+ assert.throws(()=>parseAsset('{"version":"fake",'+text.slice(1)),e=>e.code==='JSON_DUPLICATE_KEY')
+ assert.throws(()=>parseAsset(text.slice(0,-1)),e=>e.code==='JSON_SYNTAX')
+ const a=sampleAsset('forklift');a.stateDefaults.lift=NaN;assert.throws(()=>serializeAsset(a),e=>e.code==='JSON_VALUE')
+})
+test('schema validation and real temporary JSON file round-trip, without seed lookups on reload',async()=>{
+ const ajv=new Ajv({allErrors:true});ajv.addSchema(JSON.parse(await fs.readFile(new URL('./v3-document.schema.json',import.meta.url))),'v3-document.schema.json')
+ const validate=ajv.compile(JSON.parse(await fs.readFile(new URL('./v3-asset.schema.json',import.meta.url))))
+ const directory=await fs.mkdtemp(path.join(os.tmpdir(),'figure-v3-asset-'))
+ try{
+  for(const kind of Object.keys(samples)){
+   const asset=sampleAsset(kind);assert.ok(validate(asset),JSON.stringify(validate.errors))
+   const file=path.join(directory,kind+'.json')
+   try{await fs.writeFile(file,serializeAsset(asset),'utf8');const loaded=parseAsset(await fs.readFile(file,'utf8'));assert.deepEqual(compileAsset(loaded).evaluate(),compileAsset(asset).evaluate())}finally{await fs.unlink(file).catch(()=>{})}
+  }
+ }finally{await fs.rmdir(directory)}
+})

package/docs/prototypes/v3-authoring-session.mjs

@@ -0,0 +1 @@
+export {createV3AuthoringSession as createAuthoringSession} from '../../src/v3-authoring-session.ts'