@woosh/meep-engine 3.46.0 → 3.49.0

package/src/engine/network/transport/fragments/fragment_send.d.ts

@@ -1,61 +0,0 @@
-/**
- * Send a logical payload through a callback, splitting into fragment
- * packets if it exceeds the channel's single-packet capacity.
- *
- * Layout of each emitted fragment packet (before the Channel adds its
- * 8-byte header):
- *
- *   uint8   FRAGMENT_PACKET_TYPE
- *   uint16  message_id   (little-endian)
- *   uint8   chunk_index
- *   uint8   total_chunks
- *   bytes   chunk_payload
- *
- * The chunk_payload bytes are slices of the original logical payload,
- * concatenated in chunk_index order they reconstruct the original
- * payload byte-for-byte. The logical payload's own packet-type byte is
- * the first byte of chunk 0 and is preserved by the reassembly.
- *
- * Single-packet messages (payload <= MAX_CHANNEL_PAYLOAD_BYTES) are sent
- * as-is with NO fragmentation header — the receiver dispatches them
- * normally via the FIRST byte. Fragmentation overhead only applies when
- * the payload genuinely doesn't fit.
- *
- * @param {Uint8Array} payload
- * @param {number} payload_length
- * @param {number} message_id  sender-assigned, unique per logical message
- * @param {number} fragment_packet_type  packet-type byte for fragment packets
- * @param {Uint8Array} scratch  reusable scratch buffer; must be >= MAX_CHANNEL_PAYLOAD_BYTES
- * @param {function(Uint8Array, number): void} send_fn
- *   invoked once per emitted packet — single send for non-fragmented case,
- *   N sends for fragmented case
- */
-export function send_fragmented(payload: Uint8Array, payload_length: number, message_id: number, fragment_packet_type: number, scratch: Uint8Array, send_fn: (arg0: Uint8Array, arg1: number) => void): void;
-/**
- * Number of chunks {@link send_fragmented} splits a payload of `payload_length` bytes into — the
- * chunk indices a receiver may ask to have re-sent are `[0, count)`.
- *
- * @param {number} payload_length
- * @returns {number}
- */
-export function fragment_chunk_count(payload_length: number): number;
-/**
- * Re-emit a single fragment chunk for a previously-sent fragmented
- * message. Used by the NACK retransmit path: the sender's
- * {@link FragmentRetention} keeps the source bytes so any chunk can be
- * deterministically rebuilt.
- *
- * The wire layout matches what {@link send_fragmented} would have
- * produced for the same `(message_id, chunk_index, total_chunks)` —
- * receivers can't tell a retransmit from an original.
- *
- * @param {Uint8Array} payload  retained source bytes
- * @param {number} payload_length
- * @param {number} message_id
- * @param {number} chunk_index  must be < derived total_chunks; silently ignored otherwise
- * @param {number} fragment_packet_type
- * @param {Uint8Array} scratch  reusable scratch; must be >= MAX_CHANNEL_PAYLOAD_BYTES
- * @param {function(Uint8Array, number): void} send_fn
- */
-export function resend_fragment_chunk(payload: Uint8Array, payload_length: number, message_id: number, chunk_index: number, fragment_packet_type: number, scratch: Uint8Array, send_fn: (arg0: Uint8Array, arg1: number) => void): void;
-//# sourceMappingURL=fragment_send.d.ts.map

package/src/engine/network/transport/fragments/fragment_send.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fragment_send.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/fragments/fragment_send.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCATW,UAAU,kBACV,MAAM,cACN,MAAM,wBACN,MAAM,WACN,UAAU,kBACD,UAAU,QAAE,MAAM,KAAG,IAAI,QAkD5C;AAED;;;;;;GAMG;AACH,qDAHW,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,+CARW,UAAU,kBACV,MAAM,cACN,MAAM,eACN,MAAM,wBACN,MAAM,WACN,UAAU,kBACD,UAAU,QAAE,MAAM,KAAG,IAAI,QAqC5C"}

package/src/engine/network/transport/fragments/fragment_send.js

@@ -1,157 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import {
-    FRAGMENT_HEADER_BYTES,
-    MAX_CHANNEL_PAYLOAD_BYTES,
-    MAX_CHUNKS_PER_MESSAGE,
-    MAX_FRAGMENT_CHUNK_BYTES,
-} from "./packet_size.js";
-
-/**
- * Send a logical payload through a callback, splitting into fragment
- * packets if it exceeds the channel's single-packet capacity.
- *
- * Layout of each emitted fragment packet (before the Channel adds its
- * 8-byte header):
- *
- *   uint8   FRAGMENT_PACKET_TYPE
- *   uint16  message_id   (little-endian)
- *   uint8   chunk_index
- *   uint8   total_chunks
- *   bytes   chunk_payload
- *
- * The chunk_payload bytes are slices of the original logical payload,
- * concatenated in chunk_index order they reconstruct the original
- * payload byte-for-byte. The logical payload's own packet-type byte is
- * the first byte of chunk 0 and is preserved by the reassembly.
- *
- * Single-packet messages (payload <= MAX_CHANNEL_PAYLOAD_BYTES) are sent
- * as-is with NO fragmentation header — the receiver dispatches them
- * normally via the FIRST byte. Fragmentation overhead only applies when
- * the payload genuinely doesn't fit.
- *
- * @param {Uint8Array} payload
- * @param {number} payload_length
- * @param {number} message_id  sender-assigned, unique per logical message
- * @param {number} fragment_packet_type  packet-type byte for fragment packets
- * @param {Uint8Array} scratch  reusable scratch buffer; must be >= MAX_CHANNEL_PAYLOAD_BYTES
- * @param {function(Uint8Array, number): void} send_fn
- *   invoked once per emitted packet — single send for non-fragmented case,
- *   N sends for fragmented case
- */
-export function send_fragmented(
-    payload,
-    payload_length,
-    message_id,
-    fragment_packet_type,
-    scratch,
-    send_fn,
-) {
-    assert.isNonNegativeInteger(payload_length, 'payload_length');
-    assert.isNonNegativeInteger(message_id, 'message_id');
-    assert.ok(message_id <= 0xFFFF, 'message_id must fit in uint16');
-    assert.ok(scratch.length >= MAX_CHANNEL_PAYLOAD_BYTES,
-        'scratch buffer must be at least MAX_CHANNEL_PAYLOAD_BYTES');
-
-    if (payload_length <= MAX_CHANNEL_PAYLOAD_BYTES) {
-        // Fits in one packet; send as-is.
-        send_fn(payload, payload_length);
-        return;
-    }
-
-    const total_chunks = Math.ceil(payload_length / MAX_FRAGMENT_CHUNK_BYTES);
-    if (total_chunks > MAX_CHUNKS_PER_MESSAGE) {
-        throw new Error(
-            `send_fragmented: payload of ${payload_length} bytes would require ` +
-            `${total_chunks} chunks, exceeding the ${MAX_CHUNKS_PER_MESSAGE}-chunk wire limit`
-        );
-    }
-
-    for (let i = 0; i < total_chunks; i++) {
-        const chunk_offset = i * MAX_FRAGMENT_CHUNK_BYTES;
-        const remaining = payload_length - chunk_offset;
-        const chunk_size = remaining < MAX_FRAGMENT_CHUNK_BYTES ? remaining : MAX_FRAGMENT_CHUNK_BYTES;
-
-        // Build the fragment packet inside scratch.
-        scratch[0] = fragment_packet_type;
-        scratch[1] = message_id & 0xFF;
-        scratch[2] = (message_id >> 8) & 0xFF;
-        scratch[3] = i;
-        scratch[4] = total_chunks;
-        scratch.set(
-            payload.subarray(chunk_offset, chunk_offset + chunk_size),
-            FRAGMENT_HEADER_BYTES,
-        );
-
-        send_fn(scratch, FRAGMENT_HEADER_BYTES + chunk_size);
-    }
-}
-
-/**
- * Number of chunks {@link send_fragmented} splits a payload of `payload_length` bytes into — the
- * chunk indices a receiver may ask to have re-sent are `[0, count)`.
- *
- * @param {number} payload_length
- * @returns {number}
- */
-export function fragment_chunk_count(payload_length) {
-    // Payloads short enough to not fragment in the first place are never
-    // retained, so the 1 is defensive consistency rather than a real case.
-    return payload_length <= MAX_FRAGMENT_CHUNK_BYTES
-        ? 1
-        : Math.ceil(payload_length / MAX_FRAGMENT_CHUNK_BYTES);
-}
-
-/**
- * Re-emit a single fragment chunk for a previously-sent fragmented
- * message. Used by the NACK retransmit path: the sender's
- * {@link FragmentRetention} keeps the source bytes so any chunk can be
- * deterministically rebuilt.
- *
- * The wire layout matches what {@link send_fragmented} would have
- * produced for the same `(message_id, chunk_index, total_chunks)` —
- * receivers can't tell a retransmit from an original.
- *
- * @param {Uint8Array} payload  retained source bytes
- * @param {number} payload_length
- * @param {number} message_id
- * @param {number} chunk_index  must be < derived total_chunks; silently ignored otherwise
- * @param {number} fragment_packet_type
- * @param {Uint8Array} scratch  reusable scratch; must be >= MAX_CHANNEL_PAYLOAD_BYTES
- * @param {function(Uint8Array, number): void} send_fn
- */
-export function resend_fragment_chunk(
-    payload,
-    payload_length,
-    message_id,
-    chunk_index,
-    fragment_packet_type,
-    scratch,
-    send_fn,
-) {
-    assert.isNonNegativeInteger(payload_length, 'payload_length');
-    assert.isNonNegativeInteger(message_id, 'message_id');
-    assert.ok(message_id <= 0xFFFF, 'message_id must fit in uint16');
-    assert.isNonNegativeInteger(chunk_index, 'chunk_index');
-    assert.ok(scratch.length >= MAX_CHANNEL_PAYLOAD_BYTES,
-        'scratch buffer must be at least MAX_CHANNEL_PAYLOAD_BYTES');
-
-    // Recover total_chunks from the retained payload length.
-    const total_chunks = fragment_chunk_count(payload_length);
-    if (chunk_index >= total_chunks) return;
-
-    const chunk_offset = chunk_index * MAX_FRAGMENT_CHUNK_BYTES;
-    const remaining = payload_length - chunk_offset;
-    const chunk_size = remaining < MAX_FRAGMENT_CHUNK_BYTES ? remaining : MAX_FRAGMENT_CHUNK_BYTES;
-
-    scratch[0] = fragment_packet_type;
-    scratch[1] = message_id & 0xFF;
-    scratch[2] = (message_id >> 8) & 0xFF;
-    scratch[3] = chunk_index;
-    scratch[4] = total_chunks;
-    scratch.set(
-        payload.subarray(chunk_offset, chunk_offset + chunk_size),
-        FRAGMENT_HEADER_BYTES,
-    );
-
-    send_fn(scratch, FRAGMENT_HEADER_BYTES + chunk_size);
-}

package/src/engine/network/transport/fragments/packet_size.d.ts

@@ -1,99 +0,0 @@
-/**
- * Packet-size constants for the fragmentation layer.
- *
- * The target transport MTU is 1200 bytes (Quake / Source / Glenn Fiedler's
- * Networked Physics recommend ~1200 to stay under typical PMTU after IP/UDP
- * headers; ethernet 1500 - 40 IPv6 - 8 UDP = 1452 in the best case, but
- * intermediate hops with tunnelling, IPv6 extension headers, or DSLite
- * routinely shave this down — 1200 is the safe number).
- *
- * Above this, the application's logical payload must be split into chunks
- * via {@link send_fragmented} and reassembled on the receiver via
- * {@link FragmentAssembler}.
- *
- * Header overhead breakdown for a fragment packet, from the transport's
- * point of view:
- *   - {@link Channel} adds 9 bytes (seq + ack_latest + ack_bitfield + ack_present).
- *   - The FRAGMENT packet type byte = 1 byte.
- *   - Fragment header (message_id uint16 + chunk_index uint8 + total_chunks
- *     uint8) = 4 bytes.
- * Total overhead per fragment = 14 bytes; payload capacity per fragment =
- * 1200 - 14 = 1186 bytes.
- *
- * For a logical message that fits in a single packet (no fragmentation
- * needed), only the Channel header overhead applies — the payload starts
- * with its own packet-type byte (e.g. ACTION_STREAM) and is sent directly.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-/** Target transport MTU. */
-export const MTU_BYTES: 1200;
-/** Channel layer's per-packet header size. Must match {@link Channel}'s HEADER_SIZE. */
-export const CHANNEL_HEADER_BYTES: 9;
-/**
- * Bytes the Channel reserves for the actual payload (no fragmentation):
- * MTU minus the channel header.
- */
-export const MAX_CHANNEL_PAYLOAD_BYTES: number;
-/**
- * Fragment header bytes within the channel payload:
- *   - 1 byte for the FRAGMENT packet-type marker
- *   - 2 bytes for message_id (uint16)
- *   - 1 byte for chunk_index (uint8)
- *   - 1 byte for total_chunks (uint8)
- */
-export const FRAGMENT_HEADER_BYTES: 5;
-/** Maximum number of payload bytes per fragment packet. */
-export const MAX_FRAGMENT_CHUNK_BYTES: number;
-/** Maximum number of chunks in a single logical message (limited by uint8 total_chunks). */
-export const MAX_CHUNKS_PER_MESSAGE: 255;
-/** Largest single logical payload supportable by this fragmentation scheme. */
-export const MAX_LOGICAL_MESSAGE_BYTES: number;
-/**
- * NACK retransmit timing.
- *
- *   FRAGMENT_NACK_INITIAL_DELAY_MS  — how long the receiver waits after the
- *     first chunk of a message arrives before NACKing the missing chunks.
- *     Trades off latency-of-recovery against premature NACKs for chunks
- *     that were just slightly late.
- *   FRAGMENT_NACK_RESEND_INTERVAL_MS — period between NACK retries when a
- *     message remains incomplete.
- *   FRAGMENT_NACK_MAX_ROUNDS — after this many NACK rounds without
- *     completion, the receiver drops the message; the sender's retention
- *     ages out independently.
- *
- * 75 ms initial delay is sized for the consumer mobile RTT bands measured
- * across US / EU / China in 2024–2025: 5G median 15–45 ms, 4G median
- * 30–55 ms, per-path jitter <10 ms for the majority of long-lived
- * connections. 75 ms sits comfortably above worst-case (4G median + jitter
- * + wire time for a small burst) so legitimate stragglers land before the
- * NACK fires, while keeping recovery latency on real loss to ~75 ms + 1
- * RTT. On worst-case paths the receiver may occasionally NACK chunks
- * still in transit; the receiver-side dedup absorbs the duplicate
- * retransmits.
- */
-export const FRAGMENT_NACK_INITIAL_DELAY_MS: 75;
-export const FRAGMENT_NACK_RESEND_INTERVAL_MS: 75;
-export const FRAGMENT_NACK_MAX_ROUNDS: 3;
-/**
- * Sender-side retention bounds. The sender keeps a copy of each fragmented
- * message's bytes so it can satisfy NACK retransmits. Retention is
- * FIFO-evicted at `FRAGMENT_RETENTION_MAX_MESSAGES` and age-evicted at
- * `FRAGMENT_RETENTION_MAX_AGE_MS`.
- *
- * Worst-case memory per peer: `FRAGMENT_RETENTION_MAX_MESSAGES *
- * max_message_size` bytes. With the FragmentAssembler default of 64 KiB,
- * that's 1 MiB per peer at saturation; steady-state retention is empty
- * because steady traffic fits in one packet and bypasses fragmentation.
- *
- * `FRAGMENT_RETENTION_MAX_RETRIES` is how many NACKs a retained message is
- * repaired for. A NACK re-sends each chunk of the message at most once, so
- * whatever a peer asks, repair costs at most this many copies of a message
- * the sender chose to send. It matches the receiver's
- * `FRAGMENT_NACK_MAX_ROUNDS`: an honest receiver never asks more often.
- */
-export const FRAGMENT_RETENTION_MAX_AGE_MS: 1500;
-export const FRAGMENT_RETENTION_MAX_MESSAGES: 16;
-export const FRAGMENT_RETENTION_MAX_RETRIES: 3;
-//# sourceMappingURL=packet_size.d.ts.map

package/src/engine/network/transport/fragments/packet_size.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"packet_size.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/fragments/packet_size.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,4BAA4B;AAC5B,6BAA8B;AAE9B,wFAAwF;AACxF,qCAAsC;AAEtC;;;GAGG;AACH,+CAA0E;AAE1E;;;;;;GAMG;AACH,sCAAuC;AAEvC,2DAA2D;AAC3D,8CAA0F;AAE1F,4FAA4F;AAC5F,yCAA0C;AAE1C,+EAA+E;AAC/E,+CAA2F;AAE3F;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gDAAiD;AACjD,kDAAmD;AACnD,yCAA0C;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,iDAAkD;AAClD,iDAAkD;AAClD,+CAAgD"}

package/src/engine/network/transport/fragments/packet_size.js

@@ -1,107 +0,0 @@
-/**
- * Packet-size constants for the fragmentation layer.
- *
- * The target transport MTU is 1200 bytes (Quake / Source / Glenn Fiedler's
- * Networked Physics recommend ~1200 to stay under typical PMTU after IP/UDP
- * headers; ethernet 1500 - 40 IPv6 - 8 UDP = 1452 in the best case, but
- * intermediate hops with tunnelling, IPv6 extension headers, or DSLite
- * routinely shave this down — 1200 is the safe number).
- *
- * Above this, the application's logical payload must be split into chunks
- * via {@link send_fragmented} and reassembled on the receiver via
- * {@link FragmentAssembler}.
- *
- * Header overhead breakdown for a fragment packet, from the transport's
- * point of view:
- *   - {@link Channel} adds 9 bytes (seq + ack_latest + ack_bitfield + ack_present).
- *   - The FRAGMENT packet type byte = 1 byte.
- *   - Fragment header (message_id uint16 + chunk_index uint8 + total_chunks
- *     uint8) = 4 bytes.
- * Total overhead per fragment = 14 bytes; payload capacity per fragment =
- * 1200 - 14 = 1186 bytes.
- *
- * For a logical message that fits in a single packet (no fragmentation
- * needed), only the Channel header overhead applies — the payload starts
- * with its own packet-type byte (e.g. ACTION_STREAM) and is sent directly.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-
-/** Target transport MTU. */
-export const MTU_BYTES = 1200;
-
-/** Channel layer's per-packet header size. Must match {@link Channel}'s HEADER_SIZE. */
-export const CHANNEL_HEADER_BYTES = 9;
-
-/**
- * Bytes the Channel reserves for the actual payload (no fragmentation):
- * MTU minus the channel header.
- */
-export const MAX_CHANNEL_PAYLOAD_BYTES = MTU_BYTES - CHANNEL_HEADER_BYTES;
-
-/**
- * Fragment header bytes within the channel payload:
- *   - 1 byte for the FRAGMENT packet-type marker
- *   - 2 bytes for message_id (uint16)
- *   - 1 byte for chunk_index (uint8)
- *   - 1 byte for total_chunks (uint8)
- */
-export const FRAGMENT_HEADER_BYTES = 5;
-
-/** Maximum number of payload bytes per fragment packet. */
-export const MAX_FRAGMENT_CHUNK_BYTES = MAX_CHANNEL_PAYLOAD_BYTES - FRAGMENT_HEADER_BYTES;
-
-/** Maximum number of chunks in a single logical message (limited by uint8 total_chunks). */
-export const MAX_CHUNKS_PER_MESSAGE = 255;
-
-/** Largest single logical payload supportable by this fragmentation scheme. */
-export const MAX_LOGICAL_MESSAGE_BYTES = MAX_FRAGMENT_CHUNK_BYTES * MAX_CHUNKS_PER_MESSAGE;
-
-/**
- * NACK retransmit timing.
- *
- *   FRAGMENT_NACK_INITIAL_DELAY_MS  — how long the receiver waits after the
- *     first chunk of a message arrives before NACKing the missing chunks.
- *     Trades off latency-of-recovery against premature NACKs for chunks
- *     that were just slightly late.
- *   FRAGMENT_NACK_RESEND_INTERVAL_MS — period between NACK retries when a
- *     message remains incomplete.
- *   FRAGMENT_NACK_MAX_ROUNDS — after this many NACK rounds without
- *     completion, the receiver drops the message; the sender's retention
- *     ages out independently.
- *
- * 75 ms initial delay is sized for the consumer mobile RTT bands measured
- * across US / EU / China in 2024–2025: 5G median 15–45 ms, 4G median
- * 30–55 ms, per-path jitter <10 ms for the majority of long-lived
- * connections. 75 ms sits comfortably above worst-case (4G median + jitter
- * + wire time for a small burst) so legitimate stragglers land before the
- * NACK fires, while keeping recovery latency on real loss to ~75 ms + 1
- * RTT. On worst-case paths the receiver may occasionally NACK chunks
- * still in transit; the receiver-side dedup absorbs the duplicate
- * retransmits.
- */
-export const FRAGMENT_NACK_INITIAL_DELAY_MS = 75;
-export const FRAGMENT_NACK_RESEND_INTERVAL_MS = 75;
-export const FRAGMENT_NACK_MAX_ROUNDS = 3;
-
-/**
- * Sender-side retention bounds. The sender keeps a copy of each fragmented
- * message's bytes so it can satisfy NACK retransmits. Retention is
- * FIFO-evicted at `FRAGMENT_RETENTION_MAX_MESSAGES` and age-evicted at
- * `FRAGMENT_RETENTION_MAX_AGE_MS`.
- *
- * Worst-case memory per peer: `FRAGMENT_RETENTION_MAX_MESSAGES *
- * max_message_size` bytes. With the FragmentAssembler default of 64 KiB,
- * that's 1 MiB per peer at saturation; steady-state retention is empty
- * because steady traffic fits in one packet and bypasses fragmentation.
- *
- * `FRAGMENT_RETENTION_MAX_RETRIES` is how many NACKs a retained message is
- * repaired for. A NACK re-sends each chunk of the message at most once, so
- * whatever a peer asks, repair costs at most this many copies of a message
- * the sender chose to send. It matches the receiver's
- * `FRAGMENT_NACK_MAX_ROUNDS`: an honest receiver never asks more often.
- */
-export const FRAGMENT_RETENTION_MAX_AGE_MS = 1500;
-export const FRAGMENT_RETENTION_MAX_MESSAGES = 16;
-export const FRAGMENT_RETENTION_MAX_RETRIES = 3;

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_RRTAndODTFit.d.ts

@@ -1,6 +0,0 @@
-/**
- * source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
- */
-export const chunk_RRTAndODTFit: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_RRTAndODTFit.d.ts.map

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_RRTAndODTFit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_RRTAndODTFit.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/sRGB/chunk_RRTAndODTFit.js"],"names":[],"mappings":"AAEA;;GAEG;AACH,2CAUI;0BAfsB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/sRGB/chunk_RRTAndODTFit.js

@@ -1,16 +0,0 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-
-/**
- * source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
- */
-export const chunk_RRTAndODTFit = CodeChunk.from(
-// language=WGSL
-    `
-fn RRTAndODTFit(  color: vec3<f32> ) -> vec3<f32> {
-
-	let a = color * ( color + 0.0245786 ) - 0.000090537;
-	let b = color * ( 0.983729 * color + 0.4329510 ) + 0.238081;
-
-	return a / b;
-
-}`);

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_aces.d.ts

@@ -1,7 +0,0 @@
-/**
- * this implementation of ACES is modified to accommodate a brighter viewing environment.
- * the scale factor of 1/0.6 is subjective. see discussion in #19621.
- */
-export const chunk_tonemap_aces: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_tonemap_aces.d.ts.map

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_aces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_tonemap_aces.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_aces.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,2CAqCE;0BA5CwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_aces.js

@@ -1,46 +0,0 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_RRTAndODTFit } from "../sRGB/chunk_RRTAndODTFit.js";
-
-/**
- * this implementation of ACES is modified to accommodate a brighter viewing environment.
- * the scale factor of 1/0.6 is subjective. see discussion in #19621.
- */
-export const chunk_tonemap_aces = CodeChunk.from(
-// language=WGSL
-    `
-
-fn tonemap_aces( in_color:vec3<f32> ) ->vec3<f32> {
-
-    // Fitted by Stephen Hill
-	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-	const  RGB_to_ACES = mat3x3(
-		vec3( 0.59719, 0.07600, 0.02840 ), // transposed from source
-		vec3( 0.35458, 0.90834, 0.13383 ),
-		vec3( 0.04823, 0.01566, 0.83777 )
-	);
-
-	// ODT_SAT => XYZ => D60_2_D65 => sRGB
-	const  ACES_to_RGB = mat3x3(
-		vec3(  1.60475, -0.10208, -0.00327 ), // transposed from source
-		vec3( -0.53108,  1.10813, -0.07276 ),
-		vec3( -0.07367, -0.00605,  1.07602 )
-	);
-
-    var color = in_color;
-
-	color = RGB_to_ACES * color;
-
-	// Apply RRT and ODT curve fitting
-	color = RRTAndODTFit( color );
-
-	color = ACES_to_RGB * color;
-
-	// Clamp to [0, 1]
-	return saturate( color );
-
-}
-    `, [
-        chunk_RRTAndODTFit,
-    ]
-);
-

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_agx.d.ts

@@ -1,10 +0,0 @@
-/**
- * AgX Tone Mapping implementation based on Filament, which in turn is based
- * on Blender's implementation using rec 2020 primaries
- * @see https://github.com/google/filament/pull/7236
- * @see https://github.com/google/filament/blob/2456299337f2205db5c1dd038213a46679b4cd77/filament/src/ToneMapper.cpp#L332
- * Inputs and outputs are encoded as Linear-sRGB.
- */
-export const chunk_tonemap_agx: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_tonemap_agx.d.ts.map

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_agx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_tonemap_agx.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_agx.js"],"names":[],"mappings":"AAqDA;;;;;;GAMG;AACH,0CAkEE;0BA9HwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_agx.js

@@ -1,127 +0,0 @@
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_CRM_FROM_REC2020_TO_REC709 } from "../conversion/chunk_CRM_FROM_REC2020_TO_REC709.js";
-import { chunk_CRM_FROM_REC709_TO_REC2020 } from "../conversion/chunk_CRM_FROM_REC709_TO_REC2020.js";
-
-/**
- * 8th degree polynomial approximation
- * Mean error^2: 1.85907662e-06
- * Adapted from https://iolite-engine.com/blog_posts/minimal_agx_implementation
- * @type {CodeChunk}
- */
-const chunk_agxDefaultContrastApprox8 = CodeChunk.from(
-    //language=WGSL
-    `
-fn agxDefaultContrastApprox( x: vec3<f32> ) -> vec3<f32> {
-    let x2 = x * x;
-    let x4 = x2 * x2;
-    let x6 = x4 * x2;
-
-    return  - 17.86f    * x6 * x
-        + 78.01f    * x6
-        - 126.7f    * x4 * x
-        + 92.06f    * x4
-        - 28.72f    * x2 * x
-        + 4.361f    * x2
-        - 0.1718f   * x
-        + 0.002857f;
-}
-`);
-
-
-/**
- * 6th degree polynomial approximation
- * Mean error^2: 3.6705141e-06
- * Adapted from https://iolite-engine.com/blog_posts/minimal_agx_implementation
- * @type {CodeChunk}
- */
-const chunk_agxDefaultContrastApprox6 = CodeChunk.from(
-    //language=WGSL
-    `
-fn agxDefaultContrastApprox( x:vec3<f32>)->vec3<f32> {
-    let x2 = x * x;
-    let x4 = x2 * x2;
-
-    return  15.5     * x4 * x2
-        - 40.14    * x4 * x
-        + 31.96    * x4
-        - 6.868    * x2 * x
-        + 0.4298   * x2
-        + 0.1191   * x
-        - 0.00232;;
-}
-`);
-
-/**
- * AgX Tone Mapping implementation based on Filament, which in turn is based
- * on Blender's implementation using rec 2020 primaries
- * @see https://github.com/google/filament/pull/7236
- * @see https://github.com/google/filament/blob/2456299337f2205db5c1dd038213a46679b4cd77/filament/src/ToneMapper.cpp#L332
- * Inputs and outputs are encoded as Linear-sRGB.
- */
-export const chunk_tonemap_agx = CodeChunk.from(
-    //language=WGSL
-    `
-fn tonemap_agx( in_color : vec3<f32> ) ->vec3<f32> {
-
-	// AgX constants
-	const  AgXInsetMatrix = mat3x3(
-		vec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),
-		vec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),
-		vec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )
-	);
-
-	// explicit AgXOutsetMatrix generated from Filaments AgXOutsetMatrixInv
-	// https://github.com/EaryChow/AgX_LUT_Gen/blob/main/AgXBaseRec2020.py
-	const  AgXOutsetMatrix = mat3x3(
-		vec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),
-		vec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),
-		vec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )
-	);
-
-	// LOG2_MIN      = -10.0
-	// LOG2_MAX      =  +6.5
-	// MIDDLE_GRAY   =  0.18
-	const  AgxMinEv = - 12.47393;  // log2( pow( 2, LOG2_MIN ) * MIDDLE_GRAY )
-	const  AgxMaxEv = 4.026069;    // log2( pow( 2, LOG2_MAX ) * MIDDLE_GRAY )
-
-    var color = in_color;
-
-
-	color = CRM_FROM_REC709_TO_REC2020 * color;
-
-	color = AgXInsetMatrix * color;
-
-	// Log2 encoding
-	color = max( color, vec3(1e-10) ); // avoid 0 or negative numbers for log2
-	color = log2( color );
-	color = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );
-
-	color = saturate( color );
-
-	// Apply sigmoid
-	color = agxDefaultContrastApprox( color );
-
-	// Apply AgX look
-	// v = agxLook(v, look);
-
-	color = AgXOutsetMatrix * color;
-
-    // convert to output color space
-	color = CRM_FROM_REC2020_TO_REC709 * color;
-	
-	// Linearize
-	color = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );
-
-	// Gamut mapping. Simple clamp for now.
-	color = saturate( color );
-
-	return color;
-
-}
-`,
-    [
-        chunk_agxDefaultContrastApprox6,
-        chunk_CRM_FROM_REC709_TO_REC2020,
-        chunk_CRM_FROM_REC2020_TO_REC709
-    ]
-);

package/src/shade/renderer/shader/chunk/color/tonemap/chunk_tonemap_pbr_neutral.d.ts

@@ -1,7 +0,0 @@
-/**
- * @see filament https://github.com/google/filament/blob/7d80975c3cec617c274640fe2813f726770696bb/filament/src/ToneMapper.cpp#L237
- * PBR Tone Mapping, https://modelviewer.dev/examples/tone-mapping.html
- */
-export const chunk_tonemap_pbr_neutral: CodeChunk;
-import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_tonemap_pbr_neutral.d.ts.map