@omrips/viewstl 2.0.0-rc.4 → 2.0.0-rc.6

package/build/{v2/viewstl.js → viewstl.js}

@@ -1,52 +1,4 @@
-// src/v2/appearance.js
-var DISPLAYS = [
-  "flat",
-  "smooth",
-  "wireframe",
-  "edges",
-  "mesh",
-  "xray",
-  "studio",
-  "orientation"
-];
-function validateView(display, smooth) {
-  if (!DISPLAYS.includes(display)) throw new Error("Invalid display mode");
-  if (typeof smooth !== "boolean")
-    throw new Error("smooth_shading must be a boolean");
-  return { display, smooth_shading: display === "smooth" || smooth };
-}
-function viewFeatures(view) {
-  return {
-    smooth: (view.smooth_shading || view.display === "smooth") && view.display !== "wireframe",
-    edges: view.view_edges || view.display === "edges",
-    wire: view.display === "wireframe",
-    edgeAngle: view.display === "edges" ? 30 : 1
-  };
-}
-function validateSection(section) {
-  if (section == null) return null;
-  if (!["x", "y", "z"].includes(section.axis))
-    throw new Error("Section axis must be x, y or z");
-  if (!Number.isFinite(section.position) || section.position < 0 || section.position > 1)
-    throw new Error("Section position must be between 0 and 1");
-  if (section.flip !== void 0 && typeof section.flip !== "boolean")
-    throw new Error("Section flip must be a boolean");
-  return {
-    axis: section.axis,
-    position: section.position,
-    flip: section.flip ?? false
-  };
-}
-function sectionPlane(bounds, section) {
-  if (!section) return [0, 0, 0, 0];
-  const axis = ["x", "y", "z"].indexOf(section.axis), sign = section.flip ? -1 : 1;
-  const plane = [0, 0, 0, 0];
-  plane[axis] = sign;
-  plane[3] = -sign * (bounds.min[axis] + (bounds.max[axis] - bounds.min[axis]) * section.position);
-  return plane;
-}
-
-// src/v2/math.js
+// src/math.js
 var add = (a, b) => a.map((v, i) => v + b[i]);
 var sub = (a, b) => a.map((v, i) => v - b[i]);
 var mul = (a, s) => a.map((v) => v * s);
@@ -198,7 +150,178 @@ function rayTriangle(o, d, p, i) {
   return t >= 0 ? t : Infinity;
 }
 
-// src/v2/memory.js
+// src/animation.js
+var animationKeys = [
+  "x",
+  "y",
+  "z",
+  "rotationx",
+  "rotationy",
+  "rotationz",
+  "scalex",
+  "scaley",
+  "scalez"
+];
+var isScale = (key) => key.startsWith("scale");
+var number = (value, name, positive2 = false) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > Number.MAX_SAFE_INTEGER || positive2 && value <= 0)
+    throw new Error(`Invalid animation ${name}`);
+  return value;
+};
+var object = (value, name) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Invalid animation ${name}`);
+  return value;
+};
+function animationPose(model) {
+  return Object.fromEntries(
+    animationKeys.map((key) => [
+      key,
+      number(
+        model[key] ?? (isScale(key) ? model.scale ?? 1 : 0),
+        key,
+        isScale(key)
+      )
+    ])
+  );
+}
+function normalizeAnimation(input) {
+  object(input, "definition");
+  const result = {}, claimed = /* @__PURE__ */ new Set();
+  for (const mode of ["delta", "exact"]) {
+    if (input[mode] == null) continue;
+    const source = object(input[mode], mode), values = {};
+    const msec = number(source.msec ?? 300, "duration", true);
+    if (source.loop !== void 0 && typeof source.loop !== "boolean")
+      throw new Error("Animation loop must be a boolean");
+    const loop = mode === "delta" && !!source.loop;
+    for (const key of animationKeys) {
+      const value = source[key] ?? (isScale(key) ? source.scale : void 0);
+      if (value === void 0) continue;
+      if (claimed.has(key))
+        throw new Error(`Animation delta/exact conflict: ${key}`);
+      number(value, key, mode === "exact" && isScale(key));
+      if (loop && isScale(key) && value < 0)
+        throw new Error("Looping scale deltas cannot be negative");
+      values[key] = value;
+      claimed.add(key);
+    }
+    if (!Object.keys(values).length)
+      throw new Error("Animation track needs a transform");
+    result[mode] = { ...values, msec, ...loop ? { loop: true } : {} };
+  }
+  if (!Object.keys(result).length)
+    throw new Error("Animation needs delta or exact");
+  return result;
+}
+function normalizePlaybackState(input) {
+  object(input, "playback state");
+  if (input.version !== 1 || typeof input.paused !== "boolean")
+    throw new Error("Invalid animation playback state version or paused flag");
+  const elapsed_ms = number(input.elapsed_ms, "elapsed time");
+  if (elapsed_ms < 0) throw new Error("Invalid animation elapsed time");
+  object(input.origin, "origin");
+  for (const key of animationKeys) number(input.origin[key], key, isScale(key));
+  if (!Array.isArray(input.center) || input.center.length !== 3)
+    throw new Error("Invalid animation pivot");
+  return {
+    version: 1,
+    elapsed_ms,
+    paused: input.paused,
+    origin: animationPose(input.origin),
+    center: input.center.map((v) => number(v, "pivot"))
+  };
+}
+function createPlayback(definition, model, saved) {
+  const animation = normalizeAnimation(definition);
+  const state = saved == null ? null : normalizePlaybackState(saved);
+  const origin = state?.origin ?? animationPose(model);
+  const tracks = Object.entries(animation).map(([mode, a]) => {
+    const values = Object.entries(a).filter(
+      ([key]) => animationKeys.includes(key)
+    );
+    if (mode === "delta")
+      for (const [key, value] of values)
+        number(origin[key] + value, `${key} endpoint`, isScale(key));
+    return { mode, values, duration: a.msec, loop: !!a.loop, done: false };
+  });
+  const playback = {
+    animation,
+    origin,
+    tracks,
+    elapsed_ms: state?.elapsed_ms ?? 0,
+    paused: state?.paused ?? false,
+    last_time: null
+  };
+  evaluatePlayback({ ...playback, tracks: tracks.map((t) => ({ ...t })) }, {});
+  return playback;
+}
+function evaluatePlayback(playback, model) {
+  const updates = [];
+  for (const track of playback.tracks) {
+    if (track.done) continue;
+    const fraction = playback.elapsed_ms / track.duration;
+    const p = track.loop ? fraction : Math.min(fraction, 1);
+    for (const [key, value] of track.values) {
+      const from = playback.origin[key];
+      const to = track.mode === "delta" ? from + value * p : from * (1 - p) + value * p;
+      updates.push([key, number(to, `${key} result`, isScale(key))]);
+    }
+  }
+  let scaleChanged = false;
+  for (const [key, value] of updates) {
+    scaleChanged ||= isScale(key) && model[key] !== value;
+    model[key] = value;
+  }
+  for (const track of playback.tracks)
+    if (!track.loop && playback.elapsed_ms >= track.duration) track.done = true;
+  if (scaleChanged) model._stats = null;
+  return playback.tracks.some((track) => !track.done);
+}
+function advancePlayback(playback, model, time) {
+  if (playback.paused) return true;
+  if (playback.last_time !== null)
+    playback.elapsed_ms = number(
+      playback.elapsed_ms + Math.max(0, time - playback.last_time),
+      "elapsed time"
+    );
+  playback.last_time = time;
+  return evaluatePlayback(playback, model);
+}
+function playbackState(playback, suspended = false) {
+  return {
+    status: playback.paused ? "paused" : "running",
+    elapsed_ms: playback.elapsed_ms,
+    suspended,
+    tracks: playback.tracks.filter((t) => !t.done).map((t) => ({
+      mode: t.mode,
+      msec: t.duration,
+      loop: t.loop,
+      progress: t.loop ? playback.elapsed_ms % t.duration / t.duration : Math.min(1, playback.elapsed_ms / t.duration)
+    }))
+  };
+}
+function savePlayback(model) {
+  const p = model._animation;
+  if (!p) return null;
+  const factor = model.unitScale ?? 1;
+  const animation = structuredClone(p.animation), origin = { ...p.origin };
+  for (const key of animationKeys.filter(isScale)) {
+    origin[key] *= factor;
+    for (const track of Object.values(animation))
+      if (track[key] !== void 0) track[key] *= factor;
+  }
+  const animation_state = normalizePlaybackState({
+    version: 1,
+    origin,
+    elapsed_ms: p.elapsed_ms,
+    paused: p.paused,
+    center: [...model.center]
+  });
+  return { animation: normalizeAnimation(animation), animation_state };
+}
+
+// src/memory.js
 var MEMORY_OVERHEAD = 64 * 1024 * 1024;
 var TRIANGLE_MEMORY = 224;
 function geometryMemory(g) {
@@ -215,7 +338,420 @@ function derivedMemory(triangles, features) {
   return MEMORY_OVERHEAD + triangles * (TRIANGLE_MEMORY + (features.smooth ? 1536 : 0) + (features.edges || features.wire ? 2048 : 0));
 }
 
-// src/v2/geometry.js
+// src/print-options.js
+function printOptions(input = {}) {
+  const level = input.level ?? "basic";
+  if (!["basic", "detailed"].includes(level))
+    throw new Error("Choose basic or detailed print checks");
+  const number2 = (v, name, max = 1e9) => {
+    if (!Number.isFinite(v) || v <= 0 || v > max)
+      throw new Error(`Invalid ${name}`);
+    return v;
+  };
+  let profile = null;
+  if (input.profile != null) {
+    if (input.profile.technology !== "fdm")
+      throw new Error("Only FDM profiles are supported");
+    profile = { technology: "fdm" };
+    for (const key of ["min_wall_mm", "line_width_mm"])
+      if (input.profile[key] != null)
+        profile[key] = number2(input.profile[key], key);
+    if (input.profile.overhang_degrees != null)
+      profile.overhang_degrees = number2(
+        input.profile.overhang_degrees,
+        "overhang angle",
+        89.9
+      );
+    if (input.profile.build_volume_mm != null) {
+      if (!Array.isArray(input.profile.build_volume_mm) || input.profile.build_volume_mm.length !== 3)
+        throw new Error("Build volume requires X, Y and Z");
+      profile.build_volume_mm = input.profile.build_volume_mm.map(
+        (v) => number2(v, "build volume")
+      );
+    }
+  }
+  const time = number2(input.max_time_ms ?? 3e4, "check time limit", 12e4);
+  return {
+    level,
+    profile,
+    apply_transforms: input.apply_transforms !== false,
+    units_confirmed: input.units_confirmed === true,
+    max_time_ms: time
+  };
+}
+var printMemory = (triangles) => 64 * 1024 ** 2 + triangles * 2400;
+var printSignature = (model) => JSON.stringify([
+  model.x,
+  model.y,
+  model.z,
+  model.rotationx,
+  model.rotationy,
+  model.rotationz,
+  model.scaleVector,
+  model.center,
+  model.units,
+  model.unitScale
+]);
+
+// src/model-tools.js
+var axes = ["x", "y", "z"];
+function validateUnits(units) {
+  if (!["mm", "inch"].includes(units)) throw new Error("Choose mm or inch");
+  return units;
+}
+function validateSizeState(value) {
+  if (!value || value.version !== 1 || !Array.isArray(value.baseline_mm) || value.baseline_mm.length !== 3 || value.baseline_mm.some((v) => !Number.isFinite(v) || v < 0 || v > 1e12) || typeof value.editable !== "boolean" || value.unit_factor !== void 0 && (!Number.isFinite(value.unit_factor) || value.unit_factor <= 0 || value.unit_factor > 1e12))
+    throw new Error("Invalid saved model size");
+  return {
+    version: 1,
+    baseline_mm: [...value.baseline_mm],
+    file_units: validateUnits(value.file_units),
+    editable: value.editable,
+    unit_factor: value.unit_factor ?? 1
+  };
+}
+function sizeState(model) {
+  return model.size_state ??= {
+    version: 1,
+    baseline_mm: model.geometry.bounds.max.map(
+      (v, i) => (v - model.geometry.bounds.min[i]) * model.unitScale
+    ),
+    file_units: "mm",
+    editable: !model.geometry.units,
+    unit_factor: 1
+  };
+}
+function modelSize(model) {
+  if (!model.geometry) throw new Error("Wait for the model to finish opening");
+  const state = sizeState(model);
+  return {
+    ...structuredClone(state),
+    dimensions_mm: model.geometry.bounds.max.map(
+      (v, i) => (v - model.geometry.bounds.min[i]) * model.scaleVector[i]
+    )
+  };
+}
+function resizeModel(id, factors) {
+  const m = this._model(id);
+  modelSize(m);
+  if (!Array.isArray(factors) || factors.length !== 3 || factors.some((v) => !Number.isFinite(v) || v <= 0))
+    throw new Error("Scale must be a positive finite number");
+  const next = axes.map((a, i) => m["scale" + a] * factors[i]);
+  if (next.some((v) => !Number.isFinite(v) || v < 1e-12 || v > 1e12))
+    throw new Error("Scale is outside the supported range");
+  const center = m.geometry.bounds.min.map(
+    (v, i) => (v + m.geometry.bounds.max[i]) / 2
+  );
+  const before = transform(modelMatrix(m), center);
+  const cached = m._measurements;
+  const oldKey = m.scaleVector.join(",");
+  this._stopAnimation(m, "manual");
+  axes.forEach((a, i) => m["scale" + a] = next[i]);
+  const after = transform(modelMatrix(m), center);
+  axes.forEach((a, i) => m[a] += before[i] - after[i]);
+  m._stats = null;
+  if (cached?.key === oldKey && cached.positions === m.geometry.positions && factors.every((v) => v === factors[0])) {
+    m._measurements = {
+      ...cached,
+      key: m.scaleVector.join(","),
+      result: {
+        ...cached.result,
+        area_mm2: cached.result.area_mm2 * factors[0] ** 2,
+        volume_mm3: cached.result.volume_mm3 == null ? null : cached.result.volume_mm3 * factors[0] ** 3
+      }
+    };
+  }
+  this._invalidate();
+  return modelSize(m);
+}
+function setFileUnits(id, units) {
+  validateUnits(units);
+  const m = this._model(id), state = sizeState(m);
+  if (!state.editable)
+    throw new Error(
+      "This model has explicit file units, already converted to millimetres"
+    );
+  if (state.file_units === units) return modelSize(m);
+  const factor = units === "inch" ? 25.4 : 1 / 25.4;
+  const result = resizeModel.call(this, id, [factor, factor, factor]);
+  state.baseline_mm = state.baseline_mm.map((v) => v * factor);
+  state.file_units = units;
+  state.unit_factor = (state.unit_factor ?? 1) * factor;
+  return { ...result, ...structuredClone(state) };
+}
+function resetModelSize(id) {
+  const size = modelSize(this._model(id));
+  return resizeModel.call(
+    this,
+    id,
+    size.dimensions_mm.map((v, i) => v ? size.baseline_mm[i] / v : 1)
+  );
+}
+function duplicateModel(id) {
+  const source = this._model(id);
+  modelSize(source);
+  if (source._sceneImportPending)
+    throw new Error("Wait for the scene to finish opening");
+  if (this._models.size + 1 > this.limits.max_archive_entries || [...this._models.values()].reduce(
+    (n, m) => n + (m.geometry?.triangles || 0),
+    source.geometry.triangles
+  ) > this.limits.max_triangles)
+    throw new Error("Scene model or triangle limit exceeded");
+  assertMemory(
+    this.limits,
+    this._occupiedMemory() + geometryMemory(source.geometry),
+    "duplicate"
+  );
+  const copy = {};
+  for (const key of [
+    "filename",
+    "orig_filename",
+    "local_file",
+    "x",
+    "y",
+    "z",
+    "rotationx",
+    "rotationy",
+    "rotationz",
+    "opacity",
+    "units",
+    "display",
+    "view_edges",
+    "smooth_shading",
+    "color"
+  ])
+    copy[key] = source[key];
+  copy.id = this.max_model_id + 1;
+  if (!Number.isSafeInteger(copy.id))
+    throw new Error("Model ID limit exceeded");
+  copy.display_name = (source.display_name || source.orig_filename || source.filename || "Model").split(/[\\/]/).pop() + " \u2014 copy";
+  copy.center = [...source.center];
+  copy.unitScale = 1;
+  axes.forEach((a, i) => copy["scale" + a] = source.scaleVector[i]);
+  Object.defineProperty(copy, "scaleVector", {
+    get: () => axes.map((a) => copy["scale" + a] * copy.unitScale)
+  });
+  copy.geometry = { ...source.geometry };
+  copy.section = source.section ? { ...source.section } : null;
+  copy.size_state = structuredClone(sizeState(source));
+  copy.size_state.unit_factor = (copy.size_state.unit_factor ?? 1) * source.unitScale;
+  const saved = savePlayback(source);
+  this.max_model_id = copy.id;
+  this._models.set(copy.id, copy);
+  this.models_ref[copy.id] = this.models.length;
+  this.models.push(copy);
+  this.models_count = this._models.size;
+  if (saved)
+    this._startAnimation(copy, saved.animation, {
+      ...saved.animation_state,
+      paused: true
+    });
+  this._invalidate();
+  return copy.id;
+}
+var cameraDirections = {
+  front: [
+    [0, -1, 0],
+    [0, 0, 1]
+  ],
+  back: [
+    [0, 1, 0],
+    [0, 0, 1]
+  ],
+  left: [
+    [-1, 0, 0],
+    [0, 0, 1]
+  ],
+  right: [
+    [1, 0, 0],
+    [0, 0, 1]
+  ],
+  top: [
+    [0, 0, 1],
+    [0, 1, 0]
+  ],
+  bottom: [
+    [0, 0, -1],
+    [0, -1, 0]
+  ],
+  isometric: [
+    [1, -1, 1],
+    [0, 0, 1]
+  ]
+};
+function cameraView(name) {
+  const view = cameraDirections[name];
+  if (!view) throw new Error("Unknown camera view");
+  this.camera.position = this.camera.target.map((v, i) => v + view[0][i]);
+  this.camera.up = [...view[1]];
+  this.set_auto_zoom();
+}
+function validateBookmarks(bookmarks) {
+  if (!Array.isArray(bookmarks) || bookmarks.length > 32)
+    throw new Error("Save up to 32 camera views");
+  const names = /* @__PURE__ */ new Set();
+  return bookmarks.map((b) => {
+    const name = typeof b?.name === "string" ? b.name.trim() : "";
+    if (!name || name.length > 80 || /[\x00-\x1f]/.test(name) || names.has(name))
+      throw new Error("Use a unique view name of 1\u201380 characters");
+    names.add(name);
+    const state = {};
+    for (const key of ["position", "target", "up"]) {
+      if (!b.camera?.[key] || axes.some(
+        (a) => !Number.isFinite(b.camera[key][a]) || Math.abs(b.camera[key][a]) > 1e15
+      ))
+        throw new Error("Invalid saved camera");
+      state[key] = Object.fromEntries(axes.map((a) => [a, b.camera[key][a]]));
+    }
+    const d = axes.map((a) => state.position[a] - state.target[a]), u = axes.map((a) => state.up[a]);
+    if (Math.hypot(
+      d[1] * u[2] - d[2] * u[1],
+      d[2] * u[0] - d[0] * u[2],
+      d[0] * u[1] - d[1] * u[0]
+    ) < 1e-12)
+      throw new Error("Degenerate saved camera");
+    return { name, camera: state };
+  });
+}
+function mergeBookmarks(existing, incoming) {
+  const result = validateBookmarks(existing), names = new Set(result.map((b) => b.name));
+  for (const b of validateBookmarks(incoming)) {
+    let name = b.name, n = 2;
+    while (names.has(name)) name = b.name.slice(0, 70) + ` (${n++})`;
+    names.add(name);
+    result.push({ ...b, name });
+  }
+  return validateBookmarks(result);
+}
+async function measureModel(id, options = {}) {
+  await this.when_ready;
+  const m = this._model(id), g = m.geometry;
+  if (!g || m._sceneImportPending)
+    throw new Error("Wait for the model to finish opening");
+  const scale = m.scaleVector, key = scale.join(","), cached = m._measurements;
+  if (options.signal?.aborted)
+    throw new DOMException("Measurement cancelled", "AbortError");
+  if (cached?.positions === g.positions && cached.key === key)
+    return { ...cached.result };
+  const working = printMemory(g.triangles), occupied = this._occupiedMemory();
+  assertMemory(this.limits, occupied + working, "measurements");
+  const release = this._reserveMemory(
+    m,
+    working + geometryMemory(g),
+    "measurements"
+  );
+  const controller = new AbortController(), cancel = () => controller.abort();
+  this._aborters.add(controller);
+  (m._measureJobs ??= /* @__PURE__ */ new Set()).add(controller);
+  options.signal?.addEventListener("abort", cancel, { once: true });
+  let job, callbackError;
+  const check = () => {
+    if (controller.signal.aborted || this.killsign)
+      throw new DOMException("Measurement cancelled", "AbortError");
+    if (this._models.get(id) !== m || m.geometry.positions !== g.positions || m.scaleVector.join(",") !== key)
+      throw new Error("Model size changed. Calculate again.");
+  };
+  try {
+    const positions = new Float32Array(g.positions.length);
+    for (let start = 0; start < positions.length; start += 262144) {
+      check();
+      positions.set(g.positions.subarray(start, start + 262144), start);
+      if (start + 262144 < positions.length)
+        await new Promise((r) => setTimeout(r, 0));
+    }
+    job = this._pool.run(
+      {
+        kind: "measure",
+        positions,
+        scale,
+        area: g.area,
+        max_time_ms: options.max_time_ms ?? 3e4,
+        limits: {
+          ...this.limits,
+          max_memory_bytes: this.limits.max_memory_bytes - occupied
+        }
+      },
+      (progress) => {
+        try {
+          options.on_progress?.(progress);
+        } catch (error) {
+          callbackError = error;
+          controller.abort();
+        }
+      },
+      [positions.buffer]
+    );
+    controller.signal.addEventListener("abort", () => job.cancel(), {
+      once: true
+    });
+    check();
+    let result;
+    try {
+      result = await job;
+    } catch (error) {
+      throw callbackError || error;
+    }
+    check();
+    m._measurements = { positions: g.positions, key, result };
+    return { ...result };
+  } finally {
+    job?.cancel?.();
+    release();
+    this._aborters.delete(controller);
+    m._measureJobs.delete(controller);
+    options.signal?.removeEventListener("abort", cancel);
+  }
+}
+
+// src/appearance.js
+var DISPLAYS = [
+  "flat",
+  "smooth",
+  "wireframe",
+  "edges",
+  "mesh",
+  "xray",
+  "studio",
+  "orientation"
+];
+function validateView(display, smooth) {
+  if (!DISPLAYS.includes(display)) throw new Error("Invalid display mode");
+  if (typeof smooth !== "boolean")
+    throw new Error("smooth_shading must be a boolean");
+  return { display, smooth_shading: display === "smooth" || smooth };
+}
+function viewFeatures(view) {
+  return {
+    smooth: (view.smooth_shading || view.display === "smooth") && view.display !== "wireframe",
+    edges: view.view_edges || view.display === "edges",
+    wire: view.display === "wireframe",
+    edgeAngle: view.display === "edges" ? 30 : 1
+  };
+}
+function validateSection(section) {
+  if (section == null) return null;
+  if (!["x", "y", "z"].includes(section.axis))
+    throw new Error("Section axis must be x, y or z");
+  if (!Number.isFinite(section.position) || section.position < 0 || section.position > 1)
+    throw new Error("Section position must be between 0 and 1");
+  if (section.flip !== void 0 && typeof section.flip !== "boolean")
+    throw new Error("Section flip must be a boolean");
+  return {
+    axis: section.axis,
+    position: section.position,
+    flip: section.flip ?? false
+  };
+}
+function sectionPlane(bounds, section) {
+  if (!section) return [0, 0, 0, 0];
+  const axis = ["x", "y", "z"].indexOf(section.axis), sign = section.flip ? -1 : 1;
+  const plane = [0, 0, 0, 0];
+  plane[axis] = sign;
+  plane[3] = -sign * (bounds.min[axis] + (bounds.max[axis] - bounds.min[axis]) * section.position);
+  return plane;
+}
+
+// src/geometry.js
 var DEFAULT_LIMITS = Object.freeze({
   max_file_bytes: 256 * 1024 * 1024,
   max_triangles: 5e6,
@@ -363,7 +899,7 @@ function exportSTL(g, scale = [1, 1, 1], center = [0, 0, 0]) {
   return buffer;
 }
 
-// src/v2/infinite-grid.js
+// src/infinite-grid.js
 var vertex = `#version 300 es
 precision highp float;
 out vec2 screen;
@@ -455,7 +991,7 @@ var InfiniteGrid = class {
   }
 };
 
-// src/v2/selection-frame.js
+// src/selection-frame.js
 function selectionFrame(bounds) {
   const padding = Math.max(
     Math.max(...bounds.max.map((v, i) => v - bounds.min[i])) * 0.015,
@@ -473,7 +1009,7 @@ function selectionFrame(bounds) {
   return new Float32Array(lines);
 }
 
-// src/v2/renderer.js
+// src/renderer.js
 var vertex2 = `#version 300 es
 precision highp float;
 layout(location=0) in vec3 position;
@@ -509,6 +1045,7 @@ var Renderer = class {
     this.canvas = canvas;
     this.domElement = canvas;
     this.resources = /* @__PURE__ */ new Map();
+    this.sharedResources = /* @__PURE__ */ new WeakMap();
     this.frames = 0;
     this.lost = false;
     this.gl = canvas.getContext("webgl2", {
@@ -525,6 +1062,7 @@ var Renderer = class {
       e.preventDefault();
       this.lost = true;
       this.resources.clear();
+      this.sharedResources = /* @__PURE__ */ new WeakMap();
       this.gridResource = null;
       this.infiniteGrid = null;
       this.selectionResource = null;
@@ -632,7 +1170,12 @@ var Renderer = class {
     if (this.diagnostic?.model === model) this.setDiagnostic(null);
     const resources = this.resources.get(model);
     if (resources)
-      for (const resource of Object.values(resources)) this.free(resource);
+      for (const resource of Object.values(resources)) {
+        if (--resource.users === 0) {
+          this.sharedResources.get(resource.source)?.delete(resource);
+          this.free(resource);
+        }
+      }
     this.resources.delete(model);
   }
   clear() {
@@ -646,8 +1189,10 @@ var Renderer = class {
   }
   get liveBuffers() {
     let n = (this.gridResource?.buffers.length || 0) + (this.selectionResource?.buffers.length || 0) + (this.diagnosticResource?.buffers.length || 0);
+    const unique = /* @__PURE__ */ new Set();
     for (const r of this.resources.values())
-      for (const b of Object.values(r)) n += b.buffers.length;
+      for (const b of Object.values(r)) unique.add(b);
+    for (const b of unique) n += b.buffers.length;
     return n;
   }
   setDiagnostic(value) {
@@ -713,12 +1258,23 @@ var Renderer = class {
       this.resources.set(model, r);
     }
     if (!r[mode]) {
-      const g = model.geometry;
-      r[mode] = mode === "edges" || mode === "wire" ? this.upload(g[mode]) : this.upload(
-        g.positions,
-        mode === "smooth" ? g.smoothNormals : g.normals,
-        g.colors
+      const g = model.geometry, lines = mode === "edges" || mode === "wire", source = lines ? g[mode] : g.positions, normals = lines ? void 0 : mode === "smooth" ? g.smoothNormals : g.normals, colors = lines ? void 0 : g.colors;
+      let entries = this.sharedResources.get(source);
+      if (!entries) this.sharedResources.set(source, entries = /* @__PURE__ */ new Set());
+      let resource = [...entries].find(
+        (r2) => r2.normals === normals && r2.colors === colors
       );
+      if (!resource) {
+        resource = Object.assign(this.upload(source, normals, colors), {
+          source,
+          normals,
+          colors,
+          users: 0
+        });
+        entries.add(resource);
+      }
+      resource.users++;
+      r[mode] = resource;
     }
     return r[mode];
   }
@@ -894,7 +1450,7 @@ var Renderer = class {
   }
 };
 
-// src/v2/controls.js
+// src/controls.js
 var Controls = class {
   constructor(canvas, camera, invalidate, pick, type = 0) {
     this.enabled = true;
@@ -1005,7 +1561,7 @@ var Controls = class {
   }
 };
 
-// src/v2/worker-pool.js
+// src/worker-pool.js
 var WorkerPool = class {
   constructor(url, { count = 2, timeout = 12e4, factory } = {}) {
     this.url = url;
@@ -1090,7 +1646,7 @@ var WorkerPool = class {
   }
 };
 
-// src/v2/scene-import.js
+// src/scene-import.js
 var sceneFormat = (name) => String(name || "").match(/\.(vsb|vsj)(?:[?#]|$)/i)?.[1].toLowerCase() || "";
 function localSceneFile(reference, files) {
   let path;
@@ -1124,7 +1680,7 @@ function sceneURL(reference, base) {
   return url.href;
 }
 
-// src/v2/scene-import-controller.js
+// src/scene-import-controller.js
 function importScene(source, options = {}) {
   const controller = new AbortController(), signal = controller.signal;
   const generation = this._generation, ids = [], added = /* @__PURE__ */ new Map(), usedFiles = /* @__PURE__ */ new Set();
@@ -1149,8 +1705,8 @@ function importScene(source, options = {}) {
     await this.when_ready;
     check();
     oldCamera = this.get_camera_state();
-    const format = options.format || sceneFormat(typeof source === "string" ? source : source.name);
-    if (!["vsb", "vsj"].includes(format))
+    const format2 = options.format || sceneFormat(typeof source === "string" ? source : source.name);
+    if (!["vsb", "vsj"].includes(format2))
       throw new Error("Choose VSB or VSJ for a scene");
     let remote, relay;
     if (typeof source === "string") {
@@ -1183,8 +1739,8 @@ function importScene(source, options = {}) {
         source,
         remote,
         relay,
-        format,
-        name: `scene.${format}`,
+        format: format2,
+        name: `scene.${format2}`,
         limits
       },
       (p) => {
@@ -1205,6 +1761,10 @@ function importScene(source, options = {}) {
     job = null;
     check();
     const { scene, files, base } = documentData;
+    const bookmarks = mergeBookmarks(
+      this.get_camera_bookmarks(),
+      scene.camera_bookmarks || []
+    );
     this._sceneBytes -= held;
     held = Object.values(files || {}).reduce((n, b) => n + b.byteLength, 0) + JSON.stringify(scene).length * 2;
     this._sceneBytes += held;
@@ -1239,7 +1799,7 @@ function importScene(source, options = {}) {
       progress({ phase: "opening-model", loaded: index, total: models.length });
       check();
       const input = models[index], id = this.max_model_id + 1;
-      this.add_model({ ...input, id });
+      this.add_model({ ...input, id, animation: null, animation_state: null });
       const model = this._models.get(id);
       if (!model) throw new Error(this.error || "Invalid scene model");
       ids.push(id);
@@ -1264,7 +1824,9 @@ function importScene(source, options = {}) {
         }),
         delta
       );
-      ["x", "y", "z"].forEach((axis, i) => model[axis] += shift[i]);
+      if (input.animation)
+        model.center = [...input.animation_state?.center ?? desired];
+      else ["x", "y", "z"].forEach((axis, i) => model[axis] += shift[i]);
       if ([...this._models.values()].reduce(
         (n, m) => n + (m.geometry?.triangles || 0),
         0
@@ -1277,7 +1839,12 @@ function importScene(source, options = {}) {
       total: models.length
     });
     check();
-    for (const model of added.values()) model._sceneImportPending = false;
+    for (let index = 0; index < ids.length; index++) {
+      const model = added.get(ids[index]), input = models[index];
+      if (input.animation)
+        this._startAnimation(model, input.animation, input.animation_state);
+      model._sceneImportPending = false;
+    }
     if (scene.bg_color !== void 0) this.set_bg_color(scene.bg_color);
     if (scene.infinite_grid)
       this.set_infinite_grid(
@@ -1289,6 +1856,8 @@ function importScene(source, options = {}) {
     if (scene.auto_rotate !== void 0)
       this.set_auto_rotate(scene.auto_rotate);
     this._restoreCamera = scene.camera_state || (hadModels ? oldCamera : null);
+    this.camera_bookmarks = bookmarks;
+    if (scene.display_units) this.display_units = scene.display_units;
     committed = true;
     return { model_ids: ids, scene, used_files: [...usedFiles] };
   })().catch((error) => {
@@ -1309,62 +1878,7 @@ function importScene(source, options = {}) {
   return promise;
 }
 
-// src/v2/print-options.js
-function printOptions(input = {}) {
-  const level = input.level ?? "basic";
-  if (!["basic", "detailed"].includes(level))
-    throw new Error("Choose basic or detailed print checks");
-  const number = (v, name, max = 1e9) => {
-    if (!Number.isFinite(v) || v <= 0 || v > max)
-      throw new Error(`Invalid ${name}`);
-    return v;
-  };
-  let profile = null;
-  if (input.profile != null) {
-    if (input.profile.technology !== "fdm")
-      throw new Error("Only FDM profiles are supported");
-    profile = { technology: "fdm" };
-    for (const key of ["min_wall_mm", "line_width_mm"])
-      if (input.profile[key] != null)
-        profile[key] = number(input.profile[key], key);
-    if (input.profile.overhang_degrees != null)
-      profile.overhang_degrees = number(
-        input.profile.overhang_degrees,
-        "overhang angle",
-        89.9
-      );
-    if (input.profile.build_volume_mm != null) {
-      if (!Array.isArray(input.profile.build_volume_mm) || input.profile.build_volume_mm.length !== 3)
-        throw new Error("Build volume requires X, Y and Z");
-      profile.build_volume_mm = input.profile.build_volume_mm.map(
-        (v) => number(v, "build volume")
-      );
-    }
-  }
-  const time = number(input.max_time_ms ?? 3e4, "check time limit", 12e4);
-  return {
-    level,
-    profile,
-    apply_transforms: input.apply_transforms !== false,
-    units_confirmed: input.units_confirmed === true,
-    max_time_ms: time
-  };
-}
-var printMemory = (triangles) => 64 * 1024 ** 2 + triangles * 2400;
-var printSignature = (model) => JSON.stringify([
-  model.x,
-  model.y,
-  model.z,
-  model.rotationx,
-  model.rotationy,
-  model.rotationz,
-  model.scaleVector,
-  model.center,
-  model.units,
-  model.unitScale
-]);
-
-// src/v2/print-controller.js
+// src/print-controller.js
 var reports = /* @__PURE__ */ new WeakMap();
 function reportCurrent(viewer, report) {
   const saved = reports.get(report);
@@ -1461,7 +1975,9 @@ async function checkPrintability(options = {}) {
         rotationy: 0,
         rotationz: 0,
         center: [0, 0, 0],
-        scaleVector: [model.unitScale, model.unitScale, model.unitScale]
+        scaleVector: [1, 1, 1].map(
+          () => model.unitScale * (model.size_state?.unit_factor ?? 1)
+        )
       };
       progress({
         phase: "Starting",
@@ -1577,7 +2093,7 @@ function showPrintability(report, { issue, model_id = report.model_ids[0] } = {}
   return lines.length / 6;
 }
 
-// src/v2/export-options.js
+// src/export-options.js
 function exportFilename(filename, extension) {
   const name = String(filename || "scene").split(/[\\/]/).pop().split(/[?#]/)[0].replace(/[<>:"|*\x00-\x1f\x7f]/g, "_").replace(/\.(?:stl|obj|3mf|step|stp|iges|igs|zip|vsb|vsj)$/i, "").replace(/[. ]+$/g, "").slice(0, 160) || "scene";
   return `${name}.${extension}`;
@@ -1585,8 +2101,8 @@ function exportFilename(filename, extension) {
 function exportOptions(options = {}) {
   const aliases = { stp: "step", igs: "iges" };
   const requested = String(options.format || "").toLowerCase();
-  const format = aliases[requested] || requested;
-  if (!["stl", "obj", "3mf", "step", "iges"].includes(format))
+  const format2 = aliases[requested] || requested;
+  if (!["stl", "obj", "3mf", "step", "iges"].includes(format2))
     throw new Error("Export format must be stl, obj, 3mf, step or iges");
   const units = options.units ?? "mm";
   if (!["mm", "inch"].includes(units))
@@ -1596,10 +2112,10 @@ function exportOptions(options = {}) {
       throw new Error(`${key} must be a boolean`);
   if (options.on_progress !== void 0 && typeof options.on_progress !== "function")
     throw new Error("on_progress must be a function");
-  const colors = options.colors !== false && ["obj", "3mf"].includes(format);
-  const extension = format === "obj" && colors ? "zip" : format;
+  const colors = options.colors !== false && ["obj", "3mf"].includes(format2);
+  const extension = format2 === "obj" && colors ? "zip" : format2;
   return {
-    format,
+    format: format2,
     units,
     colors,
     apply_transforms: options.apply_transforms !== false,
@@ -1618,7 +2134,7 @@ function exportMemory(models, options) {
   return MEMORY_OVERHEAD + triangles * perTriangle[options.format] + models.length * 4096;
 }
 
-// src/v2/io.js
+// src/io.js
 async function readSource(source, limit, progress = () => {
 }, signal) {
   let stream, total = 0;
@@ -1680,7 +2196,7 @@ async function readSource(source, limit, progress = () => {
   return data.buffer;
 }
 
-// src/v2/three-bridge.js
+// src/three-bridge.js
 function fromThreeMesh(mesh, limits) {
   if (!mesh?.isMesh && !mesh?.geometry)
     throw new Error("Expected a Three.js mesh");
@@ -1753,7 +2269,7 @@ function toThreeMesh(model, THREE) {
   return mesh;
 }
 
-// src/v2/viewer.js
+// src/viewer.js
 var transformKeys = [
   "x",
   "y",
@@ -1791,7 +2307,10 @@ var modelKeys = [
   "smooth_shading",
   "section",
   "units",
-  "animation"
+  "animation",
+  "animation_state",
+  "size_state",
+  "display_name"
 ];
 var finite = (v, name) => {
   if (typeof v !== "number" || !Number.isFinite(v))
@@ -1823,7 +2342,7 @@ function modelOptions(input) {
   return out;
 }
 var StlViewer = class _StlViewer {
-  static version = "2.0.0-rc.4";
+  static version = "2.0.0-rc.6";
   static workerURL = null;
   constructor(parent, options = {}) {
     if (!parent?.appendChild)
@@ -1852,6 +2371,8 @@ var StlViewer = class _StlViewer {
     this._sessionActive = false;
     this._frame = 0;
     this._lastTime = 0;
+    this.camera_bookmarks = [];
+    this.display_units = "mm";
     this.grid = null;
     this._gridAuto = false;
     this.camera = {
@@ -1873,7 +2394,9 @@ var StlViewer = class _StlViewer {
       "model_loaded_callback",
       "load_error_callback",
       "loading_progress_callback",
-      "on_model_drop"
+      "on_model_drop",
+      "animation_state_callback",
+      "animation_complete_callback"
     ])
       this[name] = options[name] ?? null;
     this.onmousedown_callback = options.on_model_mousedown ?? options.on_model_mouseclick ?? null;
@@ -1912,11 +2435,15 @@ var StlViewer = class _StlViewer {
       this.parent_element.appendChild(this.canvas);
       this.renderer = new Renderer(
         this.canvas,
-        () => this._message(
-          "Graphics interrupted. Waiting for the browser to restore rendering\u2026"
-        ),
+        () => {
+          this._suspendAnimations(true);
+          this._message(
+            "Graphics interrupted. Waiting for the browser to restore rendering\u2026"
+          );
+        },
         () => {
           this._removeMessage();
+          this._suspendAnimations(this.canvas.ownerDocument.hidden);
           this._invalidate();
         },
         (e) => this._error(e)
@@ -1981,6 +2508,14 @@ var StlViewer = class _StlViewer {
         }
       };
       this.canvas.addEventListener("keydown", this._key);
+      this._visibility = () => this._suspendAnimations(
+        this.canvas.ownerDocument.hidden || this.renderer.lost
+      );
+      this.canvas.ownerDocument.addEventListener(
+        "visibilitychange",
+        this._visibility
+      );
+      this._animationSuspended = this.canvas.ownerDocument.hidden;
       this.ready = true;
       this._readyResolve(this);
       this._callback("ready_callback");
@@ -1995,6 +2530,11 @@ var StlViewer = class _StlViewer {
       this.controls?.dispose();
       this.renderer?.dispose();
       this._resizeObserver?.disconnect();
+      if (this._visibility)
+        this.canvas.ownerDocument.removeEventListener(
+          "visibilitychange",
+          this._visibility
+        );
     }
   }
   _callback(name, ...args) {
@@ -2043,7 +2583,7 @@ var StlViewer = class _StlViewer {
     const diagnostic = this.renderer?.diagnostic;
     if (diagnostic && printSignature(diagnostic.model) !== diagnostic.signature)
       this.renderer.setDiagnostic(null);
-    if (this.killsign || !this.renderer || this.renderer.lost || this._frame)
+    if (this.killsign || !this.renderer || this.renderer.lost || this._frame || this._animationSuspended)
       return;
     this._frame = requestAnimationFrame((t) => {
       this._frame = 0;
@@ -2055,12 +2595,15 @@ var StlViewer = class _StlViewer {
     this._lastTime = time;
     let animated = false;
     for (const m of this._models.values())
-      if (m.geometry && m._animation) {
+      if (m.geometry && !m._sceneImportPending && m._animation && !m._animation.paused) {
         this._animate(m, time);
-        animated ||= !!m._animation;
+        animated ||= !!m._animation && !m._animation.paused;
       }
     if (this.auto_rotate && this.controls.enabled)
       this.controls.orbit(elapsed * 0.3, 0);
+    const diagnostic = this.renderer.diagnostic;
+    if (diagnostic && printSignature(diagnostic.model) !== diagnostic.signature)
+      this.renderer.setDiagnostic(null);
     this._clip();
     try {
       this.renderer.draw(
@@ -2166,6 +2709,13 @@ var StlViewer = class _StlViewer {
         finite(m[key], key);
         if (key.startsWith("scale")) positive(m[key], key);
       }
+      if (supplied.size_state)
+        m.size_state = validateSizeState(supplied.size_state);
+      if (supplied.display_name != null) {
+        if (typeof supplied.display_name !== "string" || supplied.display_name.length > 1024)
+          throw new Error("Invalid model name");
+        m.display_name = supplied.display_name;
+      }
       m.opacity = supplied.opacity ?? supplied.mesh?.material?.opacity ?? 1;
       finite(m.opacity, "opacity");
       if (m.opacity < 0 || m.opacity > 1)
@@ -2184,6 +2734,11 @@ var StlViewer = class _StlViewer {
       m.color = supplied.color ?? (supplied.mesh?.material?.color?.getHexString ? "#" + supplied.mesh.material.color.getHexString() : null);
       if (m.color && m.color !== "transparent") colorRGB(m.color);
       m.view_edges = !!supplied.view_edges;
+      m.animation = supplied.animation == null ? null : normalizeAnimation(supplied.animation);
+      m.animation_state = supplied.animation_state == null ? null : normalizePlaybackState(supplied.animation_state);
+      if (m.animation_state && !m.animation)
+        throw new Error("Playback state needs an animation");
+      if (m.animation) createPlayback(m.animation, m, m.animation_state);
       Object.defineProperty(m, "scaleVector", {
         get: () => [
           m.scalex * m.unitScale,
@@ -2312,7 +2867,7 @@ var StlViewer = class _StlViewer {
             format: supplied.remote_format,
             relay,
             source: typeof source === "string" ? new URL(source, document.baseURI).href : source,
-            name: m.filename,
+            name: m.display_name || m.filename,
             limits,
             features: features.smooth || features.edges || features.wire ? features : null
           },
@@ -2336,7 +2891,10 @@ var StlViewer = class _StlViewer {
         );
       if ((supplied.mesh || supplied.data) && (features.smooth || features.edges || features.wire))
         await this._derive(m, features);
-      if (supplied.animation) this.animate_model(m.id, supplied.animation);
+      if (m.animation_state) m.center = [...m.animation_state.center];
+      if (m.animation && !m._animation)
+        this._startAnimation(m, m.animation, m.animation_state);
+      delete m.animation_state;
       delete m.mesh;
       delete m.data;
       this._invalidate();
@@ -2358,6 +2916,8 @@ var StlViewer = class _StlViewer {
     this._invalidate();
   }
   _deleteModel(m) {
+    this._stopAnimation(m, "removed");
+    for (const controller of m._measureJobs || []) controller.abort();
     for (const [controller, models] of this._printJobs || [])
       if (models.has(m)) controller.abort();
     this._printCache = null;
@@ -2385,9 +2945,12 @@ var StlViewer = class _StlViewer {
     if (this.killsign) return;
     this._generation++;
     this._printCache = null;
+    this.camera_bookmarks = [];
+    this.display_units = "mm";
     this._pool?.clear();
     for (const c of this._aborters) c.abort();
     this._aborters.clear();
+    for (const m of this._models.values()) this._stopAnimation(m, "clean");
     this._models.clear();
     this._pending.clear();
     this._jobs.clear();
@@ -2419,6 +2982,11 @@ var StlViewer = class _StlViewer {
       window.removeEventListener("resize", this._windowResize);
     this.renderer?.dispose();
     if (this.canvas) {
+      if (this._visibility)
+        this.canvas.ownerDocument.removeEventListener(
+          "visibilitychange",
+          this._visibility
+        );
       this.canvas.removeEventListener("drop", this._drop);
       this.canvas.removeEventListener("dragover", this._drag);
       this.canvas.removeEventListener("keydown", this._key);
@@ -2557,6 +3125,10 @@ var StlViewer = class _StlViewer {
   set_position(id, x, y, z) {
     return this._guard(() => {
       const m = this._model(id);
+      [x, y, z].forEach((v) => {
+        if (v !== void 0) finite(v, "position");
+      });
+      this._stopAnimation(m, "manual");
       [x, y, z].forEach((v, i) => {
         if (v !== void 0) m[["x", "y", "z"][i]] = finite(v, "position");
       });
@@ -2570,8 +3142,12 @@ var StlViewer = class _StlViewer {
       if (keepPrevious) {
         if (x / m.scalex !== y / m.scaley || x / m.scalex !== z / m.scalez)
           throw new Error("keep_prev_scale requires a uniform geometry factor");
+        this._stopAnimation(m, "manual");
         m.unitScale *= x / m.scalex;
-      } else [m.scalex, m.scaley, m.scalez] = [x, y, z];
+      } else {
+        this._stopAnimation(m, "manual");
+        [m.scalex, m.scaley, m.scalez] = [x, y, z];
+      }
       m._stats = null;
       this._invalidate();
     });
@@ -2585,6 +3161,10 @@ var StlViewer = class _StlViewer {
   set_rotation(id, x, y, z, increment = false) {
     return this._guard(() => {
       const m = this._model(id);
+      [x, y, z].forEach((v) => {
+        if (v !== void 0) finite(v, "rotation");
+      });
+      this._stopAnimation(m, "manual");
       [x, y, z].forEach((v, i) => {
         const k = ["rotationx", "rotationy", "rotationz"][i];
         if (v !== void 0)
@@ -2638,6 +3218,7 @@ var StlViewer = class _StlViewer {
       if (!["mm", "inch"].includes(units))
         throw new Error("Units must be mm or inch");
       const m = this._model(id);
+      this._stopAnimation(m, "manual");
       if (scale && m.units !== units)
         m.unitScale *= units === "inch" ? 25.4 : 1 / 25.4;
       m.units = units;
@@ -2805,12 +3386,42 @@ var StlViewer = class _StlViewer {
         type
       );
   }
-  get_model_info(id) {
+  get_model_size(id) {
+    return modelSize(this._model(id));
+  }
+  resize_model(id, factors) {
+    return resizeModel.call(this, id, factors);
+  }
+  set_file_units(id, units) {
+    return setFileUnits.call(this, id, units);
+  }
+  reset_model_size(id) {
+    return resetModelSize.call(this, id);
+  }
+  duplicate_model(id) {
+    return duplicateModel.call(this, id);
+  }
+  set_camera_view(name) {
+    return cameraView.call(this, name);
+  }
+  set_display_units(units) {
+    this.display_units = validateUnits(units);
+  }
+  get_camera_bookmarks() {
+    return structuredClone(this.camera_bookmarks || []);
+  }
+  set_camera_bookmarks(bookmarks) {
+    this.camera_bookmarks = validateBookmarks(bookmarks);
+  }
+  measure_model(id, options) {
+    return measureModel.call(this, id, options);
+  }
+  get_model_info(id, options = {}) {
     return this._guard(() => {
       const m = this._model(id), g = m.geometry;
       if (!g) return null;
       const s = m.scaleVector, key = s.join(",");
-      if (!m._stats || m._stats.key !== key)
+      if (options.measurements !== false && (!m._stats || m._stats.key !== key))
         m._stats = { key, ...scaledStats(g, s) };
       const factor = m.units === "inch" ? 1 / 25.4 : 1;
       return {
@@ -2826,8 +3437,8 @@ var StlViewer = class _StlViewer {
         section: m.section ? { ...m.section } : null,
         color: m.color ?? (g.colors ? "#ffffff" : "#909090"),
         scale: { x: m.scalex, y: m.scaley, z: m.scalez },
-        volume: m._stats.volume * factor ** 3,
-        area: m._stats.area * factor ** 2,
+        volume: options.measurements === false ? null : m._stats.volume * factor ** 3,
+        area: options.measurements === false ? null : m._stats.area * factor ** 2,
         triangles: g.triangles,
         bounds: { min: [...g.bounds.min], max: [...g.bounds.max] },
         has_colors: !!g.colors,
@@ -2915,7 +3526,9 @@ var StlViewer = class _StlViewer {
           rotationx: 0,
           rotationy: 0,
           rotationz: 0,
-          scaleVector: [m.unitScale, m.unitScale, m.unitScale]
+          scaleVector: [1, 1, 1].map(
+            () => m.unitScale * (m.size_state?.unit_factor ?? 1)
+          )
         };
         const matrix = modelMatrix(source), factor = settings.units === "inch" ? 1 / 25.4 : 1;
         for (let c = 0; c < 4; c++)
@@ -2983,8 +3596,8 @@ var StlViewer = class _StlViewer {
       );
   }
   async export_scene(options = {}) {
-    const format = String(options.format || "").toLowerCase();
-    if (!["vsb", "vsj"].includes(format))
+    const format2 = String(options.format || "").toLowerCase();
+    if (!["vsb", "vsj"].includes(format2))
       throw new Error("Scene format must be vsb or vsj");
     if (options.force_basename !== void 0 && typeof options.force_basename !== "boolean")
       throw new Error("force_basename must be a boolean");
@@ -3007,7 +3620,7 @@ var StlViewer = class _StlViewer {
     if (!models.length) throw new Error("No models to export");
     if (models.some((m) => !m.geometry))
       throw new Error("A model has not finished loading");
-    if (models.length + (format === "vsb" ? 1 : 0) > this.limits.max_archive_entries)
+    if (models.length + (format2 === "vsb" ? 1 : 0) > this.limits.max_archive_entries)
       throw new Error("Scene model count limit exceeded");
     const triangles = models.reduce((sum, m) => sum + m.geometry.triangles, 0);
     if (triangles > this.limits.max_triangles)
@@ -3015,18 +3628,26 @@ var StlViewer = class _StlViewer {
     const scene = this.get_vsj(
       true,
       !!options.force_basename,
-      format === "vsb"
+      format2 === "vsb"
     );
     const json = JSON.stringify(scene), manifestBytes = new Blob([json]).size;
     if (manifestBytes > this.limits.max_file_bytes)
       throw new Error("Scene manifest size limit exceeded");
-    if (format === "vsb" && manifestBytes + models.length * 84 + triangles * 50 > this.limits.max_uncompressed_bytes)
+    if (format2 === "vsb" && manifestBytes + models.length * 84 + triangles * 50 > this.limits.max_uncompressed_bytes)
       throw new Error("Scene archive limit exceeded");
-    const working = MEMORY_OVERHEAD + json.length * 8 + (format === "vsb" ? triangles * 512 : 0);
+    const working = MEMORY_OVERHEAD + json.length * 8 + (format2 === "vsb" ? triangles * 512 : 0);
     assertMemory(this.limits, this._occupiedMemory() + working, "scene export");
     this._exportBytes += working;
     let job, cancel, callbackError;
     try {
+      const snapshot = format2 === "vsb" ? models.map((m, index) => ({
+        id: m.id,
+        triangles: m.geometry.triangles,
+        positions: m.geometry.positions.slice(),
+        colors: m.geometry.colors?.slice() || null,
+        scale: scene.models[index].animation_state ? [1, 1, 1] : m.scaleVector,
+        center: scene.models[index].animation_state ? [0, 0, 0] : [...m.center]
+      })) : null;
       options.on_progress?.({
         loaded: 0,
         total: models.length,
@@ -3034,7 +3655,7 @@ var StlViewer = class _StlViewer {
       });
       checkAbort();
       let blob;
-      if (format === "vsj") {
+      if (format2 === "vsj") {
         blob = new Blob([json], { type: "application/json" });
         options.on_progress?.({
           loaded: models.length,
@@ -3042,14 +3663,6 @@ var StlViewer = class _StlViewer {
           phase: "complete"
         });
       } else {
-        const snapshot = models.map((m) => ({
-          id: m.id,
-          triangles: m.geometry.triangles,
-          positions: m.geometry.positions.slice(),
-          colors: m.geometry.colors?.slice() || null,
-          scale: m.scaleVector,
-          center: [...m.center]
-        }));
         job = this._pool.run(
           {
             kind: "export-scene",
@@ -3082,8 +3695,8 @@ var StlViewer = class _StlViewer {
       checkAbort();
       return {
         blob,
-        format,
-        filename: exportFilename(options.filename, format),
+        format: format2,
+        filename: exportFilename(options.filename, format2),
         model_ids: models.map((m) => m.id),
         triangles,
         representation: "scene"
@@ -3105,6 +3718,8 @@ var StlViewer = class _StlViewer {
       canvas_height: this.canvas_height,
       bg_color: this.bg_color,
       camera_state: this.get_camera_state(),
+      camera_bookmarks: this.get_camera_bookmarks(),
+      display_units: this.display_units || "mm",
       auto_rotate: this.auto_rotate,
       mouse_zoom: this.mouse_zoom,
       auto_resize: this.auto_resize,
@@ -3125,6 +3740,11 @@ var StlViewer = class _StlViewer {
           id: for_vsb ? -1 : m.id,
           filename: for_vsb ? `${m.id}.stl` : force_basename ? basename(m.filename) : m.filename,
           units: m.units,
+          size_state: {
+            ...structuredClone(sizeState(m)),
+            unit_factor: for_vsb && !m._animation ? 1 : m.unitScale * (sizeState(m).unit_factor ?? 1)
+          },
+          ...m.display_name ? { display_name: m.display_name } : {},
           display: m.display,
           opacity: m.opacity,
           view_edges: m.view_edges,
@@ -3135,13 +3755,21 @@ var StlViewer = class _StlViewer {
           model.orig_filename = basename(m.orig_filename || m.filename);
         for (const key of transformKeys)
           if (!key.startsWith("scale")) model[key] = m[key];
-        if (!for_vsb) {
+        if (!for_vsb || m._animation) {
           model.scalex = m.scalex * m.unitScale;
           model.scaley = m.scaley * m.unitScale;
           model.scalez = m.scalez * m.unitScale;
         }
         if (m.color) model.color = m.color;
-        if (m.animation) model.animation = structuredClone(m.animation);
+        const playback = savePlayback(m);
+        if (playback) Object.assign(model, playback);
+        else if (!for_vsb) {
+          const center = this.center_models ? m.geometry.bounds.min.map(
+            (v, i) => (v + m.geometry.bounds.max[i]) / 2
+          ) : [0, 0, 0];
+          const position = transform(modelMatrix(m), center);
+          ["x", "y", "z"].forEach((axis, i) => model[axis] = position[i]);
+        }
         data.models.push(model);
       }
     return as_js_obj ? data : JSON.stringify(data);
@@ -3155,7 +3783,10 @@ var StlViewer = class _StlViewer {
   get_vsb() {
     return {
       vsj: this.get_vsj(true, true, true),
-      files: [...this._models.values()].filter((m) => m.geometry).map((m) => ({ id: m.id, bin: this.get_stl_bin(m.id) }))
+      files: [...this._models.values()].filter((m) => m.geometry).map((m) => ({
+        id: m.id,
+        bin: m._animation ? exportSTL(m.geometry, [1, 1, 1], [0, 0, 0]) : this.get_stl_bin(m.id)
+      }))
     };
   }
   async get_vsb_blob() {
@@ -3236,20 +3867,66 @@ var StlViewer = class _StlViewer {
         );
       else if (scene.grid) this.set_grid(true);
       if (scene.camera_state) this._restoreCamera = scene.camera_state;
-      for (const input of scene.models) {
-        if (!input || typeof input !== "object")
-          throw new Error("Invalid scene model");
-        const model = modelOptions(input);
-        delete model.mesh;
-        delete model.data;
-        delete model.local_file;
-        if (files) {
-          if (typeof model.filename !== "string" || !Object.hasOwn(files, model.filename))
-            throw new Error("VSB model file is missing");
-          model.local_file = new File([files[model.filename]], model.filename);
-        } else if (model.filename)
-          model.filename = new URL(model.filename, base).href;
-        this.add_model(model);
+      const bookmarks = mergeBookmarks(
+        this.get_camera_bookmarks(),
+        scene.camera_bookmarks || []
+      );
+      const displayUnits = validateUnits(
+        scene.display_units || this.display_units || "mm"
+      );
+      const incoming = [];
+      try {
+        for (const input of scene.models) {
+          if (!input || typeof input !== "object")
+            throw new Error("Invalid scene model");
+          const model = modelOptions(input);
+          delete model.mesh;
+          delete model.data;
+          delete model.local_file;
+          if (files) {
+            if (typeof model.filename !== "string" || !Object.hasOwn(files, model.filename))
+              throw new Error("VSB model file is missing");
+            model.local_file = new File(
+              [files[model.filename]],
+              model.filename
+            );
+          } else if (model.filename)
+            model.filename = new URL(model.filename, base).href;
+          const id = model.id === void 0 || model.id === -1 ? this.max_model_id + 1 : model.id;
+          if (this._models.has(id))
+            throw new Error(`Invalid or duplicate model id: ${id}`);
+          this.add_model({
+            ...model,
+            id,
+            animation: null,
+            animation_state: null
+          });
+          const m = this._models.get(id);
+          if (!m) throw new Error(this.error || "Invalid scene model");
+          m._sceneImportPending = true;
+          incoming.push({ m, model, pending: this._pending.get(id) });
+        }
+        await Promise.all(incoming.map((item) => item.pending));
+        if (generation !== this._generation || this.killsign) return;
+        for (const { m, model } of incoming) {
+          if (this._models.get(m.id) !== m || !m.geometry)
+            throw new Error("A scene model could not be opened");
+          if (model.animation)
+            createPlayback(model.animation, m, model.animation_state);
+          else if (model.animation_state)
+            throw new Error("Playback state needs an animation");
+        }
+        for (const { m, model } of incoming) {
+          if (model.animation)
+            this._startAnimation(m, model.animation, model.animation_state);
+          m._sceneImportPending = false;
+        }
+        this.camera_bookmarks = bookmarks;
+        this.display_units = displayUnits;
+      } catch (error) {
+        for (const { m } of incoming)
+          if (this._models.get(m.id) === m) this.remove_model(m.id);
+        throw error;
       }
     })().catch((e) => {
       if (generation === this._generation && e.name !== "AbortError")
@@ -3271,56 +3948,101 @@ var StlViewer = class _StlViewer {
     return this._guard(() => {
       const m = this._model(id);
       if (!animation) {
-        m.animation = null;
-        m._animation = null;
+        this._stopAnimation(m, "stopped");
+        this._invalidate();
         return;
       }
-      const copy = structuredClone(animation), tracks = [];
-      for (const mode of ["delta", "exact"])
-        if (copy[mode]) {
-          const a = copy[mode];
-          positive(a.msec ?? 300, "animation duration");
-          const values = {};
-          for (const key of transformKeys) {
-            const value = a[key] ?? (key.startsWith("scale") ? a.scale : void 0);
-            if (value !== void 0) {
-              finite(value, key);
-              if (mode === "exact" && key.startsWith("scale"))
-                positive(value, key);
-              values[key] = value;
-            }
-          }
-          tracks.push({
-            mode,
-            values,
-            duration: a.msec ?? 300,
-            loop: mode === "delta" && !!a.loop,
-            from: Object.fromEntries(transformKeys.map((k) => [k, m[k]]))
-          });
-        }
-      if (!tracks.length) throw new Error("Animation needs delta or exact");
-      m.animation = copy;
-      m._animation = { start: null, tracks };
+      this._startAnimation(m, animation);
       this._invalidate();
     });
   }
+  _startAnimation(m, definition, saved) {
+    const playback = createPlayback(definition, m, saved);
+    if (m._animation) this._stopAnimation(m, "replaced");
+    if (saved) m.center = [...saved.center];
+    m.animation = playback.animation;
+    m._animation = playback;
+    delete m.animation_state;
+    m._animationResult = null;
+    const running = evaluatePlayback(playback, m);
+    if (running) this._animationEvent(m, saved ? "restored" : "started");
+    else this._completeAnimation(m);
+  }
+  _animationEvent(m, reason) {
+    const state = this._animationState(m);
+    queueMicrotask(() => {
+      this._callback("animation_state_callback", m.id, state, reason);
+      if (reason === "completed")
+        this._callback("animation_complete_callback", m.id, state);
+    });
+  }
+  _animationState(m) {
+    return m._animation ? playbackState(m._animation, !!this._animationSuspended) : {
+      ...m._animationResult ?? { status: "idle", elapsed_ms: 0 },
+      suspended: false,
+      tracks: []
+    };
+  }
+  _stopAnimation(m, reason) {
+    if (!m._animation && !m.animation) return;
+    m._animationResult = {
+      status: "stopped",
+      elapsed_ms: m._animation?.elapsed_ms ?? 0
+    };
+    m._animation = null;
+    m.animation = null;
+    delete m.animation_state;
+    this._animationEvent(m, reason);
+  }
+  _completeAnimation(m) {
+    m._animationResult = {
+      status: "completed",
+      elapsed_ms: m._animation.elapsed_ms
+    };
+    m._animation = null;
+    m.animation = null;
+    this._animationEvent(m, "completed");
+  }
+  pause_model_animation(id) {
+    return this._guard(() => {
+      const m = this._model(id);
+      if (!m._animation || m._animation.paused) return;
+      m._animation.paused = true;
+      m._animation.last_time = null;
+      this._animationEvent(m, "paused");
+      this._invalidate();
+    });
+  }
+  resume_model_animation(id) {
+    return this._guard(() => {
+      const m = this._model(id);
+      if (!m._animation || !m._animation.paused) return;
+      m._animation.paused = false;
+      m._animation.last_time = null;
+      this._animationEvent(m, "resumed");
+      this._invalidate();
+    });
+  }
+  get_model_animation_state(id) {
+    return this._guard(() => this._animationState(this._model(id)));
+  }
+  _suspendAnimations(suspended) {
+    this._animationSuspended = !!suspended;
+    this._lastTime = 0;
+    for (const m of this._models.values())
+      if (m._animation) m._animation.last_time = null;
+    if (suspended) {
+      cancelAnimationFrame(this._frame);
+      this._frame = 0;
+    } else this._invalidate();
+  }
   _animate(m, time) {
-    const animation = m._animation;
-    animation.start ??= time;
-    let running = false;
-    for (const t of animation.tracks) {
-      const fraction = (time - animation.start) / t.duration, p = t.loop ? fraction : Math.min(fraction, 1);
-      running ||= t.loop || fraction < 1;
-      for (const [k, v] of Object.entries(t.values))
-        m[k] = k.startsWith("scale") ? Math.max(
-          1e-6,
-          t.mode === "delta" ? t.from[k] + v * p : t.from[k] + (v - t.from[k]) * p
-        ) : t.mode === "delta" ? t.from[k] + v * p : t.from[k] + (v - t.from[k]) * p;
-    }
-    m._stats = null;
-    if (!running) {
-      m._animation = null;
-      m.animation = null;
+    if (this._animationSuspended || !m._animation) return;
+    try {
+      if (!advancePlayback(m._animation, m, time)) this._completeAnimation(m);
+    } catch (error) {
+      this._stopAnimation(m, "error");
+      this._error(error);
     }
   }
   async get_image_blob(type = "image/png") {
@@ -3343,7 +4065,300 @@ var StlViewer = class _StlViewer {
   }
 };
 
-// src/v2/memory-policy.js
+// src/app-tools.js
+var toolsControls = [
+  "size-details",
+  "size-fields",
+  "size-x",
+  "size-y",
+  "size-z",
+  "size-lock",
+  "size-percent",
+  "size-apply",
+  "size-cancel",
+  "size-reset",
+  "size-error",
+  "file-units",
+  "file-units-note",
+  "display-units",
+  "size-unit-label",
+  "duplicate-model",
+  "camera-preset",
+  "bookmark-name",
+  "bookmark-list",
+  "bookmark-save",
+  "bookmark-restore",
+  "bookmark-rename",
+  "bookmark-delete",
+  "camera-error",
+  "info-area",
+  "info-volume",
+  "measure-model",
+  "measure-cancel",
+  "measure-status"
+];
+var axes2 = ["x", "y", "z"];
+var format = new Intl.NumberFormat(void 0, { maximumSignificantDigits: 7 });
+function bindAppTools({
+  $,
+  listen,
+  window: window2,
+  getViewer,
+  getState,
+  changeSize,
+  duplicate,
+  refresh,
+  announce
+}) {
+  let draftKind = null, lastAxis = 0, base = null, selected = null, measurement = null, disposed = false;
+  const error = (id, message = "") => {
+    $(id).textContent = message;
+    $(id).hidden = !message;
+  };
+  const factor = () => getViewer()?.display_units === "inch" ? 25.4 : 1;
+  const value = (v) => Number(v.toPrecision(10));
+  function syncInfo() {
+    const v = getViewer(), { selectedId, busy } = getState(), m = v?._models.get(selectedId);
+    const s = m?.scaleVector, cached = m?._measurements;
+    const valid = cached && cached.positions === m.geometry.positions && cached.key === s.join(",");
+    const unit = factor() === 1 ? "mm" : "in";
+    const area = valid ? cached.result.area_mm2 : s && s[0] === s[1] && s[1] === s[2] ? m.geometry.area * s[0] ** 2 : null;
+    $("info-area").textContent = area == null ? "Calculate" : format.format(area / factor() ** 2) + " " + unit + "\xB2";
+    $("info-volume").textContent = valid ? cached.result.volume_valid ? format.format(cached.result.volume_mm3 / factor() ** 3) + " " + unit + "\xB3" : "Unavailable" : "Not checked";
+    if (!measurement)
+      $("measure-status").textContent = valid ? cached.result.volume_reason : "Calculate to check enclosed volume. Runs on your device.";
+    $("measure-model").disabled = busy || !m || !!measurement;
+    $("measure-cancel").hidden = !measurement;
+  }
+  function syncBookmarks() {
+    const v = getViewer(), previous = $("bookmark-list").value, bookmarks = v?.get_camera_bookmarks() || [];
+    $("bookmark-list").replaceChildren(
+      ...bookmarks.map((b) => {
+        const option = window2.document.createElement("option");
+        option.value = b.name;
+        option.textContent = b.name;
+        return option;
+      })
+    );
+    if (bookmarks.some((b) => b.name === previous))
+      $("bookmark-list").value = previous;
+    for (const id of [
+      "bookmark-restore",
+      "bookmark-rename",
+      "bookmark-delete",
+      "bookmark-list"
+    ])
+      $(id).disabled = !bookmarks.length;
+    $("bookmark-save").disabled = !v || bookmarks.length >= 32;
+  }
+  function sync() {
+    if (disposed) return;
+    const { selectedId, busy } = getState(), v = getViewer(), m = v?._models.get(selectedId);
+    if (selectedId !== selected) {
+      measurement?.abort();
+      selected = selectedId;
+    }
+    draftKind = null;
+    base = m?.geometry ? v.get_model_size(selectedId) : null;
+    $("size-fields").disabled = busy || !base;
+    $("duplicate-model").disabled = busy || !base;
+    $("display-units").value = v?.display_units || "mm";
+    $("size-unit-label").textContent = factor() === 1 ? "Dimensions in mm" : "Dimensions in inches";
+    $("file-units").value = base?.file_units || "mm";
+    $("file-units").disabled = busy || !base?.editable;
+    $("file-units-note").textContent = base?.editable ? "STL/OBJ have no units. Millimetres are assumed; choose inches to correct the physical size." : "Explicit file units were converted to millimetres on import.";
+    axes2.forEach((a, i) => {
+      $("size-" + a).value = base ? value(base.dimensions_mm[i] / factor()) : "";
+      $("size-" + a).disabled = !base || base.dimensions_mm[i] === 0;
+    });
+    const ratios = base?.baseline_mm.map((v2, i) => v2 ? base.dimensions_mm[i] / v2 : null).filter((v2) => v2 != null) || [];
+    $("size-percent").value = ratios.length && ratios.every((v2) => Math.abs(v2 / ratios[0] - 1) < 1e-8) ? value(ratios[0] * 100) : "";
+    error("size-error");
+    syncInfo();
+    syncBookmarks();
+  }
+  const attempt = (id, action) => {
+    try {
+      action();
+      error(id);
+    } catch (e) {
+      error(id, e.message);
+    }
+  };
+  axes2.forEach(
+    (a, i) => listen($("size-" + a), "input", () => {
+      if (!base) return;
+      draftKind = "axis";
+      lastAxis = i;
+      const n = $("size-" + a).valueAsNumber;
+      if (!Number.isFinite(n) || n <= 0) return;
+      if ($("size-lock").checked)
+        axes2.forEach((axis, j) => {
+          if (i !== j)
+            $("size-" + axis).value = value(
+              n * base.dimensions_mm[j] / base.dimensions_mm[i]
+            );
+        });
+      $("size-percent").value = "";
+    })
+  );
+  listen($("size-percent"), "input", () => {
+    draftKind = "percent";
+    const n = $("size-percent").valueAsNumber;
+    if (base && Number.isFinite(n) && n > 0)
+      axes2.forEach(
+        (a, i) => $("size-" + a).value = value(
+          base.baseline_mm[i] * n / 100 / factor()
+        )
+      );
+  });
+  listen(
+    $("size-apply"),
+    "click",
+    () => attempt("size-error", () => {
+      if (!base) return;
+      if (!draftKind) return;
+      const current = getViewer().get_model_size(selected).dimensions_mm;
+      let desired = axes2.map((a) => $("size-" + a).valueAsNumber * factor());
+      if (draftKind === "percent") {
+        const percent = $("size-percent").valueAsNumber;
+        if (!Number.isFinite(percent) || percent <= 0)
+          throw new Error("Enter a positive scale percentage.");
+        desired = base.baseline_mm.map((v) => v * percent / 100);
+      } else if ($("size-lock").checked) {
+        const ratio = desired[lastAxis] / base.dimensions_mm[lastAxis];
+        desired = base.dimensions_mm.map((v) => v * ratio);
+      }
+      let ratios = desired.map((n, i) => {
+        if (!Number.isFinite(n) || n < 0 || current[i] > 0 && n === 0)
+          throw new Error("Enter positive dimensions for each non-flat axis.");
+        return current[i] ? n / current[i] : 1;
+      });
+      if (ratios.every((v) => Math.abs(v / ratios[0] - 1) < 1e-12))
+        ratios = ratios.map(() => ratios[0]);
+      changeSize(() => getViewer().resize_model(selected, ratios));
+      announce("Model size updated.");
+    })
+  );
+  listen($("size-cancel"), "click", sync);
+  listen(
+    $("size-reset"),
+    "click",
+    () => attempt("size-error", () => {
+      changeSize(() => getViewer().reset_model_size(selected));
+      announce("Original size restored; file-unit correction retained.");
+    })
+  );
+  listen(
+    $("file-units"),
+    "change",
+    () => attempt("size-error", () => {
+      changeSize(
+        () => getViewer().set_file_units(selected, $("file-units").value)
+      );
+      announce("File units corrected.");
+    })
+  );
+  listen($("display-units"), "change", () => {
+    getViewer()?.set_display_units($("display-units").value);
+    refresh();
+  });
+  listen($("duplicate-model"), "click", () => attempt("size-error", duplicate));
+  listen(
+    $("camera-preset"),
+    "change",
+    () => attempt("camera-error", () => {
+      if ($("camera-preset").value)
+        getViewer().set_camera_view($("camera-preset").value);
+      announce("Camera view updated.");
+      $("camera-preset").value = "";
+    })
+  );
+  const editBookmarks = (action) => attempt("camera-error", () => {
+    const v = getViewer(), bookmarks = v.get_camera_bookmarks();
+    action(bookmarks, v);
+    v.set_camera_bookmarks(bookmarks);
+    syncBookmarks();
+  });
+  listen(
+    $("bookmark-save"),
+    "click",
+    () => editBookmarks((b, v) => {
+      b.push({ name: $("bookmark-name").value, camera: v.get_camera_state() });
+    })
+  );
+  listen(
+    $("bookmark-rename"),
+    "click",
+    () => editBookmarks((b) => {
+      b.find((b2) => b2.name === $("bookmark-list").value).name = $("bookmark-name").value;
+    })
+  );
+  listen(
+    $("bookmark-delete"),
+    "click",
+    () => editBookmarks((b) => {
+      b.splice(
+        b.findIndex((b2) => b2.name === $("bookmark-list").value),
+        1
+      );
+    })
+  );
+  listen(
+    $("bookmark-restore"),
+    "click",
+    () => attempt("camera-error", () => {
+      const b = getViewer().get_camera_bookmarks().find((b2) => b2.name === $("bookmark-list").value);
+      if (b) {
+        getViewer().set_camera_state(b.camera);
+        announce("Saved view restored.");
+      }
+    })
+  );
+  listen(
+    $("bookmark-list"),
+    "change",
+    () => $("bookmark-name").value = $("bookmark-list").value
+  );
+  listen($("measure-cancel"), "click", () => measurement?.abort());
+  listen($("measure-model"), "click", async () => {
+    const id = selected, v = getViewer(), controller = new window2.AbortController();
+    measurement = controller;
+    syncInfo();
+    $("measure-status").textContent = "Calculating area and checking volume\u2026";
+    try {
+      await v.measure_model(id, {
+        signal: controller.signal,
+        on_progress: (p) => {
+          if (selected === id && !disposed)
+            $("measure-status").textContent = p.phase + "\u2026";
+        }
+      });
+      if (!disposed && selected === id) announce("Measurements ready.");
+    } catch (e) {
+      if (!disposed && selected === id)
+        $("measure-status").textContent = e.name === "AbortError" ? "Calculation cancelled." : e.message;
+    } finally {
+      const message = $("measure-status").textContent;
+      if (measurement === controller) measurement = null;
+      if (!disposed) {
+        syncInfo();
+        if (!v._models.get(id)?._measurements && selected === id)
+          $("measure-status").textContent = message;
+      }
+    }
+  });
+  return {
+    sync,
+    syncInfo,
+    dispose() {
+      disposed = true;
+      measurement?.abort();
+    }
+  };
+}
+
+// src/memory-policy.js
 var GiB = 1024 ** 3;
 var MiB = 1024 ** 2;
 function memoryPolicy(reportedGiB) {
@@ -3373,10 +4388,10 @@ async function estimateFile(file) {
   return 64 * MiB + (file.size || 0) * 3;
 }
 
-// src/v2/model-transform.js
-var axes = ["x", "y", "z"];
-var vector2 = (p) => axes.map((a) => p[a]);
-var object = (p) => Object.fromEntries(axes.map((a, i) => [a, p[i]]));
+// src/model-transform.js
+var axes3 = ["x", "y", "z"];
+var vector2 = (p) => axes3.map((a) => p[a]);
+var object2 = (p) => Object.fromEntries(axes3.map((a, i) => [a, p[i]]));
 var dot2 = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
 var norm2 = (a) => {
   const n = Math.hypot(...a) || 1;
@@ -3407,8 +4422,8 @@ function rotationMatrix(degrees = { x: 0, y: 0, z: 0 }) {
 }
 var centerOf = (bounds) => bounds.min.map((v, i) => (v + bounds.max[i]) / 2);
 function modelCenter(model) {
-  return object(
-    centerOf(model.bounds).map((v, i) => v + model.position[axes[i]])
+  return object2(
+    centerOf(model.bounds).map((v, i) => v + model.position[axes3[i]])
   );
 }
 function modelRadius(model) {
@@ -3419,7 +4434,7 @@ function modelRadius(model) {
 }
 function enginePosition(model) {
   const c = centerOf(model.bounds), rotated = transform2(rotationMatrix(model.rotation), c);
-  return object(c.map((v, i) => model.position[axes[i]] + v - rotated[i]));
+  return object2(c.map((v, i) => model.position[axes3[i]] + v - rotated[i]));
 }
 function modelBounds(model) {
   if (!model.rotation || !Object.values(model.rotation).some((v) => v % 360))
@@ -3472,12 +4487,12 @@ function depthPosition(model, camera, amount) {
   const clearance = Math.max(model.radius || 1e-6, 1e-6) * 1.1 / Math.max(0.05, dot2(direction, forward));
   const desired = (distance || clearance) * Math.exp(Math.max(-6, Math.min(6, amount)));
   const next = amount < 0 ? Math.max(Math.min(distance, clearance), desired) : Math.max(distance, Math.min(1e12, desired));
-  return object(
+  return object2(
     vector2(model.position).map((v, i) => v + direction[i] * (next - distance))
   );
 }
 
-// src/v2/scene-layout.js
+// src/scene-layout.js
 function scenePlacement(models, mode) {
   if (mode === "custom")
     return models.map((m) => ({
@@ -3515,7 +4530,7 @@ function sceneFloor(models, placement) {
   ) : 0;
 }
 
-// src/v2/model-move.js
+// src/model-move.js
 var vector3 = (p) => [p.x, p.y, p.z];
 var sub2 = (a, b) => a.map((v, i) => v - b[i]);
 var dot3 = (a, b) => a.reduce((n, v, i) => n + v * b[i], 0);
@@ -3681,7 +4696,7 @@ function bindModelMove(canvas, {
   };
 }
 
-// src/v2/drop-source.js
+// src/drop-source.js
 function dropKind(transfer) {
   const types = Array.from(transfer?.types || [], (type) => type.toLowerCase());
   if (types.includes("files") || transfer?.files?.length) return "files";
@@ -3721,7 +4736,7 @@ function droppedURLs(transfer) {
   return [...urls];
 }
 
-// src/v2/app-export.js
+// src/app-export.js
 var exportControls = [
   "save-button",
   "save-dialog",
@@ -3760,16 +4775,16 @@ function bindAppExport({
     $("save-error").textContent = "";
   };
   function formatChanged() {
-    const format = $("save-format").value;
+    const format2 = $("save-format").value;
     if (!$("save-name").value || $("save-name").value === lastSuggestedName) {
       suggestedName();
     }
     if ($("save-mesh-note")) $("save-mesh-note").hidden = isScene();
     if ($("save-scene-note")) $("save-scene-note").hidden = !isScene();
-    $("save-colors-row").hidden = !["obj", "3mf"].includes(format);
-    $("save-cad-note").hidden = !["step", "iges"].includes(format);
+    $("save-colors-row").hidden = !["obj", "3mf"].includes(format2);
+    $("save-cad-note").hidden = !["step", "iges"].includes(format2);
     $("save-format-note").textContent = $("save-format").selectedOptions[0]?.dataset.note || "";
-    $("save-submit").textContent = format === "obj" && $("save-colors").checked ? "Download ZIP" : "Download file";
+    $("save-submit").textContent = format2 === "obj" && $("save-colors").checked ? "Download ZIP" : "Download file";
     sync();
   }
   function suggestedName() {
@@ -3891,7 +4906,7 @@ function bindAppExport({
   };
 }
 
-// src/v2/app-print.js
+// src/app-print.js
 var printControls = [
   "print-button",
   "print-panel",
@@ -3925,6 +4940,7 @@ function bindAppPrint({
 }) {
   let job = null, report = null, timer = null, disposed = false, scopeKey = "", previousScope = "", unavailable = false;
   const panel = $("print-panel"), document2 = panel.ownerDocument;
+  const pausedForCheck = /* @__PURE__ */ new Set();
   const summary = {
     issues_found: "Issues found",
     incomplete: "Check incomplete",
@@ -3946,6 +4962,15 @@ function bindAppPrint({
     const s = getState();
     $("print-button").disabled = s.busy || !s.models.length;
     if (panel.hidden) return;
+    for (const id of pausedForCheck)
+      if (!s.models.some((m) => m.id === id) || getViewer()?.get_model_animation_state(id)?.status !== "paused")
+        pausedForCheck.delete(id);
+    if ($("print-resume")) {
+      $("print-resume").hidden = !pausedForCheck.size;
+      $("print-resume").disabled = !!job || s.busy;
+    }
+    if ($("print-animation-note"))
+      $("print-animation-note").hidden = !pausedForCheck.size;
     const wasUnavailable = unavailable;
     unavailable = s.busy || !s.models.length;
     $("print-run").disabled = !!job || unavailable;
@@ -4092,6 +5117,19 @@ function bindAppPrint({
   listen($("print-fields"), "change", changed);
   listen($("print-clear"), "click", clear);
   listen($("print-cancel"), "click", cancel);
+  if ($("print-resume"))
+    listen($("print-resume"), "click", () => {
+      if (job || getState().busy) return;
+      for (const id of pausedForCheck)
+        if (getState().models.some((m) => m.id === id) && getViewer().get_model_animation_state(id)?.status === "paused")
+          getViewer().resume_model_animation(id);
+      pausedForCheck.clear();
+      report = null;
+      clear();
+      $("print-results").replaceChildren();
+      $("print-status").textContent = "Animation resumed. Pause and run the check again for the new pose.";
+      sync();
+    });
   listen($("print-results"), "click", (e) => {
     const b = e.target.closest("button[data-issue]");
     if (!b || !report) return;
@@ -4135,6 +5173,13 @@ function bindAppPrint({
         }
       }
       scopeKey = key();
+      for (const id of stateIds()) {
+        if (getViewer().get_model_animation_state(id)?.status === "running") {
+          getViewer().pause_model_animation(id);
+          pausedForCheck.add(id);
+        }
+      }
+      sync();
       const result = await getViewer().check_printability({
         model_ids: stateIds(),
         level: $("print-level").value,
@@ -4172,11 +5217,216 @@ function bindAppPrint({
       disposed = true;
       close(false);
       report = null;
+      pausedForCheck.clear();
+    }
+  };
+}
+
+// src/app-animation.js
+var animationControls = [
+  "animation-details",
+  "animation-fields",
+  "animation-axis",
+  "animation-seconds",
+  "animation-direction",
+  "animation-play",
+  "animation-pause",
+  "animation-stop",
+  "animation-status",
+  "animation-error"
+];
+var axes4 = ["x", "y", "z"];
+function syncAnimatedRecord(record, model) {
+  if (!record || !model?.geometry) return;
+  record.bounds = Object.fromEntries(
+    ["min", "max"].map((key) => [
+      key,
+      model.geometry.bounds[key].map(
+        (v, i) => (v - model.center[i]) * model.scaleVector[i]
+      )
+    ])
+  );
+  record.rotation = Object.fromEntries(
+    axes4.map((a) => [a, model["rotation" + a] * 180 / Math.PI % 360])
+  );
+  record.position = { x: 0, y: 0, z: 0 };
+  const offset = enginePosition(record);
+  for (const a of axes4) record.position[a] = model[a] - offset[a];
+}
+function centerAnimationPivot(record, model) {
+  syncAnimatedRecord(record, model);
+  const center = model.geometry.bounds.min.map(
+    (v, i) => (v + model.geometry.bounds.max[i]) / 2
+  );
+  const delta = center.map(
+    (v, i) => (v - model.center[i]) * model.scaleVector[i]
+  );
+  const rotation2 = rotationMatrix(record.rotation);
+  const original = record.originalPosition || { x: 0, y: 0, z: 0 };
+  record.originalPosition = Object.fromEntries(
+    axes4.map((a, i) => [a, original[a] + delta[i]])
+  );
+  for (let i = 0; i < 3; i++)
+    model[axes4[i]] += delta.reduce(
+      (sum, v, j) => sum + rotation2[i * 3 + j] * v,
+      0
+    );
+  model.center = center;
+  record.animationPivot = true;
+  syncAnimatedRecord(record, model);
+}
+function spinDefinition(axis, seconds, direction) {
+  if (!axes4.includes(axis) || !Number.isFinite(seconds) || seconds < 0.1 || seconds > 3600 || !["1", "-1"].includes(direction))
+    throw new Error("Choose an axis and a duration from 0.1 to 3,600 seconds.");
+  return {
+    delta: {
+      ["rotation" + axis]: 2 * Math.PI * Number(direction),
+      msec: seconds * 1e3,
+      loop: true
+    }
+  };
+}
+function bindAppAnimation({
+  $,
+  listen,
+  window: window2,
+  getState,
+  getViewer,
+  beforePlay,
+  refreshPose,
+  announce
+}) {
+  const settings = /* @__PURE__ */ new Map();
+  let selected = null, timer = null, disposed = false;
+  const state = () => {
+    const s = getState();
+    return {
+      ...s,
+      playback: s.selectedId == null ? null : getViewer()?.get_model_animation_state(s.selectedId)
+    };
+  };
+  function sync() {
+    if (disposed) return;
+    const s = state(), available = s.models.some((m) => m.id === s.selectedId);
+    for (const id of settings.keys())
+      if (!s.models.some((m) => m.id === id)) settings.delete(id);
+    $("animation-details").hidden = !available;
+    $("animation-fields").disabled = s.busy || !available;
+    if (selected !== s.selectedId) {
+      selected = s.selectedId;
+      let value = settings.get(selected);
+      if (!value) {
+        value = { axis: "z", seconds: 5, direction: "1" };
+        const a = getViewer()?._models.get(selected)?.animation;
+        const entries = Object.entries(a?.delta || {}).filter(
+          ([k, v]) => k.startsWith("rotation") && v !== 0
+        );
+        if (a?.delta?.loop && !a.exact && entries.length === 1) {
+          value = {
+            axis: entries[0][0].slice(-1),
+            seconds: a.delta.msec * 2 * Math.PI / Math.abs(entries[0][1]) / 1e3,
+            direction: entries[0][1] < 0 ? "-1" : "1"
+          };
+        }
+        settings.set(selected, value);
+      }
+      $("animation-axis").value = value.axis;
+      $("animation-seconds").value = value.seconds;
+      $("animation-direction").value = value.direction;
+      $("animation-error").hidden = true;
+    }
+    const status = s.playback?.status || "idle", active = ["running", "paused"].includes(status);
+    $("animation-play").textContent = active ? "Restart spin" : "Play";
+    $("animation-pause").textContent = status === "paused" ? "Resume" : "Pause";
+    $("animation-pause").disabled = !active;
+    $("animation-stop").disabled = !active;
+    const label = {
+      idle: "Ready",
+      running: "Playing",
+      paused: "Paused",
+      stopped: "Stopped",
+      completed: "Finished"
+    }[status];
+    const text = `${label}. ${active ? "Stop keeps the current pose." : "Spin the selected model around its center."}`;
+    if ($("animation-status").textContent !== text)
+      $("animation-status").textContent = text;
+    if (status === "running" && !timer)
+      timer = window2.setInterval(() => {
+        if (!disposed && !window2.document.hidden) refreshPose();
+      }, 250);
+    if (status !== "running" && timer) {
+      window2.clearInterval(timer);
+      timer = null;
+    }
+  }
+  function play(keepPaused = false) {
+    const s = state();
+    if (s.busy || s.selectedId == null) return;
+    try {
+      const value = {
+        axis: $("animation-axis").value,
+        seconds: $("animation-seconds").valueAsNumber,
+        direction: $("animation-direction").value
+      };
+      const definition = spinDefinition(
+        value.axis,
+        value.seconds,
+        value.direction
+      );
+      beforePlay(s.selectedId);
+      getViewer().animate_model(s.selectedId, definition);
+      if (keepPaused && s.playback?.status === "paused")
+        getViewer().pause_model_animation(s.selectedId);
+      settings.set(s.selectedId, value);
+      $("animation-error").hidden = true;
+      announce(
+        keepPaused && s.playback?.status === "paused" ? "Spin updated. Still paused." : "Animation playing."
+      );
+      sync();
+    } catch (error) {
+      $("animation-error").textContent = error.message;
+      $("animation-error").hidden = false;
+    }
+  }
+  listen($("animation-play"), "click", () => play());
+  listen($("animation-pause"), "click", () => {
+    const s = state();
+    if (s.busy || s.selectedId == null) return;
+    getViewer()[s.playback?.status === "paused" ? "resume_model_animation" : "pause_model_animation"](s.selectedId);
+    sync();
+  });
+  listen($("animation-stop"), "click", () => {
+    const s = state();
+    if (!s.busy && s.selectedId != null)
+      getViewer().animate_model(s.selectedId, null);
+    sync();
+  });
+  for (const id of [
+    "animation-axis",
+    "animation-seconds",
+    "animation-direction"
+  ])
+    listen($(id), "change", () => {
+      if (["running", "paused"].includes(state().playback?.status)) play(true);
+      else
+        settings.set(selected, {
+          axis: $("animation-axis").value,
+          seconds: $("animation-seconds").valueAsNumber,
+          direction: $("animation-direction").value
+        });
+    });
+  sync();
+  return {
+    sync,
+    dispose() {
+      disposed = true;
+      window2.clearInterval(timer);
+      settings.clear();
     }
   };
 }
 
-// src/v2/app.js
+// src/app.js
 var mountedRoots = /* @__PURE__ */ new WeakMap();
 var requiredControls = [
   "background-color",
@@ -4281,6 +5531,10 @@ function mountViewstlApp(root, options = {}) {
     missing.push(...exportControls.filter((id) => !$(id)));
   if (printControls.some((id) => $(id)))
     missing.push(...printControls.filter((id) => !$(id)));
+  if (animationControls.some((id) => $(id)))
+    missing.push(...animationControls.filter((id) => !$(id)));
+  if (toolsControls.some((id) => $(id)))
+    missing.push(...toolsControls.filter((id) => !$(id)));
   if (missing.length)
     throw new Error("Missing ViewSTL controls: " + missing.join(", "));
   const abort = new window2.AbortController();
@@ -4308,6 +5562,8 @@ function mountViewstlApp(root, options = {}) {
   let viewerPromise, viewer, generation = 0, appearanceRequest = 0, modelID = null, nextID = 0, loadingID = null;
   let exportUI;
   let printUI;
+  let animationUI;
+  let toolsUI;
   let sceneImport;
   let draining = false, busy = false, gridEnabled = false, gridHeight = 0, gridSpacing = 1, moveMode = false, transformTool = "move", modelMover, dragArrangement, background = "transparent";
   const viewNames = {
@@ -4356,6 +5612,8 @@ function mountViewstlApp(root, options = {}) {
     $(name + "-panel").hidden = !open;
     $(name + "-button").setAttribute("aria-expanded", String(open));
     syncSelection();
+    if (open && name === "info") populateInfo();
+    if (open && (name === "scene" || name === "view")) toolsUI?.sync();
   }
   function fileSize(size) {
     return size == null ? "Sample model" : size < 1024 ** 2 ? `${formatNumber.format(size / 1024)} KiB` : size < 1024 ** 3 ? `${formatNumber.format(size / 1024 ** 2)} MiB` : `${formatNumber.format(size / 1024 ** 3)} GiB`;
@@ -4381,12 +5639,14 @@ function mountViewstlApp(root, options = {}) {
     $("background-value").textContent = background === "transparent" ? "Default" : background.toUpperCase();
   }
   function syncControls() {
-    const info = modelID === null ? null : viewer.get_model_info(modelID), mode = info?.display === "smooth" ? "flat" : info?.display || "flat";
+    syncAnimatedRecord(records.get(modelID), viewer?._models.get(modelID));
+    const info = modelID === null ? null : viewer.get_model_info(modelID, { measurements: false }), mode = info?.display === "smooth" ? "flat" : info?.display || "flat";
     for (const input of modeInputs) {
       input.checked = input.value === mode;
       input.disabled = busy;
     }
-    $("view-label").textContent = viewNames[mode];
+    $("view-label").textContent = toolsUI ? "View" : viewNames[mode];
+    $("view-button").title = "View \xB7 " + viewNames[mode];
     $("smooth-shading").checked = info?.smooth_shading || false;
     $("smooth-shading").disabled = busy || mode === "wireframe";
     $("view-status").textContent = mode === "wireframe" ? "Smooth shading is available in surface views." : "Shading changes the appearance, not the geometry.";
@@ -4409,14 +5669,18 @@ function mountViewstlApp(root, options = {}) {
     syncPosition();
     exportUI?.sync();
     printUI?.sync();
+    animationUI?.sync();
+    toolsUI?.sync();
   }
   function populateInfo() {
     if (modelID === null) return;
-    const info = viewer.get_model_info(modelID), record = records.get(modelID), units = record.units === "mm" ? " mm" : "";
+    const info = viewer.get_model_info(modelID, { measurements: false }), record = records.get(modelID), factor = viewer.display_units === "inch" ? 25.4 : 1;
     $("info-triangles").textContent = info.triangles.toLocaleString();
-    $("info-dimensions").textContent = [info.dims.x, info.dims.y, info.dims.z].map((x) => formatNumber.format(x)).join(" \xD7 ") + units;
+    $("info-dimensions").textContent = [info.dims.x, info.dims.y, info.dims.z].map((x) => formatNumber.format(x / factor)).join(" \xD7 ") + (factor === 1 ? " mm" : " in");
     $("info-size").textContent = fileSize(record.size);
-    $("unit-note").textContent = units ? "Dimensions are shown in millimetres." : "Dimensions are in model units. STL and OBJ files do not specify physical units.";
+    const size = viewer.get_model_size(modelID);
+    $("unit-note").textContent = size.editable ? "File coordinates interpreted as " + (size.file_units === "inch" ? "inches." : "millimetres (assumed).") + " Change file units in Models \u2192 Size & units." : "Explicit file units were converted to millimetres on import.";
+    toolsUI?.syncInfo();
   }
   function renderList() {
     $("model-list").replaceChildren(
@@ -4488,6 +5752,10 @@ function mountViewstlApp(root, options = {}) {
   }
   function arrangeScene() {
     setMoveMode(false);
+    for (const record of records.values())
+      syncAnimatedRecord(record, viewer?._models.get(record.id));
+    if ($("scene-arrangement").value === "custom") return;
+    for (const record of records.values()) prepareManual(record.id);
     if ($("scene-arrangement").value === "original")
       for (const record of records.values())
         record.rotation = {
@@ -4504,19 +5772,20 @@ function mountViewstlApp(root, options = {}) {
     updateGrid();
     viewer?.set_auto_zoom();
   }
-  function syncPosition() {
+  function syncPosition(preserveFocus = false) {
     const record = records.get(modelID);
     for (const axis of ["x", "y", "z"]) {
       const input = $("position-" + axis);
-      input.value = Number((record?.position?.[axis] || 0).toPrecision(12));
+      if (!preserveFocus || document2.activeElement !== input)
+        input.value = Number((record?.position?.[axis] || 0).toPrecision(12));
       input.disabled = !record;
       input.removeAttribute("aria-invalid");
     }
     $("position-error").hidden = true;
-    $("position-units").textContent = record?.units === "mm" ? "Offset from file coordinates, in mm." : "Offset from file coordinates, in model units.";
+    $("position-units").textContent = record?.animationPivot ? "Position of the model center in the scene, in mm." : "Offset from file coordinates, in mm.";
     $("move-model-button").disabled = !record || busy;
     $("reset-position").disabled = !record;
-    syncRotation();
+    syncRotation(preserveFocus);
     for (const id of [
       "rotate-model-button",
       "depth-model-button",
@@ -4545,14 +5814,16 @@ function mountViewstlApp(root, options = {}) {
     viewer.set_position(record.id, p.x, p.y, p.z);
   }
   function selectedTransform() {
+    prepareManual(modelID);
     const record = records.get(modelID);
     return record ? { ...record, center: modelCenter(record), radius: modelRadius(record) } : null;
   }
-  function syncRotation() {
+  function syncRotation(preserveFocus = false) {
     const record = records.get(modelID);
     for (const axis of ["x", "y", "z"]) {
       const input = $("rotation-" + axis);
-      input.value = Number((record?.rotation?.[axis] || 0).toPrecision(10));
+      if (!preserveFocus || document2.activeElement !== input)
+        input.value = Number((record?.rotation?.[axis] || 0).toPrecision(10));
       input.disabled = !record;
       input.removeAttribute("aria-invalid");
     }
@@ -4594,10 +5865,11 @@ function mountViewstlApp(root, options = {}) {
     $("model-tool").value = transformTool;
     $("move-gesture-message").textContent = toolHints[transformTool] + " \xB7 Scroll to adjust depth";
   }
-  function setMoveMode(enabled, tool = transformTool) {
+  function setMoveMode(enabled, tool = transformTool, retainPaused = false) {
     modelMover?.setEnabled(false);
     transformTool = tool;
     moveMode = !!enabled && modelID !== null && !busy;
+    if (moveMode && !retainPaused) prepareManual(modelID);
     modelMover?.setEnabled(moveMode);
     syncTool();
     $("move-mode").hidden = !moveMode;
@@ -4621,6 +5893,7 @@ function mountViewstlApp(root, options = {}) {
     const input = $("rotation-" + axis);
     listen(input, "input", () => {
       if (modelID === null || !input.value.trim()) return;
+      prepareManual(modelID);
       if (applyRotation(
         modelID,
         { ...records.get(modelID).rotation, [axis]: input.valueAsNumber },
@@ -4632,6 +5905,7 @@ function mountViewstlApp(root, options = {}) {
     });
     listen(input, "change", () => {
       if (modelID === null) return;
+      prepareManual(modelID);
       if (!input.value.trim() || !applyRotation(modelID, {
         ...records.get(modelID).rotation,
         [axis]: input.valueAsNumber
@@ -4644,6 +5918,7 @@ function mountViewstlApp(root, options = {}) {
   listen($("reset-rotation"), "click", () => {
     setMoveMode(false);
     if (modelID !== null) {
+      prepareManual(modelID);
       applyRotation(modelID, {
         ...records.get(modelID).originalRotation || { x: 0, y: 0, z: 0 }
       });
@@ -4683,6 +5958,7 @@ function mountViewstlApp(root, options = {}) {
     const input = $("position-" + axis);
     listen(input, "input", () => {
       if (modelID === null || !input.value.trim()) return;
+      prepareManual(modelID);
       if (applyPosition(
         modelID,
         { ...records.get(modelID).position, [axis]: input.valueAsNumber },
@@ -4694,6 +5970,7 @@ function mountViewstlApp(root, options = {}) {
     });
     listen(input, "change", () => {
       if (modelID === null) return;
+      prepareManual(modelID);
       if (!input.value.trim() || !applyPosition(modelID, {
         ...records.get(modelID).position,
         [axis]: input.valueAsNumber
@@ -4710,6 +5987,7 @@ function mountViewstlApp(root, options = {}) {
   listen($("reset-position"), "click", () => {
     setMoveMode(false);
     if (modelID !== null) {
+      prepareManual(modelID);
       applyPosition(modelID, {
         ...records.get(modelID).originalPosition || { x: 0, y: 0, z: 0 }
       });
@@ -4760,6 +6038,30 @@ function mountViewstlApp(root, options = {}) {
     renderScene();
     announce(name + " removed.");
   }
+  function prepareManual(id) {
+    if (!records.has(id)) return;
+    syncAnimatedRecord(records.get(id), viewer?._models.get(id));
+    viewer?.animate_model(id, null);
+  }
+  function refreshAnimatedPose() {
+    if (disposed || modelID === null) return;
+    syncAnimatedRecord(records.get(modelID), viewer?._models.get(modelID));
+    if (!$("info-panel").hidden) populateInfo();
+    if (!$("scene-panel").hidden && $("position-details").open)
+      syncPosition(true);
+  }
+  function animationChanged(id, state, reason) {
+    if (disposed) return;
+    if (reason === "restored" && state.status === "running" && window2.matchMedia?.("(prefers-reduced-motion: reduce)").matches)
+      viewer.pause_model_animation(id);
+    syncAnimatedRecord(records.get(id), viewer?._models.get(id));
+    if (["started", "restored", "resumed"].includes(reason))
+      $("scene-arrangement").value = "custom";
+    if (id === modelID) refreshAnimatedPose();
+    animationUI?.sync();
+    printUI?.sync();
+    options.animation_state_callback?.(id, state, reason);
+  }
   async function getViewer() {
     if (!viewerPromise)
       viewerPromise = Promise.resolve().then(async () => {
@@ -4774,6 +6076,10 @@ function mountViewstlApp(root, options = {}) {
           center_models: false,
           bg_color: background,
           allow_drag_and_drop: false,
+          animation_state_callback: animationChanged,
+          animation_complete_callback: (...args) => {
+            if (!disposed) options.animation_complete_callback?.(...args);
+          },
           camera_state: {
             position: { x: 90, y: -130, z: 90 },
             target: { x: 0, y: 0, z: 0 },
@@ -4865,7 +6171,7 @@ function mountViewstlApp(root, options = {}) {
     if (queue.length && !draining) drainPromise = drainQueue();
     return drainPromise || Promise.resolve();
   }
-  function openURL(value, format = "") {
+  function openURL(value, format2 = "") {
     assertActive();
     if (!options.url_import_endpoint)
       throw new Error("URL imports are not configured.");
@@ -4874,7 +6180,7 @@ function mountViewstlApp(root, options = {}) {
       throw new Error(
         "Use a public HTTP or HTTPS file URL without login credentials."
       );
-    if (format && !/^(stl|obj|3mf|step|stp|iges|igs|vsb|vsj)$/.test(format))
+    if (format2 && !/^(stl|obj|3mf|step|stp|iges|igs|vsb|vsj)$/.test(format2))
       throw new Error("Choose a supported 3D format.");
     url.hash = "";
     const name = decodeURIComponent(
@@ -4883,9 +6189,9 @@ function mountViewstlApp(root, options = {}) {
     queue.push({
       name,
       remote: url.href,
-      format,
+      format: format2,
       size: 0,
-      scene: ["vsb", "vsj"].includes(format) ? format : sceneFormat(name)
+      scene: ["vsb", "vsj"].includes(format2) ? format2 : sceneFormat(name)
     });
     if (!draining) drainPromise = drainQueue();
     return drainPromise || Promise.resolve();
@@ -4954,7 +6260,7 @@ function mountViewstlApp(root, options = {}) {
           await engine.when_idle();
           if (token !== generation) continue;
           loadingID = null;
-          const loaded = lastLoadedID === id ? engine.get_model_info(id) : null;
+          const loaded = lastLoadedID === id ? engine.get_model_info(id, { measurements: false }) : null;
           if (!loaded) {
             announce(source.name + " could not be opened.");
             continue;
@@ -5046,7 +6352,7 @@ function mountViewstlApp(root, options = {}) {
         );
         const record = {
           id,
-          name: String(m.orig_filename || m.filename).split(/[\\/]/).pop().split(/[?#]/)[0],
+          name: String(m.display_name || m.orig_filename || m.filename).split(/[\\/]/).pop().split(/[?#]/)[0],
           size: g.file_bytes ?? m.local_file?.size ?? null,
           units: g.units || m.units,
           bounds,
@@ -5355,6 +6661,64 @@ function mountViewstlApp(root, options = {}) {
       },
       announce
     });
+  if ($("animation-details"))
+    animationUI = bindAppAnimation({
+      $,
+      listen,
+      window: window2,
+      getState: () => ({
+        busy,
+        selectedId: modelID,
+        models: [...records.values()]
+      }),
+      getViewer: () => viewer,
+      beforePlay(id) {
+        setMoveMode(false);
+        prepareManual(id);
+        centerAnimationPivot(records.get(id), viewer._models.get(id));
+        $("scene-arrangement").value = "custom";
+      },
+      refreshPose: refreshAnimatedPose,
+      announce
+    });
+  if ($("size-details"))
+    toolsUI = bindAppTools({
+      $,
+      listen,
+      window: window2,
+      getViewer: () => viewer,
+      getState: () => ({ selectedId: modelID, busy }),
+      refresh: renderScene,
+      announce,
+      changeSize(operation) {
+        setMoveMode(false);
+        const record = records.get(modelID);
+        syncAnimatedRecord(record, viewer._models.get(modelID));
+        operation();
+        syncAnimatedRecord(record, viewer._models.get(modelID));
+        $("scene-arrangement").value = "custom";
+        renderScene();
+      },
+      duplicate() {
+        const original = records.get(modelID), id = viewer.duplicate_model(modelID), m = viewer._models.get(id);
+        const record = {
+          ...original,
+          id,
+          name: m.display_name,
+          position: { ...original.position },
+          rotation: { ...original.rotation }
+        };
+        syncAnimatedRecord(record, m);
+        record.originalPosition = { ...record.position };
+        record.originalRotation = { ...record.rotation };
+        records.set(id, record);
+        nextID = Math.max(nextID, id + 1);
+        $("scene-arrangement").value = "custom";
+        selectModel(id);
+        setMoveMode(true, "move", true);
+        announce("Copy selected at the same position. Drag to move it.");
+      }
+    });
   updateGrid();
   setBusy(false);
   setMoveMode(false);
@@ -5379,6 +6743,8 @@ function mountViewstlApp(root, options = {}) {
     },
     getState() {
       assertActive();
+      for (const record of records.values())
+        syncAnimatedRecord(record, viewer?._models.get(record.id));
       return {
         selectedId: modelID,
         busy,
@@ -5391,7 +6757,8 @@ function mountViewstlApp(root, options = {}) {
           units: record.units,
           position: { ...record.position },
           rotation: { ...record.rotation },
-          color: record.color
+          color: record.color,
+          animation: viewer.get_model_animation_state(record.id)
         }))
       };
     },
@@ -5399,6 +6766,8 @@ function mountViewstlApp(root, options = {}) {
       if (disposed) return;
       exportUI?.dispose();
       printUI?.dispose();
+      animationUI?.dispose();
+      toolsUI?.dispose();
       cancelLoading();
       setMoveMode(false);
       appearanceRequest++;
@@ -5416,7 +6785,7 @@ function mountViewstlApp(root, options = {}) {
   return api;
 }
 
-// src/v2/index.js
+// src/index.js
 StlViewer.workerURL = new URL("./viewstl.worker.js", import.meta.url).href;
 var index_default = StlViewer;
 export {