gps-plus-slam-app-framework 1.10.0 → 1.13.0

package/dist/{map-data-D8sSxpOr.d.ts → map-data-BQXPtRz7.d.ts}

@@ -1,4 +1,4 @@
-import { n as RawGpsSample, t as GpsCoord } from "./geo-types-BfDK8kJu.js";
+import { n as RawGpsSample, t as GpsCoord } from "./geo-types-DGe5UKgx.js";
 import { LatLong, Matrix4, Quaternion, Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/visualization/map-data.d.ts
@@ -10,7 +10,7 @@ interface MapData {
    * (GPS-converted tip of `fusedPath`), so the dot keeps moving indoors where
    * the raw fix freezes; the last raw GPS fix is only the pre-alignment
    * fallback. See
-   * gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-07-06-recorder-live-map-user-dot-fused-pose-user-feedback.md.
+   * gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-07-06-1526-recorder-live-map-user-dot-fused-pose-user-feedback.md.
    */
   userPosition: GpsCoord | null;
   /** Raw GPS samples (yellow polyline + per-event accuracy circles). */
@@ -24,7 +24,7 @@ interface MapData {
    * north, `[0, 360)`) for the user-position heading line, or null when
    * undefined (no rotation/alignment yet, or camera near-vertical). See
    * Finding 2 of
-   * gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-06-28-map-rings-transparency-and-view-direction-user-feedback.md.
+   * gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-06-28-1822-map-rings-transparency-and-view-direction-user-feedback.md.
    *
    * Optional only so pre-existing direct `MapData` literals (e.g. the static
    * summary map, which is out of scope and draws no heading line) keep

package/dist/{map-data-D3oE8AQP.js → map-data-vL8jb5Z9.js}

@@ -7,7 +7,7 @@ import { vec3 } from "gl-matrix";
 * Turns the latest AR camera rotation into an absolute compass bearing (degrees
 * clockwise from geographic North) so the live/replay map overlay can draw a
 * thin view-direction line from the user-position dot. See Finding 2 of
-* gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-06-28-map-rings-transparency-and-view-direction-user-feedback.md.
+* gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-06-28-1822-map-rings-transparency-and-view-direction-user-feedback.md.
 *
 * Why this lives in the app-framework (NOT the library's `orientation-heading.ts`):
 * that library module is the MAGNETIC path — its bearings come from the

package/dist/{map-overlay-draw-1E61FLKs.d.ts → map-overlay-draw-sTM3wug_.d.ts}

@@ -1,4 +1,4 @@
-import { t as MapData } from "./map-data-D8sSxpOr.js";
+import { t as MapData } from "./map-data-BQXPtRz7.js";
 import L from "leaflet";
 
 //#region ../src/visualization/map-overlay-draw.d.ts

package/dist/{median-Bla_W50f.js → median-DDBrZGP0.js}

@@ -3,9 +3,9 @@
 * Shared median helpers (2026-07-10 quality-review A-2).
 *
 * Six private copies with two silently different semantics used to live in
-* `ar/qr-size-from-depth.ts`, `state/tracking-quality.ts`,
+* `ar/qr/qr-size-from-depth.ts`, `state/tracking-quality.ts`,
 * `visualization/gps-anchor.ts` (interpolating) and `ar/image-quality.ts`,
-* `ar/qr-pose-aggregation.ts`, `state/qr-detected-slice.ts` (lower-middle).
+* `ar/qr/qr-pose-aggregation.ts`, `state/qr-detected-slice.ts` (lower-middle).
 * The two variants are deliberately separate named exports — picking the
 * wrong one is exactly the drift this consolidation prevents.
 */

package/dist/{null-storage-backend-DXXuwG8T.d.ts → null-storage-backend-Dtn3TBfT.d.ts}

@@ -1,5 +1,5 @@
-import { n as SessionMetadata } from "./opfs-storage-S_odkCk1.js";
-import { n as StorageBackend, t as CreateSessionResult } from "./storage-backend-BX7egQKi.js";
+import { n as SessionMetadata } from "./opfs-storage-CrhVauNL.js";
+import { n as StorageBackend, t as CreateSessionResult } from "./storage-backend-DCYbOvTw.js";
 
 //#region ../src/storage/null-storage-backend.d.ts
 declare class NullStorageBackend implements StorageBackend {

package/dist/{occlusion-mesh-CZ4i_SW2.d.ts → occlusion-mesh-BY2aMej3.d.ts}

@@ -1,10 +1,29 @@
-import { t as GridCell } from "./bresenham3d-D-t9i_b5.js";
-import { p as OccluderDebugStyle } from "./recording-options-Cai9D14V.js";
-import { n as MeshMode, t as Aabb } from "./occupancy-mesher-BqnRd10x.js";
+import { t as GridCell } from "./bresenham3d-bt61R-Qa.js";
+import { n as MeshMode, t as Aabb } from "./occupancy-mesher-Co80tOpl.js";
 import * as THREE from "three";
-import { Vector3 } from "gps-plus-slam-js";
+import { Vector3 as Vector3$1 } from "gps-plus-slam-js";
 
 //#region ../src/visualization/occlusion-mesh.d.ts
+/**
+ * Debug-visualization style for the **persistent occluder** mesh (2026-07-02
+ * debug-viz-styles plan) — which visible debug skin(s) `OcclusionMesh` renders
+ * on top of the invisible depth-only occluder:
+ * - `'off'` — no debug rendering (the shipped default; occlusion is invisible).
+ * - `'matcap'` — the original shiny semi-transparent cyan skin.
+ * - `'depth-shaded'` — matcap + camera-distance fade + white fresnel rim, so
+ *   overlapping near/far surfaces read as separate shells.
+ * - `'wireframe'` — the raw triangulation as GL lines (mesh-structure
+ *   inspection: triangle density, mesher seams, degenerate spots).
+ * - `'depth-shaded-wireframe'` — both of the above composed.
+ *
+ * Owned here since the 2026-07-11 G-1 move (this module is the consumer; it
+ * previously lived in the recorder settings catalog). The values array is
+ * exported so the recorder's `occluderDebugStyle` validator can enum-check
+ * persisted values; the settings `<select>` options are hardcoded in the
+ * recorder's `index.html`.
+ */
+declare const OCCLUDER_DEBUG_STYLES: readonly ["off", "matcap", "depth-shaded", "wireframe", "depth-shaded-wireframe"];
+type OccluderDebugStyle = (typeof OCCLUDER_DEBUG_STYLES)[number];
 /**
  * Depth-shaded debug-skin constants — **module constants, not user settings**
  * (tune in code after the first on-device look; 2026-07-02 debug-viz-styles
@@ -106,6 +125,24 @@ declare class OcclusionMesh {
   getTriangleCount(): number;
   /** The AABB list from the most recent {@link update} (physics export hook). */
   getAabbs(): readonly Aabb[];
+  /**
+   * The underlying `THREE.Mesh` (the depth-only occluder geometry), for a
+   * pointer-raycast layer to target the real occluder surface (2026-07-15
+   * replay-harness Part B). The mesh's `colorWrite:false` invisibility does NOT
+   * affect `THREE.Raycaster`, and `frustumCulled:false` is fine for raycasting.
+   * Treat it as read-only — re-mesh via {@link update} / restyle via
+   * {@link setDebugStyle} instead of mutating the returned object.
+   */
+  getMesh(): THREE.Mesh;
+  /**
+   * Show or hide the WHOLE occluder — the depth-only mesh AND any active debug
+   * skins. Hiding stops the depth mesh writing depth, so a co-located visualizer
+   * (e.g. the occupancy cubes at the same surface) is no longer occluded by the
+   * otherwise-invisible occluder. Independent of {@link setDebugStyle}: a later
+   * `setDebugStyle` re-adds skins as visible, so re-apply `setVisible` after a
+   * style change if you need them hidden (a mesh-view controller does exactly this).
+   */
+  setVisible(visible: boolean): void;
   /**
    * Re-mesh from a fresh occupied-cell snapshot. Pass
    * `grid.getOccupiedCells(occupancy.minConfidence)` so the occluder shares the
@@ -116,7 +153,7 @@ declare class OcclusionMesh {
    *   with `mode: 'smooth'` (otherwise ignored). When omitted under `'smooth'`,
    *   the surface nets falls back to cell centres.
    */
-  update(cells: Iterable<GridCell>, cellSizeM: number, getCellPoint?: (cell: GridCell) => Vector3 | null): void;
+  update(cells: Iterable<GridCell>, cellSizeM: number, getCellPoint?: (cell: GridCell) => Vector3$1 | null): void;
   /**
    * Apply **precomputed** geometry (positions/indices) without meshing — the
    * entry point for the Web Worker offload: the driver posts the occupied-cell
@@ -183,4 +220,4 @@ declare class OcclusionMesh {
   dispose(): void;
 }
 //#endregion
-export { occluderDepthFade as a, buildOccluderDepthShadeSnippet as i, OcclusionMesh as n, occluderFresnelRim as o, OcclusionMeshOptions as r, OCCLUDER_DEPTH_SHADE as t };
+export { OcclusionMeshOptions as a, occluderFresnelRim as c, OcclusionMesh as i, OCCLUDER_DEPTH_SHADE as n, buildOccluderDepthShadeSnippet as o, OccluderDebugStyle as r, occluderDepthFade as s, OCCLUDER_DEBUG_STYLES as t };

package/dist/occupancy-cubes-visualizer-soN0Sizd.d.ts

@@ -0,0 +1,146 @@
+import { t as GridCell } from "./bresenham3d-bt61R-Qa.js";
+import * as THREE from "three";
+
+//#region ../src/visualization/occupancy-cubes-visualizer.d.ts
+/** The read surface of the framework's `OccupancyGrid` this class draws. */
+interface OccupancyGridSource {
+  getOccupiedCells(minObservations?: number): readonly GridCell[];
+  /**
+   * Viewer-local window over the occupied set (Step 2 of the 2026-07-03
+   * long-session fps plan — backed by the grid's chunk index, so the cost is
+   * bounded by the neighbourhood, not the session). Optional so older grid
+   * doubles still satisfy the interface; when present AND a finite pose is
+   * supplied AND `overCapRadiusM` is bounded, `refresh` snapshots through it
+   * instead of the O(total-cells) `getOccupiedCells` walk.
+   */
+  getOccupiedCellsWithin?(centerPos: readonly [number, number, number], radiusM: number, minObservations?: number): readonly GridCell[];
+  getCellCenter(cell: GridCell): readonly [number, number, number];
+  /**
+   * Per-cell average of the EXACT unprojected surface points (follow-up
+   * Item A), or null when unavailable. Optional so older grid doubles still
+   * satisfy the interface; when present, cubes are drawn here (hugging the
+   * real surface) instead of at the lattice `getCellCenter`.
+   */
+  getCellPoint?(cell: GridCell): readonly [number, number, number] | null;
+  /**
+   * Per-cell average camera color (0–255 per channel, Iter 8), or null
+   * when the cell carries no color — the cube then falls back to the
+   * height ramp.
+   */
+  getCellColor(cell: GridCell): readonly [number, number, number] | null;
+}
+/**
+ * Where the viewer is, for viewer-local over-cap cube selection (Issue B
+ * of the 2026-06-22 cube cadence/locality plan). Raw WebXR — the **same
+ * frame** as `getCellPoint`/`getCellCenter`, so distances are computed in
+ * one consistent space with no basis change.
+ */
+interface ViewerPose {
+  /** Camera position [x, y, z], raw WebXR. */
+  readonly cameraPos: readonly [number, number, number];
+  /**
+   * Camera rotation [x, y, z, w], raw WebXR. Carried for the **deferred**
+   * B2 in-front-of-viewer FOV pass; B1 (nearest-N) does not read it.
+   */
+  readonly cameraRot?: readonly [number, number, number, number];
+}
+interface OccupancyCubesVisualizerOptions {
+  /** Maximum rendered cubes (InstancedMesh capacity). Default 2000. */
+  readonly maxInstances?: number;
+  /**
+   * Minimum observation count for a cell to be drawn (noise filter,
+   * forwarded to `getOccupiedCells`). Default 1 — tuned in Iter 6.
+   */
+  readonly minObservations?: number;
+  /**
+   * Rendered edge length of each debug cube in meters. Deliberately
+   * much smaller than the grid cell (0.15 m) so individual voxels stay
+   * readable instead of fusing into a solid wall. Default 0.025
+   * (field-tuned: 0.1 still read as too bulky on device).
+   */
+  readonly cubeSizeM?: number;
+  /**
+   * Random source for the over-cap subset selection. Injected so tests
+   * are deterministic. Default `Math.random`.
+   */
+  readonly rng?: () => number;
+  /**
+   * Radius (meters, raw WebXR) of the viewer-local window used by the
+   * over-cap nearest-N selection (Step 1.1 of the 2026-07-03 long-session
+   * fps plan): cells beyond it are dropped before scoring/sorting, bounding
+   * the per-refresh cost by the neighbourhood instead of the whole session.
+   * At 15 cm voxels and the 2000-instance cap a 10 m sphere is already
+   * generous. Non-finite / non-positive = unbounded (legacy). Default 10.
+   */
+  readonly overCapRadiusM?: number;
+}
+declare class OccupancyCubesVisualizer {
+  private readonly arSpaceNode;
+  private readonly minObservations;
+  private readonly cubeSizeM;
+  private readonly rng;
+  private readonly overCapRadiusM;
+  private readonly mesh;
+  private readonly geometry;
+  private readonly material;
+  private disposed;
+  /**
+   * @param arSpaceNode - the node whose local space is AR-odometry NUE
+   *   and which receives the alignment matrix (`arWorldGroup` live,
+   *   `replaySceneState.arWorldGroup` in replay) — NOT the scene root.
+   */
+  constructor(arSpaceNode: THREE.Object3D, options?: OccupancyCubesVisualizerOptions);
+  /** Number of cubes currently drawn. */
+  getCount(): number;
+  /**
+   * Show or hide the cubes live without discarding them — the cheap
+   * mesh-view toggle (a later `refresh` still repopulates them). Flips the
+   * instanced mesh's `visible` flag; O(1), no re-mesh.
+   */
+  setVisible(visible: boolean): void;
+  /**
+   * Redraw from the grid: every sufficiently-observed cell when under the
+   * instance cap. Over cap, draw the cells **nearest the viewer** when a
+   * `viewerPose` is supplied (Issue B1 — keeps the local neighbourhood
+   * dense instead of a room-wide random scatter); fall back to the legacy
+   * random subset when no pose is given or the pose is non-finite (a
+   * tracking glitch), so older callers and deterministic tests are
+   * unchanged.
+   *
+   * Each chosen cell's draw position is computed exactly once (via
+   * `getCellPoint` ?? `getCellCenter`) and carried through to the draw
+   * loop — the over-cap ranking needs it one step earlier than the legacy
+   * code did.
+   */
+  refresh(grid: OccupancyGridSource, viewerPose?: ViewerPose): void;
+  /** Hide all cubes (e.g. on store swap); the mesh stays in the scene. */
+  clear(): void;
+  /** Remove the mesh from its parent and release GPU resources. */
+  dispose(): void;
+}
+/**
+ * Pick the `count` items nearest `eye`, ranked by squared distance to each
+ * item's draw position. Pure and deterministic: positions come from
+ * `positionOf` (computed exactly once per item) and are carried through on
+ * the result so the draw loop never re-fetches them. Ties keep input order
+ * (stable sort). Exported for the property tests in
+ * `occupancy-cubes-visualizer.property.test.ts`.
+ *
+ * Squared distance is sufficient — `sqrt` is monotonic, so it never changes
+ * the ranking, and skipping it avoids `count` square roots per repaint.
+ *
+ * `maxRadius` (Step 1.1 of the 2026-07-03 long-session fps plan) drops items
+ * farther than that from `eye` BEFORE scoring/sorting, shrinking the sort
+ * from O(N log N) over every cell ever seen to O(K log K) over the local
+ * neighbourhood — the linear-in-session-length term behind the long-walk fps
+ * decline. Behaviour-preserving whenever the count-th nearest item lies
+ * within the radius (property-tested); when fewer than `count` items survive
+ * the filter, only those are returned — distant cubes vanish by design (plan
+ * §Risks). Omitted / non-finite radius = unbounded (legacy behaviour).
+ */
+declare function pickNearestSubset<T>(items: readonly T[], count: number, eye: readonly [number, number, number], positionOf: (item: T) => readonly [number, number, number], maxRadius?: number): Array<{
+  item: T;
+  pos: readonly [number, number, number];
+}>;
+//#endregion
+export { pickNearestSubset as a, ViewerPose as i, OccupancyCubesVisualizerOptions as n, OccupancyGridSource as r, OccupancyCubesVisualizer as t };

package/dist/{occupancy-grid-f0I07UxI.d.ts → occupancy-grid-DKzIdCSZ.d.ts}

@@ -1,5 +1,5 @@
-import { t as GridCell } from "./bresenham3d-D-t9i_b5.js";
-import { a as RgbTuple, i as DepthSample } from "./ar-types-CBafnxhE.js";
+import { t as GridCell } from "./bresenham3d-bt61R-Qa.js";
+import { a as RgbTuple, i as DepthSample } from "./ar-types-BprL3nKv.js";
 import { Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/ar/cell-key.d.ts
@@ -21,10 +21,65 @@ interface OccupancyGridOptions {
    * carving stops, to respect depth noise. Default 2 (Unity parity).
    */
   readonly carveStopCells?: number;
+  /**
+   * Confidence-guarded carving (2026-07-16 synthetic-scene investigation):
+   * when set, a carve ray reaching a cell whose observation count is at or
+   * above this threshold DECAYS the cell (count − 1, measured point/color
+   * means preserved) and stops the trace — an established surface can no
+   * longer be erased by a single deeper reading (silhouette-grazing churn
+   * under a perfect sensor, or a noisy/bled too-far endpoint sweeping
+   * through a confirmed wall into the occluded background), while REPEATED
+   * contradicting rays still drain and eventually delete confidently-wrong
+   * cells (the 2026-07-16-1547 fossilization field regression: a HARD block
+   * made noise meshes immortal — mesh built while the grid was uncertain
+   * could never be un-built by better data). Once below the threshold, the
+   * legacy delete applies. Default undefined = legacy unguarded carving.
+   * Must be a positive safe integer when set.
+   */
+  readonly carveConfidenceThreshold?: number;
 }
+/**
+ * Recommended reconstruction defaults for apps that build AND render an occupancy
+ * mesh (the Recorder, the PhysicsDemo). These are the single framework-level source
+ * of truth so every consumer inherits the same tuning — change them here and both
+ * apps follow.
+ *
+ * They are DELIBERATELY separate from {@link OccupancyGrid}'s constructor fallback
+ * (`cellSizeM ?? 0.15`, Unity parity): that primitive fallback stays 0.15 because a
+ * pile of low-level tests build `new OccupancyGrid()` with no args and assume 0.15
+ * quantization. Both apps always pass an explicit `cellSizeM`, so the app-facing
+ * recommended default and the primitive fallback can differ without conflict.
+ *
+ * Tuning (2026-07-16 EVENING, maintainer's on-device framerate/mesh trade-off
+ * pass — supersedes the same-day corpus-sweep values 0.18/3): voxel 16 cm,
+ * noise floor 2. The sweep's argument for floor 3 (floaters = phantom
+ * colliders: mc 3 ≈ 1.9% vs mc 2 ≈ 3.5%) was measured under LEGACY carving;
+ * with the decay carve guard the floater gap largely disappears (real
+ * pillar-orbit A/B: guarded mc 2 isolates 2.12% vs guarded mc 3 2.19%), so
+ * the faster floor is affordable now. `0.16` stays within
+ * `OCCUPANCY_CONSTRAINTS.cellSizeM.max` (0.20); `2` within `minConfidence`
+ * 1–10. History: 2026-07-16-0557 corpus sweep (0.18/3),
+ * 2026-07-15-1640 device-impression change (0.18/2). See the recorder's
+ * recording-options.ts.md for the full tuning timeline.
+ */
+declare const DEFAULT_OCCUPANCY_CELL_SIZE_M = 0.16;
+/**
+ * Recommended occupancy noise floor — the minimum observation count before a cell
+ * is rendered/meshed (the Recorder's `minConfidence`, the demo's `minObservations`,
+ * and — since the decay guard — both apps' `carveConfidenceThreshold`).
+ * See {@link DEFAULT_OCCUPANCY_CELL_SIZE_M} for the rationale and the tuning note.
+ */
+declare const DEFAULT_OCCUPANCY_MIN_OBSERVATIONS = 2;
 declare class OccupancyGrid {
   readonly cellSizeM: number;
   readonly carveStopCells: number;
+  /**
+   * Carve-blocking observation-count threshold, or undefined for legacy
+   * unguarded carving (see {@link OccupancyGridOptions}). Public + always
+   * present on instances so consumers built against a newer source can
+   * feature-detect the guard on an installed build at runtime.
+   */
+  readonly carveConfidenceThreshold: number | undefined;
   private readonly cells;
   /**
    * Chunk index (Step 2 of the 2026-07-03 long-session fps plan): cell keys
@@ -51,7 +106,7 @@ declare class OccupancyGrid {
    * an already-settled cell (count `> MAX_RELEVANT_COUNT`) does NOT bump it, so a
    * consumer can cheaply skip a full re-derive (cube refresh / occluder re-mesh)
    * when the revision is unchanged — the dominant idle-time saving over a long
-   * session (see `2026-06-30-occluder-tuning-followups.md`).
+   * session (see `2026-06-30-0829-occluder-tuning-followups.md`).
    */
   private revision;
   /**
@@ -180,8 +235,63 @@ declare class OccupancyGrid {
    * steps before the endpoint. The endpoint cell itself is additionally
    * protected so a current observation is never erased (relevant for
    * carveStopCells = 0 and for the unconditional start-cell visit).
+   *
+   * With `carveConfidenceThreshold` set, the trace additionally stops at the
+   * first cell whose count has reached the threshold, DECAYING it by one
+   * observation (means preserved) — soft contradiction instead of deletion,
+   * so nothing behind an established surface is carved but repeated
+   * contradictions still un-build it (see the option docs). Note this makes
+   * a repeated identical carve NOT a no-op — the per-sample unique-endpoint
+   * dedupe in `addSample` is therefore semantically load-bearing under the
+   * guard (one decay per contradicting ray per sample).
+   *
+   * PERFORMANCE — fused walk (2026-07-17 perf loop, iteration 1): this is
+   * the framework's hottest non-render loop (hundreds of rays per depth
+   * sample at the 200 ms reconstruction cadence), and the generic
+   * `bresenham3d(callback)` shape dominated the fold profile: a fresh
+   * `[x, y, z]` tuple + callback dispatch + full `cellKey` repack +
+   * `cellsEqual` per visited cell. The Bresenham walk (identical integer
+   * stepping, `bresenham3d` stays the reference — see the fold-oracle
+   * property test) is therefore fused in here with two key tricks:
+   *
+   * - The packed cell key is maintained INCREMENTALLY: stepping one cell
+   *   along an axis moves the key by that axis' constant field stride
+   *   (base-2^17 positional packing), replacing the 3-term repack.
+   * - The endpoint guard compares packed keys (`key === endpointKey`).
+   *   Every walked cell lies inside the camera→point AABB whose corners the
+   *   caller range-checked, so packing is bijective on the whole walk and
+   *   the compare is exactly `cellsEqual` — and key aliasing is impossible.
+   *
+   * The cell tuple is materialized only on an actual delete/decay hit (rare
+   * per trace, handled in {@link carveCellAt}). Measured on the
+   * occupancy-fold bench (devbox-win11, Node 24, 50 samples × 576 pts,
+   * production config): 37.05 → 25.71 ms median of 5, −30.6%.
+   * Input safety: cameraCell/pointCell are integer cells from
+   * `cellForPosition` (finite-checked upstream) and both range-checked by
+   * `addSample`, so dm ≤ 2·CELL_KEY_LIMIT « MAX_TRACE_STEPS and the generic
+   * tracer's integer/span guards are structurally satisfied here.
    */
   private carve;
+  /**
+   * Per-cell action of the fused carve walk (extracted so both it and the
+   * walk stay under the lint complexity budget; a monomorphic private-method
+   * call per visited cell measured within noise of the fully-inlined form).
+   *
+   * @returns `false` when the trace must stop: the cell is an established
+   *   surface (count ≥ threshold) that was decayed instead of deleted.
+   */
+  private carveCellAt;
+  /**
+   * Soft contradiction of an established cell (confidence-guarded carving):
+   * remove one observation while preserving the measured point/color MEANS
+   * (sums are scaled with the count — decrementing the divisor alone would
+   * silently shift `getCellPoint`/`getCellColor`). Deletes outright when the
+   * count would reach 0 (threshold 1). Bumps revisions like any mutation
+   * that can change a consumer's occupied set (counts above
+   * MAX_RELEVANT_COUNT cannot cross any selectable floor, so those decays
+   * stay revision-silent).
+   */
+  private decayCell;
   /** Add a newly-occupied cell to its chunk's index set. */
   private indexCell;
   /** Remove a carved cell from its chunk (dropping an emptied chunk set). */
@@ -191,4 +301,4 @@ declare class OccupancyGrid {
   private increment;
 }
 //#endregion
-export { unpackCellKey as i, OccupancyGridOptions as n, cellKey as r, OccupancyGrid as t };
+export { cellKey as a, OccupancyGridOptions as i, DEFAULT_OCCUPANCY_MIN_OBSERVATIONS as n, unpackCellKey as o, OccupancyGrid as r, DEFAULT_OCCUPANCY_CELL_SIZE_M as t };

package/dist/{occupancy-mesher-BqnRd10x.d.ts → occupancy-mesher-Co80tOpl.d.ts}

@@ -1,4 +1,4 @@
-import { t as GridCell } from "./bresenham3d-D-t9i_b5.js";
+import { t as GridCell } from "./bresenham3d-bt61R-Qa.js";
 import { Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/ar/occupancy-mesher.d.ts
@@ -75,6 +75,27 @@ interface MeshOccupiedCellsOptions {
    * retain the tuple (no caching it as a key, no async use). Copy it if needed.
    */
   readonly getCellPoint?: (cell: GridCell) => Vector3 | null;
+  /**
+   * Pre-packed per-cell centroids for `'smooth'`, aligned with the **input
+   * `cells` order** (3 numbers per input cell; a non-finite triple — the
+   * worker wire protocol packs NaN for "no centroid" — falls back to that
+   * cell's geometric centre, exactly like a null/non-finite `getCellPoint`
+   * result). This is the mesh-worker fast path (2026-07-17 perf loop,
+   * iteration 2): `runMeshRequest` receives exactly this array over the wire,
+   * so consuming it directly deletes the per-cell key-map + callback + tuple
+   * plumbing from the hottest re-mesh loop. When set, `'smooth'` ignores
+   * `getCellPoint`; other modes ignore `centroids` entirely (`'corner-fit'`
+   * still needs the callback).
+   */
+  readonly centroids?: Float64Array | null;
+  /**
+   * Set `false` to skip building the per-cell AABB list (`result.aabbs` is
+   * then empty). The occlusion-mesh worker path consumes only
+   * positions/indices, and at the ~100k-cell regime the discarded AABB
+   * objects (~2 allocations per cell, every re-mesh) were pure GC pressure
+   * (2026-07-17 perf loop, iteration 2). Default `true`.
+   */
+  readonly includeAabbs?: boolean;
 }
 /**
  * Mesh a snapshot of occupied cells into a face-culled surface + AABB list.