@woosh/meep-engine 3.10.0 → 3.11.0

package/src/shade/device/timing/profile/sgpt_read_records.js

@@ -0,0 +1,153 @@
+import { assert } from "../../../../core/assert.js";
+import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
+import { SGPTDefect } from "./SGPTDefect.js";
+import { SGPT_HEADER_SIZE } from "./SGPT_HEADER_SIZE.js";
+import { SGPT_RECORD_HEADER_SIZE } from "./SGPT_RECORD_HEADER_SIZE.js";
+import { SGPT_RECORD_SYNC } from "./SGPT_RECORD_SYNC.js";
+import { SGPTRecordRef } from "./SGPTRecordRef.js";
+
+/**
+ * Sync marker as four bytes, in the order they appear on the wire. Compared byte-wise during a
+ * scan so that resynchronisation does not depend on alignment — corruption does not politely
+ * truncate to a multiple of four.
+ *
+ * @type {number[]}
+ */
+const SYNC_BYTES = [
+    SGPT_RECORD_SYNC & 0xff,
+    (SGPT_RECORD_SYNC >>> 8) & 0xff,
+    (SGPT_RECORD_SYNC >>> 16) & 0xff,
+    (SGPT_RECORD_SYNC >>> 24) & 0xff
+];
+
+/**
+ * Whether a well-formed, checksum-clean record starts at `offset`.
+ *
+ * All four conditions are checked together on purpose. The sync marker alone is a four-byte
+ * coincidence away from a false positive — a `SREC` in a pass label would do it — and accepting one
+ * mid-scan would resynchronise onto garbage and desynchronise everything after. The length has to
+ * fit and the payload has to checksum before a candidate counts.
+ *
+ * @param {Uint8Array} bytes
+ * @param {DataView} view over the same bytes, hoisted because the resync scan calls this per byte
+ * @param {number} offset
+ * @param {number} end
+ * @returns {SGPTRecordRef|null}
+ */
+function try_read_record_at(bytes, view, offset, end) {
+    if (offset + SGPT_RECORD_HEADER_SIZE > end) {
+        return null;
+    }
+
+    for (let i = 0; i < 4; i++) {
+        if (bytes[offset + i] !== SYNC_BYTES[i]) {
+            return null;
+        }
+    }
+
+    const type = view.getUint32(offset + 4, true);
+    const payload_byte_length = view.getUint32(offset + 8, true);
+    const stored_checksum = view.getUint32(offset + 12, true);
+
+    const payload_offset = offset + SGPT_RECORD_HEADER_SIZE;
+
+    if (payload_offset + payload_byte_length > end) {
+        return null;
+    }
+
+    if (crc32(bytes, payload_offset, payload_byte_length) !== stored_checksum) {
+        return null;
+    }
+
+    return new SGPTRecordRef(type, offset, payload_offset, payload_byte_length);
+}
+
+/**
+ * Walk the record stream, resynchronising past anything that is not a record.
+ *
+ * The stream is designed to be read this way rather than through the directory, and the directory
+ * is an index over the result rather than a prerequisite for it. A capture that ended when the tab
+ * did has no directory at all, and it is exactly the capture worth reading.
+ *
+ * Two recoverable outcomes are reported and kept going:
+ *
+ * - **Resync.** Bytes that are not a record are skipped and a {@link SGPT_DEFECT.RESYNC} names how
+ *   many. Everything after the damage is still decoded.
+ * - **Truncation.** The stream ends inside a record. A {@link SGPT_DEFECT.TRUNCATED} says so, and
+ *   the records before it stand. This is the ordinary end state of an interrupted session, not a
+ *   sign that anything went wrong with the writing.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} end offset one past the last readable byte
+ * @param {SGPTDefect[]} defects appended to
+ * @returns {SGPTRecordRef[]} in stream order
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_read_records(buffer, end, defects) {
+    assert.defined(buffer, 'buffer');
+    assert.isNonNegativeInteger(end, 'end');
+    assert.isArray(defects, 'defects');
+
+    const bytes = buffer.raw_bytes;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+    const result = [];
+
+    let offset = SGPT_HEADER_SIZE;
+
+    while (offset < end) {
+
+        const record = try_read_record_at(bytes, view, offset, end);
+
+        if (record !== null) {
+            result.push(record);
+
+            offset = record.payload_offset + record.payload_byte_length;
+
+            continue;
+        }
+
+        // Nothing valid here. Scan for somewhere that is.
+        const damaged_from = offset;
+
+        let scan = offset + 1;
+        let recovered = null;
+
+        while (scan < end) {
+            recovered = try_read_record_at(bytes, view, scan, end);
+
+            if (recovered !== null) {
+                break;
+            }
+
+            scan++;
+        }
+
+        if (recovered === null) {
+            // Ran out without finding another record. Everything from here on is either a partial
+            // final record or trailing damage; either way there is nothing more to decode.
+            defects.push(new SGPTDefect(
+                SGPT_DEFECT.TRUNCATED,
+                `stream ends inside a record; ${end - damaged_from} unreadable bytes at the tail`,
+                damaged_from
+            ));
+
+            break;
+        }
+
+        defects.push(new SGPTDefect(
+            SGPT_DEFECT.RESYNC,
+            `skipped ${scan - damaged_from} bytes that are not a record`,
+            damaged_from
+        ));
+
+        result.push(recovered);
+
+        offset = recovered.payload_offset + recovered.payload_byte_length;
+    }
+
+    return result;
+}

package/src/shade/device/timing/profile/sgpt_topology_codec.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Encode a `TOPO` payload.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {GPUProfileTopology} topology
+ * @param {function(string): number} intern
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_topology(buffer: BinaryBuffer, topology: GPUProfileTopology, intern: (arg0: string) => number): void;
+/**
+ * Every string a topology will need interned, in the order {@link sgpt_write_topology} asks for
+ * them.
+ *
+ * Exists because symbols must be flushed into a `SYMS` record *before* the record referencing them
+ * — interning from inside the payload writer puts them in the next flush, behind the record that
+ * needs them, and a capture truncated in between resolves none of them.
+ *
+ * @param {GPUProfileTopology} topology
+ * @param {function(string): number} intern
+ * @returns {void}
+ */
+export function sgpt_intern_topology_symbols(topology: GPUProfileTopology, intern: (arg0: string) => number): void;
+/**
+ * Decode a `TOPO` payload.
+ *
+ * @param {BinaryBuffer} buffer positioned at the payload
+ * @param {string[]} symbols
+ * @returns {GPUProfileTopology}
+ */
+export function sgpt_read_topology(buffer: BinaryBuffer, symbols: string[]): GPUProfileTopology;
+/**
+ * A content hash of everything that makes one topology different from another.
+ *
+ * This is what deduplication turns on. A Shade frame graph is nearly identical frame to frame, so
+ * the steady state hashes to one value for hundreds of frames and the structure is stored once —
+ * the difference between a capture of tens of megabytes and one of a couple.
+ *
+ * **Cull state is part of the hash.** A frame where a different set of passes was culled genuinely
+ * is a different shape, and folding the two together would report passes as having run in frames
+ * where they did not.
+ *
+ * FNV-1a over a canonical string. Not cryptographic and does not need to be: a collision costs a
+ * mislabelled structure in a debug tool, and the inputs are pass names and integers rather than
+ * anything adversarial.
+ *
+ * @param {GPUProfileTopology} topology
+ * @returns {number} unsigned 32-bit
+ */
+export function sgpt_topology_hash(topology: GPUProfileTopology): number;
+import { GPUProfileTopology } from "./GPUProfileTopology.js";
+//# sourceMappingURL=sgpt_topology_codec.d.ts.map

package/src/shade/device/timing/profile/sgpt_topology_codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_topology_codec.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_topology_codec.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;GAUG;AACH,oEAPW,kBAAkB,iBACT,MAAM,KAAG,MAAM,GACtB,IAAI,CAiFhB;AAED;;;;;;;;;;;GAWG;AACH,uDAJW,kBAAkB,iBACT,MAAM,KAAG,MAAM,GACtB,IAAI,CAqBhB;AAED;;;;;;GAMG;AACH,kEAHW,MAAM,EAAE,GACN,kBAAkB,CA2F9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,6CAHW,kBAAkB,GAChB,MAAM,CA+BlB;mCAjUM,yBAAyB"}

package/src/shade/device/timing/profile/sgpt_topology_codec.js

@@ -0,0 +1,329 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    GPUProfilePass,
+    GPUProfileResource,
+    GPUProfileResourceKind,
+    GPUProfileScope,
+    GPUProfileTopology
+} from "./GPUProfileTopology.js";
+
+const FLAG_CULLED = 1 << 0;
+const FLAG_SIDE_EFFECTS = 1 << 1;
+const FLAG_TRANSIENT = 1 << 2;
+const FLAG_IMPORTED = 1 << 3;
+
+/**
+ * `-1` means "none" throughout the topology — no scope, no producer. Shifting by one lets those
+ * ride in a `uintVar`, which has no negative encoding.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} value
+ */
+function write_optional(buffer, value) {
+    buffer.writeUintVar(value + 1);
+}
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @returns {number}
+ */
+function read_optional(buffer) {
+    return buffer.readUintVar() - 1;
+}
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @param {number[]} ids
+ */
+function write_ids(buffer, ids) {
+    buffer.writeUintVar(ids.length);
+
+    for (const id of ids) {
+        buffer.writeUintVar(id);
+    }
+}
+
+/**
+ * @param {BinaryBuffer} buffer
+ * @returns {number[]}
+ */
+function read_ids(buffer) {
+    const count = buffer.readUintVar();
+
+    const ids = [];
+
+    for (let i = 0; i < count; i++) {
+        ids.push(buffer.readUintVar());
+    }
+
+    return ids;
+}
+
+/**
+ * Encode a `TOPO` payload.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {GPUProfileTopology} topology
+ * @param {function(string): number} intern
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_topology(buffer, topology, intern) {
+    assert.defined(buffer, 'buffer');
+    assert.defined(topology, 'topology');
+    assert.isFunction(intern, 'intern');
+
+    buffer.writeUintVar(topology.id);
+    buffer.writeUintVar(intern(topology.name));
+
+    buffer.writeUintVar(topology.scopes.length);
+
+    for (const scope of topology.scopes) {
+        buffer.writeUintVar(intern(scope.name));
+        write_optional(buffer, scope.parent);
+    }
+
+    buffer.writeUintVar(topology.passes.length);
+
+    for (const pass of topology.passes) {
+        buffer.writeUintVar(pass.id);
+        buffer.writeUintVar(intern(pass.name));
+        write_optional(buffer, pass.scope);
+
+        let flags = 0;
+
+        if (pass.culled) {
+            flags |= FLAG_CULLED;
+        }
+
+        if (pass.has_side_effects) {
+            flags |= FLAG_SIDE_EFFECTS;
+        }
+
+        buffer.writeUint8(flags);
+        buffer.writeUintVar(pass.ref_count);
+
+        write_ids(buffer, pass.reads);
+        write_ids(buffer, pass.writes);
+        write_ids(buffer, pass.creates);
+    }
+
+    buffer.writeUintVar(topology.resources.length);
+
+    for (const resource of topology.resources) {
+        buffer.writeUintVar(resource.id);
+        buffer.writeUintVar(intern(resource.name));
+        buffer.writeUintVar(resource.version);
+
+        let flags = 0;
+
+        if (resource.transient) {
+            flags |= FLAG_TRANSIENT;
+        }
+
+        if (resource.imported) {
+            flags |= FLAG_IMPORTED;
+        }
+
+        buffer.writeUint8(flags);
+        write_optional(buffer, resource.producer);
+
+        buffer.writeUint8(resource.kind);
+        buffer.writeUintVar(resource.usage);
+        buffer.writeUintVar(resource.byte_size);
+
+        if (resource.kind === GPUProfileResourceKind.BUFFER) {
+            buffer.writeUintVar(resource.size);
+        } else if (resource.kind === GPUProfileResourceKind.TEXTURE) {
+            buffer.writeUintVar(resource.resolution[0]);
+            buffer.writeUintVar(resource.resolution[1]);
+            buffer.writeUintVar(resource.resolution[2]);
+            buffer.writeUintVar(resource.mip_level_count);
+            buffer.writeUintVar(resource.sample_count);
+            buffer.writeUintVar(intern(resource.format));
+            buffer.writeUintVar(intern(resource.dimension));
+        }
+    }
+}
+
+/**
+ * Every string a topology will need interned, in the order {@link sgpt_write_topology} asks for
+ * them.
+ *
+ * Exists because symbols must be flushed into a `SYMS` record *before* the record referencing them
+ * — interning from inside the payload writer puts them in the next flush, behind the record that
+ * needs them, and a capture truncated in between resolves none of them.
+ *
+ * @param {GPUProfileTopology} topology
+ * @param {function(string): number} intern
+ * @returns {void}
+ */
+export function sgpt_intern_topology_symbols(topology, intern) {
+    intern(topology.name);
+
+    for (const scope of topology.scopes) {
+        intern(scope.name);
+    }
+
+    for (const pass of topology.passes) {
+        intern(pass.name);
+    }
+
+    for (const resource of topology.resources) {
+        intern(resource.name);
+
+        if (resource.kind === GPUProfileResourceKind.TEXTURE) {
+            intern(resource.format);
+            intern(resource.dimension);
+        }
+    }
+}
+
+/**
+ * Decode a `TOPO` payload.
+ *
+ * @param {BinaryBuffer} buffer positioned at the payload
+ * @param {string[]} symbols
+ * @returns {GPUProfileTopology}
+ */
+export function sgpt_read_topology(buffer, symbols) {
+    assert.defined(buffer, 'buffer');
+    assert.isArray(symbols, 'symbols');
+
+    /**
+     * @param {number} index
+     * @returns {string}
+     */
+    const resolve = (index) => symbols[index] !== undefined
+        ? symbols[index]
+        : `<unresolved symbol ${index}>`;
+
+    const topology = new GPUProfileTopology();
+
+    topology.id = buffer.readUintVar();
+    topology.name = resolve(buffer.readUintVar());
+
+    const scope_count = buffer.readUintVar();
+
+    for (let i = 0; i < scope_count; i++) {
+        const scope = new GPUProfileScope();
+
+        scope.name = resolve(buffer.readUintVar());
+        scope.parent = read_optional(buffer);
+
+        topology.scopes.push(scope);
+    }
+
+    const pass_count = buffer.readUintVar();
+
+    for (let i = 0; i < pass_count; i++) {
+        const pass = new GPUProfilePass();
+
+        pass.id = buffer.readUintVar();
+        pass.name = resolve(buffer.readUintVar());
+        pass.scope = read_optional(buffer);
+
+        const flags = buffer.readUint8();
+
+        pass.culled = (flags & FLAG_CULLED) !== 0;
+        pass.has_side_effects = (flags & FLAG_SIDE_EFFECTS) !== 0;
+
+        pass.ref_count = buffer.readUintVar();
+
+        pass.reads = read_ids(buffer);
+        pass.writes = read_ids(buffer);
+        pass.creates = read_ids(buffer);
+
+        topology.passes.push(pass);
+    }
+
+    const resource_count = buffer.readUintVar();
+
+    for (let i = 0; i < resource_count; i++) {
+        const resource = new GPUProfileResource();
+
+        resource.id = buffer.readUintVar();
+        resource.name = resolve(buffer.readUintVar());
+        resource.version = buffer.readUintVar();
+
+        const flags = buffer.readUint8();
+
+        resource.transient = (flags & FLAG_TRANSIENT) !== 0;
+        resource.imported = (flags & FLAG_IMPORTED) !== 0;
+
+        resource.producer = read_optional(buffer);
+
+        resource.kind = buffer.readUint8();
+        resource.usage = buffer.readUintVar();
+        resource.byte_size = buffer.readUintVar();
+
+        if (resource.kind === GPUProfileResourceKind.BUFFER) {
+            resource.size = buffer.readUintVar();
+        } else if (resource.kind === GPUProfileResourceKind.TEXTURE) {
+            resource.resolution = [
+                buffer.readUintVar(),
+                buffer.readUintVar(),
+                buffer.readUintVar()
+            ];
+            resource.mip_level_count = buffer.readUintVar();
+            resource.sample_count = buffer.readUintVar();
+            resource.format = resolve(buffer.readUintVar());
+            resource.dimension = resolve(buffer.readUintVar());
+        }
+
+        topology.resources.push(resource);
+    }
+
+    return topology;
+}
+
+/**
+ * A content hash of everything that makes one topology different from another.
+ *
+ * This is what deduplication turns on. A Shade frame graph is nearly identical frame to frame, so
+ * the steady state hashes to one value for hundreds of frames and the structure is stored once —
+ * the difference between a capture of tens of megabytes and one of a couple.
+ *
+ * **Cull state is part of the hash.** A frame where a different set of passes was culled genuinely
+ * is a different shape, and folding the two together would report passes as having run in frames
+ * where they did not.
+ *
+ * FNV-1a over a canonical string. Not cryptographic and does not need to be: a collision costs a
+ * mislabelled structure in a debug tool, and the inputs are pass names and integers rather than
+ * anything adversarial.
+ *
+ * @param {GPUProfileTopology} topology
+ * @returns {number} unsigned 32-bit
+ */
+export function sgpt_topology_hash(topology) {
+    let hash = 2166136261;
+
+    /**
+     * @param {string} text
+     */
+    function feed(text) {
+        for (let i = 0; i < text.length; i++) {
+            hash ^= text.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+    }
+
+    feed(topology.name);
+
+    for (const scope of topology.scopes) {
+        feed(`S${scope.name}|${scope.parent}`);
+    }
+
+    for (const pass of topology.passes) {
+        feed(`P${pass.id}|${pass.name}|${pass.scope}|${pass.culled ? 1 : 0}|${pass.has_side_effects ? 1 : 0}`);
+        feed(`r${pass.reads.join(',')}w${pass.writes.join(',')}c${pass.creates.join(',')}`);
+    }
+
+    for (const resource of topology.resources) {
+        feed(`R${resource.id}|${resource.name}|${resource.version}|${resource.kind}|${resource.byte_size}|${resource.usage}|${resource.producer}`);
+    }
+
+    return hash >>> 0;
+}

package/src/shade/device/timing/profile/sgpt_write_header.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Write the fixed 32-byte header at the front of an `.sgpt` stream.
+ *
+ * Called once, when the session opens, with the directory fields left at zero — they are not known
+ * until the session stops, and a capture that never stops keeps them at zero permanently. That is a
+ * supported end state, not a damaged file: see {@link SGPT_HEADER_OFFSET.DIRECTORY_OFFSET}.
+ *
+ * The checksum covers bytes `[0, 12)` only, deliberately stopping short of the fields that get
+ * patched afterwards. A checksum over the whole header would have to be recomputed at stop, which
+ * means a capture cut short would carry one that fails — turning the recoverable case into an
+ * apparently corrupt file.
+ *
+ * Leaves `position` at {@link SGPT_HEADER_SIZE}, where the first record goes.
+ *
+ * @param {BinaryBuffer} buffer positioned at 0
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_header(buffer: BinaryBuffer): void;
+//# sourceMappingURL=sgpt_write_header.d.ts.map

package/src/shade/device/timing/profile/sgpt_write_header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_write_header.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_write_header.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yDALa,IAAI,CAsBhB"}

package/src/shade/device/timing/profile/sgpt_write_header.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+import { crc32 } from "../../../../core/binary/hash/crc32.js";
+import { SGPT_FORMAT_VERSION } from "./SGPT_FORMAT_VERSION.js";
+import { SGPT_HEADER_CHECKSUM_COVERAGE } from "./SGPT_HEADER_CHECKSUM_COVERAGE.js";
+import { SGPT_HEADER_OFFSET } from "./SGPT_HEADER_OFFSET.js";
+import { SGPT_HEADER_SIZE } from "./SGPT_HEADER_SIZE.js";
+import { SGPT_MAGIC } from "./SGPT_MAGIC.js";
+import { SGPT_MIN_READER_VERSION } from "./SGPT_MIN_READER_VERSION.js";
+
+/**
+ * Write the fixed 32-byte header at the front of an `.sgpt` stream.
+ *
+ * Called once, when the session opens, with the directory fields left at zero — they are not known
+ * until the session stops, and a capture that never stops keeps them at zero permanently. That is a
+ * supported end state, not a damaged file: see {@link SGPT_HEADER_OFFSET.DIRECTORY_OFFSET}.
+ *
+ * The checksum covers bytes `[0, 12)` only, deliberately stopping short of the fields that get
+ * patched afterwards. A checksum over the whole header would have to be recomputed at stop, which
+ * means a capture cut short would carry one that fails — turning the recoverable case into an
+ * apparently corrupt file.
+ *
+ * Leaves `position` at {@link SGPT_HEADER_SIZE}, where the first record goes.
+ *
+ * @param {BinaryBuffer} buffer positioned at 0
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_header(buffer) {
+    assert.defined(buffer, 'buffer');
+    assert.equal(buffer.position, 0, 'header must be written at offset 0');
+
+    buffer.writeUint32(SGPT_MAGIC);
+    buffer.writeUint16(SGPT_FORMAT_VERSION);
+    buffer.writeUint16(SGPT_MIN_READER_VERSION);
+    buffer.writeUint32(0); // flags; CLOSED is set at stop
+
+    const checksum = crc32(buffer.raw_bytes, 0, SGPT_HEADER_CHECKSUM_COVERAGE);
+
+    buffer.writeUint32(checksum);
+
+    buffer.writeUint64(0n); // directory_offset, patched at stop
+    buffer.writeUint64(0n); // directory_byte_length, patched at stop
+
+    assert.equal(buffer.position, SGPT_HEADER_SIZE, 'header size mismatch');
+}

package/src/shade/device/timing/profile/sgpt_write_record.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Append one framed record, encoding its payload through `write_payload`.
+ *
+ * The payload is written first, into the same buffer, and the framing is filled in behind it once
+ * its length and checksum are known. That ordering is what keeps a record a single pass: the
+ * alternative — encode to a scratch buffer, measure, copy — costs an allocation and a copy per
+ * frame, every frame, for nothing.
+ *
+ * A record is complete or it is absent. If `write_payload` throws, `position` is restored to where
+ * the record would have begun, so a failed encode leaves no half-record for a reader to trip over.
+ *
+ * @template T
+ * @param {BinaryBuffer} buffer positioned where the record should start
+ * @param {number} type one of {@link SGPT_RECORD_TYPE}
+ * @param {T} data handed to `write_payload`
+ * @param {function(BinaryBuffer, T): void} write_payload
+ * @returns {number} bytes written, framing included
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_record<T>(buffer: BinaryBuffer, type: number, data: T, write_payload: (arg0: BinaryBuffer, arg1: T) => void): number;
+//# sourceMappingURL=sgpt_write_record.d.ts.map

package/src/shade/device/timing/profile/sgpt_write_record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_write_record.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_write_record.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iEARW,MAAM,2DAEqB,IAAI,GAC7B,MAAM,CAwClB"}