@pioneer_zmc/dsh-workbench 0.2.1

package/web/assets/furniture/assets/fairy-table-lamp-01/model.js

@@ -0,0 +1,182 @@
+// 林间暖光台灯：自制程序化候选模型，不依赖 DOM、网络或实验文件。
+// 米制、+Y 向上、+Z 正面；底面中心原点。沿用占位台灯空间契约（X±0.12、Y0–0.42、Z±0.15）。
+// 设计剖面（检查按此独立手算）：灯罩外半轴底(0.104,0.138)→顶(0.080,0.106)、Y 0.242→0.398，
+// 壁厚 0.006；罩中部 Y=0.32 处外半轴 0.092、内半轴 0.086。灯杆中轴贯穿；支架自
+// 灯头套环(r0.0185,Y0.310)伸至顶口内缘(0.074,0.100,Y0.3985)。
+import * as THREE from 'three';
+
+function woodTexture() {
+  const size = 256;
+  const data = new Uint8Array(size * size * 4);
+  let seed = 20260930;
+  const random = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed / 4294967296; };
+  for (let v = 0; v < size; v++) for (let u = 0; u < size; u++) {
+    // 细木纹沿 U 延伸，供小底座近看；低对比，不做节疤。
+    const wave = v + 1.4 * Math.sin(u * 0.031) + 0.5 * Math.sin(u * 0.083);
+    const tone = 208 + 4 * Math.sin(wave * 0.55) + 2 * Math.sin(wave * 1.9) + (random() - 0.5) * 2.5;
+    const i = (v * size + u) * 4;
+    data[i] = tone; data[i + 1] = tone - 24; data[i + 2] = tone - 58; data[i + 3] = 255;
+  }
+  const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+  texture.magFilter = THREE.LinearFilter;
+  texture.minFilter = THREE.LinearMipmapLinearFilter;
+  texture.generateMipmaps = true;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+function fabricTexture() {
+  const size = 256;
+  const data = new Uint8Array(size * size * 4);
+  let seed = 20260931;
+  const random = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed / 4294967296; };
+  for (let v = 0; v < size; v++) for (let u = 0; u < size; u++) {
+    // 暖米色低对比细布纹：经纬轻起伏加细噪，不出现条纹或大花色。
+    const weave = 1.6 * Math.sin(u * 0.246) + 1.4 * Math.sin(v * 0.212) + 1.1 * Math.sin((u + v) * 0.147) + (random() - 0.5) * 2.2;
+    const tone = 224 + weave;
+    const i = (v * size + u) * 4;
+    data[i] = tone + 6; data[i + 1] = tone - 4; data[i + 2] = tone - 26; data[i + 3] = 255;
+  }
+  const texture = new THREE.DataTexture(data, size, size, THREE.RGBAFormat);
+  texture.colorSpace = THREE.SRGBColorSpace;
+  texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+  texture.magFilter = THREE.LinearFilter;
+  texture.minFilter = THREE.LinearMipmapLinearFilter;
+  texture.generateMipmaps = true;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+// 椭圆环带侧壁：相邻环之间张成真实曲面（自下而上排列），outward 决定法线朝外或朝轴。
+function ellipseWall(rings, segments, outward, uRepeat) {
+  const positions = [], uvs = [], indices = [];
+  const ringIds = rings.map((ring, level) => {
+    const ids = [];
+    for (let i = 0; i < segments; i++) {
+      const t = i / segments * Math.PI * 2;
+      const id = positions.length / 3;
+      positions.push(ring[0] * Math.cos(t), ring[1], ring[2] * Math.sin(t));
+      uvs.push(i / segments * uRepeat, level / (rings.length - 1));
+      ids.push(id);
+    }
+    return ids;
+  });
+  for (let level = 0; level < rings.length - 1; level++) for (let i = 0; i < segments; i++) {
+    const j = (i + 1) % segments;
+    const A = ringIds[level][i], B = ringIds[level][j], C = ringIds[level + 1][j], D = ringIds[level + 1][i];
+    if (outward) indices.push(A, C, B, A, D, C); else indices.push(A, B, C, A, C, D);
+  }
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+  geometry.setIndex(indices);
+  geometry.computeVertexNormals();
+  return geometry;
+}
+
+// 椭圆扁平环（包边）：外缘到内缘的真实窄带，up 决定法线朝上或朝下。
+function annulus(y, aO, bO, aI, bI, segments, up) {
+  const positions = [], uvs = [], indices = [];
+  const ringOf = (a, b) => { const ids = []; for (let i = 0; i < segments; i++) {
+    const t = i / segments * Math.PI * 2;
+    const id = positions.length / 3;
+    positions.push(a * Math.cos(t), y, b * Math.sin(t));
+    uvs.push(a * Math.cos(t) / 0.3 + 0.5, b * Math.sin(t) / 0.3 + 0.5);
+    ids.push(id);
+  } return ids; };
+  const outer = ringOf(aO, bO), inner = ringOf(aI, bI);
+  for (let i = 0; i < segments; i++) {
+    const j = (i + 1) % segments;
+    if (up) indices.push(outer[i], inner[i], outer[j], inner[i], inner[j], outer[j]);
+    else indices.push(outer[i], outer[j], inner[i], inner[i], outer[j], inner[j]);
+  }
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+  geometry.setIndex(indices);
+  geometry.computeVertexNormals();
+  return geometry;
+}
+
+// 圆盘（底座上下封板）：真实封板，不是悬空轮廓。
+function disc(y, r, segments, up) {
+  const positions = [], uvs = [], indices = [];
+  const center = positions.length / 3;
+  positions.push(0, y, 0); uvs.push(0.5, 0.5);
+  const ring = [];
+  for (let i = 0; i < segments; i++) {
+    const t = i / segments * Math.PI * 2;
+    const id = positions.length / 3;
+    positions.push(r * Math.cos(t), y, r * Math.sin(t));
+    uvs.push(Math.cos(t) * 0.5 + 0.5, Math.sin(t) * 0.5 + 0.5);
+    ring.push(id);
+  }
+  for (let i = 0; i < segments; i++) {
+    const j = (i + 1) % segments;
+    if (up) indices.push(center, ring[j], ring[i]); else indices.push(center, ring[i], ring[j]);
+  }
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+  geometry.setIndex(indices);
+  geometry.computeVertexNormals();
+  return geometry;
+}
+
+export function createFairyTableLamp() {
+  const group = new THREE.Group();
+  group.name = 'fairy-table-lamp-01';
+  const owned = new Set();
+  const keep = resource => { owned.add(resource); return resource; };
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    group.removeFromParent();
+    for (const resource of owned) resource.dispose();
+    owned.clear(); group.clear();
+  };
+  try {
+    const wood = keep(woodTexture());
+    const cloth = keep(fabricTexture());
+    const honey = keep(new THREE.MeshStandardMaterial({ map: wood, bumpMap: wood, bumpScale: 0.0015, roughness: 0.66, metalness: 0.01 }));
+    const brass = keep(new THREE.MeshStandardMaterial({ color: '#c19a5e', metalness: 0.7, roughness: 0.34 }));
+    const fabric = keep(new THREE.MeshStandardMaterial({ map: cloth, bumpMap: cloth, bumpScale: 0.0012, roughness: 0.94 }));
+    const lining = keep(new THREE.MeshStandardMaterial({ color: '#f2e3c2', roughness: 0.97 }));
+    const trim = keep(new THREE.MeshStandardMaterial({ color: '#d9c49c', roughness: 0.88 }));
+    const glow = keep(new THREE.MeshStandardMaterial({ color: '#ffe7c4', emissive: '#ffb46a', emissiveIntensity: 0.5, roughness: 0.4 }));
+    const add = (geometry, material, x, y, z, name) => {
+      const mesh = new THREE.Mesh(keep(geometry), material);
+      mesh.name = name; mesh.position.set(x, y, z); mesh.castShadow = mesh.receiveShadow = true;
+      group.add(mesh); return mesh;
+    };
+    // 低矮圆润蜂蜜木底座：下盘触地 Y=0，侧壁上收出柔和圆肩，顶盘承接黄铜套环。
+    add(disc(0, 0.0905, 40, false), honey, 0, 0, 0, '底座下盘');
+    add(ellipseWall([[0.0905, 0, 0.0905], [0.0905, 0.028, 0.0905], [0.088, 0.0325, 0.088], [0.0825, 0.035, 0.0825]], 40, true, 3), honey, 0, 0, 0, '底座侧壁');
+    add(disc(0.035, 0.0825, 40, true), honey, 0, 0, 0, '底座顶盘');
+    const leaf = add(new THREE.SphereGeometry(1, 12, 6), brass, 0, 0.0175, 0.0885, '黄铜叶纹嵌片');
+    leaf.scale.set(0.024, 0.009, 0.004); leaf.rotation.z = 0.35;
+    // 黄铜灯杆经两道套环真实连接底座与灯头，罩、杆都不悬浮。
+    add(new THREE.CylinderGeometry(0.017, 0.019, 0.016, 14), brass, 0, 0.041, 0, '底座黄铜套环');
+    add(new THREE.CylinderGeometry(0.0095, 0.0095, 0.254, 10), brass, 0, 0.173, 0, '灯杆');
+    add(new THREE.CylinderGeometry(0.0185, 0.0185, 0.016, 14), brass, 0, 0.305, 0, '灯头黄铜套环');
+    add(new THREE.CylinderGeometry(0.0155, 0.0155, 0.035, 12), brass, 0, 0.3285, 0, '灯座');
+    add(new THREE.SphereGeometry(0.030, 16, 12), glow, 0, 0.358, 0, '灯泡');
+    // 三根细支架从灯头套环伸向罩顶内缘，灯罩由此真实承托；上下口保持敞开。
+    for (const degree of [30, 150, 270]) {
+      const t = degree * Math.PI / 180, c = Math.cos(t), s = Math.sin(t);
+      const from = new THREE.Vector3(0.0185 * c, 0.310, 0.0185 * s);
+      const to = new THREE.Vector3(0.074 * c, 0.3985, 0.100 * s);
+      const strut = add(new THREE.BoxGeometry(0.008, from.distanceTo(to), 0.008), brass, (from.x + to.x) / 2, (from.y + to.y) / 2, (from.z + to.z) / 2, '灯罩支架');
+      strut.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), to.clone().sub(from).normalize());
+    }
+    // 微锥布灯罩：外壁、内衬与上下薄包边各有真实几何与厚度，上下开口。
+    add(ellipseWall([[0.104, 0.242, 0.138], [0.080, 0.398, 0.106]], 48, true, 4), fabric, 0, 0, 0, '灯罩外壁');
+    add(ellipseWall([[0.098, 0.242, 0.132], [0.074, 0.398, 0.100]], 48, false, 1), lining, 0, 0, 0, '灯罩内衬');
+    add(annulus(0.398, 0.080, 0.106, 0.074, 0.100, 48, true), trim, 0, 0, 0, '上包边');
+    add(annulus(0.242, 0.104, 0.138, 0.098, 0.132, 48, false), trim, 0, 0, 0, '下包边');
+    return { group, dispose };
+  } catch (error) { dispose(); throw error; }
+}

package/web/assets/furniture/catalog.js

@@ -0,0 +1,137 @@
+// 家具资产目录统一读取（E4b-1）：index.json（人工维护的总索引，不复制资产字段）→
+// 各资产包 asset.json（单件说明的唯一可编辑来源）→ 一个可被 rooms/placement.js 与
+// rooms/bindings.js 直接消费的目录。纯数据层：不加载模型、不读业务资料、不预取预览图、
+// 不碰 Three；空间精确约束仍归 placement、动作与文档身份仍归 bindings，这里不复制第二套
+// 算法，load 成功也不等于任意布局合法。fetchJson 由调用者注入（可衔接页面既有 JSON 读取器）。
+import { hasFurnitureModel } from './registry.js';
+
+const INDEX_URL = '/specdev-workbench/assets/furniture/index.json';
+const ROOT_PREFIX = '/specdev-workbench/assets/furniture/';
+const ASSET_ID_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const RESERVED_ASSET_KEYS = ['constructor', 'toString', '__proto__'];
+
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isNonEmptyString = (value) => typeof value === 'string' && value !== '';
+const typeName = (value) => (value === null ? 'null' : Array.isArray(value) ? '数组' : typeof value);
+const describe = (value) => {
+  try { const text = JSON.stringify(value); return text === undefined ? String(value) : text; } catch { return String(value); }
+};
+const reasonOf = (error) => (error instanceof Error ? error.message : String(error));
+const deepCopyOfJson = (value) => JSON.parse(JSON.stringify(value));
+const diag = (code, message, fieldPath) => ({ code, message, fieldPath });
+const failure = (code, message, fieldPath) => ({ ok: false, diagnostics: [diag(code, message, fieldPath)], catalog: null });
+
+/** 完整校验索引结构；合格返回 { leafTypes, entries }，否则返回 { problem }（调用方此时不得发任何元数据请求）。 */
+function validateIndex(index) {
+  if (!isObject(index)) return { problem: diag('LIBRARY_INDEX', `索引必须是 JSON 对象（实际是 ${typeName(index)}）`, 'index') };
+  if (index.schemaVersion !== 1) return { problem: diag('LIBRARY_INDEX', `索引 schemaVersion 必须为 1（实际 ${describe(index.schemaVersion)}）`, 'index.schemaVersion') };
+  if (!Array.isArray(index.categories)) return { problem: diag('LIBRARY_INDEX', `索引 categories 必须是数组（实际是 ${typeName(index.categories)}）`, 'index.categories') };
+  if (!Array.isArray(index.assets)) return { problem: diag('LIBRARY_INDEX', `索引 assets 必须是数组（实际是 ${typeName(index.assets)}）`, 'index.assets') };
+  const leafTypes = new Map(); // 叶类型 → 所属大类 id（分类保存在数据里，不作为路径一部分）
+  const categoryIds = new Set();
+  for (const [position, category] of index.categories.entries()) {
+    const at = `index.categories[${position}]`;
+    if (!isObject(category)) return { problem: diag('LIBRARY_INDEX', `分类条目必须是对象（${at} 实际是 ${typeName(category)}）`, at) };
+    if (!isNonEmptyString(category.id)) return { problem: diag('LIBRARY_INDEX', `分类 id 必须是非空字符串（实际 ${describe(category.id)}）`, `${at}.id`) };
+    if (categoryIds.has(category.id)) return { problem: diag('LIBRARY_INDEX', `分类 id 重复登记：${category.id}`, `${at}.id`) };
+    categoryIds.add(category.id);
+    if (!isNonEmptyString(category.name)) return { problem: diag('LIBRARY_INDEX', `分类 ${category.id} 的 name 必须是非空字符串`, `${at}.name`) };
+    if (!Array.isArray(category.types) || category.types.length === 0 || !category.types.every(isNonEmptyString)) {
+      return { problem: diag('LIBRARY_INDEX', `分类 ${category.id} 的 types 必须是非空字符串组成的非空数组（实际 ${describe(category.types)}）`, `${at}.types`) };
+    }
+    for (const type of category.types) {
+      if (leafTypes.has(type)) return { problem: diag('LIBRARY_INDEX', `叶类型 ${type} 重复登记（同时出现在 ${leafTypes.get(type)} 与 ${category.id}）`, `${at}.types`) };
+      leafTypes.set(type, category.id);
+    }
+  }
+  const entries = [];
+  const seenIds = new Set();
+  for (const [position, entry] of index.assets.entries()) {
+    const at = `index.assets[${position}]`;
+    if (!isObject(entry)) return { problem: diag('LIBRARY_INDEX', `资产索引条目必须是对象（${at} 实际是 ${typeName(entry)}）`, at) };
+    const { assetId, metadataRef } = entry;
+    if (!isNonEmptyString(assetId) || !ASSET_ID_PATTERN.test(assetId) || RESERVED_ASSET_KEYS.includes(assetId)) {
+      return { problem: diag('LIBRARY_INDEX', `assetId 必须匹配 ${ASSET_ID_PATTERN} 且不得是保留键（实际 ${describe(assetId)}）`, `${at}.assetId`) };
+    }
+    if (seenIds.has(assetId)) return { problem: diag('LIBRARY_INDEX', `assetId 重复登记：${assetId}`, `${at}.assetId`) };
+    seenIds.add(assetId);
+    if (typeof metadataRef !== 'string' || metadataRef !== `assets/${assetId}/asset.json`) {
+      return { problem: diag('LIBRARY_INDEX', `${assetId} 的 metadataRef 必须严格等于 assets/${assetId}/asset.json（实际 ${describe(metadataRef)}），不接受绝对路径、外部地址、编码绕行、反斜线、查询串或 ../`, `${at}.metadataRef`) };
+    }
+    entries.push({ assetId, metadataRef });
+  }
+  return { leafTypes, entries };
+}
+
+/** 校验单份资产说明的管理信息，返回首个 { field, message } 或 null。空间字段只查形态存在，精确约束由 placement 负责。 */
+function validateAsset(asset, expectedId, leafTypes) {
+  if (!isObject(asset)) return { field: '', message: `资产说明必须是 JSON 对象（实际是 ${typeName(asset)}）` };
+  const problems = [
+    [asset.schemaVersion !== 1, 'schemaVersion', `schemaVersion 必须为 1（实际 ${describe(asset.schemaVersion)}）`],
+    [!Number.isSafeInteger(asset.assetVersion) || asset.assetVersion <= 0, 'assetVersion', `assetVersion 必须是正的安全整数（实际 ${describe(asset.assetVersion)}）`],
+    [asset.status !== 'internal', 'status', `status 目前只接受 internal，内部登记不代表发布（实际 ${describe(asset.status)}）`],
+    [asset.assetId !== expectedId, 'assetId', `assetId 必须与索引一致（索引 ${expectedId}，实际 ${describe(asset.assetId)}）`],
+    [!isNonEmptyString(asset.category) || !leafTypes.has(asset.category), 'category', `category 必须是索引中已登记的叶类型（实际 ${describe(asset.category)}）`],
+    [!isNonEmptyString(asset.modelRef), 'modelRef', 'modelRef 必须是非空字符串'],
+    [isNonEmptyString(asset.modelRef) && !hasFurnitureModel(asset.modelRef), 'modelRef', `modelRef 未在模型注册表登记，属未知模型：${describe(asset.modelRef)}`],
+    [!isNonEmptyString(asset.name), 'name', 'name 必须是非空字符串'],
+    [!isNonEmptyString(asset.description), 'description', 'description 必须是非空字符串'],
+    [!Array.isArray(asset.styleIds) || asset.styleIds.length === 0 || !asset.styleIds.every(isNonEmptyString), 'styleIds', `styleIds 必须是非空字符串组成的非空数组（实际 ${describe(asset.styleIds)}）`],
+    [!isObject(asset.recommendations) || !isNonEmptyString(asset.recommendations.note), 'recommendations.note', 'recommendations.note 必须是非空字符串'],
+    [!isObject(asset.source) || !isNonEmptyString(asset.source.origin) || !isNonEmptyString(asset.source.license) || !isNonEmptyString(asset.source.note), 'source', 'source 的 origin／license／note 都必须是非空字符串'],
+    [asset.placeholder !== false, 'placeholder', `正式家具目录只收非占位资产，placeholder 必须为 false（实际 ${describe(asset.placeholder)}）`],
+    [asset.previewRef !== null && asset.previewRef !== `assets/${expectedId}/preview.webp`, 'previewRef', `previewRef 只能是 null 或严格等于 assets/${expectedId}/preview.webp（实际 ${describe(asset.previewRef)}）`],
+    [!isObject(asset.bounds), 'bounds', 'bounds 必须是对象（精确空间约束由 placement 校验）'],
+    [!isObject(asset.placement), 'placement', 'placement 必须是对象（精确空间约束由 placement 校验）'],
+    [!Array.isArray(asset.clearanceBoxes), 'clearanceBoxes', 'clearanceBoxes 必须是数组'],
+    [!Array.isArray(asset.surfaces), 'surfaces', 'surfaces 必须是数组'],
+    [!Array.isArray(asset.capabilities), 'capabilities', 'capabilities 必须是数组'],
+    [!(asset.approachPoint === null || isObject(asset.approachPoint)), 'approachPoint', 'approachPoint 必须是对象或 null'],
+  ];
+  for (const [broken, field, message] of problems) if (broken) return { field, message };
+  return null;
+}
+
+/**
+ * 读取统一家具目录：先读并完整校验 index.json（失败不发任何元数据请求），合格后按索引
+ * 顺序读取各资产 asset.json；任一资产读取或校验失败则整次失败，不静默跳过坏资产。
+ * @param {{ fetchJson: (url: string) => Promise<unknown> }} options 调用者注入的异步 JSON 读取器。
+ * @returns {Promise<{ ok: boolean,
+ *             diagnostics: Array<{ code: string, message: string, fieldPath: string }>,
+ *             catalog: { schemaVersion: 1, assets: object[] } | null }>}
+ *   成功时 assets 为按索引顺序的资产深拷贝（调用者改动不污染下次读取，输入对象也不被改写）；
+ *   失败时 catalog=null，code 取 LIBRARY_INPUT／LIBRARY_READ／LIBRARY_INDEX／LIBRARY_ASSET。
+ */
+export async function loadFurnitureCatalog(options) {
+  if (!isObject(options) || typeof options.fetchJson !== 'function') {
+    return failure('LIBRARY_INPUT', `参数必须是包含函数 fetchJson 的对象（参数实际是 ${typeName(options)}，fetchJson 实际是 ${isObject(options) ? typeName(options.fetchJson) : '缺失'}，不发请求）`, 'fetchJson');
+  }
+  const { fetchJson } = options;
+
+  let index;
+  try {
+    index = await fetchJson(INDEX_URL);
+  } catch (error) {
+    return failure('LIBRARY_READ', `读取家具索引失败：${INDEX_URL}（原因：${reasonOf(error)}）`, 'index');
+  }
+
+  const validated = validateIndex(index);
+  if (validated.problem) return { ok: false, diagnostics: [validated.problem], catalog: null };
+
+  const assets = [];
+  for (const { assetId, metadataRef } of validated.entries) {
+    const url = ROOT_PREFIX + metadataRef;
+    let asset;
+    try {
+      asset = await fetchJson(url);
+    } catch (error) {
+      return failure('LIBRARY_READ', `读取资产说明失败：${url}（原因：${reasonOf(error)}）`, `assets[${assetId}]`);
+    }
+    const problem = validateAsset(asset, assetId, validated.leafTypes);
+    if (problem) {
+      return failure('LIBRARY_ASSET', `资产 ${assetId} 的${problem.field ? ` ${problem.field} ` : ''}有问题：${problem.message}`, `assets[${assetId}]${problem.field ? '.' + problem.field : ''}`);
+    }
+    assets.push(deepCopyOfJson(asset)); // 有效 JSON 深拷贝：不改写 fetchJson 的输入，返回目录与输入脱钩
+  }
+  return { ok: true, diagnostics: [], catalog: { schemaVersion: 1, assets } };
+}

package/web/assets/furniture/index.json

@@ -0,0 +1,110 @@
+{
+  "schemaVersion": 1,
+  "categories": [
+    {
+      "id": "storage",
+      "name": "收纳",
+      "types": [
+        "shelf",
+        "cabinet",
+        "chest"
+      ]
+    },
+    {
+      "id": "tables",
+      "name": "桌台",
+      "types": [
+        "desk",
+        "table",
+        "display-stand"
+      ]
+    },
+    {
+      "id": "seating-sleeping",
+      "name": "坐卧",
+      "types": [
+        "chair",
+        "sofa",
+        "bed"
+      ]
+    },
+    {
+      "id": "lighting",
+      "name": "照明",
+      "types": [
+        "lamp",
+        "floor-lamp",
+        "wall-lamp"
+      ]
+    },
+    {
+      "id": "decoration",
+      "name": "装饰",
+      "types": [
+        "vase",
+        "picture",
+        "plant",
+        "ornament"
+      ]
+    },
+    {
+      "id": "signage",
+      "name": "展示标识",
+      "types": [
+        "notice-board",
+        "sign",
+        "display-screen"
+      ]
+    }
+  ],
+  "assets": [
+    {
+      "assetId": "fairy-bookshelf-01",
+      "metadataRef": "assets/fairy-bookshelf-01/asset.json"
+    },
+    {
+      "assetId": "fairy-desk-01",
+      "metadataRef": "assets/fairy-desk-01/asset.json"
+    },
+    {
+      "assetId": "fairy-table-lamp-01",
+      "metadataRef": "assets/fairy-table-lamp-01/asset.json"
+    },
+    {
+      "assetId": "fairy-notice-board-01",
+      "metadataRef": "assets/fairy-notice-board-01/asset.json"
+    },
+    {
+      "assetId": "ceramic-display-stand-01",
+      "metadataRef": "assets/ceramic-display-stand-01/asset.json"
+    },
+    {
+      "assetId": "ceramic-vase-01",
+      "metadataRef": "assets/ceramic-vase-01/asset.json"
+    },
+    {
+      "assetId": "fairy-potted-plant-01",
+      "metadataRef": "assets/fairy-potted-plant-01/asset.json"
+    },
+    {
+      "assetId": "fairy-book-stack-01",
+      "metadataRef": "assets/fairy-book-stack-01/asset.json"
+    },
+    {
+      "assetId": "fairy-bed-01",
+      "metadataRef": "assets/fairy-bed-01/asset.json"
+    },
+    {
+      "assetId": "fairy-reading-chair-01",
+      "metadataRef": "assets/fairy-reading-chair-01/asset.json"
+    },
+    {
+      "assetId": "ceramic-low-cabinet-01",
+      "metadataRef": "assets/ceramic-low-cabinet-01/asset.json"
+    },
+    {
+      "assetId": "ceramic-floor-lamp-01",
+      "metadataRef": "assets/ceramic-floor-lamp-01/asset.json"
+    }
+  ]
+}

package/web/assets/furniture/registry.js

@@ -0,0 +1,72 @@
+// 家具模型注册（E4b-1）：modelRef → 固定字面量动态 import 的白名单工厂。
+// 安全边界：modelRef 与元数据里的任何字符串都不会被拼成导入地址——每款模型的导入
+// 地址是本文件写死的字面量；未知、null、非字符串引用在导入前拒绝（constructor／
+// toString／__proto__ 等保留键也不是已登记模型），也不执行 JSON 中的代码。
+// 顶层不加载 Three.js、不构造模型；调用 create 才导入对应模型并每次创建独立实例。
+// 模块加载或工厂抛错按真实原因经 Promise 拒绝传递，不回退占位模型、不返回半个句柄。
+// 注册层不缓存模型实例；场景侧用完应调用句柄上的 dispose（接线归 E4b-2 的页面接入）。
+
+const MODEL_LOADERS = new Map([
+  ['fairy-bookshelf-01', async () => {
+    const model = await import('./assets/fairy-bookshelf-01/model.js');
+    return model.createFairyBookshelf();
+  }],
+  ['fairy-desk-01', async () => {
+    const model = await import('./assets/fairy-desk-01/model.js');
+    return model.createFairyDesk();
+  }],
+  ['fairy-table-lamp-01', async () => {
+    const model = await import('./assets/fairy-table-lamp-01/model.js');
+    return model.createFairyTableLamp();
+  }],
+  ['fairy-notice-board-01', async () => {
+    const model = await import('./assets/fairy-notice-board-01/model.js');
+    return model.createFairyNoticeBoard();
+  }],
+  ['ceramic-display-stand-01', async () => {
+    const model = await import('./assets/ceramic-display-stand-01/model.js');
+    return model.createCeramicDisplayStand();
+  }],
+  ['ceramic-vase-01', async () => {
+    const model = await import('./assets/ceramic-vase-01/model.js');
+    return model.createCeramicVase();
+  }],
+  ['fairy-potted-plant-01', async () => {
+    const model = await import('./assets/fairy-potted-plant-01/model.js');
+    return model.createFairyPottedPlant();
+  }],
+  ['fairy-book-stack-01', async () => {
+    const model = await import('./assets/fairy-book-stack-01/model.js');
+    return model.createFairyBookStack();
+  }],
+  ['fairy-bed-01', async () => {
+    const model = await import('./assets/fairy-bed-01/model.js');
+    return model.createFairyBed();
+  }],
+  ['fairy-reading-chair-01', async () => {
+    const model = await import('./assets/fairy-reading-chair-01/model.js');
+    return model.createFairyReadingChair();
+  }],
+  ['ceramic-low-cabinet-01', async () => {
+    const model = await import('./assets/ceramic-low-cabinet-01/model.js');
+    return model.createCeramicLowCabinet();
+  }],
+  ['ceramic-floor-lamp-01', async () => {
+    const model = await import('./assets/ceramic-floor-lamp-01/model.js');
+    return model.createCeramicFloorLamp();
+  }],
+]);
+
+/** modelRef 是否已登记为可创建的家具模型；保留键与未知值一律 false，且不触发任何导入。 */
+export function hasFurnitureModel(modelRef) {
+  return typeof modelRef === 'string' && MODEL_LOADERS.has(modelRef);
+}
+
+/** 按登记创建一件独立模型，返回 { group, dispose }；未登记的引用直接拒绝，不执行任何导入。 */
+export function createFurnitureModel(modelRef) {
+  if (!hasFurnitureModel(modelRef)) {
+    const shown = (() => { try { const text = JSON.stringify(modelRef); return text === undefined ? String(modelRef) : text; } catch { return String(modelRef); } })();
+    return Promise.reject(new Error(`未登记的家具模型 modelRef：${shown}——请先在 web/assets/furniture/registry.js 与 index.json 登记`));
+  }
+  return MODEL_LOADERS.get(modelRef)();
+}

package/web/assets/furniture-page.css

@@ -0,0 +1,68 @@
+/* 家具图鉴页（E9b）专属样式：只作用于 .furniture-page，颜色全部走 style.css 的
+   主题变量（深/浅主题自动跟随）；不重排业务页、建筑页或房间页。布局以图片辨识和
+   挑选为先：桌面多列卡片、窄屏单列，长名称与说明换行，不横向撑破页面。 */
+
+.furniture-page .picker-bar {
+  display: flex; flex-wrap: wrap; align-items: center; gap: 10px;
+  margin: 0 0 10px; padding: 10px 14px; border-radius: 10px;
+  background: var(--surface-soft); border: 1px solid var(--border);
+}
+.furniture-page .picker-bar p { margin: 0; color: var(--secondary); font-weight: 600; }
+.furniture-page .picker-bar button {
+  font: inherit; cursor: pointer; border-radius: 8px; padding: 5px 14px;
+  border: 1px solid var(--accent-border); background: var(--accent-bg); color: var(--accent);
+}
+.furniture-page .picker-bar button:hover:not(:disabled) { background: var(--accent-hover); }
+.furniture-page .picker-bar button:disabled { cursor: not-allowed; opacity: .55; }
+
+.furniture-page .pick-list-box { margin: 0 0 20px; }
+.furniture-page .pick-list-label { display: block; margin: 0 0 6px; color: var(--muted); font-size: 13px; }
+.furniture-page .pick-list-box textarea {
+  width: 100%; resize: vertical; font: inherit; color: var(--text);
+  background: var(--code-bg); border: 1px solid var(--border); border-radius: 8px; padding: 8px 10px;
+}
+.furniture-page .pick-list-box textarea:focus-visible { outline: 2px solid var(--accent-border); }
+.furniture-page .copy-note { margin: 6px 0 0; font-size: 13px; color: var(--secondary); }
+.furniture-page .copy-note[data-kind="ok"] { color: var(--success); }
+.furniture-page .copy-note[data-kind="bad"] { color: var(--danger); }
+
+/* 分类标题：跟 index.categories 顺序；没有分类信息时由脚本退回单一列表。 */
+.furniture-page .furniture-group { margin: 26px 0 10px; }
+.furniture-page .furniture-group h2 { margin: 0 0 4px; font-size: 15px; }
+.furniture-page .furniture-group .group-note { margin: 0 0 10px; font-size: 13px; color: var(--muted); }
+
+.furniture-cards { display: grid; grid-template-columns: repeat(auto-fill, minmax(240px, 1fr)); gap: 14px; }
+.furniture-card {
+  display: flex; flex-direction: column; gap: 8px;
+  background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 12px;
+}
+.furniture-card:has(.furniture-pick input:checked) { border-color: var(--accent-border); background: var(--accent-bg); }
+
+.furniture-page .furniture-pick { display: flex; align-items: baseline; gap: 8px; cursor: pointer; }
+.furniture-page .furniture-pick input { width: 16px; height: 16px; flex: none; align-self: center; cursor: pointer; }
+.furniture-page .furniture-name { font-weight: 600; color: var(--text); overflow-wrap: anywhere; }
+
+/* 缩略图：完整轮廓优先（object-fit: contain），不裁切床/落地灯等比例差异大的资产。 */
+.furniture-page .furniture-thumb {
+  display: flex; align-items: center; justify-content: center;
+  height: 150px; border-radius: 8px; overflow: hidden;
+  background: var(--canvas); border: 1px solid var(--border);
+}
+.furniture-page .furniture-thumb img { max-width: 100%; max-height: 100%; object-fit: contain; }
+.furniture-page .no-preview { margin: 0; color: var(--muted); font-size: 13px; }
+
+.furniture-page .furniture-size { margin: 0; color: var(--secondary); font-size: 13px; }
+.furniture-page .furniture-meta { margin: 0; color: var(--muted); font-size: 13px; }
+.furniture-page .asset-id { margin: 0; color: var(--muted); font-size: 12px; overflow-wrap: anywhere; }
+.furniture-page .furniture-card details { font-size: 13px; color: var(--secondary); }
+.furniture-page .furniture-card details summary { cursor: pointer; color: var(--muted); }
+.furniture-page .furniture-card details p { margin: 6px 0 0; overflow-wrap: anywhere; }
+
+.furniture-page .furniture-empty {
+  padding: 26px; border-radius: 10px; border: 1px dashed var(--border-strong);
+  color: var(--muted); text-align: center;
+}
+
+@media (max-width: 560px) {
+  .furniture-cards { grid-template-columns: 1fr; }
+}