@woosh/meep-engine 3.47.0 → 3.49.0

package/src/engine/network/transport/Channel.d.ts

@@ -1,85 +0,0 @@
-export class Channel {
-    /**
-     * @param {{
-     *   transport: { send(bytes: Uint8Array, length: number): void, onReceive: Signal },
-     *   max_in_flight?: number,
-     * }} options
-     *   `max_in_flight` hard-caps the number of unacked outgoing seqs. It exists
-     *   to keep the in-flight span well below the seq16 half-range (32768): once
-     *   an unacked seq falls more than half-range behind the newest sent, the
-     *   signed `seq16_distance` used for loss detection wraps and the entry can
-     *   neither be acked nor declared lost — a permanent leak (and a downstream
-     *   `seq_to_pending` leak in the orchestrator). Capping in-flight makes
-     *   that lap impossible. Default 1024 ≫ any realistic in-flight window
-     *   (RTT × send-rate) yet ≪ 32768. Only reached under a sustained one-way
-     *   stall, where eviction-as-lost is the correct verdict anyway.
-     */
-    constructor({ transport, max_in_flight }: {
-        transport: {
-            send(bytes: Uint8Array, length: number): void;
-            onReceive: Signal;
-        };
-        max_in_flight?: number;
-    });
-    /**
-     * @type {{ send(bytes: Uint8Array, length: number): void, onReceive: Signal }}
-     */
-    transport: {
-        send(bytes: Uint8Array, length: number): void;
-        onReceive: Signal;
-    };
-    /**
-     * Fired when an outgoing seq has been positively acknowledged by the peer.
-     * @type {Signal}
-     */
-    onPacketAcked: Signal;
-    /**
-     * Fired when an outgoing seq has aged out of the ack window without being acked.
-     * @type {Signal}
-     */
-    onPacketLost: Signal;
-    /**
-     * Fired when an inbound packet's payload is ready (header already stripped).
-     * Handler args: (payload: Uint8Array starting at offset 0, length: number).
-     * The Uint8Array is owned by the Channel and may be reused after the handler returns.
-     * @type {Signal}
-     */
-    onPayload: Signal;
-    /**
-     * Wrap and send a payload. Returns the seq number assigned to it.
-     *
-     * @param {Uint8Array} payload
-     * @param {number} length payload length in bytes
-     * @returns {number} seq
-     */
-    send(payload: Uint8Array, length: number): number;
-    /**
-     * Number of outgoing packets sent but not yet acked or marked lost.
-     * @returns {number}
-     */
-    unacked_count(): number;
-    /**
-     * Most recent seq received from the peer, or -1 if none yet.
-     * @returns {number}
-     */
-    latest_received_seq(): number;
-    /**
-     * Test-only: seed the next outgoing seq number. Used to fast-forward
-     * the seq counter so the seq16 wraparound can be exercised in
-     * unit tests without sending 65k packets. Do not call from production.
-     * @param {number} seq
-     */
-    seed_outgoing_seq_for_testing(seq: number): void;
-    /**
-     * Detach this Channel from its transport. The transport.onReceive subscription
-     * is removed so the Channel stops processing inbound bytes; the Channel's own
-     * Signals are left in place (callers usually hold no references to them after
-     * dispose, so they GC with the Channel). Required before discarding a Channel
-     * whose transport will be reused — otherwise the old Channel keeps consuming
-     * inbound packets in parallel with whatever replaces it.
-     */
-    dispose(): void;
-    #private;
-}
-import Signal from "../../../core/events/signal/Signal.js";
-//# sourceMappingURL=Channel.d.ts.map

package/src/engine/network/transport/Channel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Channel.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Channel.js"],"names":[],"mappings":"AA6CA;IAWI;;;;;;;;;;;;;;OAcG;IACH,0CAdW;QACV,SAAa,EAAE;YAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;QACpF,aAAiB,CAAC,EAAE,MAAM,CAAC;KACxB,EAuFH;IAnEG;;OAEG;IACH,WAFU;QAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAEpD;IA6C1B;;;OAGG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFU,MAAM,CAEgB;IAEhC;;;;;OAKG;IACH,WAFU,MAAM,CAEa;IAGjC;;;;;;OAMG;IACH,cAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAiDlB;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAFW,MAAM,QAIhB;IA+ED;;;;;;;OAOG;IACH,gBAEC;;CAiBJ;mBA9UkB,uCAAuC"}

package/src/engine/network/transport/ReliableCommandPipeline.d.ts

@@ -1,155 +0,0 @@
-/**
- * Largest reliable-command payload that fits in a single channel packet.
- *
- * A command's wire form is `uint8 packet_type + uintVar logical_seq + payload`.
- * The pipeline sends it through {@link Channel#send} directly — it does NOT
- * fragment — so the whole thing must fit one channel packet
- * ({@link MAX_CHANNEL_PAYLOAD_BYTES}). We reserve 11 bytes for the framing:
- * 1 packet-type byte + up to 10 bytes of `uintVar` for `logical_seq` (its
- * worst case; `logical_seq` grows over the session, so we budget the maximum
- * rather than the current value). Sending a larger payload on a UDP-style
- * transport would emit an over-MTU datagram that the network silently drops;
- * we reject it loudly instead.
- *
- * @type {number}
- */
-export const MAX_RELIABLE_COMMAND_PAYLOAD_BYTES: number;
-/**
- * Reliable, at-least-once delivery layer over a {@link Channel}.
- *
- * Used for messages that must arrive: chat, lobby/room state changes,
- * level transitions, kick / disconnect notifications. Distinct from the
- * action-stream traffic the rest of the netcode uses, which is UDP-style
- * best-effort with per-frame back-fill compensating for losses.
- *
- * Wire layout (after the {@link Channel}'s 8-byte header and the
- * `packet_type` byte that {@link NetworkPeer}'s dispatcher consumes):
- *
- *   uintVar logical_seq    sender-assigned, monotonically increasing
- *   bytes   command_payload
- *
- * Reliability mechanism: each outgoing command goes out as one
- * Channel.send call. The returned channel-level seq is tracked in
- * `__unacked`. When the Channel later fires:
- *   - `onPacketAcked(seq)`: drop the entry — the command was delivered
- *     (the receiver de-duplicated by logical_seq, so a "duplicate" from
- *     a previous retransmit is harmless).
- *   - `onPacketLost(seq)`: the Channel's 33-packet ack window aged out
- *     this seq without seeing it acked. Re-send the same logical
- *     command on a fresh channel seq.
- *
- * Receiver side: a sliding-window de-dupe of recent `logical_seq` values.
- * Anything seen within the last `max_received_history` is silently
- * dropped; first-time arrivals fire `onCommand` with the payload bytes.
- *
- * Ordering: NOT guaranteed. Commands may arrive in any order. If you
- * need in-order delivery (level transitions before subsequent chat),
- * key payloads with a counter and reorder in the application handler.
- *
- * Lifecycle constraints:
- *   - `max_unacked` caps outstanding commands. Send throws when full
- *     (signals real backpressure — receiver gone or path is broken).
- *   - `max_received_history` caps the de-dupe set. A retransmit older
- *     than this window will be re-delivered as a duplicate to the
- *     application; not a problem in practice because the sender's
- *     `max_unacked` keeps the inflight set bounded too.
- *
- * Caveats:
- *   - Loss detection relies on the Channel's seq window, which advances
- *     when subsequent packets are sent. Under sustained no-traffic
- *     conditions a single lost reliable command may stay unacked
- *     indefinitely — by convention the action-stream's per-tick traffic
- *     keeps the window moving even when the application is otherwise
- *     idle. Real production code may want a timer-based retransmit
- *     fallback layered on top of this.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ReliableCommandPipeline {
-    /**
-     * @param {{
-     *   channel: import("./Channel.js").Channel,
-     *   packet_type: number,
-     *   max_unacked?: number,
-     *   max_received_history?: number,
-     *   max_retries?: number,
-     * }} options
-     */
-    constructor({ channel, packet_type, max_unacked, max_received_history, max_retries, }: {
-        channel: import("./Channel.js").Channel;
-        packet_type: number;
-        max_unacked?: number;
-        max_received_history?: number;
-        max_retries?: number;
-    });
-    /** @type {import("./Channel.js").Channel} */
-    channel: import("./Channel.js").Channel;
-    /** @type {number} @readonly */
-    readonly packet_type: number;
-    /** @type {number} @readonly */
-    readonly max_unacked: number;
-    /** @type {number} @readonly */
-    readonly max_received_history: number;
-    /**
-     * Maximum retransmissions per logical command before it is dropped
-     * and {@link onCommandAbandoned} fires. Bounded so a permanently-
-     * black-holed peer can't pin retransmit traffic on the channel
-     * forever. The default (16) tolerates roughly half a second of
-     * sustained loss at typical channel cadences before giving up.
-     * @type {number} @readonly
-     */
-    readonly max_retries: number;
-    /**
-     * Fired when a brand-new logical command arrives (not a duplicate).
-     * Args: `(buf, payload_offset, payload_length)`. The buffer is
-     * shared scratch; consumers must copy bytes if they need them to
-     * outlive the handler.
-     * @type {Signal}
-     */
-    onCommand: Signal;
-    /**
-     * Fired when a sent command has been retransmitted `max_retries`
-     * times without an ack and is being given up on. Args:
-     * `(logical_seq)`. Subscribers typically surface this as a "command
-     * failed to deliver" event to the application, or treat it as a
-     * hard signal to tear down the session.
-     * @type {Signal}
-     */
-    onCommandAbandoned: Signal;
-    /**
-     * Send a logical command. Returns the assigned `logical_seq` (useful
-     * for application-level diagnostics; the receiver dedups internally
-     * regardless).
-     *
-     * @param {Uint8Array} payload
-     * @param {number} length
-     * @returns {number}
-     */
-    send(payload: Uint8Array, length: number): number;
-    /**
-     * Called by the orchestrator (typically {@link NetworkPeer}'s
-     * dispatcher) when a packet of this pipeline's type arrives. `buf`
-     * is positioned just past the packet-type byte.
-     *
-     * @param {BinaryBuffer} buf
-     * @param {number} total_length    full transport-level payload length,
-     *                                  including the consumed packet-type byte
-     */
-    handle_inbound(buf: BinaryBuffer, total_length: number): void;
-    /**
-     * Number of commands sent that haven't yet been acked. Useful for
-     * backpressure / progress UI.
-     * @returns {number}
-     */
-    unacked_count(): number;
-    /**
-     * Drop subscriptions and clear state. Required before discarding a
-     * pipeline whose channel will outlive it.
-     */
-    dispose(): void;
-    #private;
-}
-import Signal from "../../../core/events/signal/Signal.js";
-import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
-//# sourceMappingURL=ReliableCommandPipeline.d.ts.map

package/src/engine/network/transport/ReliableCommandPipeline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ReliableCommandPipeline.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/ReliableCommandPipeline.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,iDAFU,MAAM,CAEiE;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH;IAsBI;;;;;;;;OAQG;IACH,uFARW;QACV,OAAW,EAAE,OAAO,cAAc,EAAE,OAAO,CAAC;QAC5C,WAAe,EAAE,MAAM,CAAC;QACxB,WAAe,CAAC,EAAE,MAAM,CAAC;QACzB,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,WAAe,CAAC,EAAE,MAAM,CAAC;KACtB,EAmFH;IAnEG,6CAA6C;IAC7C,SADW,OAAO,cAAc,EAAE,OAAO,CACnB;IACtB,+BAA+B;IAC/B,sBADW,MAAM,CACa;IAC9B,+BAA+B;IAC/B,sBADW,MAAM,CACa;IAC9B,+BAA+B;IAC/B,+BADW,MAAM,CAC+B;IAChD;;;;;;;OAOG;IACH,sBAFU,MAAM,CAEc;IA2B9B;;;;;;OAMG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;OAOG;IACH,oBAFU,MAAM,CAEsB;IAS1C;;;;;;;;OAQG;IACH,cAJW,UAAU,UACV,MAAM,GACJ,MAAM,CA+BlB;IAED;;;;;;;;OAQG;IACH,oBAJW,YAAY,gBACZ,MAAM,QAwChB;IAED;;;;OAIG;IACH,iBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAMC;;CAsCJ;mBA5UkB,uCAAuC;6BAD7B,sCAAsC"}

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

@@ -1,105 +0,0 @@
-/**
- * Per-peer reassembly buffer for fragmented packets.
- *
- * When a sender's logical payload exceeds the MTU it gets split into
- * multiple {@link NetworkPacketType.FRAGMENT} packets, each carrying a
- * `(message_id, chunk_index, total_chunks, chunk_bytes)` tuple. The
- * receiver feeds those tuples to {@link receive}; once all chunks for a
- * `message_id` have arrived, `receive` returns the reassembled bytes
- * for the upper layer to dispatch.
- *
- * Loss recovery via NACK: a partially-received message that doesn't
- * complete within `nack_initial_delay_ms` triggers a NACK back to the
- * sender listing the missing chunk indices. NACK rounds repeat at
- * `nack_resend_interval_ms` up to `nack_max_rounds`; after that the
- * receiver gives up on the message and the sender's retention ages
- * out independently. Wire the per-tick driver via {@link service}.
- *
- * Loss-of-last-resort model: if even the NACK retries fail (link is
- * dead, sender retention was evicted, etc.) the message never
- * completes and FIFO-evicts when the pending cap is hit. Upper layers
- * are still expected to tolerate occasional missing messages — NACK
- * recovers most loss, not all.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class FragmentAssembler {
-    /**
-     * @param {{
-     *   max_pending_messages?: number,
-     *   max_message_size?: number,
-     *   nack_initial_delay_ms?: number,
-     *   nack_resend_interval_ms?: number,
-     *   nack_max_rounds?: number,
-     * }} [options]
-     *   `max_pending_messages` caps the number of in-flight reassembly
-     *   slots; when full, the oldest pending message is evicted to make
-     *   room. `max_message_size` rejects reassembled messages larger than
-     *   this many bytes (defensive against a malicious peer or a wedged
-     *   sender). The `nack_*` knobs control the retransmit-request timer
-     *   driven by {@link service}.
-     */
-    constructor({ max_pending_messages, max_message_size, nack_initial_delay_ms, nack_resend_interval_ms, nack_max_rounds, }?: {
-        max_pending_messages?: number;
-        max_message_size?: number;
-        nack_initial_delay_ms?: number;
-        nack_resend_interval_ms?: number;
-        nack_max_rounds?: number;
-    });
-    /** @type {number} @readonly */
-    readonly max_pending_messages: number;
-    /** @type {number} @readonly */
-    readonly max_message_size: number;
-    /** @type {number} @readonly */
-    readonly nack_initial_delay_ms: number;
-    /** @type {number} @readonly */
-    readonly nack_resend_interval_ms: number;
-    /** @type {number} @readonly */
-    readonly nack_max_rounds: number;
-    /**
-     * Process an incoming fragment. Returns the reassembled bytes when
-     * the message is complete, or null otherwise.
-     *
-     * @param {number} message_id     sender-assigned message id
-     * @param {number} chunk_index    0-based
-     * @param {number} total_chunks   expected number of chunks (>= 1)
-     * @param {Uint8Array} chunk_bytes  source byte array
-     * @param {number} chunk_offset   start offset within `chunk_bytes`
-     * @param {number} chunk_length   number of bytes from `chunk_offset` to consume
-     * @returns {Uint8Array|null}
-     */
-    receive(message_id: number, chunk_index: number, total_chunks: number, chunk_bytes: Uint8Array, chunk_offset: number, chunk_length: number): Uint8Array | null;
-    /**
-     * Per-tick maintenance: drive NACK emission for pending messages
-     * whose initial delay has elapsed and whose resend interval has
-     * lapsed, and drop messages whose NACK budget is exhausted.
-     *
-     * On the first service tick that observes a pending entry, its
-     * arrival is timestamped (so the initial delay is measured from
-     * `now_ms` of that tick rather than from the actual wall-clock
-     * arrival of the first chunk — at typical tick rates the difference
-     * is one tick, negligible vs. the 100 ms initial delay).
-     *
-     * `on_nack` is invoked once per eligible message with
-     * `(message_id, indices, count)`: the missing chunks in index order, but
-     * never more of them than the message has delivered. The `indices` argument is a
-     * reused internal Uint8Array; only `indices[0..count)` is valid
-     * and only for the duration of the call.
-     *
-     * @param {number} now_ms
-     * @param {function(number, Uint8Array, number): void} on_nack
-     */
-    service(now_ms: number, on_nack: (arg0: number, arg1: Uint8Array, arg2: number) => void): void;
-    /**
-     * Number of in-flight reassembly slots currently held.
-     * @returns {number}
-     */
-    pending_count(): number;
-    /**
-     * Drop all in-flight reassembly state. Useful on peer disconnect.
-     */
-    clear(): void;
-    #private;
-}
-//# sourceMappingURL=FragmentAssembler.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"FragmentAssembler.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/fragments/FragmentAssembler.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAmCI;;;;;;;;;;;;;;OAcG;IACH,2HAdW;QACV,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,gBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,qBAAyB,CAAC,EAAE,MAAM,CAAC;QACnC,uBAA2B,CAAC,EAAE,MAAM,CAAC;QACrC,eAAmB,CAAC,EAAE,MAAM,CAAC;KAC1B,EAwDH;IAnCG,+BAA+B;IAC/B,+BADW,MAAM,CAC+B;IAChD,+BAA+B;IAC/B,2BADW,MAAM,CACuB;IACxC,+BAA+B;IAC/B,gCADW,MAAM,CACiC;IAClD,+BAA+B;IAC/B,kCADW,MAAM,CACqC;IACtD,+BAA+B;IAC/B,0BADW,MAAM,CACqB;IA4B1C;;;;;;;;;;;OAWG;IACH,oBARW,MAAM,eACN,MAAM,gBACN,MAAM,eACN,UAAU,gBACV,MAAM,gBACN,MAAM,GACJ,UAAU,GAAC,IAAI,CAuF3B;IA0BD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAHW,MAAM,kBACG,MAAM,QAAE,UAAU,QAAE,MAAM,KAAG,IAAI,QA+CpD;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;OAEG;IACH,cAMC;;CAQJ"}

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

@@ -1,103 +0,0 @@
-/**
- * Per-peer sender-side retention buffer for fragmented message bytes,
- * used to satisfy NACK retransmits from the peer's {@link FragmentAssembler}.
- *
- * Lifecycle:
- *   1. {@link retain} — called on each fragmented send; copies the source
- *      bytes into the retention so they're available to retransmit. If
- *      the per-peer slot cap is hit, the oldest retained entry is FIFO-
- *      evicted.
- *   2. {@link consume_nack} — looks up retained bytes for a NACK target
- *      and bumps the retry counter. Returns `null` if the entry is gone
- *      (aged out, evicted, or out of retry budget — in which case the
- *      entry is dropped here too).
- *   3. {@link service} — call once per tick to age out entries older
- *      than `max_age_ms`.
- *   4. {@link clear} — drop everything; call on peer disconnect.
- *
- * Memory cost: each retained entry holds a fresh copy of its source
- * payload (the upstream send buffer is a reused scratch). With the
- * default 16 slots × up-to-64 KiB cap on the receiver, worst case is
- * 1 MiB per peer; steady-state is empty because steady traffic fits in
- * one packet and bypasses fragmentation.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class FragmentRetention {
-    /**
-     * @param {{
-     *   max_messages?: number,
-     *   max_age_ms?: number,
-     *   max_retries?: number,
-     * }} [options]
-     *   `max_messages` caps simultaneously-retained messages; oldest is
-     *   FIFO-evicted on overflow. `max_age_ms` is the per-entry TTL.
-     *   `max_retries` caps how many NACK retransmit rounds a single
-     *   retained message can satisfy before being dropped.
-     */
-    constructor({ max_messages, max_age_ms, max_retries, }?: {
-        max_messages?: number;
-        max_age_ms?: number;
-        max_retries?: number;
-    });
-    /** @type {number} @readonly */
-    readonly max_messages: number;
-    /** @type {number} @readonly */
-    readonly max_age_ms: number;
-    /** @type {number} @readonly */
-    readonly max_retries: number;
-    /**
-     * Copy `payload[0..length)` into retention under `message_id`.
-     * Evicts the oldest retained entry if `max_messages` is exceeded.
-     *
-     * If a retained entry already exists for `message_id` (only legitimate
-     * cause: uint16 wrap), the old entry is dropped first so the FIFO
-     * position and retry budget restart from the new send.
-     *
-     * @param {number} message_id
-     * @param {Uint8Array} payload  source bytes (caller may overwrite after return)
-     * @param {number} length       number of bytes from `payload[0]` to copy
-     * @param {number} now_ms       monotonic timestamp for age-out
-     */
-    retain(message_id: number, payload: Uint8Array, length: number, now_ms: number): void;
-    /**
-     * Mark a NACK round for `message_id` and return the retained entry
-     * so the caller can re-emit the missing chunks. Returns `null` if
-     * no entry exists, or if the per-message retry budget is now
-     * exhausted (in which case the entry is dropped).
-     *
-     * @param {number} message_id
-     * @returns {{payload: Uint8Array, length: number}|null}
-     */
-    consume_nack(message_id: number): {
-        payload: Uint8Array;
-        length: number;
-    } | null;
-    /**
-     * Per-tick maintenance: evict any entry older than `max_age_ms`.
-     *
-     * The FIFO is in strict insertion order, so we can stop at the first
-     * still-fresh entry rather than scanning the whole map.
-     *
-     * @param {number} now_ms
-     */
-    service(now_ms: number): void;
-    /**
-     * Number of currently-retained messages.
-     * @returns {number}
-     */
-    size(): number;
-    /**
-     * Whether `message_id` is currently retained.
-     * @param {number} message_id
-     * @returns {boolean}
-     */
-    has(message_id: number): boolean;
-    /**
-     * Drop every retained entry. Use on peer disconnect.
-     */
-    clear(): void;
-    #private;
-}
-//# sourceMappingURL=FragmentRetention.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"FragmentRetention.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/fragments/FragmentRetention.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAUI;;;;;;;;;;OAUG;IACH,yDAVW;QACV,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,UAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAe,CAAC,EAAE,MAAM,CAAC;KACtB,EA6BH;IAdG,+BAA+B;IAC/B,uBADW,MAAM,CACe;IAChC,+BAA+B;IAC/B,qBADW,MAAM,CACW;IAC5B,+BAA+B;IAC/B,sBADW,MAAM,CACa;IAWlC;;;;;;;;;;;;OAYG;IACH,mBALW,MAAM,WACN,UAAU,UACV,MAAM,UACN,MAAM,QAuBhB;IAED;;;;;;;;OAQG;IACH,yBAHW,MAAM,GACJ;QAAC,OAAO,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,GAAC,IAAI,CAYtD;IAED;;;;;;;OAOG;IACH,gBAFW,MAAM,QAehB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAGC;;CAQJ"}

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/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/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;
-
-}`);