* Push a value onto the stack. * @param {number} value - The value to push. * @throws {Error} If the stack is full.

* Gets a layer by ID * * @param {number} id - The layer ID * @returns {Layer|null} The layer or null if not found

* Set the value at the specified logical index from the front of the queue. * @param {number} index - The logical index from the front (0 is the fr

* Allocate an index from the free list. * @returns {number} The allocated index, or -1 if the list is full and couldn't grow.

* Get the chunk at the given index. * @param {number} index - The index of the chunk to get. * @returns {Chunk} - The chunk at the given index.

* Get a data view for a node * @param {number} node_index - The index of the node * @returns {AABBNodeDataView} - A data view for the node

* Creates a new layer * * @param {number} type - The type of layer * @param {Object} properties - Properties for the layer * @param {numbe

* Retrieves a reusable view object pointing to the data of a specific fragment * for a given entity instance. * * @template {import('../fragm

* Utility to log the tensor. * @param {number} id - the ID of the tensor to log. * @param {string} op_name - the name of the operation.

* Utility to create a random tensor. * Using Tensor.create(), this will automatically enable reuse. * * @param {number[]} shape - desired sha

* Utility to create a zeros tensor. * Using Tensor.create(), this will automatically enable reuse. * * @param {number[]} shape - desired shap

* Adds a training batch to the queue. * If the queue is full, it overwrites the oldest batch. * * @param {Object} batch - An object with prop

* Adds a new render pass to the render graph. * * @param {string} name - The name of the render pass. * @param {number} pass_type - The type

* Creates a new query with the given fragment requirements. * @param {string[]} fragment_requirements - The fragment requirements to use for the qu

* Pop a log from the buffer * @returns {Array<{message: string, timestamp: number}>}

* Marks this chunk as dirty.

* Retrieves a physical render pass from the resource cache using its handle. * * @param {number} handle - The handle of the render pass to retri

* Registers an existing buffer in the render graph. * This method creates a new resource handle for an existing buffer, sets up its configuration,

* Clear the log buffer

* Creates a new image resource in the render graph. * * @param {Object} config - The configuration object for the image resource. * @param {n

* Get the value at the specified logical index from the front of the queue. * @param {number} index - The logical index from the front (0 is the fr

* Retrieves the GPU buffer associated with a specific fragment field or custom buffer definition. * This provides convenient access to the buffers

* Retrieves a physical image from the resource cache using its handle. * * @param {number} handle - The handle of the image to retrieve. * @r

* Log a message * @param {string} message * @param {string} [level='info'] - Log level (info, warn, error)

* Gets the font object for a given font ID * @param {number} font_id - The ID of the font * @returns {Font|null} The font object or null if not

* Add a line to be drawn * @param {Array} start - Start position [x, y, z] * @param {Array} end - End position [x, y, z] * @param {Array} col

* Factory method to create or recycle a Tensor. * This checks the free list for an available tensor and reinitializes it * instead of calling ne

* Create a new entity with the given fragments and instance count. * * @param {Fragments[]} fragments - Array of fragments * @param {number}

* Compose the 28-bit row field from chunk_index and local_slot. * Low LOCAL_SLOT_BITS bits = local_slot; next CHUNK_INDEX_BITS bits = chunk_index.

* Registers a handler for a specific layer type * * @param {string} type - The layer type * @param {Object} handler - Object with forward, ba

* Get the fragment view for the given fragment ID. * @param {typeof import('../fragment.js').Fragment} fragment_class - The fragment class to get t

* Test ray intersection with an AABB (Axis-Aligned Bounding Box) * Uses slab method with precomputed inverse direction * @returns {number|fa

* Calculate the surface area of an AABB * @param {Array<number>} min_point - The minimum point of the AABB * @param {Array<number>} max_point -

* Creates a new buffer resource in the render graph. * This method allocates a new buffer resource, sets up its configuration, and registers it in

* Getter for the length of the tensor. * This is equivalent to the size of the tensor. * @returns {number} the size of the tensor.

* Get the current log buffer without clearing it * @returns {Array<{message: string, timestamp: number}>}

* Reparent an entity in the global scene-graph.

* Update a region of the GPU buffer corresponding to a chunk segment. * @param {number} base_row - The starting row index in the GPU buffer for thi

* Adds a single fragment type to an existing entity. * If the entity already has the fragment, it returns a view to the existing fragment data.

* Destroys a layer and its connections * * @param {number} id - The ID of the layer to destroy