chatroom-cli 1.138.0 → 1.138.1

package/dist/index.js

@@ -3795,6 +3795,385 @@ var init_meshoptimizer = __esm(() => {
   init_meshopt_tangents();
 });
 
+// src/commands/generate-3d/asset-analysis.ts
+function toUnit(value) {
+  return value / 255;
+}
+function percentile(histogram, total, fraction) {
+  const target = Math.min(total, Math.ceil(fraction * total));
+  let seen = 0;
+  for (let value = 0;value < HISTOGRAM_BINS; value += 1) {
+    seen += histogram[value] ?? 0;
+    if (seen >= target)
+      return toUnit(value);
+  }
+  return 1;
+}
+function countInRange(histogram, first, last) {
+  let count = 0;
+  for (let value = first;value <= last; value += 1)
+    count += histogram[value] ?? 0;
+  return count;
+}
+function channelStats(pixels, channel) {
+  const total = Math.floor(pixels.length / CHANNELS_PER_TEXEL);
+  if (total === 0)
+    return EMPTY_STATS;
+  const histogram = new Uint32Array(HISTOGRAM_BINS);
+  let weighted = 0;
+  for (let index = channel;index < pixels.length; index += CHANNELS_PER_TEXEL) {
+    const value = pixels[index];
+    histogram[value] += 1;
+    weighted += value;
+  }
+  return {
+    mean: weighted / (255 * total),
+    p5: percentile(histogram, total, 0.05),
+    p50: percentile(histogram, total, 0.5),
+    p95: percentile(histogram, total, 0.95),
+    fractionAtLeastHalf: countInRange(histogram, HALF_BYTE, HISTOGRAM_BINS - 1) / total,
+    fractionAtMostTenth: countInRange(histogram, 0, TENTH_BYTE) / total
+  };
+}
+function isFiniteBox(min, max) {
+  return min.every((value) => Number.isFinite(value)) && max.every((value) => Number.isFinite(value));
+}
+function mergeBounds(boxes) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const box of boxes) {
+    min[0] = Math.min(min[0], box.min[0]);
+    min[1] = Math.min(min[1], box.min[1]);
+    min[2] = Math.min(min[2], box.min[2]);
+    max[0] = Math.max(max[0], box.max[0]);
+    max[1] = Math.max(max[1], box.max[1]);
+    max[2] = Math.max(max[2], box.max[2]);
+  }
+  return isFiniteBox(min, max) ? { min, max } : { min: [0, 0, 0], max: [0, 0, 0] };
+}
+function extentsOf(bounds) {
+  return [
+    bounds.max[0] - bounds.min[0],
+    bounds.max[1] - bounds.min[1],
+    bounds.max[2] - bounds.min[2]
+  ];
+}
+async function decodeImageRgba(image, sharpFactory) {
+  const { data, info } = await sharpFactory(Buffer.from(image)).toColourspace("srgb").ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  if (info.channels !== 4) {
+    throw new Error(`Image decoded to ${info.channels} channels; expected 4 (RGBA).`);
+  }
+  return { pixels: new Uint8Array(data), width: info.width, height: info.height };
+}
+async function decodePixels(texture, sharp, cache) {
+  const cached = cache.get(texture);
+  if (cached !== undefined)
+    return cached;
+  const image = texture.getImage();
+  if (image === null || image.length === 0) {
+    throw new Error("A metallic-roughness texture has no embedded image.");
+  }
+  const { pixels } = await decodeImageRgba(image, sharp);
+  cache.set(texture, pixels);
+  return pixels;
+}
+async function describeMaterial(index, material, sharp, cache) {
+  const texture = material.getMetallicRoughnessTexture();
+  const base = {
+    index,
+    name: material.getName() || null,
+    metallicFactor: material.getMetallicFactor(),
+    roughnessFactor: material.getRoughnessFactor(),
+    hasMetallicRoughnessTexture: texture !== null
+  };
+  if (texture === null)
+    return { ...base, metal: null, roughness: null };
+  if (!DECODABLE_IMAGE_MIME_TYPES.has(texture.getMimeType())) {
+    return { ...base, metal: null, roughness: null };
+  }
+  const pixels = await decodePixels(texture, sharp, cache);
+  return { ...base, metal: channelStats(pixels, 2), roughness: channelStats(pixels, 1) };
+}
+async function analyseDocument(doc) {
+  const [{ getBounds }, { default: sharp }] = await Promise.all([
+    import("@gltf-transform/functions"),
+    import("sharp")
+  ]);
+  const bounds = mergeBounds(doc.getRoot().listScenes().map((scene) => getBounds(scene)));
+  const cache = new Map;
+  const materials = [];
+  for (const [index, material] of doc.getRoot().listMaterials().entries()) {
+    materials.push(await describeMaterial(index, material, sharp, cache));
+  }
+  return { bounds, extents: extentsOf(bounds), materials };
+}
+var CHANNELS_PER_TEXEL = 4, HALF_BYTE = 128, TENTH_BYTE = 25, HISTOGRAM_BINS = 256, EMPTY_STATS, DECODABLE_IMAGE_MIME_TYPES;
+var init_asset_analysis = __esm(() => {
+  EMPTY_STATS = {
+    mean: 0,
+    p5: 0,
+    p50: 0,
+    p95: 0,
+    fractionAtLeastHalf: 0,
+    fractionAtMostTenth: 0
+  };
+  DECODABLE_IMAGE_MIME_TYPES = new Set([
+    "image/jpeg",
+    "image/png",
+    "image/webp"
+  ]);
+});
+
+// src/commands/generate-3d/fit.ts
+async function currentBounds(doc, getBounds) {
+  return mergeBounds(doc.getRoot().listScenes().map((scene) => getBounds(scene)));
+}
+function originOffset(bounds, origin) {
+  if (origin === "as-is")
+    return [0, 0, 0];
+  const midX = (bounds.min[0] + bounds.max[0]) / 2;
+  const midZ = (bounds.min[2] + bounds.max[2]) / 2;
+  const y = origin === "feet" ? bounds.min[1] : (bounds.min[1] + bounds.max[1]) / 2;
+  return [-midX, -y, -midZ];
+}
+function scaleForHeight(bounds, targetHeight) {
+  const height = bounds.max[1] - bounds.min[1];
+  if (!Number.isFinite(height) || height <= 0) {
+    throw new Error("Cannot fit the model: its scene height is 0.");
+  }
+  return targetHeight / height;
+}
+function addWrapper(doc, translation, scale) {
+  for (const scene of doc.getRoot().listScenes()) {
+    const roots = [...scene.listChildren()];
+    const wrapper = doc.createNode("Fit").setTranslation(translation).setScale([scale, scale, scale]);
+    for (const root of roots)
+      wrapper.addChild(root);
+    scene.addChild(wrapper);
+  }
+}
+function isIdentity(fit) {
+  return fit.scale === 1 && fit.translation[0] === 0 && fit.translation[1] === 0 && fit.translation[2] === 0;
+}
+function applyFitTransform(doc, fit) {
+  if (isIdentity(fit))
+    return;
+  addWrapper(doc, fit.translation, fit.scale);
+}
+function fitTransform(bounds, options) {
+  const offset = originOffset(bounds, options.origin);
+  const scale = options.targetHeight === undefined ? 1 : scaleForHeight(bounds, options.targetHeight);
+  return {
+    scale,
+    translation: [offset[0] * scale, offset[1] * scale, offset[2] * scale]
+  };
+}
+async function applyFit(doc, analysis, options) {
+  if (options.origin === "as-is" && options.targetHeight === undefined) {
+    return {
+      origin: "as-is",
+      targetHeight: null,
+      scale: 1,
+      translation: [0, 0, 0],
+      bounds: analysis.bounds
+    };
+  }
+  const { scale, translation } = fitTransform(analysis.bounds, options);
+  addWrapper(doc, translation, scale);
+  const { getBounds } = await import("@gltf-transform/functions");
+  const bounds = await currentBounds(doc, getBounds);
+  return {
+    origin: options.origin,
+    targetHeight: options.targetHeight ?? null,
+    scale,
+    translation,
+    bounds: {
+      min: [bounds.min[0], bounds.min[1], bounds.min[2]],
+      max: [bounds.max[0], bounds.max[1], bounds.max[2]]
+    }
+  };
+}
+var init_fit = __esm(() => {
+  init_asset_analysis();
+});
+
+// src/commands/generate-3d/material-normalise.ts
+function materialName(material) {
+  return material.getName() || null;
+}
+function untexturedDecision(index, material) {
+  const name = materialName(material);
+  if (material.getMetallicFactor() !== 1) {
+    return { index, name, decision: "unchanged", reason: "explicit-factor" };
+  }
+  material.setMetallicFactor(0);
+  return { index, name, decision: "non-metal", metalFraction: 0 };
+}
+function requireImage(texture) {
+  const image = texture.getImage();
+  if (image === null || image.length === 0) {
+    throw new Error("A metallic-roughness texture has no embedded image.");
+  }
+  return image;
+}
+function isWeakMetal(value) {
+  return value < METAL_MASK_THRESHOLD;
+}
+function isPartlyMetal(value) {
+  return value > NON_METAL_TENTH_BYTE && value < METAL_MASK_THRESHOLD;
+}
+async function maskBlueChannel(texture, sharpFactory) {
+  const { pixels, width, height } = await decodeImageRgba(requireImage(texture), sharpFactory);
+  let masked = 0;
+  for (let index = 2;index < pixels.length; index += 4) {
+    const blue = pixels[index];
+    if (!isWeakMetal(blue))
+      continue;
+    if (isPartlyMetal(blue))
+      masked += 1;
+    pixels[index] = 0;
+  }
+  const png = await sharpFactory(Buffer.from(pixels), {
+    raw: { width, height, channels: 4 }
+  }).png().toBuffer();
+  texture.setImage(new Uint8Array(png)).setMimeType("image/png");
+  return masked / (pixels.length / 4);
+}
+function hasUsableImage(texture, stats) {
+  return DECODABLE_IMAGE_MIME_TYPES.has(texture.getMimeType()) && stats.metal !== null && stats.roughness !== null;
+}
+function canMask(texture, stats) {
+  if (!hasUsableImage(texture, stats))
+    return false;
+  return stats.metal.fractionAtLeastHalf >= NON_METAL_FRACTION_MAX;
+}
+function isMaskCandidate(material, stats) {
+  if (stats === undefined || material.getMetallicFactor() !== 1)
+    return false;
+  const texture = material.getMetallicRoughnessTexture();
+  if (texture === null)
+    return false;
+  return canMask(texture, stats);
+}
+function texturedNonMaskedDecision(index, material, texture, stats) {
+  const name = materialName(material);
+  if (!hasUsableImage(texture, stats)) {
+    return { index, name, decision: "unchanged", reason: "unsupported-image" };
+  }
+  if (material.getMetallicFactor() !== 1) {
+    return { index, name, decision: "unchanged", reason: "explicit-factor" };
+  }
+  material.setMetallicFactor(0);
+  return {
+    index,
+    name,
+    decision: "non-metal",
+    metalFraction: stats.metal.fractionAtLeastHalf
+  };
+}
+function nonMaskedDecision(index, material, stats) {
+  if (stats === undefined) {
+    return {
+      index,
+      name: materialName(material),
+      decision: "unchanged",
+      reason: "missing-analysis"
+    };
+  }
+  const texture = material.getMetallicRoughnessTexture();
+  if (texture === null)
+    return untexturedDecision(index, material);
+  return texturedNonMaskedDecision(index, material, texture, stats);
+}
+function textureUsers(materials, texture) {
+  const users = [];
+  for (const [index, material] of materials.entries()) {
+    if (material.getMetallicRoughnessTexture() === texture)
+      users.push(index);
+  }
+  return users;
+}
+function needsClone(texture, users, masked) {
+  const parents = texture.listParents().filter((parent) => parent.propertyType !== "Root").length;
+  return users.length > masked.length || parents > users.length;
+}
+function maskedUserFor(index, material, stats) {
+  if (!isMaskCandidate(material, stats))
+    return null;
+  if (stats === undefined || stats.metal === null)
+    return null;
+  return { index, material, metalFraction: stats.metal.fractionAtLeastHalf };
+}
+async function maskTextureGroup(args) {
+  const { texture, masked, users, sharpFactory, decisions } = args;
+  const clone = needsClone(texture, users, masked.map((user) => user.index));
+  const target = clone ? texture.clone() : texture;
+  const maskedFraction = await maskBlueChannel(target, sharpFactory);
+  for (const user of masked) {
+    user.material.setMetallicFactor(1);
+    if (clone)
+      user.material.setMetallicRoughnessTexture(target);
+    decisions.set(user.index, {
+      index: user.index,
+      name: materialName(user.material),
+      decision: "metal-masked",
+      metalFraction: user.metalFraction,
+      maskedFraction
+    });
+  }
+}
+function maskedEntryFor(index, material, stats) {
+  const user = maskedUserFor(index, material, stats);
+  if (user === null)
+    return null;
+  const texture = material.getMetallicRoughnessTexture();
+  return texture === null ? null : { texture, user };
+}
+function maskedGroups(materials, analysis) {
+  const groups = new Map;
+  for (const [index, material] of materials.entries()) {
+    const entry = maskedEntryFor(index, material, analysis.materials[index]);
+    if (entry === null)
+      continue;
+    const group = groups.get(entry.texture) ?? [];
+    group.push(entry.user);
+    groups.set(entry.texture, group);
+  }
+  return groups;
+}
+function fillNonMasked(materials, analysis, decisions) {
+  for (const [index, material] of materials.entries()) {
+    if (decisions.has(index))
+      continue;
+    decisions.set(index, nonMaskedDecision(index, material, analysis.materials[index]));
+  }
+}
+async function normaliseMaterials(doc, analysis) {
+  const { default: sharpFactory } = await import("sharp");
+  const materials = doc.getRoot().listMaterials();
+  const decisions = new Map;
+  for (const [texture, masked] of maskedGroups(materials, analysis)) {
+    await maskTextureGroup({
+      texture,
+      masked,
+      users: textureUsers(materials, texture),
+      sharpFactory,
+      decisions
+    });
+  }
+  fillNonMasked(materials, analysis, decisions);
+  return materials.map((_material, index) => decisions.get(index) ?? {
+    index,
+    name: null,
+    decision: "unchanged",
+    reason: "missing-analysis"
+  });
+}
+var NON_METAL_FRACTION_MAX = 0.01, METAL_MASK_THRESHOLD = 128, NON_METAL_TENTH_BYTE = 25;
+var init_material_normalise = __esm(() => {
+  init_asset_analysis();
+});
+
 // src/commands/generate-3d/web-variant.ts
 import {
   NodeIO,
@@ -3925,6 +4304,16 @@ async function createWebVariant(glb, opts) {
     weld: () => weld(),
     simplifyAt: (ratio) => simplify({ simplifier: MeshoptSimplifier, ratio, error: 0.01, lockBorder: true })
   });
+  let materials;
+  let fit;
+  if (opts.processed !== undefined) {
+    materials = opts.processed.materials;
+    fit = opts.processed.fit;
+  } else {
+    const analysis = await analyseDocument(document2);
+    materials = await normaliseMaterials(document2, analysis);
+    fit = await applyFit(document2, analysis, opts.fit ?? { origin: "as-is" });
+  }
   await compressTextures({
     document: document2,
     compressTexture,
@@ -3939,12 +4328,17 @@ async function createWebVariant(glb, opts) {
     ...describeDocument(document2),
     simplified: geometry.simplified,
     skinnedPath: geometry.skinnedPath,
-    source
+    source,
+    materials,
+    fit
   };
 }
 var SILENT_LOGGER, COMPRESSIBLE_MIME_TYPES, WEBP_EXTENSION = "EXT_texture_webp", DRACO_EXTENSION = "KHR_draco_mesh_compression", MESHOPT_EXTENSION = "EXT_meshopt_compression";
 var init_web_variant = __esm(() => {
   init_meshoptimizer();
+  init_asset_analysis();
+  init_fit();
+  init_material_normalise();
   init_model_registry();
   SILENT_LOGGER = {
     debug: () => {},
@@ -3964,6 +4358,9 @@ import { createRequire as createRequire2 } from "module";
 function deflateSync(data, opts) {
   return dopt(data, opts || {}, 0, 0);
 }
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
 function strToU8(str, latin1) {
   if (latin1) {
     var ar_1 = new u8(str.length);
@@ -3997,6 +4394,21 @@ function strToU8(str, latin1) {
   }
   return slc(ar, 0, ai);
 }
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i2 = 0;i2 < dat.length; i2 += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
 function zipSync(data, opts) {
   if (!opts)
     opts = {};
@@ -4040,6 +4452,46 @@ function zipSync(data, opts) {
   wzf(out, o, files.length, cdl, oe);
   return out;
 }
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (;b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = b4(data, e - 20) == 117853008;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i2 = 0;i2 < c; ++i2) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
 var require2, _a, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, clim, freb = function(eb, start) {
   var b = new u16(31);
   for (var i = 0;i < 31; ++i) {
@@ -4087,7 +4539,20 @@ var require2, _a, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, c
     }
   }
   return co;
-}, flt, i, i, i, i, fdt, i, flm, fdm, shft = function(p) {
+}, flt, i, i, i, i, fdt, i, flm, flrm, fdm, fdrm, max = function(a) {
+  var m = a[0];
+  for (var i2 = 1;i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
+  }
+  return m;
+}, bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+}, bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+}, shft = function(p) {
   return (p + 7) / 8 | 0;
 }, slc = function(v, s, e) {
   if (s == null || s < 0)
@@ -4103,6 +4568,146 @@ var require2, _a, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, c
   if (!nt)
     throw e;
   return e;
+}, inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i2 = 0;i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i2 = 0;i2 < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i2++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i2++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (;; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (;bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (;bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
 }, wbits = function(d, p, v) {
   v <<= p & 7;
   var o = p / 8 | 0;
@@ -4426,6 +5031,12 @@ var require2, _a, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, c
   for (var k in b)
     o[k] = b[k];
   return o;
+}, b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+}, b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+}, b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
 }, wbytes = function(d, b, v) {
   for (;v; ++b)
     d[b] = v, v >>>= 8;
@@ -4441,7 +5052,46 @@ var require2, _a, Worker2, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, c
       fltn(val, n, t, o);
     }
   }
-}, te, td, tds = 0, exfl = function(ex) {
+}, te, td, tds = 0, dutf8 = function(d) {
+  for (var r = "", i2 = 0;; ) {
+    var c = d[i2++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i2 + eb > d.length)
+      return { s: r, r: slc(d, i2 - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+  }
+}, slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+}, zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+  var _a2 = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+}, z64hs = function(d, b, l, z, sc, su, off) {
+  var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+  var nf = nsc + nsu + noff;
+  if (z && nf) {
+    for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
+      if (b2(d, b) == 1) {
+        return [
+          nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+          nsu ? b8(d, b + 4) : su,
+          noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+          1
+        ];
+      }
+    }
+    if (z < 2)
+      err(13);
+  }
+  return [sc, su, off, 0];
+}, exfl = function(ex) {
   var le = 0;
   if (ex) {
     for (var k in ex) {
@@ -4535,7 +5185,9 @@ var init_esm = __esm(() => {
   for (i = 0;i < 32; ++i)
     fdt[i] = 5;
   flm = /* @__PURE__ */ hMap(flt, 9, 0);
+  flrm = /* @__PURE__ */ hMap(flt, 9, 1);
   fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+  fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
   ec = [
     "unexpected EOF",
     "invalid block type",
@@ -9083,7 +9735,7 @@ function validateInputOption(opts) {
   }
   validateInputObject(opts.input);
 }
-function requireImage(images, model) {
+function requireImage2(images, model) {
   const image = images[0];
   if (!image?.url) {
     throw new GenerateImageError(`fal returned no image for model ${model}`);
@@ -9425,7 +10077,7 @@ async function generateAndSave(deps, model, input, outPath) {
   if (result.data.images.length > 1) {
     deps.warn(`⚠️ fal returned ${result.data.images.length} images; only the first is saved.`);
   }
-  const image = requireImage(result.data.images, model);
+  const image = requireImage2(result.data.images, model);
   const bytes = await downloadImage(deps, result.requestId, image.url);
   await saveImage(deps, outPath, bytes, result.requestId, image.url);
   return {
@@ -9870,6 +10522,109 @@ var init_deps2 = __esm(() => {
   GLB_MAGIC = [103, 108, 84, 70];
 });
 
+// src/commands/generate-3d/checks.ts
+function formatMean(mean) {
+  return mean.toFixed(2);
+}
+function isWholeTextureMetal(material) {
+  if (material.metal === null) {
+    return !material.hasMetallicRoughnessTexture && material.metallicFactor >= CHECK_THRESHOLDS.wholeTextureMetalFraction;
+  }
+  return material.metallicFactor > 0 && material.metal.fractionAtLeastHalf >= CHECK_THRESHOLDS.wholeTextureMetalFraction;
+}
+function metalWholeTextureFor(material) {
+  if (!isWholeTextureMetal(material))
+    return null;
+  return {
+    id: "metal-whole-texture",
+    severity: "warning",
+    materialIndex: material.index,
+    message: `Material ${material.index} looks metal across its whole surface; check that the surface really is metal.`
+  };
+}
+function flatChecks(analysis) {
+  const largest = Math.max(...analysis.extents);
+  if (largest <= 0)
+    return [];
+  const ratio = Math.min(...analysis.extents) / largest;
+  if (ratio >= CHECK_THRESHOLDS.flatRatio)
+    return [];
+  return [
+    {
+      id: "flat",
+      severity: "warning",
+      materialIndex: null,
+      message: "Model is flat (thickness is under 5% of its width); a flat model may disappear from some angles."
+    }
+  ];
+}
+function feetChecks(analysis) {
+  const height = analysis.bounds.max[1] - analysis.bounds.min[1];
+  const offset = Math.abs(analysis.bounds.min[1]);
+  if (offset <= CHECK_THRESHOLDS.feetShare * height)
+    return [];
+  return [
+    {
+      id: "not-on-feet",
+      severity: "warning",
+      materialIndex: null,
+      message: `Model's base is not at the origin. Use --origin feet to move the base to the origin.`
+    }
+  ];
+}
+function hasChannels(material) {
+  return material.metal !== null && material.roughness !== null;
+}
+function texturedGlossy(material) {
+  if (!hasChannels(material))
+    return null;
+  if (material.metal.fractionAtLeastHalf >= NON_METAL_FRACTION_MAX)
+    return null;
+  const value = material.roughness.mean * material.roughnessFactor;
+  return value < CHECK_THRESHOLDS.glossyRoughnessMean ? { value, label: "mean" } : null;
+}
+function untexturedGlossy(material) {
+  if (material.metallicFactor >= NON_METAL_FACTOR_MAX)
+    return null;
+  return material.roughnessFactor < CHECK_THRESHOLDS.glossyRoughnessMean ? { value: material.roughnessFactor, label: "factor" } : null;
+}
+function glossyValue(material) {
+  return material.hasMetallicRoughnessTexture ? texturedGlossy(material) : untexturedGlossy(material);
+}
+function glossyFor(material) {
+  const glossy = glossyValue(material);
+  if (glossy === null)
+    return null;
+  return {
+    id: "glossy-non-metal",
+    severity: "warning",
+    materialIndex: material.index,
+    message: `Material ${material.index} is non-metal with low roughness (${glossy.label} ${formatMean(glossy.value)}); it may look glossy or metallic under light.`
+  };
+}
+function computeChecks(analysis) {
+  const checks = [...flatChecks(analysis), ...feetChecks(analysis)];
+  for (const material of analysis.materials) {
+    const metal = metalWholeTextureFor(material);
+    if (metal !== null)
+      checks.push(metal);
+    const glossy = glossyFor(material);
+    if (glossy !== null)
+      checks.push(glossy);
+  }
+  return checks;
+}
+var CHECK_THRESHOLDS, NON_METAL_FACTOR_MAX = 0.5;
+var init_checks = __esm(() => {
+  init_material_normalise();
+  CHECK_THRESHOLDS = {
+    wholeTextureMetalFraction: 0.5,
+    flatRatio: 0.05,
+    feetShare: 0.01,
+    glossyRoughnessMean: 0.35
+  };
+});
+
 // src/commands/generate-3d/package-name.ts
 function sanitizeNamePart(value) {
   return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "");
@@ -9910,10 +10665,59 @@ function formatCount(count) {
 function captionRow(label, value) {
   return `    <dt>${label}</dt><dd>${value}</dd>`;
 }
+function variantButton(variant, pressed, label) {
+  return `  <button type="button" class="variant" data-variant="${variant}" aria-pressed="${pressed}">${label}</button>`;
+}
+function lightingButton(mode, pressed) {
+  const label = mode === "studio" ? "Studio" : mode === "directional" ? "Directional" : "Unlit";
+  return `  <button type="button" class="lighting-option" data-lighting="${mode}" aria-pressed="${pressed}">${label}</button>`;
+}
+function checksPanel(checks, note) {
+  if (note !== undefined && note !== null) {
+    return `  <p class="ok">${escapeHtml(note)}</p>`;
+  }
+  if (checks.length === 0) {
+    return `  <p class="ok">No issues found.</p>`;
+  }
+  const items = checks.map((check) => `    <li data-check="${escapeHtml(check.id)}">${escapeHtml(check.message)}</li>`).join(`
+`);
+  return `  <ul>
+${items}
+  </ul>`;
+}
+function glbDataUri(glb) {
+  return `data:model/gltf-binary;base64,${Buffer.from(glb).toString("base64")}`;
+}
+function isSunTexel(x2, y) {
+  const dx = x2 - Math.round(ENVIRONMENT_WIDTH * 0.75);
+  const dy = y - Math.round(ENVIRONMENT_HEIGHT * 0.7);
+  return dx * dx + dy * dy <= SUN_RADIUS_PX * SUN_RADIUS_PX;
+}
+async function directionalEnvironmentPng() {
+  const { default: sharp } = await import("sharp");
+  const pixels = new Uint8Array(ENVIRONMENT_WIDTH * ENVIRONMENT_HEIGHT * 4);
+  for (let index = 0;index < pixels.length; index += 4) {
+    pixels[index + 3] = 255;
+    const texel = index / 4;
+    const x2 = texel % ENVIRONMENT_WIDTH;
+    const y = Math.floor(texel / ENVIRONMENT_WIDTH);
+    if (!isSunTexel(x2, y))
+      continue;
+    pixels[index] = 255;
+    pixels[index + 1] = 255;
+    pixels[index + 2] = 255;
+  }
+  const png = await sharp(Buffer.from(pixels), {
+    raw: { width: ENVIRONMENT_WIDTH, height: ENVIRONMENT_HEIGHT, channels: 4 }
+  }).png().toBuffer();
+  return new Uint8Array(png);
+}
 function renderPreviewHtml(input) {
   const title = escapeHtml(input.title);
   const prompt = input.prompt === null ? "Not specified." : escapeHtml(input.prompt);
-  const dataUri = `data:model/gltf-binary;base64,${Buffer.from(input.webGlb).toString("base64")}`;
+  const masterDataUri = glbDataUri(input.masterGlb);
+  const webDataUri = glbDataUri(input.webGlb);
+  const directionalEnvironment = `data:image/png;base64,${Buffer.from(input.directionalEnvironmentPng).toString("base64")}`;
   const rows = [
     captionRow("Model id", escapeHtml(input.modelId)),
     captionRow("Prompt", prompt),
@@ -9924,6 +10728,20 @@ function renderPreviewHtml(input) {
     captionRow("Master file", `${escapeHtml(input.masterZipEntry)} (in ${escapeHtml(input.zipName)})`)
   ].join(`
 `);
+  const masterLabel = `Full resolution (master, ${formatBytes(input.masterBytes)}, ${formatCount(input.masterTriangles)} triangles)`;
+  const webLabel = `Scaled down (web, ${formatBytes(input.webBytes)}, ${formatCount(input.webTriangles)} triangles)`;
+  const variantButtons = [
+    variantButton("master", false, masterLabel),
+    variantButton("web", true, webLabel)
+  ].join(`
+`);
+  const lightingButtons = [
+    lightingButton("studio", true),
+    lightingButton("directional", false),
+    lightingButton("unlit", false)
+  ].join(`
+`);
+  const checks = checksPanel(input.checks, input.checksNote);
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -9939,15 +10757,109 @@ function renderPreviewHtml(input) {
 ${rows}
   </dl>
 </div>
+<section class="checks">
+  <h2>Checks</h2>
+${checks}
+</section>
+<div class="variants" role="group" aria-label="Variant">
+${variantButtons}
+</div>
+<div class="lighting" role="group" aria-label="Lighting">
+${lightingButtons}
+</div>
 <model-viewer
-  src="${dataUri}"
+  src="${webDataUri}"
+  data-master-src="${masterDataUri}"
+  data-directional-environment="${directionalEnvironment}"
   alt="${title} preview"
   camera-controls
   auto-rotate
   shadow-intensity="1"
   exposure="1"
   touch-action="pan-y"></model-viewer>
-<p class="note">Preview of the web variant. Full-resolution master is in ${escapeHtml(input.zipName)}. Drag to orbit, scroll to zoom.</p>
+<p class="note">Switch between the full-resolution master and the scaled-down web variant, and between Studio, Directional, and Unlit lighting. Drag to orbit, scroll to zoom.</p>
+<script>
+  const viewer = document.querySelector('model-viewer');
+  const variants = {
+    master: viewer.getAttribute('data-master-src'),
+    web: viewer.getAttribute('src'),
+  };
+  const directionalEnvironment = viewer.getAttribute('data-directional-environment');
+  let lighting = 'studio';
+
+  const unlitState = new WeakMap();
+
+  function materialsOf() {
+    const model = viewer.model;
+    return model && model.materials ? model.materials : [];
+  }
+
+  function setUnlit(enabled) {
+    for (const material of materialsOf()) {
+      const pbr = material.pbrMetallicRoughness;
+      if (!pbr || !material.emissiveTexture) continue;
+      const saved = unlitState.get(material);
+      if (enabled) {
+        const state = saved || {
+          baseColorFactor: [...pbr.baseColorFactor],
+          metallicFactor: pbr.metallicFactor,
+          roughnessFactor: pbr.roughnessFactor,
+          emissiveFactor: [...material.emissiveFactor],
+          emissiveStrength: material.emissiveStrength,
+          emissiveTexture: material.emissiveTexture.texture,
+        };
+        unlitState.set(material, state);
+        const base = pbr.baseColorTexture ? pbr.baseColorTexture.texture : null;
+        pbr.setBaseColorFactor([0, 0, 0, 1]);
+        pbr.setMetallicFactor(0);
+        pbr.setRoughnessFactor(1);
+        material.setEmissiveStrength(1);
+        material.emissiveTexture.setTexture(base);
+        material.setEmissiveFactor(state.baseColorFactor.slice(0, 3));
+      } else if (saved) {
+        pbr.setBaseColorFactor(saved.baseColorFactor);
+        pbr.setMetallicFactor(saved.metallicFactor);
+        pbr.setRoughnessFactor(saved.roughnessFactor);
+        material.setEmissiveFactor(saved.emissiveFactor);
+        material.setEmissiveStrength(saved.emissiveStrength);
+        material.emissiveTexture.setTexture(saved.emissiveTexture);
+        unlitState.delete(material);
+      }
+    }
+  }
+
+  function applyLighting() {
+    if (lighting === 'directional') {
+      viewer.setAttribute('environment-image', directionalEnvironment);
+      viewer.setAttribute('exposure', '20');
+    } else {
+      viewer.removeAttribute('environment-image');
+      viewer.setAttribute('exposure', '1');
+    }
+    setUnlit(lighting === 'unlit');
+  }
+
+  for (const button of document.querySelectorAll('button[data-variant]')) {
+    button.addEventListener('click', () => {
+      const name = button.getAttribute('data-variant');
+      viewer.setAttribute('src', variants[name]);
+      for (const other of document.querySelectorAll('button[data-variant]')) {
+        other.setAttribute('aria-pressed', String(other === button));
+      }
+    });
+  }
+  for (const button of document.querySelectorAll('button[data-lighting]')) {
+    button.addEventListener('click', () => {
+      lighting = button.getAttribute('data-lighting');
+      for (const other of document.querySelectorAll('button[data-lighting]')) {
+        other.setAttribute('aria-pressed', String(other === button));
+      }
+      applyLighting();
+    });
+  }
+  viewer.addEventListener('load', applyLighting);
+  applyLighting();
+</script>
 <script
   type="module"
   src="${MODEL_VIEWER_URL}"
@@ -9957,18 +10869,31 @@ ${rows}
 </html>
 `;
 }
-var MODEL_VIEWER_URL = "https://cdn.jsdelivr.net/npm/@google/model-viewer@3.5.0/dist/model-viewer.min.js", MODEL_VIEWER_SRI = "sha384-Ftcjj/GNLxPvzNDftO/oryXB9aGxsGZY9JGqsXG0uUKgQDl9RfDgsx9NJ/4IVNPe", PANEL_STYLE = `
+var MODEL_VIEWER_URL = "https://cdn.jsdelivr.net/npm/@google/model-viewer@3.5.0/dist/model-viewer.min.js", MODEL_VIEWER_SRI = "sha384-Ftcjj/GNLxPvzNDftO/oryXB9aGxsGZY9JGqsXG0uUKgQDl9RfDgsx9NJ/4IVNPe", ENVIRONMENT_WIDTH = 512, ENVIRONMENT_HEIGHT = 256, SUN_RADIUS_PX = 10, PANEL_STYLE = `
   :root { color-scheme: dark; }
   body { margin: 0; padding: 24px; background: #111318; color: #e6e8ec;
          font: 14px/1.5 ui-sans-serif, system-ui, -apple-system, sans-serif; }
   h1 { margin: 0 0 16px; font-size: 18px; font-weight: 600; }
-  .caption { margin: 0 0 16px; padding: 12px 16px; border: 1px solid #2a2f3a;
+  .caption, .checks { margin: 0 0 16px; padding: 12px 16px; border: 1px solid #2a2f3a;
              border-radius: 8px; background: #171a21; }
   .caption dl { display: grid; grid-template-columns: max-content 1fr;
                 gap: 4px 16px; margin: 0; }
   .caption dt { color: #9aa3b2; }
   .caption dd { margin: 0; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
                 font-size: 12px; word-break: break-word; }
+  .checks h2 { margin: 0 0 8px; font-size: 14px; font-weight: 600; }
+  .checks ul { margin: 0; padding-left: 20px; }
+  .checks li { color: #f0c674; }
+  .checks .ok { margin: 0; color: #9aa3b2; }
+  .variants, .lighting { display: flex; flex-wrap: wrap; gap: 8px; margin: 0 0 16px; }
+  .variants { margin-bottom: 8px; }
+  .variant, .lighting-option { padding: 8px 12px; border: 1px solid #2a2f3a;
+             border-radius: 8px; background: #171a21; color: #e6e8ec;
+             font: inherit; cursor: pointer; }
+  .variant[aria-pressed="true"], .lighting-option[aria-pressed="true"] {
+             border-color: #6b8afd; background: #1d2436; }
+  .variant:focus-visible, .lighting-option:focus-visible {
+             outline: 2px solid #6b8afd; outline-offset: 2px; }
   model-viewer { width: 100%; height: 70vh; min-height: 420px;
                  background: #0b0d11; border: 1px solid #2a2f3a; border-radius: 8px; }
   .note { color: #9aa3b2; font-size: 12px; }
@@ -10095,6 +11020,8 @@ __export(exports_generate_3d, {
 });
 import { createHash as createHash3 } from "node:crypto";
 import { basename, dirname as dirname4, extname as extname2, join as join2, resolve as resolve2 } from "node:path";
+import { NodeIO as NodeIO2 } from "@gltf-transform/core";
+import { ALL_EXTENSIONS as ALL_EXTENSIONS2 } from "@gltf-transform/extensions";
 function outputStem(outPath) {
   return outPath.slice(0, -GLB_EXTENSION.length);
 }
@@ -10329,13 +11256,21 @@ function inputParts(ctx, capabilities) {
 function rigParts(ctx) {
   return passedFlags(ctx).filter((entry) => !INPUT_FLAG_NAMES.includes(entry.flag)).filter((entry) => isAllowed(entry.flag, ctx.model)).map(formatForCommand);
 }
+function fitParts(fit) {
+  if (fit === undefined)
+    return [];
+  return [
+    ...fit.targetHeight === undefined ? [] : [`--target-height ${fit.targetHeight}`],
+    ...fit.origin === "as-is" ? [] : [`--origin ${fit.origin}`]
+  ];
+}
 function outputParts(ctx) {
-  const parts = [`--out ${shellQuote(ctx.out)}`];
-  if (ctx.force === true)
-    parts.push("--force");
-  if (ctx.packageDir !== undefined)
-    parts.push(`--package-dir ${shellQuote(ctx.packageDir)}`);
-  return parts;
+  return [
+    `--out ${shellQuote(ctx.out)}`,
+    ...ctx.force === true ? ["--force"] : [],
+    ...ctx.packageDir === undefined ? [] : [`--package-dir ${shellQuote(ctx.packageDir)}`],
+    ...fitParts(ctx.fit)
+  ];
 }
 function repeatParts(ctx) {
   const dryRun = ctx.dryRun === true ? ["--dry-run"] : [];
@@ -10538,6 +11473,7 @@ function resolvePlanTarget(opts) {
     out: opts.out,
     force: opts.force,
     packageDir: opts.packageDir,
+    fit: opts.fit,
     dryRun: opts.dryRun
   };
   validateRigging(flagContext);
@@ -10588,6 +11524,7 @@ async function planGenerate3d(opts, deps) {
     inputKeys: Object.keys(opts.extraInput ?? {}),
     modelWarning: modelWarningFor(model),
     confirmCost: opts.confirmCost === true,
+    fit: opts.fit,
     ...naming
   };
 }
@@ -10649,6 +11586,12 @@ function inputNoteLines(plan) {
 function confirmationLines(plan) {
   return plan.riggingRequest !== null && !plan.confirmCost ? ["Add --confirm-cost to run."] : [];
 }
+function fitLines(plan) {
+  if (plan.fit === undefined)
+    return [];
+  const height = plan.fit.targetHeight === undefined ? "no scale" : `target height ${plan.fit.targetHeight} m`;
+  return [`Fit: ${height}, origin ${plan.fit.origin} (master, web, and rig outputs)`];
+}
 function formatGenerate3dPlan(plan) {
   return [
     `Would generate ${plan.outPath}`,
@@ -10657,6 +11600,7 @@ function formatGenerate3dPlan(plan) {
     `Preview ${plan.htmlPath}`,
     ...planModelLines(plan),
     ...modelWarningLines(plan),
+    ...fitLines(plan),
     ...formatReferencePlan(plan),
     "Request:",
     JSON.stringify(plan.input, null, 2),
@@ -10702,6 +11646,7 @@ function buildManifest2(args) {
     output: {
       path: args.outPath,
       sha256: args.sha256,
+      sourceSha256: args.sourceSha256,
       bytes: args.byteLength,
       contentType: GLB_CONTENT_TYPE
     },
@@ -10725,21 +11670,29 @@ function riggingFailure(args) {
   const request = args.requestId === null ? "" : ` for request ${args.requestId}`;
   return new Generate3dError(`Rigging failed${request} (${args.endpoint}): ${args.detail}. The generated mesh and manifest are kept: ${args.meshPath}.`);
 }
+async function prepareRigGlb(args) {
+  return normaliseMasterGlb(args.downloaded, args.fit, args.sharedFit);
+}
 async function downloadAndSaveGlb(args) {
-  let bytes;
+  let downloaded;
   try {
-    bytes = await args.deps.fetchGlb(args.url);
+    downloaded = await args.deps.fetchGlb(args.url);
   } catch (err2) {
     throw args.fail(`Failed to download ${args.label} (${args.url}): ${describeError(err2)}`);
   }
+  const prepared = await prepareRigGlb({
+    downloaded,
+    fit: args.fit,
+    sharedFit: args.sharedFit
+  });
   try {
-    await args.deps.writeFile(args.path, bytes);
+    await args.deps.writeFile(args.path, prepared.bytes);
   } catch (err2) {
     throw args.fail(`Failed to save ${args.label} ${args.path}: ${describeError(err2)}`);
   }
-  return bytes;
+  return prepared;
 }
-async function downloadAnimations(plan, deps, output, fail) {
+async function downloadAnimations(plan, deps, output, fail, sharedFit) {
   const animations = [];
   const files = [];
   for (const [index, animation] of output.animations.entries()) {
@@ -10747,14 +11700,23 @@ async function downloadAnimations(plan, deps, output, fail) {
     if (planned === undefined || planned.actionId !== animation.actionId) {
       throw fail(`No planned output path for animation clip ${animation.actionId}.`);
     }
-    const bytes = await downloadAndSaveGlb({
+    const prepared = await downloadAndSaveGlb({
       deps,
       url: animation.glbUrl,
       path: planned.path,
       label: `animation clip ${animation.actionId}`,
-      fail
+      fail,
+      fit: undefined,
+      sharedFit
+    });
+    files.push({
+      actionId: animation.actionId,
+      path: planned.path,
+      bytes: prepared.bytes,
+      materials: prepared.materials,
+      fit: prepared.fit,
+      ...definedErrors(prepared.normaliseError, prepared.fitError)
     });
-    files.push({ actionId: animation.actionId, path: planned.path, bytes });
     animations.push({
       actionId: animation.actionId,
       path: planned.path,
@@ -10791,14 +11753,15 @@ async function runRigging(plan, deps, modelGlbUrl) {
   } catch (err2) {
     throw fail(describeError(err2));
   }
-  const riggedBytes = await downloadAndSaveGlb({
+  const rigged = await downloadAndSaveGlb({
     deps,
     url: output.riggedGlbUrl,
     path: riggedGlbPath,
     label: "rigged GLB",
-    fail
+    fail,
+    fit: plan.fit
   });
-  const animations = await downloadAnimations(plan, deps, output, fail);
+  const animations = await downloadAnimations(plan, deps, output, fail, rigged.fit);
   return {
     section: {
       endpoint: request.endpoint,
@@ -10812,7 +11775,10 @@ async function runRigging(plan, deps, modelGlbUrl) {
       files: [],
       costLines: riggingCostLines(plan.animationActionIds.length)
     },
-    riggedBytes,
+    riggedBytes: rigged.bytes,
+    riggedMaterials: rigged.materials,
+    riggedFit: rigged.fit,
+    ...riggedErrorFields(rigged),
     animations: animations.bytes
   };
 }
@@ -10828,7 +11794,10 @@ function rigEntryNames(stem, kind, actionId) {
 async function buildOneRigFile(plan, deps, file) {
   const names = rigEntryNames(plan.stem, file.kind, file.actionId);
   try {
-    const web = await deps.createWebVariant(file.bytes, WEB_VARIANT_OPTIONS);
+    const web = await deps.createWebVariant(file.bytes, webVariantOptions(plan, {
+      materials: file.materials,
+      fit: file.fit
+    }));
     return { packaged: { ...file, ...names, web, webError: null }, message: null };
   } catch (err2) {
     const message = describeError(err2);
@@ -10844,13 +11813,19 @@ function rigFileInputs(plan, rig) {
       kind: "rigged",
       actionId: null,
       path: plan.riggedOutPath ?? "",
-      bytes: rig.riggedBytes
+      bytes: rig.riggedBytes,
+      materials: rig.riggedMaterials,
+      fit: rig.riggedFit,
+      ...definedErrors(rig.riggedNormaliseError, rig.riggedFitError)
     },
     ...rig.animations.map((animation) => ({
       kind: "animation",
       actionId: animation.actionId,
       path: animation.path,
-      bytes: animation.bytes
+      bytes: animation.bytes,
+      materials: animation.materials,
+      fit: animation.fit,
+      ...definedErrors(animation.normaliseError, animation.fitError)
     }))
   ];
 }
@@ -10878,6 +11853,9 @@ function rigFileManifestEntry(file) {
     actionId: file.actionId,
     path: file.path,
     bytes: file.bytes.byteLength,
+    materials: file.materials,
+    fit: file.fit,
+    ...definedErrors(file.normaliseError, file.fitError),
     webError: file.webError
   };
   if (file.web === null) {
@@ -10929,6 +11907,12 @@ function buildMasterVariant(args) {
     file: `${args.stem}.glb`,
     bytes: args.masterBytes.byteLength,
     sha256: args.masterSha256,
+    sourceSha256: args.sourceSha256,
+    materials: args.materials,
+    fit: args.fit,
+    ...args.normaliseError === undefined ? {} : { normaliseError: args.normaliseError },
+    ...args.fitError === undefined ? {} : { fitError: args.fitError },
+    checks: args.checks,
     triangles: args.source.triangles,
     textures: args.source.textures,
     extensionsUsed: args.source.extensionsUsed
@@ -10937,7 +11921,7 @@ function buildMasterVariant(args) {
 function rigWebFailures(files) {
   return files.filter((file) => file.webError !== null).map((file) => ({ file: file.entry, message: file.webError ?? "" }));
 }
-function webSettings(web) {
+function webSettings(web, checks) {
   return {
     maxTexturePx: WEB_VARIANT_MAX_TEXTURE_PX,
     textureFormat: "jpeg",
@@ -10945,7 +11929,10 @@ function webSettings(web) {
     dataQuality: WEB_VARIANT_DATA_TEXTURE_QUALITY,
     triangleTarget: WEB_VARIANT_TRIANGLE_TARGET,
     simplified: web.simplified,
-    skinnedPath: web.skinnedPath
+    skinnedPath: web.skinnedPath,
+    materials: web.materials,
+    fit: web.fit,
+    ...checks === undefined ? {} : { checks }
   };
 }
 function variantEntry(args) {
@@ -10962,14 +11949,14 @@ function variantEntry(args) {
     ...args.settings === undefined ? {} : { settings: args.settings }
   };
 }
-function buildWebVariantEntry(stem, web, webSha256) {
+function buildWebVariantEntry(stem, web, webSha256, checks) {
   return {
     ...variantEntry({
       name: "web",
       file: `web/${stem}.web.glb`,
       bytes: web.bytes,
       stats: web,
-      settings: webSettings(web)
+      settings: webSettings(web, checks)
     }),
     sha256: webSha256
   };
@@ -10997,9 +11984,14 @@ function buildPackageManifest(args) {
         stem: args.stem,
         masterBytes: args.masterBytes,
         masterSha256: args.masterSha256,
+        sourceSha256: args.masterSourceSha256,
+        materials: args.masterMaterials,
+        fit: args.masterFit,
+        ...args.masterErrors,
+        checks: args.masterChecks,
         source: args.web.source
       }),
-      buildWebVariantEntry(args.stem, args.web, args.webSha256),
+      buildWebVariantEntry(args.stem, args.web, args.webSha256, args.webChecks),
       ...args.rigVariants
     ],
     referenceImage: args.reference,
@@ -11027,9 +12019,16 @@ function buildPackageEntries(args) {
 function packageFailure(plan, step, err2) {
   return new Generate3dError(`Failed to ${step}: ${describeError(err2)}. The master mesh and manifest are kept: ${plan.outPath}.`);
 }
-async function buildWebVariant(plan, deps, masterBytes) {
+function webVariantOptions(plan, processed) {
+  return {
+    ...WEB_VARIANT_OPTIONS,
+    ...plan.fit === undefined ? {} : { fit: plan.fit },
+    processed
+  };
+}
+async function buildWebVariant(plan, deps, masterBytes, processed) {
   try {
-    return await deps.createWebVariant(masterBytes, WEB_VARIANT_OPTIONS);
+    return await deps.createWebVariant(masterBytes, webVariantOptions(plan, processed));
   } catch (err2) {
     throw packageFailure(plan, "build the web variant", err2);
   }
@@ -11077,8 +12076,13 @@ async function writeZipAndPreview(plan, deps, files) {
 }
 async function writePackage(args) {
   const { plan, deps, master, paths, reference } = args;
-  const web = await buildWebVariant(plan, deps, master.bytes);
+  const web = await buildWebVariant(plan, deps, master.bytes, {
+    materials: master.materials,
+    fit: master.fit
+  });
   const webSha256 = createHash3("sha256").update(web.bytes).digest("hex");
+  const webChecks = await checksForGlb(web.bytes);
+  const directionalEnvironment = await directionalEnvironmentPng();
   const packageManifest = buildPackageManifest({
     packageName: args.packageName,
     createdAt: deps.now().toISOString(),
@@ -11088,6 +12092,12 @@ async function writePackage(args) {
     inputImage: master.inputImage,
     masterBytes: master.bytes,
     masterSha256: master.sha256,
+    masterSourceSha256: master.sourceSha256,
+    masterMaterials: master.materials,
+    masterFit: master.fit,
+    masterErrors: definedErrors(master.normaliseError, master.fitError),
+    masterChecks: args.masterChecks,
+    webChecks,
     web,
     webSha256,
     stem: plan.stem,
@@ -11108,6 +12118,7 @@ async function writePackage(args) {
     modelId: plan.model.id,
     prompt: args.prompt?.trim() ?? null,
     requestId: master.requestId,
+    masterGlb: master.bytes,
     webGlb: web.bytes,
     webSha256,
     webTriangles: web.triangles,
@@ -11115,7 +12126,9 @@ async function writePackage(args) {
     masterBytes: master.bytes.byteLength,
     webBytes: web.bytes.byteLength,
     masterZipEntry: `${plan.stem}.glb`,
-    zipName: `${args.packageName}.zip`
+    zipName: `${args.packageName}.zip`,
+    checks: args.masterChecks,
+    directionalEnvironmentPng: directionalEnvironment
   });
   await writeZipAndPreview(plan, deps, { ...paths, zipBytes, html, force: args.force });
   return paths;
@@ -11168,6 +12181,112 @@ async function ensureOutputDirs(plan, deps) {
   await deps.ensureParentDir(plan.outPath);
   await deps.ensureParentDir(plan.zipPath);
 }
+function glbIo() {
+  return new NodeIO2().registerExtensions(ALL_EXTENSIONS2).registerDependencies({ "meshopt.decoder": MeshoptDecoder });
+}
+async function analyseGlb(glb) {
+  return analyseDocument(await glbIo().readBinary(glb));
+}
+async function checksForGlb(glb) {
+  try {
+    return computeChecks(await analyseGlb(glb));
+  } catch {
+    return [];
+  }
+}
+function sourceFallback(glb, errors) {
+  return { bytes: glb, materials: [], fit: null, ...errors };
+}
+function dropMeshoptExtension(document2) {
+  document2.getRoot().listExtensionsUsed().find((extension) => extension.extensionName === "EXT_meshopt_compression")?.dispose();
+}
+function definedErrors(normaliseError, fitError) {
+  return {
+    ...normaliseError === undefined ? {} : { normaliseError },
+    ...fitError === undefined ? {} : { fitError }
+  };
+}
+function riggedErrorFields(prepared) {
+  return {
+    ...prepared.normaliseError === undefined ? {} : { riggedNormaliseError: prepared.normaliseError },
+    ...prepared.fitError === undefined ? {} : { riggedFitError: prepared.fitError }
+  };
+}
+async function readGlbDocument(glb) {
+  try {
+    return { document: await glbIo().readBinary(glb) };
+  } catch (err2) {
+    return { normaliseError: `Normalisation failed: ${describeError(err2)}` };
+  }
+}
+function defaultFitResult(analysis) {
+  return {
+    origin: "as-is",
+    targetHeight: null,
+    scale: 1,
+    translation: [0, 0, 0],
+    bounds: analysis.bounds
+  };
+}
+function applySharedFit(document2, sharedFit) {
+  if (sharedFit !== null)
+    applyFitTransform(document2, sharedFit);
+  return { fit: sharedFit };
+}
+async function fitByOptions(document2, analysis, fit) {
+  if (fit === undefined)
+    return { fit: defaultFitResult(analysis) };
+  try {
+    return { fit: await applyFit(document2, analysis, fit) };
+  } catch (err2) {
+    return { fitError: `Fit failed: ${describeError(err2)}` };
+  }
+}
+async function prepareFit(document2, analysis, fit, sharedFit) {
+  if (sharedFit !== undefined)
+    return applySharedFit(document2, sharedFit);
+  return fitByOptions(document2, analysis, fit);
+}
+async function prepareDocument(document2, fit, sharedFit) {
+  let analysis;
+  let materials;
+  try {
+    analysis = await analyseDocument(document2);
+    materials = await normaliseMaterials(document2, analysis);
+  } catch (err2) {
+    return { normaliseError: `Normalisation failed: ${describeError(err2)}` };
+  }
+  const preparedFit = await prepareFit(document2, analysis, fit, sharedFit);
+  if (!("fit" in preparedFit))
+    return preparedFit;
+  return { materials, fit: preparedFit.fit };
+}
+async function writePreparedDocument(io, document2) {
+  try {
+    return await io.writeBinary(document2);
+  } catch {
+    return null;
+  }
+}
+async function normaliseMasterGlb(glb, fit, sharedFit) {
+  const read = await readGlbDocument(glb);
+  if ("normaliseError" in read)
+    return sourceFallback(glb, read);
+  dropMeshoptExtension(read.document);
+  const prepared = await prepareDocument(read.document, fit, sharedFit);
+  if (!("materials" in prepared))
+    return sourceFallback(glb, prepared);
+  const { prune } = await import("@gltf-transform/functions");
+  read.document.setLogger(SILENT_LOGGER2);
+  await read.document.transform(prune({ propertyTypes: ["Texture"], keepSolidTextures: true }));
+  const bytes = await writePreparedDocument(glbIo(), read.document);
+  if (bytes === null) {
+    return sourceFallback(glb, {
+      normaliseError: "Normalisation failed: the GLB could not be written back."
+    });
+  }
+  return { bytes, materials: prepared.materials, fit: prepared.fit };
+}
 async function generateMaster(plan, deps, opts, reference = null) {
   const inputImage = reference?.inputImage ?? await uploadInputImage2(deps, plan.inputTarget);
   const input = plan.model.buildInput({
@@ -11178,9 +12297,11 @@ async function generateMaster(plan, deps, opts, reference = null) {
   const result = await deps.falSubscribe(plan.model.id, input);
   const output = readModelOutput(plan.model, result.data, result.requestId);
   const recovery = { requestId: result.requestId, url: output.glbUrl };
-  const bytes = await withRecovery("download", recovery, () => deps.fetchGlb(output.glbUrl));
-  await withRecovery("save", recovery, () => deps.writeFile(plan.outPath, bytes));
-  const sha2562 = createHash3("sha256").update(bytes).digest("hex");
+  const sourceBytes = await withRecovery("download", recovery, () => deps.fetchGlb(output.glbUrl));
+  const normalised = await normaliseMasterGlb(sourceBytes, plan.fit);
+  await withRecovery("save", recovery, () => deps.writeFile(plan.outPath, normalised.bytes));
+  const sourceSha256 = createHash3("sha256").update(sourceBytes).digest("hex");
+  const sha2562 = createHash3("sha256").update(normalised.bytes).digest("hex");
   const manifest = buildManifest2({
     model: plan.model,
     input,
@@ -11188,7 +12309,8 @@ async function generateMaster(plan, deps, opts, reference = null) {
     requestId: result.requestId,
     outPath: plan.outPath,
     sha256: sha2562,
-    byteLength: bytes.byteLength,
+    sourceSha256,
+    byteLength: normalised.bytes.byteLength,
     textureUrls: output.textureUrls,
     referenceImage: buildReferenceManifest(plan, reference, inputImage),
     generatedAt: deps.now().toISOString(),
@@ -11196,8 +12318,12 @@ async function generateMaster(plan, deps, opts, reference = null) {
   });
   await deps.writeJson(plan.manifestPath, manifest);
   return {
-    bytes,
+    bytes: normalised.bytes,
     sha256: sha2562,
+    sourceSha256,
+    materials: normalised.materials,
+    fit: normalised.fit,
+    ...definedErrors(normalised.normaliseError, normalised.fitError),
     requestId: result.requestId,
     inputImage,
     glbUrl: output.glbUrl,
@@ -11249,7 +12375,8 @@ async function packageOrError(args) {
       prompt: args.prompt,
       force: args.force,
       reference: args.reference,
-      rigFiles: args.rigFiles
+      rigFiles: args.rigFiles,
+      masterChecks: args.masterChecks
     });
     return null;
   } catch (err2) {
@@ -11269,7 +12396,8 @@ async function packageRun(args) {
     prompt: args.opts.prompt,
     force: args.opts.force === true,
     reference: args.reference,
-    rigFiles: args.rigging.files
+    rigFiles: args.rigging.files,
+    masterChecks: args.masterChecks
   });
   if (packageError === null) {
     await args.deps.writeJson(args.plan.manifestPath, packagedManifest(args.master, args.rigging, args.plan));
@@ -11286,6 +12414,8 @@ async function generate3d(opts, deps) {
   const reference = await generateReferenceFile(plan, deps);
   const bundledReference = await bundleReference(plan, deps, reference);
   const master = await generateMaster(plan, deps, opts, reference);
+  const masterChecks = await checksForGlb(master.bytes);
+  const warnings = [master.normaliseError, master.fitError].filter((warning) => warning !== undefined);
   const rigging = await rigOrError(plan, deps, master);
   const built = await buildRigFilesOrEmpty(plan, deps, rigging);
   rigging.files = built.files;
@@ -11293,19 +12423,34 @@ async function generate3d(opts, deps) {
   const rigged = rigManifest(master, rigging);
   if (rigged !== null)
     await deps.writeJson(plan.manifestPath, rigged);
-  await packageRun({ plan, deps, master, opts, reference: bundledReference, rigging });
+  await packageRun({
+    plan,
+    deps,
+    master,
+    opts,
+    reference: bundledReference,
+    rigging,
+    masterChecks
+  });
   return {
     outPath: plan.outPath,
     manifestPath: plan.manifestPath,
     zipPath: plan.zipPath,
     htmlPath: plan.htmlPath,
     sha256: master.sha256,
+    checks: masterChecks,
+    warnings,
     costLines: formatGenerate3dCost(plan.costLines, plan.model.id, plan.generationCostKnown)
   };
 }
-var GLB_CONTENT_TYPE = "model/gltf-binary", GLB_EXTENSION = ".glb", PLANNED_MODEL_URL = "<generated mesh GLB URL>", RIGGING_HUMANOID_WARNING = "Rigging (Meshy) expects a humanoid mesh; non-humanoid meshes fail on fal.", WEB_VARIANT_TRIANGLE_TARGET = 30000, WEB_VARIANT_MAX_TEXTURE_PX = 1024, WEB_VARIANT_TEXTURE_QUALITY = 80, WEB_VARIANT_DATA_TEXTURE_QUALITY = 95, PACKAGE_MANIFEST_NAME = "manifest.json", PACKAGE_PRICING_NOTE = "list-price estimate, not a billed amount", HTTP_URL_PATTERN2, INPUT_IMAGE_CONTENT_TYPES2, INPUT_REQUIREMENTS, PACKAGE_COLLISION_HINT = "Another run used this name in the same second; wait a second, use a different --package-dir, or pass --force.", FLAG_CAPABILITY, INPUT_FLAG_NAMES, INPUT_PLACEHOLDERS, INPUT_CAPABILITY, RESERVED_INPUT_FLAGS, GENERATED_REFERENCE_URL = "<generated reference image URL>", WEB_VARIANT_OPTIONS;
+var GLB_CONTENT_TYPE = "model/gltf-binary", GLB_EXTENSION = ".glb", PLANNED_MODEL_URL = "<generated mesh GLB URL>", RIGGING_HUMANOID_WARNING = "Rigging (Meshy) expects a humanoid mesh; non-humanoid meshes fail on fal.", WEB_VARIANT_TRIANGLE_TARGET = 30000, WEB_VARIANT_MAX_TEXTURE_PX = 1024, WEB_VARIANT_TEXTURE_QUALITY = 80, WEB_VARIANT_DATA_TEXTURE_QUALITY = 95, PACKAGE_MANIFEST_NAME = "manifest.json", PACKAGE_PRICING_NOTE = "list-price estimate, not a billed amount", HTTP_URL_PATTERN2, INPUT_IMAGE_CONTENT_TYPES2, INPUT_REQUIREMENTS, PACKAGE_COLLISION_HINT = "Another run used this name in the same second; wait a second, use a different --package-dir, or pass --force.", FLAG_CAPABILITY, INPUT_FLAG_NAMES, INPUT_PLACEHOLDERS, INPUT_CAPABILITY, RESERVED_INPUT_FLAGS, GENERATED_REFERENCE_URL = "<generated reference image URL>", WEB_VARIANT_OPTIONS, SILENT_LOGGER2;
 var init_generate_3d = __esm(() => {
+  init_meshoptimizer();
+  init_asset_analysis();
+  init_checks();
   init_deps2();
+  init_fit();
+  init_material_normalise();
   init_model_registry();
   init_package_name();
   init_rigging();
@@ -11345,6 +12490,192 @@ var init_generate_3d = __esm(() => {
     quality: WEB_VARIANT_TEXTURE_QUALITY,
     dataQuality: WEB_VARIANT_DATA_TEXTURE_QUALITY
   };
+  SILENT_LOGGER2 = {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {}
+  };
+});
+
+// src/commands/generate-3d/rebuild-preview.ts
+var exports_rebuild_preview = {};
+__export(exports_rebuild_preview, {
+  rebuildPreviewFromZip: () => rebuildPreviewFromZip
+});
+import { readFile as readFile3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname5, join as join3 } from "node:path";
+import { NodeIO as NodeIO3 } from "@gltf-transform/core";
+import { ALL_EXTENSIONS as ALL_EXTENSIONS3 } from "@gltf-transform/extensions";
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidPackage(zipPath, detail) {
+  return new Error(`Cannot rebuild the preview from ${zipPath}: ${detail}`);
+}
+function requireString(record, field, zipPath) {
+  const value = record[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw invalidPackage(zipPath, `manifest.json has no ${field}.`);
+  }
+  return value;
+}
+function requireCount(record, field, zipPath) {
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw invalidPackage(zipPath, `manifest.json has no valid ${field}.`);
+  }
+  return value;
+}
+function requireRecord(record, field, zipPath) {
+  const value = record[field];
+  if (!isRecord5(value)) {
+    throw invalidPackage(zipPath, `manifest.json has no ${field} object.`);
+  }
+  return value;
+}
+function readPrompt(generator, zipPath) {
+  const prompt = generator.prompt;
+  if (prompt === null || typeof prompt === "string")
+    return prompt;
+  throw invalidPackage(zipPath, "manifest.json has no valid generator.prompt.");
+}
+function requireVariant(variants, name, zipPath) {
+  const match = variants.find((variant) => isRecord5(variant) && variant.name === name);
+  if (!isRecord5(match)) {
+    throw invalidPackage(zipPath, `manifest.json has no "${name}" variant.`);
+  }
+  return {
+    name,
+    file: requireString(match, "file", zipPath),
+    bytes: requireCount(match, "bytes", zipPath),
+    triangles: requireCount(match, "triangles", zipPath),
+    sha256: requireString(match, "sha256", zipPath)
+  };
+}
+function parseManifest(bytes, zipPath) {
+  let raw;
+  try {
+    raw = JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    throw invalidPackage(zipPath, "manifest.json is not valid JSON.");
+  }
+  if (!isRecord5(raw)) {
+    throw invalidPackage(zipPath, "manifest.json is not an object.");
+  }
+  const generator = requireRecord(raw, "generator", zipPath);
+  const variants = raw.variants;
+  if (!Array.isArray(variants)) {
+    throw invalidPackage(zipPath, "manifest.json has no variants array.");
+  }
+  return {
+    model: requireString(generator, "model", zipPath),
+    requestId: requireString(generator, "requestId", zipPath),
+    prompt: readPrompt(generator, zipPath),
+    master: requireVariant(variants, "master", zipPath),
+    web: requireVariant(variants, "web", zipPath)
+  };
+}
+function requireEntry(files, variant, role, zipPath) {
+  const bytes = files[variant.file];
+  if (bytes === undefined) {
+    throw invalidPackage(zipPath, `the ${role} GLB ${variant.file} is missing from the zip.`);
+  }
+  if (bytes.byteLength !== variant.bytes) {
+    throw invalidPackage(zipPath, `${variant.file} is ${bytes.byteLength} bytes in the zip, but manifest.json says ${variant.bytes}.`);
+  }
+  return bytes;
+}
+async function readArchive(zipPath) {
+  const archive = await readFile3(zipPath).catch((err2) => {
+    throw new Error(`Cannot read the package ${zipPath}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  });
+  try {
+    return unzipSync(archive);
+  } catch (err2) {
+    throw invalidPackage(zipPath, `not a readable zip archive (${err2 instanceof Error ? err2.message : String(err2)}).`);
+  }
+}
+function loadPackage(zipPath, files) {
+  const manifestBytes = files[PACKAGE_MANIFEST_NAME2];
+  if (manifestBytes === undefined) {
+    throw invalidPackage(zipPath, `${PACKAGE_MANIFEST_NAME2} is missing from the zip.`);
+  }
+  const manifest = parseManifest(manifestBytes, zipPath);
+  return {
+    manifest,
+    masterGlb: requireEntry(files, manifest.master, "master", zipPath),
+    webGlb: requireEntry(files, manifest.web, "web", zipPath)
+  };
+}
+function packageBase(zipName, zipPath) {
+  if (!zipName.endsWith(".zip") || zipName.length === ".zip".length) {
+    throw invalidPackage(zipPath, "the package must be a non-empty .zip file.");
+  }
+  return zipName.slice(0, -".zip".length);
+}
+async function requireWritablePreview(htmlPath, force) {
+  const stats = await stat2(htmlPath).catch(() => null);
+  if (stats === null)
+    return;
+  if (stats.isDirectory()) {
+    throw new Error(`Preview is a directory: ${htmlPath}. Pass a file path.`);
+  }
+  if (!force) {
+    throw new Error(`Preview already exists: ${htmlPath}. Pass --force to overwrite.`);
+  }
+}
+async function writePreview(htmlPath, html, force) {
+  await requireWritablePreview(htmlPath, force);
+  try {
+    await writeFile2(htmlPath, new TextEncoder().encode(html), { flag: force ? "w" : "wx" });
+  } catch (err2) {
+    throw new Error(`Cannot write the preview ${htmlPath}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  }
+}
+async function rebuildPreviewFromZip(zipPath, options) {
+  const zipName = basename2(zipPath);
+  const base = packageBase(zipName, zipPath);
+  const htmlPath = join3(dirname5(zipPath), `${base}.html`);
+  await requireWritablePreview(htmlPath, options.force);
+  const { manifest, masterGlb, webGlb } = loadPackage(zipPath, await readArchive(zipPath));
+  let checks = [];
+  let checksNote = null;
+  try {
+    const io = new NodeIO3().registerExtensions(ALL_EXTENSIONS3).registerDependencies({ "meshopt.decoder": MeshoptDecoder });
+    checks = computeChecks(await analyseDocument(await io.readBinary(masterGlb)));
+  } catch (err2) {
+    const detail = err2 instanceof Error ? err2.message : String(err2);
+    checksNote = `Checks unavailable: ${detail}`;
+  }
+  const directionalEnvironment = await directionalEnvironmentPng();
+  const html = renderPreviewHtml({
+    title: base,
+    modelId: manifest.model,
+    prompt: manifest.prompt,
+    requestId: manifest.requestId,
+    masterGlb,
+    webGlb,
+    webSha256: manifest.web.sha256,
+    webTriangles: manifest.web.triangles,
+    masterTriangles: manifest.master.triangles,
+    masterBytes: manifest.master.bytes,
+    webBytes: manifest.web.bytes,
+    masterZipEntry: manifest.master.file,
+    zipName,
+    checks,
+    checksNote,
+    directionalEnvironmentPng: directionalEnvironment
+  });
+  await writePreview(htmlPath, html, options.force);
+  return htmlPath;
+}
+var PACKAGE_MANIFEST_NAME2 = "manifest.json";
+var init_rebuild_preview = __esm(() => {
+  init_esm();
+  init_meshoptimizer();
+  init_asset_analysis();
+  init_checks();
 });
 
 // ../../node_modules/.pnpm/pngjs@6.0.0/node_modules/pngjs/lib/chunkstream.js
@@ -12156,17 +13487,17 @@ var require_bitmapper = __commonJS((exports) => {
     }
     return rawPos;
   }
-  function mapImageCustomBit(image, pxData, getPxPos, bpp, bits, maxBit) {
+  function mapImageCustomBit(image, pxData, getPxPos, bpp, bits2, maxBit) {
     let imageWidth = image.width;
     let imageHeight = image.height;
     let imagePass = image.index;
     for (let y = 0;y < imageHeight; y++) {
       for (let x2 = 0;x2 < imageWidth; x2++) {
-        let pixelData = bits.get(bpp);
+        let pixelData = bits2.get(bpp);
         let pxPos = getPxPos(x2, y, imagePass);
         pixelBppCustomMapper[bpp](pxData, pixelData, pxPos, maxBit);
       }
-      bits.resetAfterLine();
+      bits2.resetAfterLine();
     }
   }
   exports.dataToBitMap = function(data, bitmapInfo) {
@@ -12175,9 +13506,9 @@ var require_bitmapper = __commonJS((exports) => {
     let depth = bitmapInfo.depth;
     let bpp = bitmapInfo.bpp;
     let interlace = bitmapInfo.interlace;
-    let bits;
+    let bits2;
     if (depth !== 8) {
-      bits = bitRetriever(data, depth);
+      bits2 = bitRetriever(data, depth);
     }
     let pxData;
     if (depth <= 8) {
@@ -12205,7 +13536,7 @@ var require_bitmapper = __commonJS((exports) => {
       if (depth === 8) {
         rawPos = mapImage8Bit(images[imageIndex], pxData, getPxPos, bpp, data, rawPos);
       } else {
-        mapImageCustomBit(images[imageIndex], pxData, getPxPos, bpp, bits, maxBit);
+        mapImageCustomBit(images[imageIndex], pxData, getPxPos, bpp, bits2, maxBit);
       }
     }
     if (depth === 8) {
@@ -12213,7 +13544,7 @@ var require_bitmapper = __commonJS((exports) => {
         throw new Error("extra data found");
       }
     } else {
-      bits.end();
+      bits2.end();
     }
     return pxData;
   };
@@ -12916,13 +14247,13 @@ var require_sync_inflate = __commonJS((exports, module) => {
     }
     return engine._processChunk(buffer, flushFlag);
   }
-  function inflateSync(buffer, opts) {
+  function inflateSync2(buffer, opts) {
     return zlibBufferSync(new Inflate(opts), buffer);
   }
-  module.exports = exports = inflateSync;
+  module.exports = exports = inflateSync2;
   exports.Inflate = Inflate;
   exports.createInflate = createInflate;
-  exports.inflateSync = inflateSync;
+  exports.inflateSync = inflateSync2;
 });
 
 // ../../node_modules/.pnpm/pngjs@6.0.0/node_modules/pngjs/lib/sync-reader.js
@@ -12983,7 +14314,7 @@ var require_filter_parse_sync = __commonJS((exports) => {
 var require_parser_sync = __commonJS((exports, module) => {
   var hasSyncZlib = true;
   var zlib = __require("zlib");
-  var inflateSync = require_sync_inflate();
+  var inflateSync2 = require_sync_inflate();
   if (!zlib.deflateSync) {
     hasSyncZlib = false;
   }
@@ -13045,7 +14376,7 @@ var require_parser_sync = __commonJS((exports, module) => {
     } else {
       let rowSize = (metaData.width * metaData.bpp * metaData.depth + 7 >> 3) + 1;
       let imageSize = rowSize * metaData.height;
-      inflatedData = inflateSync(inflateData, {
+      inflatedData = inflateSync2(inflateData, {
         chunkSize: imageSize,
         maxLength: imageSize
       });
@@ -13239,7 +14570,7 @@ var exports_slice_deps = {};
 __export(exports_slice_deps, {
   createDefaultSliceImageDeps: () => createDefaultSliceImageDeps
 });
-import { lstat, mkdir as mkdir3, readFile as readFile5, stat as stat4 } from "node:fs/promises";
+import { lstat, mkdir as mkdir3, readFile as readFile6, stat as stat5 } from "node:fs/promises";
 function decodePng(bytes) {
   const png = PNG.sync.read(Buffer.from(bytes));
   return { width: png.width, height: png.height, data: png.data };
@@ -13258,7 +14589,7 @@ function classifyStat(stats) {
 }
 async function statInput(path) {
   try {
-    return classifyStat(await stat4(path));
+    return classifyStat(await stat5(path));
   } catch (err2) {
     if (err2.code === "ENOENT") {
       return { kind: "missing", size: 0 };
@@ -13269,7 +14600,7 @@ async function statInput(path) {
 async function readJsonIfExists(path) {
   let text;
   try {
-    text = await readFile5(path, "utf8");
+    text = await readFile6(path, "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") {
       return;
@@ -13280,7 +14611,7 @@ async function readJsonIfExists(path) {
 }
 async function fileIdentity(path) {
   try {
-    const stats = await stat4(path);
+    const stats = await stat5(path);
     return { dev: stats.dev, ino: stats.ino };
   } catch (err2) {
     if (err2.code === "ENOENT") {
@@ -13306,7 +14637,7 @@ function createDefaultSliceImageDeps() {
   return {
     pathStatus,
     statInput,
-    readFile: readFile5,
+    readFile: readFile6,
     readJsonIfExists,
     decodePng,
     encodePng,
@@ -13344,7 +14675,7 @@ var init_remove_image_background_deps = __esm(() => {
 });
 
 // src/commands/remove-image-background/remove-image-background-fal.ts
-import { basename as basename3, resolve as resolve4 } from "node:path";
+import { basename as basename4, resolve as resolve4 } from "node:path";
 function validateBackgroundResult(raw, model) {
   const unexpected = new RemoveBackgroundFalError(`fal returned no image for ${model}`);
   if (!isRecord2(raw))
@@ -13499,7 +14830,7 @@ async function removeBackgroundFal(options, deps) {
     model: spec.model,
     input: {
       ...engine === "birefnet" ? { mode: "Matting", output_format: "png" } : {},
-      source: basename3(inPath),
+      source: basename4(inPath),
       sourceBytes: source.bytes.byteLength,
       sourceSha256: sha256(source.bytes),
       width: source.width,
@@ -13568,7 +14899,7 @@ var exports_remove_image_background_fal_deps = {};
 __export(exports_remove_image_background_fal_deps, {
   createDefaultRemoveBackgroundFalDeps: () => createDefaultRemoveBackgroundFalDeps
 });
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 function mebibytes(bytes) {
   return Math.round(bytes / (1024 * 1024));
 }
@@ -13608,7 +14939,7 @@ function createDefaultRemoveBackgroundFalDeps() {
     pathStatus: slice.pathStatus,
     writeFile: slice.writeFile,
     writeJson: slice.writeJson,
-    ensureParentDir: (path) => slice.ensureDir(dirname6(path)),
+    ensureParentDir: (path) => slice.ensureDir(dirname7(path)),
     now: () => new Date,
     sdkVersion: readInstalledPackageVersion("@fal-ai/client"),
     log: (message) => console.log(message)
@@ -13711,15 +15042,15 @@ var init_stdin_heredoc = __esm(() => {
 
 // src/version.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname7, join as join5 } from "node:path";
+import { dirname as dirname8, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 function getVersion() {
   try {
     const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname2 = dirname7(__filename2);
+    const __dirname2 = dirname8(__filename2);
     const possiblePaths = [
-      join5(__dirname2, "..", "package.json"),
-      join5(__dirname2, "..", "..", "package.json")
+      join6(__dirname2, "..", "package.json"),
+      join6(__dirname2, "..", "..", "package.json")
     ];
     for (const packagePath of possiblePaths) {
       try {
@@ -21221,12 +22552,12 @@ __export(exports_storage, {
 });
 import * as fs from "node:fs/promises";
 import { homedir, hostname } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 async function ensureConfigDir() {
   await fs.mkdir(CHATROOM_DIR, { recursive: true, mode: 448 });
 }
 function getAuthFilePath() {
-  return join6(CHATROOM_DIR, AUTH_FILE);
+  return join7(CHATROOM_DIR, AUTH_FILE);
 }
 function parseJsonc(content) {
   const jsonContent = content.split(`
@@ -21394,7 +22725,7 @@ var CHATROOM_DIR, AUTH_FILE = "auth.jsonc", PRODUCTION_CONVEX_URL = "https://cha
 var init_storage = __esm(() => {
   init_client2();
   init_version();
-  CHATROOM_DIR = join6(homedir(), ".chatroom");
+  CHATROOM_DIR = join7(homedir(), ".chatroom");
 });
 
 // ../../node_modules/.pnpm/convex@1.45.0_react@19.2.7/node_modules/convex/dist/esm/server/pagination.js
@@ -22845,7 +24176,7 @@ function make(combine2) {
 function min(order) {
   return make((self2, that) => order(self2, that) === -1 ? self2 : that);
 }
-function max(order) {
+function max2(order) {
   return make((self2, that) => order(self2, that) === 1 ? self2 : that);
 }
 
@@ -23038,7 +24369,7 @@ var init_result = __esm(() => {
 function make4(compare) {
   return (self2, that) => self2 === that ? 0 : compare(self2, that);
 }
-var Number2, mapInput, isLessThan = (O) => dual(2, (self2, that) => O(self2, that) === -1), isGreaterThan = (O) => dual(2, (self2, that) => O(self2, that) === 1), isLessThanOrEqualTo = (O) => dual(2, (self2, that) => O(self2, that) !== 1), isGreaterThanOrEqualTo = (O) => dual(2, (self2, that) => O(self2, that) !== -1), min2 = (O) => dual(2, (self2, that) => self2 === that || O(self2, that) < 1 ? self2 : that), max2 = (O) => dual(2, (self2, that) => self2 === that || O(self2, that) > -1 ? self2 : that), clamp = (O) => dual(2, (self2, options) => min2(O)(options.maximum, max2(O)(options.minimum, self2))), isBetween = (O) => dual(2, (self2, options) => !isLessThan(O)(self2, options.minimum) && !isGreaterThan(O)(self2, options.maximum));
+var Number2, mapInput, isLessThan = (O) => dual(2, (self2, that) => O(self2, that) === -1), isGreaterThan = (O) => dual(2, (self2, that) => O(self2, that) === 1), isLessThanOrEqualTo = (O) => dual(2, (self2, that) => O(self2, that) !== 1), isGreaterThanOrEqualTo = (O) => dual(2, (self2, that) => O(self2, that) !== -1), min2 = (O) => dual(2, (self2, that) => self2 === that || O(self2, that) < 1 ? self2 : that), max3 = (O) => dual(2, (self2, that) => self2 === that || O(self2, that) > -1 ? self2 : that), clamp = (O) => dual(2, (self2, options) => min2(O)(options.maximum, max3(O)(options.minimum, self2))), isBetween = (O) => dual(2, (self2, options) => !isLessThan(O)(self2, options.minimum) && !isGreaterThan(O)(self2, options.maximum));
 var init_Order = __esm(() => {
   init_Function();
   Number2 = /* @__PURE__ */ make4((self2, that) => {
@@ -23050,7 +24381,7 @@ var init_Order = __esm(() => {
       return 1;
     return self2 < that ? -1 : 1;
   });
-  mapInput = /* @__PURE__ */ dual(2, (self2, f) => make4((b1, b2) => self2(f(b1), f(b2))));
+  mapInput = /* @__PURE__ */ dual(2, (self2, f) => make4((b1, b22) => self2(f(b1), f(b22))));
 });
 
 // ../../node_modules/.pnpm/effect@4.0.1/node_modules/effect/dist/Option.js
@@ -23462,7 +24793,7 @@ __export(exports_Duration, {
   min: () => min3,
   millis: () => millis,
   micros: () => micros,
-  max: () => max3,
+  max: () => max4,
   matchPair: () => matchPair,
   match: () => match2,
   isZero: () => isZero,
@@ -23731,7 +25062,7 @@ var TypeId4 = "~effect/Duration", bigint0, bigint1, bigint2, bigint10, bigint24,
   onMillis: (self3, that2) => self3 === that2,
   onNanos: (self3, that2) => self3 === that2,
   onInfinity: (self3, that2) => self3.value._tag === that2.value._tag
-}), min3, max3, clamp2, divide, divideUnsafe, times, subtract, sum, isLessThan2, isLessThanOrEqualTo2, isGreaterThan2, isGreaterThanOrEqualTo2, equals2, parts = (self2) => {
+}), min3, max4, clamp2, divide, divideUnsafe, times, subtract, sum, isLessThan2, isLessThanOrEqualTo2, isGreaterThan2, isGreaterThanOrEqualTo2, equals2, parts = (self2) => {
   if (self2.value._tag === "Infinity") {
     return {
       days: Infinity,
@@ -23938,7 +25269,7 @@ var init_Duration = __esm(() => {
   }));
   between = /* @__PURE__ */ isBetween(Order);
   min3 = /* @__PURE__ */ min2(Order);
-  max3 = /* @__PURE__ */ max2(Order);
+  max4 = /* @__PURE__ */ max3(Order);
   clamp2 = /* @__PURE__ */ clamp(Order);
   divide = /* @__PURE__ */ dual(2, (self2, by) => {
     if (!Number.isFinite(by))
@@ -24023,7 +25354,7 @@ var init_Duration = __esm(() => {
   isGreaterThanOrEqualTo2 = /* @__PURE__ */ isGreaterThanOrEqualTo(Order);
   equals2 = /* @__PURE__ */ dual(2, (self2, that) => Equivalence(self2, that));
   ReducerSum = /* @__PURE__ */ make2(sum, zero);
-  CombinerMax = /* @__PURE__ */ max(Order);
+  CombinerMax = /* @__PURE__ */ max2(Order);
   CombinerMin = /* @__PURE__ */ min(Order);
 });
 
@@ -25120,7 +26451,7 @@ ${prefix}}`;
   let expiresAt = 0;
   let exit2;
   let current;
-  const join7 = (fiber2, run) => {
+  const join8 = (fiber2, run) => {
     run.awaiters++;
     onExitUnsafe(fiber2, () => {
       if (--run.awaiters > 0 || current !== run)
@@ -25132,7 +26463,7 @@ ${prefix}}`;
   };
   return [withFiber((fiber2) => {
     if (current !== undefined)
-      return join7(fiber2, current);
+      return join8(fiber2, current);
     if (exit2 !== undefined && (expiresAt === Infinity || fiber2.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)) {
       return exit2;
     }
@@ -25153,7 +26484,7 @@ ${prefix}}`;
       expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration;
       exit2 = exit_;
     }), true, true);
-    return run.fiber._exit ?? join7(fiber2, run);
+    return run.fiber._exit ?? join8(fiber2, run);
   }), sync(() => {
     exit2 = undefined;
   })];
@@ -27863,11 +29194,11 @@ var TypeId10 = "~effect/Cron", CronProto, isCron = (u) => hasProperty(u, TypeId1
     weekday: lookup3.prev.weekday(weekdays)
   };
   return o;
-}, makeRestrictions = (field, min4, max4, normalize2 = (value) => value) => (values) => {
+}, makeRestrictions = (field, min4, max5, normalize2 = (value) => value) => (values) => {
   const restrictions = [];
   for (const value of values) {
-    if (!Number.isInteger(value) || value < min4 || value > max4) {
-      throw new RangeError(`${field} must contain only integers between ${min4} and ${max4}`);
+    if (!Number.isInteger(value) || value < min4 || value > max5) {
+      throw new RangeError(`${field} must contain only integers between ${min4} and ${max5}`);
     }
     restrictions.push(normalize2(value));
   }
@@ -28386,7 +29717,7 @@ __export(exports_Schedule, {
   once: () => once,
   modifyDelay: () => modifyDelay,
   min: () => min4,
-  max: () => max4,
+  max: () => max5,
   map: () => map6,
   jittered: () => jittered,
   isSchedule: () => isSchedule,
@@ -28442,7 +29773,7 @@ var TypeId11 = "~effect/Schedule", randomNext, CurrentMetadata2, ScheduleProto,
       return as(sleep(duration), meta);
     });
   });
-})), toStepWithSleep = (schedule) => map3(toStepWithMetadata(schedule), (step) => (input) => map3(step(input), (meta) => meta.output)), addDelay, concat, concatResult, max4 = (schedules) => fromStep(map3(all2(schedules.map(toStep)), (steps) => (now, input) => flatMap(forEach(steps, (step) => matchEffect2(step(now, input), {
+})), toStepWithSleep = (schedule) => map3(toStepWithMetadata(schedule), (step) => (input) => map3(step(input), (meta) => meta.output)), addDelay, concat, concatResult, max5 = (schedules) => fromStep(map3(all2(schedules.map(toStep)), (steps) => (now, input) => flatMap(forEach(steps, (step) => matchEffect2(step(now, input), {
   onSuccess: (result2) => succeed3(result2[1]),
   onDone: () => undefined_,
   onFailure: failCause
@@ -28453,13 +29784,13 @@ var TypeId11 = "~effect/Schedule", randomNext, CurrentMetadata2, ScheduleProto,
   }
   return succeed3([duration, duration]);
 }))), maxDuration = (results2) => {
-  let max5 = results2[0];
+  let max6 = results2[0];
   for (let i3 = 1;i3 < results2.length; i3++) {
-    max5 = results2[i3] && max5 && max3(max5, results2[i3]);
-    if (max5 === undefined)
+    max6 = results2[i3] && max6 && max4(max6, results2[i3]);
+    if (max6 === undefined)
       break;
   }
-  return max5;
+  return max6;
 }, cron = (expression, tz) => {
   const parsed = isCron(expression) ? succeed2(expression) : parse(expression, tz);
   return fromStep(map3(fromResult(parsed), (cron2) => (now, _) => {
@@ -29213,7 +30544,7 @@ var init_Metric = __esm(() => {
       let count = 0;
       let sum2 = 0;
       let min5 = Number.MAX_VALUE;
-      let max5 = -Number.MAX_VALUE;
+      let max6 = -Number.MAX_VALUE;
       map2(sort(bounds, Number2), (n, i3) => {
         boundaries[i3] = n;
       });
@@ -29242,8 +30573,8 @@ var init_Metric = __esm(() => {
         if (value < min5) {
           min5 = value;
         }
-        if (value > max5) {
-          max5 = value;
+        if (value > max6) {
+          max6 = value;
         }
       };
       const getBuckets = () => {
@@ -29261,7 +30592,7 @@ var init_Metric = __esm(() => {
         buckets: getBuckets(),
         count,
         min: min5,
-        max: max5,
+        max: max6,
         sum: sum2
       }), update);
     }
@@ -29289,7 +30620,7 @@ var init_Metric = __esm(() => {
       let count = 0;
       let sum2 = 0;
       let min5 = Number.MAX_VALUE;
-      let max5 = -Number.MAX_VALUE;
+      let max6 = -Number.MAX_VALUE;
       const snapshot = (now) => {
         const builder = [];
         let i3 = 0;
@@ -29329,8 +30660,8 @@ var init_Metric = __esm(() => {
         if (value < min5) {
           min5 = value;
         }
-        if (value > max5) {
-          max5 = value;
+        if (value > max6) {
+          max6 = value;
         }
       };
       const get2 = (context2) => {
@@ -29340,7 +30671,7 @@ var init_Metric = __esm(() => {
           quantiles,
           count,
           min: min5,
-          max: max5,
+          max: max6,
           sum: sum2
         };
       };
@@ -29959,7 +31290,7 @@ var exports_Fiber = {};
 __export(exports_Fiber, {
   runIn: () => runIn,
   joinAll: () => joinAll,
-  join: () => join7,
+  join: () => join8,
   isFiber: () => isFiber,
   interruptAs: () => interruptAs,
   interruptAllAs: () => interruptAllAs,
@@ -29969,13 +31300,13 @@ __export(exports_Fiber, {
   awaitAll: () => awaitAll,
   await: () => await_
 });
-var await_, awaitAll, join7, joinAll, interrupt4, interruptAs, interruptAll, interruptAllAs, isFiber = (u) => hasProperty(u, FiberTypeId), getCurrent, runIn;
+var await_, awaitAll, join8, joinAll, interrupt4, interruptAs, interruptAll, interruptAllAs, isFiber = (u) => hasProperty(u, FiberTypeId), getCurrent, runIn;
 var init_Fiber = __esm(() => {
   init_effect();
   init_Predicate();
   await_ = fiberAwait;
   awaitAll = fiberAwaitAll;
-  join7 = fiberJoin;
+  join8 = fiberJoin;
   joinAll = fiberJoinAll;
   interrupt4 = fiberInterrupt;
   interruptAs = fiberInterruptAs;
@@ -33161,7 +34492,7 @@ function handleCheckPropertyResult(result3, payload, property) {
   }
 }
 var $ZodCheck, numericOriginMap, $ZodCheckLessThan, $ZodCheckGreaterThan, $ZodCheckMultipleOf, $ZodCheckNumberFormat, $ZodCheckBigIntFormat, $ZodCheckMaxSize, $ZodCheckMinSize, $ZodCheckSizeEquals, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodCheckLengthEquals, $ZodCheckStringFormat, $ZodCheckRegex, $ZodCheckLowerCase, $ZodCheckUpperCase, $ZodCheckIncludes, $ZodCheckStartsWith, $ZodCheckEndsWith, $ZodCheckProperty, $ZodCheckMimeType, $ZodCheckOverwrite;
-var init_checks = __esm(() => {
+var init_checks2 = __esm(() => {
   init_core2();
   init_regexes();
   init_util();
@@ -34158,7 +35489,7 @@ function handleRefineResult(result3, payload, input, inst) {
 }
 var $ZodType, $ZodString, $ZodStringFormat, $ZodGUID, $ZodUUID, $ZodEmail, $ZodURL, $ZodEmoji, $ZodNanoID, $ZodCUID, $ZodCUID2, $ZodULID, $ZodXID, $ZodKSUID, $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration, $ZodIPv4, $ZodIPv6, $ZodMAC, $ZodCIDRv4, $ZodCIDRv6, $ZodBase64, $ZodBase64URL, $ZodE164, $ZodJWT, $ZodCustomStringFormat, $ZodNumber, $ZodNumberFormat, $ZodBoolean, $ZodBigInt, $ZodBigIntFormat, $ZodSymbol, $ZodUndefined, $ZodNull, $ZodAny, $ZodUnknown, $ZodNever, $ZodVoid, $ZodDate, $ZodArray, $ZodObject, $ZodObjectJIT, $ZodUnion, $ZodXor, $ZodDiscriminatedUnion, $ZodIntersection, $ZodTuple, $ZodRecord, $ZodMap, $ZodSet, $ZodEnum, $ZodLiteral, $ZodFile, $ZodTransform, $ZodOptional, $ZodExactOptional, $ZodNullable, $ZodDefault, $ZodPrefault, $ZodNonOptional, $ZodSuccess, $ZodCatch, $ZodNaN, $ZodPipe, $ZodCodec, $ZodPreprocess, $ZodReadonly, $ZodTemplateLiteral, $ZodFunction, $ZodPromise, $ZodLazy, $ZodCustom;
 var init_schemas = __esm(() => {
-  init_checks();
+  init_checks2();
   init_core2();
   init_parse();
   init_regexes();
@@ -42977,7 +44308,7 @@ function _stringFormat(Class2, format3, fnOrRegex, _params = {}) {
 }
 var TimePrecision;
 var init_api4 = __esm(() => {
-  init_checks();
+  init_checks2();
   init_registries();
   init_schemas();
   init_util();
@@ -44207,7 +45538,7 @@ var init_core3 = __esm(() => {
   init_parse();
   init_errors2();
   init_schemas();
-  init_checks();
+  init_checks2();
   init_versions();
   init_registries();
   init_api4();
@@ -44247,7 +45578,7 @@ __export(exports_checks2, {
   gt: () => _gt,
   endsWith: () => _endsWith
 });
-var init_checks2 = __esm(() => {
+var init_checks3 = __esm(() => {
   init_core3();
 });
 
@@ -45046,7 +46377,7 @@ var init_schemas2 = __esm(() => {
   init_core3();
   init_json_schema_processors();
   init_to_json_schema();
-  init_checks2();
+  init_checks3();
   init_iso();
   init_parse2();
   _installedGroups = /* @__PURE__ */ new WeakMap;
@@ -46256,7 +47587,7 @@ function fromJSONSchema(schema, params) {
 var z, RECOGNIZED_KEYS;
 var init_from_json_schema = __esm(() => {
   init_registries();
-  init_checks2();
+  init_checks3();
   init_iso();
   init_schemas2();
   z = {
@@ -46608,7 +47939,7 @@ var init_external = __esm(() => {
   init_iso();
   init_coerce();
   init_schemas2();
-  init_checks2();
+  init_checks3();
   init_errors3();
   init_parse2();
   init_compat();
@@ -47853,7 +49184,7 @@ var init_conversation_mode = __esm(() => {
 });
 
 // ../shared/src/domain/task-envelope.ts
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isConversationMode(value) {
@@ -47899,10 +49230,10 @@ function copyTaskEnvelope(envelope) {
   };
 }
 function isEnvelopeRecordAndVersion(value) {
-  return isRecord5(value) && value.version === TASK_ENVELOPE_VERSION;
+  return isRecord6(value) && value.version === TASK_ENVELOPE_VERSION;
 }
 function isWorkflowShape(workflow) {
-  return isRecord5(workflow) && isHandoffPreset(workflow.preset) && isHandoffPhase(workflow.phase);
+  return isRecord6(workflow) && isHandoffPreset(workflow.preset) && isHandoffPhase(workflow.phase);
 }
 function isPresetChoice(workflow, mode) {
   return workflow.preset === workflowPresetForMode(mode);
@@ -49792,17 +51123,17 @@ import {
   writeFileSync
 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash4("sha256").update(url2).digest("hex").substring(0, 8);
 }
 function getChildPidsFilePath() {
-  const dir = join8(homedir2(), ".chatroom");
-  return join8(dir, `daemon-children-${getUrlHash()}.pids`);
+  const dir = join9(homedir2(), ".chatroom");
+  return join9(dir, `daemon-children-${getUrlHash()}.pids`);
 }
 function ensureChatroomDir() {
-  const dir = join8(homedir2(), ".chatroom");
+  const dir = join9(homedir2(), ".chatroom");
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
@@ -53131,7 +54462,7 @@ var init_task_service = __esm(() => {
 
 // src/daemon/services/task-service/infrastructure/repository/task-handoff-repository.ts
 import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 function normalizeRole(role) {
   return role.toLowerCase();
@@ -53151,7 +54482,7 @@ function mapRow(row) {
   };
 }
 function createTaskHandoffRepository(dbPath) {
-  mkdirSync2(dirname8(dbPath), { recursive: true });
+  mkdirSync2(dirname9(dbPath), { recursive: true });
   const db = new DatabaseSync(dbPath);
   db.exec(`
     CREATE TABLE IF NOT EXISTS task_handoffs (
@@ -55709,7 +57040,7 @@ function createAgentLogWriter(prefix, options) {
 var BASH_TOOL_KIND = "tool: bash", BASH_RUNNING_PREFIX = "running:";
 
 // src/daemon/infrastructure/local/harness/services/pi/pi-agent-service.ts
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function isExplicitToolError(result3) {
   if (result3 === null || typeof result3 !== "object")
     return false;
@@ -55719,7 +57050,7 @@ function isExplicitToolError(result3) {
   return "error" in obj && obj.error !== undefined;
 }
 function getPiSessionDir(workingDir) {
-  return join9(workingDir, ".chatroom", "pi-sessions");
+  return join10(workingDir, ".chatroom", "pi-sessions");
 }
 var PI_COMMAND = "pi", GET_STATE_TIMEOUT_MS = 5000, PiAgentService;
 var init_pi_agent_service = __esm(() => {
@@ -56176,25 +57507,25 @@ var init_model_provider = () => {};
 // src/daemon/infrastructure/local/harness/services/cursor-sdk/cursor-sdk-package.ts
 import { existsSync as existsSync2, readFileSync as readFileSync5 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname9, join as join10 } from "node:path";
+import { dirname as dirname10, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 function resolveChatroomCliRoot(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath2(moduleRef) : moduleRef;
-  let dir = dirname9(filePath);
-  while (dir !== dirname9(dir)) {
-    const packageJsonPath = join10(dir, "package.json");
+  let dir = dirname10(filePath);
+  while (dir !== dirname10(dir)) {
+    const packageJsonPath = join11(dir, "package.json");
     if (existsSync2(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname9(dir);
+    dir = dirname10(dir);
   }
   throw new CursorSdkPackageError(`Could not locate chatroom-cli package root while resolving @cursor/sdk. ${REINSTALL_HINT}`);
 }
 function readPinnedSdkVersion(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync5(join10(chatroomCliRoot, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync5(join11(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.["@cursor/sdk"];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match5 = pinned.match(/^(\d+\.\d+\.\d+)/);
@@ -56204,7 +57535,7 @@ function readPinnedSdkVersion(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion(entryPath) {
-  const packageJsonPath = join10(dirname9(entryPath), "..", "..", "package.json");
+  const packageJsonPath = join11(dirname10(entryPath), "..", "..", "package.json");
   const pkg = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -56217,7 +57548,7 @@ function resolveSdkEsmImportPath(cjsEntryPath) {
 }
 async function importBundledCursorSdk(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
-  const require4 = createRequire5(join10(chatroomCliRoot, "package.json"));
+  const require4 = createRequire5(join11(chatroomCliRoot, "package.json"));
   const pinnedVersion = readPinnedSdkVersion(chatroomCliRoot);
   const entryPath = require4.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
   const installedVersion = readInstalledSdkVersion(entryPath);
@@ -56233,7 +57564,7 @@ async function importBundledCursorSdk(moduleRef = import.meta.url) {
 }
 function getBundledCursorSdkVersion(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot(moduleRef);
-  const require4 = createRequire5(join10(chatroomCliRoot, "package.json"));
+  const require4 = createRequire5(join11(chatroomCliRoot, "package.json"));
   const entryPath = require4.resolve("@cursor/sdk", { paths: [chatroomCliRoot] });
   return readInstalledSdkVersion(entryPath);
 }
@@ -57125,25 +58456,25 @@ import {
 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename5, dirname as dirname10, join as join11 } from "node:path";
+import { basename as basename6, dirname as dirname11, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 function resolveChatroomCliRoot2(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath3(moduleRef) : moduleRef;
-  let dir = dirname10(filePath);
-  while (dir !== dirname10(dir)) {
-    const packageJsonPath = join11(dir, "package.json");
+  let dir = dirname11(filePath);
+  while (dir !== dirname11(dir)) {
+    const packageJsonPath = join12(dir, "package.json");
     if (existsSync3(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return realpathSync(dir);
       }
     }
-    dir = dirname10(dir);
+    dir = dirname11(dir);
   }
   throw new ClaudeSdkPackageError(`Could not locate chatroom-cli package root while resolving ${CLAUDE_AGENT_SDK_PKG}. ${REINSTALL_HINT2}`);
 }
 function readPinnedSdkVersion2(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync6(join11(chatroomCliRoot, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync6(join12(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.[CLAUDE_AGENT_SDK_PKG];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match5 = pinned.match(/^(\d+\.\d+\.\d+)/);
@@ -57153,7 +58484,7 @@ function readPinnedSdkVersion2(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion2(entryPath) {
-  const packageJsonPath = join11(dirname10(entryPath), "package.json");
+  const packageJsonPath = join12(dirname11(entryPath), "package.json");
   const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
   return pkg.version;
 }
@@ -57179,19 +58510,19 @@ function resolveNativeCliBinaryPath(sdkEntryPath) {
   const binaryName = process.platform === "win32" ? "claude.exe" : "claude";
   let pkgDir;
   try {
-    pkgDir = dirname10(require4.resolve(`${platformPkg}/package.json`));
+    pkgDir = dirname11(require4.resolve(`${platformPkg}/package.json`));
   } catch {
     throw new ClaudeSdkPackageError(`Native CLI binary package ${platformPkg} is not installed. ${REINSTALL_HINT2}`);
   }
-  const binaryPath = join11(pkgDir, binaryName);
+  const binaryPath = join12(pkgDir, binaryName);
   if (!existsSync3(binaryPath)) {
     throw new ClaudeSdkPackageError(`Native CLI binary is missing: ${binaryPath}. ${REINSTALL_HINT2}`);
   }
   return binaryPath;
 }
 function pinNativeBinary(sourcePath, sdkVersion, pinRoot) {
-  const dir = join11(pinRoot, sdkVersion);
-  const pinnedPath = join11(dir, basename5(sourcePath));
+  const dir = join12(pinRoot, sdkVersion);
+  const pinnedPath = join12(dir, basename6(sourcePath));
   if (existsSync3(pinnedPath))
     return pinnedPath;
   mkdirSync3(dir, { recursive: true, mode: 448 });
@@ -57205,7 +58536,7 @@ async function resolvePathToClaudeCodeExecutable(moduleRef = import.meta.url) {
   if (cachedExecutablePath)
     return cachedExecutablePath;
   const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const require4 = createRequire6(join11(chatroomCliRoot, "package.json"));
+  const require4 = createRequire6(join12(chatroomCliRoot, "package.json"));
   const sdkEntryPath = require4.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
   const embeddedPath = resolveNativeCliBinaryPath(sdkEntryPath);
   const { extractFromBunfs } = await import("@anthropic-ai/claude-agent-sdk/extract");
@@ -57215,7 +58546,7 @@ async function resolvePathToClaudeCodeExecutable(moduleRef = import.meta.url) {
 }
 async function importBundledClaudeSdk(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const require4 = createRequire6(join11(chatroomCliRoot, "package.json"));
+  const require4 = createRequire6(join12(chatroomCliRoot, "package.json"));
   const pinnedVersion = readPinnedSdkVersion2(chatroomCliRoot);
   const entryPath = require4.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
   const installedVersion = readInstalledSdkVersion2(entryPath);
@@ -57229,7 +58560,7 @@ async function importBundledClaudeSdk(moduleRef = import.meta.url) {
 }
 function getBundledClaudeSdkVersion(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot2(moduleRef);
-  const require4 = createRequire6(join11(chatroomCliRoot, "package.json"));
+  const require4 = createRequire6(join12(chatroomCliRoot, "package.json"));
   const entryPath = require4.resolve(CLAUDE_AGENT_SDK_PKG, { paths: [chatroomCliRoot] });
   return readInstalledSdkVersion2(entryPath);
 }
@@ -57252,7 +58583,7 @@ var init_claude_sdk_package = __esm(() => {
       this.name = "ClaudeSdkPackageError";
     }
   };
-  PINNED_BINARY_ROOT = join11(homedir3(), ".chatroom", "claude-native");
+  PINNED_BINARY_ROOT = join12(homedir3(), ".chatroom", "claude-native");
 });
 
 // src/daemon/infrastructure/local/harness/services/assistant-text-capture.ts
@@ -58113,25 +59444,25 @@ var init_codex_sdk_model_variants = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/codex-sdk/codex-sdk-package.ts
 import { existsSync as existsSync4, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { dirname as dirname11, join as join12 } from "node:path";
+import { dirname as dirname12, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL3 } from "node:url";
 function resolveChatroomCliRoot3(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath4(moduleRef) : moduleRef;
-  let dir = dirname11(filePath);
-  while (dir !== dirname11(dir)) {
-    const packageJsonPath = join12(dir, "package.json");
+  let dir = dirname12(filePath);
+  while (dir !== dirname12(dir)) {
+    const packageJsonPath = join13(dir, "package.json");
     if (existsSync4(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname11(dir);
+    dir = dirname12(dir);
   }
   throw new CodexSdkPackageError(`Could not locate chatroom-cli package root while resolving @openai/codex-sdk. ${REINSTALL_HINT3}`);
 }
 function readPinnedSdkVersion3(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync7(join12(chatroomCliRoot, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync7(join13(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.["@openai/codex-sdk"];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match5 = pinned.match(/^(\d+\.\d+\.\d+)/);
@@ -58145,11 +59476,11 @@ function readInstalledSdkVersion3(packageJsonPath) {
   return pkg.version;
 }
 function resolveCodexSdkPackageJson(chatroomCliRoot) {
-  const require4 = createRequire7(join12(chatroomCliRoot, "package.json"));
+  const require4 = createRequire7(join13(chatroomCliRoot, "package.json"));
   try {
     return require4.resolve("@openai/codex-sdk/package.json", { paths: [chatroomCliRoot] });
   } catch {
-    const candidate = join12(chatroomCliRoot, "node_modules", "@openai", "codex-sdk", "package.json");
+    const candidate = join13(chatroomCliRoot, "node_modules", "@openai", "codex-sdk", "package.json");
     if (existsSync4(candidate)) {
       return candidate;
     }
@@ -58193,7 +59524,7 @@ function addPlatformPackageJsonCandidate(candidates, candidate) {
 }
 function resolvePlatformPackageJsonCandidates(platformPkg, chatroomCliRoot, codexPackageJson, chatroomRequire, codexRequire) {
   const candidates = [];
-  const codexPackageDir = realpathSync2(dirname11(codexPackageJson));
+  const codexPackageDir = realpathSync2(dirname12(codexPackageJson));
   const platformPkgBaseName = platformPkg.includes("/") ? platformPkg.slice(platformPkg.indexOf("/") + 1) : platformPkg;
   try {
     addPlatformPackageJsonCandidate(candidates, codexRequire.resolve(`${platformPkg}/package.json`));
@@ -58201,17 +59532,17 @@ function resolvePlatformPackageJsonCandidates(platformPkg, chatroomCliRoot, code
   try {
     addPlatformPackageJsonCandidate(candidates, chatroomRequire.resolve(`${platformPkg}/package.json`, { paths: [chatroomCliRoot] }));
   } catch {}
-  addPlatformPackageJsonCandidate(candidates, join12(codexPackageDir, "..", platformPkgBaseName, "package.json"));
-  addPlatformPackageJsonCandidate(candidates, join12(codexPackageDir, "node_modules", platformPkg, "package.json"));
+  addPlatformPackageJsonCandidate(candidates, join13(codexPackageDir, "..", platformPkgBaseName, "package.json"));
+  addPlatformPackageJsonCandidate(candidates, join13(codexPackageDir, "node_modules", platformPkg, "package.json"));
   return candidates;
 }
 function resolveNativeCodexBinary(vendorRoot, targetTriple, codexBinaryName) {
-  const packageRoot = join12(vendorRoot, targetTriple);
-  const packageBinaryPath = join12(packageRoot, "bin", codexBinaryName);
-  if (isRegularFile(packageBinaryPath) && isRegularFile(join12(packageRoot, "codex-package.json"))) {
+  const packageRoot = join13(vendorRoot, targetTriple);
+  const packageBinaryPath = join13(packageRoot, "bin", codexBinaryName);
+  if (isRegularFile(packageBinaryPath) && isRegularFile(join13(packageRoot, "codex-package.json"))) {
     return packageBinaryPath;
   }
-  const legacyBinaryPath = join12(packageRoot, "codex", codexBinaryName);
+  const legacyBinaryPath = join13(packageRoot, "codex", codexBinaryName);
   if (isRegularFile(legacyBinaryPath)) {
     return legacyBinaryPath;
   }
@@ -58219,7 +59550,7 @@ function resolveNativeCodexBinary(vendorRoot, targetTriple, codexBinaryName) {
 }
 function resolveCodexExecutablePath(moduleRef = import.meta.url) {
   const chatroomCliRoot = resolveChatroomCliRoot3(moduleRef);
-  const require4 = createRequire7(join12(chatroomCliRoot, "package.json"));
+  const require4 = createRequire7(join13(chatroomCliRoot, "package.json"));
   let codexPackageJson;
   try {
     codexPackageJson = require4.resolve(`${CODEX_NPM_NAME}/package.json`, {
@@ -58237,7 +59568,7 @@ function resolveCodexExecutablePath(moduleRef = import.meta.url) {
     throw new CodexSdkPackageError(`Native Codex CLI package ${platformPkg} is not installed. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies. ${REINSTALL_HINT3}`);
   }
   for (const platformPackageJson of platformPackageJsonCandidates) {
-    const vendorRoot = join12(dirname11(platformPackageJson), "vendor");
+    const vendorRoot = join13(dirname12(platformPackageJson), "vendor");
     const binaryPath = resolveNativeCodexBinary(vendorRoot, targetTriple, codexBinaryName);
     if (binaryPath) {
       return binaryPath;
@@ -58253,7 +59584,7 @@ async function importBundledCodexSdk(moduleRef = import.meta.url) {
   if (installedVersion !== pinnedVersion) {
     throw new CodexSdkPackageError(`@openai/codex-sdk@${installedVersion} does not match chatroom-cli pin (${pinnedVersion}). ${REINSTALL_HINT3}`);
   }
-  const distEntryPath = join12(dirname11(packageJsonPath), "dist", "index.js");
+  const distEntryPath = join13(dirname12(packageJsonPath), "dist", "index.js");
   if (!existsSync4(distEntryPath)) {
     throw new CodexSdkPackageError(`@openai/codex-sdk entry file is missing: ${distEntryPath}. ${REINSTALL_HINT3}`);
   }
@@ -60346,12 +61677,12 @@ var init_session_event_forwarder = __esm(() => {
 // src/daemon/infrastructure/local/harness/services/opencode-sdk/session-metadata-store.ts
 import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname12, join as join13 } from "node:path";
+import { dirname as dirname13, join as join14 } from "node:path";
 
 class FileSessionMetadataStore {
   filePath;
   constructor(filePath) {
-    this.filePath = filePath ?? join13(homedir4(), ".chatroom", "opencode-sdk-sessions.json");
+    this.filePath = filePath ?? join14(homedir4(), ".chatroom", "opencode-sdk-sessions.json");
   }
   load() {
     try {
@@ -60363,7 +61694,7 @@ class FileSessionMetadataStore {
   }
   save(sessions) {
     try {
-      const dir = dirname12(this.filePath);
+      const dir = dirname13(this.filePath);
       if (!existsSync5(dir)) {
         mkdirSync4(dir, { recursive: true, mode: 448 });
       }
@@ -60946,25 +62277,25 @@ var init_opencode_sdk = __esm(() => {
 
 // src/daemon/infrastructure/local/harness/services/pi-sdk/pi-sdk-package.ts
 import { existsSync as existsSync6, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname13, join as join14 } from "node:path";
+import { dirname as dirname14, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL as pathToFileURL4 } from "node:url";
 function resolveChatroomCliRoot4(moduleRef = import.meta.url) {
   const filePath = moduleRef.startsWith("file:") ? fileURLToPath5(moduleRef) : moduleRef;
-  let dir = dirname13(filePath);
-  while (dir !== dirname13(dir)) {
-    const packageJsonPath = join14(dir, "package.json");
+  let dir = dirname14(filePath);
+  while (dir !== dirname14(dir)) {
+    const packageJsonPath = join15(dir, "package.json");
     if (existsSync6(packageJsonPath)) {
       const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
       if (pkg.name === "chatroom-cli") {
         return dir;
       }
     }
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   throw new PiSdkPackageError(`Could not locate chatroom-cli package root while resolving ${PI_CODING_AGENT_PKG}. ${REINSTALL_HINT4}`);
 }
 function readPinnedSdkVersion4(chatroomCliRoot) {
-  const pkg = JSON.parse(readFileSync9(join14(chatroomCliRoot, "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync9(join15(chatroomCliRoot, "package.json"), "utf8"));
   const specifier = pkg.dependencies?.[PI_CODING_AGENT_PKG];
   const pinned = specifier?.replace(/^[\^~>=<]+/, "").trim() ?? "";
   const match5 = pinned.match(/^(\d+\.\d+\.\d+)/);
@@ -60974,18 +62305,18 @@ function readPinnedSdkVersion4(chatroomCliRoot) {
   return match5[1];
 }
 function readInstalledSdkVersion4(entryPath) {
-  const packageJsonPath = join14(dirname13(entryPath), "..", "package.json");
+  const packageJsonPath = join15(dirname14(entryPath), "..", "package.json");
   const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf8"));
   return pkg.version;
 }
 function resolvePiSdkEntryPathFromNodeModules(chatroomCliRoot) {
   let dir = chatroomCliRoot;
-  while (dir !== dirname13(dir)) {
-    const entryPath = join14(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
+  while (dir !== dirname14(dir)) {
+    const entryPath = join15(dir, "node_modules", PI_CODING_AGENT_PKG, "dist", "index.js");
     if (existsSync6(entryPath)) {
       return entryPath;
     }
-    dir = dirname13(dir);
+    dir = dirname14(dir);
   }
   return;
 }
@@ -60993,7 +62324,7 @@ function resolvePiSdkEntryPath(chatroomCliRoot) {
   const resolveMeta = import.meta.resolve;
   if (typeof resolveMeta === "function") {
     try {
-      const parentUrl = pathToFileURL4(join14(chatroomCliRoot, "package.json")).href;
+      const parentUrl = pathToFileURL4(join15(chatroomCliRoot, "package.json")).href;
       return fileURLToPath5(resolveMeta(PI_CODING_AGENT_PKG, parentUrl));
     } catch {}
   }
@@ -61720,7 +63051,7 @@ var MACHINE_CONFIG_VERSION = "1";
 import { randomBytes, randomUUID as randomUUID7 } from "node:crypto";
 import * as fs4 from "node:fs/promises";
 import { homedir as homedir5, hostname as hostname4 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function enqueueMachineConfigSave(task) {
   const run = saveChain.then(task, task);
   saveChain = run.catch(() => {
@@ -61729,14 +63060,14 @@ function enqueueMachineConfigSave(task) {
   return run;
 }
 function chatroomConfigDir() {
-  return join15(homedir5(), ".chatroom");
+  return join16(homedir5(), ".chatroom");
 }
 async function ensureConfigDir2() {
   const dir = chatroomConfigDir();
   await fs4.mkdir(dir, { recursive: true, mode: 448 });
 }
 function getMachineConfigPath() {
-  return join15(chatroomConfigDir(), MACHINE_FILE);
+  return join16(chatroomConfigDir(), MACHINE_FILE);
 }
 async function loadConfigFile() {
   const configPath = getMachineConfigPath();
@@ -61838,7 +63169,7 @@ var init_storage2 = __esm(() => {
 // src/infrastructure/machine/daemon-state.ts
 import * as fs5 from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function agentKey3(chatroomId, role, workingDir) {
   return workingDir ? `${chatroomId}/${role}/${encodeURIComponent(workingDir)}` : `${chatroomId}/${role}`;
 }
@@ -61846,7 +63177,7 @@ async function ensureStateDir() {
   await fs5.mkdir(STATE_DIR, { recursive: true, mode: 448 });
 }
 function stateFilePath(machineId) {
-  return join16(STATE_DIR, `${machineId}.json`);
+  return join17(STATE_DIR, `${machineId}.json`);
 }
 async function loadDaemonState(machineId) {
   const filePath = stateFilePath(machineId);
@@ -61947,8 +63278,8 @@ async function loadEventCursor(machineId) {
 }
 var CHATROOM_DIR2, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
-  CHATROOM_DIR2 = join16(homedir6(), ".chatroom");
-  STATE_DIR = join16(CHATROOM_DIR2, "machines", "state");
+  CHATROOM_DIR2 = join17(homedir6(), ".chatroom");
+  STATE_DIR = join17(CHATROOM_DIR2, "machines", "state");
 });
 
 // src/infrastructure/machine/index.ts
@@ -68791,8 +70122,8 @@ var init_backo2 = __esm(() => {
   Backoff.prototype.setMin = function(min5) {
     this.ms = min5;
   };
-  Backoff.prototype.setMax = function(max5) {
-    this.max = max5;
+  Backoff.prototype.setMax = function(max6) {
+    this.max = max6;
   };
   Backoff.prototype.setJitter = function(jitter) {
     this.jitter = jitter;
@@ -69351,9 +70682,9 @@ function resolveEnvSlug(convexUrl) {
 
 // src/infrastructure/log-server/resolve-logs-db-path.ts
 import { homedir as homedir7 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function resolveLogsDbPath(convexUrl) {
-  return join17(homedir7(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
+  return join18(homedir7(), ".chatroom", resolveEnvSlug(convexUrl ?? getConvexUrl()), "logs.sqlite");
 }
 var init_resolve_logs_db_path = __esm(() => {
   init_client2();
@@ -69387,10 +70718,10 @@ var init_log_schema = __esm(() => {
 
 // src/infrastructure/log-server/open-log-database.ts
 import { mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 function openLogDatabase(dbPath) {
-  mkdirSync5(dirname14(dbPath), { recursive: true });
+  mkdirSync5(dirname15(dbPath), { recursive: true });
   const db = new DatabaseSync2(dbPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA busy_timeout = 5000");
@@ -69499,9 +70830,9 @@ function parsePsPidCommandLines(stdout) {
 function readPpid(pid) {
   if (process.platform === "linux") {
     try {
-      const stat6 = readFileSync10(`/proc/${pid}/stat`, "utf-8");
-      const closeParen = stat6.lastIndexOf(")");
-      const rest = closeParen >= 0 ? stat6.slice(closeParen + 2).split(" ") : stat6.split(" ");
+      const stat7 = readFileSync10(`/proc/${pid}/stat`, "utf-8");
+      const closeParen = stat7.lastIndexOf(")");
+      const rest = closeParen >= 0 ? stat7.slice(closeParen + 2).split(" ") : stat7.split(" ");
       const ppid = Number.parseInt(rest[1] ?? "", 10);
       return Number.isFinite(ppid) && ppid >= 0 ? ppid : null;
     } catch {
@@ -69582,7 +70913,7 @@ var init_daemon_process_scan = __esm(() => {
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, mkdirSync as mkdirSync6 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function getUrlHash2() {
   const url3 = getConvexUrl();
   return createHash5("sha256").update(url3).digest("hex").substring(0, 8);
@@ -69596,7 +70927,7 @@ function ensureChatroomDir2() {
   }
 }
 function getPidFilePath() {
-  return join18(CHATROOM_DIR3, getPidFileName());
+  return join19(CHATROOM_DIR3, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -69742,7 +71073,7 @@ var CHATROOM_DIR3, LOCK_RETRY_INTERVAL_MS = 500, LOCK_RETRY_MAX_WAIT_MS = 15000,
 var init_pid = __esm(() => {
   init_daemon_process_scan();
   init_client2();
-  CHATROOM_DIR3 = join18(homedir8(), ".chatroom");
+  CHATROOM_DIR3 = join19(homedir8(), ".chatroom");
 });
 
 // src/commands/diagnostics/index.ts
@@ -69751,7 +71082,7 @@ __export(exports_diagnostics, {
   logs: () => logs,
   debugDaemon: () => debugDaemon
 });
-import { stat as stat6, writeFile as writeFile5 } from "node:fs/promises";
+import { stat as stat7, writeFile as writeFile6 } from "node:fs/promises";
 function parseDuration(value2) {
   const match5 = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/.exec(value2.trim().toLowerCase());
   if (!match5)
@@ -69770,7 +71101,7 @@ function parseTimestamp(value2, flag) {
 async function writeOrPrint(value2, output) {
   const rendered = JSON.stringify(value2, null, 2);
   if (output) {
-    await writeFile5(output, `${rendered}
+    await writeFile6(output, `${rendered}
 `, "utf8");
     console.log(`Wrote diagnostic dump to ${output}`);
     return;
@@ -69813,7 +71144,7 @@ async function debugDaemon(options) {
 async function readAllLogs(options, fromTimestamp, toTimestamp) {
   const dbPath = resolveLogsDbPath();
   try {
-    await stat6(dbPath);
+    await stat7(dbPath);
   } catch {
     return { dbPath, entries: [] };
   }
@@ -69869,7 +71200,7 @@ async function logs(options) {
     return;
   }
   if (options.output) {
-    await writeFile5(options.output, result3.entries.map((entry) => `${new Date(entry.timestamp).toISOString()} [${entry.level}] ${entry.source} ${entry.message}`).join(`
+    await writeFile6(options.output, result3.entries.map((entry) => `${new Date(entry.timestamp).toISOString()} [${entry.level}] ${entry.source} ${entry.message}`).join(`
 `) + (result3.entries.length ? `
 ` : ""), "utf8");
     console.log(`Wrote ${result3.entries.length} log entries to ${options.output}`);
@@ -70088,9 +71419,9 @@ var init_init = __esm(() => {
 });
 
 // src/tools/output.ts
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function resolveChatroomDir(workingDir) {
-  return join19(workingDir, CHATROOM_DIR4);
+  return join20(workingDir, CHATROOM_DIR4);
 }
 async function ensureChatroomDir3(deps, workingDir) {
   const dir = resolveChatroomDir(workingDir);
@@ -70098,7 +71429,7 @@ async function ensureChatroomDir3(deps, workingDir) {
   return dir;
 }
 async function ensureGitignore(deps, workingDir) {
-  const gitignorePath = join19(workingDir, ".gitignore");
+  const gitignorePath = join20(workingDir, ".gitignore");
   const entry = CHATROOM_DIR4;
   let content = "";
   try {
@@ -70128,7 +71459,7 @@ function formatOutputTimestamp(date5 = new Date) {
 function generateOutputPath(workingDir, toolName, extension2, date5) {
   const timestamp = formatOutputTimestamp(date5);
   const filename = `${toolName}-${timestamp}.${extension2}`;
-  return join19(resolveChatroomDir(workingDir), filename);
+  return join20(resolveChatroomDir(workingDir), filename);
 }
 var CHATROOM_DIR4 = ".chatroom";
 var init_output = () => {};
@@ -70138,7 +71469,7 @@ var exports_parse_pdf = {};
 __export(exports_parse_pdf, {
   parsePdf: () => parsePdf
 });
-import { access, readFile as readFile9, writeFile as writeFile6, mkdir as mkdir7, appendFile } from "node:fs/promises";
+import { access, readFile as readFile10, writeFile as writeFile7, mkdir as mkdir7, appendFile } from "node:fs/promises";
 import { resolve as resolve7 } from "node:path";
 function isUrl(input) {
   return input.startsWith("http://") || input.startsWith("https://");
@@ -70148,10 +71479,10 @@ function createDefaultDeps6() {
     fs: {
       access: (p) => access(p),
       mkdir: (p, opts) => mkdir7(p, opts).then(() => {}),
-      readFile: (p, enc) => readFile9(p, { encoding: enc }).then((b) => b.toString()),
+      readFile: (p, enc) => readFile10(p, { encoding: enc }).then((b) => b.toString()),
       appendFile: (p, content) => appendFile(p, content),
-      readFileAsBuffer: (p) => readFile9(p),
-      writeFile: (p, content, enc) => writeFile6(p, content, enc)
+      readFileAsBuffer: (p) => readFile10(p),
+      writeFile: (p, content, enc) => writeFile7(p, content, enc)
     },
     parser: {
       parse: async (input) => {
@@ -82903,9 +84234,9 @@ var init_parse_skill_file = __esm(() => {
 });
 
 // src/infrastructure/external-skills/discover-external-skills.ts
-import { lstat as lstat2, readdir as readdir2, readFile as readFile11, realpath, stat as stat7 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, readFile as readFile12, realpath, stat as stat8 } from "node:fs/promises";
 import os from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function errorCode(err2) {
   return err2?.code ?? "unknown";
 }
@@ -82914,7 +84245,7 @@ function issue2(path2, reason, detail) {
 }
 function getExternalSkillRoots(homeDir) {
   return EXTERNAL_SKILL_ROOT_SUFFIXES.map((suffix) => ({
-    path: join21(homeDir, ...suffix.split("/"))
+    path: join22(homeDir, ...suffix.split("/"))
   }));
 }
 async function discoverExternalSkills(options) {
@@ -82936,7 +84267,7 @@ async function scanRoot(rootPath, cap, state) {
     state.issues.push(issue2(rootPath, "root-truncated", String(candidates.length)));
   }
   for (const entry of candidates.slice(0, cap)) {
-    const sourcePath = join21(rootPath, entry);
+    const sourcePath = join22(rootPath, entry);
     try {
       await scanEntry(entry, sourcePath, state);
     } catch (err2) {
@@ -82978,15 +84309,15 @@ async function scanEntry(entry, sourcePath, state) {
 }
 async function isSkillCandidate(sourcePath, issues) {
   try {
-    if (!(await stat7(sourcePath)).isDirectory())
+    if (!(await stat8(sourcePath)).isDirectory())
       return false;
   } catch (err2) {
     issues.push(issue2(sourcePath, "unreadable", errorCode(err2)));
     return false;
   }
-  const skillPath = join21(sourcePath, SKILL_FILE_NAME);
+  const skillPath = join22(sourcePath, SKILL_FILE_NAME);
   try {
-    const skillStat = await stat7(skillPath);
+    const skillStat = await stat8(skillPath);
     if (!skillStat.isFile())
       return false;
     if (skillStat.size > MAX_SKILL_FILE_BYTES) {
@@ -83011,7 +84342,7 @@ async function isSymlink2(path2) {
 }
 async function readSkillFile(sourcePath, issues) {
   try {
-    return await readFile11(join21(sourcePath, SKILL_FILE_NAME), "utf8");
+    return await readFile12(join22(sourcePath, SKILL_FILE_NAME), "utf8");
   } catch (err2) {
     issues.push(issue2(sourcePath, "unreadable", errorCode(err2)));
     return;
@@ -84871,10 +86202,10 @@ var init_durable_fifo_queue_schema = __esm(() => {
 
 // src/daemon/infrastructure/outbox/lib/durable-fifo-queue-store.ts
 import { mkdirSync as mkdirSync7 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { dirname as dirname16 } from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 function openDurableFifoQueueStore(dbPath) {
-  mkdirSync7(dirname15(dbPath), { recursive: true });
+  mkdirSync7(dirname16(dbPath), { recursive: true });
   const db = new DatabaseSync3(dbPath);
   for (const sql of DURABLE_FIFO_QUEUE_MIGRATIONS)
     db.exec(sql);
@@ -85169,9 +86500,9 @@ var init_keyed_fifo_batched_outbox_registry = __esm(() => {
 
 // src/daemon/infrastructure/outbox/outbox-db-path.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function resolveOutboxDbPath(machineId, kind) {
-  return join23(homedir9(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
+  return join24(homedir9(), ".chatroom", "daemon", machineId, `outbox-${kind}.sqlite`);
 }
 var init_outbox_db_path = () => {};
 
@@ -85502,9 +86833,9 @@ var init_orphan_tracker = __esm(() => {
 });
 
 // src/daemon/entry/handlers/process/output-store.ts
-import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile12, rm as rm3 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile13, rm as rm3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 
 class TempFileOutputStore {
   state;
@@ -85535,7 +86866,7 @@ class TempFileOutputStore {
   async getLastNLines(maxLines) {
     let source;
     try {
-      source = await readFile12(this.state.filePath, "utf-8");
+      source = await readFile13(this.state.filePath, "utf-8");
     } catch {
       source = this.state.inMemory;
     }
@@ -85552,7 +86883,7 @@ class TempFileOutputStore {
   }
   async getFullOutput() {
     try {
-      return await readFile12(this.state.filePath, "utf-8");
+      return await readFile13(this.state.filePath, "utf-8");
     } catch {
       return this.state.inMemory;
     }
@@ -85567,7 +86898,7 @@ function createOutputStore(runId) {
   if (!RUN_ID_RE.test(runId)) {
     throw new Error(`Invalid runId: ${runId}`);
   }
-  const filePath = join24(TEMP_DIR, `${runId}.log`);
+  const filePath = join25(TEMP_DIR, `${runId}.log`);
   return new TempFileOutputStore(filePath);
 }
 async function ensureTempDir() {
@@ -85581,15 +86912,15 @@ async function cleanOrphanTempFiles() {
 var TAIL_WINDOW_BYTES, TEMP_DIR, RUN_ID_RE, MAX_TAIL_LINES_V2 = 50;
 var init_output_store = __esm(() => {
   TAIL_WINDOW_BYTES = 32 * 1024;
-  TEMP_DIR = join24(tmpdir(), "chatroom-cli", "runs");
+  TEMP_DIR = join25(tmpdir(), "chatroom-cli", "runs");
   RUN_ID_RE = /^[a-z0-9]+$/i;
 });
 
 // src/daemon/entry/task-handoff-repository-path.ts
 import { homedir as homedir10 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function resolveTaskHandoffRepositoryPath(machineId) {
-  return join25(homedir10(), ".chatroom", "daemon", machineId, "task-handoffs.sqlite");
+  return join26(homedir10(), ".chatroom", "daemon", machineId, "task-handoffs.sqlite");
 }
 var init_task_handoff_repository_path = () => {};
 
@@ -85705,10 +87036,10 @@ var init_durable_coalescing_state_schema = __esm(() => {
 
 // src/daemon/infrastructure/outbox/lib/durable-coalescing-state-store.ts
 import { mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { dirname as dirname17 } from "node:path";
 import { DatabaseSync as DatabaseSync4 } from "node:sqlite";
 function openDurableCoalescingStateStore(path2) {
-  mkdirSync8(dirname16(path2), { recursive: true });
+  mkdirSync8(dirname17(path2), { recursive: true });
   const db = new DatabaseSync4(path2);
   for (const sql of DURABLE_COALESCING_STATE_MIGRATIONS)
     db.exec(sql);
@@ -87182,7 +88513,7 @@ var init_workspace_visibility_policy = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import path2 from "node:path";
 function normalizeRelativePath(relativePath) {
@@ -87247,7 +88578,7 @@ async function loadGitExtraExcludeRuleSets(rootDir) {
 }
 async function readIgnoreFile(filePath) {
   try {
-    return await readFile13(filePath, "utf-8");
+    return await readFile14(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -88219,7 +89550,7 @@ var init_git_workspace_hierarchy = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/index.js
-import { lstat as lstat3, readdir as readdir3, realpath as realpath2, stat as stat8 } from "node:fs/promises";
+import { lstat as lstat3, readdir as readdir3, realpath as realpath2, stat as stat9 } from "node:fs/promises";
 import { join as pjoin, resolve as presolve, sep as psep } from "node:path";
 import { Readable } from "node:stream";
 function readdirp(root, options = {}) {
@@ -88316,7 +89647,7 @@ var init_readdirp = __esm(() => {
       const type = opts.type ?? defaultOptions.type;
       this._fileFilter = normalizeFilter(opts.fileFilter);
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
-      const statMethod = opts.lstat ? lstat3 : stat8;
+      const statMethod = opts.lstat ? lstat3 : stat9;
       if (wantBigintFsStats) {
         this._stat = (path5) => statMethod(path5, { bigint: true });
       } else {
@@ -88404,9 +89735,9 @@ var init_readdirp = __esm(() => {
       return { files, depth, path: path5 };
     }
     _formatEntry(dirent, path5) {
-      const basename6 = this._isDirent ? dirent.name : dirent;
-      const fullPath = pjoin(path5, basename6);
-      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename6 };
+      const basename7 = this._isDirent ? dirent.name : dirent;
+      const fullPath = pjoin(path5, basename7);
+      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename7 };
       if (this._isDirent) {
         entry.dirent = dirent;
         return entry;
@@ -88471,7 +89802,7 @@ var init_readdirp = __esm(() => {
 
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat4, open, stat as stat9 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat4, open, stat as stat10 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
 function createFsWatchInstance(path5, options, listener, errHandler, emitRaw) {
@@ -88502,9 +89833,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path5);
-    const basename7 = sp.basename(path5);
+    const basename8 = sp.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename7);
+    parent.add(basename8);
     const absolutePath = sp.resolve(path5);
     const options = {
       persistent: opts.persistent
@@ -88514,7 +89845,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -88532,18 +89863,18 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname18 = sp.dirname(file2);
-    const basename7 = sp.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname18);
+    const dirname19 = sp.dirname(file2);
+    const basename8 = sp.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname19);
     let prevStats = stats;
-    if (parent.has(basename7))
+    if (parent.has(basename8))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat9(file2);
+          const newStats2 = await stat10(file2);
           if (this.fsw.closed)
             return;
           const at = newStats2.atimeMs;
@@ -88561,9 +89892,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname18, basename7);
+          this.fsw._remove(dirname19, basename8);
         }
-      } else if (parent.has(basename7)) {
+      } else if (parent.has(basename8)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -88899,7 +90230,7 @@ var init_handler = __esm(() => {
     ERROR: "error"
   };
   EV = EVENTS;
-  statMethods = { lstat: lstat4, stat: stat9 };
+  statMethods = { lstat: lstat4, stat: stat10 };
   HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
   binaryExtensions = new Set([
     "3dm",
@@ -89171,7 +90502,7 @@ var init_handler = __esm(() => {
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir4, stat as stat10 } from "node:fs/promises";
+import { readdir as readdir4, stat as stat11 } from "node:fs/promises";
 import * as sp2 from "node:path";
 function arrify(item) {
   return Array.isArray(item) ? item : [item];
@@ -89625,7 +90956,7 @@ var init_chokidar = __esm(() => {
         const fullPath = opts.cwd ? sp2.join(opts.cwd, path5) : path5;
         let stats2;
         try {
-          stats2 = await stat10(fullPath);
+          stats2 = await stat11(fullPath);
         } catch (err2) {}
         if (!stats2 || this.closed)
           return;
@@ -89729,8 +91060,8 @@ var init_chokidar = __esm(() => {
       }
       return this._userIgnored(path5, stats);
     }
-    _isntIgnored(path5, stat11) {
-      return !this._isIgnored(path5, stat11);
+    _isntIgnored(path5, stat12) {
+      return !this._isIgnored(path5, stat12);
     }
     _getWatchHelpers(path5) {
       return new WatchHelper(path5, this.options.followSymlinks, this);
@@ -89951,7 +91282,7 @@ function diffPathIndexes(previous, next2) {
 import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
 import * as fs6 from "node:fs/promises";
 import { homedir as homedir12 } from "node:os";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function workspaceKeyFor(workingDir) {
   const normalized = normalizeWorkingDirForLookup(workingDir);
   return createHash8("sha256").update(normalized).digest("hex").slice(0, 16);
@@ -89965,10 +91296,10 @@ function buildPathIndex(entries) {
 }
 function manifestPath(machineId, workingDir) {
   const key = workspaceKeyFor(workingDir);
-  return join28(SYNC_STATE_DIR, machineId, key, "manifest.json");
+  return join29(SYNC_STATE_DIR, machineId, key, "manifest.json");
 }
 async function ensureDir2(filePath) {
-  await fs6.mkdir(join28(filePath, ".."), { recursive: true, mode: 448 });
+  await fs6.mkdir(join29(filePath, ".."), { recursive: true, mode: 448 });
 }
 async function loadWorkspaceSyncManifest(machineId, workingDir) {
   try {
@@ -90028,7 +91359,7 @@ function entriesFromPathIndex(paths) {
 }
 var SYNC_STATE_VERSION = "2", SYNC_STATE_DIR;
 var init_workspace_sync_state = __esm(() => {
-  SYNC_STATE_DIR = join28(homedir12(), ".chatroom", "sync-state");
+  SYNC_STATE_DIR = join29(homedir12(), ".chatroom", "sync-state");
 });
 
 // src/infrastructure/services/workspace/workspace-file-tree-coordinator.ts
@@ -91842,17 +93173,17 @@ function parseMakefileTargets(content) {
 var MAX_NAME_LENGTH2 = 256;
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
-import { readFile as readFile15, readdir as readdir5, stat as stat11 } from "node:fs/promises";
-import { join as join29, basename as basename8, resolve as resolve11 } from "node:path";
+import { readFile as readFile16, readdir as readdir5, stat as stat12 } from "node:fs/promises";
+import { join as join30, basename as basename9, resolve as resolve11 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
-  const parentDir2 = join29(rootDir, cleaned.slice(0, -2));
+  const parentDir2 = join30(rootDir, cleaned.slice(0, -2));
   try {
     const entries = await readdir5(parentDir2, { withFileTypes: true });
     const dirs = [];
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const dirPath = join29(parentDir2, entry.name);
+      const dirPath = join30(parentDir2, entry.name);
       if (resolve11(dirPath).startsWith(resolve11(rootDir))) {
         dirs.push(dirPath);
       }
@@ -91863,11 +93194,11 @@ async function resolveGlobPatternStar(rootDir, cleaned) {
   }
 }
 async function resolveLiteralPath(rootDir, cleaned) {
-  const dir = join29(rootDir, cleaned);
+  const dir = join30(rootDir, cleaned);
   try {
     if (!resolve11(dir).startsWith(resolve11(rootDir)))
       return [];
-    const s = await stat11(dir);
+    const s = await stat12(dir);
     if (s.isDirectory())
       return [dir];
   } catch {}
@@ -91883,10 +93214,10 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile15(join29(dir, "package.json"), "utf-8");
+    const content = await readFile16(join30(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
-      name: pkg.name || basename8(dir),
+      name: pkg.name || basename9(dir),
       scripts: pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {}
     };
   } catch {
@@ -91895,7 +93226,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile15(join29(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile16(join30(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -91922,7 +93253,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile15(join29(rootDir, "package.json"), "utf-8");
+    const content = await readFile16(join30(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -91970,12 +93301,12 @@ async function resolveSubWorkspaces(rootDir, pm) {
 var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
-import { access as access2, readFile as readFile16 } from "node:fs/promises";
-import { join as join30, relative as relative3, basename as basename9 } from "node:path";
+import { access as access2, readFile as readFile17 } from "node:fs/promises";
+import { join as join31, relative as relative3, basename as basename10 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join30(workingDir, file2));
+      await access2(join31(workingDir, file2));
       return manager;
     } catch {}
   }
@@ -92019,7 +93350,7 @@ function isValidScriptEntry(name, script) {
 }
 async function readJsonFile(filePath, label) {
   try {
-    const content = await readFile16(filePath, "utf-8");
+    const content = await readFile17(filePath, "utf-8");
     return parseJsonc2(content);
   } catch (error51) {
     if (error51.code !== "ENOENT") {
@@ -92043,8 +93374,8 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
   return commands;
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
-  let rootPackageName = basename9(workingDir);
-  const pkg = await readJsonFile(join30(workingDir, "package.json"), "root package.json");
+  let rootPackageName = basename10(workingDir);
+  const pkg = await readJsonFile(join31(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
   if (pkg.name)
@@ -92060,7 +93391,7 @@ async function readRootPackageJson(workingDir, pm, scriptPrefix) {
 }
 async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
   const turboTaskNames = [];
-  const turbo = await readJsonFile(join30(workingDir, "turbo.json"), "turbo.json");
+  const turbo = await readJsonFile(join31(workingDir, "turbo.json"), "turbo.json");
   if (!turbo?.tasks || typeof turbo.tasks !== "object")
     return turboTaskNames;
   for (const taskName of Object.keys(turbo.tasks)) {
@@ -92073,10 +93404,10 @@ async function readTurboJson(workingDir, _turboPrefix, _rootSubWorkspace) {
 async function readDenoJson(workingDir) {
   const commands = [];
   for (const fileName of ["deno.json", "deno.jsonc"]) {
-    const deno = await readJsonFile(join30(workingDir, fileName), fileName);
+    const deno = await readJsonFile(join31(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
-    const pkgName = deno.name ?? basename9(workingDir);
+    const pkgName = deno.name ?? basename10(workingDir);
     const subWorkspace = { type: "deno", path: ".", name: pkgName };
     for (const [taskName, taskCommand] of Object.entries(deno.tasks)) {
       if (!isValidScriptEntry(taskName, taskCommand))
@@ -92096,14 +93427,14 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile16(join30(workingDir, fileName), "utf-8");
+      const content = await readFile17(join31(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
       const subWorkspace = {
         type: "make",
         path: ".",
-        name: basename9(workingDir)
+        name: basename10(workingDir)
       };
       for (const target of targets) {
         commands.push({
@@ -92234,8 +93565,8 @@ function createWorkspaceGitProbe(args2) {
 }
 async function statFingerprint(absPath) {
   try {
-    const stat12 = await fs7.stat(absPath);
-    return `${stat12.mtimeMs}:${stat12.size}`;
+    const stat13 = await fs7.stat(absPath);
+    return `${stat13.mtimeMs}:${stat13.size}`;
   } catch {
     return "missing";
   }
@@ -93261,12 +94592,12 @@ async function readCommandsUnits(workingDir) {
   return [{ kind: "commands", commands: commands.map(toCommandEntry) }];
 }
 async function readWorktreeUnits(workingDir) {
-  const [dirty, stat12] = await Promise.all([isDirty(workingDir), getDiffStat(workingDir)]);
+  const [dirty, stat13] = await Promise.all([isDirty(workingDir), getDiffStat(workingDir)]);
   return [
     {
       kind: "worktree",
       isDirty: dirty,
-      diffStat: stat12.status === "available" ? { ...stat12.diffStat } : { filesChanged: 0, insertions: 0, deletions: 0 }
+      diffStat: stat13.status === "available" ? { ...stat13.diffStat } : { filesChanged: 0, insertions: 0, deletions: 0 }
     }
   ];
 }
@@ -93643,7 +94974,7 @@ var init_workspace_service2 = __esm(() => {
 });
 
 // src/daemon/entry/init-daemon.ts
-import { stat as stat12 } from "node:fs/promises";
+import { stat as stat13 } from "node:fs/promises";
 async function discoverModelsForHarness(harness, service4) {
   const installed2 = await service4.isInstalled();
   if (!installed2) {
@@ -93678,7 +95009,7 @@ function createDefaultDeps22() {
       kill: (pid, signal) => process.kill(pid, signal)
     },
     fs: {
-      stat: stat12
+      stat: stat13
     },
     machine: {
       clearAgentPid,
@@ -97518,7 +98849,7 @@ var init_git_clone = __esm(() => {
 
 // src/infrastructure/local-actions/git-clone.ts
 import { spawn as spawn5 } from "node:child_process";
-import { readdir as readdir6, stat as stat13 } from "node:fs/promises";
+import { readdir as readdir6, stat as stat14 } from "node:fs/promises";
 function parseGitCloneProgressLine(line) {
   const match5 = PROGRESS_LINE_PATTERN.exec(line.trim());
   if (!match5?.[1] || !match5[2])
@@ -97532,7 +98863,7 @@ function classifyGitCloneFailure(stderrTail, spawnErrorCode) {
 }
 async function statOrNull(path8) {
   try {
-    return await stat13(path8);
+    return await stat14(path8);
   } catch (error51) {
     if (error51.code === "ENOENT")
       return null;
@@ -98111,7 +99442,7 @@ var init_assert_registered_working_dir = () => {};
 
 // src/infrastructure/services/workspace/workspace-path-security.ts
 import { realpath as realpath3 } from "node:fs/promises";
-import { dirname as dirname19, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve12, sep } from "node:path";
+import { dirname as dirname20, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve12, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 function validateRelativePathSegments(filePath) {
   if (filePath.includes("\x00"))
@@ -98139,7 +99470,7 @@ function assertContained(workspaceRoot, targetPath) {
   return { ok: true };
 }
 async function resolveNonExistentTarget(workspaceRoot, candidate) {
-  let current = dirname19(candidate);
+  let current = dirname20(candidate);
   for (;; ) {
     try {
       const ancestorReal = await realpath3(current);
@@ -98157,7 +99488,7 @@ async function resolveNonExistentTarget(workspaceRoot, candidate) {
       if (code2 !== "ENOENT") {
         return { ok: false, error: "Invalid file path" };
       }
-      const parent = dirname19(current);
+      const parent = dirname20(current);
       if (parent === current) {
         return { ok: false, error: "Path escapes workspace" };
       }
@@ -98216,7 +99547,7 @@ function gunzipBase64Payload(base643, maxBytes) {
 var init_workspace_path_security = () => {};
 
 // src/daemon/entry/files/file-content-fulfillment.ts
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 import { gzipSync as gzipSync3 } from "node:zlib";
 function getErrorCause(error51) {
   if (typeof error51 === "object" && error51 !== null && "cause" in error51 && error51.cause !== undefined) {
@@ -98291,7 +99622,7 @@ var init_file_content_fulfillment = __esm(() => {
         continue;
       }
       let fileNotFound = false;
-      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile17(absolutePath)), (error51) => {
+      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile18(absolutePath)), (error51) => {
         if (isENOENT(error51)) {
           fileNotFound = true;
           return exports_Effect.succeed(Buffer.alloc(0));
@@ -98536,10 +99867,10 @@ function parseAttachmentFileName(remainder) {
   if (underscore <= 0)
     return false;
   const uuid3 = remainder.slice(0, underscore);
-  const basename10 = remainder.slice(underscore + 1);
-  if (!UUID_V4_RE.test(uuid3) || !basename10)
+  const basename11 = remainder.slice(underscore + 1);
+  if (!UUID_V4_RE.test(uuid3) || !basename11)
     return false;
-  return sanitizeChatAttachmentFileName(basename10) === basename10;
+  return sanitizeChatAttachmentFileName(basename11) === basename11;
 }
 function getInvalidChatAttachmentUploadPathReason(relativePath) {
   if (relativePath.includes("\\"))
@@ -98568,14 +99899,14 @@ function normalizeSegments(relativePath) {
 function hasBlockedSegment(lowerSegments) {
   return lowerSegments.some((segment) => BLOCKED_SEGMENT_NAMES.has(segment));
 }
-function hasBlockedBasename(basename10) {
-  return /^\.env(?:\.|$)/.test(basename10) || /\.(?:pem|key)$/.test(basename10) || basename10 === "id_rsa" || basename10 === "credentials.json";
+function hasBlockedBasename(basename11) {
+  return /^\.env(?:\.|$)/.test(basename11) || /\.(?:pem|key)$/.test(basename11) || basename11 === "id_rsa" || basename11 === "credentials.json";
 }
 function isBlockedUploadTargetPath(relativePath) {
   if (!relativePath)
     return false;
-  const { lowerSegments, basename: basename10 } = normalizeSegments(relativePath);
-  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename10);
+  const { lowerSegments, basename: basename11 } = normalizeSegments(relativePath);
+  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename11);
 }
 function getBlockedUploadTargetReason(relativePath) {
   if (!isBlockedUploadTargetPath(relativePath))
@@ -98625,8 +99956,8 @@ var init_file_write_request_priority = __esm(() => {
 });
 
 // src/daemon/entry/files/file-write-fulfillment.ts
-import { access as access4, mkdir as mkdir12, rename as rename4, rm as rm5, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname20 } from "node:path";
+import { access as access4, mkdir as mkdir12, rename as rename4, rm as rm5, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname21 } from "node:path";
 function isTerminalFileWriteError(errorMessage3) {
   const terminalMessages = new Set([
     "Invalid file path",
@@ -98725,11 +100056,11 @@ async function validateWriteOperation(operation, absolutePath) {
 }
 async function writePayloadToDisk(absolutePath, operation, content) {
   if (operation === "create") {
-    await mkdir12(dirname20(absolutePath), { recursive: true });
-    await writeFile10(absolutePath, content, { flag: "wx" });
+    await mkdir12(dirname21(absolutePath), { recursive: true });
+    await writeFile11(absolutePath, content, { flag: "wx" });
     return;
   }
-  await writeFile10(absolutePath, content);
+  await writeFile11(absolutePath, content);
 }
 async function fulfillOneFileWriteRequest(session2, request3) {
   const claim = await claimWriteRequest(session2, request3);
@@ -98803,7 +100134,7 @@ async function fulfillOneFileWriteRequest(session2, request3) {
         });
         return;
       }
-      await mkdir12(dirname20(targetResolved.absolutePath), { recursive: true });
+      await mkdir12(dirname21(targetResolved.absolutePath), { recursive: true });
       await rename4(resolved.absolutePath, targetResolved.absolutePath);
       await completeWriteRequest(session2, claimed._id, claimed.revision, { status: "done" });
       const elapsed2 = Date.now() - startTime;
@@ -100534,9 +101865,9 @@ var init_execute_chatroom_stop_command = __esm(() => {
 
 // src/daemon/entry/persistence-path.ts
 import { homedir as homedir13 } from "node:os";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 function resolvePersistenceDbPath(machineId) {
-  return join31(homedir13(), ".chatroom", "daemon", machineId, "events.sqlite");
+  return join32(homedir13(), ".chatroom", "daemon", machineId, "events.sqlite");
 }
 var init_persistence_path = () => {};
 
@@ -101095,10 +102426,10 @@ var init_schema = __esm(() => {
 
 // src/daemon/infrastructure/persistence/open-database.ts
 import { mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname21 } from "node:path";
+import { dirname as dirname22 } from "node:path";
 import { DatabaseSync as DatabaseSync5 } from "node:sqlite";
 function openDatabase(dbPath) {
-  mkdirSync9(dirname21(dbPath), { recursive: true });
+  mkdirSync9(dirname22(dbPath), { recursive: true });
   const db = new DatabaseSync5(dbPath);
   for (const sql of MIGRATIONS2) {
     db.exec(sql);
@@ -112072,13 +113403,13 @@ var require_cookie = __commonJS((exports) => {
     } while (index < len2);
     return obj;
   }
-  function startIndex(str, index, max5) {
+  function startIndex(str, index, max6) {
     do {
       var code2 = str.charCodeAt(index);
       if (code2 !== 32 && code2 !== 9)
         return index;
-    } while (++index < max5);
-    return max5;
+    } while (++index < max6);
+    return max6;
   }
   function endIndex(str, index, min5) {
     while (index > min5) {
@@ -117211,19 +118542,19 @@ function routeRequest(req, res, deps) {
 
 // src/daemon/local-web/server/serve-static.ts
 import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname22, join as join32 } from "node:path";
+import { dirname as dirname23, join as join33 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function clientDistCandidates(here) {
   return [
-    join32(here, "client/build"),
-    join32(here, "../client/build"),
-    join32(here, "../src/daemon/local-web/client/build")
+    join33(here, "client/build"),
+    join33(here, "../client/build"),
+    join33(here, "../src/daemon/local-web/client/build")
   ];
 }
-function resolveClientDistDir(here = dirname22(fileURLToPath6(import.meta.url))) {
+function resolveClientDistDir(here = dirname23(fileURLToPath6(import.meta.url))) {
   const candidates = clientDistCandidates(here);
   for (const dir of candidates) {
-    if (existsSync10(join32(dir, "index.html")))
+    if (existsSync10(join33(dir, "index.html")))
       return dir;
   }
   return candidates[0];
@@ -117236,7 +118567,7 @@ function tryServeStatic(req, res, distDir) {
     return false;
   }
   const safePath = pathname === "/" ? "/index.html" : pathname;
-  const filePath = join32(distDir, safePath);
+  const filePath = join33(distDir, safePath);
   if (!filePath.startsWith(distDir)) {
     res.writeHead(403);
     res.end();
@@ -117253,7 +118584,7 @@ function tryServeStatic(req, res, distDir) {
     }
     return true;
   }
-  const indexPath = join32(distDir, "index.html");
+  const indexPath = join33(distDir, "index.html");
   if (existsSync10(indexPath)) {
     res.writeHead(200, { "Content-Type": "text/html" });
     if (req.method === "HEAD") {
@@ -118617,7 +119948,7 @@ var {
 } = import__.default;
 
 // src/commands/generate-3d/index.ts
-import { readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
 init_model_registry();
 var GENERATE_3D_PLATFORMS = ["fal"];
 var DEFAULT_GENERATE_3D_PLATFORM = "fal";
@@ -118627,6 +119958,20 @@ function parsePlatform(value) {
   }
   return value;
 }
+var ORIGIN_MODES = ["feet", "center", "as-is"];
+function parseOrigin(value) {
+  if (!ORIGIN_MODES.includes(value)) {
+    throw new InvalidArgumentError(`must be one of ${ORIGIN_MODES.join(", ")}`);
+  }
+  return value;
+}
+function parseTargetHeight(value) {
+  const meters = Number(value);
+  if (!Number.isFinite(meters) || meters <= 0) {
+    throw new InvalidArgumentError("must be a positive, finite number of metres");
+  }
+  return meters;
+}
 var CAPABILITY_FLAGS = [
   { capability: "prompt", flag: "--prompt" },
   { capability: "image", flag: "--input-image" },
@@ -118661,7 +120006,7 @@ function parseInputJson2(text) {
   return parsed;
 }
 async function readInputFile(path) {
-  const stats = await stat2(path).catch(() => null);
+  const stats = await stat3(path).catch(() => null);
   if (stats === null)
     throw new Error(`--input file not found: ${path}`);
   if (!stats.isFile())
@@ -118669,7 +120014,7 @@ async function readInputFile(path) {
   if (stats.size > MAX_INPUT_BYTES) {
     throw new Error(`--input file is ${stats.size} bytes; the maximum is ${MAX_INPUT_BYTES} bytes (1 MiB).`);
   }
-  return parseInputJson2(await readFile3(path, "utf8"));
+  return parseInputJson2(await readFile4(path, "utf8"));
 }
 async function readExtraInput(value) {
   if (value === undefined)
@@ -118702,7 +120047,16 @@ Package:
   <base>.zip holds the master GLB, web/<stem>.web.glb, and manifest.json; the
   reference image at reference/... when one was generated or supplied; and the
   rigged and animation GLBs with their web versions when rigging ran.
-  <base>.html is a standalone preview. <base> is <out-stem>-<timestamp>.
+  <base>.html is a standalone preview of both variants: the full-resolution
+  master and the scaled-down web variant. <base> is <out-stem>-<timestamp>.
+
+Fit:
+  --target-height and --origin apply to the master, the web variant, and every
+  rig output. With no flags the asset is written as the model returned it.
+
+Preview:
+  chatroom generate-3d preview <base>.zip rebuilds <base>.html from an existing
+  package without contacting fal. Pass --force to replace an existing page.
 
 Cost:
   List prices as of ${GENERATE_3D_PRICES_AS_OF}, not billed amounts; fal returns no
@@ -118714,9 +120068,18 @@ function printResult(result) {
   console.log(`Manifest ${result.manifestPath}`);
   console.log(`Package ${result.zipPath}`);
   console.log(`Preview ${result.htmlPath}`);
+  for (const check of result.checks)
+    console.log(`Warning: ${check.message}`);
+  for (const warning of result.warnings)
+    console.log(`Warning: ${warning}`);
   for (const line of result.costLines)
     console.log(line);
 }
+function toFit(options) {
+  if (options.origin === "as-is" && options.targetHeight === undefined)
+    return;
+  return { origin: options.origin, targetHeight: options.targetHeight };
+}
 function toGenerate3dOptions(options, extraInput) {
   const base = {
     prompt: options.prompt,
@@ -118724,6 +120087,7 @@ function toGenerate3dOptions(options, extraInput) {
     model: options.model,
     out: options.out,
     force: options.force,
+    fit: toFit(options),
     rig: options.rig,
     packageDir: options.packageDir,
     extraInput,
@@ -118747,7 +120111,12 @@ async function executeGenerate3d(options) {
   const { generate3d: generate3d2 } = await Promise.resolve().then(() => (init_generate_3d(), exports_generate_3d));
   printResult(await generate3d2(generateOptions, deps));
 }
-async function runGenerate3d(options) {
+async function runGenerate3d(options, command) {
+  if (options.out === undefined) {
+    command.error("error: required option '--out <path>' not specified", {
+      code: "commander.missingMandatoryOptionValue"
+    });
+  }
   try {
     await executeGenerate3d(options);
   } catch (err2) {
@@ -118755,12 +120124,26 @@ async function runGenerate3d(options) {
     process.exitCode = 1;
   }
 }
+async function runGenerate3dPreview(zip, options, command) {
+  try {
+    const { rebuildPreviewFromZip: rebuildPreviewFromZip2 } = await Promise.resolve().then(() => (init_rebuild_preview(), exports_rebuild_preview));
+    const parentForce = command.parent?.opts().force === true;
+    const htmlPath = await rebuildPreviewFromZip2(zip, {
+      force: options.force === true || parentForce
+    });
+    console.log(`Preview ${htmlPath}`);
+  } catch (err2) {
+    console.error(`❌ ${err2 instanceof Error ? err2.message : String(err2)}`);
+    process.exitCode = 1;
+  }
+}
 function registerGenerate3dCommand(program2) {
-  program2.command("generate-3d").description("Generate one 3D mesh (GLB) with a fal model, plus its JSON manifest and a zip/preview package").option("--model <id>", "fal endpoint id (default fal-ai/trellis-2); any id is accepted").requiredOption("--out <path>", "Output GLB path (manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_3D_PLATFORM).option("--prompt <text>", "text prompt; with the default model, a reference image is generated first").option("--input-image <path-or-url>", "reference image (local file or URL); the image-to-3D input").option("--force", "replace existing output, reference, package, preview, rig, and clip files").option("--rig", "rig with Meshy 7.1 (requires --model meshy/v7.1/...); needs --confirm-cost on a real run").option("--animation-action-id <id>", "Meshy preset animation id (0-696), repeatable; requires --rig", collectRepeatable, []).option("--package-dir <dir>", "Directory for the package zip and preview (default: the directory of --out)").option("--input <json|@file>", "extra fal request fields as a JSON object, merged over the model defaults; reserved: prompt, image_url; @file reads JSON from a file").option("--confirm-cost", "confirm the priced plan for a real run that rigs or animates (Meshy 7.1 only), after the user confirms the priced dry run; not needed for --dry-run").option("--dry-run", "Validate and print the request and the static list-price estimate. No upload or fal generation call is made; FAL_API_KEY is not required").addHelpText("after", HELP_AFTER).action(runGenerate3d);
+  const generate3d2 = program2.command("generate-3d").description("Generate one 3D mesh (GLB) with a fal model, plus its JSON manifest and a zip/preview package").option("--model <id>", "fal endpoint id (default fal-ai/trellis-2); any id is accepted").option("--out <path>", "Output GLB path (required; manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_3D_PLATFORM).option("--prompt <text>", "text prompt; with the default model, a reference image is generated first").option("--input-image <path-or-url>", "reference image (local file or URL); the image-to-3D input").option("--force", "replace existing output, reference, package, preview, rig, and clip files").option("--target-height <meters>", "Scale the model so its height is this many metres (positive, finite)", parseTargetHeight).option("--origin <origin>", "Where the origin goes: feet (bottom centre), center, or as-is (default)", parseOrigin, "as-is").option("--rig", "rig with Meshy 7.1 (requires --model meshy/v7.1/...); needs --confirm-cost on a real run").option("--animation-action-id <id>", "Meshy preset animation id (0-696), repeatable; requires --rig", collectRepeatable, []).option("--package-dir <dir>", "Directory for the package zip and preview (default: the directory of --out)").option("--input <json|@file>", "extra fal request fields as a JSON object, merged over the model defaults; reserved: prompt, image_url; @file reads JSON from a file").option("--confirm-cost", "confirm the priced plan for a real run that rigs or animates (Meshy 7.1 only), after the user confirms the priced dry run; not needed for --dry-run").option("--dry-run", "Validate and print the request and the static list-price estimate. No upload or fal generation call is made; FAL_API_KEY is not required").addHelpText("after", HELP_AFTER).action(runGenerate3d);
+  generate3d2.command("preview <zip>").description("Rebuild <base>.html from an existing package zip, offline").option("--force", "replace an existing <base>.html").action(runGenerate3dPreview);
 }
 
 // src/commands/generate-image/index.ts
-import { readFile as readFile4, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile5, stat as stat4 } from "node:fs/promises";
 init_image();
 init_model_capabilities();
 init_image_preflight();
@@ -118781,7 +120164,7 @@ async function readInputOption(value) {
   if (!value.startsWith("@"))
     return parseInputJson(value);
   const path = value.slice(1);
-  const stats = await stat3(path).catch(() => null);
+  const stats = await stat4(path).catch(() => null);
   if (stats === null)
     throw new Error(`--input file not found: ${path}`);
   if (!stats.isFile())
@@ -118789,7 +120172,7 @@ async function readInputOption(value) {
   if (stats.size > MAX_SIDECAR_BYTES) {
     throw new Error(`--input file is ${stats.size} bytes; the maximum is ${MAX_SIDECAR_BYTES} bytes (1 MiB).`);
   }
-  return parseInputJson(await readFile4(path, "utf8"));
+  return parseInputJson(await readFile5(path, "utf8"));
 }
 function parseSeed(value) {
   const seed = Number(value);
@@ -118852,7 +120235,7 @@ function registerChatroomRoleCommand(program2, config) {
 }
 
 // src/commands/remove-image-background/remove-image-background.ts
-import { basename as basename2, dirname as dirname5, extname as extname3, join as join3, resolve as resolve3 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname as extname3, join as join4, resolve as resolve3 } from "node:path";
 
 // src/commands/remove-image-background/background-key.ts
 init_image_preflight();
@@ -119217,7 +120600,7 @@ function resolveMode(opts) {
       throw new RemoveBackgroundError("--out must end in .png.");
     }
     const outPath = resolve3(opts.out);
-    return { kind: "single", inPath: resolve3(opts.in), outPath, outDir: dirname5(outPath) };
+    return { kind: "single", inPath: resolve3(opts.in), outPath, outDir: dirname6(outPath) };
   }
   if (opts.inDir === undefined || opts.outDir === undefined) {
     throw new RemoveBackgroundError("--in-dir and --out-dir must be used together.");
@@ -119245,7 +120628,7 @@ function requireRanges(opts) {
 async function enumerateInputs(mode, deps) {
   if (mode.kind === "single") {
     return {
-      inputs: [{ path: mode.inPath, stem: basename2(mode.inPath, extname3(mode.inPath)) }],
+      inputs: [{ path: mode.inPath, stem: basename3(mode.inPath, extname3(mode.inPath)) }],
       ignoredNonPng: 0
     };
   }
@@ -119258,7 +120641,7 @@ async function enumerateInputs(mode, deps) {
     throw new RemoveBackgroundError(`${mode.inDir} contains ${pngs.length} PNG files; the maximum is ${MAX_BATCH_FILES}.`);
   }
   return {
-    inputs: pngs.map((name) => ({ path: join3(mode.inDir, name), stem: basename2(name, ".png") })),
+    inputs: pngs.map((name) => ({ path: join4(mode.inDir, name), stem: basename3(name, ".png") })),
     ignoredNonPng: entries.length - pngs.length
   };
 }
@@ -119313,7 +120696,7 @@ function requireSafeName(name, context) {
 }
 function assignNames(mode, opts, tiles) {
   if (mode.kind === "single") {
-    const name = requireSafeName(basename2(mode.outPath, ".png"), "--out");
+    const name = requireSafeName(basename3(mode.outPath, ".png"), "--out");
     return [{ tile: tiles[0], assignedName: name, assignedBy: "out" }];
   }
   const stems = new Set(tiles.map((tile) => tile.stem));
@@ -119538,7 +120921,7 @@ async function prepareAssets(named, mode, options, deps) {
       throw new RemoveBackgroundError(`Cannot remove the background from ${entry.tile.path}: ${keyed.message}`);
     }
     const { encoded, outputWidth, outputHeight, trim } = encodeAsset(entry.tile.image, keyed, options, deps);
-    const path = mode.kind === "single" ? mode.outPath : join3(mode.outDir, `${entry.assignedName}.png`);
+    const path = mode.kind === "single" ? mode.outPath : join4(mode.outDir, `${entry.assignedName}.png`);
     prepared.push({
       tile: namedTile,
       keyed,
@@ -119817,7 +121200,7 @@ function registerRemoveImageBackgroundFalCommand(program2) {
 
 // src/commands/slice-image/slice.ts
 init_image_preflight();
-import { basename as basename4, extname as extname4, join as join4, resolve as resolve5 } from "node:path";
+import { basename as basename5, extname as extname4, join as join5, resolve as resolve5 } from "node:path";
 var SLICE_TOOL = "chatroom slice-image";
 var MAX_TILES = 256;
 var MAX_GRID_DIMENSION = 64;
@@ -119832,12 +121215,12 @@ class SliceImageError extends Error {
 function padWidth(tileCount) {
   return Math.max(2, String(tileCount).length);
 }
-function requireInteger(value, label, min, max) {
+function requireInteger(value, label, min, max2) {
   if (!Number.isInteger(value)) {
     throw new SliceImageError(`${label} must be an integer.`);
   }
-  if (value < min || max !== undefined && value > max) {
-    const range = max === undefined ? `at least ${min}` : `between ${min} and ${max}`;
+  if (value < min || max2 !== undefined && value > max2) {
+    const range = max2 === undefined ? `at least ${min}` : `between ${min} and ${max2}`;
     throw new SliceImageError(`${label} must be ${range}.`);
   }
   return value;
@@ -120128,20 +121511,20 @@ async function sliceImage(opts, deps) {
     gutter,
     allowRemainder: opts.allowRemainder === true
   });
-  const sheetStem = basename4(inPath, extname4(inPath));
+  const sheetStem = basename5(inPath, extname4(inPath));
   const names = resolveTileNames({
     cols,
     rows,
     names: opts.names,
     prefix: opts.prefix ?? sheetStem
   });
-  const indexPath = join4(outDir, `${sheetStem}.slices.json`);
+  const indexPath = join5(outDir, `${sheetStem}.slices.json`);
   const sourceManifestPath = `${inPath}.json`;
   const outputs = grid.cells.map((cell) => {
     const name = names[cell.index] ?? "";
     if (name.length === 0)
       return null;
-    const path = join4(outDir, `${name}.png`);
+    const path = join5(outDir, `${name}.png`);
     return { cell, name, path, manifestPath: `${path}.json` };
   }).filter((entry) => entry !== null);
   const skipped = grid.cells.filter((cell) => (names[cell.index] ?? "").length === 0).map((cell) => cell.index);
@@ -121048,4 +122431,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=D6C1587E8A62204B64756E2164756E21
+//# debugId=0BF4A795FB05C49664756E2164756E21