@forgeax/engine-geometry 0.1.2

package/dist/index.mjs

@@ -0,0 +1,2000 @@
+import { ok, countUvSets, AssetError, ASSET_ERROR_HINTS, err } from '@forgeax/engine-types';
+import { decodeMeshBinHeader, MESH_BIN_HEADER_V4_BYTES, MESH_BIN_VERSION } from '@forgeax/engine-pack';
+import { box3, circle2, box2 } from '@forgeax/engine-math';
+
+// src/assets/mesh-decoder.ts
+var EPSILON = 1e-8;
+function tangentInputError(field, value, reason) {
+  return new AssetError({
+    code: "asset-parse-failed",
+    expected: `valid tangent topology: ${reason}`,
+    hint: ASSET_ERROR_HINTS["asset-parse-failed"],
+    detail: { field, value, reason }
+  });
+}
+function preflightTangentInput(positions, normals, uvs, indices) {
+  if (positions.length % 3 !== 0) {
+    return err(
+      tangentInputError(
+        "positions",
+        positions.length,
+        "positions.length must be divisible by the position stride of 3"
+      )
+    );
+  }
+  const vertexCount = positions.length / 3;
+  if (normals.length !== vertexCount * 3) {
+    return err(
+      tangentInputError(
+        "normals",
+        normals.length,
+        `normals.length must equal vertexCount * 3 (${vertexCount * 3})`
+      )
+    );
+  }
+  if (uvs.length !== vertexCount * 2) {
+    return err(
+      tangentInputError(
+        "uvs",
+        uvs.length,
+        `uvs.length must equal vertexCount * 2 (${vertexCount * 2})`
+      )
+    );
+  }
+  if (indices === void 0) {
+    if (vertexCount % 3 !== 0) {
+      return err(
+        tangentInputError(
+          "positions",
+          vertexCount,
+          "non-indexed vertexCount must be divisible by the triangle size of 3"
+        )
+      );
+    }
+    return ok(vertexCount);
+  }
+  if (indices.length % 3 !== 0) {
+    return err(
+      tangentInputError(
+        "indices",
+        indices.length,
+        "indices.length must be divisible by the triangle size of 3"
+      )
+    );
+  }
+  for (let indexPosition = 0; indexPosition < indices.length; indexPosition++) {
+    const index = indices[indexPosition];
+    if (index === void 0 || !Number.isInteger(index) || index < 0 || index >= vertexCount) {
+      return err(
+        tangentInputError(
+          "indices",
+          index ?? -1,
+          `indices[${indexPosition}] must be an integer in [0, ${vertexCount})`
+        )
+      );
+    }
+  }
+  return ok(vertexCount);
+}
+function computeTangentVec4(positions, normals, uvs, indices) {
+  const preflight = preflightTangentInput(positions, normals, uvs, indices);
+  if (!preflight.ok) return preflight;
+  const vertexCount = preflight.value;
+  const accumT = new Float32Array(vertexCount * 3);
+  const accumSign = new Float32Array(vertexCount);
+  const triangleCount = indices !== void 0 ? indices.length / 3 : vertexCount / 3;
+  for (let tri = 0; tri < triangleCount; tri++) {
+    const i0 = indices !== void 0 ? indices[tri * 3] ?? 0 : tri * 3;
+    const i1 = indices !== void 0 ? indices[tri * 3 + 1] ?? 0 : tri * 3 + 1;
+    const i2 = indices !== void 0 ? indices[tri * 3 + 2] ?? 0 : tri * 3 + 2;
+    const p0x = positions[i0 * 3] ?? 0;
+    const p0y = positions[i0 * 3 + 1] ?? 0;
+    const p0z = positions[i0 * 3 + 2] ?? 0;
+    const p1x = positions[i1 * 3] ?? 0;
+    const p1y = positions[i1 * 3 + 1] ?? 0;
+    const p1z = positions[i1 * 3 + 2] ?? 0;
+    const p2x = positions[i2 * 3] ?? 0;
+    const p2y = positions[i2 * 3 + 1] ?? 0;
+    const p2z = positions[i2 * 3 + 2] ?? 0;
+    const u0 = uvs[i0 * 2] ?? 0;
+    const v0 = uvs[i0 * 2 + 1] ?? 0;
+    const u1 = uvs[i1 * 2] ?? 0;
+    const v1 = uvs[i1 * 2 + 1] ?? 0;
+    const u2 = uvs[i2 * 2] ?? 0;
+    const v2 = uvs[i2 * 2 + 1] ?? 0;
+    const dP1x = p1x - p0x;
+    const dP1y = p1y - p0y;
+    const dP1z = p1z - p0z;
+    const dP2x = p2x - p0x;
+    const dP2y = p2y - p0y;
+    const dP2z = p2z - p0z;
+    const dU1 = u1 - u0;
+    const dV1 = v1 - v0;
+    const dU2 = u2 - u0;
+    const dV2 = v2 - v0;
+    const det = dU1 * dV2 - dU2 * dV1;
+    if (Math.abs(det) < EPSILON) {
+      continue;
+    }
+    const invDet = 1 / det;
+    const tx = invDet * (dV2 * dP1x - dV1 * dP2x);
+    const ty = invDet * (dV2 * dP1y - dV1 * dP2y);
+    const tz = invDet * (dV2 * dP1z - dV1 * dP2z);
+    const cx = dP1y * dP2z - dP1z * dP2y;
+    const cy = dP1z * dP2x - dP1x * dP2z;
+    const cz = dP1x * dP2y - dP1y * dP2x;
+    const faceArea = 0.5 * Math.sqrt(cx * cx + cy * cy + cz * cz);
+    if (faceArea < EPSILON) continue;
+    const signDet = det >= 0 ? 1 : -1;
+    const signedWeight = faceArea * signDet;
+    for (const vi of [i0, i1, i2]) {
+      accumT[vi * 3] = (accumT[vi * 3] ?? 0) + tx * faceArea;
+      accumT[vi * 3 + 1] = (accumT[vi * 3 + 1] ?? 0) + ty * faceArea;
+      accumT[vi * 3 + 2] = (accumT[vi * 3 + 2] ?? 0) + tz * faceArea;
+      accumSign[vi] = (accumSign[vi] ?? 0) + signedWeight;
+    }
+  }
+  const out = new Float32Array(vertexCount * 4);
+  for (let v = 0; v < vertexCount; v++) {
+    let tx = accumT[v * 3] ?? 0;
+    let ty = accumT[v * 3 + 1] ?? 0;
+    let tz = accumT[v * 3 + 2] ?? 0;
+    const nx = normals[v * 3] ?? 0;
+    const ny = normals[v * 3 + 1] ?? 0;
+    const nz = normals[v * 3 + 2] ?? 0;
+    const tLen = Math.sqrt(tx * tx + ty * ty + tz * tz);
+    if (tLen < EPSILON) {
+      const ax = Math.abs(nx);
+      const ay = Math.abs(ny);
+      const az = Math.abs(nz);
+      let rx = 1;
+      let ry = 0;
+      let rz = 0;
+      if (ax <= ay && ax <= az) {
+        rx = 1;
+        ry = 0;
+        rz = 0;
+      } else if (ay <= ax && ay <= az) {
+        rx = 0;
+        ry = 1;
+        rz = 0;
+      } else {
+        rx = 0;
+        ry = 0;
+        rz = 1;
+      }
+      tx = ny * rz - nz * ry;
+      ty = nz * rx - nx * rz;
+      tz = nx * ry - ny * rx;
+      const fLen = Math.sqrt(tx * tx + ty * ty + tz * tz) || 1;
+      tx /= fLen;
+      ty /= fLen;
+      tz /= fLen;
+    } else {
+      tx /= tLen;
+      ty /= tLen;
+      tz /= tLen;
+    }
+    const dotTN = tx * nx + ty * ny + tz * nz;
+    let gx = tx - dotTN * nx;
+    let gy = ty - dotTN * ny;
+    let gz = tz - dotTN * nz;
+    const gLen = Math.sqrt(gx * gx + gy * gy + gz * gz);
+    if (gLen < EPSILON) {
+      const ax = Math.abs(nx);
+      const ay = Math.abs(ny);
+      const az = Math.abs(nz);
+      let rx = 1;
+      let ry = 0;
+      let rz = 0;
+      if (ax <= ay && ax <= az) {
+        rx = 1;
+        ry = 0;
+        rz = 0;
+      } else if (ay <= ax && ay <= az) {
+        rx = 0;
+        ry = 1;
+        rz = 0;
+      } else {
+        rx = 0;
+        ry = 0;
+        rz = 1;
+      }
+      gx = ny * rz - nz * ry;
+      gy = nz * rx - nx * rz;
+      gz = nx * ry - ny * rx;
+      const fLen = Math.sqrt(gx * gx + gy * gy + gz * gz) || 1;
+      gx /= fLen;
+      gy /= fLen;
+      gz /= fLen;
+    } else {
+      gx /= gLen;
+      gy /= gLen;
+      gz /= gLen;
+    }
+    const accSign = accumSign[v] ?? 0;
+    const w = accSign >= 0 ? 1 : -1;
+    out[v * 4] = gx;
+    out[v * 4 + 1] = gy;
+    out[v * 4 + 2] = gz;
+    out[v * 4 + 3] = w;
+  }
+  return ok(out);
+}
+var ATTRIBUTE_FORMAT_MAP = {
+  position: "float32x3",
+  normal: "float32x3",
+  uv: "float32x2",
+  tangent: "float32x4",
+  skinIndex: "uint16x4",
+  skinWeight: "float32x4",
+  uv1: "float32x2",
+  uv2: "float32x2",
+  uv3: "float32x2",
+  uv4: "float32x2",
+  uv5: "float32x2",
+  uv6: "float32x2",
+  uv7: "float32x2",
+  color: "float32x4"
+};
+var ATTRIBUTE_BYTE_STRIDE = {
+  position: 12,
+  normal: 12,
+  uv: 8,
+  tangent: 16,
+  skinIndex: 8,
+  skinWeight: 16,
+  uv1: 8,
+  uv2: 8,
+  uv3: 8,
+  uv4: 8,
+  uv5: 8,
+  uv6: 8,
+  uv7: 8,
+  color: 16
+};
+var isAttributeKey = (key) => key in ATTRIBUTE_FORMAT_MAP;
+var CANONICAL_KEYS = Object.keys(ATTRIBUTE_FORMAT_MAP).filter(isAttributeKey);
+var UV_KEYS = CANONICAL_KEYS.filter(
+  (key) => key === "uv" || key.startsWith("uv")
+);
+function emitAliasEntries(entries, fromIndex, toIndex, aliasOffset, currentStride) {
+  for (let k = fromIndex; k < toIndex && k < UV_KEYS.length; k++) {
+    const uvKey = UV_KEYS[k];
+    entries.push({
+      key: uvKey,
+      shaderLocation: CANONICAL_KEYS.indexOf(uvKey),
+      offset: aliasOffset,
+      format: ATTRIBUTE_FORMAT_MAP[uvKey]
+    });
+  }
+  return fromIndex === 0 ? currentStride + ATTRIBUTE_BYTE_STRIDE.uv : currentStride;
+}
+function buildMeshAttributeMapForUvSets(uvSetCount) {
+  const map = {
+    position: new Float32Array(0),
+    normal: new Float32Array(0),
+    uv: new Float32Array(0),
+    tangent: new Float32Array(0)
+  };
+  for (let set = 1; set < uvSetCount && set < UV_KEYS.length; set++) {
+    map[UV_KEYS[set]] = new Float32Array(0);
+  }
+  return map;
+}
+function deriveVertexBufferLayout(map, opts) {
+  const shaderUvSetCount = opts?.shaderUvSetCount ?? 0;
+  const entries = [];
+  let offset = 0;
+  for (const key of CANONICAL_KEYS) {
+    if (map[key] === void 0) continue;
+    entries.push({
+      key,
+      shaderLocation: CANONICAL_KEYS.indexOf(key),
+      offset,
+      format: ATTRIBUTE_FORMAT_MAP[key]
+    });
+    offset += ATTRIBUTE_BYTE_STRIDE[key];
+  }
+  const present = entries.length;
+  if (shaderUvSetCount > 0) {
+    const meshUvSetCount = countUvSets(map);
+    if (shaderUvSetCount > meshUvSetCount) {
+      const lastUvIndex = meshUvSetCount - 1;
+      const lastUvKey = lastUvIndex >= 0 && lastUvIndex < UV_KEYS.length ? UV_KEYS[lastUvIndex] : void 0;
+      const aliasOffset = lastUvKey !== void 0 ? CANONICAL_KEYS.indexOf(lastUvKey) : -1;
+      const aliasByteOffset = aliasOffset >= 0 ? entries.find((e) => e.shaderLocation === aliasOffset)?.offset ?? 0 : offset;
+      offset = emitAliasEntries(entries, meshUvSetCount, shaderUvSetCount, aliasByteOffset, offset);
+    }
+  }
+  if (present === 0 && shaderUvSetCount === 0) return [];
+  entries.sort((a, b) => a.shaderLocation - b.shaderLocation);
+  return [
+    {
+      arrayStride: offset,
+      attributes: entries.map(({ shaderLocation, offset: entryOffset, format }) => ({
+        shaderLocation,
+        offset: entryOffset,
+        format
+      }))
+    }
+  ];
+}
+function deriveVertexBufferLayoutFromProjection(projection, opts) {
+  const entries = projection.attributes.map(({ key, shaderLocation, offset, format }) => ({
+    key,
+    shaderLocation,
+    offset,
+    format
+  }));
+  let arrayStride = projection.arrayStride;
+  const shaderUvSetCount = opts?.shaderUvSetCount ?? 0;
+  if (shaderUvSetCount > 0) {
+    const meshUvSetCount = entries.filter(
+      (entry) => entry.key === "uv" || entry.key.startsWith("uv")
+    ).length;
+    if (shaderUvSetCount > meshUvSetCount) {
+      const lastUv = entries.filter((entry) => entry.key === "uv" || entry.key.startsWith("uv")).at(-1);
+      const aliasOffset = lastUv?.offset ?? arrayStride;
+      for (let index = meshUvSetCount; index < shaderUvSetCount && index < UV_KEYS.length; index += 1) {
+        const key = UV_KEYS[index];
+        if (key === void 0) continue;
+        entries.push({
+          key,
+          shaderLocation: CANONICAL_KEYS.indexOf(key),
+          offset: aliasOffset,
+          format: ATTRIBUTE_FORMAT_MAP[key]
+        });
+      }
+      if (meshUvSetCount === 0) arrayStride += ATTRIBUTE_BYTE_STRIDE.uv;
+    }
+  }
+  entries.sort((a, b) => a.shaderLocation - b.shaderLocation);
+  return projection.attributes.length === 0 ? [] : [
+    {
+      arrayStride,
+      attributes: entries.map(({ shaderLocation, offset, format }) => ({
+        shaderLocation,
+        offset,
+        format
+      }))
+    }
+  ];
+}
+function bytesForFormat(format) {
+  if (format === "uint16x4" || format === "float32x2") return 8;
+  if (format === "float32x3") return 12;
+  return 16;
+}
+function storageOf(value) {
+  if (value instanceof ArrayBuffer) return "array-buffer";
+  if (value instanceof Float32Array) return "float32";
+  if (value instanceof Uint16Array) return "uint16";
+  return "other";
+}
+function elementView(value, format) {
+  if (value instanceof Float32Array || value instanceof Uint16Array) return value;
+  if (value instanceof ArrayBuffer) {
+    return format === "uint16x4" ? new Uint16Array(value) : new Float32Array(value);
+  }
+  return void 0;
+}
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `vlp-v1-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function deriveVertexLayoutProjection(map) {
+  const attributes = [];
+  let offset = 0;
+  let mask = 0;
+  for (const key of CANONICAL_KEYS) {
+    const value = map[key];
+    if (value === void 0) continue;
+    const format = ATTRIBUTE_FORMAT_MAP[key];
+    const byteLength = bytesForFormat(format);
+    attributes.push({
+      key,
+      shaderLocation: CANONICAL_KEYS.indexOf(key),
+      offset,
+      format,
+      byteLength
+    });
+    mask |= 1 << CANONICAL_KEYS.indexOf(key);
+    offset += byteLength;
+  }
+  const digestInput = [
+    "1",
+    String(mask),
+    String(offset),
+    ...attributes.map(
+      (entry) => `${entry.key},${entry.shaderLocation},${entry.offset},${entry.format}`
+    )
+  ].join("|");
+  return Object.freeze({
+    schemaVersion: 1,
+    attributes: Object.freeze(attributes),
+    mask,
+    arrayStride: offset,
+    digest: fnv1a(digestInput)
+  });
+}
+var VertexAttributePackError = class extends AssetError {
+  constructor(detail) {
+    super({
+      code: "asset-invalid-value",
+      expected: "canonical vertex attributes with matching storage and cardinality",
+      hint: ASSET_ERROR_HINTS["asset-invalid-value"],
+      detail
+    });
+  }
+};
+function deriveVertexLayoutProjectionFromMask(mask) {
+  const knownMask = (1 << CANONICAL_KEYS.length) - 1;
+  const unsignedMask = Number.isInteger(mask) && mask >= 0 ? mask >>> 0 : 4294967295;
+  const unknownMask = unsignedMask & ~knownMask;
+  if (mask === 0) {
+    return err({
+      code: "vertex-layout-mask-invalid",
+      expected: "a non-empty canonical vertex attribute mask",
+      hint: "re-cook the mesh-bin payload from MeshAsset.attributes",
+      detail: { mask, knownMask, unknownMask, reason: "empty" }
+    });
+  }
+  if (!Number.isInteger(mask) || mask < 0 || unknownMask !== 0) {
+    return err({
+      code: "vertex-layout-mask-invalid",
+      expected: `a mask using only canonical bits 0..${CANONICAL_KEYS.length - 1}`,
+      hint: "re-cook the mesh-bin payload from MeshAsset.attributes",
+      detail: { mask, knownMask, unknownMask, reason: "unknown-bits" }
+    });
+  }
+  const map = {};
+  for (let index = 0; index < CANONICAL_KEYS.length; index += 1) {
+    if ((mask & 1 << index) === 0) continue;
+    const key = CANONICAL_KEYS[index];
+    if (key !== void 0)
+      map[key] = key === "skinIndex" ? new Uint16Array(0) : new Float32Array(0);
+  }
+  return ok(deriveVertexLayoutProjection(map));
+}
+function packInterleavedVertexAttributes(map, vertexCount) {
+  const invalid2 = (detail) => err(new VertexAttributePackError(detail));
+  if (!Number.isInteger(vertexCount) || vertexCount < 0) {
+    return invalid2({ field: "vertexCount", reason: "vertex-count-invalid", actual: vertexCount });
+  }
+  const projection = deriveVertexLayoutProjection(map);
+  if (projection.attributes.length === 0) {
+    return invalid2({ field: "attributes", reason: "attributes-empty", actualCount: 0 });
+  }
+  const output = new ArrayBuffer(projection.arrayStride * vertexCount);
+  const outputFloats = new Float32Array(output);
+  const outputU16 = new Uint16Array(output);
+  for (const entry of projection.attributes) {
+    const sourceValue = map[entry.key];
+    if (sourceValue === void 0) continue;
+    const uint16 = entry.format === "uint16x4";
+    const components = entry.byteLength / (uint16 ? 2 : 4);
+    const bytesPerComponent = uint16 ? 2 : 4;
+    if (sourceValue instanceof ArrayBuffer && sourceValue.byteLength % bytesPerComponent !== 0) {
+      return invalid2({
+        field: entry.key,
+        reason: "attribute-cardinality-mismatch",
+        vertexCount,
+        componentsPerVertex: components,
+        expectedLength: vertexCount * components,
+        actualLength: sourceValue.byteLength / bytesPerComponent
+      });
+    }
+    const source = elementView(sourceValue, entry.format);
+    if (source === void 0 || (uint16 ? storageOf(sourceValue) !== "uint16" && storageOf(sourceValue) !== "array-buffer" : storageOf(sourceValue) !== "float32" && storageOf(sourceValue) !== "array-buffer")) {
+      return invalid2({
+        field: entry.key,
+        reason: "attribute-storage-invalid",
+        expectedStorage: uint16 ? "uint16" : "float32",
+        actualStorage: storageOf(sourceValue)
+      });
+    }
+    const expectedLength = vertexCount * components;
+    if (source.length !== expectedLength) {
+      return invalid2({
+        field: entry.key,
+        reason: "attribute-cardinality-mismatch",
+        vertexCount,
+        componentsPerVertex: components,
+        expectedLength,
+        actualLength: source.length
+      });
+    }
+    if (entry.key === "color") {
+      for (let elementIndex = 0; elementIndex < source.length; elementIndex += 1) {
+        const component = source[elementIndex];
+        if (!Number.isFinite(component)) {
+          return invalid2({
+            field: "color",
+            reason: "attribute-non-finite",
+            elementIndex,
+            actual: Number.isNaN(component) ? "nan" : component === Number.POSITIVE_INFINITY ? "positive-infinity" : "negative-infinity"
+          });
+        }
+      }
+    }
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+      for (let component = 0; component < components; component += 1) {
+        const sourceIndex = vertex * components + component;
+        const byteOffset = vertex * projection.arrayStride + entry.offset + component * (uint16 ? 2 : 4);
+        if (uint16) outputU16[byteOffset / 2] = Number(source[sourceIndex] ?? 0);
+        else outputFloats[byteOffset / 4] = Number(source[sourceIndex] ?? 0);
+      }
+    }
+  }
+  return ok(Object.freeze({ projection, vertices: outputFloats }));
+}
+
+// src/box.ts
+var FACTORY_FLOATS_PER_VERTEX = 8;
+var PROCEDURAL_FLOATS_PER_VERTEX = 12;
+function interleavedInputError(field, value, reason) {
+  return new AssetError({
+    code: "asset-parse-failed",
+    expected: `valid interleaved triangle topology: ${reason}`,
+    hint: ASSET_ERROR_HINTS["asset-parse-failed"],
+    detail: { field, value, reason }
+  });
+}
+function buildAttributes(vertices, vertexCount) {
+  const positions = new Float32Array(vertexCount * 3);
+  const normals = new Float32Array(vertexCount * 3);
+  const uvs = new Float32Array(vertexCount * 2);
+  const tangents = new Float32Array(vertexCount * 4);
+  for (let i = 0; i < vertexCount; i++) {
+    const base = i * PROCEDURAL_FLOATS_PER_VERTEX;
+    positions[i * 3 + 0] = vertices[base + 0];
+    positions[i * 3 + 1] = vertices[base + 1];
+    positions[i * 3 + 2] = vertices[base + 2];
+    normals[i * 3 + 0] = vertices[base + 3];
+    normals[i * 3 + 1] = vertices[base + 4];
+    normals[i * 3 + 2] = vertices[base + 5];
+    uvs[i * 2 + 0] = vertices[base + 6];
+    uvs[i * 2 + 1] = vertices[base + 7];
+    tangents[i * 4 + 0] = vertices[base + 8];
+    tangents[i * 4 + 1] = vertices[base + 9];
+    tangents[i * 4 + 2] = vertices[base + 10];
+    tangents[i * 4 + 3] = vertices[base + 11];
+  }
+  const attrs = {
+    position: positions,
+    normal: normals,
+    uv: uvs,
+    tangent: tangents
+  };
+  deriveVertexBufferLayout(attrs);
+  return attrs;
+}
+function meshFromInterleaved(vertices, indices) {
+  if (vertices.length % FACTORY_FLOATS_PER_VERTEX !== 0) {
+    return err(
+      interleavedInputError(
+        "vertices",
+        vertices.length,
+        `vertices.length must be divisible by the interleaved stride of ${FACTORY_FLOATS_PER_VERTEX}`
+      )
+    );
+  }
+  const vertexCount = vertices.length / FACTORY_FLOATS_PER_VERTEX;
+  if (indices.length % 3 !== 0) {
+    return err(
+      interleavedInputError(
+        "indices",
+        indices.length,
+        "indices.length must be divisible by the triangle size of 3"
+      )
+    );
+  }
+  for (let indexPosition = 0; indexPosition < indices.length; indexPosition++) {
+    const index = indices[indexPosition];
+    if (index === void 0 || !Number.isInteger(index) || index < 0 || index >= vertexCount) {
+      return err(
+        interleavedInputError(
+          "indices",
+          index ?? -1,
+          `indices[${indexPosition}] must be an integer in [0, ${vertexCount})`
+        )
+      );
+    }
+  }
+  const positions = new Float32Array(vertexCount * 3);
+  const normals = new Float32Array(vertexCount * 3);
+  const uvs = new Float32Array(vertexCount * 2);
+  for (let i = 0; i < vertexCount; i++) {
+    const base = i * FACTORY_FLOATS_PER_VERTEX;
+    positions[i * 3 + 0] = vertices[base + 0];
+    positions[i * 3 + 1] = vertices[base + 1];
+    positions[i * 3 + 2] = vertices[base + 2];
+    normals[i * 3 + 0] = vertices[base + 3];
+    normals[i * 3 + 1] = vertices[base + 4];
+    normals[i * 3 + 2] = vertices[base + 5];
+    uvs[i * 2 + 0] = vertices[base + 6];
+    uvs[i * 2 + 1] = vertices[base + 7];
+  }
+  const tangentResult = computeTangentVec4(positions, normals, uvs, indices);
+  if (!tangentResult.ok) return tangentResult;
+  const tangents = tangentResult.value;
+  const expanded = new Float32Array(vertexCount * PROCEDURAL_FLOATS_PER_VERTEX);
+  for (let i = 0; i < vertexCount; i++) {
+    const dst = i * PROCEDURAL_FLOATS_PER_VERTEX;
+    const src = i * FACTORY_FLOATS_PER_VERTEX;
+    expanded[dst + 0] = vertices[src + 0];
+    expanded[dst + 1] = vertices[src + 1];
+    expanded[dst + 2] = vertices[src + 2];
+    expanded[dst + 3] = vertices[src + 3];
+    expanded[dst + 4] = vertices[src + 4];
+    expanded[dst + 5] = vertices[src + 5];
+    expanded[dst + 6] = vertices[src + 6];
+    expanded[dst + 7] = vertices[src + 7];
+    expanded[dst + 8] = tangents[i * 4];
+    expanded[dst + 9] = tangents[i * 4 + 1];
+    expanded[dst + 10] = tangents[i * 4 + 2];
+    expanded[dst + 11] = tangents[i * 4 + 3];
+  }
+  return ok({
+    kind: "mesh",
+    vertices: expanded,
+    indices,
+    attributes: buildAttributes(expanded, vertexCount),
+    submeshes: [
+      {
+        indexOffset: 0,
+        indexCount: indices.length,
+        vertexCount,
+        topology: "triangle-list",
+        materialSlot: 0
+      }
+    ],
+    materialSlots: [{ slotName: "Default" }],
+    // Procedural meshes carry their own local-space AABB: after feat-20260614
+    // (D-15) `allocSharedRef` stores the payload verbatim -- there is no
+    // `withMeshAabb` pass like the old `register`/`catalog` path -- so the cull
+    // + pick path can only read an AABB the POD already holds.
+    aabb: box3.fromPositions(box3.create(), positions)
+  });
+}
+function degenerate(detail) {
+  return new AssetError({
+    code: "asset-parse-failed",
+    expected: `all dimensions > 0; segments >= 1 (${detail})`,
+    hint: ASSET_ERROR_HINTS["asset-parse-failed"]
+  });
+}
+function createBoxGeometry(width, height, depth, widthSegments = 1, heightSegments = 1, depthSegments = 1) {
+  if (width <= 0 || height <= 0 || depth <= 0) {
+    return err(degenerate(`width=${width}, height=${height}, depth=${depth}`));
+  }
+  const ws = widthSegments | 0;
+  const hs = heightSegments | 0;
+  const ds = depthSegments | 0;
+  if (ws < 1 || hs < 1 || ds < 1) {
+    return err(degenerate(`widthSegments=${ws}, heightSegments=${hs}, depthSegments=${ds}`));
+  }
+  const hw = width / 2;
+  const hh = height / 2;
+  const hd = depth / 2;
+  const faces = [
+    // +X face
+    {
+      uAxis: 2,
+      vAxis: 1,
+      wAxis: 0,
+      uSign: -1,
+      vSign: 1,
+      wSign: 1,
+      uSegs: ds,
+      vSegs: hs,
+      uSize: depth,
+      vSize: height,
+      wSize: width
+    },
+    // -X face
+    {
+      uAxis: 2,
+      vAxis: 1,
+      wAxis: 0,
+      uSign: 1,
+      vSign: 1,
+      wSign: -1,
+      uSegs: ds,
+      vSegs: hs,
+      uSize: depth,
+      vSize: height,
+      wSize: width
+    },
+    // +Y face
+    {
+      uAxis: 0,
+      vAxis: 2,
+      wAxis: 1,
+      uSign: 1,
+      vSign: 1,
+      wSign: 1,
+      uSegs: ws,
+      vSegs: ds,
+      uSize: width,
+      vSize: depth,
+      wSize: height
+    },
+    // -Y face
+    {
+      uAxis: 0,
+      vAxis: 2,
+      wAxis: 1,
+      uSign: 1,
+      vSign: -1,
+      wSign: -1,
+      uSegs: ws,
+      vSegs: ds,
+      uSize: width,
+      vSize: depth,
+      wSize: height
+    },
+    // +Z face
+    {
+      uAxis: 0,
+      vAxis: 1,
+      wAxis: 2,
+      uSign: 1,
+      vSign: 1,
+      wSign: 1,
+      uSegs: ws,
+      vSegs: hs,
+      uSize: width,
+      vSize: height,
+      wSize: depth
+    },
+    // -Z face
+    {
+      uAxis: 0,
+      vAxis: 1,
+      wAxis: 2,
+      uSign: -1,
+      vSign: 1,
+      wSign: -1,
+      uSegs: ws,
+      vSegs: hs,
+      uSize: width,
+      vSize: height,
+      wSize: depth
+    }
+  ];
+  let vertexCount = 0;
+  let indexCount = 0;
+  for (const f of faces) {
+    vertexCount += (f.uSegs + 1) * (f.vSegs + 1);
+    indexCount += f.uSegs * f.vSegs * 6;
+  }
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  let iIdx = 0;
+  const halves = [hw, hh, hd];
+  for (const f of faces) {
+    const vStart = vIdx;
+    const halfU = halves[f.uAxis];
+    const halfV = halves[f.vAxis];
+    const halfW = halves[f.wAxis];
+    for (let j = 0; j <= f.vSegs; j++) {
+      for (let i = 0; i <= f.uSegs; i++) {
+        const uCoord = (i / f.uSegs * f.uSize - f.uSize / 2) * f.uSign;
+        const vCoord = (j / f.vSegs * f.vSize - f.vSize / 2) * f.vSign;
+        const pos = [0, 0, 0];
+        pos[f.uAxis] = uCoord / f.uSize * halfU * 2;
+        pos[f.vAxis] = vCoord / f.vSize * halfV * 2;
+        pos[f.wAxis] = halfW * f.wSign;
+        const normal = [0, 0, 0];
+        normal[f.wAxis] = f.wSign;
+        const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+        vertices[base + 0] = pos[0];
+        vertices[base + 1] = pos[1];
+        vertices[base + 2] = pos[2];
+        vertices[base + 3] = normal[0];
+        vertices[base + 4] = normal[1];
+        vertices[base + 5] = normal[2];
+        vertices[base + 6] = i / f.uSegs;
+        vertices[base + 7] = j / f.vSegs;
+        vIdx++;
+      }
+    }
+    const isCyclic = (f.vAxis - f.uAxis + 3) % 3 === 1 && (f.wAxis - f.vAxis + 3) % 3 === 1;
+    const levi = isCyclic ? 1 : -1;
+    const ccwOutward = levi * f.uSign * f.vSign * f.wSign > 0;
+    for (let j = 0; j < f.vSegs; j++) {
+      for (let i = 0; i < f.uSegs; i++) {
+        const a = vStart + j * (f.uSegs + 1) + i;
+        const b = vStart + j * (f.uSegs + 1) + i + 1;
+        const c = vStart + (j + 1) * (f.uSegs + 1) + i;
+        const d = vStart + (j + 1) * (f.uSegs + 1) + i + 1;
+        if (ccwOutward) {
+          indices[iIdx++] = a;
+          indices[iIdx++] = b;
+          indices[iIdx++] = d;
+          indices[iIdx++] = a;
+          indices[iIdx++] = d;
+          indices[iIdx++] = c;
+        } else {
+          indices[iIdx++] = a;
+          indices[iIdx++] = d;
+          indices[iIdx++] = b;
+          indices[iIdx++] = a;
+          indices[iIdx++] = c;
+          indices[iIdx++] = d;
+        }
+      }
+    }
+  }
+  return meshFromInterleaved(vertices, indices);
+}
+
+// src/assets/mesh-binary.ts
+function parseGuid(value) {
+  const compact = value.replaceAll("-", "");
+  if (!/^[0-9a-f]{32}$/i.test(compact)) return void 0;
+  const bytes = new Uint8Array(16);
+  for (let index = 0; index < bytes.length; index += 1) {
+    const pair = compact.slice(index * 2, index * 2 + 2);
+    const parsed = Number.parseInt(pair, 16);
+    if (!Number.isInteger(parsed)) return void 0;
+    bytes[index] = parsed;
+  }
+  return bytes;
+}
+function floatArray(value) {
+  if (value instanceof Float32Array) return value;
+  if (Array.isArray(value)) return new Float32Array(value);
+  return void 0;
+}
+function indexArray(value) {
+  if (value instanceof Uint16Array || value instanceof Uint32Array) {
+    return value.length === 0 ? void 0 : value;
+  }
+  if (!Array.isArray(value)) return void 0;
+  if (value.length === 0) return void 0;
+  return value.some((entry) => entry > 65535) ? new Uint32Array(value) : new Uint16Array(value);
+}
+function integerArray(value) {
+  if (value instanceof Uint16Array) return value;
+  if (Array.isArray(value)) return new Uint16Array(value);
+  return void 0;
+}
+function morphTargets(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length === 0 || value.length > 8) return void 0;
+  const targets = [];
+  for (const raw of value) {
+    if (raw === null || typeof raw !== "object") return void 0;
+    const target = {};
+    for (const [key, stream] of Object.entries(raw)) {
+      if (key !== "position" && key !== "normal" && key !== "tangent") return void 0;
+      const typed = floatArray(stream);
+      if (typed === void 0) return void 0;
+      if (key === "position") target.position = typed;
+      else if (key === "normal") target.normal = typed;
+      else target.tangent = typed;
+    }
+    if (Object.keys(target).length === 0) return void 0;
+    targets.push(target);
+  }
+  return targets;
+}
+function unpackMeshBinary(bytes) {
+  const headerResult = decodeMeshBinHeader(bytes);
+  if (!headerResult.ok) return void 0;
+  const header = headerResult.value;
+  const projectionResult = deriveVertexLayoutProjectionFromMask(header.mask);
+  if (!projectionResult.ok) return void 0;
+  const projection = projectionResult.value;
+  if (projection.schemaVersion !== header.projectionVersion || projection.arrayStride !== header.stride || projection.digest !== header.digest) {
+    return void 0;
+  }
+  const payloadBytes = header.vertexBytes + header.indexBytes + header.jsonBytes;
+  if (MESH_BIN_HEADER_V4_BYTES + payloadBytes !== bytes.byteLength) return void 0;
+  let offset = MESH_BIN_HEADER_V4_BYTES;
+  const vertexBytes = bytes.subarray(offset, offset + header.vertexBytes);
+  const vertices = new Float32Array(vertexBytes.byteLength / 4);
+  new Uint8Array(vertices.buffer).set(vertexBytes);
+  offset += header.vertexBytes;
+  let indices;
+  if (header.indexCount > 0) {
+    const indexBytes = bytes.subarray(offset, offset + header.indexBytes);
+    if (header.indexWidth === 2) {
+      indices = new Uint16Array(header.indexCount);
+      new Uint8Array(indices.buffer).set(indexBytes);
+    } else if (header.indexWidth === 4) {
+      indices = new Uint32Array(header.indexCount);
+      new Uint8Array(indices.buffer).set(indexBytes);
+    } else {
+      return void 0;
+    }
+    offset += header.indexBytes;
+  }
+  let metadata;
+  try {
+    metadata = JSON.parse(
+      new TextDecoder().decode(bytes.subarray(offset, offset + header.jsonBytes))
+    );
+  } catch {
+    return void 0;
+  }
+  if (metadata.submeshes === void 0 || metadata.submeshes.length === 0 || metadata.materialSlots === void 0) {
+    return void 0;
+  }
+  const attributes = {};
+  const view = new DataView(vertices.buffer);
+  for (const entry of projection.attributes) {
+    const components = entry.byteLength / (entry.format === "uint16x4" ? 2 : 4);
+    const target = entry.format === "uint16x4" ? new Uint16Array(header.vertexCount * components) : new Float32Array(header.vertexCount * components);
+    for (let vertex = 0; vertex < header.vertexCount; vertex += 1) {
+      for (let component = 0; component < components; component += 1) {
+        const sourceOffset = vertex * header.stride + entry.offset + component * (entry.format === "uint16x4" ? 2 : 4);
+        if (sourceOffset + (entry.format === "uint16x4" ? 2 : 4) > vertices.byteLength) {
+          return void 0;
+        }
+        if (target instanceof Uint16Array) {
+          target[vertex * components + component] = view.getUint16(sourceOffset, true);
+        } else {
+          const value = view.getFloat32(sourceOffset, true);
+          if (!Number.isFinite(value)) return void 0;
+          target[vertex * components + component] = value;
+        }
+      }
+    }
+    attributes[entry.key] = target;
+  }
+  const decodedMorphTargets = morphTargets(metadata.morphTargets);
+  const morphWeightValues = metadata.morphWeights === void 0 ? void 0 : new Float32Array(metadata.morphWeights);
+  if (decodedMorphTargets !== void 0 && morphWeightValues !== void 0 && decodedMorphTargets.length !== morphWeightValues.length) {
+    return void 0;
+  }
+  return {
+    version: MESH_BIN_VERSION,
+    vertices,
+    attributes,
+    projection,
+    ...indices === void 0 ? {} : { indices },
+    submeshes: metadata.submeshes,
+    materialSlots: metadata.materialSlots,
+    ...metadata.aabb === void 0 ? {} : { aabb: new Float32Array(metadata.aabb) },
+    // MeshAsset.vertices remains a Float32Array, so translate the wire stride
+    // (bytes) back to the legacy float-count input expected by meshFromParts.
+    floatsPerVertex: header.stride / Float32Array.BYTES_PER_ELEMENT,
+    uvSetCount: 1,
+    ...decodedMorphTargets === void 0 ? {} : { morphTargets: decodedMorphTargets },
+    ...morphWeightValues === void 0 ? {} : { morphWeights: morphWeightValues }
+  };
+}
+function materialSlotsFor(raw, submeshes, refs) {
+  if (raw === void 0)
+    return submeshes.map((_submesh, index) => ({ slotName: `LegacySlot_${index}` }));
+  return raw.map((slot, index) => {
+    const reference = slot.defaultMaterialRef === void 0 ? void 0 : refs[slot.defaultMaterialRef];
+    const defaultMaterial = reference === void 0 ? void 0 : parseGuid(reference);
+    return {
+      slotName: typeof slot.slotName === "string" && slot.slotName.trim().length > 0 ? slot.slotName : `LegacySlot_${index}`,
+      ...typeof slot.sourceKey === "string" ? { sourceKey: slot.sourceKey } : {},
+      ...defaultMaterial === void 0 ? {} : { defaultMaterial }
+    };
+  });
+}
+function submeshesFor(raw, vertexCount, indexCount) {
+  const values = raw === void 0 || raw.length === 0 ? [{ indexOffset: 0, indexCount, vertexCount, topology: "triangle-list" }] : raw;
+  return values.map((value, index) => ({
+    indexOffset: typeof value.indexOffset === "number" ? value.indexOffset : 0,
+    indexCount: typeof value.indexCount === "number" ? value.indexCount : indexCount,
+    vertexCount: typeof value.vertexCount === "number" ? value.vertexCount : vertexCount,
+    topology: value.topology === "line-list" || value.topology === "line-strip" || value.topology === "point-list" || value.topology === "triangle-strip" ? value.topology : "triangle-list",
+    materialSlot: typeof value.materialSlot === "number" ? value.materialSlot : index
+  }));
+}
+function deriveAabb(vertices, stride) {
+  if (stride < 3 || vertices.length < 3 || vertices.length % stride !== 0) return void 0;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let minZ = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  let maxZ = Number.NEGATIVE_INFINITY;
+  for (let offset = 0; offset < vertices.length; offset += stride) {
+    const x = vertices[offset];
+    const y = vertices[offset + 1];
+    const z = vertices[offset + 2];
+    if (x === void 0 || y === void 0 || z === void 0) return void 0;
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    minZ = Math.min(minZ, z);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+    maxZ = Math.max(maxZ, z);
+  }
+  return Float32Array.of(minX, minY, minZ, maxX, maxY, maxZ);
+}
+function meshFromParts(parts, refs) {
+  const vertices = floatArray(parts.vertices);
+  if (vertices === void 0 || vertices.length === 0) return void 0;
+  const indices = indexArray(parts.indices);
+  const sourceAttributes = parts.attributes !== null && typeof parts.attributes === "object" ? parts.attributes : {};
+  const attributes = {};
+  for (const key of [
+    "position",
+    "normal",
+    "uv",
+    "tangent",
+    "uv1",
+    "uv2",
+    "uv3",
+    "uv4",
+    "uv5",
+    "uv6",
+    "uv7",
+    "color"
+  ]) {
+    const value = floatArray(sourceAttributes[key]);
+    if (value !== void 0) attributes[key] = value;
+  }
+  const skinIndex = integerArray(sourceAttributes.skinIndex);
+  const skinWeight = floatArray(sourceAttributes.skinWeight);
+  if (skinIndex !== void 0) attributes.skinIndex = skinIndex;
+  if (skinWeight !== void 0) attributes.skinWeight = skinWeight;
+  const stride = parts.floatsPerVertex ?? 0;
+  const vertexCount = stride > 0 ? vertices.length / stride : vertices.length;
+  const submeshes = submeshesFor(parts.submeshes, vertexCount, indices?.length ?? 0);
+  const materialSlots = materialSlotsFor(parts.materialSlots, submeshes, refs);
+  const aabb = floatArray(parts.aabb) ?? deriveAabb(vertices, stride);
+  if (aabb === void 0) return void 0;
+  const morph = morphTargets(parts.morphTargets);
+  const weights = floatArray(parts.morphWeights);
+  if (morph !== void 0 && weights !== void 0 && morph.length !== weights.length)
+    return void 0;
+  const uvSetCount = parts.uvSetCount ?? 1;
+  if (stride > 0 && uvSetCount > 1) {
+    const hasSkin = stride === 18 + (uvSetCount - 1) * 2;
+    const firstOffset = hasSkin ? 18 : PROCEDURAL_FLOATS_PER_VERTEX;
+    const extraUvKeys = ["uv1", "uv2", "uv3", "uv4", "uv5", "uv6", "uv7"];
+    for (let set = 1; set < uvSetCount; set += 1) {
+      const key = extraUvKeys[set - 1];
+      if (key === void 0) return void 0;
+      const values = new Float32Array(vertexCount * 2);
+      const sourceOffset = firstOffset + (set - 1) * 2;
+      for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        const source = vertex * stride + sourceOffset;
+        values[vertex * 2] = vertices[source] ?? 0;
+        values[vertex * 2 + 1] = vertices[source + 1] ?? 0;
+      }
+      attributes[key] = values;
+    }
+  }
+  return {
+    kind: "mesh",
+    vertices,
+    ...indices === void 0 ? {} : { indices },
+    attributes,
+    aabb,
+    submeshes,
+    materialSlots,
+    ...morph === void 0 ? {} : { morphTargets: morph },
+    ...weights === void 0 ? {} : { morphWeights: weights }
+  };
+}
+function decodeMeshBinary(bytes, refs) {
+  const decoded = unpackMeshBinary(bytes);
+  if (decoded === void 0) return void 0;
+  return meshFromParts(
+    {
+      vertices: decoded.vertices,
+      ...decoded.attributes === void 0 ? {} : { attributes: decoded.attributes },
+      ...decoded.indices === void 0 ? {} : { indices: decoded.indices },
+      ...decoded.aabb === void 0 ? {} : { aabb: decoded.aabb },
+      ...decoded.submeshes === void 0 ? {} : { submeshes: decoded.submeshes },
+      ...decoded.materialSlots === void 0 ? {} : { materialSlots: decoded.materialSlots },
+      ...decoded.morphTargets === void 0 ? {} : { morphTargets: decoded.morphTargets },
+      ...decoded.morphWeights === void 0 ? {} : { morphWeights: decoded.morphWeights },
+      ...decoded.skinIndex === void 0 && decoded.skinWeight === void 0 ? {} : {
+        attributes: {
+          ...decoded.skinIndex === void 0 ? {} : { skinIndex: decoded.skinIndex },
+          ...decoded.skinWeight === void 0 ? {} : { skinWeight: decoded.skinWeight }
+        }
+      },
+      floatsPerVertex: decoded.floatsPerVertex,
+      uvSetCount: decoded.uvSetCount
+    },
+    refs
+  );
+}
+function normalizeMeshPayload(payload, refs) {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+  const source = payload;
+  if (source.kind !== "mesh") return void 0;
+  return meshFromParts(
+    {
+      vertices: source.vertices,
+      ...source.indices === void 0 ? {} : { indices: source.indices },
+      ...source.attributes === void 0 ? {} : { attributes: source.attributes },
+      ...source.aabb === void 0 ? {} : { aabb: source.aabb },
+      submeshes: Array.isArray(source.submeshes) ? source.submeshes : [],
+      ...Array.isArray(source.materialSlots) ? { materialSlots: source.materialSlots } : {},
+      ...source.morphTargets === void 0 ? {} : { morphTargets: source.morphTargets },
+      ...source.morphWeights === void 0 ? {} : { morphWeights: source.morphWeights },
+      floatsPerVertex: PROCEDURAL_FLOATS_PER_VERTEX
+    },
+    refs
+  );
+}
+function createCylinderGeometry(radiusTop, radiusBottom, height, radialSegments = 16, heightSegments = 1) {
+  if (radiusTop < 0 || radiusBottom < 0 || height <= 0) {
+    return err(
+      degenerate(`radiusTop=${radiusTop}, radiusBottom=${radiusBottom}, height=${height}`)
+    );
+  }
+  if (radiusTop === 0 && radiusBottom === 0) {
+    return err(degenerate(`radiusTop=0 and radiusBottom=0; at least one must be > 0`));
+  }
+  const rs = radialSegments | 0;
+  const hs = heightSegments | 0;
+  if (rs < 3) return err(degenerate(`radialSegments=${rs}; minimum 3`));
+  if (hs < 1) return err(degenerate(`heightSegments=${hs}; minimum 1`));
+  const halfHeight = height / 2;
+  const sideVertexCount = (rs + 1) * (hs + 1);
+  const topCap = radiusTop > 0;
+  const bottomCap = radiusBottom > 0;
+  const topCount = topCap ? rs + 2 : 0;
+  const bottomCount = bottomCap ? rs + 2 : 0;
+  const vertexCount = sideVertexCount + topCount + bottomCount;
+  const sideIndexCount = rs * hs * 6;
+  const topIdxCount = topCap ? rs * 3 : 0;
+  const bottomIdxCount = bottomCap ? rs * 3 : 0;
+  const indexCount = sideIndexCount + topIdxCount + bottomIdxCount;
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  const slope = (radiusBottom - radiusTop) / height;
+  for (let iy = 0; iy <= hs; iy++) {
+    const v = iy / hs;
+    const y = halfHeight - v * height;
+    const radius = v * (radiusBottom - radiusTop) + radiusTop;
+    for (let ix = 0; ix <= rs; ix++) {
+      const u = ix / rs;
+      const theta = u * Math.PI * 2;
+      const sinT = Math.sin(theta);
+      const cosT = Math.cos(theta);
+      const x = radius * sinT;
+      const z = radius * cosT;
+      const nx = sinT;
+      const ny = slope;
+      const nz = cosT;
+      const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = x;
+      vertices[base + 1] = y;
+      vertices[base + 2] = z;
+      vertices[base + 3] = nx / nlen;
+      vertices[base + 4] = ny / nlen;
+      vertices[base + 5] = nz / nlen;
+      vertices[base + 6] = u;
+      vertices[base + 7] = v;
+      vIdx++;
+    }
+  }
+  let iIdx = 0;
+  for (let iy = 0; iy < hs; iy++) {
+    for (let ix = 0; ix < rs; ix++) {
+      const a = (rs + 1) * iy + ix;
+      const b = (rs + 1) * (iy + 1) + ix;
+      const c = (rs + 1) * (iy + 1) + ix + 1;
+      const d = (rs + 1) * iy + ix + 1;
+      indices[iIdx++] = a;
+      indices[iIdx++] = b;
+      indices[iIdx++] = d;
+      indices[iIdx++] = b;
+      indices[iIdx++] = c;
+      indices[iIdx++] = d;
+    }
+  }
+  if (topCap) {
+    const centerIdx = vIdx;
+    const cBase = vIdx * FACTORY_FLOATS_PER_VERTEX;
+    vertices[cBase + 0] = 0;
+    vertices[cBase + 1] = halfHeight;
+    vertices[cBase + 2] = 0;
+    vertices[cBase + 3] = 0;
+    vertices[cBase + 4] = 1;
+    vertices[cBase + 5] = 0;
+    vertices[cBase + 6] = 0.5;
+    vertices[cBase + 7] = 0.5;
+    vIdx++;
+    const ringStart = vIdx;
+    for (let ix = 0; ix <= rs; ix++) {
+      const u = ix / rs;
+      const theta = u * Math.PI * 2;
+      const sinT = Math.sin(theta);
+      const cosT = Math.cos(theta);
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = radiusTop * sinT;
+      vertices[base + 1] = halfHeight;
+      vertices[base + 2] = radiusTop * cosT;
+      vertices[base + 3] = 0;
+      vertices[base + 4] = 1;
+      vertices[base + 5] = 0;
+      vertices[base + 6] = sinT * 0.5 + 0.5;
+      vertices[base + 7] = cosT * 0.5 + 0.5;
+      vIdx++;
+    }
+    for (let ix = 0; ix < rs; ix++) {
+      indices[iIdx++] = centerIdx;
+      indices[iIdx++] = ringStart + ix;
+      indices[iIdx++] = ringStart + ix + 1;
+    }
+  }
+  if (bottomCap) {
+    const centerIdx = vIdx;
+    const cBase = vIdx * FACTORY_FLOATS_PER_VERTEX;
+    vertices[cBase + 0] = 0;
+    vertices[cBase + 1] = -halfHeight;
+    vertices[cBase + 2] = 0;
+    vertices[cBase + 3] = 0;
+    vertices[cBase + 4] = -1;
+    vertices[cBase + 5] = 0;
+    vertices[cBase + 6] = 0.5;
+    vertices[cBase + 7] = 0.5;
+    vIdx++;
+    const ringStart = vIdx;
+    for (let ix = 0; ix <= rs; ix++) {
+      const u = ix / rs;
+      const theta = u * Math.PI * 2;
+      const sinT = Math.sin(theta);
+      const cosT = Math.cos(theta);
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = radiusBottom * sinT;
+      vertices[base + 1] = -halfHeight;
+      vertices[base + 2] = radiusBottom * cosT;
+      vertices[base + 3] = 0;
+      vertices[base + 4] = -1;
+      vertices[base + 5] = 0;
+      vertices[base + 6] = sinT * 0.5 + 0.5;
+      vertices[base + 7] = cosT * 0.5 + 0.5;
+      vIdx++;
+    }
+    for (let ix = 0; ix < rs; ix++) {
+      indices[iIdx++] = centerIdx;
+      indices[iIdx++] = ringStart + ix + 1;
+      indices[iIdx++] = ringStart + ix;
+    }
+  }
+  return meshFromInterleaved(vertices, indices);
+}
+function createPlaneGeometry(width, height, widthSegments = 1, heightSegments = 1) {
+  if (width <= 0 || height <= 0) {
+    return err(degenerate(`width=${width}, height=${height}`));
+  }
+  const ws = widthSegments | 0;
+  const hs = heightSegments | 0;
+  if (ws < 1 || hs < 1) {
+    return err(degenerate(`widthSegments=${ws}, heightSegments=${hs}`));
+  }
+  const halfW = width / 2;
+  const halfH = height / 2;
+  const gridX1 = ws + 1;
+  const gridY1 = hs + 1;
+  const segW = width / ws;
+  const segH = height / hs;
+  const vertexCount = gridX1 * gridY1;
+  const indexCount = ws * hs * 6;
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  for (let iy = 0; iy < gridY1; iy++) {
+    const y = iy * segH - halfH;
+    for (let ix = 0; ix < gridX1; ix++) {
+      const x = ix * segW - halfW;
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = x;
+      vertices[base + 1] = -y;
+      vertices[base + 2] = 0;
+      vertices[base + 3] = 0;
+      vertices[base + 4] = 0;
+      vertices[base + 5] = 1;
+      vertices[base + 6] = ix / ws;
+      vertices[base + 7] = iy / hs;
+      vIdx++;
+    }
+  }
+  let iIdx = 0;
+  for (let iy = 0; iy < hs; iy++) {
+    for (let ix = 0; ix < ws; ix++) {
+      const a = ix + gridX1 * iy;
+      const b = ix + gridX1 * (iy + 1);
+      const c = ix + 1 + gridX1 * (iy + 1);
+      const d = ix + 1 + gridX1 * iy;
+      indices[iIdx++] = a;
+      indices[iIdx++] = b;
+      indices[iIdx++] = d;
+      indices[iIdx++] = b;
+      indices[iIdx++] = c;
+      indices[iIdx++] = d;
+    }
+  }
+  return meshFromInterleaved(vertices, indices);
+}
+function createSphereGeometry(radius, widthSegments = 16, heightSegments = 12) {
+  if (radius <= 0) return err(degenerate(`radius=${radius}`));
+  const ws = widthSegments | 0;
+  const hs = heightSegments | 0;
+  if (ws < 3) return err(degenerate(`widthSegments=${ws}; minimum 3`));
+  if (hs < 2) return err(degenerate(`heightSegments=${hs}; minimum 2`));
+  const vertexCount = (ws + 1) * (hs + 1);
+  const indexCount = ws * hs * 6;
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  for (let iy = 0; iy <= hs; iy++) {
+    const v = iy / hs;
+    const phi = v * Math.PI;
+    for (let ix = 0; ix <= ws; ix++) {
+      const u = ix / ws;
+      const theta = u * Math.PI * 2;
+      const x = -radius * Math.cos(theta) * Math.sin(phi);
+      const y = radius * Math.cos(phi);
+      const z = radius * Math.sin(theta) * Math.sin(phi);
+      const nx = x / radius;
+      const ny = y / radius;
+      const nz = z / radius;
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = x;
+      vertices[base + 1] = y;
+      vertices[base + 2] = z;
+      vertices[base + 3] = nx;
+      vertices[base + 4] = ny;
+      vertices[base + 5] = nz;
+      vertices[base + 6] = u;
+      vertices[base + 7] = v;
+      vIdx++;
+    }
+  }
+  let iIdx = 0;
+  const stride = ws + 1;
+  for (let iy = 0; iy < hs; iy++) {
+    for (let ix = 0; ix < ws; ix++) {
+      const a = iy * stride + ix + 1;
+      const b = iy * stride + ix;
+      const c = (iy + 1) * stride + ix;
+      const d = (iy + 1) * stride + ix + 1;
+      if (iy !== 0) {
+        indices[iIdx++] = a;
+        indices[iIdx++] = b;
+        indices[iIdx++] = d;
+      }
+      if (iy !== hs - 1) {
+        indices[iIdx++] = b;
+        indices[iIdx++] = c;
+        indices[iIdx++] = d;
+      }
+    }
+  }
+  const trimmed = indices.slice(0, iIdx);
+  return meshFromInterleaved(vertices, trimmed);
+}
+
+// src/assets/primitive-mesh.ts
+function createPrimitiveMesh(kind) {
+  switch (kind) {
+    case "cube":
+      return createBoxGeometry(1, 1, 1);
+    case "triangle":
+      return meshFromInterleaved(
+        new Float32Array([
+          0,
+          0.7,
+          0,
+          0,
+          0,
+          1,
+          0.5,
+          1,
+          -0.7,
+          -0.6,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0.7,
+          -0.6,
+          0,
+          0,
+          0,
+          1,
+          1,
+          0
+        ]),
+        new Uint16Array([0, 1, 2])
+      );
+    case "quad":
+      return createPlaneGeometry(1, 1);
+    case "sphere":
+      return createSphereGeometry(1, 16, 12);
+    case "cylinder":
+      return createCylinderGeometry(0.5, 0.5, 1, 16, 1);
+    case "nine-slice-quad":
+      return createPlaneGeometry(1, 1, 3, 3);
+  }
+}
+
+// src/assets/mesh-decoder.ts
+var meshAssetKind = {
+  kind: "mesh"
+};
+var PROCEDURAL_MESH_KINDS = {
+  "procedural-cube": "cube",
+  "procedural-triangle": "triangle",
+  "procedural-quad": "quad",
+  "procedural-sphere": "sphere",
+  "procedural-cylinder": "cylinder",
+  "procedural-nine-slice-quad": "nine-slice-quad"
+};
+function proceduralMesh(payload) {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) return void 0;
+  const geometry = payload.geometry;
+  if (typeof geometry !== "string") return void 0;
+  const kind = PROCEDURAL_MESH_KINDS[geometry];
+  if (kind === void 0) return void 0;
+  const result = createPrimitiveMesh(kind);
+  if (result.ok) return result;
+  return err({
+    code: "asset-package-invalid",
+    expected: `a valid procedural ${kind} mesh payload`,
+    hint: "recook the authored procedural mesh descriptor",
+    detail: { guid: "", reason: "procedural mesh creation failed" }
+  });
+}
+var meshAssetDecoder = {
+  async decode({ envelope, artifacts }) {
+    const payload = envelope.payload;
+    const procedural = proceduralMesh(payload);
+    if (procedural !== void 0) {
+      if (!procedural.ok) {
+        return err({
+          code: "asset-package-invalid",
+          expected: procedural.error.expected,
+          hint: procedural.error.hint,
+          detail: { guid: envelope.guid, reason: "procedural mesh creation failed" }
+        });
+      }
+      return procedural;
+    }
+    const body = envelope.artifacts.body;
+    if (body !== void 0) {
+      const bytes = await artifacts.read(body);
+      if (!bytes.ok) return err(bytes.error);
+      const decoded = decodeMeshBinary(bytes.value, envelope.refs);
+      if (decoded === void 0) {
+        return err({
+          code: "asset-package-invalid",
+          expected: "a valid mesh-binary/4 body artifact with a local-space AABB",
+          hint: "recook the mesh binary and publish its validated geometry payload",
+          detail: { guid: envelope.guid, reason: "mesh binary decode failed" }
+        });
+      }
+      return ok(decoded);
+    }
+    const normalized = normalizeMeshPayload(payload, envelope.refs);
+    if (normalized !== void 0) return ok(normalized);
+    if (payload.kind !== "mesh" || !(payload.vertices instanceof Float32Array) || payload.vertices.length === 0 || payload.aabb === void 0) {
+      return err({
+        code: "asset-package-invalid",
+        expected: "a mesh payload with vertices and a local-space AABB",
+        hint: "recook the mesh binary and publish its validated geometry payload",
+        detail: { guid: envelope.guid, reason: "mesh payload failed geometry validation" }
+      });
+    }
+    return ok(payload);
+  }
+};
+var meshAssetContribution = {
+  kind: meshAssetKind,
+  decoder: meshAssetDecoder,
+  consumer: "Geometry"
+};
+function createCapsuleGeometry(radius, length, capSegments = 4, radialSegments = 8) {
+  if (radius <= 0) return err(degenerate(`radius=${radius}`));
+  if (length < 0) return err(degenerate(`length=${length}`));
+  const cs = capSegments | 0;
+  const rs = radialSegments | 0;
+  if (cs < 1) return err(degenerate(`capSegments=${cs}; minimum 1`));
+  if (rs < 3) return err(degenerate(`radialSegments=${rs}; minimum 3`));
+  const halfLength = length / 2;
+  const latRows = 2 * (cs + 1);
+  const vertexCount = latRows * (rs + 1);
+  const indexCount = (latRows - 1) * rs * 6;
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  for (let row = 0; row < latRows; row++) {
+    const topHemi = row <= cs;
+    let ringR;
+    let y;
+    let centerY;
+    if (topHemi) {
+      const t = row / cs;
+      const a = t * (Math.PI / 2);
+      ringR = radius * Math.sin(a);
+      centerY = halfLength;
+      y = centerY + radius * Math.cos(a);
+    } else {
+      const t = (row - (cs + 1)) / cs;
+      const a = t * (Math.PI / 2);
+      ringR = radius * Math.cos(a);
+      centerY = -halfLength;
+      y = centerY - radius * Math.sin(a);
+    }
+    const v = row / (latRows - 1);
+    for (let ix = 0; ix <= rs; ix++) {
+      const u = ix / rs;
+      const theta = u * Math.PI * 2;
+      const sinT = Math.sin(theta);
+      const cosT = Math.cos(theta);
+      const x = ringR * sinT;
+      const z = ringR * cosT;
+      const nx = x;
+      const ny = y - centerY;
+      const nz = z;
+      const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = x;
+      vertices[base + 1] = y;
+      vertices[base + 2] = z;
+      vertices[base + 3] = nx / nlen;
+      vertices[base + 4] = ny / nlen;
+      vertices[base + 5] = nz / nlen;
+      vertices[base + 6] = u;
+      vertices[base + 7] = v;
+      vIdx++;
+    }
+  }
+  let iIdx = 0;
+  const stride = rs + 1;
+  for (let row = 0; row < latRows - 1; row++) {
+    for (let ix = 0; ix < rs; ix++) {
+      const a = row * stride + ix + 1;
+      const b = row * stride + ix;
+      const c = (row + 1) * stride + ix;
+      const d = (row + 1) * stride + ix + 1;
+      const northPoleRow = row === 0;
+      const southPoleRow = row === latRows - 2;
+      if (!northPoleRow) {
+        indices[iIdx++] = a;
+        indices[iIdx++] = b;
+        indices[iIdx++] = d;
+      }
+      if (!southPoleRow) {
+        indices[iIdx++] = b;
+        indices[iIdx++] = c;
+        indices[iIdx++] = d;
+      }
+    }
+  }
+  const trimmed = indices.slice(0, iIdx);
+  return meshFromInterleaved(vertices, trimmed);
+}
+function createConeGeometry(radius, height, radialSegments = 16, heightSegments = 1) {
+  if (radius <= 0) return err(degenerate(`radius=${radius}`));
+  if (height <= 0) return err(degenerate(`height=${height}`));
+  return createCylinderGeometry(0, radius, height, radialSegments, heightSegments);
+}
+var DEFAULT_RESOLUTION = 32;
+function invalid(detail) {
+  return err(degenerate(detail));
+}
+function resolution(value) {
+  const resolved = value ?? DEFAULT_RESOLUTION;
+  const integer = resolved | 0;
+  return integer >= 3 && integer === resolved ? integer : void 0;
+}
+function finitePoint(point) {
+  return Number.isFinite(point[0]) && Number.isFinite(point[1]);
+}
+function maskRadius(shape) {
+  switch (shape.kind) {
+    case "circle":
+    case "circular-sector":
+    case "circular-segment":
+      return shape.radius;
+    case "ellipse":
+    case "annulus":
+    case "capsule":
+    case "rhombus":
+    case "rectangle":
+    case "regular-polygon":
+    case "triangle":
+    case "segment":
+    case "polyline":
+      return void 0;
+  }
+}
+function validateMeshOptions(shape, options) {
+  const uv = options?.uv;
+  if (uv === void 0) return ok(void 0);
+  const radius = maskRadius(shape);
+  return radius !== void 0 && radius > 0 && Number.isFinite(uv.angle) ? ok({ kind: "circular-mask", radius, angle: uv.angle }) : invalid(`circular-mask UV requires a circular shape and finite angle`);
+}
+function area(points) {
+  let value = 0;
+  for (let i = 0; i < points.length; i++) {
+    const a = points[i];
+    const b = points[(i + 1) % points.length];
+    if (!a || !b) continue;
+    value += a[0] * b[1] - b[0] * a[1];
+  }
+  return value / 2;
+}
+function centroid(points) {
+  let x = 0;
+  let y = 0;
+  for (const point of points) {
+    x += point[0];
+    y += point[1];
+  }
+  const count = Math.max(1, points.length);
+  return [x / count, y / count];
+}
+function counterClockwise(points) {
+  return area(points) < 0 ? [...points].reverse() : [...points];
+}
+function circleBoundary(radius, count, start = -Math.PI / 2) {
+  return Array.from({ length: count }, (_, i) => {
+    const angle = start + i / count * Math.PI * 2;
+    return [Math.cos(angle) * radius, Math.sin(angle) * radius];
+  });
+}
+function arcBoundary(radius, angle, count, start) {
+  return Array.from({ length: count + 1 }, (_, i) => {
+    const t = i / count;
+    const current = start + angle * t;
+    return [Math.cos(current) * radius, Math.sin(current) * radius];
+  });
+}
+function ellipseBoundary(halfWidth, halfHeight, count) {
+  return Array.from({ length: count }, (_, i) => {
+    const angle = -Math.PI / 2 + i / count * Math.PI * 2;
+    return [Math.cos(angle) * halfWidth, Math.sin(angle) * halfHeight];
+  });
+}
+function capsuleBoundary(radius, halfLength, count) {
+  const points = [];
+  for (let i = 0; i <= count; i++) {
+    const angle = i / count * Math.PI;
+    points.push([Math.cos(angle) * radius, halfLength + Math.sin(angle) * radius]);
+  }
+  for (let i = 0; i <= count; i++) {
+    const angle = Math.PI + i / count * Math.PI;
+    points.push([Math.cos(angle) * radius, -halfLength + Math.sin(angle) * radius]);
+  }
+  points.pop();
+  points.shift();
+  return points;
+}
+function buildMesh(points, indices, topology, uvProjection) {
+  const positions = new Float32Array(points.length * 3);
+  const normals = new Float32Array(points.length * 3);
+  const uvs = new Float32Array(points.length * 2);
+  const tangents = new Float32Array(points.length * 4);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const point of points) {
+    minX = Math.min(minX, point[0]);
+    minY = Math.min(minY, point[1]);
+    maxX = Math.max(maxX, point[0]);
+    maxY = Math.max(maxY, point[1]);
+  }
+  const width = Math.max(maxX - minX, 1);
+  const height = Math.max(maxY - minY, 1);
+  const vertices = new Float32Array(points.length * PROCEDURAL_FLOATS_PER_VERTEX);
+  for (let i = 0; i < points.length; i++) {
+    const point = points[i];
+    if (!point) continue;
+    const [x, y] = point;
+    const positionOffset = i * 3;
+    const uvOffset = i * 2;
+    const tangentOffset = i * 4;
+    const vertexOffset = i * PROCEDURAL_FLOATS_PER_VERTEX;
+    positions[positionOffset] = x;
+    positions[positionOffset + 1] = y;
+    normals[positionOffset + 2] = 1;
+    const cos = uvProjection === void 0 ? 1 : Math.cos(uvProjection.angle);
+    const sin = uvProjection === void 0 ? 0 : Math.sin(uvProjection.angle);
+    const projectedX = x * cos - y * sin;
+    const projectedY = x * sin + y * cos;
+    const u = uvProjection === void 0 ? (x - minX) / width : 0.5 + projectedX / (2 * uvProjection.radius);
+    const v = uvProjection === void 0 ? (maxY - y) / height : 0.5 - projectedY / (2 * uvProjection.radius);
+    uvs[uvOffset] = u;
+    uvs[uvOffset + 1] = v;
+    tangents[tangentOffset] = 1;
+    tangents[tangentOffset + 3] = 1;
+    vertices[vertexOffset] = x;
+    vertices[vertexOffset + 1] = y;
+    vertices[vertexOffset + 5] = 1;
+    vertices[vertexOffset + 6] = u;
+    vertices[vertexOffset + 7] = v;
+    vertices[vertexOffset + 8] = 1;
+    vertices[vertexOffset + 11] = 1;
+  }
+  return {
+    kind: "mesh",
+    vertices,
+    indices: new Uint32Array(indices),
+    attributes: { position: positions, normal: normals, uv: uvs, tangent: tangents },
+    submeshes: [
+      {
+        indexOffset: 0,
+        indexCount: indices.length,
+        vertexCount: points.length,
+        topology,
+        materialSlot: 0
+      }
+    ],
+    materialSlots: [{ slotName: "Default" }],
+    aabb: box3.fromPositions(box3.create(), positions)
+  };
+}
+function fill(points, uvProjection) {
+  const boundary = counterClockwise(points);
+  const center = centroid(boundary);
+  const vertices = [center, ...boundary];
+  const indices = [];
+  for (let i = 0; i < boundary.length; i++) {
+    const next = (i + 1) % boundary.length;
+    indices.push(0, i + 1, next + 1);
+  }
+  return buildMesh(vertices, indices, "triangle-list", uvProjection);
+}
+function ring(outer, inner) {
+  const outside = counterClockwise(outer);
+  const inside = counterClockwise(inner);
+  const count = Math.min(outside.length, inside.length);
+  const vertices = [...outside.slice(0, count), ...inside.slice(0, count)];
+  const indices = [];
+  for (let i = 0; i < count; i++) {
+    const next = (i + 1) % count;
+    indices.push(i, next, count + i, next, count + next, count + i);
+  }
+  return buildMesh(vertices, indices, "triangle-list");
+}
+function segment(points) {
+  const indices = [];
+  for (let i = 0; i + 1 < points.length; i += 1) indices.push(i, i + 1);
+  return buildMesh(points, indices, "line-list");
+}
+function shapeBoundary(shape, count) {
+  switch (shape.kind) {
+    case "circle":
+      return circleBoundary(shape.radius, count);
+    case "circular-sector":
+      return [
+        ...arcBoundary(shape.radius, shape.angle, count, -Math.PI / 2 - shape.angle / 2),
+        [0, 0]
+      ];
+    case "circular-segment":
+      return arcBoundary(shape.radius, shape.angle, count, -Math.PI / 2 - shape.angle / 2);
+    case "ellipse":
+      return ellipseBoundary(shape.halfWidth, shape.halfHeight, count);
+    case "capsule":
+      return capsuleBoundary(shape.radius, shape.halfLength, Math.max(2, Math.floor(count / 2)));
+    case "rhombus":
+      return [
+        [0, shape.halfHeight],
+        [shape.halfWidth, 0],
+        [0, -shape.halfHeight],
+        [-shape.halfWidth, 0]
+      ];
+    case "rectangle":
+      return [
+        [-shape.width / 2, -shape.height / 2],
+        [shape.width / 2, -shape.height / 2],
+        [shape.width / 2, shape.height / 2],
+        [-shape.width / 2, shape.height / 2]
+      ];
+    case "regular-polygon":
+      return Array.from({ length: shape.sides }, (_, i) => {
+        const angle = -Math.PI / 2 + i / shape.sides * Math.PI * 2;
+        return [Math.cos(angle) * shape.radius, Math.sin(angle) * shape.radius];
+      });
+    case "triangle":
+      return [...shape.vertices];
+    case "annulus":
+    case "segment":
+    case "polyline":
+      return void 0;
+  }
+}
+function scaleAround(points, factor) {
+  const center = centroid(points);
+  return points.map(([x, y]) => [
+    center[0] + (x - center[0]) * factor,
+    center[1] + (y - center[1]) * factor
+  ]);
+}
+function withResolution(value, valid, detail) {
+  const count = resolution(value);
+  return valid && count !== void 0 ? ok(count) : invalid(detail);
+}
+function validateCommon(shape) {
+  switch (shape.kind) {
+    case "circle":
+      return withResolution(
+        shape.resolution,
+        shape.radius > 0 && Number.isFinite(shape.radius),
+        `circle radius=${shape.radius}, resolution=${shape.resolution}`
+      );
+    case "circular-sector":
+    case "circular-segment":
+      return withResolution(
+        shape.resolution,
+        shape.radius > 0 && shape.angle > 0 && shape.angle <= Math.PI * 2 && Number.isFinite(shape.radius) && Number.isFinite(shape.angle),
+        `${shape.kind} radius=${shape.radius}, angle=${shape.angle}, resolution=${shape.resolution}`
+      );
+    case "ellipse":
+      return withResolution(
+        shape.resolution,
+        shape.halfWidth > 0 && shape.halfHeight > 0 && Number.isFinite(shape.halfWidth) && Number.isFinite(shape.halfHeight),
+        `ellipse halfWidth=${shape.halfWidth}, halfHeight=${shape.halfHeight}, resolution=${shape.resolution}`
+      );
+    case "annulus":
+      return withResolution(
+        shape.resolution,
+        shape.innerRadius >= 0 && shape.outerRadius > shape.innerRadius && Number.isFinite(shape.innerRadius) && Number.isFinite(shape.outerRadius),
+        `annulus innerRadius=${shape.innerRadius}, outerRadius=${shape.outerRadius}, resolution=${shape.resolution}`
+      );
+    case "capsule":
+      return withResolution(
+        shape.resolution,
+        shape.radius > 0 && shape.halfLength >= 0 && Number.isFinite(shape.radius) && Number.isFinite(shape.halfLength),
+        `capsule radius=${shape.radius}, halfLength=${shape.halfLength}, resolution=${shape.resolution}`
+      );
+    case "rhombus":
+      return shape.halfWidth > 0 && shape.halfHeight > 0 && Number.isFinite(shape.halfWidth) && Number.isFinite(shape.halfHeight) ? ok(0) : invalid(`rhombus halfWidth=${shape.halfWidth}, halfHeight=${shape.halfHeight}`);
+    case "rectangle":
+      return shape.width > 0 && shape.height > 0 && Number.isFinite(shape.width) && Number.isFinite(shape.height) ? ok(0) : invalid(`rectangle width=${shape.width}, height=${shape.height}`);
+    case "regular-polygon":
+      return shape.radius > 0 && Number.isFinite(shape.radius) && Number.isInteger(shape.sides) && shape.sides >= 3 ? ok(0) : invalid(`regular-polygon radius=${shape.radius}, sides=${shape.sides}`);
+    case "triangle":
+      return shape.vertices.every(finitePoint) && Math.abs(area(shape.vertices)) > 1e-7 ? ok(0) : invalid("triangle vertices must be finite and non-collinear");
+    case "segment":
+      return shape.vertices.every(finitePoint) && (shape.vertices[0][0] !== shape.vertices[1][0] || shape.vertices[0][1] !== shape.vertices[1][1]) ? ok(0) : invalid("segment endpoints must be finite and distinct");
+    case "polyline":
+      return shape.vertices.length >= 2 && shape.vertices.every(finitePoint) ? ok(0) : invalid("polyline needs at least two finite vertices");
+  }
+}
+function create2dGeometry(shape, options) {
+  const checked = validateCommon(shape);
+  if (!checked.ok) return checked;
+  const meshOptions = validateMeshOptions(shape, options);
+  if (!meshOptions.ok) return meshOptions;
+  if (shape.kind === "segment" || shape.kind === "polyline") return ok(segment(shape.vertices));
+  if (shape.kind === "annulus") {
+    const outer = circleBoundary(shape.outerRadius, checked.value);
+    const inner = circleBoundary(shape.innerRadius, checked.value);
+    return ok(ring(outer, inner));
+  }
+  const points = shapeBoundary(shape, checked.value);
+  if (!points) return invalid(`unsupported 2d shape kind=${shape.kind}`);
+  return ok(fill(points, meshOptions.value));
+}
+function boundsPoints(shape, count) {
+  if (shape.kind === "annulus") return circleBoundary(shape.outerRadius, count);
+  if (shape.kind === "segment" || shape.kind === "polyline") return [...shape.vertices];
+  return shapeBoundary(shape, count);
+}
+function compute2dBounds(shape, pose = {}) {
+  const checked = validateCommon(shape);
+  if (!checked.ok) return checked;
+  const translation = pose.translation ?? [0, 0];
+  const rotation = pose.rotation ?? 0;
+  if (!finitePoint(translation) || !Number.isFinite(rotation)) {
+    return invalid("2d bounds pose must contain finite translation and rotation");
+  }
+  const points = boundsPoints(shape, checked.value);
+  if (points === void 0 || points.length === 0)
+    return invalid(`unsupported 2d bounds kind=${shape.kind}`);
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const transformed = points.map(
+    ([x, y]) => [translation[0] + x * cos - y * sin, translation[1] + x * sin + y * cos]
+  );
+  let radius = 0;
+  for (const [x, y] of points) radius = Math.max(radius, Math.hypot(x, y));
+  return ok({
+    aabb: box2.fromPoints(box2.create(), transformed),
+    circle: circle2.create(translation[0], translation[1], radius)
+  });
+}
+function create2dRingGeometry(shape, thickness, resolutionOverride) {
+  if (!(thickness > 0) || !Number.isFinite(thickness))
+    return invalid(`ring thickness=${thickness}`);
+  const checked = validateCommon(shape);
+  if (!checked.ok) return checked;
+  if (shape.kind === "segment" || shape.kind === "polyline" || shape.kind === "annulus") {
+    return invalid(`rings require a closed non-annulus shape, got ${shape.kind}`);
+  }
+  const count = resolutionOverride === void 0 ? checked.value : resolution(resolutionOverride);
+  if (count === void 0) return invalid(`ring resolution=${resolutionOverride}`);
+  const outer = shapeBoundary(shape, count);
+  if (!outer) return invalid(`unsupported ring shape kind=${shape.kind}`);
+  const extent = Math.max(...outer.map(([x, y]) => Math.hypot(x, y)));
+  const factor = (extent - thickness) / extent;
+  if (!(factor > 1e-5))
+    return invalid(`ring thickness=${thickness} exceeds shape extent=${extent}`);
+  return ok(ring(outer, scaleAround(outer, factor)));
+}
+function createTorusGeometry(radius, tube, radialSegments = 8, tubularSegments = 24) {
+  if (radius <= 0) return err(degenerate(`radius=${radius}`));
+  if (tube <= 0) return err(degenerate(`tube=${tube}`));
+  const rs = radialSegments | 0;
+  const ts = tubularSegments | 0;
+  if (rs < 3) return err(degenerate(`radialSegments=${rs}; minimum 3`));
+  if (ts < 3) return err(degenerate(`tubularSegments=${ts}; minimum 3`));
+  const vertexCount = (rs + 1) * (ts + 1);
+  const indexCount = rs * ts * 6;
+  const vertices = new Float32Array(vertexCount * FACTORY_FLOATS_PER_VERTEX);
+  const indices = new Uint32Array(indexCount);
+  let vIdx = 0;
+  for (let j = 0; j <= rs; j++) {
+    const v = j / rs * Math.PI * 2;
+    const cosV = Math.cos(v);
+    const sinV = Math.sin(v);
+    for (let i = 0; i <= ts; i++) {
+      const u = i / ts * Math.PI * 2;
+      const cosU = Math.cos(u);
+      const sinU = Math.sin(u);
+      const x = (radius + tube * cosV) * cosU;
+      const y = (radius + tube * cosV) * sinU;
+      const z = tube * sinV;
+      const centerX = radius * cosU;
+      const centerY = radius * sinU;
+      const nx = x - centerX;
+      const ny = y - centerY;
+      const nz = z;
+      const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+      const base = vIdx * FACTORY_FLOATS_PER_VERTEX;
+      vertices[base + 0] = x;
+      vertices[base + 1] = y;
+      vertices[base + 2] = z;
+      vertices[base + 3] = nx / nlen;
+      vertices[base + 4] = ny / nlen;
+      vertices[base + 5] = nz / nlen;
+      vertices[base + 6] = i / ts;
+      vertices[base + 7] = j / rs;
+      vIdx++;
+    }
+  }
+  let iIdx = 0;
+  for (let j = 1; j <= rs; j++) {
+    for (let i = 1; i <= ts; i++) {
+      const a = (ts + 1) * j + i - 1;
+      const b = (ts + 1) * (j - 1) + i - 1;
+      const c = (ts + 1) * (j - 1) + i;
+      const d = (ts + 1) * j + i;
+      indices[iIdx++] = a;
+      indices[iIdx++] = b;
+      indices[iIdx++] = d;
+      indices[iIdx++] = b;
+      indices[iIdx++] = c;
+      indices[iIdx++] = d;
+    }
+  }
+  return meshFromInterleaved(vertices, indices);
+}
+
+export { PROCEDURAL_FLOATS_PER_VERTEX, VertexAttributePackError, buildMeshAttributeMapForUvSets, compute2dBounds, computeTangentVec4, create2dGeometry, create2dRingGeometry, createBoxGeometry, createCapsuleGeometry, createConeGeometry, createCylinderGeometry, createPlaneGeometry, createPrimitiveMesh, createSphereGeometry, createTorusGeometry, deriveVertexBufferLayout, deriveVertexBufferLayoutFromProjection, deriveVertexLayoutProjection, deriveVertexLayoutProjectionFromMask, meshAssetContribution, meshAssetDecoder, meshAssetKind, meshFromInterleaved, packInterleavedVertexAttributes };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map