@rezless/vm 0.3.0 → 0.5.0

package/dist/prim-params.js

@@ -1,10 +1,12 @@
-import { ALL_SIDES, CLICK_ACTION_TOUCH, PRIM_ALPHA_MODE, PRIM_ALPHA_MODE_NONE, PRIM_ALLOW_UNSIT, PRIM_BUMP_NONE, PRIM_BUMP_SHINY, PRIM_CAST_SHADOWS, PRIM_CLICK_ACTION, PRIM_COLOR, PRIM_DAMAGE, PRIM_DESC, PRIM_FLEXIBLE, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_GLTF_ALPHA_MODE_OPAQUE, PRIM_GLTF_BASE_COLOR, PRIM_GLTF_EMISSIVE, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_NORMAL, PRIM_HEALTH, PRIM_HOLE_DEFAULT, PRIM_LINK_TARGET, PRIM_MATERIAL, PRIM_MATERIAL_STONE, PRIM_NAME, PRIM_NORMAL, PRIM_OMEGA, PRIM_PHANTOM, PRIM_PHYSICS, PRIM_PHYSICS_SHAPE_PRIM, PRIM_PHYSICS_SHAPE_TYPE, PRIM_POINT_LIGHT, PRIM_POSITION, PRIM_POS_LOCAL, PRIM_PROJECTOR, PRIM_REFLECTION_PROBE, PRIM_RENDER_MATERIAL, PRIM_ROTATION, PRIM_ROT_LOCAL, PRIM_SCRIPTED_SIT_ONLY, PRIM_SCULPT_TYPE_SPHERE, PRIM_SHINY_NONE, PRIM_SIT_FLAGS, PRIM_SIT_TARGET, PRIM_SIZE, PRIM_SLICE, PRIM_SPECULAR, PRIM_TEMP_ON_REZ, PRIM_TEXGEN, PRIM_TEXGEN_DEFAULT, PRIM_TEXT, PRIM_TEXTURE, PRIM_TYPE, PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM, PRIM_TYPE_RING, PRIM_TYPE_SCULPT, PRIM_TYPE_SPHERE, PRIM_TYPE_TORUS, PRIM_TYPE_TUBE, STATUS_PHANTOM, STATUS_PHYSICS, TEXTURE_DEFAULT, } from './generated/constants.js';
-import { NULL_KEY } from './values/types.js';
+import { ALL_SIDES, CLICK_ACTION_TOUCH, PRIM_ALPHA_MODE, PRIM_ALPHA_MODE_NONE, PRIM_ALLOW_UNSIT, PRIM_BUMP_NONE, PRIM_BUMP_SHINY, PRIM_CAST_SHADOWS, PRIM_CLICK_ACTION, PRIM_COLOR, PRIM_DAMAGE, PRIM_DESC, PRIM_FLEXIBLE, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_GLTF_ALPHA_MODE_OPAQUE, PRIM_GLTF_BASE_COLOR, PRIM_GLTF_EMISSIVE, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_NORMAL, PRIM_HEALTH, PRIM_HOLE_DEFAULT, PRIM_LINK_TARGET, PRIM_MATERIAL, PRIM_MATERIAL_WOOD, PRIM_NAME, PRIM_NORMAL, PRIM_OMEGA, PRIM_PHANTOM, PRIM_PHYSICS, PRIM_PHYSICS_SHAPE_PRIM, PRIM_PHYSICS_SHAPE_TYPE, PRIM_POINT_LIGHT, PRIM_POSITION, PRIM_POS_LOCAL, PRIM_PROJECTOR, PRIM_REFLECTION_PROBE, PRIM_RENDER_MATERIAL, PRIM_ROTATION, PRIM_ROT_LOCAL, PRIM_SCRIPTED_SIT_ONLY, PRIM_SCULPT_TYPE_SPHERE, PRIM_SHINY_NONE, PRIM_SIT_FLAGS, PRIM_SIT_TARGET, PRIM_SIZE, PRIM_SLICE, PRIM_SPECULAR, PRIM_TEMP_ON_REZ, PRIM_TEXGEN, PRIM_TEXGEN_DEFAULT, PRIM_TEXT, PRIM_TEXTURE, PRIM_TYPE, PRIM_TYPE_BOX, PRIM_TYPE_CYLINDER, PRIM_TYPE_PRISM, PRIM_TYPE_RING, PRIM_TYPE_SCULPT, PRIM_TYPE_SPHERE, PRIM_TYPE_TORUS, PRIM_TYPE_TUBE, STATUS_PHANTOM, STATUS_PHYSICS, TEXTURE_DEFAULT, } from './generated/constants.js';
+import { NULL_KEY, isRotation, isVector } from './values/types.js';
+import { listElementType } from './values/list-types.js';
+import { truncateUtf8 } from './values/utf8.js';
 /**
- * Typed-literal aliases for the kwdb PRIM_TYPE_* constants. The
+ * Typed-literal aliases for the PRIM_TYPE_* constants. The
  * generated module exports them as `: number` so TS can't narrow on
  * them; we re-pin them to their literal values here. The `as` assertions
- * are runtime-asserted below so a future kwdb renumber would surface as
+ * are runtime-asserted below so a future upstream renumber would surface as
  * a load-time failure rather than silent corruption.
  */
 const SHAPE_BOX = PRIM_TYPE_BOX;
@@ -15,11 +17,16 @@ const SHAPE_TORUS = PRIM_TYPE_TORUS;
 const SHAPE_TUBE = PRIM_TYPE_TUBE;
 const SHAPE_RING = PRIM_TYPE_RING;
 const SHAPE_SCULPT = PRIM_TYPE_SCULPT;
-if (SHAPE_BOX !== 0 || SHAPE_CYLINDER !== 1 || SHAPE_PRISM !== 2 ||
-    SHAPE_SPHERE !== 3 || SHAPE_TORUS !== 4 || SHAPE_TUBE !== 5 ||
-    SHAPE_RING !== 6 || SHAPE_SCULPT !== 7) {
-    throw new Error('kwdb PRIM_TYPE_* constants disagree with PrimShape literal aliases');
+/** Throws unless `shapes` lists PRIM_TYPE_BOX..PRIM_TYPE_SCULPT as 0..7 in order. */
+export function assertShapeAliases(shapes) {
+    if (shapes.length !== 8 || shapes.some((v, i) => v !== i)) {
+        throw new Error('PRIM_TYPE_* constants disagree with PrimShape literal aliases');
+    }
 }
+assertShapeAliases([
+    SHAPE_BOX, SHAPE_CYLINDER, SHAPE_PRISM, SHAPE_SPHERE,
+    SHAPE_TORUS, SHAPE_TUBE, SHAPE_RING, SHAPE_SCULPT,
+]);
 const zero = () => ({ x: 0, y: 0, z: 0 });
 const one = () => ({ x: 1, y: 1, z: 1 });
 const identityRot = () => ({ x: 0, y: 0, z: 0, s: 1 });
@@ -75,7 +82,7 @@ export function defaultPrimParams() {
         sculpt: { textureKey: '', type: PRIM_SCULPT_TYPE_SPHERE },
         slice: { x: 0, y: 1, z: 0 },
         shape: defaultShape(),
-        material: PRIM_MATERIAL_STONE,
+        material: PRIM_MATERIAL_WOOD,
         tempOnRez: false,
         castShadows: false,
         allowUnsit: true,
@@ -87,7 +94,7 @@ export function defaultPrimParams() {
         damage: { amount: 0, type: 0 },
         health: 1,
         reflectionProbe: { enabled: false, ambiance: 0, clipDistance: 0, flags: 0 },
-        physicsMaterial: { gravityMultiplier: 1, restitution: 0, friction: 0, density: 1000 },
+        physicsMaterial: { gravityMultiplier: 1, restitution: 0.5, friction: Math.fround(0.6), density: 1000 },
         textureAnim: { mode: 0, face: 0, sizex: 0, sizey: 0, start: 0, length: 0, rate: 0 },
         passCollisions: 0,
         passTouches: 0,
@@ -113,15 +120,21 @@ const asRot = (v) => {
     return identityRot();
 };
 const toByteChannel = (c) => Math.floor(Math.min(1, Math.max(0, c)) * 255) / 255;
-function facesOf(faceArg) {
-    const f = num(faceArg, 0) | 0;
-    if (f === ALL_SIDES)
-        return [0, 1, 2, 3, 4, 5];
-    return [f];
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+const clampVec = (v, lo, hi) => ({ x: clamp(v.x, lo, hi), y: clamp(v.y, lo, hi), z: clamp(v.z, lo, hi) });
+function normalizeRot(r) {
+    const mag = Math.hypot(r.x, r.y, r.z, r.s);
+    if (mag === 0)
+        return identityRot();
+    return { x: r.x / mag, y: r.y / mag, z: r.z / mag, s: r.s / mag };
 }
-function inRange(face) {
-    return face >= 0 && face <= 5;
+/** Face indexes a face argument names: every face for ALL_SIDES, none past the shape's face count. */
+export function faceIndices(p, face) {
+    if (face === ALL_SIDES)
+        return p.faces.map((_, i) => i);
+    return face >= 0 && face < p.faces.length ? [face] : [];
 }
+const facesOf = (p, faceArg) => faceIndices(p, num(faceArg, 0) | 0);
 /**
  * Slot count for a PRIM_* rule's *write* form, given the rule constant
  * and (for variable-shape rules like PRIM_TYPE) the rules list + cursor
@@ -205,14 +218,14 @@ export function writePrimParam(prim, param, rules, cursor) {
     const p = prim.params;
     switch (param) {
         case PRIM_NAME:
-            prim.name = str(rules[cursor]);
+            prim.name = truncateUtf8(str(rules[cursor]), 63);
             return 1;
         case PRIM_DESC:
-            prim.description = str(rules[cursor]);
+            prim.description = truncateUtf8(str(rules[cursor]), 127);
             prim.appearance.description = prim.description;
             return 1;
         case PRIM_TEXT: {
-            const text = str(rules[cursor]);
+            const text = truncateUtf8(str(rules[cursor]), 254);
             const color = asVec(rules[cursor + 1]);
             const alpha = num(rules[cursor + 2], 1);
             prim.appearance.text = { text, color, alpha };
@@ -224,10 +237,10 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 1;
         case PRIM_ROTATION:
         case PRIM_ROT_LOCAL:
-            p.rotation = asRot(rules[cursor]);
+            p.rotation = normalizeRot(asRot(rules[cursor]));
             return 1;
         case PRIM_SIZE:
-            p.size = asVec(rules[cursor]);
+            p.size = clampVec(asVec(rules[cursor]), 0.01, 64);
             return 1;
         case PRIM_SLICE:
             p.slice = asVec(rules[cursor]);
@@ -317,27 +330,22 @@ export function writePrimParam(prim, param, rules, cursor) {
         case PRIM_TYPE:
             return writePrimType(p, rules, cursor);
         case PRIM_COLOR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const color = asVec(rules[cursor + 1]);
-            const alpha = num(rules[cursor + 2], 1);
+            const alpha = clamp(num(rules[cursor + 2], 1), 0, 1);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
-                // Clone so faces don't alias the same vector instance.
-                p.faces[f].color = { x: color.x, y: color.y, z: color.z };
+                p.faces[f].color = clampVec(color, 0, 1);
                 p.faces[f].alpha = alpha;
             }
             return 3;
         }
         case PRIM_TEXTURE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
             const rot = num(rules[cursor + 4]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].texture = tex;
                 p.faces[f].textureRepeats = { x: repeats.x, y: repeats.y, z: repeats.z };
                 p.faces[f].textureOffsets = { x: offsets.x, y: offsets.y, z: offsets.z };
@@ -346,66 +354,54 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 5;
         }
         case PRIM_RENDER_MATERIAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const m = str(rules[cursor + 1]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].renderMaterial = m;
             }
             return 2;
         }
         case PRIM_FULLBRIGHT: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const v = num(rules[cursor + 1]) !== 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].fullBright = v;
             }
             return 2;
         }
         case PRIM_GLOW: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const v = num(rules[cursor + 1]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].glow = v;
                 p.glow[f] = v;
             }
             return 2;
         }
         case PRIM_BUMP_SHINY: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const shiny = num(rules[cursor + 1]) | 0;
             const bump = num(rules[cursor + 2]) | 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].bumpShiny = { shiny, bump };
             }
             return 3;
         }
         case PRIM_TEXGEN: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const mode = num(rules[cursor + 1]) | 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].texgen = mode;
             }
             return 2;
         }
         case PRIM_NORMAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
             const rot = num(rules[cursor + 4]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].normal = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -416,7 +412,7 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 5;
         }
         case PRIM_SPECULAR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
@@ -425,8 +421,6 @@ export function writePrimParam(prim, param, rules, cursor) {
             const gloss = num(rules[cursor + 6]) | 0;
             const env = num(rules[cursor + 7]) | 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].specular = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -441,18 +435,16 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 8;
         }
         case PRIM_ALPHA_MODE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const mode = num(rules[cursor + 1]) | 0;
             const cutoff = num(rules[cursor + 2]) | 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].alphaMode = { mode, cutoff };
             }
             return 3;
         }
         case PRIM_GLTF_BASE_COLOR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
@@ -463,8 +455,6 @@ export function writePrimParam(prim, param, rules, cursor) {
             const aCut = num(rules[cursor + 8]);
             const dbl = num(rules[cursor + 9]) | 0;
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].gltf.baseColor = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -480,14 +470,12 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 10;
         }
         case PRIM_GLTF_NORMAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
             const rot = num(rules[cursor + 4]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].gltf.normal = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -498,7 +486,7 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 5;
         }
         case PRIM_GLTF_METALLIC_ROUGHNESS: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
@@ -506,8 +494,6 @@ export function writePrimParam(prim, param, rules, cursor) {
             const metallic = num(rules[cursor + 5]);
             const rough = num(rules[cursor + 6]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].gltf.metallicRoughness = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -520,15 +506,13 @@ export function writePrimParam(prim, param, rules, cursor) {
             return 7;
         }
         case PRIM_GLTF_EMISSIVE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const tex = str(rules[cursor + 1]);
             const repeats = asVec(rules[cursor + 2]);
             const offsets = asVec(rules[cursor + 3]);
             const rot = num(rules[cursor + 4]);
             const tint = asVec(rules[cursor + 5]);
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 p.faces[f].gltf.emissive = {
                     texture: tex,
                     textureRepeats: { x: repeats.x, y: repeats.y, z: repeats.z },
@@ -547,6 +531,7 @@ export function writePrimParam(prim, param, rules, cursor) {
 }
 function writePrimType(p, rules, cursor) {
     const kind = (num(rules[cursor]) | 0);
+    const old = p.shape;
     switch (kind) {
         case SHAPE_BOX:
         case SHAPE_CYLINDER:
@@ -560,7 +545,7 @@ function writePrimType(p, rules, cursor) {
                 topSize: asVec(rules[cursor + 5]),
                 topShear: asVec(rules[cursor + 6]),
             };
-            return 7;
+            break;
         case SHAPE_SPHERE:
             p.shape = {
                 kind: SHAPE_SPHERE,
@@ -570,7 +555,7 @@ function writePrimType(p, rules, cursor) {
                 twist: asVec(rules[cursor + 4]),
                 dimple: asVec(rules[cursor + 5]),
             };
-            return 6;
+            break;
         case SHAPE_TORUS:
         case SHAPE_TUBE:
         case SHAPE_RING:
@@ -588,14 +573,14 @@ function writePrimType(p, rules, cursor) {
                 radiusOffset: num(rules[cursor + 10]),
                 skew: num(rules[cursor + 11]),
             };
-            return 12;
+            break;
         case SHAPE_SCULPT:
             p.shape = {
                 kind: SHAPE_SCULPT,
                 map: str(rules[cursor + 1]),
                 type: num(rules[cursor + 2]) | 0,
             };
-            return 3;
+            break;
         default:
             // Unknown PRIM_TYPE_* kind: terminate the walk rather than guessing
             // a slot count. Matches writePrimParamSlots' default behavior so
@@ -603,6 +588,8 @@ function writePrimType(p, rules, cursor) {
             // same way.
             return null;
     }
+    remapFaces(p, old);
+    return writePrimParamSlots(PRIM_TYPE, rules, cursor);
 }
 /**
  * Read a single PRIM_* rule, returning the flat values it expands to and
@@ -622,6 +609,7 @@ export function readPrimParam(prim, param, rules, cursor) {
             return { values: t ? [t.text, t.color, t.alpha] : ['', zero(), 0], consumed: 0 };
         }
         case PRIM_POSITION:
+            return { values: [prim.regionPosition()], consumed: 0 };
         case PRIM_POS_LOCAL:
             return { values: [p.position], consumed: 0 };
         case PRIM_ROTATION:
@@ -683,147 +671,119 @@ export function readPrimParam(prim, param, rules, cursor) {
         case PRIM_TYPE:
             return { values: readPrimType(p), consumed: 0 };
         case PRIM_COLOR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].color, p.faces[f].alpha);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_TEXTURE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const fa = p.faces[f];
                 out.push(fa.texture, fa.textureRepeats, fa.textureOffsets, fa.textureRotation);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_RENDER_MATERIAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].renderMaterial);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_FULLBRIGHT: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].fullBright ? 1 : 0);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_GLOW: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].glow);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_BUMP_SHINY: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].bumpShiny.shiny, p.faces[f].bumpShiny.bump);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_TEXGEN: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].texgen);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_NORMAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const n = p.faces[f].normal;
                 out.push(n.texture, n.textureRepeats, n.textureOffsets, n.textureRotation);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_SPECULAR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const s = p.faces[f].specular;
                 out.push(s.texture, s.textureRepeats, s.textureOffsets, s.textureRotation, s.color, s.glossiness, s.environment);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_ALPHA_MODE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 out.push(p.faces[f].alphaMode.mode, p.faces[f].alphaMode.cutoff);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_GLTF_BASE_COLOR: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const g = p.faces[f].gltf.baseColor;
                 out.push(g.texture, g.textureRepeats, g.textureOffsets, g.textureRotation, g.color, g.alpha, g.alphaMode, g.alphaCutoff, g.doubleSided);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_GLTF_NORMAL: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const g = p.faces[f].gltf.normal;
                 out.push(g.texture, g.textureRepeats, g.textureOffsets, g.textureRotation);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_GLTF_METALLIC_ROUGHNESS: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const g = p.faces[f].gltf.metallicRoughness;
                 out.push(g.texture, g.textureRepeats, g.textureOffsets, g.textureRotation, g.metallic, g.roughness);
             }
             return { values: out, consumed: 1 };
         }
         case PRIM_GLTF_EMISSIVE: {
-            const faces = facesOf(rules[cursor]);
+            const faces = facesOf(p, rules[cursor]);
             const out = [];
             for (const f of faces) {
-                if (!inRange(f))
-                    continue;
                 const g = p.faces[f].gltf.emissive;
                 out.push(g.texture, g.textureRepeats, g.textureOffsets, g.textureRotation, g.tint);
             }
@@ -916,4 +876,129 @@ export function primParamTypes(param, values) {
     const pattern = param === PRIM_TYPE ? primTypeTypes(values[0]) : (PRIM_PARAM_TYPES[param] ?? []);
     return values.map((_, i) => pattern[i % pattern.length]);
 }
+const PER_FACE_RULES = new Set([
+    PRIM_COLOR, PRIM_TEXTURE, PRIM_RENDER_MATERIAL, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_BUMP_SHINY,
+    PRIM_TEXGEN, PRIM_NORMAL, PRIM_SPECULAR, PRIM_ALPHA_MODE, PRIM_GLTF_BASE_COLOR,
+    PRIM_GLTF_NORMAL, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_EMISSIVE,
+]);
+const RULE_CONSTANTS = {
+    PRIM_NAME, PRIM_DESC, PRIM_TEXT, PRIM_POSITION, PRIM_POS_LOCAL, PRIM_ROTATION, PRIM_ROT_LOCAL,
+    PRIM_SIZE, PRIM_SLICE, PRIM_MATERIAL, PRIM_PHYSICS, PRIM_PHANTOM, PRIM_TEMP_ON_REZ,
+    PRIM_PHYSICS_SHAPE_TYPE, PRIM_CAST_SHADOWS, PRIM_ALLOW_UNSIT, PRIM_SCRIPTED_SIT_ONLY,
+    PRIM_SIT_FLAGS, PRIM_CLICK_ACTION, PRIM_HEALTH, PRIM_DAMAGE, PRIM_OMEGA, PRIM_POINT_LIGHT,
+    PRIM_REFLECTION_PROBE, PRIM_PROJECTOR, PRIM_FLEXIBLE, PRIM_SIT_TARGET, PRIM_TYPE, PRIM_COLOR,
+    PRIM_TEXTURE, PRIM_RENDER_MATERIAL, PRIM_FULLBRIGHT, PRIM_GLOW, PRIM_BUMP_SHINY, PRIM_TEXGEN,
+    PRIM_NORMAL, PRIM_SPECULAR, PRIM_ALPHA_MODE, PRIM_GLTF_BASE_COLOR, PRIM_GLTF_NORMAL,
+    PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_EMISSIVE,
+};
+const RULE_NAMES = new Map(Object.entries(RULE_CONSTANTS).map(([name, value]) => [value, name]));
+function givenType(rules, index) {
+    const known = listElementType(rules, index);
+    if (known)
+        return known;
+    const v = rules[index];
+    if (typeof v === 'string')
+        return 'string';
+    if (typeof v === 'number')
+        return Number.isInteger(v) ? 'integer' : 'float';
+    if (isRotation(v))
+        return 'rotation';
+    if (isVector(v))
+        return 'vector';
+    return 'list';
+}
+function typeAccepts(expected, given) {
+    if (expected === given)
+        return true;
+    const numeric = (t) => t === 'integer' || t === 'float';
+    const text = (t) => t === 'string' || t === 'key';
+    return (numeric(expected) && numeric(given)) || (text(expected) && text(given));
+}
+/** `%g`-style number text, as the simulator prints it in error messages. */
+const formatG = (v) => String(Number(v.toPrecision(6)));
+/**
+ * Check one PRIM_* rule of a set call before it is applied. Returns null if
+ * the rule can run, otherwise the error text that follows "rule #N" in the
+ * simulator's message (e.g. " (PRIM_SIZE): arg #1 vector expected but string given").
+ */
+/** GLTF override rules take "" in any slot after the face to mean "no override". */
+const GLTF_RULES = new Set([PRIM_GLTF_BASE_COLOR, PRIM_GLTF_NORMAL, PRIM_GLTF_METALLIC_ROUGHNESS, PRIM_GLTF_EMISSIVE]);
+export function checkPrimRule(param, rules, cursor) {
+    const name = RULE_NAMES.get(param);
+    if (name === undefined || writePrimParamSlots(param, rules, cursor) === null)
+        return ': unknown rule';
+    const pattern = param === PRIM_TYPE ? primTypeTypes(rules[cursor]) : PRIM_PARAM_TYPES[param];
+    const expected = PER_FACE_RULES.has(param) ? ['integer', ...pattern] : pattern;
+    for (let i = 0; i < expected.length; i++) {
+        if (cursor + i >= rules.length)
+            break;
+        if (i > 0 && GLTF_RULES.has(param) && rules[cursor + i] === '')
+            continue;
+        const given = givenType(rules, cursor + i);
+        if (!typeAccepts(expected[i], given)) {
+            return ` (${name}): arg #${i + 1} ${expected[i]} expected but ${given} given`;
+        }
+    }
+    if (param === PRIM_GLOW) {
+        const glow = num(rules[cursor + 1]);
+        if (glow < 0 || glow > 1)
+            return ` (${name}): bounds error; ${formatG(glow)} is not in (0, 1)`;
+    }
+    return null;
+}
+const PROFILE_SIDES = {
+    [SHAPE_BOX]: 4, [SHAPE_CYLINDER]: 1, [SHAPE_PRISM]: 3, [SHAPE_SPHERE]: 1,
+    [SHAPE_TORUS]: 1, [SHAPE_TUBE]: 4, [SHAPE_RING]: 3,
+};
+const isCut = (range) => range.x > 0 || range.y < 1;
+function faceRoles(shape) {
+    if (shape.kind === SHAPE_SCULPT)
+        return [{ from: 0, to: 1 }];
+    const looped = shape.kind === SHAPE_TORUS || shape.kind === SHAPE_TUBE || shape.kind === SHAPE_RING;
+    const profileCut = looped ? shape.advancedCut : shape.cut;
+    const pathEnds = shape.kind === SHAPE_SPHERE
+        ? isCut(shape.dimple) || shape.hollow > 0
+        : !looped || isCut(shape.cut);
+    const sides = PROFILE_SIDES[shape.kind];
+    const roles = pathEnds ? ['top'] : [];
+    for (let i = 0; i < sides; i++) {
+        const from = i / sides, to = (i + 1) / sides;
+        if (from < profileCut.y && to > profileCut.x)
+            roles.push({ from, to });
+    }
+    if (shape.hollow > 0)
+        roles.push('inner');
+    if (pathEnds)
+        roles.push('bottom');
+    if (isCut(profileCut))
+        roles.push('cutStart', 'cutEnd');
+    return roles;
+}
+/**
+ * Rebuild the face slots for a new shape. A face keeps the values of the old
+ * face with the same role; an outer side takes the first old outer side it
+ * overlaps, else the nearest one; any other new face copies the old last face.
+ */
+function remapFaces(p, oldShape) {
+    const oldRoles = faceRoles(oldShape);
+    const old = p.faces;
+    const last = old[old.length - 1];
+    const oldOuter = oldRoles.flatMap((r, i) => (typeof r === 'string' ? [] : [{ ...r, face: old[i] }]));
+    const source = (role) => {
+        if (typeof role === 'string')
+            return old[oldRoles.indexOf(role)] ?? last;
+        const gap = (o) => Math.max(o.from - role.to, role.from - o.to);
+        const overlap = oldOuter.find((o) => gap(o) < 0);
+        if (overlap)
+            return overlap.face;
+        const nearest = oldOuter.reduce((a, o) => (!a || gap(o) < gap(a) ? o : a), undefined);
+        return nearest?.face ?? last;
+    };
+    p.faces = faceRoles(p.shape).map((role) => structuredClone(source(role)));
+    p.glow = p.faces.map((f) => f.glow);
+}
+/** Face count of a prim shape, as llGetNumberOfSides reports it. */
+export function numberOfSides(shape) {
+    return faceRoles(shape).length;
+}
 //# sourceMappingURL=prim-params.js.map