quatX(deg: number) → void

Quaternion for a rotation of `deg` degrees about X, as the {x,y,z,w} array the Transform rotation field takes.

mapGeometry(g: any) → void

Map a THREE geometry spec { type, p = {...} } to a Zero primitive model plus the constant local pose of the visual child that makes the primitive match THREE's geometry-space conventions (dimensions, axis, and origin).

quatMul(a: { number }, b: { number }) → void

Pick the backing material asset for a THREE material spec.

quatRotate(q: { number }, v: { number }) → void

composeBakePose(bake: { number }, g: any) → void

The pose for a mesh visual combining a geometry bake (flat TRS from the JS side's translate/rotate calls on a parametric geometry) with the primitive's constant mapping pose: vertex v -> Bake * Map * v.

mapMaterial(mat: any) → string

applyTint(vis: any, mat: any) → void

new(opts: any?) → void

_register(id: number, rec: any) → void

_parentEnt(parentId: any) → any

The hierarchy parent for a new object: another tracked object's entity, or the session root when the object sits directly under the THREE scene.

createNode(spec: any) → number

A bare transform node mirroring a THREE Group/Object3D. Carries no visual; exists so children compose world transforms through the native hierarchy.

geomArray(v: any) → any

A plain number array for a geometry field that may arrive as a zero-copy typed-array record from the zerojs bridge.

createMesh(spec: any) → number

createInstancedMesh(spec: any) → number

An instanced mesh: one parent entity, one shared visual source (a single runtime mesh handle for custom vertex data, or a mapped primitive model), and one child entity per instance carrying its decomposed TRS. Same-model children batch into GPU instancing in the renderer.

updateInstances(id: number, upd: any) → void

Re-sync per-instance data for an instanced mesh: `upd.trs` carries the full flat TRS array (10 per instance), `upd.colors` a flat RGB array. Transforms land in one batchWrite per field.

createModel(spec: any) → number

A GLTF model node: stamps the imported bundle's node rows as temporary entities carrying native Mesh/Material components resolved from the bundle's own sub-assets. The node carries the THREE-side transform; the stamped hierarchy hangs beneath it. No script components, no persistence — the JS app owns behavior and the engine renders.

playAnimation(id: number, clipName: any) → void

Play an animation clip on a model node's stamped bundle: resolves the clip among the bundle's own animation assets by name, falling back to the first.

createPointLight(spec: any) → number

updateLight(id: number, spec: any) → void

updateMeshMaterial(id: number, mat: any) → void

setVisible(id: number, v: boolean) → void

remove(id: number) → void

syncTransforms(flat: { number }) → void

Apply a frame of transforms. `flat` is [id, px,py,pz, qx,qy,qz,qw, sx,sy,sz] repeating, carrying ONLY the objects whose local transform changed this frame (the JS side tracks dirtiness). Each field lands in one batchWrite crossing sized to the change set, so static objects generate no writes at all.

setKinematic(id: number, spec: any) → void

Register (or with spec == nil, release) constant-velocity host integration for an object. `spec` = { px,py,pz, vx,vy,vz, wrap = { axis = "x"|"y"|"z", min, max } }. Registered objects advance in `tick` each frame and land in one translation batchWrite — per-frame motion costs no interpreted JS. `wrap` teleports the axis back across the [min,max] band when it exits.

tick(dt: number) → void

Advance every kinematic object by `dt` seconds and write the frame's translations in one batch crossing.

getPosition(id: number) → void

Current local position of a kinematic object as {x, y, z} — the readback for JS-side game logic (collision) against host-integrated motion.

setCamera(c: any) → void

setAmbient(spec: any) → void

setDirectional(spec: any) → void

setBackground(c: any) → void

readResolved(full: string) → string

Serve a browser-style fetch from the session's asset root. Returns { ok, status, body } with the file's raw bytes as a string. Resolve one candidate VFS file path: direct read, importer-relocated (`<stem>.<category>/<base>`), then content-hash sibling (`<stem>.<hash>.<ext>` as written by hashing build pipelines when the request uses the logical name).

jsonDecode(s: string) → any

JSON + matrix helpers shared by bundle metadata and the geometry kernels Minimal JSON decoder (objects, arrays, strings, numbers, booleans, null; UTF-8 passthrough with \uXXXX escapes) for bundle entity_template files.

skipWs( ) → void

parseString( ) → string

parseNumber( ) → number

parseValue( ) → void

normalMatrix(m: { number }) → void

Inverse-transpose of the upper-left 3x3, for transforming normals.

loadBundleMeta(bundlePath: string) → any

Parse a bundle's entity_template into node rows plus its animation clip names. Cached per bundle path; the template is authored once at import.

bundleIdentityFor(bundlePath: string) → string

The bundle asset identity for a bundle VFS path (`/zero/source/a/b/x.bundle` → `a.b.x.bundle`).

bundleFor(url: string) → string

Resolve a model URL to the bundle the importer derived from the source file. Model sources are imported at authoring time; a URL without its bundle resolves to nil and the caller reports it.

sourceGlbFor(url: string) → string

Resolve a model URL to its source file on the VFS (the same candidate walk bundleFor uses, but for the .glb/.gltf itself).

loadModel(url: string) → any

JS-facing model metadata: named nodes with hierarchy (parent as index), local TRS, mesh/skinned flags, and the bundle's animation clip names.

refByIdentity(category: string, identity: string) → any

subAssetHandle(identity: string, category: string) → any

readBundleMesh(source: string, nodeName: string) → any

Vertex data for one mesh node of a model's bundle — the read side of the bundle-mapped proxy contract: a proxy's BufferGeometry materializes real attributes from this when the app introspects it. Returns flat positions/normals/uvs plus triangle indices (0-based).

stampBundle(source: string, node: any, rec: any) → void

Stamp a model URL's bundle rows as temporary entities under `node`: Transform hierarchy plus native Mesh/Material components. Rows flagged hidden stay hidden; the first skinned row becomes the animation mount.

isTaRec(v: any) → boolean

Geometry kernels — bulk operations on typed-array records The zerojs bridge crosses typed arrays as zero-copy layout records over their backing buffer, so these run native loops over the SAME bytes the JS BufferAttributes hold. In-place ops mutate what JS sees; producing ops return fresh records the bridge lifts back into typed arrays.

f32Rec(buf: buffer, len: number) → any

u32Rec(buf: buffer, len: number) → any

copyIntoF32(dst: buffer, at: number, rec: any) → void

Copy a record's elements into `dst` as f32 starting at element `at`, converting element kinds through the record's own reader.

applyMat4(spec: any) → boolean

In-place position (mat4) and normal (inverse-transpose) transform, matching BufferGeometry.applyMatrix4. `m` is a 16-element column-major matrix.

merge(spec: any) → any

Merge geometries: concatenates each named float attribute and offsets indices by the running vertex count. Geometries without an index contribute a sequential range. Returns records plus per-geometry groups.

toNonIndexed(spec: any) → any

Expand indexed attributes into per-corner arrays, matching toNonIndexed.

bounds(spec: any) → any

Axis-aligned bounds and bounding sphere of a position record.

computeNormals(spec: any) → any

Area-weighted vertex normals from positions (+ optional index), matching computeVertexNormals. Returns a fresh normal record.

corner(i: number) → void

addFace(ia: number, ib: number, ic: number) → void

fetchFile(url: string) → any

destroy( ) → void

envFor(session: any) → void

The flat function table installed as `__ZERO` on a ZeroJS VM. Every function is a plain closure over the session so the marshaling bridge lifts each into a JS function.

createMesh(spec: ?) → void

createInstancedMesh(spec: ?) → void

updateInstances(id: ?, upd: ?) → void

createNode(spec: ?) → void

createModel(spec: ?) → void

playAnimation(id: ?, clipName: ?) → void

createPointLight(spec: ?) → void

updateLight(id: ?, spec: ?) → void

updateMeshMaterial(id: ?, mat: ?) → void

setVisible(id: ?, v: ?) → void

remove(id: ?) → void

syncTransforms(flat: ?) → void

setKinematic(id: ?, spec: ?) → void

getPosition(id: ?) → void

setCamera(c: ?) → void

setAmbient(s: ?) → void

setDirectional(s: ?) → void

setBackground(c: ?) → void

screen( ) → void

now( ) → void

input( ) → void

pollEvents( ) → void

fetchFile(url: ?) → void

loadModel(url: ?) → void

readBundleMesh(source: ?, nodeName: ?) → void

geomApplyMat4(spec: ?) → void

geomMerge(spec: ?) → void

geomToNonIndexed(spec: ?) → void

geomBounds(spec: ?) → void

geomComputeNormals(spec: ?) → void