@tsplc/debug 0.0.0-stage → 0.2.17

package/dist/index.js

@@ -0,0 +1,1681 @@
+// packages/debug/src/debugger.ts
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { telemetryBatch } from "@tsplc/server/telemetry";
+import { z as z2 } from "zod";
+
+// packages/debug/src/adapter.ts
+var qualityRank = { good: 0, uncertain: 1, bad: 2, unavailable: 3 };
+var worstQuality = (samples) => samples.reduce((worst, sample) => {
+  const quality = sample?.quality ?? "unavailable";
+  return qualityRank[quality] > qualityRank[worst] ? quality : worst;
+}, "good");
+
+// packages/debug/src/hardware.ts
+var faultyState = /error|fault|fail|timeout|lost|closed/i;
+var untyped = { kind: "scalar", iec: "ANY" };
+var healthReads = (device) => {
+  const { state, states, diagnostic, message } = device.health ?? {};
+  return [
+    ...state ? [
+      {
+        target: state,
+        type: states ? { kind: "enum", name: "state", members: states } : { kind: "scalar", iec: "DINT" }
+      }
+    ] : [],
+    ...diagnostic ? [{ target: diagnostic, type: { kind: "scalar", iec: "BOOL" } }] : [],
+    ...message ? [{ target: message, type: { kind: "scalar", iec: "STRING" } }] : []
+  ];
+};
+var deviceReads = (device, io, typeOf) => [
+  ...healthReads(device),
+  ...device.assemblies.flatMap(({ raw, bytes }) => raw ? [
+    {
+      target: raw,
+      type: { kind: "array", element: "BYTE", length: bytes, lower: 0 }
+    }
+  ] : []),
+  ...io.filter((binding) => binding.device === device.id).map(({ target, type }) => ({ target, type: typeOf(type) })),
+  ...Object.values(device.status ?? {}).map((target) => ({ target, type: untyped }))
+];
+var health = (device, value) => {
+  const { state, states, diagnostic, message } = device.health ?? {};
+  if (!state && !diagnostic)
+    return { state: "unknown", quality: "unavailable" };
+  const stateSample = state ? value(state) : undefined;
+  const diagnosticSample = diagnostic ? value(diagnostic) : undefined;
+  const messageSample = message ? value(message) : undefined;
+  const quality = worstQuality([
+    ...state ? [stateSample] : [],
+    ...diagnostic ? [diagnosticSample] : []
+  ]);
+  const number = typeof stateSample?.value === "number" ? stateSample.value : undefined;
+  const name = Object.entries(states ?? {}).find(([, member]) => member === number)?.[0] ?? (typeof stateSample?.value === "string" ? stateSample.value : undefined);
+  const faulted = diagnosticSample?.value === true || name !== undefined && faultyState.test(name);
+  return {
+    state: quality !== "good" ? "stale" : faulted ? "fault" : "ok",
+    ...number !== undefined && { value: number },
+    ...name && { name },
+    ...typeof diagnosticSample?.value === "boolean" && { diagnostic: diagnosticSample.value },
+    ...typeof messageSample?.value === "string" && { message: messageSample.value },
+    quality
+  };
+};
+var deviceState = (device, io, value) => ({
+  id: device.id,
+  health: health(device, value),
+  assemblies: device.assemblies.map(({ direction, address, raw }) => {
+    const sample = raw ? value(raw) : undefined;
+    return {
+      direction,
+      ...address && { address },
+      bytes: Array.isArray(sample?.value) && sample.value.every((byte) => typeof byte === "number") ? sample.value : null,
+      quality: sample?.quality ?? "unavailable"
+    };
+  }),
+  channels: io.flatMap((binding) => binding.device === device.id && binding.channel ? [
+    {
+      id: binding.channel,
+      path: binding.path,
+      value: value(binding.target)?.value ?? null,
+      quality: value(binding.target)?.quality ?? "unavailable"
+    }
+  ] : []),
+  status: Object.fromEntries(Object.entries(device.status ?? {}).map(([label, target]) => [
+    label,
+    { value: value(target)?.value ?? null, quality: value(target)?.quality ?? "unavailable" }
+  ]))
+});
+
+// packages/debug/src/jobs.ts
+var scalar = (iec) => ({ kind: "scalar", iec });
+var busyRead = (job) => ({
+  target: `${job.target}.busy`,
+  type: scalar("BOOL")
+});
+var detailReads = (job) => [
+  { target: `${job.target}.step`, type: scalar("UINT") },
+  { target: `${job.target}.cancelling`, type: scalar("BOOL") },
+  ...job.startedAt ? [{ target: job.startedAt, type: scalar("UDINT") }] : [],
+  ...job.requests.map(({ sequence }) => ({ target: sequence, type: scalar("UDINT") }))
+];
+var busyOf = (job, value, traced) => {
+  const read = value(busyRead(job).target);
+  return read?.quality === "good" ? read.value === true : traced?.busy ?? null;
+};
+var numberOf = (sample) => sample?.quality === "good" && typeof sample.value === "number" ? sample.value : undefined;
+var jobState = (job, inputs) => {
+  const { value, traced, clock, now } = inputs;
+  const busy = busyOf(job, value, traced);
+  const startedPlc = job.startedAt === undefined ? undefined : numberOf(value(job.startedAt));
+  const startedAt = traced?.startedAt ?? (clock && startedPlc !== undefined ? new Date(startedPlc - clock.offsetMs).toISOString() : undefined);
+  const base = {
+    id: job.id,
+    quality: value(busyRead(job).target)?.quality ?? (traced ? "good" : "unavailable"),
+    busy,
+    ...startedAt && { startedAt },
+    ...inputs.failure && { failure: inputs.failure }
+  };
+  if (!busy)
+    return base;
+  if (inputs.unread)
+    return { ...base, unread: true };
+  const step = numberOf(value(`${job.target}.step`));
+  const current = job.steps.find((candidate) => candidate.step === step);
+  const calls = job.requests.map((call) => {
+    const sequence = numberOf(value(call.sequence)) ?? 0;
+    const trace = inputs.request({ job: call.job ?? job.id, service: call.service, sequence });
+    return { service: call.service, sequence, trace };
+  }).filter(({ sequence }) => sequence > 0);
+  const later = (call, than) => call.trace && than.trace ? call.trace.startedAt > than.trace.startedAt : call.sequence > than.sequence;
+  const latest = calls.reduce((latest, call) => latest && !later(call, latest) ? latest : call, undefined);
+  const cancelling = value(`${job.target}.cancelling`);
+  return {
+    ...base,
+    ...cancelling?.quality === "good" && { cancelling: cancelling.value === true },
+    ...step !== undefined && { step },
+    ...current && { current: { kind: current.kind, range: current.range, text: current.text } },
+    ...startedAt && { elapsedMs: Math.max(0, now - Date.parse(startedAt)) },
+    ...latest && {
+      request: {
+        service: latest.service,
+        sequence: latest.sequence,
+        ...latest.trace && { trace: latest.trace }
+      }
+    }
+  };
+};
+
+// packages/debug/src/paths.ts
+var segmentPattern = /[^.[\]]+|\[(?:-?\d+|\*)\]/g;
+var pathSegments = (path) => path.match(segmentPattern) ?? [];
+var joinPath = (prefix, segment) => segment.startsWith("[") || !prefix ? `${prefix}${segment}` : `${prefix}.${segment}`;
+var typeOf = (manifest, id) => manifest.types[id] ?? { kind: "scalar", iec: id };
+var createPaths = (manifest) => {
+  const typeOfId = (id) => typeOf(manifest, id);
+  const bases = new Map([
+    ...manifest.roots.map(({ path, ...root }) => [path, { kind: "target", path, ...root }]),
+    ...manifest.io.map(({ path, target, type }) => [path, { kind: "target", path, target, type, readable: true }])
+  ]);
+  const constants = new Map(manifest.constants.map(({ path, ...constant }) => [
+    path,
+    { kind: "constant", path, ...constant }
+  ]));
+  const groups = new Map;
+  for (const path of [...bases.keys(), ...constants.keys()]) {
+    let prefix = "";
+    for (const segment of pathSegments(path)) {
+      let children = groups.get(prefix);
+      if (!children)
+        groups.set(prefix, children = new Set);
+      children.add(segment);
+      prefix = joinPath(prefix, segment);
+    }
+  }
+  const resolve = (path) => {
+    const constant = constants.get(path);
+    if (constant)
+      return constant;
+    const segments = pathSegments(path);
+    for (let length = segments.length;length > 0; length--) {
+      const base = bases.get(segments.slice(0, length).reduce(joinPath, ""));
+      if (!base)
+        continue;
+      let resolved = base;
+      for (const segment of segments.slice(length)) {
+        const type = typeOfId(resolved.type);
+        if (type.kind === "record") {
+          const field = type.fields.find(({ name }) => name === segment);
+          if (!field)
+            return;
+          resolved = {
+            kind: "target",
+            path: joinPath(resolved.path, segment),
+            target: `${resolved.target}.${field.target}`,
+            type: field.type,
+            readable: resolved.readable,
+            ...field.generated && { generated: true },
+            ...field.declaration && { declaration: field.declaration }
+          };
+        } else if (type.kind === "array") {
+          const index = /^\[(-?\d+)\]$/.exec(segment)?.[1];
+          if (index === undefined || Number(index) < type.lower || Number(index) >= type.lower + type.length)
+            return;
+          resolved = {
+            kind: "target",
+            path: joinPath(resolved.path, segment),
+            target: `${resolved.target}[${index}]`,
+            type: type.element,
+            readable: resolved.readable
+          };
+        } else
+          return;
+      }
+      return resolved;
+    }
+  };
+  const typedChildren = (resolved) => {
+    const type = resolved?.kind === "target" ? typeOfId(resolved.type) : undefined;
+    if (type?.kind === "record")
+      return type.fields.map(({ name }) => name);
+    if (type?.kind === "array")
+      return Array.from({ length: type.length }, (_, index) => `[${type.lower + index}]`);
+    return [];
+  };
+  const children = (path) => {
+    const names = [...typedChildren(resolve(path)), ...groups.get(path) ?? []];
+    return [...new Set(names)].map((name) => {
+      const child = joinPath(path, name);
+      return { name, ...resolve(child) ?? { kind: "group", path: child } };
+    });
+  };
+  const isLeaf = (node) => node.kind === "constant" || node.kind === "target" && ["scalar", "enum"].includes(typeOfId(node.type).kind);
+  const expand = (patterns, limit = 2000) => {
+    const leaves = new Set;
+    const add = (path) => {
+      leaves.add(path);
+      if (leaves.size > limit)
+        throw new RangeError(`More than ${limit} values match`);
+    };
+    const below = (node) => {
+      if (isLeaf(node))
+        return add(node.path);
+      for (const child of children(node.path))
+        if (!(child.kind === "target" && child.generated))
+          below(child);
+    };
+    const match = (prefix, rest, wildcard) => {
+      const [head, ...tail] = rest;
+      if (head === undefined) {
+        const node = resolve(prefix) ?? (groups.has(prefix) ? { kind: "group", path: prefix } : undefined);
+        if (node)
+          below(node);
+        else if (!wildcard)
+          add(prefix);
+        return;
+      }
+      if (head === "*" || head === "[*]") {
+        for (const child of children(prefix))
+          if (!(child.kind === "target" && child.generated) && (head === "*" || child.name.startsWith("[")))
+            match(child.path, tail, true);
+      } else
+        match(joinPath(prefix, head), tail, wildcard);
+    };
+    for (const pattern of patterns)
+      match("", pathSegments(pattern), false);
+    return [...leaves];
+  };
+  const decode = (typeId, raw) => {
+    const type = typeOfId(typeId);
+    if (type.kind === "enum")
+      return Object.entries(type.members).find(([, value]) => value === raw)?.[0] ?? raw;
+    if (type.kind === "scalar" && type.iec === "BOOL" && typeof raw === "number")
+      return raw !== 0;
+    return raw;
+  };
+  return { typeOf: typeOfId, resolve, children, isLeaf, expand, decode };
+};
+
+// packages/debug/src/telemetry.ts
+import { recordedAt } from "@tsplc/server/telemetry-log";
+var clockWindowMs = 60000;
+var createTelemetryFollower = (manifest) => {
+  const intervals = new Map(manifest.tasks.map(({ name, intervalMs }) => [name, intervalMs]));
+  const tasks = new Map(manifest.tasks.map(({ name }) => [
+    name,
+    { name, scan: null, scansPerSecond: null, dropped: 0 }
+  ]));
+  const rates = new Map;
+  let estimates = [];
+  let newest = 0;
+  let build = null;
+  const clock = () => {
+    if (!estimates.length)
+      return null;
+    const offsets = estimates.map(({ offsetMs }) => offsetMs);
+    const best = estimates.reduce((best, estimate) => estimate.offsetMs > best.offsetMs ? estimate : best);
+    return {
+      offsetMs: best.offsetMs,
+      uncertaintyMs: best.offsetMs - Math.min(...offsets) + best.intervalMs
+    };
+  };
+  const observe = (batch, receivedAt) => {
+    const rate = rates.get(batch.task);
+    const restarted = rate !== undefined && batch.now < rate.now;
+    if (restarted)
+      estimates = [];
+    estimates = estimates.filter(({ at }) => receivedAt - at < clockWindowMs);
+    estimates.push({
+      offsetMs: batch.now - receivedAt,
+      intervalMs: intervals.get(batch.task) ?? 0,
+      at: receivedAt
+    });
+    const stats = {
+      name: batch.task,
+      scansPerSecond: tasks.get(batch.task)?.scansPerSecond ?? null,
+      scan: batch.scan,
+      dropped: batch.dropped
+    };
+    if (!rate || restarted)
+      rates.set(batch.task, { scan: batch.scan, now: batch.now });
+    else if (batch.now - rate.now >= 1000) {
+      stats.scansPerSecond = (batch.scan - rate.scan) * 1000 / (batch.now - rate.now);
+      rates.set(batch.task, { scan: batch.scan, now: batch.now });
+    }
+    tasks.set(batch.task, stats);
+  };
+  return {
+    since: () => newest,
+    accept: (reply) => {
+      if (reply.latest < newest) {
+        newest = 0;
+        return [];
+      }
+      const received = [];
+      for (const batch of reply.batches) {
+        if (batch.seq <= newest)
+          continue;
+        newest = batch.seq;
+        build = batch.build;
+        const receivedAt = new Date(batch.receivedAt);
+        observe(batch, receivedAt.getTime());
+        batch.records.forEach((record, index) => received.push({
+          build: batch.build,
+          task: batch.task,
+          sequence: batch.first + index,
+          at: recordedAt(batch, record, receivedAt).toISOString(),
+          record
+        }));
+      }
+      return received;
+    },
+    build: () => build,
+    clock,
+    tasks: () => [...tasks.values()].map((task) => ({ ...task }))
+  };
+};
+
+// packages/debug/src/timeline.ts
+var timelineEntries = {
+  app: (at, task, sequence, record) => ({
+    at,
+    approximate: true,
+    source: "plc",
+    kind: "app",
+    task,
+    sequence,
+    record
+  }),
+  trace: (at, trace) => ({
+    at,
+    approximate: true,
+    source: "plc",
+    kind: "trace",
+    trace
+  }),
+  request: (request) => ({
+    at: request.startedAt,
+    approximate: true,
+    source: "server",
+    kind: "request",
+    request
+  }),
+  deploy: (at, details) => ({
+    at,
+    approximate: false,
+    source: "agent",
+    kind: "deploy",
+    ...details
+  }),
+  audit: (at, details) => ({
+    at,
+    approximate: false,
+    source: "agent",
+    kind: "audit",
+    ...details
+  }),
+  connection: (at, state, error) => ({
+    at,
+    approximate: false,
+    source: "debugger",
+    kind: "connection",
+    state,
+    ...error && { error }
+  })
+};
+var createTimeline = (limit = 1e4) => {
+  const entries = [];
+  return {
+    add: (entry) => {
+      let index = entries.length;
+      while (index > 0 && entry.at < (entries[index - 1]?.at ?? entry.at))
+        index--;
+      entries.splice(index, 0, entry);
+      if (entries.length > limit)
+        entries.splice(0, entries.length - limit);
+    },
+    since: (at) => at ? entries.filter((entry) => entry.at > at) : [...entries]
+  };
+};
+
+// packages/debug/src/trace.ts
+var createTraceDecoder = (manifest, paths) => {
+  const sites = new Map(manifest.events.map((site) => [site.id, site]));
+  const jobs = new Map(manifest.jobs.map((job) => [job.id, job]));
+  const jobSites = new Map(manifest.events.flatMap(({ id, job: jobId, phase }) => {
+    const job = jobId === undefined ? undefined : jobs.get(jobId);
+    return job && phase ? [[id, { job, started: phase === "started" }]] : [];
+  }));
+  return {
+    decode: (record, task, sequence) => {
+      const site = sites.get(record.site);
+      if (!site)
+        return;
+      return {
+        sequence,
+        task,
+        scan: record.scan,
+        plcTime: record.time,
+        site: site.id,
+        value: paths.decode(site.type, record.value),
+        operands: site.operands.map(({ text, path, stable, type }, index) => ({
+          text,
+          ...path && { path },
+          stable,
+          value: paths.decode(type, record.operands[index])
+        }))
+      };
+    },
+    job: (record) => jobSites.get(record.site)
+  };
+};
+
+// packages/debug/src/watch.ts
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+var watchGroupsSchema = z.strictObject({
+  groups: z.record(z.string().min(1), z.array(z.string().min(1)))
+});
+var loadWatchGroups = async (file, configured) => {
+  let saved = existsSync(file) ? watchGroupsSchema.parse(JSON.parse(await readFile(file, "utf8"))).groups : {};
+  const groups = () => ({ groups: { ...configured, ...saved } });
+  return {
+    groups,
+    save: async ({ groups: next }) => {
+      saved = Object.fromEntries(Object.entries(next).filter(([name, paths]) => !isDeepStrictEqual(configured[name], paths)));
+      await mkdir(dirname(file), { recursive: true });
+      await writeFile(file, JSON.stringify({ groups: saved }, null, 2));
+      return groups();
+    }
+  };
+};
+
+// packages/debug/src/debugger.ts
+class DebugError extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+var pullMs = 1000;
+var buildCheckMs = 1e4;
+var hardwareMs = 5000;
+var detailedJobs = 16;
+var requestsRemembered = 1000;
+var requestTrace = z2.object({
+  seq: z2.number().int(),
+  service: z2.string(),
+  job: z2.number().int().optional(),
+  sequence: z2.number().int().optional(),
+  startedAt: z2.string(),
+  durationMs: z2.number().optional(),
+  status: z2.enum(["pending", "ok", "error", "timeout"]),
+  httpStatus: z2.number().int().optional(),
+  error: z2.string().optional(),
+  input: z2.unknown().optional(),
+  output: z2.unknown().optional()
+});
+var requestsReply = z2.object({ requests: z2.array(requestTrace), latest: z2.number().int() });
+var telemetryReply = z2.object({
+  batches: z2.array(telemetryBatch.extend({ seq: z2.number().int(), receivedAt: z2.string() })),
+  latest: z2.number().int()
+});
+var message = (error) => error instanceof Error ? error.message : String(error);
+var createShown = () => {
+  const counts = new Map;
+  return {
+    has: (key) => counts.has(key),
+    add: (keys) => {
+      for (const key of keys)
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      return () => {
+        for (const key of keys) {
+          const count = counts.get(key) - 1;
+          if (count)
+            counts.set(key, count);
+          else
+            counts.delete(key);
+        }
+      };
+    }
+  };
+};
+var createDebugger = async (options) => {
+  const { manifest, adapter } = options;
+  const paths = createPaths(manifest);
+  const trace = createTraceDecoder(manifest, paths);
+  const telemetry = createTelemetryFollower(manifest);
+  const timeline = createTimeline();
+  const watchGroups = await loadWatchGroups(join(options.stateDirectory, "watch.json"), options.watch);
+  const listeners = new Set;
+  const controller = new AbortController;
+  const { signal } = controller;
+  let controllerBuild = null;
+  const emit = (message) => {
+    for (const listener of listeners)
+      listener(message);
+  };
+  const record = (entry) => {
+    timeline.add(entry);
+    emit({ event: "timeline", data: entry });
+  };
+  for (const entry of options.timeline ?? [])
+    timeline.add(entry);
+  const session = () => ({
+    build: {
+      manifest: manifest.build.id,
+      controller: controllerBuild,
+      matches: controllerBuild === manifest.build.id
+    },
+    connection: { ...adapter.connection(), endpoint: adapter.endpoint },
+    reading: { method: adapter.method, intervalMs: adapter.samplingMs },
+    tasks: telemetry.tasks(),
+    clock: telemetry.clock(),
+    ...options.release && { release: options.release },
+    ...options.projectRoot && { projectRoot: options.projectRoot }
+  });
+  const setBuild = (build) => {
+    if (build === controllerBuild)
+      return;
+    controllerBuild = build;
+    emit({ event: "session", data: session() });
+  };
+  const unavailable = (path, status) => ({
+    path,
+    value: null,
+    quality: "unavailable",
+    status,
+    receivedAt: new Date().toISOString()
+  });
+  const locate = (path) => {
+    const resolved = paths.resolve(path);
+    if (!resolved)
+      return unavailable(path, "Unknown path");
+    if (resolved.kind === "constant")
+      return {
+        path,
+        value: resolved.value,
+        quality: "good",
+        status: "Constant",
+        receivedAt: new Date().toISOString()
+      };
+    if (!resolved.readable)
+      return unavailable(path, "Not readable");
+    return resolved;
+  };
+  const targetRead = ({ target, type }) => ({
+    target,
+    type: paths.typeOf(type)
+  });
+  const sampleOf = (path, type, sample) => ({
+    path,
+    ...sample,
+    value: paths.decode(type, sample.value)
+  });
+  const watch = (patterns, listener) => {
+    const watched = new Map;
+    const reads = [];
+    for (const path of paths.expand(patterns)) {
+      const located = locate(path);
+      if (!("target" in located)) {
+        listener(located);
+        continue;
+      }
+      if (!watched.has(located.target))
+        reads.push(targetRead(located));
+      watched.set(located.target, [...watched.get(located.target) ?? [], { path, ...located }]);
+    }
+    if (!reads.length)
+      return () => {};
+    return adapter.subscribe(reads, (target, received) => {
+      for (const { path, type } of watched.get(target) ?? [])
+        listener(sampleOf(path, type, received));
+    });
+  };
+  const values = async (patterns) => {
+    const connection = adapter.connection();
+    if (connection.state !== "connected")
+      throw new DebugError(connection.error ?? "The controller is not connected", 503);
+    const located = paths.expand(patterns).map((path) => ({ path, located: locate(path) }));
+    const read = await adapter.read(located.flatMap(({ located }) => ("target" in located) ? [targetRead(located)] : []));
+    return located.map(({ path, located }) => {
+      if (!("target" in located))
+        return located;
+      const sample = read.get(located.target);
+      return sample ? sampleOf(path, located.type, sample) : unavailable(path, "Not read");
+    });
+  };
+  const stopBuild = adapter.subscribe([{ target: manifest.build.target, type: { kind: "scalar", iec: "STRING" } }], (_, sample) => {
+    if (sample.quality === "good" && typeof sample.value === "string")
+      setBuild(sample.value);
+  }, buildCheckMs);
+  const latest = new Map;
+  const traced = new Map;
+  const failures = new Map;
+  const requests = new Map;
+  let unread = new Set;
+  const shownJobs = createShown();
+  const shownHealth = createShown();
+  const shownDevices = createShown();
+  const sent = new Map;
+  const jobOf = (job) => jobState(job, {
+    value: (target) => latest.get(target),
+    traced: traced.get(job.id),
+    failure: failures.get(job.id),
+    unread: unread.has(job.id),
+    clock: telemetry.clock(),
+    now: Date.now(),
+    request: ({ job, service, sequence }) => requests.get(`${job}:${service}:${sequence}`)
+  });
+  const deviceOf = (id) => deviceState(manifest.devices.find((device) => device.id === id), manifest.io, (target) => latest.get(target));
+  const send = (key, message) => {
+    const json = JSON.stringify(message.data);
+    if (sent.get(key) === json)
+      return;
+    sent.set(key, json);
+    emit(message);
+  };
+  const updateJob = (job) => send(`job:${job.id}`, { event: "job", data: jobOf(job) });
+  const updateDevice = (id) => send(`device:${id}`, { event: "device", data: deviceOf(id) });
+  const reader = (intervalMs, update) => {
+    let current = { key: "", stop: () => {} };
+    return (reads) => {
+      const key = reads.map(({ read }) => read.target).join(`
+`);
+      if (key === current.key)
+        return;
+      current.stop();
+      const owners = new Map;
+      for (const { owner, read } of reads)
+        owners.set(read.target, [...owners.get(read.target) ?? [], owner]);
+      current = {
+        key,
+        stop: reads.length ? adapter.subscribe([...new Map(reads.map(({ read }) => [read.target, read])).values()], (target, sample) => {
+          latest.set(target, sample);
+          for (const owner of owners.get(target) ?? [])
+            update(owner);
+          schedule();
+        }, intervalMs) : () => {}
+      };
+    };
+  };
+  const readJobs = reader(adapter.samplingMs, updateJob);
+  const readDevices = reader(hardwareMs, updateDevice);
+  const plan = () => {
+    const shown = manifest.jobs.filter((job) => shownJobs.has(job.id));
+    const busy = shown.filter((job) => busyOf(job, (target) => latest.get(target), traced.get(job.id)));
+    unread = new Set(busy.slice(detailedJobs).map(({ id }) => id));
+    readJobs([
+      ...shown.map((job) => ({ owner: job, read: busyRead(job) })),
+      ...busy.slice(0, detailedJobs).flatMap((job) => detailReads(job).map((read) => ({ owner: job, read })))
+    ]);
+    readDevices(manifest.devices.flatMap((device) => (shownDevices.has(device.id) ? deviceReads(device, manifest.io, paths.typeOf) : shownHealth.has(device.id) ? healthReads(device) : []).map((read) => ({ owner: device.id, read }))));
+  };
+  let planned = false;
+  const schedule = () => {
+    if (planned)
+      return;
+    planned = true;
+    queueMicrotask(() => {
+      planned = false;
+      plan();
+    });
+  };
+  const show = (interest) => {
+    const stops = [
+      shownJobs.add(interest.jobs),
+      shownHealth.add(interest.health),
+      shownDevices.add(interest.devices)
+    ];
+    schedule();
+    return () => {
+      for (const stop of stops)
+        stop();
+      schedule();
+    };
+  };
+  const receive = ({ build, task, sequence, at, record: received }) => {
+    if (received.kind === "trace") {
+      if (build !== manifest.build.id)
+        return;
+      const event = trace.decode(received, task, sequence);
+      if (event)
+        record(timelineEntries.trace(at, event));
+      const site = trace.job(received);
+      if (!site)
+        return;
+      const startedAt = site.started ? at : traced.get(site.job.id)?.startedAt;
+      traced.set(site.job.id, { busy: site.started, ...startedAt && { startedAt } });
+      updateJob(site.job);
+      schedule();
+      return;
+    }
+    record(timelineEntries.app(at, task, sequence, received));
+    if (received.kind !== "exception" || received.handled)
+      return;
+    const job = manifest.jobs.find(({ name, instance }) => name === received.function && instance === received.instance);
+    if (!job)
+      return;
+    failures.set(job.id, {
+      at,
+      code: received.code,
+      ...received.name && { name: received.name },
+      source: received.source
+    });
+    updateJob(job);
+  };
+  const pull = async (url, token) => {
+    const response = await fetch(url, { headers: { authorization: `Bearer ${token}` }, signal });
+    if (!response.ok)
+      throw new Error(`The server answered ${response.status}`);
+    return response.json();
+  };
+  const pullTelemetry = async ({ url, token }) => {
+    const reply = telemetryReply.parse(await pull(new URL(`/tsplc/telemetry?since=${telemetry.since()}`, url), token));
+    const received = telemetry.accept(reply);
+    for (const item of received)
+      receive(item);
+    const build = telemetry.build();
+    if (build)
+      setBuild(build);
+    if (reply.batches.length)
+      emit({ event: "session", data: session() });
+  };
+  const pullRequests = ({ url, token }) => {
+    let newest = 0;
+    const pending = new Map;
+    return async () => {
+      const since = pending.size ? Math.min(...pending.keys()) - 1 : newest;
+      const body = requestsReply.parse(await pull(new URL(`/tsplc/debug/requests?since=${since}`, url), token));
+      if (body.latest < newest) {
+        newest = 0;
+        pending.clear();
+        return;
+      }
+      const oldest = body.requests[0]?.seq;
+      if (oldest !== undefined) {
+        for (const seq of pending.keys())
+          if (seq < oldest)
+            pending.delete(seq);
+      }
+      for (const request of body.requests) {
+        const waiting = pending.get(request.seq);
+        if (waiting && request.status === "pending")
+          continue;
+        if (!waiting && request.seq <= newest)
+          continue;
+        const entry = waiting ?? timelineEntries.request(request);
+        entry.request = request;
+        newest = Math.max(newest, request.seq);
+        if (request.status === "pending")
+          pending.set(request.seq, entry);
+        else
+          pending.delete(request.seq);
+        if (!waiting)
+          timeline.add(entry);
+        emit({ event: "request", data: request });
+        emit({ event: "timeline", data: entry });
+        if (request.job === undefined || request.sequence === undefined)
+          continue;
+        requests.set(`${request.job}:${request.service}:${request.sequence}`, request);
+        for (const key of [...requests.keys()].slice(0, -requestsRemembered))
+          requests.delete(key);
+        const job = manifest.jobs.find(({ id }) => id === request.job);
+        if (job)
+          updateJob(job);
+      }
+    };
+  };
+  const stopConnection = adapter.onConnection((connection) => {
+    record(timelineEntries.connection(connection.since, connection.state, connection.error));
+    emit({ event: "session", data: session() });
+    if (connection.state !== "connected") {
+      for (const [target, sample] of latest)
+        latest.set(target, {
+          ...sample,
+          quality: "unavailable",
+          status: connection.error ?? "The controller is not connected"
+        });
+      for (const job of manifest.jobs)
+        updateJob(job);
+      for (const device of manifest.devices)
+        updateDevice(device.id);
+    }
+  });
+  const repeat = async (name, intervalMs, work) => {
+    let failure;
+    while (!signal.aborted) {
+      try {
+        await work();
+        failure = undefined;
+      } catch (error) {
+        if (signal.aborted)
+          return;
+        if (message(error) !== failure)
+          options.log(`${name} failed: ${message(error)}`);
+        failure = message(error);
+      }
+      await delay(intervalMs, undefined, { signal }).catch(() => {
+        return;
+      });
+    }
+  };
+  const { server } = options;
+  const running = server ? [
+    repeat("Reading the server's telemetry", pullMs, () => pullTelemetry(server)),
+    repeat("Reading the server's requests", pullMs, pullRequests(server))
+  ] : [];
+  return {
+    manifest,
+    paths,
+    session,
+    values,
+    jobs: () => manifest.jobs.map(jobOf),
+    hardware: () => manifest.devices.map(({ id }) => deviceOf(id)),
+    timeline: (since) => timeline.since(since),
+    watchGroups: () => watchGroups.groups(),
+    saveWatchGroups: (groups) => watchGroups.save(groups),
+    record,
+    watch,
+    show,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    close: async () => {
+      controller.abort();
+      stopBuild();
+      readJobs([]);
+      readDevices([]);
+      stopConnection();
+      await Promise.all(running);
+      await adapter.close();
+    }
+  };
+};
+// packages/debug/src/http.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { z as z4 } from "zod";
+
+// packages/debug/src/manifest.ts
+import { z as z3 } from "zod";
+var sourceRange = z3.object({
+  file: z3.number().int(),
+  line: z3.number().int(),
+  column: z3.number().int(),
+  endLine: z3.number().int(),
+  endColumn: z3.number().int()
+});
+var json = z3.lazy(() => z3.union([
+  z3.string(),
+  z3.number(),
+  z3.boolean(),
+  z3.null(),
+  z3.array(json),
+  z3.record(z3.string(), json)
+]));
+var debugField = z3.object({
+  name: z3.string(),
+  target: z3.string(),
+  type: z3.string(),
+  declaration: sourceRange.optional(),
+  generated: z3.literal(true).optional()
+});
+var debugType = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("scalar"), iec: z3.string() }),
+  z3.object({
+    kind: z3.literal("enum"),
+    name: z3.string(),
+    members: z3.record(z3.string(), z3.number().int())
+  }),
+  z3.object({
+    kind: z3.literal("record"),
+    name: z3.string(),
+    declaration: sourceRange.optional(),
+    fields: z3.array(debugField)
+  }),
+  z3.object({
+    kind: z3.literal("array"),
+    element: z3.string(),
+    length: z3.number().int(),
+    lower: z3.number().int()
+  })
+]);
+var debugRoot = z3.object({
+  path: z3.string(),
+  target: z3.string(),
+  type: z3.string(),
+  declaration: sourceRange.optional(),
+  readable: z3.boolean(),
+  generated: z3.literal(true).optional()
+});
+var debugConstant = z3.object({
+  path: z3.string(),
+  type: z3.string(),
+  value: json,
+  declaration: sourceRange.optional()
+});
+var debugIo = z3.object({
+  path: z3.string(),
+  target: z3.string(),
+  direction: z3.enum(["input", "output"]),
+  type: z3.string(),
+  device: z3.string().optional(),
+  channel: z3.string().optional(),
+  address: z3.string().optional(),
+  inverted: z3.literal(true).optional(),
+  shared: z3.literal(true).optional()
+});
+var debugChannel = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  direction: z3.enum(["input", "output"]),
+  type: z3.string(),
+  offsetBits: z3.number().int(),
+  bits: z3.number().int(),
+  address: z3.string().optional(),
+  unit: z3.string().optional(),
+  description: z3.string().optional()
+});
+var debugDevice = z3.object({
+  id: z3.string(),
+  product: z3.string().optional(),
+  vendor: z3.string().optional(),
+  productCode: z3.string().optional(),
+  network: z3.object({ address: z3.string(), rpiMs: z3.number().optional() }).optional(),
+  connection: z3.string().optional(),
+  assemblies: z3.array(z3.object({
+    direction: z3.enum(["input", "output"]),
+    bytes: z3.number().int(),
+    address: z3.string().optional(),
+    raw: z3.string().optional()
+  })),
+  health: z3.object({
+    state: z3.string().optional(),
+    states: z3.record(z3.string(), z3.number().int()).optional(),
+    diagnostic: z3.string().optional(),
+    message: z3.string().optional()
+  }).optional(),
+  status: z3.record(z3.string(), z3.string()).optional(),
+  channels: z3.array(debugChannel)
+});
+var debugFunction = z3.object({
+  id: z3.number().int(),
+  name: z3.string(),
+  declaration: sourceRange,
+  instance: z3.string().optional(),
+  task: z3.string().optional(),
+  target: z3.string(),
+  reads: z3.array(z3.object({ range: sourceRange, path: z3.string() }))
+});
+var debugJob = z3.object({
+  id: z3.number().int(),
+  name: z3.string(),
+  declaration: sourceRange,
+  instance: z3.string().optional(),
+  target: z3.string(),
+  steps: z3.array(z3.object({
+    step: z3.number().int(),
+    kind: z3.enum(["await", "return", "throw", "statement"]),
+    range: sourceRange,
+    text: z3.string()
+  })),
+  startedAt: z3.string().optional(),
+  requests: z3.array(z3.object({
+    service: z3.string(),
+    target: z3.string(),
+    sequence: z3.string(),
+    job: z3.number().int().optional()
+  })),
+  generated: z3.literal(true).optional()
+});
+var debugEventSite = z3.object({
+  id: z3.number().int(),
+  kind: z3.enum(["state", "decision", "job"]),
+  job: z3.number().int().optional(),
+  phase: z3.enum(["started", "finished"]).optional(),
+  path: z3.string(),
+  function: z3.number().int().optional(),
+  type: z3.string(),
+  range: sourceRange,
+  text: z3.string(),
+  task: z3.string(),
+  operands: z3.array(z3.object({
+    text: z3.string(),
+    range: sourceRange,
+    type: z3.string(),
+    path: z3.string().optional(),
+    stable: z3.boolean()
+  }))
+});
+var debugWriter = z3.object({
+  output: z3.string(),
+  target: z3.string(),
+  sites: z3.array(z3.object({ id: z3.number().int(), range: sourceRange, function: z3.number().int() }))
+});
+var debugTask = z3.object({
+  name: z3.string(),
+  intervalMs: z3.number(),
+  priority: z3.number().int()
+});
+var debugManifest = z3.object({
+  kind: z3.literal("tsplc-debug"),
+  version: z3.literal(1),
+  build: z3.object({
+    id: z3.string(),
+    target: z3.string(),
+    compiler: z3.string()
+  }),
+  sources: z3.array(z3.string()),
+  types: z3.record(z3.string(), debugType),
+  roots: z3.array(debugRoot),
+  constants: z3.array(debugConstant),
+  io: z3.array(debugIo),
+  devices: z3.array(debugDevice),
+  functions: z3.array(debugFunction),
+  jobs: z3.array(debugJob),
+  events: z3.array(debugEventSite),
+  writers: z3.array(debugWriter),
+  tasks: z3.array(debugTask),
+  errors: z3.record(z3.string(), z3.string())
+});
+
+// packages/debug/src/ui/index.ts
+import { createRequire } from "node:module";
+import { dirname as dirname2, resolve } from "node:path";
+
+// packages/debug/src/ui/page.ts
+var css = `
+:root{color-scheme:dark;
+--bg:#0c0e11;--grid:rgba(255,255,255,.025);--panel:#13161b;--panel-2:#191d23;--line:#262b33;--line-soft:#1d2128;
+--fg:#d8dce2;--dim:#7c848f;--accent:#f2a33a;--link:#79c0ff;
+--live:#5ee0a0;--uncertain:#f3c64a;--bad:#ff6b6b;--stale:#8a919b;--unavailable:#5a616b;--constant:#b8a2ff;
+--hatch:rgba(138,145,155,.16);
+--mono:"JetBrains Mono","Cascadia Mono","IBM Plex Mono","SF Mono",Menlo,Consolas,monospace;
+--sans:"IBM Plex Sans","Segoe UI Variable Text","Segoe UI","Helvetica Neue",sans-serif}
+@media (prefers-color-scheme:light){:root{color-scheme:light;
+--bg:#f3f1ec;--grid:rgba(0,0,0,.035);--panel:#fffefb;--panel-2:#f6f4ef;--line:#d8d3c8;--line-soft:#e7e3da;
+--fg:#1b1e22;--dim:#6a6e75;--accent:#b5650a;--link:#0a5bb0;
+--live:#0d8048;--uncertain:#9a6400;--bad:#c42525;--stale:#767b83;--unavailable:#a1a6ad;--constant:#6447cc;
+--hatch:rgba(118,123,131,.16)}}
+*{box-sizing:border-box}
+html,body{height:100%}
+body{margin:0;font:13px/1.45 var(--sans);color:var(--fg);background:var(--bg);
+background-image:linear-gradient(var(--grid) 1px,transparent 1px),linear-gradient(90deg,var(--grid) 1px,transparent 1px);
+background-size:24px 24px;display:grid;grid-template-rows:auto minmax(0,1fr);font-variant-numeric:tabular-nums}
+a{color:var(--link);text-decoration:none}a:hover{text-decoration:underline}
+code,.mono,.path,.src{font-family:var(--mono);font-size:12px}
+.src,.nowrap,.grid td.num{white-space:nowrap}
+code{color:var(--fg);background:var(--panel-2);border:1px solid var(--line-soft);border-radius:3px;padding:0 4px}
+.dim,.hint,.empty{color:var(--dim)}.hint{margin:4px 0 12px}.empty{margin:8px 0;font-style:italic}
+.err{color:var(--bad)}.num{text-align:right}
+button,input{font:inherit;color:inherit}
+button{background:var(--panel-2);border:1px solid var(--line);border-radius:4px;padding:3px 10px;cursor:pointer}
+button:hover{border-color:var(--dim)}button.primary{background:var(--accent);border-color:var(--accent);color:#16110a;font-weight:600}
+button:disabled{opacity:.5;cursor:default}
+input{background:var(--panel);border:1px solid var(--line);border-radius:4px;padding:4px 8px}
+input:focus,button:focus-visible,.vlist:focus-visible{outline:1px solid var(--accent);outline-offset:1px}
+h1{font:600 18px var(--sans);margin:0 0 12px;letter-spacing:-.01em}
+h2{font:600 10.5px var(--sans);text-transform:uppercase;letter-spacing:.14em;color:var(--dim);margin:0 0 10px}
+h2 a{color:inherit}h3{font:600 12px var(--sans);margin:14px 0 6px}
+
+header{background:var(--panel);border-top:2px solid var(--accent);border-bottom:1px solid var(--line)}
+.bar{display:flex;align-items:stretch;gap:0;overflow-x:auto}
+.brand{display:flex;align-items:center;gap:6px;padding:8px 16px;border-right:1px solid var(--line);white-space:nowrap}
+.brand b{font:700 13px var(--mono);letter-spacing:.04em}.brand span{font:500 13px var(--mono);color:var(--accent)}
+.brand .ro{font:600 9.5px var(--sans);letter-spacing:.14em;text-transform:uppercase;color:var(--dim);border:1px solid var(--line);border-radius:3px;padding:1px 5px;margin-left:6px}
+.readouts{display:flex;flex:1}
+.readout{display:flex;flex-direction:column;justify-content:center;padding:6px 14px;border-right:1px solid var(--line-soft);white-space:nowrap}
+.readout .label{font:600 9px var(--sans);letter-spacing:.16em;text-transform:uppercase;color:var(--dim)}
+.readout .reading{font:12px var(--mono);display:flex;align-items:center;gap:8px}
+.build.match i{color:var(--live);font-style:normal}.build.mismatch{color:var(--bad)}.build.mismatch i{font-style:normal;font-weight:700}
+.task b{color:var(--fg);font-weight:600}
+.dot{width:8px;height:8px;border-radius:50%;display:inline-block;background:var(--unavailable)}
+.dot.c-connected{background:var(--live);box-shadow:0 0 6px var(--live)}.dot.c-lost,.dot.c-failed{background:var(--bad)}.dot.c-unavailable{background:var(--uncertain)}
+.dot.c-connecting{background:var(--uncertain);animation:pulse 1s infinite alternate}
+@keyframes pulse{to{opacity:.3}}
+nav{display:flex;gap:2px;padding:0 10px;border-top:1px solid var(--line-soft)}
+nav a{color:var(--dim);padding:7px 12px 6px;text-transform:capitalize;border-bottom:2px solid transparent;font-weight:500}
+nav a:hover{color:var(--fg);text-decoration:none}nav a.on{color:var(--fg);border-bottom-color:var(--accent)}
+.banner{padding:7px 16px;font-weight:600;display:flex;gap:12px;align-items:center}
+.banner.danger{background:var(--bad);color:#fff}
+.banner.warn{background:repeating-linear-gradient(135deg,var(--uncertain) 0 14px,color-mix(in srgb,var(--uncertain) 85%,#000) 14px 28px);color:#1b1404}
+.banner.error{background:var(--panel-2);color:var(--bad);border-top:1px solid var(--bad)}
+.banner button{margin-left:auto}
+
+main{overflow:auto;min-height:0}
+.page{padding:16px 18px 28px;animation:enter .18s ease-out}
+@keyframes enter{from{opacity:0;transform:translateY(3px)}}
+.panel{background:var(--panel);border:1px solid var(--line);border-radius:6px;padding:12px 14px}
+.toolbar{display:flex;flex-wrap:wrap;gap:10px;align-items:center;margin-bottom:10px}
+.check{display:inline-flex;gap:5px;align-items:center;color:var(--dim);cursor:pointer}.check input{margin:0}
+.sep{margin-left:8px}.count{color:var(--dim);font:12px var(--mono);margin-left:auto}
+.tabs{display:flex;flex-wrap:wrap;gap:4px;margin-bottom:10px;align-items:center}
+.tab{background:transparent}.tab.on{border-color:var(--accent);color:var(--fg)}
+.tab .n{color:var(--dim);margin-left:6px;font:11px var(--mono)}
+.tag{font:600 9.5px var(--sans);letter-spacing:.08em;text-transform:uppercase;color:var(--dim);border:1px solid var(--line);border-radius:3px;padding:0 4px;margin:0 4px}
+dl{display:grid;grid-template-columns:max-content 1fr;gap:3px 14px;margin:0}dt{color:var(--dim)}dd{margin:0;min-width:0;overflow-wrap:anywhere}
+.facts{margin-bottom:14px}.readings dd{display:flex;gap:8px;align-items:baseline}
+.crumbs{color:var(--dim);margin-bottom:4px}
+
+table.grid{width:100%;border-collapse:collapse;background:var(--panel);border:1px solid var(--line);border-radius:6px}
+.grid th{font:600 9.5px var(--sans);letter-spacing:.14em;text-transform:uppercase;color:var(--dim);text-align:left;padding:7px 10px;border-bottom:1px solid var(--line);position:sticky;top:0;background:var(--panel)}
+.grid td{padding:6px 10px;border-bottom:1px solid var(--line-soft);vertical-align:top}
+.grid tr:last-child td{border-bottom:0}.link-row{cursor:pointer}.link-row:hover td{background:var(--panel-2)}
+tr.highlight td{background:color-mix(in srgb,var(--accent) 12%,transparent)}
+
+.value{font:12.5px var(--mono);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.meta{font:11px var(--mono);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.meta::before{display:inline-block;width:1.4ch}
+.s-live{color:var(--live)}.meta.s-live::before{content:"●"}
+.s-uncertain{color:var(--uncertain)}.value.s-uncertain{text-decoration:underline dotted}.meta.s-uncertain::before{content:"◐"}
+.s-bad{color:var(--bad)}.value.s-bad{text-decoration:line-through}.meta.s-bad::before{content:"✕"}
+.s-stale{color:var(--stale)}.value.s-stale{background:repeating-linear-gradient(135deg,transparent 0 4px,var(--hatch) 4px 8px)}.meta.s-stale::before{content:"○"}
+.s-unavailable{color:var(--unavailable)}.meta.s-unavailable::before{content:"–"}
+.s-constant{color:var(--constant)}.value.s-constant{font-style:italic}.meta.s-constant::before{content:"◆"}
+.s-group{color:var(--dim)}
+
+.variables{height:100%;display:flex;flex-direction:column;padding-bottom:12px}
+.search{flex:1;min-width:280px;max-width:640px;font-family:var(--mono);font-size:12.5px;padding:6px 10px}
+.split{flex:1;min-height:0;display:grid;grid-template-columns:minmax(0,1fr) 380px;gap:12px}
+.listwrap{display:flex;flex-direction:column;min-height:0;background:var(--panel);border:1px solid var(--line);border-radius:6px;overflow:hidden}
+.vlist{flex:1;overflow:auto;position:relative;outline:none}
+.vspacer{position:relative}.vwindow{position:absolute;left:0;right:0;top:0}
+.row{display:grid;grid-template-columns:minmax(220px,1fr) minmax(90px,15ch) 21ch 17ch 40px minmax(110px,19ch);gap:8px;align-items:center;height:26px;padding-right:10px;border-bottom:1px solid var(--line-soft);cursor:default}
+.row:hover{background:var(--panel-2)}.row.selected{background:color-mix(in srgb,var(--accent) 13%,transparent);box-shadow:inset 2px 0 0 var(--accent)}
+.row.head{font:600 9.5px var(--sans);letter-spacing:.14em;text-transform:uppercase;color:var(--dim);border-bottom:1px solid var(--line);padding-left:10px}
+.row.generated .name{opacity:.7}
+.name{font:12.5px var(--mono);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;display:flex;align-items:center}
+.name mark{background:color-mix(in srgb,var(--accent) 35%,transparent);color:inherit;border-radius:2px}
+.twisty{display:inline-grid;place-items:center;width:18px;height:18px;flex:none;padding:0;border:0;background:none;color:var(--dim);font-size:10px}
+.type{font:11.5px var(--mono);color:var(--dim);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.row .src{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-size:11px}
+.rec{padding:0;width:22px;height:18px;border:1px solid transparent;background:none;color:var(--line);font-size:11px}
+.rec:hover{color:var(--dim);border-color:var(--line)}.rec.on{color:var(--bad)}.rec.elsewhere{color:var(--dim)}
+.side{display:flex;flex-direction:column;gap:12px;overflow:auto;min-height:0}
+.detail-path{font-size:12.5px;overflow-wrap:anywhere;margin-bottom:8px;color:var(--fg)}
+.detail-value{display:flex;gap:12px;align-items:baseline;margin-bottom:10px;padding:8px 10px;background:var(--panel-2);border-radius:4px}
+.detail-value .value{font-size:20px}.detail .site{margin:3px 0}.detail button{margin-top:10px}
+.member{display:grid;grid-template-columns:minmax(0,1fr) auto auto 22px;gap:8px;align-items:center;padding:3px 0;border-bottom:1px solid var(--line-soft)}
+.member .path{font-size:11.5px}.remove{padding:0 5px;border:0;background:none;color:var(--dim)}
+.groups form input{width:110px;padding:2px 6px}
+
+.badge{display:inline-block;font:600 10.5px var(--mono);letter-spacing:.04em;padding:1px 7px;border-radius:3px;border:1px solid;text-transform:uppercase}
+.h-ok{color:var(--live);border-color:var(--live)}
+.h-fault{color:#fff;background:var(--bad);border-color:var(--bad)}
+.h-stale{color:var(--stale);border-color:var(--stale);background:repeating-linear-gradient(135deg,transparent 0 4px,var(--hatch) 4px 8px)}
+.h-unknown{color:var(--dim);border-color:var(--dim);border-style:dashed}
+.st{font:600 11px var(--mono);text-transform:lowercase}
+.st-busy,.st-pending,.st-connecting,.st-cancelling{color:var(--uncertain)}
+.st-failed,.st-error,.st-timeout,.st-lost{color:var(--bad)}.st-unavailable{color:var(--uncertain)}
+.st-done,.st-ok,.st-connected{color:var(--live)}.st-idle,.st-unknown{color:var(--dim)}
+.await code{white-space:pre-wrap}
+
+.overview{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px;align-items:start}
+.overview .wide{grid-column:1/-1}
+.overview>*{animation:enter .25s ease-out backwards}.overview>:nth-child(2){animation-delay:.04s}.overview>:nth-child(3){animation-delay:.08s}.overview>:nth-child(4){animation-delay:.12s}
+.counts{display:grid;grid-template-columns:repeat(4,1fr);gap:8px;margin-bottom:10px}
+.count-box{border:1px solid;border-radius:5px;padding:6px 10px;display:flex;flex-direction:column}
+.count-box b{font:600 22px var(--mono)}.count-box span{font:600 9.5px var(--sans);letter-spacing:.14em;text-transform:uppercase}
+.count-box.h-fault{background:color-mix(in srgb,var(--bad) 12%,transparent);color:var(--bad)}
+.device-line{padding:3px 0}
+
+.assemblies{display:flex;flex-direction:column;gap:12px;margin-bottom:18px}
+.assembly h3{margin:0 0 10px}
+.bitgrid{display:grid;grid-template-columns:4ch repeat(8,52px) 4ch minmax(0,1fr);gap:3px;align-items:stretch}
+.bh{font:600 9.5px var(--mono);color:var(--dim);text-align:center;letter-spacing:.06em}.legend-head{text-align:left;padding-left:6px}
+.byte,.hex{font-size:11.5px;color:var(--dim);align-self:center}
+.bit{position:relative;height:34px;display:flex;flex-direction:column;align-items:center;justify-content:center;font:600 13px var(--mono);
+border:1px dashed var(--line);border-radius:3px;color:var(--unavailable)}
+.bit small{font:9px var(--mono);color:var(--dim);max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:0 2px}
+.bit.mapped{border-style:solid;color:var(--dim);background:var(--panel-2)}
+.bit.on{color:var(--fg)}
+.bit.mapped.on{color:var(--live);background:color-mix(in srgb,var(--live) 16%,transparent);border-color:color-mix(in srgb,var(--live) 60%,transparent);box-shadow:0 0 8px color-mix(in srgb,var(--live) 25%,transparent)}
+.bit.none{color:var(--unavailable)}
+.q-stale .bit,.q-uncertain .bit,.q-bad .bit{background-image:repeating-linear-gradient(135deg,transparent 0 4px,var(--hatch) 4px 8px)}
+.q-stale .bit.on,.q-bad .bit.on{color:var(--stale);box-shadow:none;border-color:var(--line)}
+.legend{display:flex;flex-wrap:wrap;gap:4px 12px;align-items:center;font-size:11.5px;padding-left:6px}
+.legend-item{display:inline-flex;gap:6px;align-items:baseline}.legend-item b{font:600 11px var(--mono)}
+.mapped-path{display:flex;flex-wrap:wrap;gap:4px 10px;align-items:baseline}
+
+.recent .entries{display:flex;flex-direction:column;background:var(--panel);border:1px solid var(--line);border-radius:6px}
+.entry{display:grid;grid-template-columns:14ch 9ch minmax(0,1fr);gap:10px;padding:7px 12px;border-bottom:1px solid var(--line-soft)}
+.overview .entry{padding:6px 0}
+.when{color:var(--dim);font-size:11.5px}.approx{color:var(--uncertain);margin-left:4px;cursor:help}
+.source{font:600 9.5px var(--sans);letter-spacing:.12em;text-transform:uppercase;padding-top:2px}
+.src-plc{color:var(--accent)}.src-server{color:var(--link)}.src-agent{color:var(--constant)}.src-debugger{color:var(--dim)}
+.body>div{margin:1px 0}.val{font:600 12.5px var(--mono)}
+.chips{display:flex;flex-wrap:wrap;gap:5px;align-items:center;margin-top:3px}
+.chip{display:inline-flex;align-items:baseline;gap:3px;font:11.5px var(--mono);border:1px solid var(--line);border-radius:10px;padding:0 8px;background:var(--panel-2)}
+.chip.unstable{border-style:dashed}
+.tag.lvl-info{color:var(--link);border-color:var(--link)}.tag.lvl-warn{color:var(--uncertain);border-color:var(--uncertain)}.tag.lvl-error{color:var(--bad);border-color:var(--bad)}
+.recent>button{margin-top:10px}
+
+.fatal{padding:40px;max-width:720px}.fatal h1{color:var(--bad)}
+@media (max-width:1100px){.split{grid-template-columns:minmax(0,1fr)}.side{max-height:40vh}.overview{grid-template-columns:minmax(0,1fr)}}
+`;
+var html = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>tsPLC debug</title><link rel="icon" href="data:,">
+<script>if(!location.pathname.endsWith("/"))location.replace(location.pathname+"/"+location.search+location.hash)</script>
+<style>${css}</style></head>
+<body><p class="empty" style="padding:24px">Loading the debugger…</p>
+<script type="module" src="./ui.js"></script></body></html>`;
+
+// packages/debug/src/ui/index.ts
+var ui;
+var build = async () => {
+  const result = await Bun.build({
+    entrypoints: [
+      resolve(dirname2(createRequire(import.meta.url).resolve("@tsplc/debug")), "../src/ui/main.ts")
+    ],
+    target: "browser",
+    minify: true
+  });
+  if (!result.success)
+    throw new AggregateError(result.logs, "Bundling the debugger UI failed");
+  return { html, script: await result.outputs[0].text() };
+};
+var loadUi = () => ui ??= build();
+
+// packages/debug/src/http.ts
+var heartbeatMs = 5000;
+var encoder = new TextEncoder;
+var json2 = (body, status = 200) => Response.json(body, { status, headers: { "Cache-Control": "no-store" } });
+var list = (value) => (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+var loadManifest = async (file) => debugManifest.parse(JSON.parse(await readFile2(file, "utf8")));
+var interest = (search) => {
+  const jobs = list(search.get("jobs")).map(Number);
+  if (!jobs.every(Number.isInteger))
+    throw new DebugError("jobs must be job ids", 400);
+  return {
+    watch: list(search.get("watch")),
+    jobs,
+    health: list(search.get("health")),
+    devices: list(search.get("devices"))
+  };
+};
+var stream = (debug, { watch, ...shown }) => {
+  debug.paths.expand(watch);
+  let stop = () => {};
+  return new Response(new ReadableStream({
+    start: (controller) => {
+      let open = true;
+      const write = (text) => {
+        if (open)
+          controller.enqueue(encoder.encode(text));
+      };
+      const send = ({ event, data }) => write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+      send({ event: "session", data: debug.session() });
+      const latest = new Map;
+      const sendSample = (sample) => {
+        latest.set(sample.path, { sample, sentAt: Date.now() });
+        send({ event: "sample", data: sample });
+      };
+      const unsubscribe = debug.subscribe(send);
+      const unwatch = debug.watch(watch, sendSample);
+      const unshow = debug.show(shown);
+      const heartbeat = setInterval(() => write(`: keepalive
+
+`), heartbeatMs);
+      const { intervalMs } = debug.session().reading;
+      const refresh = setInterval(() => {
+        if (debug.session().connection.state !== "connected")
+          return;
+        const now = Date.now();
+        for (const { sample, sentAt } of latest.values())
+          if (now - sentAt >= intervalMs)
+            sendSample({ ...sample, receivedAt: new Date(now).toISOString() });
+      }, intervalMs);
+      stop = () => {
+        open = false;
+        clearInterval(heartbeat);
+        clearInterval(refresh);
+        unsubscribe();
+        unwatch();
+        unshow();
+      };
+    },
+    cancel: () => stop()
+  }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-store" } });
+};
+var createDebugHandler = (debug, log) => async (request, route) => {
+  const { searchParams } = new URL(request.url);
+  const key = `${request.method} ${route}`;
+  try {
+    switch (key) {
+      case "GET /":
+        return new Response((await loadUi()).html, {
+          headers: { "Content-Type": "text/html; charset=utf-8" }
+        });
+      case "GET /ui.js":
+        return new Response((await loadUi()).script, {
+          headers: { "Content-Type": "text/javascript; charset=utf-8" }
+        });
+      case "GET /api/session":
+        return json2(debug.session());
+      case "GET /api/manifest":
+        return json2(debug.manifest);
+      case "GET /api/stream":
+        return stream(debug, interest(searchParams));
+      case "GET /api/values":
+        return json2(await debug.values(list(searchParams.get("paths"))));
+      case "GET /api/jobs":
+        return json2(debug.jobs());
+      case "GET /api/hardware":
+        return json2(debug.hardware());
+      case "GET /api/timeline":
+        return json2(debug.timeline(searchParams.get("since") ?? undefined));
+      case "GET /api/watch":
+        return json2(debug.watchGroups());
+      case "PUT /api/watch":
+        return json2(await debug.saveWatchGroups(watchGroupsSchema.parse(await request.json())));
+    }
+    return json2({ error: `No route ${key}` }, 404);
+  } catch (error) {
+    if (error instanceof DebugError)
+      return json2({ error: error.message }, error.status);
+    if (error instanceof RangeError || error instanceof SyntaxError)
+      return json2({ error: error.message }, 400);
+    if (error instanceof z4.ZodError)
+      return json2({ error: z4.prettifyError(error) }, 400);
+    log(`${key} failed: ${error instanceof Error ? error.stack : String(error)}`);
+    return json2({ error: "The debugger failed; see its log" }, 500);
+  }
+};
+var serveDebugger = (debug, options) => {
+  const handle = createDebugHandler(debug, options.log);
+  return Bun.serve({
+    hostname: "127.0.0.1",
+    port: options.port,
+    fetch: (request) => {
+      const host = request.headers.get("host")?.replace(/:\d+$/, "");
+      if (host !== "127.0.0.1" && host !== "localhost")
+        return json2({ error: "Use http://127.0.0.1 or http://localhost" }, 403);
+      return handle(request, new URL(request.url).pathname);
+    }
+  });
+};
+// packages/debug/src/login.ts
+import { setTimeout as delay2 } from "node:timers/promises";
+
+class LoginUnavailable extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.state = options?.state ?? "unavailable";
+  }
+  state;
+}
+var noLogin = "Live values need an engineering login: run `tsplc login`.";
+var retryMs = 5000;
+var integerTypes = new Set([
+  ...["SINT", "INT", "DINT", "LINT", "USINT", "UINT", "UDINT", "ULINT"],
+  ...["BYTE", "WORD", "DWORD", "LWORD"]
+]);
+var timeUnits = {
+  d: 86400000,
+  h: 3600000,
+  m: 60000,
+  s: 1000,
+  ms: 1,
+  us: 0.001,
+  ns: 0.000001
+};
+var typeName = (type) => type.kind === "scalar" ? type.iec : type.kind;
+var message2 = (error) => error instanceof Error ? error.message : String(error);
+var integer = (text) => {
+  const radix = /^(2|8|16)#([0-9a-f_]+)$/i.exec(text);
+  const digits = radix ? radix[2].replaceAll("_", "") : text.replaceAll("_", "");
+  if (!radix && !/^[+-]?\d+$/.test(digits))
+    return;
+  const value = BigInt(radix ? `0${{ 2: "b", 8: "o", 16: "x" }[radix[1]]}${digits}` : digits);
+  return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
+};
+var duration = (text) => {
+  const body = /^L?T(?:IME)?#(-?)(.+)$/i.exec(text);
+  if (!body)
+    return;
+  const parts = [...body[2].replaceAll("_", "").matchAll(/(\d+(?:\.\d+)?)(ms|us|ns|d|h|m|s)/gi)];
+  if (parts.map(([part]) => part).join("") !== body[2].replaceAll("_", ""))
+    return;
+  const ms = parts.reduce((total, [, amount, unit]) => total + Number(amount) * timeUnits[unit.toLowerCase()], 0);
+  return body[1] ? -ms : ms;
+};
+var quoted = (text) => {
+  const body = /^(['"])(.*)\1$/s.exec(text);
+  if (!body)
+    return;
+  return body[2].replace(/\$([0-9a-f]{2}|[$'"lnprt])/gi, (_, code) => {
+    if (code.length === 2)
+      return String.fromCharCode(parseInt(code, 16));
+    const named = { l: `
+`, n: `
+`, p: "\f", r: "\r", t: "\t" };
+    return named[code.toLowerCase()] ?? code;
+  });
+};
+var parseLoginValue = (type, text) => {
+  const trimmed = text.trim();
+  const untyped = trimmed.replace(/^(?!L?T(?:IME)?#)[a-z_]+#(?=.)/i, "");
+  switch (type.kind) {
+    case "enum": {
+      const number = integer(untyped);
+      if (typeof number === "number")
+        return number;
+      const named = /^(?:\w+\.)*(\w+)(?:\s*\((-?\d+)\))?$/.exec(untyped);
+      if (!named)
+        return;
+      return type.members[named[1]] ?? (named[2] === undefined ? named[1] : Number(named[2]));
+    }
+    case "array": {
+      const items = /^\[?(.*?)\]?$/s.exec(untyped)[1].trim();
+      if (!items)
+        return [];
+      const element = { kind: "scalar", iec: type.element };
+      const values = items.split(/\s*,\s*/).map((item) => parseLoginValue(element, item));
+      return values.length === type.length && values.every((value) => value !== undefined) ? values : undefined;
+    }
+    case "record":
+      return;
+    case "scalar":
+      break;
+  }
+  const iec = type.iec.toUpperCase();
+  if (iec === "BOOL")
+    return { TRUE: true, FALSE: false, 1: true, 0: false }[untyped.toUpperCase()];
+  if (integerTypes.has(iec))
+    return integer(untyped);
+  if (iec === "REAL" || iec === "LREAL") {
+    const number = Number(untyped);
+    return untyped !== "" && !Number.isNaN(number) ? number : undefined;
+  }
+  if (iec === "TIME" || iec === "LTIME")
+    return duration(trimmed);
+  if (/^W?STRING\b/.test(iec))
+    return quoted(trimmed) ?? trimmed;
+  return trimmed;
+};
+var createLoginAdapter = (options) => {
+  const samplingMs = options.samplingMs ?? 1000;
+  let connection = { state: "connecting", since: new Date().toISOString() };
+  const connectionListeners = new Set;
+  const subscriptions = new Set;
+  const rejected = new Map;
+  const controller = new AbortController;
+  const setConnection = (state, error) => {
+    if (controller.signal.aborted)
+      return;
+    if (connection.state === state && connection.error === error)
+      return;
+    if (state !== "connected")
+      rejected.clear();
+    connection = { state, since: new Date().toISOString(), ...error && { error } };
+    for (const listener of connectionListeners)
+      listener(connection);
+  };
+  const split = async (expressions) => {
+    try {
+      return await options.read(expressions);
+    } catch (error) {
+      if (error instanceof LoginUnavailable)
+        throw error;
+      if (expressions.length === 1) {
+        rejected.set(expressions[0], message2(error));
+        return {};
+      }
+      const half = Math.ceil(expressions.length / 2);
+      return {
+        ...await split(expressions.slice(0, half)),
+        ...await split(expressions.slice(half))
+      };
+    }
+  };
+  const readText = async (expressions) => {
+    try {
+      return await options.read(expressions);
+    } catch (error) {
+      if (error instanceof LoginUnavailable)
+        throw error;
+      await options.read([options.probe]);
+      return split(expressions);
+    }
+  };
+  const read = async (targets) => {
+    const unique = [...new Map(targets.map((target) => [target.target, target])).values()];
+    const expressions = unique.map(({ target }) => target).filter((target) => !rejected.has(target));
+    const samples = new Map;
+    let values;
+    const overdue = setTimeout(() => setConnection("lost", "The engineering login stopped answering"), 3 * samplingMs);
+    try {
+      values = expressions.length ? await readText(expressions) : {};
+      setConnection("connected");
+    } catch (error) {
+      setConnection(error instanceof LoginUnavailable ? error.state : "lost", message2(error));
+      const receivedAt = new Date().toISOString();
+      for (const { target } of unique)
+        samples.set(target, {
+          value: null,
+          quality: "unavailable",
+          status: message2(error),
+          receivedAt
+        });
+      return samples;
+    } finally {
+      clearTimeout(overdue);
+    }
+    const receivedAt = new Date().toISOString();
+    for (const { target, type } of unique) {
+      const text = values[target];
+      const refused = rejected.get(target);
+      const value = text === undefined ? undefined : parseLoginValue(type, text);
+      samples.set(target, value !== undefined ? { value, quality: "good", status: "Good", receivedAt } : {
+        value: text ?? null,
+        quality: "bad",
+        status: refused ?? (text === undefined ? "Not returned by the login" : `Not a ${typeName(type)}`),
+        receivedAt
+      });
+    }
+    return samples;
+  };
+  const poll = async () => {
+    while (!controller.signal.aborted) {
+      const started = Date.now();
+      const due = [...subscriptions].filter(({ due }) => due <= started + samplingMs / 2);
+      if (due.length) {
+        for (const subscription of due)
+          subscription.due = started + subscription.intervalMs;
+        const stopped = Promise.withResolvers();
+        const stop = () => stopped.resolve();
+        controller.signal.addEventListener("abort", stop, { once: true });
+        const samples = await Promise.race([
+          read(due.flatMap(({ targets }) => targets)),
+          stopped.promise
+        ]).finally(() => controller.signal.removeEventListener("abort", stop));
+        if (!samples || controller.signal.aborted)
+          break;
+        for (const subscription of due)
+          if (subscriptions.has(subscription))
+            for (const { target } of subscription.targets)
+              subscription.listener(target, samples.get(target));
+      }
+      const took = Date.now() - started;
+      const waiting = connection.state !== "connected" && connection.state !== "connecting";
+      await delay2(waiting ? retryMs : took > samplingMs ? took : samplingMs - took, undefined, {
+        signal: controller.signal
+      }).catch(() => {
+        return;
+      });
+    }
+  };
+  const running = poll();
+  return {
+    method: "engineering login",
+    endpoint: options.endpoint,
+    samplingMs,
+    connection: () => connection,
+    onConnection: (listener) => {
+      connectionListeners.add(listener);
+      return () => connectionListeners.delete(listener);
+    },
+    read,
+    subscribe: (targets, listener, intervalMs = samplingMs) => {
+      const subscription = { targets, listener, intervalMs, due: 0 };
+      subscriptions.add(subscription);
+      return () => subscriptions.delete(subscription);
+    },
+    close: async () => {
+      controller.abort();
+      subscriptions.clear();
+      connectionListeners.clear();
+      await running;
+    }
+  };
+};
+// packages/debug/src/opcua.ts
+import { resolve as resolve2 } from "node:path";
+import { createMonitor } from "@tsplc/opcua";
+var opcUaConnection = (monitor, options) => {
+  const password = monitor.passwordEnv && options.env[monitor.passwordEnv];
+  if (monitor.username && !password)
+    throw new Error(monitor.passwordEnv ? `Set ${monitor.passwordEnv} to the OPC UA password of ${monitor.username}.` : "Configure monitor.passwordEnv for the OPC UA user.");
+  return {
+    endpoint: monitor.endpoint,
+    namespaceUri: monitor.namespaceUri,
+    certificateDirectory: resolve2(options.root, monitor.certificateDirectory),
+    security: monitor.securityPolicy,
+    securityMode: monitor.securityMode === "Sign" ? "Sign" : "SignAndEncrypt",
+    ...monitor.username && password && { credentials: { username: monitor.username, password } }
+  };
+};
+var createOpcUaAdapter = (options) => {
+  const monitor = createMonitor(options);
+  const controller = new AbortController;
+  const running = monitor.run(controller.signal);
+  const sample = ({ value, quality, status }) => ({
+    value,
+    quality,
+    status,
+    receivedAt: new Date().toISOString()
+  });
+  const names = (targets) => targets.map(({ target }) => target);
+  return {
+    method: "OPC UA",
+    endpoint: options.endpoint,
+    samplingMs: monitor.samplingMs,
+    connection: monitor.status,
+    onConnection: monitor.onStatus,
+    read: async (targets) => new Map(Object.entries(await monitor.read(names(targets))).map(([target, reading]) => [
+      target,
+      sample(reading)
+    ])),
+    subscribe: (targets, listener) => monitor.watch(names(targets), (target, reading) => listener(target, sample(reading))),
+    close: async () => {
+      controller.abort();
+      await running;
+    }
+  };
+};
+export {
+  DebugError,
+  LoginUnavailable,
+  createDebugHandler,
+  createDebugger,
+  createLoginAdapter,
+  createOpcUaAdapter,
+  createPaths,
+  loadManifest,
+  noLogin,
+  opcUaConnection,
+  serveDebugger,
+  timelineEntries
+};
+
+//# debugId=19B08BFA048A0C5264756E2164756E21
+//# sourceMappingURL=index.js.map