@driftengine/capture 4.0.0

package/src/gaussians/rasterise.ts

@@ -0,0 +1,81 @@
+/**
+ * A cloud of Gaussians drawn on the CPU: `project.ts`'s ellipses, composited nearest first.
+ *
+ * **It exists to be differentiated**, which is what separates it from the shader that draws splats
+ * in a game. A reference rasteriser is how the gradients in `gradients.ts` are checked — a central
+ * difference of this against the analytic answer — and how a fitted cloud is compared with the
+ * frames it was fitted to. It is thousands of times slower than the shader, and per-frame rules
+ * about allocation do not reach it.
+ */
+import { exactExp } from '@driftengine/core';
+
+import { cameraCentre, sh1Basis, splatColour, viewDirection } from './harmonics.ts';
+import {
+  visibleGaussians,
+  type GaussianSet,
+  type Projected,
+  type RasterCamera,
+} from './project.ts';
+
+/**
+ * A frame this rasteriser writes: **single precision where it stands in for a render target, double
+ * where the caller is differentiating through it.** The fitting loop accumulates its loss in double
+ * and a frame quantised to single is a floor under every difference taken through one — measured at
+ * about a part in five hundred of the slope, against a part in ten million when the frame is double.
+ */
+export type Frame = Float32Array | Float64Array;
+
+/** Below this the Gaussian contributes nothing worth compositing. */
+const FAINT = 1 / 255 / 4;
+
+/**
+ * `set` through `camera` into `out`, four floats a pixel: linear colour, premultiplied as it
+ * composites, and the alpha the cloud covered the pixel with.
+ */
+export function rasteriseGaussians(set: GaussianSet, camera: RasterCamera, out: Frame): void {
+  const { width, height } = camera;
+  out.fill(0);
+  const transmittance = new Float64Array(width * height).fill(1);
+  const { order, projected } = visibleGaussians(set, camera);
+  /* A Gaussian's colour is a function of where it is seen from, so it is resolved once a frame. */
+  const eye = new Float64Array(3);
+  cameraCentre(camera.worldToCamera, eye);
+  const direction = new Float64Array(3);
+  const basis = new Float64Array(3);
+  const colour = new Float64Array(3);
+  for (const at of order) {
+    const one = projected[at] as Projected;
+    viewDirection(set.positions, at, eye, direction);
+    sh1Basis(direction, basis);
+    splatColour(set.colors, set.sh1, at, basis, colour);
+    const determinant = one.a * one.d - one.b * one.b;
+    const inverse = [one.d / determinant, -one.b / determinant, one.a / determinant];
+    const left = Math.max(0, Math.floor(one.x - one.radius));
+    const right = Math.min(width - 1, Math.ceil(one.x + one.radius));
+    const top = Math.max(0, Math.floor(one.y - one.radius));
+    const bottom = Math.min(height - 1, Math.ceil(one.y + one.radius));
+    const opacity = set.opacities[at] as number;
+    for (let y = top; y <= bottom; y += 1) {
+      for (let x = left; x <= right; x += 1) {
+        const dx = x + 0.5 - one.x;
+        const dy = y + 0.5 - one.y;
+        const power =
+          -0.5 *
+          ((inverse[0] as number) * dx * dx +
+            2 * (inverse[1] as number) * dx * dy +
+            (inverse[2] as number) * dy * dy);
+        /* The inverse of a positive definite covariance is positive definite, so `power` is at
+           most zero and the exponential at most one: there is nothing to guard against here. */
+        const alpha = opacity * exactExp(power);
+        if (alpha < FAINT) continue;
+        const pixel = y * width + x;
+        const share = alpha * (transmittance[pixel] as number);
+        for (let c = 0; c < 3; c += 1) {
+          out[pixel * 4 + c] = (out[pixel * 4 + c] as number) + share * (colour[c] as number);
+        }
+        out[pixel * 4 + 3] = (out[pixel * 4 + 3] as number) + share;
+        transmittance[pixel] = (transmittance[pixel] as number) * (1 - alpha);
+      }
+    }
+  }
+}

package/src/gaussians/refine.ts

@@ -0,0 +1,176 @@
+/**
+ * Where the cloud grows and where it is thrown away: densification and pruning, as one plan.
+ *
+ * **A fit that only moves the Gaussians it started with cannot see detail its seeds did not.** The
+ * seeds come from a sparse reconstruction — a few hundred corners — and a room has more surface
+ * than that. So the busiest Gaussians are made into two: a small one is **cloned**, which puts a
+ * second Gaussian where one was not enough, and a large one is **split**, which replaces a blur
+ * covering several surfaces with two that can each take one. The reference implementation decides
+ * between the two by the same test.
+ *
+ * **Busiest by rank rather than by a threshold.** The reference compares an accumulated screen-space
+ * gradient against 0.0002, a number in units of that implementation's own normalisation, and a
+ * number in units nobody can check is a number nobody can tune. This takes a fixed fraction of the
+ * cloud — the most-moved fifth — which says the same thing scale-free: *these are the Gaussians the
+ * frames keep pulling on.* What it gives up is the reference's property that a converged fit stops
+ * growing on its own; the budget is what stops it here, and the pruning below is what keeps the
+ * budget spent on Gaussians that are doing something.
+ *
+ * **Pruning is by opacity, and it happens first.** A Gaussian the fit has faded to nothing is
+ * carrying a slot and contributing less light than a pixel can hold.
+ */
+import { exactExp, exactLog } from '@driftengine/core';
+
+import { gather, type Family } from './adam.ts';
+import { rotationFromQuaternion } from './project.ts';
+
+/** Below this a Gaussian contributes less than a quarter of one value of an eight-bit channel. */
+export const FADED = 1 / 255 / 4;
+
+/** How much of the cloud is made into two, where there is room. */
+const BUSIEST = 0.2;
+
+/** A split halves what it divides, near enough: the reference's own divisor. */
+const SPLIT_SHRINK = 1.6;
+
+export interface RefineOptions {
+  /** The most Gaussians the cloud may hold. */
+  readonly budget: number;
+  /** A Gaussian wider than this is split rather than cloned, in metres. */
+  readonly splitAbove: number;
+  readonly random: () => number;
+}
+
+/** Everything the plan rewrites, in one place. */
+export interface RefineCloud {
+  count: number;
+  readonly families: readonly Family[];
+  readonly positions: Family;
+  readonly logScales: Family;
+  readonly rotations: Family;
+  readonly opacities: Float64Array;
+  /** How hard the frames have pulled on each Gaussian since the last refinement. */
+  readonly motion: Float64Array;
+  readonly sources: Int32Array;
+  /** Where each of today's Gaussians ended up after a prune, so a split can find its own half. */
+  readonly reverse: Int32Array;
+  readonly fresh: Uint8Array;
+  readonly scratch: Float64Array;
+}
+
+/**
+ * Prune, then grow, then rewrite every family; answers the new count.
+ *
+ * The cloud's own arrays are rewritten in place through its scratch, so nothing is reallocated and
+ * the caller's view of it stays valid. **The materialised scales and opacities are not**: a slot
+ * that has just been split holds the logarithm it was given and the metres of whatever stood there
+ * before, so the caller materialises again before drawing. The fit does that at the top of every
+ * step, which is why this does not do it twice.
+ */
+export function refineCloud(cloud: RefineCloud, options: RefineOptions): number {
+  const { budget, splitAbove, random } = options;
+  const { sources, fresh, motion } = cloud;
+
+  /* Everything still worth drawing, in order, with its history intact. */
+  const { reverse } = cloud;
+  let kept = 0;
+  for (let at = 0; at < cloud.count; at += 1) {
+    reverse[at] = -1;
+    if ((cloud.opacities[at] as number) < FADED) continue;
+    reverse[at] = kept;
+    sources[kept] = at;
+    fresh[kept] = 0;
+    kept += 1;
+  }
+  /* A prune that emptied the cloud would leave the fit nothing to descend, so it is refused. */
+  if (kept === 0) return cloud.count;
+
+  /* The busiest fifth of what is left, most-pulled first, as far as the budget allows. */
+  const order = Array.from({ length: kept }, (_, slot) => slot);
+  order.sort((a, b) => {
+    const first = motion[sources[a] as number] as number;
+    const second = motion[sources[b] as number] as number;
+    return first === second ? (sources[a] as number) - (sources[b] as number) : second - first;
+  });
+  /*
+   * At least one where there is room and something is pulling, because a fifth of a small cloud
+   * rounds to none — and a cloud of four that can never grow however long it is fitted is a cliff
+   * nobody would look for.
+   */
+  const room = budget - kept;
+  const share = Math.floor(kept * BUSIEST);
+  const wanted = Math.min(room, share > 1 ? share : 1);
+  let total = kept;
+  const rotation = new Float64Array(9);
+  for (let taken = 0; taken < wanted; taken += 1) {
+    const slot = order[taken] as number;
+    const from = sources[slot] as number;
+    if (!((motion[from] as number) > 0)) break;
+    sources[total] = from;
+    fresh[total] = 1;
+    total += 1;
+  }
+
+  gather(cloud.families, sources, fresh, total, cloud.scratch);
+
+  /*
+   * Now the two halves are told apart. A clone is left where it was — its own gradient is what
+   * separates it, and its Adam state is empty where its parent's is not. A split is shrunk and both
+   * halves are moved, because two Gaussians of the parent's size in the parent's place are one
+   * blur drawn twice.
+   */
+  for (let slot = kept; slot < total; slot += 1) {
+    const parent = sources[slot] as number;
+    let widest = 0;
+    for (let c = 0; c < 3; c += 1) {
+      const scale = exactExp(cloud.logScales.values[slot * 3 + c] as number);
+      widest = scale > widest ? scale : widest;
+    }
+    if (widest <= splitAbove) continue;
+    rotationFromQuaternion(cloud.rotations.values, slot, rotation);
+    shrinkAndDisplace(cloud, slot, rotation, random);
+    shrinkAndDisplace(cloud, reverse[parent] as number, rotation, random);
+  }
+  cloud.count = total;
+  motion.fill(0);
+  return total;
+}
+
+/** One half of a split: smaller than what it came from, and somewhere inside it. */
+function shrinkAndDisplace(
+  cloud: RefineCloud,
+  slot: number,
+  rotation: Float64Array,
+  random: () => number,
+): void {
+  if (slot < 0) return;
+  displace(cloud, slot, rotation, random);
+  for (let c = 0; c < 3; c += 1) {
+    cloud.logScales.values[slot * 3 + c] =
+      (cloud.logScales.values[slot * 3 + c] as number) - exactLog(SPLIT_SHRINK);
+  }
+}
+
+/** One sample from a Gaussian's own shape, added to where it stands. */
+function displace(
+  cloud: RefineCloud,
+  slot: number,
+  rotation: Float64Array,
+  random: () => number,
+): void {
+  /*
+   * A sum of three uniforms either side of zero rather than a normal deviate: the fit only needs
+   * two halves to land somewhere inside the shape they came from, and a Box–Muller transform would
+   * want a logarithm and a cosine for no gain the picture can show.
+   */
+  const local = [0, 0, 0];
+  for (let c = 0; c < 3; c += 1) {
+    const spread = random() + random() + random() - 1.5;
+    local[c] = spread * exactExp(cloud.logScales.values[slot * 3 + c] as number);
+  }
+  for (let r = 0; r < 3; r += 1) {
+    let sum = 0;
+    for (let c = 0; c < 3; c += 1) sum += (rotation[r * 3 + c] as number) * (local[c] as number);
+    cloud.positions.values[slot * 3 + r] = (cloud.positions.values[slot * 3 + r] as number) + sum;
+  }
+}

package/src/gaussians/similarity.ts

@@ -0,0 +1,87 @@
+/**
+ * How alike two pictures are, structure included.
+ *
+ * **A squared difference is not a likeness.** It is what the fit descends, because it has a
+ * gradient, and it is the wrong thing to judge the result by: a cloud that is uniformly a little
+ * dark scores badly on it and looks right, and one that is right on average with the structure
+ * smeared away scores well and looks wrong. Structural similarity compares local means, variances
+ * and covariance, so it answers the question a reader actually asks of a capture.
+ *
+ * **Uniform windows rather than a Gaussian one.** The original weights each window by an 11 × 11
+ * Gaussian; this walks 8 × 8 blocks with equal weight, which is the same three terms over a
+ * different support and is what every fast implementation does. What it gives up is comparability
+ * with a number quoted from the paper — so a floor here is measured against this implementation
+ * and not lifted from one written elsewhere.
+ */
+
+/** The side of the block the three statistics are taken over. */
+export const SIMILARITY_WINDOW = 8;
+
+/*
+ * The stabilisers, for values on 0 to 1. They keep a window where both pictures are flat from
+ * dividing zero by zero, and they are the reason two dark patches are not declared identical on
+ * the strength of a rounding difference.
+ */
+const C1 = 0.01 * 0.01;
+const C2 = 0.03 * 0.03;
+
+/**
+ * The mean structural similarity of `a` and `b`, one value a pixel, over every window.
+ *
+ * A picture narrower or shorter than a window is compared as one window rather than refused: it
+ * has a mean and a variance like any other, and the alternative is a measure that cannot answer
+ * for a thumbnail.
+ */
+export function structuralSimilarity(
+  a: ArrayLike<number>,
+  b: ArrayLike<number>,
+  width: number,
+  height: number,
+): number {
+  let total = 0;
+  let windows = 0;
+  for (let top = 0; top < height; top += SIMILARITY_WINDOW) {
+    for (let left = 0; left < width; left += SIMILARITY_WINDOW) {
+      const right = Math.min(width, left + SIMILARITY_WINDOW);
+      const bottom = Math.min(height, top + SIMILARITY_WINDOW);
+      const pixels = (right - left) * (bottom - top);
+      if (pixels === 0) continue;
+      let sumA = 0;
+      let sumB = 0;
+      for (let y = top; y < bottom; y += 1) {
+        for (let x = left; x < right; x += 1) {
+          sumA += a[y * width + x] as number;
+          sumB += b[y * width + x] as number;
+        }
+      }
+      const meanA = sumA / pixels;
+      const meanB = sumB / pixels;
+      let varianceA = 0;
+      let varianceB = 0;
+      let covariance = 0;
+      for (let y = top; y < bottom; y += 1) {
+        for (let x = left; x < right; x += 1) {
+          const offA = (a[y * width + x] as number) - meanA;
+          const offB = (b[y * width + x] as number) - meanB;
+          varianceA += offA * offA;
+          varianceB += offB * offB;
+          covariance += offA * offB;
+        }
+      }
+      /*
+       * Divided by n − 1 where there is more than one pixel, which is the unbiased estimate the
+       * original uses. A single-pixel window has no spread to estimate and is compared by its
+       * means alone.
+       */
+      const spread = pixels > 1 ? pixels - 1 : 1;
+      varianceA /= spread;
+      varianceB /= spread;
+      covariance /= spread;
+      const luminance = (2 * meanA * meanB + C1) / (meanA * meanA + meanB * meanB + C1);
+      const structure = (2 * covariance + C2) / (varianceA + varianceB + C2);
+      total += luminance * structure;
+      windows += 1;
+    }
+  }
+  return windows === 0 ? 1 : total / windows;
+}

package/src/index.ts

@@ -0,0 +1,225 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/**
+ * `@driftengine/capture` — a video to a playable scene, on the player's own device.
+ *
+ * **What is here so far is the models a capture runs**, each written as a definition the engine's
+ * one neural runtime builds a graph from: `@driftengine/texture` holds the operators and the rule
+ * that every weight is read or set aside by name, and this package says which weights a model reads
+ * and how. A definition is run over a checkpoint once, when it is converted, and over the converted
+ * file afterwards whenever a clip needs the graph at a new size — every device kernel bakes its
+ * shapes, and a clip's aspect ratio decides the patch grid.
+ *
+ * **Depth Anything 3**: depth, its confidence and a camera per view, from one view or several at
+ * once. **Depth Anything V2 Small**, the lighter fallback: relative depth from one view.
+ * **MobileSAM**: masks from a point or a box, an encoder run once an image and a decoder once a
+ * prompt. **SAM 2.1**: the same, and objects tracked through a video by a memory of the frames before.
+ * **OWLv2**: boxes for things named in words, an image graph and a text graph joined on the host,
+ * with CLIP's tokenizer. Each answers as its upstream's own code does on a seeded miniature of its
+ * layout, the fixtures shipped beside them.
+ */
+export { eachFrame, selectFrames } from './frames.ts';
+export type { FrameChoice, FrameSize, FrameSource } from './frames.ts';
+export {
+  cholesky,
+  choleskySolve,
+  levenbergMarquardt,
+  svd3,
+  svdN,
+  symmetricEigen,
+} from './math/dense.ts';
+export type { FitOptions, LeastSquares } from './math/dense.ts';
+export { schurSolve } from './math/schur.ts';
+export type { BlockNormals } from './math/schur.ts';
+export {
+  DESCRIPTOR_BYTES,
+  createFeatureSet,
+  describeFeatures,
+  detectFeatures,
+  matchFeatures,
+} from './features.ts';
+export type { Descriptors, FeatureSet } from './features.ts';
+export { estimatePoses } from './poses.ts';
+export type { CaptureFrame, PoseOptions, PoseResult } from './poses.ts';
+export { relativePose, triangulate } from './twoView.ts';
+export type { RelativePoseOut, RelativePoseResult } from './twoView.ts';
+export { lookAt, renderTestScene } from './testScene.ts';
+export type { TestBox, TestCamera, TestPlane, TestScene } from './testScene.ts';
+export { createDepthEstimator } from './depth.ts';
+export type { DepthEstimate, DepthEstimator, DepthView, RawFrame } from './depth.ts';
+export type { GraphRun } from './run.ts';
+export {
+  DEPTH_PIXEL_MEAN,
+  DEPTH_PIXEL_STD,
+  longestSideSize,
+  prepareDepthFrame,
+  prepareOwlv2Frame,
+  prepareSam2Frame,
+  prepareSamFrame,
+} from './prepare.ts';
+export type { PreparedFrame } from './prepare.ts';
+export { areaResize, triangleResize, PILLOW_PRECISION, TORCHVISION_PRECISION } from './resample.ts';
+export { browserFrameSource } from './browserFrames.ts';
+export type { BrowserClip } from './browserFrames.ts';
+export {
+  DEPTH_ANYTHING_3,
+  decodeCamera,
+  decodeDepth,
+  depthAnything3,
+} from './models/depthAnything3.ts';
+export type { DepthAnything3Config } from './models/depthAnything3.ts';
+export { DEPTH_ANYTHING_2_SMALL, depthAnything2 } from './models/depthAnything2.ts';
+export type { DepthAnything2Config } from './models/depthAnything2.ts';
+export type { HeadConfig } from './models/dualDpt.ts';
+export type { VitConfig } from './models/vit.ts';
+export {
+  MINIATURE_CASES,
+  MINIATURE_DEPTH_ANYTHING_2,
+  MINIATURE_DEPTH_ANYTHING_3,
+  MINIATURE_SEED,
+  miniatureCheckpoint,
+  miniatureCheckpoint2,
+  miniatureImages,
+} from './models/miniature.ts';
+export {
+  MOBILE_SAM,
+  SAM_PIXEL_MEAN,
+  SAM_PIXEL_STD,
+  mobileSamDecoder,
+  mobileSamEncoder,
+  samMasksToImage,
+} from './models/mobileSam.ts';
+export type { MobileSamConfig } from './models/mobileSam.ts';
+export type { SamDecoderConfig } from './models/samDecoder.ts';
+export {
+  SAM2_PROMPT,
+  SAM2_VIDEO_PROMPT,
+  SAM_PROMPT,
+  samGridPositions,
+  samInputSize,
+  samPromptTokens,
+  samTokenCount,
+  stabilityScore,
+} from './models/samPrompt.ts';
+export type { SamPrompt, SamPromptLayout } from './models/samPrompt.ts';
+export {
+  MINIATURE_MOBILE_SAM,
+  MINIATURE_SAM_IMAGE,
+  MINIATURE_SAM_PROMPTS,
+  miniatureSamCheckpoint,
+} from './models/samMiniature.ts';
+export type { TinyVitConfig } from './models/tinyVit.ts';
+export { SAM_21_TINY, sam21Decoder, sam21Encoder } from './models/sam21.ts';
+export type { Sam21Config, Sam21MemoryConfig } from './models/sam21.ts';
+export {
+  sam21MasksToImage,
+  sam21MemoryAttention,
+  sam21MemoryEncoder,
+  sam21Upscale,
+} from './models/sam21Video.ts';
+export { Sam21Tracker } from './models/sam2Tracker.ts';
+export type { Sam21Frame, Sam21Video, Sam21Weights } from './models/sam2Tracker.ts';
+export type { HieraConfig } from './models/hiera.ts';
+export {
+  MINIATURE_SAM_21,
+  MINIATURE_SAM_21_IMAGE,
+  MINIATURE_SAM_21_PROMPTS,
+  miniatureSam21Checkpoint,
+} from './models/sam21Miniature.ts';
+export {
+  OWLV2_BASE,
+  OWLV2_PIXEL_MEAN,
+  OWLV2_PIXEL_STD,
+  owlv2BoxBias,
+  owlv2Image,
+  owlv2Text,
+} from './models/owlv2.ts';
+export type { Owlv2Config } from './models/owlv2.ts';
+export type { ClipTowerConfig } from './models/clipTower.ts';
+export { owlv2Detections, owlv2Logits } from './models/owlv2Detect.ts';
+export type { Owlv2Detection, Owlv2Patches } from './models/owlv2Detect.ts';
+export { clipTokenizer, owlv2Tokens } from './models/clipTokenizer.ts';
+export type { ClipTokenizer } from './models/clipTokenizer.ts';
+export {
+  MINIATURE_OWLV2,
+  MINIATURE_OWLV2_IMAGE,
+  MINIATURE_OWLV2_MERGES,
+  MINIATURE_OWLV2_QUERIES,
+  miniatureOwlv2Checkpoint,
+} from './models/owlv2Miniature.ts';
+/*
+ * **Gaussians.** A reference rasteriser that projects the way `@driftengine/splats`' shader does,
+ * its analytic gradients, and the fit that descends them into a `SplatSource` the engine draws.
+ * `optimiseGaussians` is what a caller wants; the rest is exported because a caller measuring or
+ * extending a fit needs the same pieces the fit is built from.
+ */
+export { optimiseGaussians } from './gaussians/optimise.ts';
+export type { OptimiseOptions } from './gaussians/optimise.ts';
+export { projectGaussian, visibleGaussians, LOW_PASS, REACH } from './gaussians/project.ts';
+export type { GaussianSet, Projected, RasterCamera } from './gaussians/project.ts';
+export { rasteriseGaussians } from './gaussians/rasterise.ts';
+export type { Frame } from './gaussians/rasterise.ts';
+export { accumulateGradients, createGradients, imageLoss } from './gaussians/gradients.ts';
+export type { GaussianGradients } from './gaussians/gradients.ts';
+export { sh1Basis, splatColour, SH1_COEFFICIENTS, SH_C1 } from './gaussians/harmonics.ts';
+export { structuralSimilarity, SIMILARITY_WINDOW } from './gaussians/similarity.ts';
+/*
+ * **Splats to a surface.** A cloud's depth, many views of it fused into one volume, that volume's
+ * crossing as a mesh facing outwards, and the mesh brought down to a budget — which is what a game
+ * stands on, rather than the cloud, which only draws.
+ */
+export { renderDepth } from './gaussians/depth.ts';
+export { createVolume, fuseDepth } from './fusion.ts';
+export type { FuseOptions, SurfaceView, Volume } from './fusion.ts';
+export { marchVolume } from './marching.ts';
+export type { MarchOptions } from './marching.ts';
+export { decimate } from './decimate.ts';
+export type { DecimateOptions } from './decimate.ts';
+/*
+ * **A surface to stand on.** The drawn mesh cleaned for collision, and a prop's convex hulls inside
+ * the container's own caps — which is where a capture stops being a picture.
+ */
+export { collisionMesh, propHulls } from './collide.ts';
+export type { CollisionOptions, CollisionSource, PropHulls } from './collide.ts';
+/*
+ * **A surface's material, separated from the light it was photographed under.** Multi-view inverse
+ * rendering with a classical separation: what stays the same across views is the material, what
+ * moves is the light, and a chromaticity that holds across an intensity jump is a shadow. Every
+ * surface gets a confidence, and `delight.ts` states plainly what that confidence does and does not
+ * grade. `renderLit` is the lit fixture the measurements are made against.
+ */
+export { createDelightOut, delight } from './delight.ts';
+export type { DelightOptions, DelightOut, DelightView } from './delight.ts';
+export { interpolate, nearestHit, renderLit } from './delightScene.ts';
+export type { Light, LitScene, MeshHit } from './delightScene.ts';
+/*
+ * **A mesh cut into regions, and each region proposed as something a scene could hold.** Stage four
+ * and labelled as such: with a model loaded the masks are voted onto the mesh, and with none the
+ * geometry answers on its own. Nothing here decides what an object *is* — a region nobody labelled
+ * comes back as scenery, which is drawn, solid, and doing nothing.
+ */
+export { segmentGeometry } from './segment.ts';
+export type { Region, SegmentOptions } from './segment.ts';
+export { labelMasks, liftMasks, promptGrid } from './masks.ts';
+export type { MaskView } from './masks.ts';
+export {
+  MOVABLE_COMPONENTS,
+  SCENERY_COMPONENTS,
+  WALKABLE_COMPONENTS,
+  proposeEntities,
+} from './propose.ts';
+export type { EntityProposal, ProposeOptions } from './propose.ts';
+/*
+ * **Every stage in one file.** A capture that arrives as six files is a capture somebody has to
+ * reassemble; this writes the mesh, its materials and decode program, the cloud, a prop's hulls,
+ * the way across the scene and the proposals into one `.drft`. The proposals travel under a
+ * component this package declares — a capture proposes in its own words, and what a scene ends up
+ * holding is the consumer's decision.
+ */
+export {
+  PROPOSAL_COMPONENT,
+  PROPOSAL_SCHEMA,
+  captureFile,
+  proposalScene,
+  readProposals,
+} from './scene.ts';
+export type { CaptureScene } from './scene.ts';