@@ -1,6 +1,37 @@
 # Stacks Frontend
 
-This core package contains the core frontend/browser functionalities of Stacks, all of which are auto-imported into your projects.
+This package contains Stacks browser APIs. Import module APIs explicitly; the STX runtime and compiler determine which composables are available without imports.
+
+## Native model geometry
+
+`@stacksjs/browser/model-viewer` supports native box, tube and cylinder shapes,
+same-origin binary STL files, and indexed inline meshes for procedural models.
+Pass the scene to the STX `ModelViewer` component.
+
+```ts
+import type { ModelScene } from '@stacksjs/browser/model-viewer'
+
+const scene: ModelScene = {
+  nodes: [{
+    id: 'panel',
+    geometry: {
+      kind: 'mesh',
+      vertices: [[0, 0, 0], [100, 0, 0], [0, 50, 0]],
+      triangles: [[0, 1, 2]],
+    },
+    color: '#254b38',
+  }],
+}
+```
+
+Coordinates follow the same authored units as the rest of the scene. Vertices
+and triangle indices are JSON-compatible triples. The viewer validates array
+sizes, finite Float32 coordinates, integer in-range indices and repeated
+indices. Each mesh permits up to 500,000 vertices and 500,000 triangles, subject
+to the existing whole-scene detail limit. Input arrays are copied, not mutated.
+Inline meshes require no file request or persistent STL cache entry. The STL
+loader retains its same-origin requirement; inline meshes do not enable remote
+URLs. Rendering geometry does not establish its physical safety or suitability.
 
 ## ☘️ Features
 
 
@@ -3,6 +3,7 @@ export type ModelVector = [number, number, number]
 export type ModelMatrix = number[]
 export type ModelGeometry =
   | { kind: 'stl', src: string }
+  | { kind: 'mesh', vertices: ModelVector[], triangles: [number, number, number][] }
   | { kind: 'box', size: ModelVector }
   | { kind: 'tube', outer: number, inner: number, length: number }
   | { kind: 'cylinder', radius: number, length: number, innerRadius?: number, segments?: number }
@@ -79,6 +80,27 @@ export function parseBinaryModelStl(buffer: ArrayBuffer): Float32Array {
 }
 
 export function createModelGeometry(geometry: Exclude<ModelGeometry, { kind: 'stl' }>): Float32Array {
+  // Indexed geometry is authored in the scene, so it needs no URL, fetch or
+  // retained STL resource. This keeps interactive procedural models native.
+  if (geometry.kind === 'mesh') {
+    if (!Array.isArray(geometry.vertices) || geometry.vertices.length < 3 || geometry.vertices.length > 500000
+      || !Array.isArray(geometry.triangles) || !geometry.triangles.length || geometry.triangles.length > 500000)
+      throw new Error('An inline mesh requires 3-500000 vertices and 1-500000 triangles.')
+    for (const vertex of geometry.vertices) {
+      if (!Array.isArray(vertex) || vertex.length !== 3 || ![0, 1, 2].every(axis => Number.isFinite(vertex[axis]) && Number.isFinite(Math.fround(vertex[axis]!))))
+        throw new Error('An inline mesh contains an invalid coordinate.')
+    }
+    const output = new Float32Array(geometry.triangles.length * 9)
+    for (let face = 0; face < geometry.triangles.length; face++) {
+      const indices = geometry.triangles[face]!
+      if (!Array.isArray(indices) || indices.length !== 3 || ![0, 1, 2].every(corner => Number.isInteger(indices[corner]) && indices[corner]! >= 0 && indices[corner]! < geometry.vertices.length)
+        || new Set(indices).size !== 3)
+        throw new Error('An inline mesh contains an invalid triangle index.')
+      for (let corner = 0; corner < 3; corner++)
+        output.set(geometry.vertices[indices[corner]!]!, face * 9 + corner * 3)
+    }
+    return output
+  }
   const positions: number[] = []
   const triangle = (a: ModelVector, b: ModelVector, c: ModelVector) => positions.push(...a, ...b, ...c)
   const quad = (a: ModelVector, b: ModelVector, c: ModelVector, d: ModelVector) => { triangle(a, b, c); triangle(a, c, d) }
 
@@ -1,5 +1,33 @@
 import { expect, test } from 'bun:test'
 import { createModelGeometry, modelTransform, multiplyModelMatrices, parseBinaryModelStl, transformModelPoint } from '../src/model-viewer'
+import type { ModelGeometry } from '../src/model-viewer'
+
+test('indexed inline meshes preserve winding and repeated shared vertices without a fetch', () => {
+  const geometry: ModelGeometry = { kind: 'mesh', vertices: [[0, 0, 0], [10, 0, 0], [10, 20, 0], [0, 20, 0]], triangles: [[0, 1, 2], [0, 2, 3]] }
+  const output = createModelGeometry(geometry)
+  expect([...output]).toEqual([0, 0, 0, 10, 0, 0, 10, 20, 0, 0, 0, 0, 10, 20, 0, 0, 20, 0])
+  output[0] = 99
+  expect(geometry.vertices[0]).toEqual([0, 0, 0])
+})
+
+test('inline meshes reject malformed, nonfinite, Float32-overflowing and oversized input before delivery', () => {
+  const valid: Extract<ModelGeometry, { kind: 'mesh' }> = { kind: 'mesh', vertices: [[0, 0, 0], [1, 0, 0], [0, 1, 0]], triangles: [[0, 1, 2]] }
+  const invalid = [
+    { ...valid, vertices: [] }, { ...valid, triangles: [] },
+    { ...valid, vertices: [[Number.NaN, 0, 0], [1, 0, 0], [0, 1, 0]] },
+    { ...valid, vertices: [[1e100, 0, 0], [1, 0, 0], [0, 1, 0]] },
+    { ...valid, vertices: [[0, 0], [1, 0, 0], [0, 1, 0]] },
+    { ...valid, vertices: [[0, , 0], [1, 0, 0], [0, 1, 0]] },
+    { ...valid, triangles: [[0, 1, 3]] }, { ...valid, triangles: [[0, -1, 2]] },
+    { ...valid, triangles: [[0, 1.5, 2]] }, { ...valid, triangles: [[0, 0, 2]] },
+    { ...valid, triangles: [[0, 1]] },
+    { ...valid, triangles: [[0, , 2]] },
+    { ...valid, vertices: Array.from({ length: 500001 }, () => [0, 0, 0]) },
+    { ...valid, triangles: Array.from({ length: 500001 }, () => [0, 1, 2]) },
+  ]
+  for (const input of invalid)
+    expect(() => createModelGeometry(input as typeof valid)).toThrow()
+})
 
 test('model transforms preserve CAD millimeters and compose local rotations before world placement', () => {
   const point = transformModelPoint([70, 155, 6], modelTransform([0, 27, 200], [90, 0, 0]))