@aethervtt/shard-shader 0.0.1 → 0.1.0

package/dist/baseline/fragment-kernel.d.ts

@@ -0,0 +1,15 @@
+/** The uniform an image kernel's fragment form reads its target from: width, height, depth, layer. */
+export declare const FRAGMENT_KERNEL_TARGET = "shard_target";
+export interface FragmentKernel {
+    /** The module's WGSL with the fragment entry point (named as the compute one was). */
+    source: string;
+    /** The storage texture it wrote: its format, and its (group, binding), now the target uniform. */
+    format: string;
+    group: number;
+    binding: number;
+}
+/**
+ * The fragment form of the image kernel `entry` in a module's source. Throws
+ * `shader/fragment-kernel` when the kernel isn't one (no single storage output, stores elsewhere).
+ */
+export declare function fragmentKernel(source: string, entry?: string, label?: string): FragmentKernel;

package/dist/baseline/fragment-kernel.js

@@ -0,0 +1,114 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { attribute, declarations, matching, tokenize } from "./wgsl.js";
+const FRAGMENT_KERNEL_TARGET = "shard_target";
+function fragmentKernel(source, entry = "main", label = "kernel") {
+  const fail = (message) => {
+    throw new ShardError("shader/fragment-kernel", `${label}: ${message}`, {
+      hint: "Only image kernels run as fragment passes: one storage texture, stored at the invocation id."
+    });
+  };
+  const tokens = tokenize(source);
+  const decls = declarations(source, tokens);
+  const outputs = decls.filter(
+    (d) => d.keyword === "var" && d.type.trim().startsWith("texture_storage_")
+  );
+  if (outputs.length !== 1) fail(`needs exactly one storage texture, found ${outputs.length}`);
+  const output = outputs[0];
+  const kind = output.type.trim();
+  const format = kind.slice(kind.indexOf("<") + 1, kind.indexOf(",")).trim();
+  const dims = kind.startsWith("texture_storage_3d") ? "xyz" : "xy";
+  const fn = decls.find((d) => d.keyword === "fn" && d.name === entry);
+  if (!fn?.attributes.some((a) => a.name === "compute")) fail(`no @compute fn ${entry}`);
+  const fnToken = tokens.findIndex((t, k) => k >= fn.first && t.text === "fn");
+  const body = fnBody(tokens, fnToken, fn.last);
+  const id = invocationId(tokens, body.params, body.open);
+  if (!id) fail("its entry point takes no @builtin(global_invocation_id)");
+  const edits = [];
+  const group = attribute(output, "group");
+  const binding = attribute(output, "binding");
+  edits.push({
+    start: output.start,
+    end: output.end,
+    text: `@group(${group}) @binding(${binding}) var<uniform> ${FRAGMENT_KERNEL_TARGET}: vec4u;`
+  });
+  for (let i = 0; i < tokens.length; i++) {
+    if (i >= output.first && i <= output.last) continue;
+    const t = tokens[i];
+    if (t.kind !== "ident" || t.text !== output.name || tokens[i - 1]?.text === ".") continue;
+    const call = tokens[i - 2]?.text;
+    if (tokens[i - 1]?.text !== "(" || call !== "textureDimensions" && call !== "textureStore") {
+      fail(`uses "${output.name}" other than in textureDimensions or textureStore`);
+    }
+    const open = i - 1;
+    const close = matching(tokens, open);
+    if (call === "textureDimensions") {
+      edits.push({
+        start: tokens[i - 2].start,
+        end: tokens[close].end,
+        text: `${FRAGMENT_KERNEL_TARGET}.${dims}`
+      });
+      continue;
+    }
+    if (i < body.open || i > body.close) fail("stores outside its entry point");
+    const commas = topLevelCommas(tokens, open, close);
+    const value = source.slice(tokens[commas[commas.length - 1]].end, tokens[close].start).trim();
+    let end = tokens[close].end;
+    let next = close + 1;
+    if (tokens[next]?.text === ";") end = tokens[next++].end;
+    if (tokens[next]?.text === "return" && tokens[next + 1]?.text === ";")
+      end = tokens[next + 1].end;
+    edits.push({ start: tokens[i - 2].start, end, text: `return ${value};` });
+  }
+  for (let i = body.open; i < body.close; i++) {
+    if (tokens[i].text !== "return" || tokens[i + 1]?.text !== ";") continue;
+    if (edits.some((e) => e.start <= tokens[i].start && tokens[i].end <= e.end)) continue;
+    edits.push({ start: tokens[i].start, end: tokens[i + 1].end, text: "discard;" });
+  }
+  const attrStart = fn.attributes.length > 0 ? tokens[fn.first].start : fn.start;
+  edits.push({
+    start: attrStart,
+    end: tokens[fnToken].start,
+    text: "@fragment "
+  });
+  edits.push({
+    start: tokens[body.params].start,
+    end: tokens[body.open].end,
+    text: `(@builtin(position) shard_position: vec4f) -> @location(0) vec4f {
+  let ${id} = vec3u(vec2u(shard_position.xy), ${FRAGMENT_KERNEL_TARGET}.w);`
+  });
+  edits.sort((a, b) => b.start - a.start);
+  let out = source;
+  for (const e of edits) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  return { source: out, format, group: Number(group), binding: Number(binding) };
+}
+function fnBody(tokens, first, last) {
+  let params = first;
+  while (params <= last && tokens[params].text !== "(") params++;
+  const paramsClose = matching(tokens, params);
+  let open = paramsClose + 1;
+  while (open <= last && tokens[open].text !== "{") open++;
+  return { params, open, close: matching(tokens, open) };
+}
+function invocationId(tokens, first, open) {
+  for (let i = first; i < open; i++) {
+    if (tokens[i].text === "global_invocation_id" && tokens[i - 2]?.text === "builtin") {
+      return tokens[i + 2]?.kind === "ident" ? tokens[i + 2].text : void 0;
+    }
+  }
+  return void 0;
+}
+function topLevelCommas(tokens, open, close) {
+  const out = [];
+  let depth = 0;
+  for (let i = open + 1; i < close; i++) {
+    const t = tokens[i].text;
+    if (t === "(" || t === "[" || t === "{") depth++;
+    else if (t === ")" || t === "]" || t === "}") depth--;
+    else if (t === "," && depth === 0) out.push(i);
+  }
+  return out;
+}
+export {
+  FRAGMENT_KERNEL_TARGET,
+  fragmentKernel
+};

package/dist/baseline/rewrite.d.ts

@@ -0,0 +1,20 @@
+import { type DataDeclaration } from '../data-marks.js';
+import type { SourceLocation } from '../library.js';
+/** What a binding becomes on baseline, for the engine's bind group layouts. */
+export interface RetargetedBinding {
+    group: number;
+    binding: number;
+    name: string;
+    as: 'data-texture' | 'uniform' | 'unfilterable-float';
+}
+export interface BaselineRewrite {
+    code: string;
+    bindings: RetargetedBinding[];
+    /** The offset in the linked code a rewritten offset came from (for compile errors). */
+    toLinked(offset: number): number;
+}
+/**
+ * Rewrites linked WGSL for the baseline tier. `data` is every `@data` declaration of the modules
+ * the variant links; `locate` maps a linked offset to its module and line, for errors.
+ */
+export declare function rewriteForBaseline(code: string, data: readonly DataDeclaration[], locate?: (offset: number) => SourceLocation | undefined, label?: string): BaselineRewrite;

package/dist/baseline/rewrite.js

@@ -0,0 +1,436 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { DATA_TEXTURE_WIDTH } from "../data-marks.js";
+import {
+  attribute,
+  declarations,
+  Layouts,
+  matching,
+  parseType,
+  tokenize
+} from "./wgsl.js";
+const RENDER_STAGES = /* @__PURE__ */ new Set(["vertex", "fragment"]);
+function rewriteForBaseline(code, data, locate = () => void 0, label = "shader") {
+  const tokens = tokenize(code);
+  const decls = declarations(code, tokens);
+  const layouts = new Layouts(code, tokens, decls);
+  const edits = [];
+  const bindings = [];
+  const tail = [];
+  const fail = (code2, message, offset, hint) => {
+    const at = locate(offset);
+    throw new ShardError(code2, `${label}: ${message}`, {
+      path: at ? `${at.module}:${at.line}:${at.column}` : void 0,
+      hint
+    });
+  };
+  const globals = /* @__PURE__ */ new Map();
+  for (const d of decls) if (d.keyword === "var") globals.set(d.name, d);
+  const reachable = renderReachable(tokens, decls, globals);
+  let coordNeeded = false;
+  for (const d of decls) {
+    if (d.keyword !== "var" || !d.template.startsWith("storage")) continue;
+    const group = Number(attribute(d, "group"));
+    const binding = Number(attribute(d, "binding"));
+    const marked = data.find((x) => x.group === group && x.binding === binding);
+    if (!marked) {
+      if (reachable.has(d.name)) {
+        fail(
+          "shader/baseline-storage",
+          `storage buffer "${d.name}" is read by a vertex or fragment shader, which the baseline tier can't do`,
+          d.start,
+          "Read engine data through shard::data (a @data declaration), or keep it out of render stages on baseline with @if(!BASELINE)."
+        );
+      }
+      continue;
+    }
+    if (d.template.includes("read_write")) {
+      fail("shader/baseline-data", `@data "${d.name}" must be read-only`, d.start);
+    }
+    const type = parseType(d.type);
+    const varToken = tokens.findIndex((t, i) => i >= d.first && t.text === "var");
+    if (marked.kind === "uniform") {
+      const runtime = type.kind === "array" && type.count === void 0;
+      if (runtime && !marked.count) {
+        fail(
+          "shader/baseline-data",
+          `@data(uniform) "${d.name}" is a runtime-sized array: give it a length, @data(uniform, N)`,
+          d.start
+        );
+      }
+      const sized = runtime && type.kind === "array" ? { ...type, count: marked.count } : type;
+      if (!layouts.sameInUniform(sized)) {
+        fail(
+          "shader/baseline-uniform-layout",
+          `@data(uniform) "${d.name}" (${d.type}) lies out differently in uniform memory`,
+          d.start,
+          "Pad its arrays to 16-byte strides, or declare it @data (a data texture)."
+        );
+      }
+      const element = sized.kind === "array" ? sized.element : void 0;
+      if (sized.kind === "array" && sized.count !== void 0 && element && (element.kind === "struct" || element.kind === "matrix" || element.kind === "array")) {
+        const words = sized.count * layouts.stride(sized, "storage") / 16;
+        edits.push({
+          start: tokens[varToken].start,
+          end: d.end,
+          text: `var<uniform> ${d.name}: array<vec4<u32>, ${words}>;`
+        });
+        rejectShadowing(tokens, decls, d, fail);
+        for (const i of usesOf(tokens, decls, d)) {
+          const t = tokens[i];
+          if (tokens[i + 1]?.text === "[") {
+            const close = matching(tokens, i + 1);
+            edits.push({ start: t.start, end: tokens[i + 1].end, text: `${d.name}_at(u32(` });
+            edits.push({ start: tokens[close].start, end: tokens[close].end, text: "))" });
+          } else if (tokens[i - 1]?.text === "&" && tokens[i - 2]?.text === "(" && tokens[i - 3]?.text === "arrayLength" && tokens[i + 1]?.text === ")") {
+            edits.push({
+              start: tokens[i - 3].start,
+              end: tokens[i + 1].end,
+              text: `${sized.count}u`
+            });
+          } else {
+            fail(
+              "shader/baseline-data",
+              `@data(uniform) "${d.name}" is used other than by index or arrayLength`,
+              t.start,
+              "Read one element at a time: name[i]."
+            );
+          }
+        }
+        tail.push(
+          loader(
+            d.name,
+            sized,
+            layouts,
+            false,
+            (k) => `${d.name}[${k}]`
+          )
+        );
+      } else if (runtime && type.kind === "array") {
+        edits.push({
+          start: tokens[varToken].start,
+          end: d.end,
+          text: `var<uniform> ${d.name}: array<${type.elementText}, ${marked.count}>;`
+        });
+        for (let i = 3; i < tokens.length - 1; i++) {
+          if (tokens[i].text === d.name && tokens[i - 1].text === "&" && tokens[i - 2].text === "(" && tokens[i - 3].text === "arrayLength" && tokens[i + 1].text === ")") {
+            edits.push({
+              start: tokens[i - 3].start,
+              end: tokens[i + 1].end,
+              text: `${marked.count}u`
+            });
+          }
+        }
+      } else {
+        const close = matching(tokens, varToken + 1);
+        edits.push({
+          start: tokens[varToken].start,
+          end: tokens[close].end,
+          text: "var<uniform>"
+        });
+      }
+      bindings.push({ group, binding, name: d.name, as: "uniform" });
+      continue;
+    }
+    if (type.kind !== "array") {
+      fail("shader/baseline-data", `@data "${d.name}" must be an array (${d.type})`, d.start);
+    }
+    const array = type;
+    edits.push({
+      start: tokens[varToken].start,
+      end: d.end,
+      text: `var ${d.name}: texture_2d<u32>;`
+    });
+    bindings.push({ group, binding, name: d.name, as: "data-texture" });
+    rejectShadowing(tokens, decls, d, fail);
+    let lengthUsed = false;
+    for (const i of usesOf(tokens, decls, d)) {
+      const t = tokens[i];
+      if (tokens[i + 1]?.text === "[") {
+        const close = matching(tokens, i + 1);
+        edits.push({ start: t.start, end: tokens[i + 1].end, text: `${d.name}_at(u32(` });
+        edits.push({ start: tokens[close].start, end: tokens[close].end, text: "))" });
+        continue;
+      }
+      if (tokens[i - 1]?.text === "&" && tokens[i - 2]?.text === "(" && tokens[i - 3]?.text === "arrayLength" && tokens[i + 1]?.text === ")") {
+        edits.push({
+          start: tokens[i - 3].start,
+          end: tokens[i + 1].end,
+          text: `${d.name}_len()`
+        });
+        lengthUsed = true;
+        continue;
+      }
+      fail(
+        "shader/baseline-data",
+        `@data "${d.name}" is used other than by index or arrayLength`,
+        t.start,
+        "Read one element at a time: name[i]."
+      );
+    }
+    tail.push(
+      loader(
+        d.name,
+        array,
+        layouts,
+        lengthUsed,
+        (k) => `textureLoad(${d.name}, shard_data_coord(${k}), 0)`
+      )
+    );
+    coordNeeded = true;
+  }
+  if (coordNeeded) {
+    tail.unshift(
+      `fn shard_data_coord(k: u32) -> vec2i {
+  return vec2i(i32(k % ${DATA_TEXTURE_WIDTH}u), i32(k / ${DATA_TEXTURE_WIDTH}u));
+}`
+    );
+  }
+  for (const d of decls) {
+    if (d.keyword !== "var" || !d.type.startsWith("texture_depth_")) continue;
+    const kind = d.type.trim();
+    const floatType = kind === "texture_depth_2d" ? "texture_2d<f32>" : kind === "texture_depth_2d_array" ? "texture_2d_array<f32>" : kind === "texture_depth_cube" ? "texture_cube<f32>" : void 0;
+    if (!floatType) continue;
+    const calls = callsOn(tokens, d);
+    if (calls.some((c) => /Compare/.test(c.fn))) continue;
+    if (usesOf(tokens, decls, d).length !== calls.length) continue;
+    const typeStart = code.indexOf(kind, d.start);
+    edits.push({ start: typeStart, end: typeStart + kind.length, text: floatType });
+    for (const c of calls) {
+      if (c.fn === "textureGather") {
+        edits.push({ start: c.open, end: c.open, text: "0, " });
+      } else if (c.fn !== "textureDimensions" && c.fn !== "textureNumLayers") {
+        edits.push({ start: c.close, end: c.close, text: ".x" });
+      }
+    }
+    bindings.push({
+      group: Number(attribute(d, "group")),
+      binding: Number(attribute(d, "binding")),
+      name: d.name,
+      as: "unfilterable-float"
+    });
+  }
+  let reverseBits = false;
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.text === "interpolate" && tokens[i - 1]?.text === "@" && tokens[i + 1]?.text === "(" && tokens[i + 2]?.text === "flat" && tokens[i + 3]?.text === ")") {
+      edits.push({ start: tokens[i + 3].start, end: tokens[i + 3].start, text: ", either" });
+    }
+    if (t.text === "reverseBits" && tokens[i + 1]?.text === "(") {
+      edits.push({ start: t.start, end: t.end, text: "shard_reverse_bits" });
+      reverseBits = true;
+    }
+    if ((t.text === "countOneBits" || t.text === "firstLeadingBit" || t.text === "firstTrailingBit" || t.text === "extractBits" || t.text === "insertBits" || t.text === "textureNumLevels") && tokens[i + 1]?.text === "(") {
+      fail(
+        "shader/baseline-builtin",
+        `${t.text} has no GLSL ES 3.00 equivalent`,
+        t.start,
+        "Compute it differently on baseline (@if(BASELINE))."
+      );
+    }
+  }
+  if (reverseBits) tail.push(REVERSE_BITS);
+  return { ...apply(code, edits, tail), bindings };
+}
+function usesOf(tokens, decls, d) {
+  const out = [];
+  let s = 0;
+  const structs = decls.filter((x) => x.keyword === "struct");
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.kind !== "ident" || t.text !== d.name || tokens[i - 1]?.text === ".") continue;
+    if (i >= d.first && i <= d.last) continue;
+    while (s < structs.length && structs[s].last < i) s++;
+    if (s < structs.length && structs[s].first <= i) continue;
+    out.push(i);
+  }
+  return out;
+}
+function renderReachable(tokens, decls, globals) {
+  const fns = /* @__PURE__ */ new Map();
+  for (const d of decls) if (d.keyword === "fn") fns.set(d.name, d);
+  const seen = /* @__PURE__ */ new Set();
+  const out = /* @__PURE__ */ new Set();
+  const stack = decls.filter((d) => d.keyword === "fn" && d.attributes.some((a) => RENDER_STAGES.has(a.name))).map((d) => d.name);
+  while (stack.length > 0) {
+    const name = stack.pop();
+    if (seen.has(name)) continue;
+    seen.add(name);
+    const fn = fns.get(name);
+    for (let i = fn.first; i <= fn.last; i++) {
+      const t = tokens[i];
+      if (t.kind !== "ident" || tokens[i - 1]?.text === ".") continue;
+      if (fns.has(t.text) && !seen.has(t.text)) stack.push(t.text);
+      else if (globals.has(t.text)) out.add(t.text);
+    }
+  }
+  return out;
+}
+function rejectShadowing(tokens, decls, data, fail) {
+  for (const d of decls) {
+    if (d.keyword !== "fn") continue;
+    for (let i = d.first; i <= d.last; i++) {
+      const t = tokens[i];
+      if (t.text !== data.name) continue;
+      const before = tokens[i - 1]?.text;
+      const after = tokens[i + 1]?.text;
+      const declares = before === "let" || before === "var" || before === "const";
+      const parameter = after === ":" && (before === "(" || before === ",");
+      if (declares || parameter) {
+        fail(
+          "shader/baseline-shadowed",
+          `"${data.name}" is declared again inside ${d.name}, over the @data declaration`,
+          t.start,
+          "Rename the local."
+        );
+      }
+    }
+  }
+}
+function callsOn(tokens, d) {
+  const out = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.kind !== "ident" || !t.text.startsWith("texture")) continue;
+    if (tokens[i + 1]?.text !== "(" || tokens[i + 2]?.text !== d.name) continue;
+    const close = matching(tokens, i + 1);
+    out.push({ fn: t.text, open: tokens[i + 2].start, close: tokens[close].end });
+  }
+  return out;
+}
+function loader(name, array, layouts, withLength, fetch) {
+  const stride = layouts.stride(array, "storage");
+  const element = array.element;
+  const lines = [];
+  let word;
+  if (stride % 16 === 0) {
+    const texels = stride / 16;
+    lines.push(`  let b = i * ${texels}u;`);
+    for (let k = 0; k < texels; k++) {
+      lines.push(`  let t${k} = ${fetch(`b + ${k}u`)};`);
+    }
+    word = (byte) => `t${byte >> 4}.${"xyzw"[(byte & 15) >> 2]}`;
+  } else {
+    lines.push(`  let b = i * ${stride}u;`);
+    word = (byte) => `${name}_word(b + ${byte}u)`;
+  }
+  const body = `${lines.join("\n")}
+  return ${read(element, 0, word, layouts)};`;
+  let out = `fn ${name}_at(i: u32) -> ${canonical(element)} {
+${body}
+}`;
+  if (stride % 16 !== 0) {
+    out += `
+fn ${name}_word(byte: u32) -> u32 {
+  return ${fetch("byte / 16u")}[(byte % 16u) / 4u];
+}`;
+  }
+  if (withLength) {
+    out += `
+fn ${name}_len() -> u32 {
+  let d = vec2i(textureDimensions(${name}));
+  return textureLoad(${name}, d - vec2i(1, 1), 0).x / ${stride}u;
+}`;
+  }
+  return out;
+}
+function read(t, offset, word, layouts) {
+  switch (t.kind) {
+    case "scalar":
+      return scalar(t.name, word(offset));
+    case "vector": {
+      const parts = [];
+      for (let k = 0; k < t.size; k++) parts.push(scalar(t.element.name, word(offset + k * 4)));
+      return `${canonical(t)}(${parts.join(", ")})`;
+    }
+    case "matrix": {
+      const column = { kind: "vector", size: t.rows, element: t.element };
+      const step = t.rows === 2 ? 8 : 16;
+      const columns = [];
+      for (let c = 0; c < t.columns; c++)
+        columns.push(read(column, offset + c * step, word, layouts));
+      return `${canonical(t)}(${columns.join(", ")})`;
+    }
+    case "array": {
+      if (t.count === void 0)
+        throw new ShardError("shader/baseline-data", "Nested runtime array");
+      const stride = layouts.stride(t, "storage");
+      const items = [];
+      for (let k = 0; k < t.count; k++)
+        items.push(read(t.element, offset + k * stride, word, layouts));
+      return `${canonical(t)}(${items.join(", ")})`;
+    }
+    case "struct": {
+      const s = layouts.struct(t.name, "storage");
+      return `${t.name}(${s.members.map((m) => read(m.type, offset + m.offset, word, layouts)).join(", ")})`;
+    }
+    default:
+      throw new ShardError(
+        "shader/baseline-data",
+        `Can't read ${JSON.stringify(t)} from a data texture`
+      );
+  }
+}
+function scalar(name, w) {
+  if (name === "u32") return w;
+  if (name === "i32" || name === "f32") return `bitcast<${name}>(${w})`;
+  throw new ShardError("shader/baseline-data", `${name} can't live in a data texture`);
+}
+function canonical(t) {
+  switch (t.kind) {
+    case "scalar":
+      return t.name;
+    case "vector":
+      return `vec${t.size}<${t.element.name}>`;
+    case "matrix":
+      return `mat${t.columns}x${t.rows}<${t.element.name}>`;
+    case "array":
+      return t.count === void 0 ? `array<${canonical(t.element)}>` : `array<${canonical(t.element)}, ${t.count}>`;
+    case "struct":
+      return t.name;
+    case "atomic":
+      return `atomic<${canonical(t.element)}>`;
+    default:
+      return t.text;
+  }
+}
+const REVERSE_BITS = `fn shard_reverse_bits(v: u32) -> u32 {
+  var x = v;
+  x = ((x >> 1u) & 0x55555555u) | ((x & 0x55555555u) << 1u);
+  x = ((x >> 2u) & 0x33333333u) | ((x & 0x33333333u) << 2u);
+  x = ((x >> 4u) & 0x0F0F0F0Fu) | ((x & 0x0F0F0F0Fu) << 4u);
+  x = ((x >> 8u) & 0x00FF00FFu) | ((x & 0x00FF00FFu) << 8u);
+  return (x >> 16u) | (x << 16u);
+}`;
+function apply(code, edits, tail) {
+  edits.sort((a, b) => a.start - b.start || a.end - b.end);
+  let out = "";
+  let at = 0;
+  const marks = [];
+  for (const e of edits) {
+    out += code.slice(at, e.start);
+    marks.push({ out: out.length, linked: e.start });
+    out += e.text;
+    at = e.end;
+    marks.push({ out: out.length, linked: e.end });
+  }
+  out += code.slice(at);
+  const end = code.length;
+  if (tail.length > 0) out += `
+// baseline tier (0064)
+${tail.join("\n\n")}
+`;
+  return {
+    code: out,
+    toLinked(offset) {
+      let base = { out: 0, linked: 0 };
+      for (const m of marks) {
+        if (m.out > offset) break;
+        base = m;
+      }
+      return Math.min(end, base.linked + (offset - base.out));
+    }
+  };
+}
+export {
+  rewriteForBaseline
+};

package/dist/baseline/wgsl.d.ts

@@ -0,0 +1,106 @@
+export interface Token {
+    kind: 'ident' | 'number' | 'punct';
+    text: string;
+    start: number;
+    end: number;
+}
+/** Tokens of `code`, comments skipped. Punctuation is one character, except `->`. */
+export declare function tokenize(code: string): Token[];
+/** Index of the token closing the bracket at `open` (`(`, `[`, `{` or `<` of a template). */
+export declare function matching(tokens: readonly Token[], open: number): number;
+export interface Attribute {
+    name: string;
+    /** Argument text, e.g. `2` for `@group(2)`; '' without arguments. */
+    args: string;
+}
+/** A module-scope declaration: its attributes, keyword, name and where it lies in the code. */
+export interface Declaration {
+    attributes: Attribute[];
+    keyword: 'struct' | 'fn' | 'var' | 'const' | 'override' | 'alias' | 'other';
+    name: string;
+    /** `var<storage, read>` → `storage, read`. */
+    template: string;
+    /** The type after `:` (vars), as written. */
+    type: string;
+    /** Offsets of the whole declaration, attributes included, and of its body or type. */
+    start: number;
+    end: number;
+    /** Token range of the declaration. */
+    first: number;
+    last: number;
+}
+/** Module-scope declarations of linked WGSL, in order. */
+export declare function declarations(code: string, tokens: readonly Token[]): Declaration[];
+export declare function attribute(d: Declaration, name: string): string | undefined;
+export type WgslType = {
+    kind: 'scalar';
+    name: 'f32' | 'u32' | 'i32' | 'f16' | 'bool';
+} | {
+    kind: 'vector';
+    size: 2 | 3 | 4;
+    element: WgslType & {
+        kind: 'scalar';
+    };
+} | {
+    kind: 'matrix';
+    columns: 2 | 3 | 4;
+    rows: 2 | 3 | 4;
+    element: WgslType & {
+        kind: 'scalar';
+    };
+} | {
+    kind: 'array';
+    element: WgslType;
+    elementText: string;
+    count: number | undefined;
+    text: string;
+} | {
+    kind: 'struct';
+    name: string;
+} | {
+    kind: 'atomic';
+    element: WgslType;
+} | {
+    kind: 'other';
+    text: string;
+};
+/** Parses a type as written (`array<Light>`, `vec3f`, `mat4x4<f32>`, `Instance`). */
+export declare function parseType(text: string): WgslType;
+export interface Member {
+    name: string;
+    type: WgslType;
+    typeText: string;
+    offset: number;
+    size: number;
+    align: number;
+}
+export interface StructLayout {
+    name: string;
+    members: Member[];
+    size: number;
+    align: number;
+}
+export type AddressSpace = 'storage' | 'uniform';
+/**
+ * Struct layouts by name, under one address space's rules (WGSL §14.4): uniform raises array
+ * strides and struct alignments to 16. `@align` and `@size` are honored.
+ */
+export declare class Layouts {
+    private readonly structs;
+    private readonly cache;
+    constructor(code: string, tokens: readonly Token[], decls: readonly Declaration[]);
+    has(name: string): boolean;
+    struct(name: string, space: AddressSpace): StructLayout;
+    align(t: WgslType, space: AddressSpace): number;
+    size(t: WgslType, space: AddressSpace): number;
+    /** Bytes between an array's elements. */
+    stride(t: WgslType & {
+        kind: 'array';
+    }, space: AddressSpace): number;
+    /**
+     * Whether a type lies out the same in uniform and storage memory: every member and element at
+     * the same offset, so the same bytes read the same through either.
+     */
+    sameInUniform(t: WgslType): boolean;
+    private sameLayout;
+}