@tsplc/debug 0.2.17 → 0.2.19

package/src/paths.ts

@@ -1,3 +1,4 @@
+import { isArrayIndexSegment, symbolPathSegments } from "@tsplc/opcua/contract";
 import type { DebugManifest, DebugType, SourceRange } from "./manifest.ts";
 
 /**
@@ -7,179 +8,251 @@ import type { DebugManifest, DebugType, SourceRange } from "./manifest.ts";
 
 /** A path that reads a target, or a constant the compiler folded. */
 export type ResolvedPath =
-  | {
-      kind: "target";
-      path: string;
-      target: string;
-      type: string;
-      readable: boolean;
-      generated?: true;
-      declaration?: SourceRange;
-    }
-  | { kind: "constant"; path: string; type: string; value: unknown; declaration?: SourceRange };
+	| {
+			kind: "target";
+			path: string;
+			target: string;
+			type: string;
+			readable: boolean;
+			generated?: true;
+			declaration?: SourceRange;
+	  }
+	| {
+			kind: "constant";
+			path: string;
+			type: string;
+			value: unknown;
+			declaration?: SourceRange;
+	  };
 
 /** Roots or constants that share a prefix, such as `program` above `program.diverters`. */
 interface GroupPath {
-  kind: "group";
-  path: string;
+	kind: "group";
+	path: string;
 }
 
 /** A child in the instance tree. */
 export type PathNode = { name: string } & (ResolvedPath | GroupPath);
 
-const segmentPattern = /[^.[\]]+|\[(?:-?\d+|\*)\]/g;
+/** In a pattern, every index of an array. */
+const anyIndex = "[*]";
 
-export const pathSegments = (path: string) => path.match(segmentPattern) ?? [];
+/** Names and indexes as the controller's symbol paths split them, and `[*]` in patterns. */
+export const pathSegments = (path: string) =>
+	path
+		.split(anyIndex)
+		.flatMap((part, index) => [
+			...(index > 0 ? [anyIndex] : []),
+			...symbolPathSegments(part),
+		]);
 
 export const joinPath = (prefix: string, segment: string) =>
-  segment.startsWith("[") || !prefix ? `${prefix}${segment}` : `${prefix}.${segment}`;
+	segment.startsWith("[") || !prefix
+		? `${prefix}${segment}`
+		: `${prefix}.${segment}`;
 
 /** Scalar type ids are their IEC names, and may have no entry in `types`. */
 export const typeOf = (manifest: DebugManifest, id: string): DebugType =>
-  manifest.types[id] ?? { kind: "scalar", iec: id };
+	manifest.types[id] ?? { kind: "scalar", iec: id };
 
 export const createPaths = (manifest: DebugManifest) => {
-  const typeOfId = (id: string) => typeOf(manifest, id);
-  // I/O bindings are readable symbols with TypeScript paths of their own.
-  const bases = new Map<string, Extract<ResolvedPath, { kind: "target" }>>([
-    ...manifest.roots.map(
-      ({ path, ...root }) => [path, { kind: "target" as const, path, ...root }] as const,
-    ),
-    ...manifest.io.map(
-      ({ path, target, type }) =>
-        [path, { kind: "target" as const, path, target, type, readable: true }] as const,
-    ),
-  ]);
-  const constants = new Map(
-    manifest.constants.map(({ path, ...constant }) => [
-      path,
-      { kind: "constant" as const, path, ...constant },
-    ]),
-  );
-  /** Children of the prefixes of every root and constant path, which are groups unless they resolve. */
-  const groups = new Map<string, Set<string>>();
-  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: string): ResolvedPath | undefined => {
-    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: ResolvedPath = 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: ResolvedPath | undefined) => {
-    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 [];
-  };
-
-  /** A path's fields or indexes, and the roots and constants below it. */
-  const children = (path: string): PathNode[] => {
-    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: ResolvedPath | GroupPath) =>
-    node.kind === "constant" ||
-    (node.kind === "target" && ["scalar", "enum"].includes(typeOfId(node.type).kind));
-
-  /**
-   * Leaf paths matching `patterns`, where `*` stands for one segment. A pattern naming a record,
-   * array or group stands for all its leaves; wildcards and expansion skip compiler-made fields.
-   * Paths that don't resolve are kept, so callers can report them.
-   */
-  const expand = (patterns: readonly string[], limit = 2000) => {
-    const leaves = new Set<string>();
-    const add = (path: string) => {
-      leaves.add(path);
-      if (leaves.size > limit) throw new RangeError(`More than ${limit} values match`);
-    };
-    const below = (node: ResolvedPath | GroupPath) => {
-      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: string, rest: readonly string[], wildcard: boolean) => {
-      const [head, ...tail] = rest;
-      if (head === undefined) {
-        const node: ResolvedPath | GroupPath | undefined =
-          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];
-  };
-
-  /** A value as TypeScript shows it: enum members by name, BOOL as a boolean. */
-  const decode = (typeId: string, raw: unknown) => {
-    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 };
+	const typeOfId = (id: string) => typeOf(manifest, id);
+	// I/O bindings are readable symbols with TypeScript paths of their own.
+	const bases = new Map<string, Extract<ResolvedPath, { kind: "target" }>>([
+		...manifest.roots.map(
+			({ path, ...root }) =>
+				[path, { kind: "target" as const, path, ...root }] as const,
+		),
+		...manifest.io.map(
+			({ path, target, type }) =>
+				[
+					path,
+					{ kind: "target" as const, path, target, type, readable: true },
+				] as const,
+		),
+	]);
+	const constants = new Map(
+		manifest.constants.map(({ path, ...constant }) => [
+			path,
+			{ kind: "constant" as const, path, ...constant },
+		]),
+	);
+	/** Children of the prefixes of every root and constant path, which are groups unless they resolve. */
+	const groups = new Map<string, Set<string>>();
+	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: string): ResolvedPath | undefined => {
+		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: ResolvedPath = 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") {
+					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}${segment}`,
+						type: type.element,
+						readable: resolved.readable,
+					};
+				} else {
+					return;
+				}
+			}
+			return resolved;
+		}
+	};
+
+	const typedChildren = (resolved: ResolvedPath | undefined) => {
+		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 [];
+	};
+
+	/** A path's fields or indexes, and the roots and constants below it. */
+	const children = (path: string): PathNode[] => {
+		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: ResolvedPath | GroupPath) =>
+		node.kind === "constant" ||
+		(node.kind === "target" &&
+			["scalar", "enum"].includes(typeOfId(node.type).kind));
+
+	/**
+	 * Leaf paths matching `patterns`, where `*` stands for one segment. A pattern naming a record,
+	 * array or group stands for all its leaves; wildcards and expansion skip compiler-made fields.
+	 * Paths that don't resolve are kept, so callers can report them.
+	 */
+	const expand = (patterns: readonly string[], limit = 2000) => {
+		const leaves = new Set<string>();
+		const add = (path: string) => {
+			leaves.add(path);
+			if (leaves.size > limit) {
+				throw new RangeError(`More than ${limit} values match`);
+			}
+		};
+		const below = (node: ResolvedPath | GroupPath) => {
+			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: string,
+			rest: readonly string[],
+			wildcard: boolean,
+		) => {
+			const [head, ...tail] = rest;
+			if (head === undefined) {
+				const node: ResolvedPath | GroupPath | undefined =
+					resolve(prefix) ??
+					(groups.has(prefix) ? { kind: "group", path: prefix } : undefined);
+				if (node) {
+					below(node);
+				} else if (!wildcard) {
+					add(prefix);
+				}
+				return;
+			}
+			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 {
+				match(joinPath(prefix, head), tail, wildcard);
+			}
+		};
+		for (const pattern of patterns) {
+			match("", pathSegments(pattern), false);
+		}
+		return [...leaves];
+	};
+
+	/** A value as TypeScript shows it: enum members by name, BOOL as a boolean. */
+	const decode = (typeId: string, raw: unknown) => {
+		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 };
 };
 
 export type Paths = ReturnType<typeof createPaths>;

package/src/requests.ts

@@ -0,0 +1,86 @@
+import type { RequestsReply } from "@tsplc/server/requests";
+import type { RequestTrace } from "./api.ts";
+import { type Entry, timelineEntries } from "./timeline.ts";
+
+/** Traces kept for jobs to find their calls by; older ones are forgotten. */
+const callsRemembered = 1000;
+
+/** A call that started or ended, with its timeline entry; `added` when the entry is new. */
+interface RequestChange {
+	request: RequestTrace;
+	entry: Entry<"request">;
+	added: boolean;
+}
+
+/**
+ * Follows the app server's request trace (`GET /tsplc/debug/requests`), asking again from before
+ * the oldest call still pending, so each call is seen when it starts and again when it ends.
+ */
+export const createRequestFollower = () => {
+	let newest = 0;
+	const pending = new Map<number, Entry<"request">>();
+	/** By `<job id>:<service>:<sequence>`, newest last. */
+	const calls = new Map<string, RequestTrace>();
+
+	return {
+		/** Where the next pull starts. */
+		since: () => (pending.size ? Math.min(...pending.keys()) - 1 : newest),
+		/** Takes a reply to `?since=<since()>`, telling `changed` of each call as it is taken. */
+		accept: (
+			reply: RequestsReply,
+			changed: (change: RequestChange) => void,
+		) => {
+			// A restarted server counts from 1 again.
+			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 });
+			}
+		},
+		/** The server's trace of a call, which the PLC tags with its job and the call site's count. */
+		call: ({
+			job,
+			service,
+			sequence,
+		}: {
+			job: number;
+			service: string;
+			sequence: number;
+		}) => calls.get(`${job}:${service}:${sequence}`),
+	};
+};