@marble.fun/track-catalog 3.0.0

package/src/pages/play/race/track-appearance-stone-block-shell.ts

@@ -0,0 +1,517 @@
+import * as THREE from 'three'
+
+import {
+  isSharedStoneTrackShellAppearance,
+  isSharedStoneTrackShellDefaultTheme,
+  SHARED_STONE_TRACK_SHELL_THEME_IDS,
+} from '../../../three/stone-track-shell-appearance'
+import { TRACK_RAIL_WALL_THICKNESS } from './track-definition'
+import {
+  canonicalConvergentConnectedTerminalClosures,
+  canonicalWallFrameAt,
+  type CanonicalWallFrame,
+  type CanonicalWallRun,
+} from './track-surface-topology'
+
+export const STONE_TRACK_SHELL_TARGET_PITCH = 1.12
+export const STONE_TRACK_SHELL_COURSE_COUNT = 5
+export const STONE_TRACK_SHELL_MORTAR_GAP = 0.018
+export const STONE_TRACK_SHELL_BLOCK_DEPTH = 0.38
+export const STONE_TRACK_SHELL_CAP_HEIGHT = 0.21
+export const STONE_TRACK_SHELL_CAP_DEPTH = 0.52
+// Canonical connectors already share one exact docking plane. Extending both
+// neighboring brick halves through it creates double-owned coplanar faces and
+// visible interpenetration, especially under grazing light.
+export const STONE_TRACK_SHELL_CONNECTOR_OVERLAP = 0
+// Underlap the canonical floor far enough to cover the per-brick depth
+// variation. Centering the masonry outside the
+// old 20 cm guard left a real dark channel between these two visual shells.
+export const STONE_TRACK_SHELL_FLOOR_UNDERLAP = 0.08
+export const STONE_TRACK_SHELL_PREVIEW_OUTWARD_OFFSET =
+  STONE_TRACK_SHELL_BLOCK_DEPTH * 0.5 - STONE_TRACK_SHELL_FLOOR_UNDERLAP
+
+// One rectangular ring per end; curved bricks retain a midpoint for their silhouette.
+const MAX_SWEEP_SAMPLE_SPACING = 0.75
+
+export interface StoneTrackShellMaterials {
+  wall: THREE.Material
+  floor: THREE.Material
+}
+
+export interface StoneTrackShellOptions {
+  themeId: string
+  connectionPhase?: number | readonly number[]
+  deferGeometry?: boolean
+}
+
+interface StoneSegment {
+  start: number
+  end: number
+  metricLength: number
+  closeStart: boolean
+  closeEnd: boolean
+}
+
+interface GeometryAccumulator {
+  positions: number[]
+  uvs: number[]
+  metricUvs: number[]
+  moduleCount: number
+  maxModuleLength: number
+}
+
+interface SweptBlockOptions {
+  start: number
+  end: number
+  metricLength: number
+  depth: number
+  height: number
+  verticalOffset: number
+  outwardOffset: number
+  uvPhase: readonly [number, number]
+  /** Distance already consumed by this brick before the current piece begins. */
+  uvLongitudinalStart: number
+  closeStart: boolean
+  closeEnd: boolean
+}
+
+type WallFrameSampler = (distance: number) => CanonicalWallFrame
+
+function masonryUvPhase(runIndex: number, course: number, segmentIndex: number, cap: boolean): [number, number] {
+  let seed = Math.imul(course + 1, 0x45d9f3b)
+  seed ^= Math.imul(segmentIndex + 1, 0x119de1f3)
+  seed ^= Math.imul(runIndex + 2, 0x3449f)
+  if (cap) seed ^= 0x27d4eb2d
+  seed ^= seed >>> 16
+  seed = Math.imul(seed, 0x7feb352d)
+  seed ^= seed >>> 15
+  seed = Math.imul(seed, 0x846ca68b)
+  seed ^= seed >>> 16
+  const unsigned = seed >>> 0
+  // The preview divides geometry UVs by 1.6 and then applies a 0.9 texture
+  // repeat. Production's metric shader uses a 1.6/0.9 world size, so storing
+  // preview phases in 1.6-world-unit space reproduces the exact transform.
+  return [((unsigned & 0xffff) / 0x10000) * 1.6, ((unsigned >>> 16) / 0x10000) * 1.6]
+}
+
+function positiveModulo(value: number, divisor: number): number {
+  return ((value % divisor) + divisor) % divisor
+}
+
+function courseSegments(
+  run: CanonicalWallRun,
+  course: number,
+  connectionPhase: number,
+  closeStart = false,
+  closeEnd = false,
+): StoneSegment[] {
+  if (run.length <= 0.001) return []
+  const offset = course % 2 === 0 ? 0 : STONE_TRACK_SHELL_TARGET_PITCH * 0.5
+  const boundaries = [0]
+  const phaseRemainder = positiveModulo(connectionPhase - offset, STONE_TRACK_SHELL_TARGET_PITCH)
+  const firstBoundary =
+    phaseRemainder <= 0.000_001 ? STONE_TRACK_SHELL_TARGET_PITCH : STONE_TRACK_SHELL_TARGET_PITCH - phaseRemainder
+  for (let distance = firstBoundary; distance < run.length; distance += STONE_TRACK_SHELL_TARGET_PITCH) {
+    if (distance > 0.12) boundaries.push(distance)
+  }
+  boundaries.push(run.length)
+  return boundaries.slice(0, -1).flatMap((boundary, index) => {
+    const next = boundaries[index + 1]!
+    const start = boundary === 0 ? boundary : boundary + STONE_TRACK_SHELL_MORTAR_GAP * 0.5
+    const end = next === run.length ? next : next - STONE_TRACK_SHELL_MORTAR_GAP * 0.5
+    return end - start < 0.02
+      ? []
+      : [
+          {
+            start,
+            end,
+            metricLength: end - start,
+            closeStart: boundary !== 0 || run.capStart || closeStart,
+            closeEnd: next !== run.length || run.capEnd || closeEnd,
+          },
+        ]
+  })
+}
+
+function appendTriangle(
+  output: GeometryAccumulator,
+  a: THREE.Vector3,
+  b: THREE.Vector3,
+  c: THREE.Vector3,
+  uvA: readonly [number, number],
+  uvB: readonly [number, number],
+  uvC: readonly [number, number],
+  uvPhase: readonly [number, number],
+  metricLength: number,
+  reverseWinding: boolean,
+): void {
+  const points = reverseWinding ? [a, c, b] : [a, b, c]
+  const triangleUvs = reverseWinding ? [uvA, uvC, uvB] : [uvA, uvB, uvC]
+  for (const point of points) output.positions.push(point.x, point.y, point.z)
+  for (const uv of triangleUvs) {
+    const u = uv[0] + uvPhase[0]
+    const v = uv[1] + uvPhase[1]
+    output.uvs.push(u, v)
+    output.metricUvs.push(u, v, 1, metricLength)
+  }
+}
+
+function appendSweptBlock(
+  output: GeometryAccumulator,
+  sampleFrame: WallFrameSampler,
+  options: SweptBlockOptions,
+): void {
+  const physicalLength = Math.max(0.001, options.metricLength)
+  const startFrame = sampleFrame(options.start)
+  const endFrame = sampleFrame(options.end)
+  const linearSweep = [0.25, 0.5, 0.75].every(fraction => {
+    const frame = sampleFrame(THREE.MathUtils.lerp(options.start, options.end, fraction))
+    const expectedBase = startFrame.base.clone().lerp(endFrame.base, fraction)
+    return (
+      frame.base.distanceToSquared(expectedBase) <= 0.000_000_01 &&
+      frame.tangent.dot(startFrame.tangent) >= 0.999_999_9 &&
+      frame.up.dot(startFrame.up) >= 0.999_999_9 &&
+      frame.outward.dot(startFrame.outward) >= 0.999_999_9
+    )
+  })
+  const subdivisions = linearSweep ? 1 : Math.max(2, Math.ceil(physicalLength / MAX_SWEEP_SAMPLE_SPACING))
+  const fractions = new Set([0, 1])
+  for (let index = 1; index < subdivisions; index += 1) fractions.add(index / subdivisions)
+  const orderedFractions = [...fractions].sort((left, right) => left - right)
+  const directionProbe = sampleFrame(Math.min(options.end, options.start + 0.01))
+  // The preview's ring order is front-facing when its path tangent opposes
+  // the ring sweep. Canonical runs can use either traversal direction, so
+  // orient every triangle from the actual path progression instead of side.
+  const reverseWinding = directionProbe.base.clone().sub(startFrame.base).dot(startFrame.tangent) > 0
+  const rings = orderedFractions.map(fraction => {
+    const distance = THREE.MathUtils.lerp(options.start, options.end, fraction)
+    const frame = fraction === 0 ? startFrame : fraction === 1 ? endFrame : sampleFrame(distance)
+    const center = frame.base
+      .clone()
+      .addScaledVector(frame.outward, options.outwardOffset)
+      .addScaledVector(frame.up, options.verticalOffset)
+    const halfDepth = options.depth * 0.5
+    const halfHeight = options.height * 0.5
+    const crossSection: Array<readonly [number, number]> = [
+      [-halfDepth, -halfHeight],
+      [halfDepth, -halfHeight],
+      [halfDepth, halfHeight],
+      [-halfDepth, halfHeight],
+    ]
+    const points = crossSection.map(([depthOffset, heightOffset]) =>
+      center.clone().addScaledVector(frame.outward, depthOffset).addScaledVector(frame.up, heightOffset),
+    )
+    const perimeter = [0]
+    for (let edge = 1; edge < crossSection.length; edge += 1) {
+      const previous = crossSection[edge - 1]!
+      const current = crossSection[edge]!
+      perimeter.push(perimeter.at(-1)! + Math.hypot(current[0] - previous[0], current[1] - previous[1]))
+    }
+    const first = crossSection[0]!
+    const last = crossSection.at(-1)!
+    const perimeterTotal = perimeter.at(-1)! + Math.hypot(first[0] - last[0], first[1] - last[1])
+    return { fraction, center, crossSection, points, perimeter, perimeterTotal }
+  })
+
+  for (let ringIndex = 0; ringIndex < rings.length - 1; ringIndex += 1) {
+    const current = rings[ringIndex]!
+    const next = rings[ringIndex + 1]!
+    for (let edge = 0; edge < current.crossSection.length; edge += 1) {
+      const nextEdge = (edge + 1) % current.crossSection.length
+      const currentV = current.perimeter[edge]!
+      const currentNextV = nextEdge === 0 ? current.perimeterTotal : current.perimeter[nextEdge]!
+      const nextV = next.perimeter[edge]!
+      const nextNextV = nextEdge === 0 ? next.perimeterTotal : next.perimeter[nextEdge]!
+      // A brick can straddle two track pieces. Its second half must resume the
+      // first half's UVs; restarting U at zero makes the connector visible even
+      // when the swept geometry itself is perfectly flush.
+      const currentU = options.uvLongitudinalStart + current.fraction * physicalLength
+      const nextU = options.uvLongitudinalStart + next.fraction * physicalLength
+      appendTriangle(
+        output,
+        current.points[edge]!,
+        current.points[nextEdge]!,
+        next.points[edge]!,
+        [currentU, currentV],
+        [currentU, currentNextV],
+        [nextU, nextV],
+        options.uvPhase,
+        physicalLength,
+        reverseWinding,
+      )
+      appendTriangle(
+        output,
+        current.points[nextEdge]!,
+        next.points[nextEdge]!,
+        next.points[edge]!,
+        [currentU, currentNextV],
+        [nextU, nextNextV],
+        [nextU, nextV],
+        options.uvPhase,
+        physicalLength,
+        reverseWinding,
+      )
+    }
+  }
+
+  const startRing = rings[0]!
+  const endRing = rings.at(-1)!
+  // Two triangles close a rectangular end. A centre fan adds vertices and
+  // triangles without changing the surface or its planar UV interpolation.
+  for (const [a, b, c] of [[0, 1, 2], [0, 2, 3]] as const) {
+    if (options.closeStart) {
+      appendTriangle(output, startRing.points[a]!, startRing.points[c]!, startRing.points[b]!,
+        startRing.crossSection[a]!, startRing.crossSection[c]!, startRing.crossSection[b]!,
+        options.uvPhase, physicalLength, reverseWinding)
+    }
+    if (options.closeEnd) {
+      const uv = (index: number): [number, number] => [physicalLength + endRing.crossSection[index]![0], endRing.crossSection[index]![1]]
+      appendTriangle(output, endRing.points[a]!, endRing.points[b]!, endRing.points[c]!,
+        uv(a), uv(b), uv(c), options.uvPhase, physicalLength, reverseWinding)
+    }
+  }
+  output.moduleCount += 1
+  output.maxModuleLength = Math.max(output.maxModuleLength, physicalLength)
+}
+
+function appendRun(
+  output: GeometryAccumulator,
+  run: CanonicalWallRun,
+  sampleFrame: WallFrameSampler,
+  runIndex: number,
+  wallHeight: number,
+  connectionPhase: number,
+  closeStart: boolean,
+  closeEnd: boolean,
+): { wallBlocks: number; capBlocks: number } {
+  const usableWallHeight = Math.max(0.1, wallHeight - STONE_TRACK_SHELL_CAP_HEIGHT)
+  const courseHeight = usableWallHeight / STONE_TRACK_SHELL_COURSE_COUNT
+  let wallBlocks = 0
+  let capBlocks = 0
+  for (let course = 0; course < STONE_TRACK_SHELL_COURSE_COUNT; course += 1) {
+    const courseOffset = course % 2 === 0 ? 0 : STONE_TRACK_SHELL_TARGET_PITCH * 0.5
+    for (const segment of courseSegments(run, course, connectionPhase, closeStart, closeEnd)) {
+      const globalBrickIndex = Math.floor(
+        (connectionPhase + segment.start - courseOffset + 0.000_001) / STONE_TRACK_SHELL_TARGET_PITCH,
+      )
+      const depthVariation = (positiveModulo(globalBrickIndex * 17 + course * 7 + runIndex * 11, 3) - 1) * 0.012
+      appendSweptBlock(output, sampleFrame, {
+        ...segment,
+        depth: STONE_TRACK_SHELL_BLOCK_DEPTH,
+        height: courseHeight - STONE_TRACK_SHELL_MORTAR_GAP,
+        verticalOffset: courseHeight * (course + 0.5),
+        outwardOffset: STONE_TRACK_SHELL_PREVIEW_OUTWARD_OFFSET + depthVariation,
+        uvPhase: masonryUvPhase(runIndex, course, globalBrickIndex, false),
+        uvLongitudinalStart: positiveModulo(
+          connectionPhase + segment.start - courseOffset,
+          STONE_TRACK_SHELL_TARGET_PITCH,
+        ),
+      })
+      wallBlocks += 1
+    }
+  }
+  for (const segment of courseSegments(run, 0, connectionPhase, closeStart, closeEnd)) {
+    const globalBrickIndex = Math.floor((connectionPhase + segment.start + 0.000_001) / STONE_TRACK_SHELL_TARGET_PITCH)
+    appendSweptBlock(output, sampleFrame, {
+      ...segment,
+      depth: STONE_TRACK_SHELL_CAP_DEPTH,
+      height: STONE_TRACK_SHELL_CAP_HEIGHT - STONE_TRACK_SHELL_MORTAR_GAP * 0.5,
+      verticalOffset: usableWallHeight + STONE_TRACK_SHELL_CAP_HEIGHT * 0.5,
+      outwardOffset: STONE_TRACK_SHELL_PREVIEW_OUTWARD_OFFSET,
+      uvPhase: masonryUvPhase(runIndex, STONE_TRACK_SHELL_COURSE_COUNT, globalBrickIndex, true),
+      uvLongitudinalStart: positiveModulo(connectionPhase + segment.start, STONE_TRACK_SHELL_TARGET_PITCH),
+    })
+    capBlocks += 1
+  }
+  return { wallBlocks, capBlocks }
+}
+
+function createBatchedGeometry(
+  runs: readonly CanonicalWallRun[],
+  wallHeight: number,
+  connectionPhases: readonly number[],
+): {
+  geometry: THREE.BufferGeometry
+  wallBlocks: number
+  capBlocks: number
+  moduleCount: number
+  maxModuleLength: number
+} {
+  const output: GeometryAccumulator = { positions: [], uvs: [], metricUvs: [], moduleCount: 0, maxModuleLength: 0 }
+  let wallBlocks = 0
+  let capBlocks = 0
+  const sharedConnectedClosures = canonicalConvergentConnectedTerminalClosures(runs)
+  runs.forEach((run, runIndex) => {
+    const frames = new Map<number, CanonicalWallFrame>()
+    const sampleFrame = (distance: number): CanonicalWallFrame => {
+      const target = THREE.MathUtils.clamp(distance, 0, run.length)
+      const cached = frames.get(target)
+      if (cached) return cached
+      const frame = canonicalWallFrameAt(run, target)
+      frames.set(target, frame)
+      return frame
+    }
+    const counts = appendRun(
+      output,
+      run,
+      sampleFrame,
+      runIndex,
+      wallHeight,
+      connectionPhases[runIndex] ?? connectionPhases[0] ?? 0,
+      sharedConnectedClosures.has(`${runIndex}:start`),
+      sharedConnectedClosures.has(`${runIndex}:end`),
+    )
+    wallBlocks += counts.wallBlocks
+    capBlocks += counts.capBlocks
+  })
+  const geometry = new THREE.BufferGeometry()
+  geometry.setAttribute('position', new THREE.Float32BufferAttribute(output.positions, 3))
+  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(output.uvs, 2))
+  // AO and surface sampling share the exact masonry UVs, including seams.
+  geometry.setAttribute('uv1', geometry.getAttribute('uv'))
+  geometry.setAttribute('themeNetUv', new THREE.Float32BufferAttribute(output.metricUvs, 4))
+  geometry.computeVertexNormals()
+  geometry.computeBoundingBox()
+  geometry.computeBoundingSphere()
+  geometry.userData.moduleCount = output.moduleCount
+  geometry.userData.sharedConnectedClosureCount = sharedConnectedClosures.size
+  return { geometry, wallBlocks, capBlocks, moduleCount: output.moduleCount, maxModuleLength: output.maxModuleLength }
+}
+
+function canonicalEditorBounds(runs: readonly CanonicalWallRun[], wallHeight: number): THREE.Box3 {
+  const bounds = new THREE.Box3()
+  const halfThickness = TRACK_RAIL_WALL_THICKNESS * 0.5
+  for (const run of runs) {
+    for (const frame of run.frames) {
+      for (const across of [-halfThickness, halfThickness]) {
+        bounds.expandByPoint(frame.base.clone().addScaledVector(frame.outward, across).addScaledVector(frame.up, -0.03))
+        bounds.expandByPoint(
+          frame.base
+            .clone()
+            .addScaledVector(frame.outward, across)
+            .addScaledVector(frame.up, wallHeight - 0.03),
+        )
+      }
+    }
+  }
+  return bounds
+}
+
+/**
+ * Builds the approved architecture directly from canonical wall boundaries.
+ * Every visible unit is swept along its boundary (including curves and grades)
+ * and all units are merged into one draw call. The canonical ribbon remains
+ * the only floor and Rapier collider, so this visual shell cannot alter motion.
+ */
+export function addStoneTrackShellVisual(
+  host: THREE.Group,
+  id: string,
+  runs: readonly CanonicalWallRun[],
+  wallHeight: number,
+  materials: StoneTrackShellMaterials,
+  options: StoneTrackShellOptions,
+): THREE.Group | undefined {
+  if (wallHeight <= STONE_TRACK_SHELL_CAP_HEIGHT || runs.length === 0) return undefined
+  const group = new THREE.Group()
+  group.name = `${id}-shared-stone-track-shell`
+  group.userData.themeOnly = [...SHARED_STONE_TRACK_SHELL_THEME_IDS]
+  group.visible = group.userData.themeOnly.includes(options.themeId)
+  group.userData.initialThemeId = options.themeId
+  group.userData.visualOnly = true
+  group.userData.appearance = 'shared-stone-block-shell-v2'
+  group.userData.representation = 'procedural-swept-masonry-batch'
+  group.userData.courseCount = STONE_TRACK_SHELL_COURSE_COUNT
+  group.userData.targetPitch = STONE_TRACK_SHELL_TARGET_PITCH
+  group.userData.mortarGap = STONE_TRACK_SHELL_MORTAR_GAP
+  group.userData.previewGeometryPort = 'like-for-like'
+  group.userData.outwardOffset = STONE_TRACK_SHELL_PREVIEW_OUTWARD_OFFSET
+  group.userData.floorBoundaryUnderlap = STONE_TRACK_SHELL_FLOOR_UNDERLAP
+  group.userData.wallThickness = TRACK_RAIL_WALL_THICKNESS
+  group.userData.floorGeometry = 'canonical-ribbon-only'
+  group.userData.drawCallBudget = 1
+  const requestedPhases = Array.isArray(options.connectionPhase)
+    ? options.connectionPhase
+    : runs.map(() => options.connectionPhase)
+  const initialConnectionPhases = runs.map((_run, index) => {
+    const phase = requestedPhases[index] ?? requestedPhases[0]
+    return Number.isFinite(phase) ? phase! : 0
+  })
+  group.userData.connectionPhase = initialConnectionPhases[0] ?? 0
+  group.userData.connectionPhases = [...initialConnectionPhases]
+  group.userData.runMetricLengths = runs.map(run => run.length)
+  group.userData.runTerminals = runs.flatMap((run, runIndex) => [
+    {
+      runIndex,
+      terminal: 'start',
+      base: run.frames[0]!.base.toArray(),
+      tangent: run.frames[0]!.tangent.toArray(),
+      cap: run.capStart,
+    },
+    {
+      runIndex,
+      terminal: 'end',
+      base: run.frames.at(-1)!.base.toArray(),
+      tangent: run.frames.at(-1)!.tangent.toArray(),
+      cap: run.capEnd,
+    },
+  ])
+  group.userData.connectorRule = 'global-phase-single-docking-plane'
+  group.userData.connectorOverlap = STONE_TRACK_SHELL_CONNECTOR_OVERLAP
+  group.userData.connectedTerminalCaps = 'open-neighbor-owned'
+  group.userData.sharedConnectedClosureRule = 'one-owner-for-convergent-internal-terminals'
+
+  let mesh: THREE.Mesh | undefined
+  const buildGeometry = (phases: readonly number[]): void => {
+    const built = createBatchedGeometry(runs, wallHeight, phases)
+    if (mesh) {
+      const previousGeometry = mesh.geometry
+      mesh.geometry = built.geometry
+      previousGeometry.dispose()
+    } else {
+      mesh = new THREE.Mesh(built.geometry, materials.wall)
+      mesh.name = `${group.name}-stone-module-batch`
+      mesh.castShadow = true
+      mesh.receiveShadow = true
+      mesh.userData.visualOnly = true
+      // Render the protruding 3D masonry, but keep Track Lab's lime selection box
+      // on the canonical wall envelope. This mirrors the legacy wall dimensions
+      // and prevents a theme from appearing to resize the authored track piece.
+      const editorBounds = canonicalEditorBounds(runs, wallHeight)
+      mesh.userData.editorBoundsOverride = {
+        min: editorBounds.min.toArray(),
+        max: editorBounds.max.toArray(),
+      }
+      mesh.userData.editorBoundsSource = 'canonical-wall-envelope'
+      mesh.userData.drawCallBudget = 1
+      mesh.userData.sharedConnectedClosureCount = built.geometry.userData.sharedConnectedClosureCount
+      group.add(mesh)
+    }
+    group.userData.moduleCount = built.moduleCount
+    group.userData.roleCounts = { wallBlock: built.wallBlocks, capBlock: built.capBlocks }
+    group.userData.maxModuleLength = built.maxModuleLength
+  }
+  group.userData.moduleCount = 0
+  group.userData.roleCounts = { wallBlock: 0, capBlock: 0 }
+  group.userData.maxModuleLength = 0
+  if (!options.deferGeometry) buildGeometry(initialConnectionPhases)
+  const setMaterialConnectionPhase = (phaseOrPhases: number | readonly number[]): void => {
+    const requested = Array.isArray(phaseOrPhases) ? phaseOrPhases : runs.map(() => phaseOrPhases)
+    const phases = runs.map((_run, index) => requested[index] ?? requested[0] ?? 0)
+    if (phases.some(phase => !Number.isFinite(phase))) return
+    const current = group.userData.connectionPhases as readonly number[]
+    const phaseChanged = phases.length !== current.length || phases.some((phase, index) => phase !== current[index])
+    if (mesh && !phaseChanged) return
+    buildGeometry(phases)
+    group.userData.connectionPhase = phases[0] ?? 0
+    group.userData.connectionPhases = [...phases]
+  }
+  group.userData.setMaterialConnectionPhase = setMaterialConnectionPhase
+  host.add(group)
+
+  const ensureModel = (): Promise<THREE.Group> => Promise.resolve(group)
+  group.userData.ensureModel = ensureModel
+  group.userData.modelReady = ensureModel()
+  return group
+}
+
+export { isSharedStoneTrackShellAppearance, isSharedStoneTrackShellDefaultTheme }