@tsplc/debug 0.2.17 → 0.2.18

package/dist/index.js

@@ -1,11 +1,19 @@
 // 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";
+import { requestsReply } from "@tsplc/server/requests";
+import { telemetryReply } from "@tsplc/server/telemetry";
+
+// packages/debug/src/errors.ts
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
 
 // packages/debug/src/adapter.ts
-var qualityRank = { good: 0, uncertain: 1, bad: 2, unavailable: 3 };
+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;
@@ -32,16 +40,31 @@ var deviceReads = (device, io, typeOf) => [
   ...device.assemblies.flatMap(({ raw, bytes }) => raw ? [
     {
       target: raw,
-      type: { kind: "array", element: "BYTE", length: bytes, lower: 0 }
+      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 }))
+  ...Object.values(device.status ?? {}).map((target) => ({
+    target,
+    type: untyped
+  }))
 ];
+var healthState = (quality, faulted) => {
+  if (quality !== "good") {
+    return "stale";
+  }
+  return faulted ? "fault" : "ok";
+};
 var health = (device, value) => {
   const { state, states, diagnostic, message } = device.health ?? {};
-  if (!state && !diagnostic)
+  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;
@@ -53,11 +76,15 @@ var health = (device, value) => {
   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",
+    state: healthState(quality, faulted),
     ...number !== undefined && { value: number },
     ...name && { name },
-    ...typeof diagnosticSample?.value === "boolean" && { diagnostic: diagnosticSample.value },
-    ...typeof messageSample?.value === "string" && { message: messageSample.value },
+    ...typeof diagnosticSample?.value === "boolean" && {
+      diagnostic: diagnosticSample.value
+    },
+    ...typeof messageSample?.value === "string" && {
+      message: messageSample.value
+    },
     quality
   };
 };
@@ -83,7 +110,10 @@ var deviceState = (device, io, value) => ({
   ] : []),
   status: Object.fromEntries(Object.entries(device.status ?? {}).map(([label, target]) => [
     label,
-    { value: value(target)?.value ?? null, quality: value(target)?.quality ?? "unavailable" }
+    {
+      value: value(target)?.value ?? null,
+      quality: value(target)?.quality ?? "unavailable"
+    }
   ]))
 });
 
@@ -97,7 +127,10 @@ 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") }))
+  ...job.requests.map(({ sequence }) => ({
+    target: sequence,
+    type: scalar("UDINT")
+  }))
 ];
 var busyOf = (job, value, traced) => {
   const read = value(busyRead(job).target);
@@ -116,15 +149,21 @@ var jobState = (job, inputs) => {
     ...startedAt && { startedAt },
     ...inputs.failure && { failure: inputs.failure }
   };
-  if (!busy)
+  if (!busy) {
     return base;
-  if (inputs.unread)
+  }
+  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 });
+    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;
@@ -132,9 +171,13 @@ var jobState = (job, inputs) => {
   const cancelling = value(`${job.target}.cancelling`);
   return {
     ...base,
-    ...cancelling?.quality === "good" && { cancelling: cancelling.value === true },
+    ...cancelling?.quality === "good" && {
+      cancelling: cancelling.value === true
+    },
     ...step !== undefined && { step },
-    ...current && { current: { kind: current.kind, range: current.range, text: current.text } },
+    ...current && {
+      current: { kind: current.kind, range: current.range, text: current.text }
+    },
     ...startedAt && { elapsedMs: Math.max(0, now - Date.parse(startedAt)) },
     ...latest && {
       request: {
@@ -147,15 +190,22 @@ var jobState = (job, inputs) => {
 };
 
 // packages/debug/src/paths.ts
-var segmentPattern = /[^.[\]]+|\[(?:-?\d+|\*)\]/g;
-var pathSegments = (path) => path.match(segmentPattern) ?? [];
+import { isArrayIndexSegment, symbolPathSegments } from "@tsplc/opcua/contract";
+var anyIndex = "[*]";
+var pathSegments = (path) => path.split(anyIndex).flatMap((part, index) => [
+  ...index > 0 ? [anyIndex] : [],
+  ...symbolPathSegments(part)
+]);
 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 }])
+    ...manifest.io.map(({ path, target, type }) => [
+      path,
+      { kind: "target", path, target, type, readable: true }
+    ])
   ]);
   const constants = new Map(manifest.constants.map(({ path, ...constant }) => [
     path,
@@ -166,28 +216,32 @@ var createPaths = (manifest) => {
     let prefix = "";
     for (const segment of pathSegments(path)) {
       let children = groups.get(prefix);
-      if (!children)
+      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)
+    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)
+      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)
+          if (!field) {
             return;
+          }
           resolved = {
             kind: "target",
             path: joinPath(resolved.path, segment),
@@ -198,32 +252,42 @@ var createPaths = (manifest) => {
             ...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)
+          if (!isArrayIndexSegment(segment)) {
             return;
+          }
+          const index = Number(segment.slice(1, -1));
+          if (index < type.lower || index >= type.lower + type.length) {
+            return;
+          }
           resolved = {
             kind: "target",
             path: joinPath(resolved.path, segment),
-            target: `${resolved.target}[${index}]`,
+            target: `${resolved.target}${segment}`,
             type: type.element,
             readable: resolved.readable
           };
-        } else
+        } else {
           return;
+        }
       }
       return resolved;
     }
   };
   const typedChildren = (resolved) => {
     const type = resolved?.kind === "target" ? typeOfId(resolved.type) : undefined;
-    if (type?.kind === "record")
+    if (type?.kind === "record") {
       return type.fields.map(({ name }) => name);
-    if (type?.kind === "array")
+    }
+    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) ?? []];
+    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 } };
@@ -234,48 +298,184 @@ var createPaths = (manifest) => {
     const leaves = new Set;
     const add = (path) => {
       leaves.add(path);
-      if (leaves.size > limit)
+      if (leaves.size > limit) {
         throw new RangeError(`More than ${limit} values match`);
+      }
     };
     const below = (node) => {
-      if (isLeaf(node))
+      if (isLeaf(node)) {
         return add(node.path);
-      for (const child of children(node.path))
-        if (!(child.kind === "target" && child.generated))
+      }
+      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)
+        if (node) {
           below(node);
-        else if (!wildcard)
+        } 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("[")))
+      if (head === "*" || head === anyIndex) {
+        for (const child of children(prefix)) {
+          if (!(child.kind === "target" && child.generated) && (head === "*" || child.name.startsWith("["))) {
             match(child.path, tail, true);
-      } else
+          }
+        }
+      } else {
         match(joinPath(prefix, head), tail, wildcard);
+      }
     };
-    for (const pattern of patterns)
+    for (const pattern of patterns) {
       match("", pathSegments(pattern), false);
+    }
     return [...leaves];
   };
   const decode = (typeId, raw) => {
     const type = typeOfId(typeId);
-    if (type.kind === "enum")
+    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")
+    }
+    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/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 insertInTimeOrder = (entries, entry) => {
+  for (let index = entries.length;index >= 0; index--) {
+    const before = entries[index - 1];
+    if (before === undefined || before.at <= entry.at) {
+      entries.splice(index, 0, entry);
+      return;
+    }
+  }
+};
+var createTimeline = (limit = 1e4) => {
+  const entries = [];
+  return {
+    add: (entry) => {
+      insertInTimeOrder(entries, entry);
+      if (entries.length > limit) {
+        entries.splice(0, entries.length - limit);
+      }
+    },
+    since: (at) => at ? entries.filter((entry) => entry.at > at) : [...entries]
+  };
+};
+
+// packages/debug/src/requests.ts
+var callsRemembered = 1000;
+var createRequestFollower = () => {
+  let newest = 0;
+  const pending = new Map;
+  const calls = new Map;
+  return {
+    since: () => pending.size ? Math.min(...pending.keys()) - 1 : newest,
+    accept: (reply, changed) => {
+      if (reply.latest < newest) {
+        newest = 0;
+        pending.clear();
+        return;
+      }
+      const oldest = reply.requests[0]?.seq;
+      if (oldest !== undefined) {
+        for (const seq of pending.keys()) {
+          if (seq < oldest) {
+            pending.delete(seq);
+          }
+        }
+      }
+      for (const request of reply.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 (request.job !== undefined && request.sequence !== undefined) {
+          calls.set(`${request.job}:${request.service}:${request.sequence}`, request);
+          for (const key of [...calls.keys()].slice(0, -callsRemembered)) {
+            calls.delete(key);
+          }
+        }
+        changed({ request, entry, added: !waiting });
+      }
+    },
+    call: ({
+      job,
+      service,
+      sequence
+    }) => calls.get(`${job}:${service}:${sequence}`)
+  };
+};
+
 // packages/debug/src/telemetry.ts
 import { recordedAt } from "@tsplc/server/telemetry-log";
 var clockWindowMs = 60000;
@@ -290,8 +490,9 @@ var createTelemetryFollower = (manifest) => {
   let newest = 0;
   let build = null;
   const clock = () => {
-    if (!estimates.length)
+    if (!estimates.length) {
       return null;
+    }
     const offsets = estimates.map(({ offsetMs }) => offsetMs);
     const best = estimates.reduce((best, estimate) => estimate.offsetMs > best.offsetMs ? estimate : best);
     return {
@@ -302,8 +503,9 @@ var createTelemetryFollower = (manifest) => {
   const observe = (batch, receivedAt) => {
     const rate = rates.get(batch.task);
     const restarted = rate !== undefined && batch.now < rate.now;
-    if (restarted)
+    if (restarted) {
       estimates = [];
+    }
     estimates = estimates.filter(({ at }) => receivedAt - at < clockWindowMs);
     estimates.push({
       offsetMs: batch.now - receivedAt,
@@ -316,9 +518,9 @@ var createTelemetryFollower = (manifest) => {
       scan: batch.scan,
       dropped: batch.dropped
     };
-    if (!rate || restarted)
+    if (!rate || restarted) {
       rates.set(batch.task, { scan: batch.scan, now: batch.now });
-    else if (batch.now - rate.now >= 1000) {
+    } 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 });
     }
@@ -333,8 +535,9 @@ var createTelemetryFollower = (manifest) => {
       }
       const received = [];
       for (const batch of reply.batches) {
-        if (batch.seq <= newest)
+        if (batch.seq <= newest) {
           continue;
+        }
         newest = batch.seq;
         build = batch.build;
         const receivedAt = new Date(batch.receivedAt);
@@ -355,69 +558,6 @@ var createTelemetryFollower = (manifest) => {
   };
 };
 
-// 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]));
@@ -429,8 +569,9 @@ var createTraceDecoder = (manifest, paths) => {
   return {
     decode: (record, task, sequence) => {
       const site = sites.get(record.site);
-      if (!site)
+      if (!site) {
         return;
+      }
       return {
         sequence,
         task,
@@ -457,7 +598,7 @@ 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)))
+  groups: z.record(z.string().nonempty(), z.array(z.string().nonempty()))
 });
 var loadWatchGroups = async (file, configured) => {
   let saved = existsSync(file) ? watchGroupsSchema.parse(JSON.parse(await readFile(file, "utf8"))).groups : {};
@@ -485,40 +626,22 @@ 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)
+      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)
+          if (count) {
             counts.set(key, count);
-          else
+          } else {
             counts.delete(key);
+          }
         }
       };
     }
@@ -529,6 +652,7 @@ var createDebugger = async (options) => {
   const paths = createPaths(manifest);
   const trace = createTraceDecoder(manifest, paths);
   const telemetry = createTelemetryFollower(manifest);
+  const requests = createRequestFollower();
   const timeline = createTimeline();
   const watchGroups = await loadWatchGroups(join(options.stateDirectory, "watch.json"), options.watch);
   const listeners = new Set;
@@ -536,15 +660,17 @@ var createDebugger = async (options) => {
   const { signal } = controller;
   let controllerBuild = null;
   const emit = (message) => {
-    for (const listener of listeners)
+    for (const listener of listeners) {
       listener(message);
+    }
   };
   const record = (entry) => {
     timeline.add(entry);
     emit({ event: "timeline", data: entry });
   };
-  for (const entry of options.timeline ?? [])
+  for (const entry of options.timeline ?? []) {
     timeline.add(entry);
+  }
   const session = () => ({
     build: {
       manifest: manifest.build.id,
@@ -559,8 +685,9 @@ var createDebugger = async (options) => {
     ...options.projectRoot && { projectRoot: options.projectRoot }
   });
   const setBuild = (build) => {
-    if (build === controllerBuild)
+    if (build === controllerBuild) {
       return;
+    }
     controllerBuild = build;
     emit({ event: "session", data: session() });
   };
@@ -573,9 +700,10 @@ var createDebugger = async (options) => {
   });
   const locate = (path) => {
     const resolved = paths.resolve(path);
-    if (!resolved)
+    if (!resolved) {
       return unavailable(path, "Unknown path");
-    if (resolved.kind === "constant")
+    }
+    if (resolved.kind === "constant") {
       return {
         path,
         value: resolved.value,
@@ -583,11 +711,16 @@ var createDebugger = async (options) => {
         status: "Constant",
         receivedAt: new Date().toISOString()
       };
-    if (!resolved.readable)
+    }
+    if (!resolved.readable) {
       return unavailable(path, "Not readable");
+    }
     return resolved;
   };
-  const targetRead = ({ target, type }) => ({
+  const targetRead = ({
+    target,
+    type
+  }) => ({
     target,
     type: paths.typeOf(type)
   });
@@ -605,38 +738,51 @@ var createDebugger = async (options) => {
         listener(located);
         continue;
       }
-      if (!watched.has(located.target))
+      if (!watched.has(located.target)) {
         reads.push(targetRead(located));
-      watched.set(located.target, [...watched.get(located.target) ?? [], { path, ...located }]);
+      }
+      watched.set(located.target, [
+        ...watched.get(located.target) ?? [],
+        { path, ...located }
+      ]);
     }
-    if (!reads.length)
+    if (!reads.length) {
       return () => {};
+    }
     return adapter.subscribe(reads, (target, received) => {
-      for (const { path, type } of watched.get(target) ?? [])
+      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")
+    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))
+      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")
+  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();
@@ -649,35 +795,41 @@ var createDebugger = async (options) => {
     unread: unread.has(job.id),
     clock: telemetry.clock(),
     now: Date.now(),
-    request: ({ job, service, sequence }) => requests.get(`${job}:${service}:${sequence}`)
+    request: requests.call
   });
-  const deviceOf = (id) => deviceState(manifest.devices.find((device) => device.id === id), manifest.io, (target) => latest.get(target));
+  const deviceOf = (device) => deviceState(device, manifest.io, (target) => latest.get(target));
   const send = (key, message) => {
     const json = JSON.stringify(message.data);
-    if (sent.get(key) === json)
+    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 updateDevice = (device) => send(`device:${device.id}`, { event: "device", data: deviceOf(device) });
   const reader = (intervalMs, update) => {
     let current = { key: "", stop: () => {} };
     return (reads) => {
       const key = reads.map(({ read }) => read.target).join(`
 `);
-      if (key === current.key)
+      if (key === current.key) {
         return;
+      }
       current.stop();
       const owners = new Map;
-      for (const { owner, read } of reads)
+      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) => {
+        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) ?? [])
+          for (const owner of owners.get(target) ?? []) {
             update(owner);
+          }
           schedule();
         }, intervalMs) : () => {}
       };
@@ -685,6 +837,15 @@ var createDebugger = async (options) => {
   };
   const readJobs = reader(adapter.samplingMs, updateJob);
   const readDevices = reader(hardwareMs, updateDevice);
+  const shownDeviceReads = (device) => {
+    if (shownDevices.has(device.id)) {
+      return deviceReads(device, manifest.io, paths.typeOf);
+    }
+    if (shownHealth.has(device.id)) {
+      return healthReads(device);
+    }
+    return [];
+  };
   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)));
@@ -693,12 +854,13 @@ var createDebugger = async (options) => {
       ...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 }))));
+    readDevices(manifest.devices.flatMap((device) => shownDeviceReads(device).map((read) => ({ owner: device, read }))));
   };
   let planned = false;
   const schedule = () => {
-    if (planned)
+    if (planned) {
       return;
+    }
     planned = true;
     queueMicrotask(() => {
       planned = false;
@@ -713,33 +875,48 @@ var createDebugger = async (options) => {
     ];
     schedule();
     return () => {
-      for (const stop of stops)
+      for (const stop of stops) {
         stop();
+      }
       schedule();
     };
   };
-  const receive = ({ build, task, sequence, at, record: received }) => {
+  const receive = ({
+    build,
+    task,
+    sequence,
+    at,
+    record: received
+  }) => {
     if (received.kind === "trace") {
-      if (build !== manifest.build.id)
+      if (build !== manifest.build.id) {
         return;
+      }
       const event = trace.decode(received, task, sequence);
-      if (event)
+      if (event) {
         record(timelineEntries.trace(at, event));
+      }
       const site = trace.job(received);
-      if (!site)
+      if (!site) {
         return;
+      }
       const startedAt = site.started ? at : traced.get(site.job.id)?.startedAt;
-      traced.set(site.job.id, { busy: site.started, ...startedAt && { 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)
+    if (received.kind !== "exception" || received.handled) {
       return;
+    }
     const job = manifest.jobs.find(({ name, instance }) => name === received.function && instance === received.instance);
-    if (!job)
+    if (!job) {
       return;
+    }
     failures.set(job.id, {
       at,
       code: received.code,
@@ -749,81 +926,69 @@ var createDebugger = async (options) => {
     updateJob(job);
   };
   const pull = async (url, token) => {
-    const response = await fetch(url, { headers: { authorization: `Bearer ${token}` }, signal });
-    if (!response.ok)
+    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 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)
+    for (const item of received) {
       receive(item);
+    }
     const build = telemetry.build();
-    if (build)
+    if (build) {
       setBuild(build);
-    if (reply.batches.length)
+    }
+    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 pullRequests = async ({
+    url,
+    token
+  }) => {
+    const reply = requestsReply.parse(await pull(new URL(`/tsplc/debug/requests?since=${requests.since()}`, url), token));
+    requests.accept(reply, ({ request, entry, added }) => {
+      if (added) {
+        timeline.add(entry);
       }
-      const oldest = body.requests[0]?.seq;
-      if (oldest !== undefined) {
-        for (const seq of pending.keys())
-          if (seq < oldest)
-            pending.delete(seq);
+      emit({ event: "request", data: request });
+      emit({ event: "timeline", data: entry });
+      if (request.job === undefined || request.sequence === undefined) {
+        return;
       }
-      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 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)
+      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)
+      }
+      for (const job of manifest.jobs) {
         updateJob(job);
-      for (const device of manifest.devices)
-        updateDevice(device.id);
+      }
+      for (const device of manifest.devices) {
+        updateDevice(device);
+      }
     }
   });
   const repeat = async (name, intervalMs, work) => {
@@ -833,11 +998,14 @@ var createDebugger = async (options) => {
         await work();
         failure = undefined;
       } catch (error) {
-        if (signal.aborted)
+        if (signal.aborted) {
           return;
-        if (message(error) !== failure)
-          options.log(`${name} failed: ${message(error)}`);
-        failure = message(error);
+        }
+        const message = errorMessage(error);
+        if (message !== failure) {
+          options.log(`${name} failed: ${message}`);
+        }
+        failure = message;
       }
       await delay(intervalMs, undefined, { signal }).catch(() => {
         return;
@@ -847,7 +1015,7 @@ var createDebugger = async (options) => {
   const { server } = options;
   const running = server ? [
     repeat("Reading the server's telemetry", pullMs, () => pullTelemetry(server)),
-    repeat("Reading the server's requests", pullMs, pullRequests(server))
+    repeat("Reading the server's requests", pullMs, () => pullRequests(server))
   ] : [];
   return {
     manifest,
@@ -855,7 +1023,7 @@ var createDebugger = async (options) => {
     session,
     values,
     jobs: () => manifest.jobs.map(jobOf),
-    hardware: () => manifest.devices.map(({ id }) => deviceOf(id)),
+    hardware: () => manifest.devices.map(deviceOf),
     timeline: (since) => timeline.since(since),
     watchGroups: () => watchGroups.groups(),
     saveWatchGroups: (groups) => watchGroups.save(groups),
@@ -879,189 +1047,193 @@ var createDebugger = async (options) => {
 };
 // packages/debug/src/http.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { z as z4 } from "zod";
+import { z as z3 } 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()
+import { z as z2 } from "zod";
+var sourceRange = z2.object({
+  file: z2.number().int(),
+  line: z2.number().int(),
+  column: z2.number().int(),
+  endLine: z2.number().int(),
+  endColumn: z2.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 json = z2.lazy(() => z2.union([
+  z2.string(),
+  z2.number(),
+  z2.boolean(),
+  z2.null(),
+  z2.array(json),
+  z2.record(z2.string(), json)
 ]));
-var debugField = z3.object({
-  name: z3.string(),
-  target: z3.string(),
-  type: z3.string(),
+var debugField = z2.object({
+  name: z2.string(),
+  target: z2.string(),
+  type: z2.string(),
   declaration: sourceRange.optional(),
-  generated: z3.literal(true).optional()
+  generated: z2.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())
+var debugType = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("scalar"), iec: z2.string() }),
+  z2.object({
+    kind: z2.literal("enum"),
+    name: z2.string(),
+    members: z2.record(z2.string(), z2.number().int())
   }),
-  z3.object({
-    kind: z3.literal("record"),
-    name: z3.string(),
+  z2.object({
+    kind: z2.literal("record"),
+    name: z2.string(),
     declaration: sourceRange.optional(),
-    fields: z3.array(debugField)
+    fields: z2.array(debugField)
   }),
-  z3.object({
-    kind: z3.literal("array"),
-    element: z3.string(),
-    length: z3.number().int(),
-    lower: z3.number().int()
+  z2.object({
+    kind: z2.literal("array"),
+    element: z2.string(),
+    length: z2.number().int(),
+    lower: z2.number().int()
   })
 ]);
-var debugRoot = z3.object({
-  path: z3.string(),
-  target: z3.string(),
-  type: z3.string(),
+var debugRoot = z2.object({
+  path: z2.string(),
+  target: z2.string(),
+  type: z2.string(),
   declaration: sourceRange.optional(),
-  readable: z3.boolean(),
-  generated: z3.literal(true).optional()
+  readable: z2.boolean(),
+  generated: z2.literal(true).optional()
 });
-var debugConstant = z3.object({
-  path: z3.string(),
-  type: z3.string(),
+var debugConstant = z2.object({
+  path: z2.string(),
+  type: z2.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 debugIo = z2.object({
+  path: z2.string(),
+  target: z2.string(),
+  direction: z2.enum(["input", "output"]),
+  type: z2.string(),
+  device: z2.string().optional(),
+  channel: z2.string().optional(),
+  address: z2.string().optional(),
+  inverted: z2.literal(true).optional(),
+  shared: z2.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 debugChannel = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  direction: z2.enum(["input", "output"]),
+  type: z2.string(),
+  offsetBits: z2.number().int(),
+  bits: z2.number().int(),
+  address: z2.string().optional(),
+  unit: z2.string().optional(),
+  description: z2.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()
+var debugDevice = z2.object({
+  id: z2.string(),
+  product: z2.string().optional(),
+  vendor: z2.string().optional(),
+  productCode: z2.string().optional(),
+  network: z2.object({ address: z2.string(), rpiMs: z2.number().optional() }).optional(),
+  connection: z2.string().optional(),
+  assemblies: z2.array(z2.object({
+    direction: z2.enum(["input", "output"]),
+    bytes: z2.number().int(),
+    address: z2.string().optional(),
+    raw: z2.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()
+  health: z2.object({
+    state: z2.string().optional(),
+    states: z2.record(z2.string(), z2.number().int()).optional(),
+    diagnostic: z2.string().optional(),
+    message: z2.string().optional()
   }).optional(),
-  status: z3.record(z3.string(), z3.string()).optional(),
-  channels: z3.array(debugChannel)
+  status: z2.record(z2.string(), z2.string()).optional(),
+  channels: z2.array(debugChannel)
 });
-var debugFunction = z3.object({
-  id: z3.number().int(),
-  name: z3.string(),
+var debugFunction = z2.object({
+  id: z2.number().int(),
+  name: z2.string(),
   declaration: sourceRange,
-  instance: z3.string().optional(),
-  task: z3.string().optional(),
-  target: z3.string(),
-  reads: z3.array(z3.object({ range: sourceRange, path: z3.string() }))
+  instance: z2.string().optional(),
+  task: z2.string().optional(),
+  target: z2.string(),
+  reads: z2.array(z2.object({ range: sourceRange, path: z2.string() }))
 });
-var debugJob = z3.object({
-  id: z3.number().int(),
-  name: z3.string(),
+var debugJob = z2.object({
+  id: z2.number().int(),
+  name: z2.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"]),
+  instance: z2.string().optional(),
+  target: z2.string(),
+  steps: z2.array(z2.object({
+    step: z2.number().int(),
+    kind: z2.enum(["await", "return", "throw", "statement"]),
     range: sourceRange,
-    text: z3.string()
+    text: z2.string()
   })),
-  startedAt: z3.string().optional(),
-  requests: z3.array(z3.object({
-    service: z3.string(),
-    target: z3.string(),
-    sequence: z3.string(),
-    job: z3.number().int().optional()
+  startedAt: z2.string().optional(),
+  requests: z2.array(z2.object({
+    service: z2.string(),
+    target: z2.string(),
+    sequence: z2.string(),
+    job: z2.number().int().optional()
   })),
-  generated: z3.literal(true).optional()
+  generated: z2.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(),
+var debugEventSite = z2.object({
+  id: z2.number().int(),
+  kind: z2.enum(["state", "decision", "job"]),
+  job: z2.number().int().optional(),
+  phase: z2.enum(["started", "finished"]).optional(),
+  path: z2.string(),
+  function: z2.number().int().optional(),
+  type: z2.string(),
   range: sourceRange,
-  text: z3.string(),
-  task: z3.string(),
-  operands: z3.array(z3.object({
-    text: z3.string(),
+  text: z2.string(),
+  task: z2.string(),
+  operands: z2.array(z2.object({
+    text: z2.string(),
     range: sourceRange,
-    type: z3.string(),
-    path: z3.string().optional(),
-    stable: z3.boolean()
+    type: z2.string(),
+    path: z2.string().optional(),
+    stable: z2.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 debugWriter = z2.object({
+  output: z2.string(),
+  target: z2.string(),
+  sites: z2.array(z2.object({
+    id: z2.number().int(),
+    range: sourceRange,
+    function: z2.number().int()
+  }))
 });
-var debugTask = z3.object({
-  name: z3.string(),
-  intervalMs: z3.number(),
-  priority: z3.number().int()
+var debugTask = z2.object({
+  name: z2.string(),
+  intervalMs: z2.number(),
+  priority: z2.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()
+var debugManifest = z2.object({
+  kind: z2.literal("tsplc-debug"),
+  version: z2.literal(1),
+  build: z2.object({
+    id: z2.string(),
+    target: z2.string(),
+    compiler: z2.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())
+  sources: z2.array(z2.string()),
+  types: z2.record(z2.string(), debugType),
+  roots: z2.array(debugRoot),
+  constants: z2.array(debugConstant),
+  io: z2.array(debugIo),
+  devices: z2.array(debugDevice),
+  functions: z2.array(debugFunction),
+  jobs: z2.array(debugJob),
+  events: z2.array(debugEventSite),
+  writers: z2.array(debugWriter),
+  tasks: z2.array(debugTask),
+  errors: z2.record(z2.string(), z2.string())
 });
 
 // packages/debug/src/ui/index.ts
@@ -1254,10 +1426,12 @@ var build = async () => {
       resolve(dirname2(createRequire(import.meta.url).resolve("@tsplc/debug")), "../src/ui/main.ts")
     ],
     target: "browser",
+    conditions: ["bun"],
     minify: true
   });
-  if (!result.success)
+  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();
@@ -1270,8 +1444,9 @@ var list = (value) => (value ?? "").split(",").map((item) => item.trim()).filter
 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))
+  if (!jobs.every(Number.isInteger)) {
     throw new DebugError("jobs must be job ids", 400);
+  }
   return {
     watch: list(search.get("watch")),
     jobs,
@@ -1286,8 +1461,9 @@ var stream = (debug, { watch, ...shown }) => {
     start: (controller) => {
       let open = true;
       const write = (text) => {
-        if (open)
+        if (open) {
           controller.enqueue(encoder.encode(text));
+        }
       };
       const send = ({ event, data }) => write(`event: ${event}
 data: ${JSON.stringify(data)}
@@ -1307,12 +1483,18 @@ data: ${JSON.stringify(data)}
 `), heartbeatMs);
       const { intervalMs } = debug.session().reading;
       const refresh = setInterval(() => {
-        if (debug.session().connection.state !== "connected")
+        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() });
+        for (const { sample, sentAt } of latest.values()) {
+          if (now - sentAt >= intervalMs) {
+            sendSample({
+              ...sample,
+              receivedAt: new Date(now).toISOString()
+            });
+          }
+        }
       }, intervalMs);
       stop = () => {
         open = false;
@@ -1324,7 +1506,12 @@ data: ${JSON.stringify(data)}
       };
     },
     cancel: () => stop()
-  }), { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-store" } });
+  }), {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-store"
+    }
+  });
 };
 var createDebugHandler = (debug, log) => async (request, route) => {
   const { searchParams } = new URL(request.url);
@@ -1360,12 +1547,15 @@ var createDebugHandler = (debug, log) => async (request, route) => {
     }
     return json2({ error: `No route ${key}` }, 404);
   } catch (error) {
-    if (error instanceof DebugError)
+    if (error instanceof DebugError) {
       return json2({ error: error.message }, error.status);
-    if (error instanceof RangeError || error instanceof SyntaxError)
+    }
+    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);
+    }
+    if (error instanceof z3.ZodError) {
+      return json2({ error: z3.prettifyError(error) }, 400);
+    }
     log(`${key} failed: ${error instanceof Error ? error.stack : String(error)}`);
     return json2({ error: "The debugger failed; see its log" }, 500);
   }
@@ -1377,8 +1567,9 @@ var serveDebugger = (debug, options) => {
     port: options.port,
     fetch: (request) => {
       const host = request.headers.get("host")?.replace(/:\d+$/, "");
-      if (host !== "127.0.0.1" && host !== "localhost")
+      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);
     }
   });
@@ -1386,19 +1577,15 @@ var serveDebugger = (debug, options) => {
 // 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"]
-]);
+// packages/debug/src/login-value.ts
+import { elementaryType } from "@tsplc/iec";
+var booleans = {
+  TRUE: true,
+  FALSE: false,
+  "1": true,
+  "0": false
+};
+var radixPrefixes = { 2: "0b", 8: "0o", 16: "0x" };
 var timeUnits = {
   d: 86400000,
   h: 3600000,
@@ -1408,106 +1595,154 @@ var timeUnits = {
   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 stringEscapes = {
+  l: `
+`,
+  n: `
+`,
+  p: "\f",
+  r: "\r",
+  t: "\t"
+};
+var withoutTypePrefix = (text) => text.replace(/^(?!L?T(?:IME)?#)[a-z_]+#(?=.)/i, "");
+var bigIntLiteral = (text) => {
+  const [, radix, digits] = /^(2|8|16)#([0-9a-f_]+)$/i.exec(text) ?? [];
+  if (radix !== undefined && digits !== undefined) {
+    return `${radixPrefixes[radix]}${digits.replaceAll("_", "")}`;
+  }
+  const decimal = text.replaceAll("_", "");
+  return /^[+-]?\d+$/.test(decimal) ? decimal : undefined;
+};
 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))
+  const literal = bigIntLiteral(text);
+  if (literal === undefined) {
     return;
-  const value = BigInt(radix ? `0${{ 2: "b", 8: "o", 16: "x" }[radix[1]]}${digits}` : digits);
+  }
+  const value = BigInt(literal);
   return Number.isSafeInteger(Number(value)) ? Number(value) : String(value);
 };
+var real = (text) => {
+  const number = Number(text);
+  return text !== "" && !Number.isNaN(number) ? number : undefined;
+};
 var duration = (text) => {
-  const body = /^L?T(?:IME)?#(-?)(.+)$/i.exec(text);
-  if (!body)
+  const [, sign, body] = /^L?T(?:IME)?#(-?)(.+)$/i.exec(text) ?? [];
+  if (body === undefined) {
     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("_", ""))
+  }
+  const units = body.replaceAll("_", "");
+  const parts = [...units.matchAll(/(\d+(?:\.\d+)?)(ms|us|ns|d|h|m|s)/gi)];
+  if (parts.map(([part]) => part).join("") !== units) {
     return;
+  }
   const ms = parts.reduce((total, [, amount, unit]) => total + Number(amount) * timeUnits[unit.toLowerCase()], 0);
-  return body[1] ? -ms : ms;
+  return sign ? -ms : ms;
 };
 var quoted = (text) => {
-  const body = /^(['"])(.*)\1$/s.exec(text);
-  if (!body)
+  const [, , body] = /^(['"])(.*)\1$/s.exec(text) ?? [];
+  return body?.replace(/\$([0-9a-f]{2}|[$'"lnprt])/gi, (_, code) => code.length === 2 ? String.fromCharCode(parseInt(code, 16)) : stringEscapes[code.toLowerCase()] ?? code);
+};
+var enumValue = (type, text) => {
+  const number = integer(text);
+  if (typeof number === "number") {
+    return number;
+  }
+  const [, name, value] = /^(?:\w+\.)*(\w+)(?:\s*\((-?\d+)\))?$/.exec(text) ?? [];
+  if (name === undefined) {
     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;
-  });
+  }
+  return type.members[name] ?? (value === undefined ? name : Number(value));
+};
+var arrayValue = (type, text) => {
+  const items = text.replace(/^\[/, "").replace(/\]$/, "").trim();
+  if (!items) {
+    return [];
+  }
+  const values = items.split(/\s*,\s*/).map((item) => scalarValue(type.element, item));
+  return values.length === type.length && values.every((value) => value !== undefined) ? values : undefined;
+};
+var scalarValue = (iec, text) => {
+  const untyped = withoutTypePrefix(text);
+  const name = iec.toUpperCase();
+  switch (elementaryType(name)?.family) {
+    case "bool":
+      return booleans[untyped.toUpperCase()];
+    case "integer":
+    case "bits":
+      return integer(untyped);
+    case "real":
+      return real(untyped);
+    case "duration":
+      return duration(text);
+  }
+  if (/^W?STRING\b/.test(name)) {
+    return quoted(text) ?? text;
+  }
+  return text;
 };
 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 "enum":
+      return enumValue(type, withoutTypePrefix(trimmed));
+    case "array":
+      return arrayValue(type, withoutTypePrefix(trimmed));
     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;
+      return scalarValue(type.iec, trimmed);
   }
-  if (iec === "TIME" || iec === "LTIME")
-    return duration(trimmed);
-  if (/^W?STRING\b/.test(iec))
-    return quoted(trimmed) ?? trimmed;
-  return trimmed;
 };
+
+// packages/debug/src/login.ts
+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 typeName = (type) => type.kind === "scalar" ? type.iec : type.kind;
 var createLoginAdapter = (options) => {
   const samplingMs = options.samplingMs ?? 1000;
-  let connection = { state: "connecting", since: new Date().toISOString() };
+  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)
+    if (controller.signal.aborted) {
       return;
-    if (connection.state === state && connection.error === error)
+    }
+    if (connection.state === state && connection.error === error) {
       return;
-    if (state !== "connected")
+    }
+    if (state !== "connected") {
       rejected.clear();
-    connection = { state, since: new Date().toISOString(), ...error && { error } };
-    for (const listener of connectionListeners)
+    }
+    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)
+      if (error instanceof LoginUnavailable) {
         throw error;
+      }
       if (expressions.length === 1) {
-        rejected.set(expressions[0], message2(error));
+        rejected.set(expressions[0], errorMessage(error));
         return {};
       }
       const half = Math.ceil(expressions.length / 2);
@@ -1521,56 +1756,75 @@ var createLoginAdapter = (options) => {
     try {
       return await options.read(expressions);
     } catch (error) {
-      if (error instanceof LoginUnavailable)
+      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 readTexts = async (expressions) => {
     const overdue = setTimeout(() => setConnection("lost", "The engineering login stopped answering"), 3 * samplingMs);
     try {
-      values = expressions.length ? await readText(expressions) : {};
+      const texts = expressions.length ? await readText(expressions) : {};
       setConnection("connected");
+      return { texts };
     } 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;
+      setConnection(error instanceof LoginUnavailable ? error.state : "lost", errorMessage(error));
+      return { error: errorMessage(error) };
     } finally {
       clearTimeout(overdue);
     }
+  };
+  const parsedSample = ({ target, type }, text, receivedAt) => {
+    const value = text === undefined ? undefined : parseLoginValue(type, text);
+    if (value !== undefined) {
+      return { value, quality: "good", status: "Good", receivedAt };
+    }
+    const reason = text === undefined ? "Not returned by the login" : `Not a ${typeName(type)}`;
+    return {
+      value: text ?? null,
+      quality: "bad",
+      status: rejected.get(target) ?? reason,
+      receivedAt
+    };
+  };
+  const read = async (targets) => {
+    const unique = [
+      ...new Map(targets.map((target) => [target.target, target])).values()
+    ];
+    const result = await readTexts(unique.map(({ target }) => target).filter((target) => !rejected.has(target)));
     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
-      });
+    if ("error" in result) {
+      return new Map(unique.map(({ target }) => [
+        target,
+        {
+          value: null,
+          quality: "unavailable",
+          status: result.error,
+          receivedAt
+        }
+      ]));
+    }
+    return new Map(unique.map((read) => [
+      read.target,
+      parsedSample(read, result.texts[read.target], receivedAt)
+    ]));
+  };
+  const pauseAfter = (tookMs) => {
+    if (connection.state !== "connected" && connection.state !== "connecting") {
+      return retryMs;
     }
-    return samples;
+    return tookMs > samplingMs ? tookMs : samplingMs - tookMs;
   };
   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)
+        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 });
@@ -1578,16 +1832,18 @@ var createLoginAdapter = (options) => {
           read(due.flatMap(({ targets }) => targets)),
           stopped.promise
         ]).finally(() => controller.signal.removeEventListener("abort", stop));
-        if (!samples || controller.signal.aborted)
+        if (!samples || controller.signal.aborted) {
           break;
-        for (const subscription of due)
-          if (subscriptions.has(subscription))
-            for (const { target } of subscription.targets)
+        }
+        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, {
+      await delay2(pauseAfter(Date.now() - started), undefined, {
         signal: controller.signal
       }).catch(() => {
         return;
@@ -1619,20 +1875,19 @@ var createLoginAdapter = (options) => {
   };
 };
 // packages/debug/src/opcua.ts
-import { resolve as resolve2 } from "node:path";
-import { createMonitor } from "@tsplc/opcua";
+import {
+  createMonitor,
+  monitorConnection
+} from "@tsplc/opcua";
 var opcUaConnection = (monitor, options) => {
-  const password = monitor.passwordEnv && options.env[monitor.passwordEnv];
-  if (monitor.username && !password)
+  const password = monitor.passwordEnv ? options.env[monitor.passwordEnv] : undefined;
+  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 } }
-  };
+  }
+  return monitorConnection(monitor, {
+    root: options.root,
+    password: password ?? null
+  });
 };
 var createOpcUaAdapter = (options) => {
   const monitor = createMonitor(options);
@@ -1651,10 +1906,7 @@ var createOpcUaAdapter = (options) => {
     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)
-    ])),
+    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();
@@ -1677,5 +1929,5 @@ export {
   timelineEntries
 };
 
-//# debugId=19B08BFA048A0C5264756E2164756E21
+//# debugId=D1ADCD561935AA0C64756E2164756E21
 //# sourceMappingURL=index.js.map