@woosh/meep-engine 3.9.0 → 3.11.0

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

@@ -0,0 +1,172 @@
+import { assert } from "../../../../core/assert.js";
+import { GPUProfileFrame } from "./GPUProfileFrame.js";
+import { GPUProfileSpan } from "./GPUProfileSpan.js";
+import { GPUProfileWork } from "./GPUProfileWork.js";
+import { gpu_profile_span_kind_from_name, gpu_profile_span_kind_name } from "./GPUProfileSpanKind.js";
+
+/**
+ * Largest span offset representable in the u32 the payload uses.
+ * @type {number}
+ */
+const MAX_BEGIN_OFFSET = 0xffffffff;
+
+/**
+ * Encode one frame's `FRAM` payload.
+ *
+ * Timestamps are stored relative to the frame's own epoch rather than absolutely, which is what
+ * turns two 8-byte values per span into a u32 and a varint. A u32 of nanoseconds holds 4.29
+ * seconds, three orders of magnitude past any frame, and it survives a stall rather than wrapping.
+ *
+ * Two things a device can report that the format will not carry, both clamped and both counted
+ * rather than thrown on — a capture that refuses to record because one span came back strange is
+ * worth less than one that records it and says so:
+ *
+ * - **An end before its begin.** Stored as a zero duration.
+ * Work — dispatch and draw counts — rides behind a one-byte presence flag per span rather than a
+ * per-frame one, because a frame can mix instrumented and uninstrumented passes: a pass opened
+ * before the recorder was attached has none, and a flag per frame would have to lie about one of
+ * them.
+ *
+ * - **A begin more than 4.29 s after the frame epoch.** Only reachable if spans from different
+ *   query sets turn out not to share a clock, which is unspecified in WebGPU and true in practice.
+ *   Clamped to the maximum, which will look obviously wrong in the inspector rather than subtly so.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {GPUProfileFrame} frame
+ * @param {function(string): number} intern
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_frame(buffer, frame, intern) {
+    assert.defined(buffer, 'buffer');
+    assert.defined(frame, 'frame');
+    assert.isFunction(intern, 'intern');
+
+    const spans = frame.spans;
+
+    buffer.writeUintVar(frame.frame_index);
+    buffer.writeFloat64(frame.cpu_begin_ms);
+    buffer.writeFloat64(frame.cpu_submit_ms);
+    buffer.writeUint64(frame.gpu_epoch_ns);
+    buffer.writeUintVar(frame.dropped_pass_count);
+    buffer.writeUintVar(spans.length);
+
+    for (const span of spans) {
+        buffer.writeUintVar(intern(span.label));
+        buffer.writeUint8(gpu_profile_span_kind_from_name(span.kind));
+        buffer.writeUint8(span.query_set_id);
+
+        const begin = span.t_begin_ns;
+
+        buffer.writeUint32(begin < 0 ? 0 : (begin > MAX_BEGIN_OFFSET ? MAX_BEGIN_OFFSET : begin));
+
+        buffer.writeUintVar(span.duration_ns < 0 ? 0 : span.duration_ns);
+
+        buffer.writeUintVar(span.graph_pass_id + 1); // -1 (none) becomes 0, so it fits a uintVar
+
+        const work = span.work;
+
+        if (work === null || work === undefined) {
+            buffer.writeUint8(0);
+        } else {
+            buffer.writeUint8(1);
+
+            buffer.writeUintVar(work.dispatch_count);
+            buffer.writeUintVar(work.indirect_dispatch_count);
+            buffer.writeUintVar(work.workgroups[0]);
+            buffer.writeUintVar(work.workgroups[1]);
+            buffer.writeUintVar(work.workgroups[2]);
+            buffer.writeUintVar(work.draw_count);
+            buffer.writeUintVar(work.indirect_draw_count);
+            buffer.writeUintVar(work.vertex_count);
+            buffer.writeUintVar(work.index_count);
+            buffer.writeUintVar(work.instance_count);
+            buffer.writeUintVar(intern(work.pipeline));
+            buffer.writeUintVar(work.workgroup_size[0]);
+            buffer.writeUintVar(work.workgroup_size[1]);
+            buffer.writeUintVar(work.workgroup_size[2]);
+        }
+    }
+
+    /*
+     Appended after the span loop rather than beside `frame_index`, so that a reader written
+     against format 1 — which stops once it has read `span_count` spans — decodes everything it
+     knows about and simply never sees this. That is why `min_reader_version` did not have to move
+     when the topology link was added.
+    */
+    buffer.writeUintVar(frame.topology_id + 1);
+}
+
+/**
+ * Decode one frame's `FRAM` payload.
+ *
+ * @param {BinaryBuffer} buffer positioned at the payload
+ * @param {string[]} symbols resolved so far
+ * @param {number} end offset one past this payload, so an older capture without the trailing
+ * topology reference is read as having none rather than running into the next record
+ * @returns {GPUProfileFrame}
+ */
+export function sgpt_read_frame(buffer, symbols, end) {
+    assert.defined(buffer, 'buffer');
+    assert.isArray(symbols, 'symbols');
+    assert.isNonNegativeInteger(end, 'end');
+
+    const frame = new GPUProfileFrame();
+
+    frame.frame_index = buffer.readUintVar();
+    frame.cpu_begin_ms = buffer.readFloat64();
+    frame.cpu_submit_ms = buffer.readFloat64();
+    frame.gpu_epoch_ns = buffer.readUint64();
+    frame.dropped_pass_count = buffer.readUintVar();
+
+    const span_count = buffer.readUintVar();
+
+    const spans = frame.spans;
+
+    for (let i = 0; i < span_count; i++) {
+        const span = new GPUProfileSpan();
+
+        const label_ref = buffer.readUintVar();
+
+        // A symbol block always precedes the record referencing it, so an unresolved index means
+        // the capture is damaged rather than merely incomplete. Naming it beats a blank label.
+        span.label = symbols[label_ref] !== undefined
+            ? symbols[label_ref]
+            : `<unresolved symbol ${label_ref}>`;
+
+        span.kind = gpu_profile_span_kind_name(buffer.readUint8());
+        span.query_set_id = buffer.readUint8();
+        span.t_begin_ns = buffer.readUint32();
+        span.duration_ns = buffer.readUintVar();
+        span.graph_pass_id = buffer.readUintVar() - 1;
+
+        if (buffer.readUint8() === 1) {
+            const work = new GPUProfileWork();
+
+            work.dispatch_count = buffer.readUintVar();
+            work.indirect_dispatch_count = buffer.readUintVar();
+            work.workgroups = [buffer.readUintVar(), buffer.readUintVar(), buffer.readUintVar()];
+            work.draw_count = buffer.readUintVar();
+            work.indirect_draw_count = buffer.readUintVar();
+            work.vertex_count = buffer.readUintVar();
+            work.index_count = buffer.readUintVar();
+            work.instance_count = buffer.readUintVar();
+
+            const pipeline_ref = buffer.readUintVar();
+
+            work.pipeline = symbols[pipeline_ref] ?? "";
+            work.workgroup_size = [buffer.readUintVar(), buffer.readUintVar(), buffer.readUintVar()];
+
+            span.work = work;
+        }
+
+        spans.push(span);
+    }
+
+    // Absent in a format-1 capture, which simply has no topology to point at.
+    frame.topology_id = buffer.position < end ? buffer.readUintVar() - 1 : -1;
+
+    return frame;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Encode the `META` payload.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {GPUProfileMeta} meta
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_meta(buffer: BinaryBuffer, meta: GPUProfileMeta): void;
+/**
+ * Decode the `META` payload.
+ *
+ * @param {BinaryBuffer} buffer positioned at the payload
+ * @returns {GPUProfileMeta}
+ */
+export function sgpt_read_meta(buffer: BinaryBuffer): GPUProfileMeta;
+import { GPUProfileMeta } from "./GPUProfileMeta.js";
+//# sourceMappingURL=sgpt_meta_codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_meta_codec.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_meta_codec.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,4DANW,cAAc,GACZ,IAAI,CAyBhB;AAED;;;;;GAKG;AACH,sDAFa,cAAc,CAyB1B;+BA/D8B,qBAAqB"}

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

@@ -0,0 +1,65 @@
+import { assert } from "../../../../core/assert.js";
+import { GPUProfileMeta } from "./GPUProfileMeta.js";
+
+/**
+ * Encode the `META` payload.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {GPUProfileMeta} meta
+ * @returns {void}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_write_meta(buffer, meta) {
+    assert.defined(buffer, 'buffer');
+    assert.defined(meta, 'meta');
+
+    buffer.writeUint8(meta.level);
+    buffer.writeFloat64(meta.wall_clock_start_ms);
+
+    buffer.writeUTF8String(meta.note);
+    buffer.writeUTF8String(meta.engine_version);
+
+    buffer.writeUTF8String(meta.adapter_vendor);
+    buffer.writeUTF8String(meta.adapter_architecture);
+    buffer.writeUTF8String(meta.adapter_device);
+    buffer.writeUTF8String(meta.adapter_description);
+
+    buffer.writeUintVar(meta.features.length);
+
+    for (const feature of meta.features) {
+        buffer.writeUTF8String(feature);
+    }
+}
+
+/**
+ * Decode the `META` payload.
+ *
+ * @param {BinaryBuffer} buffer positioned at the payload
+ * @returns {GPUProfileMeta}
+ */
+export function sgpt_read_meta(buffer) {
+    assert.defined(buffer, 'buffer');
+
+    const meta = new GPUProfileMeta();
+
+    meta.level = buffer.readUint8();
+    meta.wall_clock_start_ms = buffer.readFloat64();
+
+    meta.note = buffer.readUTF8String();
+    meta.engine_version = buffer.readUTF8String();
+
+    meta.adapter_vendor = buffer.readUTF8String();
+    meta.adapter_architecture = buffer.readUTF8String();
+    meta.adapter_device = buffer.readUTF8String();
+    meta.adapter_description = buffer.readUTF8String();
+
+    const feature_count = buffer.readUintVar();
+
+    for (let i = 0; i < feature_count; i++) {
+        meta.features.push(buffer.readUTF8String());
+    }
+
+    return meta;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Decode a whole `.sgpt` capture.
+ *
+ * Reads by **scanning records**, not by consulting the directory. The directory is an index over
+ * the stream rather than a prerequisite for reading it, and a capture that ended when the tab did
+ * has none at all — which is exactly the capture somebody most wants to open.
+ *
+ * Nothing here throws on damage. A capture comes back whole, with whatever could be decoded and a
+ * list of what could not.
+ *
+ * @param {ArrayBuffer} bytes
+ * @returns {GPUProfileCapture}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_read_capture(bytes: ArrayBuffer): GPUProfileCapture;
+import { GPUProfileCapture } from "./GPUProfileCapture.js";
+//# sourceMappingURL=sgpt_read_capture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_read_capture.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_read_capture.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;GAeG;AACH,yCANW,WAAW,GACT,iBAAiB,CA8G7B;kCAnIiC,wBAAwB"}

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

@@ -0,0 +1,134 @@
+import { assert } from "../../../../core/assert.js";
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { GPUProfileCapture } from "./GPUProfileCapture.js";
+import { SGPT_DEFECT } from "./SGPT_DEFECT.js";
+import { SGPTDefect } from "./SGPTDefect.js";
+import { sgpt_read_frame } from "./sgpt_frame_codec.js";
+import { sgpt_read_header } from "./sgpt_read_header.js";
+import { sgpt_read_meta } from "./sgpt_meta_codec.js";
+import { sgpt_read_records } from "./sgpt_read_records.js";
+import { sgpt_read_topology } from "./sgpt_topology_codec.js";
+import { SGPT_RECORD_TYPE } from "./SGPT_RECORD_TYPE.js";
+
+/**
+ * Decode a whole `.sgpt` capture.
+ *
+ * Reads by **scanning records**, not by consulting the directory. The directory is an index over
+ * the stream rather than a prerequisite for reading it, and a capture that ended when the tab did
+ * has none at all — which is exactly the capture somebody most wants to open.
+ *
+ * Nothing here throws on damage. A capture comes back whole, with whatever could be decoded and a
+ * list of what could not.
+ *
+ * @param {ArrayBuffer} bytes
+ * @returns {GPUProfileCapture}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_read_capture(bytes) {
+    assert.isInstanceOf(bytes, ArrayBuffer, 'bytes');
+
+    const capture = new GPUProfileCapture();
+
+    const buffer = BinaryBuffer.fromArrayBuffer(bytes);
+
+    const end = bytes.byteLength;
+
+    const header = sgpt_read_header(buffer, capture.defects);
+
+    capture.header = header;
+
+    if (header === null) {
+        return capture;
+    }
+
+    const records = sgpt_read_records(buffer, end, capture.defects);
+
+    /**
+     * Symbol table, accumulated as `SYMS` blocks arrive. Blocks always precede the records that
+     * reference them, so this is complete by the time each reference is resolved.
+     *
+     * @type {string[]}
+     */
+    const symbols = [];
+
+    let seen_meta = false;
+
+    for (const record of records) {
+
+        buffer.position = record.payload_offset;
+
+        try {
+            switch (record.type) {
+
+                case SGPT_RECORD_TYPE.META:
+                    capture.meta = sgpt_read_meta(buffer);
+                    seen_meta = true;
+                    break;
+
+                case SGPT_RECORD_TYPE.SYMS: {
+                    const first_index = buffer.readUintVar();
+                    const count = buffer.readUintVar();
+
+                    for (let i = 0; i < count; i++) {
+                        symbols[first_index + i] = buffer.readUTF8String();
+                    }
+
+                    break;
+                }
+
+                case SGPT_RECORD_TYPE.FRAM:
+                    capture.frames.push(sgpt_read_frame(
+                        buffer,
+                        symbols,
+                        record.payload_offset + record.payload_byte_length
+                    ));
+                    break;
+
+                case SGPT_RECORD_TYPE.TOPO: {
+                    const topology = sgpt_read_topology(buffer, symbols);
+
+                    // Indexed by the id the writer assigned, not by arrival order — a resynchronised
+                    // reader may have skipped one, and shifting the rest up would mis-attribute
+                    // every frame after the damage.
+                    capture.topologies[topology.id] = topology;
+
+                    break;
+                }
+
+                case SGPT_RECORD_TYPE.DIRE:
+                    // Deliberately not read. Everything it indexes has already been walked, and
+                    // trusting it over the records would make a capture without one a lesser
+                    // capture. It exists so a future reader can seek instead of scan.
+                    break;
+
+                default: {
+                    const seen = capture.unknown_record_counts.get(record.type);
+
+                    capture.unknown_record_counts.set(record.type, seen === undefined ? 1 : seen + 1);
+
+                    break;
+                }
+            }
+        } catch (e) {
+            // One record failing to decode costs that record. The framing already told us where
+            // the next one starts, so there is no reason for it to cost anything else.
+            capture.defects.push(new SGPTDefect(
+                SGPT_DEFECT.PAYLOAD,
+                `record type 0x${record.type.toString(16)} failed to decode: ${e.message}`,
+                record.offset
+            ));
+        }
+    }
+
+    if (!seen_meta) {
+        capture.defects.push(new SGPTDefect(
+            SGPT_DEFECT.PAYLOAD,
+            'no META record; adapter, settings and timestamp resolution are unknown for this capture',
+            -1
+        ));
+    }
+
+    return capture;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Decode the head of an `.sgpt` stream.
+ *
+ * Three conditions are fatal and return `null`, because nothing downstream can mean anything
+ * without them: too few bytes to hold a header, the wrong magic, and a `min_reader_version` above
+ * what this build understands. Everything else is reported through `defects` and the header is
+ * still returned — a bad header checksum, in particular, does not stop the records from being
+ * readable by scanning, and refusing on it would throw away recoverable captures.
+ *
+ * Leaves `position` at {@link SGPT_HEADER_SIZE} on success.
+ *
+ * @param {BinaryBuffer} buffer positioned at 0
+ * @param {SGPTDefect[]} defects appended to
+ * @returns {SGPTHeader|null} null when the stream is not readable as `.sgpt` at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_read_header(buffer: BinaryBuffer, defects: SGPTDefect[]): SGPTHeader | null;
+import { SGPTDefect } from "./SGPTDefect.js";
+import { SGPTHeader } from "./SGPTHeader.js";
+//# sourceMappingURL=sgpt_read_header.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_read_header.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_read_header.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,gEANW,UAAU,EAAE,GACV,UAAU,GAAC,IAAI,CAqE3B;2BA1F0B,iBAAiB;2BAMjB,iBAAiB"}

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

@@ -0,0 +1,94 @@
+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_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 { SGPTHeader } from "./SGPTHeader.js";
+
+/**
+ * Decode the head of an `.sgpt` stream.
+ *
+ * Three conditions are fatal and return `null`, because nothing downstream can mean anything
+ * without them: too few bytes to hold a header, the wrong magic, and a `min_reader_version` above
+ * what this build understands. Everything else is reported through `defects` and the header is
+ * still returned — a bad header checksum, in particular, does not stop the records from being
+ * readable by scanning, and refusing on it would throw away recoverable captures.
+ *
+ * Leaves `position` at {@link SGPT_HEADER_SIZE} on success.
+ *
+ * @param {BinaryBuffer} buffer positioned at 0
+ * @param {SGPTDefect[]} defects appended to
+ * @returns {SGPTHeader|null} null when the stream is not readable as `.sgpt` at all
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_read_header(buffer, defects) {
+    assert.defined(buffer, 'buffer');
+    assert.isArray(defects, 'defects');
+
+    const available = buffer.capacity;
+
+    if (available < SGPT_HEADER_SIZE) {
+        defects.push(new SGPTDefect(
+            SGPT_DEFECT.HEADER,
+            `stream is ${available} bytes, a header needs ${SGPT_HEADER_SIZE}`,
+            0
+        ));
+
+        return null;
+    }
+
+    buffer.position = 0;
+
+    const magic = buffer.readUint32();
+
+    if (magic !== SGPT_MAGIC) {
+        defects.push(new SGPTDefect(
+            SGPT_DEFECT.HEADER,
+            `not an .sgpt stream: magic 0x${(magic >>> 0).toString(16)}, expected 0x${SGPT_MAGIC.toString(16)}`,
+            0
+        ));
+
+        return null;
+    }
+
+    const header = new SGPTHeader();
+
+    header.format_version = buffer.readUint16();
+    header.min_reader_version = buffer.readUint16();
+    header.flags = buffer.readUint32();
+
+    const stored_checksum = buffer.readUint32();
+    const actual_checksum = crc32(buffer.raw_bytes, 0, SGPT_HEADER_CHECKSUM_COVERAGE);
+
+    if (stored_checksum !== actual_checksum) {
+        // Not fatal on purpose. The checksum covers the magic and versions only, and nothing the
+        // records need in order to be scannable, so a mismatch means "this file has been damaged
+        // somewhere" rather than "there is nothing here to read".
+        defects.push(new SGPTDefect(
+            SGPT_DEFECT.CHECKSUM,
+            `header checksum 0x${stored_checksum.toString(16)} does not match computed 0x${actual_checksum.toString(16)}`,
+            SGPT_HEADER_OFFSET.HEADER_CHECKSUM
+        ));
+    }
+
+    header.directory_offset = Number(buffer.readUint64());
+    header.directory_byte_length = Number(buffer.readUint64());
+
+    if (header.min_reader_version > SGPT_FORMAT_VERSION) {
+        defects.push(new SGPTDefect(
+            SGPT_DEFECT.HEADER,
+            `capture requires reader version ${header.min_reader_version}, this build is ${SGPT_FORMAT_VERSION}`,
+            SGPT_HEADER_OFFSET.MIN_READER_VERSION
+        ));
+
+        return null;
+    }
+
+    return header;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * 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: BinaryBuffer, end: number, defects: SGPTDefect[]): SGPTRecordRef[];
+import { SGPTDefect } from "./SGPTDefect.js";
+import { SGPTRecordRef } from "./SGPTRecordRef.js";
+//# sourceMappingURL=sgpt_read_records.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_read_records.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_read_records.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6DAPW,MAAM,WACN,UAAU,EAAE,GACV,aAAa,EAAE,CAqE3B;2BArJ0B,iBAAiB;8BAId,oBAAoB"}