@flowsilver/algoviz 0.0.0-stage → 0.4.0

package/package.json

@@ -1,6 +1,42 @@
-{
-  "name": "@flowsilver/algoviz",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "name": "@flowsilver/algoviz",
+  "version": "0.4.0",
+  "description": "Validate, replay, and compare algorithm traces in a self-contained offline viewer.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FlowSilver/AlgoViz.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "apps/inspector/",
+    "packages/",
+    "schemas/",
+    "examples/frozenlake/",
+    "docs/protocol.md"
+  ],
+  "type": "module",
+  "bin": {
+    "algoviz": "packages/cli/index.js"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "algoviz": "node packages/cli/index.js",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "node --test",
+    "test:browser": "node --test scripts/check-preview.js scripts/check-comparison.js"
+  },
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "esbuild": "^0.28.2",
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "playwright": "^1.65.0",
+    "typescript": "^7.0.2"
+  }
+}

package/packages/cli/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { readFile, mkdtemp, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import { build } from "esbuild";
+import { indexRun } from "../core/comparison.js";
+import { loadReplay } from "../core/index.js";
+import { loadViews } from "../core/protocol.js";
+
+const inspector = new URL("../../apps/inspector/", import.meta.url);
+const projectRoot = fileURLToPath(new URL("../../", import.meta.url));
+const usage = `Usage:
+  algoviz validate <visualization.json> <trace.jsonl>
+  algoviz preview <visualization.json> <trace.jsonl> [--output <preview.html>] [--renderer <name=file>]
+  algoviz compare <left-spec> <left-trace> <right-spec> <right-trace> [--output <preview.html>] [--renderer <name=file>]
+`;
+
+async function readUtf8(path) {
+  const bytes = await readFile(path);
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+  } catch {
+    throw new Error(`${path}: expected UTF-8 text`);
+  }
+}
+
+async function bundleLicenses(inputs) {
+  const packages = new Set();
+  for (const input of Object.keys(inputs)) {
+    const path = resolve(projectRoot, input).replaceAll("\\", "/");
+    const packageDirectory = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//.exec(path)?.[1];
+    if (packageDirectory) packages.add(packageDirectory);
+  }
+  const licenses = [await readFile(join(projectRoot, "LICENSE"), "utf8")];
+  for (const directory of [...packages].sort()) {
+    const files = (await readdir(directory)).filter((file) => /^licen[cs]e(?:\..+)?$/i.test(file));
+    for (const file of files.sort()) {
+      licenses.push(`${basename(directory)}\n\n${await readFile(join(directory, file), "utf8")}`);
+    }
+  }
+  return licenses.join("\n\n").replaceAll("-->", "-- >");
+}
+
+async function previewHtml(data, renderer) {
+  const entry = (path) => JSON.stringify(path.replaceAll("\\", "/"));
+  const inspectorEntry = entry(fileURLToPath(new URL("index.js", inspector)));
+  const plugin = renderer ? `import render from ${entry(renderer.path)};\n` : "";
+  const registry = renderer ? `new Map([[${JSON.stringify(renderer.name)}, render]])` : "new Map()";
+  const [template, styles, bundle] = await Promise.all([
+    readFile(new URL("index.html", inspector), "utf8"),
+    readFile(new URL("style.css", inspector), "utf8"),
+    build({
+      absWorkingDir: projectRoot,
+      stdin: {
+        contents: `${plugin}import { start } from ${inspectorEntry};\nstart(${registry});`,
+        resolveDir: projectRoot,
+      },
+      platform: "browser",
+      format: "iife",
+      bundle: true,
+      minify: true,
+      legalComments: "inline",
+      metafile: true,
+      write: false,
+    }),
+  ]);
+  const parts = {
+    STYLES: styles,
+    DATA: JSON.stringify(data).replaceAll("<", "\\u003c"),
+    SCRIPT: bundle.outputFiles[0].text,
+    LICENSES: await bundleLicenses(bundle.metafile.inputs),
+  };
+  return template.replace(/%(STYLES|DATA|SCRIPT|LICENSES)%/g, (_, name) => parts[name]);
+}
+
+function readRenderer(value) {
+  if (value === undefined) return undefined;
+  const match = /^([a-z][a-z0-9-]*)=(.+)$/.exec(value);
+  if (!match) throw new Error("Expected --renderer name=path-to-module");
+  return { name: match[1], path: resolve(match[2]) };
+}
+
+async function readRun(specPath, tracePath) {
+  const [specText, traceText] = await Promise.all([readUtf8(specPath), readUtf8(tracePath)]);
+  return { specText, traceText, traceSource: tracePath, specSource: specPath };
+}
+
+async function main() {
+  const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    options: { help: { type: "boolean", short: "h" }, output: { type: "string" }, renderer: { type: "string" } },
+  });
+  if (values.help) {
+    console.log(usage.trimEnd());
+    return;
+  }
+  const [command, ...paths] = positionals;
+  if (!["validate", "preview", "compare"].includes(command)
+      || paths.length !== (command === "compare" ? 4 : 2)
+      || (command === "validate" && (values.output !== undefined || values.renderer !== undefined))) {
+    throw new Error(usage.trimEnd());
+  }
+
+  const renderer = readRenderer(values.renderer);
+  const runs = await Promise.all([readRun(paths[0], paths[1]), ...(command === "compare" ? [readRun(paths[2], paths[3])] : [])]);
+  for (const run of runs) {
+    if (command !== "validate") {
+      for (const view of loadViews(run.specText, run.specSource)) {
+        if (view.type === "custom" && view.renderer !== renderer?.name) {
+          throw new Error(`${run.specSource}: renderer "${view.renderer}" requires --renderer ${view.renderer}=<file>`);
+        }
+      }
+    }
+    if (command === "compare") {
+      indexRun(run);
+    } else {
+      const replay = loadReplay(run.traceText, run);
+      replay.seek(replay.lastStep);
+      if (command === "validate") {
+        const count = replay.lastStep + 1;
+        console.log(`Validated ${count} replay ${count === 1 ? "state" : "states"}.`);
+        return;
+      }
+    }
+  }
+
+  const html = await previewHtml({ runs: runs.map((run) => ({
+    ...run, traceSource: basename(run.traceSource), specSource: basename(run.specSource),
+  })) }, renderer);
+  const destination = values.output === undefined
+    ? join(await mkdtemp(join(tmpdir(), "algoviz-")), "preview.html")
+    : resolve(values.output);
+  await writeFile(destination, html, { encoding: "utf8", flag: "wx" });
+  console.log(`Open ${pathToFileURL(destination).href}`);
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error.code === "EEXIST" ? `Preview already exists at ${error.path}. Choose a new output path.` : error.message);
+  process.exitCode = 1;
+}

package/packages/core/comparison.js

@@ -0,0 +1,43 @@
+import { loadReplay, ReplayError } from "./index.js";
+
+/** @import { ReplayOptions } from "./types.js" */
+
+/**
+ * Index a run by its zero-based episode and step coordinates, validating each frame.
+ * @param {ReplayOptions & { traceText: string }} input
+ */
+export function indexRun({ traceText, ...options }) {
+  const replay = loadReplay(traceText, { ...options, checkpointInterval: 128 });
+  /** @type {{ start: number, actions: (string | undefined)[] }[]} */
+  const episodes = [];
+  let frame = replay.current;
+  while (true) {
+    const { episode, t, last } = frame.state;
+    const current = episodes.at(-1);
+    if (episode === episodes.length && t === 0) {
+      episodes.push({ start: frame.step, actions: [undefined] });
+    } else if (current && episode === episodes.length - 1 && t === current.actions.length) {
+      const action = last && typeof last === "object" && !Array.isArray(last) ? last.action : undefined;
+      current.actions.push(typeof action === "string" ? action : undefined);
+    } else {
+      throw new ReplayError("Expected consecutive zero-based episode and t values", {
+        source: options.traceSource ?? "trace.jsonl", line: frame.step + 1,
+      });
+    }
+    if (frame.step === replay.lastStep) return { replay, episodes };
+    frame = replay.stepForward();
+  }
+}
+
+/**
+ * Find the first transition with a different recorded action in the shared part of an episode.
+ * @param {ReturnType<typeof indexRun>[]} runs
+ * @param {number} episode
+ */
+export function firstDifferentAction(runs, episode) {
+  const [a, b] = runs.map((run) => run.episodes[episode]?.actions ?? []);
+  for (let step = 1; step < Math.min(a.length, b.length); step++) {
+    if (a[step] !== undefined && b[step] !== undefined && a[step] !== b[step]) return step;
+  }
+  return undefined;
+}

package/packages/core/index.js

@@ -0,0 +1,124 @@
+import { applyUpdate } from "./json-pointer.js";
+import { checkBindings, loadTrace, loadViews, ReplayError } from "./protocol.js";
+import { diffStates } from "./state-changes.js";
+
+/** @import { JsonObject, ReplayFrame, ReplayOptions, StateChange, TraceRecords, ViewSpec } from "./types.js" */
+
+export { ReplayError } from "./protocol.js";
+
+/**
+ * @param {string} traceText
+ * @param {ReplayOptions} [options]
+ */
+export function loadReplay(traceText, {
+  traceSource = "trace.jsonl",
+  specText,
+  specSource = "visualization.json",
+  checkpointInterval,
+} = {}) {
+  const records = loadTrace(traceText, traceSource);
+  const views = specText === undefined ? [] : loadViews(specText, specSource);
+  return new TraceReplay(records, views, traceSource, checkpointInterval);
+}
+
+class TraceReplay {
+  #records;
+  #views;
+  #source;
+  #checkpointInterval;
+  #lastCheckpoint = 0;
+  /** @type {Map<number, JsonObject>} */
+  #checkpoints = new Map();
+  /** @type {ReplayFrame} */
+  #frame;
+  /** @type {JsonObject | undefined} */
+  #previousState;
+
+  /**
+   * @param {TraceRecords} records
+   * @param {ViewSpec[]} views
+   * @param {string} source
+   * @param {number} [checkpointInterval]
+   */
+  constructor(records, views, source, checkpointInterval) {
+    if (checkpointInterval !== undefined && (!Number.isSafeInteger(checkpointInterval) || checkpointInterval < 1)) {
+      throw new RangeError("Checkpoint interval must be a positive integer");
+    }
+    this.#records = records;
+    this.#views = views;
+    this.#source = source;
+    this.#checkpointInterval = checkpointInterval;
+    const state = records[0].state;
+    checkBindings(state, views, source, 1);
+    this.#frame = { step: 0, state, events: [] };
+  }
+
+  get current() {
+    return structuredClone(this.#frame);
+  }
+
+  get lastStep() {
+    return this.#records.length - 1;
+  }
+
+  /** @returns {StateChange[]} */
+  get changes() {
+    return this.#previousState ? structuredClone(diffStates(this.#previousState, this.#frame.state)) : [];
+  }
+
+  stepForward() {
+    return this.seek(Math.min(this.#frame.step + 1, this.lastStep));
+  }
+
+  stepBackward() {
+    return this.seek(Math.max(this.#frame.step - 1, 0));
+  }
+
+  /** @param {number} step */
+  seek(step) {
+    if (!Number.isInteger(step) || step < 0 || step > this.lastStep) {
+      throw new RangeError(`Step must be an integer from 0 through ${this.lastStep}`);
+    }
+    if (step === this.#frame.step) return this.current;
+
+    const interval = this.#checkpointInterval;
+    // Start before the target to reconstruct the Changes panel's preceding state.
+    const checkpoint = interval ? Math.min(this.#lastCheckpoint, Math.floor((step - 1) / interval) * interval) : 0;
+    const start = this.#frame.step < step && this.#frame.step > checkpoint
+      ? this.#frame : { step: Math.max(checkpoint, 0), state: this.#checkpoints.get(checkpoint) ?? this.#records[0].state };
+    const candidate = structuredClone(start.state);
+    /** @type {[number, JsonObject][]} */
+    const checkpoints = [];
+    /** @type {JsonObject | undefined} */
+    let previousState;
+    for (let next = start.step + 1; next <= step; next++) {
+      const line = next + 1;
+      const record = this.#records[next];
+      if (record.type !== "step") throw new Error(`Missing step record at line ${line}`);
+      if (next === step) previousState = next === start.step + 1 ? start.state : structuredClone(candidate);
+      for (const [operationIndex, update] of record.updates.entries()) {
+        try {
+          applyUpdate(candidate, update);
+        } catch (error) {
+          throw new ReplayError(error instanceof Error ? error.message : String(error), {
+            source: this.#source, line, operationIndex, path: update.path,
+          });
+        }
+      }
+      checkBindings(candidate, this.#views, this.#source, line);
+      if (interval && next > this.#lastCheckpoint && next % interval === 0) {
+        checkpoints.push([next, structuredClone(candidate)]);
+      }
+    }
+
+    const record = this.#records[step];
+    // Commit the frame and its comparison baseline only after successful validation.
+    this.#frame = { step, state: candidate, events: record.type === "step" ? record.events ?? [] : [] };
+    this.#previousState = previousState;
+    for (const [index, state] of checkpoints) {
+      this.#checkpoints.set(index, state);
+      this.#lastCheckpoint = index;
+    }
+    return this.current;
+  }
+}

package/packages/core/json-pointer.js

@@ -0,0 +1,94 @@
+/** @import { ItemBinding, JsonObject, JsonValue, StateUpdate } from "./types.js" */
+
+/** @param {string} pointer */
+function tokens(pointer) {
+  if (pointer === "") return [];
+  return pointer.slice(1).split("/").map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+
+/**
+ * @param {JsonValue[]} array
+ * @param {string} token
+ * @param {boolean} [inserting]
+ */
+function arrayIndex(array, token, inserting = false) {
+  if (inserting && token === "-") return array.length;
+  if (!/^(?:0|[1-9][0-9]*)$/.test(token)) {
+    throw new Error(`Invalid array index ${JSON.stringify(token)}`);
+  }
+
+  const index = Number(token);
+  const lastIndex = inserting ? array.length : array.length - 1;
+  if (index > lastIndex) throw new Error(`Array index ${token} is out of range`);
+  return index;
+}
+
+/**
+ * @param {JsonValue} parent
+ * @param {string} key
+ * @returns {JsonValue}
+ */
+function readMember(parent, key) {
+  if (Array.isArray(parent)) return parent[arrayIndex(parent, key)];
+  if (parent === null || typeof parent !== "object") {
+    throw new Error(`Cannot read member ${JSON.stringify(key)} from a scalar`);
+  }
+  if (!Object.hasOwn(parent, key)) throw new Error(`Missing member ${JSON.stringify(key)}`);
+  return parent[key];
+}
+
+/**
+ * @param {JsonValue} state
+ * @param {string} pointer
+ */
+export function resolvePointer(state, pointer) {
+  return tokens(pointer).reduce(readMember, state);
+}
+
+/**
+ * @param {JsonValue} entry
+ * @param {ItemBinding} binding
+ */
+export function resolveArrayItem(entry, binding) {
+  const label = resolvePointer(entry, binding.label);
+  if (typeof label !== "string") {
+    throw new Error(`Expected a string label at ${JSON.stringify(binding.label)}`);
+  }
+  return { label, value: resolvePointer(entry, binding.value) };
+}
+
+/**
+ * @param {JsonObject} state
+ * @param {StateUpdate} update
+ */
+export function applyUpdate(state, { op, path, value }) {
+  const parents = tokens(path);
+  const key = parents.pop();
+  if (key === undefined) throw new Error("Update path must name a state member");
+  const parent = parents.reduce(readMember, state);
+
+  if (Array.isArray(parent)) {
+    const index = arrayIndex(parent, key, op === "add");
+    if (op === "add") parent.splice(index, 0, structuredClone(value));
+    else if (op === "remove") parent.splice(index, 1);
+    else parent[index] = structuredClone(value);
+    return;
+  }
+
+  if (parent === null || typeof parent !== "object") {
+    throw new Error(`Cannot update member ${JSON.stringify(key)} on a scalar`);
+  }
+  if (op !== "add") readMember(parent, key);
+
+  if (op === "remove") {
+    delete parent[key];
+  } else {
+    // JSON keys such as __proto__ must become ordinary own properties.
+    Object.defineProperty(parent, key, {
+      value: structuredClone(value),
+      enumerable: true,
+      writable: true,
+      configurable: true,
+    });
+  }
+}

package/packages/core/protocol.js

@@ -0,0 +1,188 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { visit } from "jsonc-parser";
+import graphSchema from "../../schemas/graph-view-data.schema.json" with { type: "json" };
+import traceSchema from "../../schemas/trace-record.schema.json" with { type: "json" };
+import specSchema from "../../schemas/visualization-spec.schema.json" with { type: "json" };
+import { resolveArrayItem, resolvePointer } from "./json-pointer.js";
+
+/** @import { ValidateFunction, ErrorObject } from "ajv" */
+/** @import { GraphViewData, InitialRecord, ItemBinding, JsonObject, JsonValue, ReplayLocation, StepRecord, TraceRecords, ViewSpec, VisualizationSpec } from "./types.js" */
+
+const ajv = new Ajv2020({ ownProperties: true });
+ajv.addSchema(traceSchema, "trace-record");
+const validateInitial = /** @type {ValidateFunction<InitialRecord>} */ (recordValidator("initial"));
+const validateStep = /** @type {ValidateFunction<StepRecord>} */ (recordValidator("step"));
+/** @type {ValidateFunction<VisualizationSpec>} */
+const validateSpec = ajv.compile(specSchema);
+/** @type {ValidateFunction<GraphViewData>} */
+const validateGraph = ajv.compile(graphSchema);
+
+/** @param {"initial" | "step"} type */
+function recordValidator(type) {
+  const validate = ajv.getSchema(`trace-record#/$defs/${type}`);
+  if (!validate) throw new Error(`Missing trace schema for ${type}`);
+  return validate;
+}
+
+export class ReplayError extends Error {
+  /**
+   * @param {string} message
+   * @param {ReplayLocation} location
+   */
+  constructor(message, { source, line, operationIndex, path, viewId }) {
+    const location = line === undefined ? source : `${source}:${line}`;
+    const subject = operationIndex !== undefined ? ` update ${operationIndex}`
+      : viewId !== undefined ? ` view ${JSON.stringify(viewId)}` : "";
+    const pointer = path === undefined ? "" : ` at ${JSON.stringify(path)}`;
+    super(`${location}${subject}${pointer}: ${message}`);
+    this.name = "ReplayError";
+    this.source = source;
+    this.line = line;
+    this.operationIndex = operationIndex;
+    this.path = path;
+    this.viewId = viewId;
+  }
+}
+
+/**
+ * @param {string} text
+ * @param {ReplayLocation} location
+ * @returns {unknown}
+ */
+function parseJson(text, location) {
+  try {
+    const value = JSON.parse(text, (_key, entry) => {
+      if (typeof entry === "number" && !Number.isFinite(entry)) {
+        throw new Error("Number is outside the finite JavaScript range");
+      }
+      return entry;
+    });
+    /** @type {Set<string>[]} */
+    const keys = [];
+    // JSON.parse checks syntax, while the visitor sees keys before duplicates are discarded.
+    visit(text, {
+      onObjectBegin() { keys.push(new Set()); },
+      onObjectEnd() { keys.pop(); },
+      onObjectProperty(key) {
+        const objectKeys = keys.at(-1);
+        if (!objectKeys) throw new Error("Invalid JSON object");
+        if (objectKeys.has(key)) throw new Error(`Duplicate member ${JSON.stringify(key)}`);
+        objectKeys.add(key);
+      },
+    });
+    return value;
+  } catch (error) {
+    throw new ReplayError(error instanceof Error ? error.message : String(error), location);
+  }
+}
+
+/** @param {ErrorObject | undefined} problem */
+function schemaMessage(problem) {
+  return [problem?.instancePath, problem?.message ?? "Invalid input"].filter(Boolean).join(" ");
+}
+
+/**
+ * @template T
+ * @param {string} lineText
+ * @param {ReplayLocation} location
+ * @param {"initial" | "step"} expected
+ * @param {ValidateFunction<T>} validate
+ * @returns {T}
+ */
+function readRecord(lineText, location, expected, validate) {
+  if (lineText.trim() === "") throw new ReplayError("Blank trace line", location);
+  const record = parseJson(lineText, location);
+  if (typeof record !== "object" || record === null || !("type" in record) || record.type !== expected) {
+    throw new ReplayError(`Expected a record with type ${JSON.stringify(expected)}`, location);
+  }
+  if (validate(record)) return record;
+
+  const problem = validate.errors?.[0];
+  const operation = /^\/updates\/(\d+)(?:\/|$)/.exec(problem?.instancePath ?? "");
+  if (operation && "updates" in record && Array.isArray(record.updates)) {
+    location.operationIndex = Number(operation[1]);
+    const path = record.updates[location.operationIndex]?.path;
+    if (typeof path === "string") location.path = path;
+  }
+  throw new ReplayError(schemaMessage(problem), location);
+}
+
+/**
+ * @param {string} text
+ * @param {string} source
+ * @returns {TraceRecords}
+ */
+export function loadTrace(text, source) {
+  if (typeof text !== "string") throw new TypeError("Trace input must be decoded JSONL text");
+  const lines = text.split(/\r?\n/);
+  if (lines.at(-1) === "") lines.pop();
+  const first = lines.shift();
+  if (first === undefined) throw new ReplayError("Expected an initial record", { source, line: 1 });
+  const initial = readRecord(first, { source, line: 1 }, "initial", validateInitial);
+  return [initial, ...lines.map((text, index) => readRecord(text, { source, line: index + 2 }, "step", validateStep))];
+}
+
+/**
+ * @param {string} text
+ * @param {string} source
+ */
+export function loadViews(text, source) {
+  if (typeof text !== "string") throw new TypeError("Spec input must be decoded JSON text");
+  const spec = parseJson(text, { source });
+  if (!validateSpec(spec)) throw new ReplayError(schemaMessage(validateSpec.errors?.[0]), { source });
+
+  const ids = new Set();
+  for (const view of spec.views) {
+    if (ids.has(view.id)) throw new ReplayError("Duplicate view ID", { source, viewId: view.id });
+    ids.add(view.id);
+  }
+  return spec.views;
+}
+
+/** @param {JsonValue} graph */
+function checkGraph(graph) {
+  if (!validateGraph(graph)) throw new Error(schemaMessage(validateGraph.errors?.[0]));
+  const nodeIds = new Set(graph.nodes.map((node) => node.id));
+  const edgeIds = new Set(graph.edges.map((edge) => edge.id));
+  if (nodeIds.size !== graph.nodes.length) throw new Error("Graph node IDs must be unique");
+  if (edgeIds.size !== graph.edges.length) throw new Error("Graph edge IDs must be unique");
+  for (const edge of graph.edges) {
+    if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+      throw new Error(`Edge ${JSON.stringify(edge.id)} refers to a missing node`);
+    }
+  }
+}
+
+/**
+ * @param {JsonValue} array
+ * @param {ItemBinding | undefined} binding
+ */
+function checkArray(array, binding) {
+  if (!Array.isArray(array)) throw new Error("Expected an array");
+  if (!binding) return;
+  for (const [index, entry] of array.entries()) {
+    try {
+      resolveArrayItem(entry, binding);
+    } catch (error) {
+      throw new Error(`Array item ${index}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+/**
+ * @param {JsonObject} state
+ * @param {ViewSpec[]} views
+ * @param {string} source
+ * @param {number} line
+ */
+export function checkBindings(state, views, source, line) {
+  for (const view of views) {
+    try {
+      const value = resolvePointer(state, view.source);
+      if (view.type === "graph") checkGraph(value);
+      else if (view.type === "array") checkArray(value, view.item);
+    } catch (error) {
+      throw new ReplayError(error instanceof Error ? error.message : String(error), { source, line, viewId: view.id, path: view.source });
+    }
+  }
+}