@woosh/meep-engine 3.10.0 → 3.11.0

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

@@ -0,0 +1,11 @@
+/**
+ * `'SREC'`, the little-endian u32 that opens every record in the stream.
+ *
+ * A reader that has lost its place — corruption, a torn write, a capture that ended when the tab
+ * did — scans forward for this and resumes. It is not a guarantee on its own: four bytes of payload
+ * can spell `SREC` by accident. It is the cheap filter, and the record's length and checksum are
+ * what actually confirm the find. See {@link sgpt_read_records}.
+ *
+ * @type {number}
+ */
+export const SGPT_RECORD_SYNC = 0x43455253;

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

@@ -0,0 +1,18 @@
+/**
+ * What a record in an `.sgpt` stream carries. Written as a little-endian u32 tag, so a hex dump
+ * reads as the four letters.
+ *
+ * A reader **must** skip a type it does not know, using the record's declared length. That is what
+ * lets a newer recorder add record types without a format version bump, and what lets an older
+ * inspector open the result and be honest about which parts it cannot show.
+ */
+export type SGPT_RECORD_TYPE = number;
+export namespace SGPT_RECORD_TYPE {
+    let META: number;
+    let SYMS: number;
+    let TOPO: number;
+    let FRAM: number;
+    let CNTR: number;
+    let DIRE: number;
+}
+//# sourceMappingURL=SGPT_RECORD_TYPE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SGPT_RECORD_TYPE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/SGPT_RECORD_TYPE.js"],"names":[],"mappings":";;;;;;;;+BAQU,MAAM"}

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

@@ -0,0 +1,46 @@
+/**
+ * What a record in an `.sgpt` stream carries. Written as a little-endian u32 tag, so a hex dump
+ * reads as the four letters.
+ *
+ * A reader **must** skip a type it does not know, using the record's declared length. That is what
+ * lets a newer recorder add record types without a format version bump, and what lets an older
+ * inspector open the result and be honest about which parts it cannot show.
+ *
+ * @enum {number}
+ */
+export const SGPT_RECORD_TYPE = {
+    /**
+     * Session context: adapter, engine version, renderer settings, verbosity level, the calibrated
+     * timestamp period. Written once, immediately after the header.
+     */
+    META: 0x4154454D,
+
+    /**
+     * A block of strings, introduced by the record that first needs them and referenced by index
+     * afterwards. Emitted inline rather than gathered into one table at the tail, so a truncated
+     * capture still resolves every name it references.
+     */
+    SYMS: 0x534D5953,
+
+    /**
+     * One frame graph topology: passes, resource nodes, edges, scopes, descriptors. Content-hashed,
+     * so the steady state emits this once and every subsequent frame refers to it by id.
+     */
+    TOPO: 0x4F504F54,
+
+    /**
+     * One frame: which topology, the CPU clocks around it, and the GPU spans that came back.
+     */
+    FRAM: 0x4D415246,
+
+    /**
+     * Counter samples over the session — GPU memory in use, scene scale, resolution.
+     */
+    CNTR: 0x52544E43,
+
+    /**
+     * The directory, written at {@link GPUProfileSession.stop}. An index, never a dependency: every
+     * record above is readable by scanning, and a capture that never got to stop is still a capture.
+     */
+    DIRE: 0x45524944
+};

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

@@ -0,0 +1,20 @@
+/**
+ * Record the shape of a compiled frame graph.
+ *
+ * **Call after `compile`, and ideally after `execute`.** Reference counts and cull decisions are
+ * what `compile` derives; before it every pass reads as culled, which would be recorded as a frame
+ * in which nothing ran.
+ *
+ * Resources are keyed by **node**, one per version, matching `FrameGraph.exportToJson`. Passes
+ * record the node they touched rather than the underlying resource, so a registry-keyed model would
+ * leave every reference past version 0 pointing at nothing.
+ *
+ * @param {FrameGraph} graph
+ * @returns {GPUProfileTopology}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function frame_graph_extract_topology(graph: FrameGraph): GPUProfileTopology;
+import { GPUProfileTopology } from "./GPUProfileTopology.js";
+//# sourceMappingURL=frame_graph_extract_topology.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame_graph_extract_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/frame_graph_extract_topology.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;GAgBG;AACH,iEALa,kBAAkB,CAkH9B;mCArKM,yBAAyB"}

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

@@ -0,0 +1,174 @@
+import { assert } from "../../../../core/assert.js";
+import { gpu_texture_format_info } from "../../../descriptor/texture/format/gpu_texture_format_info.js";
+import {
+    GPUProfilePass,
+    GPUProfileResource,
+    GPUProfileResourceKind,
+    GPUProfileScope,
+    GPUProfileTopology
+} from "./GPUProfileTopology.js";
+
+/**
+ * Declared bytes for a texture descriptor: the whole mip chain, at the given sample count.
+ *
+ * A format the engine's table does not know reports 0 rather than throwing. A capture is a
+ * diagnostic; refusing to record one because a size could not be worked out would be the wrong
+ * trade every time.
+ *
+ * @param {TextureResourceDescriptor} descriptor
+ * @returns {number}
+ */
+function texture_byte_size(descriptor) {
+    let info;
+
+    try {
+        info = gpu_texture_format_info(descriptor.format);
+    } catch {
+        // `gpu_texture_format_info` throws on a name it does not know. Correct for the renderer,
+        // wrong here: a capture is a diagnostic, and losing the whole recording because one
+        // resource used a format the table has not caught up with is the wrong trade every time.
+        return 0;
+    }
+
+    const { block_width, block_height, bytes_per_block } = info;
+
+    let total = 0;
+
+    for (let mip = 0; mip < descriptor.mipLevelCount; mip++) {
+        const w = Math.max(1, Math.floor(descriptor.resolution[0]) >> mip);
+        const h = Math.max(1, Math.floor(descriptor.resolution[1]) >> mip);
+        const d = Math.max(1, Math.floor(descriptor.resolution[2]) >> mip);
+
+        total += Math.ceil(w / block_width) * Math.ceil(h / block_height) * d * bytes_per_block;
+    }
+
+    return total * descriptor.sampleCount;
+}
+
+/**
+ * Record the shape of a compiled frame graph.
+ *
+ * **Call after `compile`, and ideally after `execute`.** Reference counts and cull decisions are
+ * what `compile` derives; before it every pass reads as culled, which would be recorded as a frame
+ * in which nothing ran.
+ *
+ * Resources are keyed by **node**, one per version, matching `FrameGraph.exportToJson`. Passes
+ * record the node they touched rather than the underlying resource, so a registry-keyed model would
+ * leave every reference past version 0 pointing at nothing.
+ *
+ * @param {FrameGraph} graph
+ * @returns {GPUProfileTopology}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function frame_graph_extract_topology(graph) {
+    assert.defined(graph, 'graph');
+
+    const topology = new GPUProfileTopology();
+
+    topology.name = graph.name;
+
+    /**
+     * Scopes are reached through the nodes that were recorded inside them, and flattened to an
+     * array here. `FrameGraph` keeps them as a parent chain rather than a list, so this walk is
+     * what turns the chain into something a reader can index.
+     *
+     * @type {Map<FrameGraphScope, number>}
+     */
+    const scope_ids = new Map();
+
+    /**
+     * @param {FrameGraphScope|null} scope
+     * @returns {number} index, or -1
+     */
+    function intern_scope(scope) {
+        if (scope === null || scope === undefined) {
+            return -1;
+        }
+
+        const existing = scope_ids.get(scope);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        // parent first, so a parent always has a lower index than its children and a reader can
+        // resolve the chain in one forward pass
+        const parent = intern_scope(scope.parent);
+
+        const record = new GPUProfileScope();
+
+        record.name = scope.name;
+        record.parent = parent;
+
+        const id = topology.scopes.length;
+
+        topology.scopes.push(record);
+        scope_ids.set(scope, id);
+
+        return id;
+    }
+
+    for (const node of graph.__pass_nodes) {
+        const pass = new GPUProfilePass();
+
+        pass.id = node.id;
+        pass.name = node.name;
+        pass.scope = intern_scope(node.scope);
+        pass.culled = !node.can_execute();
+        pass.has_side_effects = node.has_side_effects;
+        pass.ref_count = node.ref_count;
+        pass.reads = node.resource_reads.slice();
+        pass.writes = node.resource_writes.slice();
+        pass.creates = node.resource_creates.slice();
+
+        topology.passes.push(pass);
+    }
+
+    for (const node of graph.__resource_nodes) {
+        const entry = graph.__resource_registry[node.resource_id];
+
+        const resource = new GPUProfileResource();
+
+        resource.id = node.id;
+        resource.name = node.name;
+        resource.version = node.version;
+        resource.producer = node.producer !== null ? node.producer.id : -1;
+
+        if (entry !== undefined) {
+            resource.transient = entry.isTransient();
+            resource.imported = entry.isImported();
+        }
+
+        const descriptor = entry?.resource_descriptor;
+
+        if (descriptor !== undefined && descriptor !== null) {
+            const type = descriptor.type;
+
+            if (type === 'buffer') {
+                resource.kind = GPUProfileResourceKind.BUFFER;
+                resource.size = descriptor.size;
+                resource.usage = descriptor.usage;
+                resource.byte_size = descriptor.size;
+            } else if (type === 'texture') {
+                resource.kind = GPUProfileResourceKind.TEXTURE;
+                resource.resolution = [
+                    Math.floor(descriptor.resolution[0]),
+                    Math.floor(descriptor.resolution[1]),
+                    Math.floor(descriptor.resolution[2])
+                ];
+                resource.mip_level_count = descriptor.mipLevelCount;
+                resource.sample_count = descriptor.sampleCount;
+                resource.format = descriptor.format;
+                resource.dimension = descriptor.dimension;
+                resource.usage = descriptor.usage;
+                resource.byte_size = texture_byte_size(descriptor);
+            }
+        }
+
+        topology.resources.push(resource);
+    }
+
+    return topology;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Wrap a pass encoder so that the work encoded into it is recorded.
+ *
+ * **A `Proxy` rather than a hand-written forwarder.** A pass encoder has around twenty methods and
+ * WebGPU keeps adding them; a forwarding class that misses one does not fail loudly, it silently
+ * drops a call that the renderer needed, and only while profiling — the worst possible shape for a
+ * bug. Everything not named below is forwarded untouched, including anything added later.
+ *
+ * The cost is a `Proxy` on the hot encoding path, which is why this exists only while a capture is
+ * running at {@link GPUProfileLevel.WORKLOAD} or above. Bound methods are cached per encoder so the
+ * `get` trap does not allocate a new closure on every `setBindGroup`.
+ *
+ * @param {GPUComputePassEncoder|GPURenderPassEncoder} encoder
+ * @param {GPUProfileWork} work accumulated into
+ * @returns {GPUComputePassEncoder|GPURenderPassEncoder}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function make_profiling_pass_encoder(encoder: GPUComputePassEncoder | GPURenderPassEncoder, work: GPUProfileWork): GPUComputePassEncoder | GPURenderPassEncoder;
+//# sourceMappingURL=make_profiling_pass_encoder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"make_profiling_pass_encoder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/make_profiling_pass_encoder.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qDAPW,4CAA0C,yBAExC,4CAA0C,CAiGtD"}

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

@@ -0,0 +1,114 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Wrap a pass encoder so that the work encoded into it is recorded.
+ *
+ * **A `Proxy` rather than a hand-written forwarder.** A pass encoder has around twenty methods and
+ * WebGPU keeps adding them; a forwarding class that misses one does not fail loudly, it silently
+ * drops a call that the renderer needed, and only while profiling — the worst possible shape for a
+ * bug. Everything not named below is forwarded untouched, including anything added later.
+ *
+ * The cost is a `Proxy` on the hot encoding path, which is why this exists only while a capture is
+ * running at {@link GPUProfileLevel.WORKLOAD} or above. Bound methods are cached per encoder so the
+ * `get` trap does not allocate a new closure on every `setBindGroup`.
+ *
+ * @param {GPUComputePassEncoder|GPURenderPassEncoder} encoder
+ * @param {GPUProfileWork} work accumulated into
+ * @returns {GPUComputePassEncoder|GPURenderPassEncoder}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function make_profiling_pass_encoder(encoder, work) {
+    assert.defined(encoder, 'encoder');
+    assert.defined(work, 'work');
+
+    /**
+     * @type {Map<string|symbol, function>}
+     */
+    const bound = new Map();
+
+    /**
+     * @param {string} name
+     * @param {function} original
+     * @returns {function}
+     */
+    function wrap(name, original) {
+        switch (name) {
+
+            case 'dispatchWorkgroups':
+                return function (x, y = 1, z = 1) {
+                    work.dispatch_count++;
+                    work.workgroups[0] += x;
+                    work.workgroups[1] += y;
+                    work.workgroups[2] += z;
+
+                    return original.call(encoder, x, y, z);
+                };
+
+            case 'dispatchWorkgroupsIndirect':
+                return function (...args) {
+                    // Size lives in a GPU buffer, so there is nothing to add to `workgroups`.
+                    // Counted apart so the totals are not read as covering this.
+                    work.indirect_dispatch_count++;
+
+                    return original.apply(encoder, args);
+                };
+
+            case 'draw':
+                return function (vertex_count, instance_count = 1, ...rest) {
+                    work.draw_count++;
+                    work.vertex_count += vertex_count;
+                    work.instance_count += instance_count;
+
+                    return original.call(encoder, vertex_count, instance_count, ...rest);
+                };
+
+            case 'drawIndexed':
+                return function (index_count, instance_count = 1, ...rest) {
+                    work.draw_count++;
+                    work.index_count += index_count;
+                    work.instance_count += instance_count;
+
+                    return original.call(encoder, index_count, instance_count, ...rest);
+                };
+
+            case 'drawIndirect':
+            case 'drawIndexedIndirect':
+                return function (...args) {
+                    work.indirect_draw_count++;
+
+                    return original.apply(encoder, args);
+                };
+
+            default:
+                return function (...args) {
+                    return original.apply(encoder, args);
+                };
+        }
+    }
+
+    return new Proxy(encoder, {
+        get(target, property) {
+            const value = Reflect.get(target, property, target);
+
+            if (typeof value !== 'function') {
+                return value;
+            }
+
+            let fn = bound.get(property);
+
+            if (fn === undefined) {
+                fn = wrap(property, value);
+
+                bound.set(property, fn);
+            }
+
+            return fn;
+        },
+
+        set(target, property, value) {
+            return Reflect.set(target, property, value, target);
+        }
+    });
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Read a compute entry point's workgroup size out of its WGSL.
+ *
+ * **Only literal sizes.** WGSL allows `@workgroup_size(WG_X)` against a pipeline-overridable
+ * constant, and resolving that would mean tracking override values through pipeline creation for a
+ * number that is nice to have. Such a shader reports `[0, 0, 0]`, which the model treats as
+ * *unknown* rather than as zero — an invocation count of 0 alongside a real duration would be a
+ * lie, and this is the difference between the two.
+ *
+ * A module with several entry points reports the first size found. Shade compiles one entry point
+ * per compute pipeline, so in practice there is only ever one.
+ *
+ * @param {string} code WGSL source
+ * @returns {number[]} `[x, y, z]`, or `[0, 0, 0]` when it could not be read
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function parse_workgroup_size(code: string): number[];
+//# sourceMappingURL=parse_workgroup_size.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse_workgroup_size.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/parse_workgroup_size.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;GAiBG;AACH,2CANW,MAAM,GACJ,MAAM,EAAE,CAqBpB"}

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

@@ -0,0 +1,43 @@
+/**
+ * `@workgroup_size(...)` with literal integer arguments. Whitespace is permitted anywhere WGSL
+ * permits it; anything that is not a plain decimal literal deliberately fails to match.
+ *
+ * @type {RegExp}
+ */
+const WORKGROUP_SIZE = /@workgroup_size\s*\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?(?:,\s*(\d+)\s*)?\)/;
+
+/**
+ * Read a compute entry point's workgroup size out of its WGSL.
+ *
+ * **Only literal sizes.** WGSL allows `@workgroup_size(WG_X)` against a pipeline-overridable
+ * constant, and resolving that would mean tracking override values through pipeline creation for a
+ * number that is nice to have. Such a shader reports `[0, 0, 0]`, which the model treats as
+ * *unknown* rather than as zero — an invocation count of 0 alongside a real duration would be a
+ * lie, and this is the difference between the two.
+ *
+ * A module with several entry points reports the first size found. Shade compiles one entry point
+ * per compute pipeline, so in practice there is only ever one.
+ *
+ * @param {string} code WGSL source
+ * @returns {number[]} `[x, y, z]`, or `[0, 0, 0]` when it could not be read
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function parse_workgroup_size(code) {
+    if (typeof code !== 'string') {
+        return [0, 0, 0];
+    }
+
+    const match = WORKGROUP_SIZE.exec(code);
+
+    if (match === null) {
+        return [0, 0, 0];
+    }
+
+    return [
+        Number(match[1]),
+        match[2] !== undefined ? Number(match[2]) : 1,
+        match[3] !== undefined ? Number(match[3]) : 1
+    ];
+}

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

@@ -0,0 +1,18 @@
+/**
+ * A four-character tag as the little-endian u32 it occupies on the wire.
+ *
+ * The container writes every tag — the file magic, the record sync marker, each record type — as a
+ * u32, and reads them back the same way, so `'SGPT'` on disk is the bytes `S G P T` in that order.
+ * This is the same convention {@link VGEO_MAGIC} follows.
+ *
+ * Constants are declared as literals rather than calls to this, so nothing is computed at import
+ * time; this exists so `sgpt_fourcc.spec.js` can prove each literal is the tag it claims to be.
+ *
+ * @param {string} tag exactly four characters, each in the ASCII range
+ * @returns {number} unsigned 32-bit
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_fourcc(tag: string): number;
+//# sourceMappingURL=sgpt_fourcc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_fourcc.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_fourcc.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,iCANW,MAAM,GACJ,MAAM,CAoBlB"}

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

@@ -0,0 +1,34 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * A four-character tag as the little-endian u32 it occupies on the wire.
+ *
+ * The container writes every tag — the file magic, the record sync marker, each record type — as a
+ * u32, and reads them back the same way, so `'SGPT'` on disk is the bytes `S G P T` in that order.
+ * This is the same convention {@link VGEO_MAGIC} follows.
+ *
+ * Constants are declared as literals rather than calls to this, so nothing is computed at import
+ * time; this exists so `sgpt_fourcc.spec.js` can prove each literal is the tag it claims to be.
+ *
+ * @param {string} tag exactly four characters, each in the ASCII range
+ * @returns {number} unsigned 32-bit
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sgpt_fourcc(tag) {
+    assert.isString(tag, 'tag');
+    assert.equal(tag.length, 4, 'tag must be exactly 4 characters');
+
+    let r = 0;
+
+    for (let i = 0; i < 4; i++) {
+        const code = tag.charCodeAt(i);
+
+        assert.ok(code <= 0x7f, `tag[${i}] must be ASCII, was code ${code}`);
+
+        r |= code << (i * 8);
+    }
+
+    return r >>> 0;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * 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: BinaryBuffer, frame: GPUProfileFrame, intern: (arg0: string) => number): void;
+/**
+ * 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: BinaryBuffer, symbols: string[], end: number): GPUProfileFrame;
+import { GPUProfileFrame } from "./GPUProfileFrame.js";
+//# sourceMappingURL=sgpt_frame_codec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgpt_frame_codec.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/sgpt_frame_codec.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8DAPW,eAAe,iBACN,MAAM,KAAG,MAAM,GACtB,IAAI,CA+DhB;AAED;;;;;;;;GAQG;AACH,+DALW,MAAM,EAAE,OACR,MAAM,GAEJ,eAAe,CA+D3B;gCA1K+B,sBAAsB"}