@aryacode/dsh-engineering 0.0.0-stage → 0.4.0

package/vendor/l5x/lib/model/routines.js

@@ -0,0 +1,183 @@
+/**
+ * Routine reader — ladder as NeutralText with rung comments, Structured Text
+ * as its lines.
+ *
+ * A ladder rung is returned as the compact NeutralText the export already
+ * stores, e.g. `XIC(Motor_Start)XIO(Motor_Fault)OTE(Motor_Run);`, which is what
+ * makes one rung a single readable line instead of its graphical XML. Any other
+ * routine language is reported by name rather than decomposed.
+ */
+import { descriptionOf, programElements } from "./module.js";
+import { attribute, elementChildren, firstChild, nodeText, optionalAttribute } from "./xml.js";
+/** The language code a ladder routine carries. */
+const LADDER = 'RLL';
+/** The language code a Structured Text routine carries. */
+const STRUCTURED_TEXT = 'ST';
+/**
+ * List routines with the size of each body.
+ *
+ * The listing names the program, so a caller can pass the name back to
+ * {@link getRoutine}. Only the count for the routine's own language is
+ * reported, which is why at most one count is ever present.
+ *
+ * @param document - The parsed project.
+ * @param program - Program name to restrict to; empty or omitted keeps every program.
+ * @returns One entry per routine, in written order.
+ */
+export function listRoutines(document, program = '') {
+    const routines = program === '' ? document.routines : document.routines.filter(routine => routine.program === program);
+    return routines.map(routineInfoOf);
+}
+/**
+ * Read one routine's body.
+ *
+ * @param document - The parsed project.
+ * @param program - Program holding the routine.
+ * @param routineName - Routine name.
+ * @returns The routine, or undefined when that program has no such routine.
+ */
+export function getRoutine(document, program, routineName) {
+    return document.routines.find(routine => routine.program === program && routine.name === routineName);
+}
+/**
+ * Read every program's routines of a controller.
+ *
+ * @param controller - The controller element.
+ * @returns The routines, in program then written order.
+ */
+export function buildRoutines(controller) {
+    const routines = [];
+    for (const program of programElements(controller)) {
+        const programName = optionalAttribute(program, 'Name', '');
+        const elements = firstChild(program, 'Routines');
+        if (elements === undefined)
+            continue;
+        for (const routine of elementChildren(elements, 'Routine'))
+            routines.push(routineBody(programName, routine));
+    }
+    return routines;
+}
+/**
+ * Decode one routine element's body.
+ *
+ * Add-on instructions read their internal routines through this, so an AOI's
+ * ladder and Structured Text are decoded exactly as a program's are.
+ *
+ * @param owner - Program or add-on instruction the routine belongs to.
+ * @param routine - The `<Routine>` element.
+ * @returns The routine with its body decoded.
+ */
+export function routineBody(owner, routine) {
+    const type = optionalAttribute(routine, 'Type', '');
+    return {
+        program: owner,
+        name: optionalAttribute(routine, 'Name', ''),
+        type,
+        description: descriptionOf(routine),
+        body: decodeBody(type, routine),
+    };
+}
+/** A listing entry for one routine already read. */
+function routineInfoOf(routine) {
+    const entry = {
+        program: routine.program,
+        name: routine.name,
+        type: routine.type,
+        description: routine.description,
+    };
+    if (routine.body.type === LADDER)
+        return { ...entry, rungCount: routine.body.rungs.length };
+    if (routine.body.type === STRUCTURED_TEXT)
+        return { ...entry, lineCount: splitLines(routine.body.code).length };
+    return entry;
+}
+/**
+ * The numbered lines of a Structured Text body.
+ *
+ * An empty body has no lines: the reader joins the export's lines with `\n`, so
+ * a body of no lines and a body of one empty line both read as `''`, and the
+ * export's own line count is what a listing reports.
+ *
+ * @param code - A Structured Text body.
+ * @returns One entry per line, numbered from zero in body order.
+ */
+export function splitLines(code) {
+    if (code === '')
+        return [];
+    return code.split('\n').map((text, number) => ({ number, text }));
+}
+/** The body of a routine, by its declared language. */
+function decodeBody(type, routine) {
+    if (type === LADDER)
+        return { type: LADDER, rungs: decodeRungs(routine) };
+    if (type === STRUCTURED_TEXT)
+        return { type: STRUCTURED_TEXT, code: decodeLines(routine).join('\n') };
+    if ((type === 'FBD' && firstChild(routine, 'FBDContent') !== undefined) || (type === 'SFC' && firstChild(routine, 'SFCContent') !== undefined)) {
+        return { type, nodes: decodeDiagram(routine, type === 'FBD' ? 'FBDContent' : 'SFCContent') };
+    }
+    return { type: 'other', note: `${type} detailed parsing not yet supported` };
+}
+function decodeDiagram(routine, contentName) {
+    const content = firstChild(routine, contentName);
+    if (content === undefined)
+        return [];
+    const nodes = [];
+    for (const sheet of elementChildren(content, 'Sheet')) {
+        const number = Number.parseInt(sheet.attrs['Number'] ?? '0', 10);
+        const visit = (child) => {
+            const text = nodeText(child);
+            if (Object.keys(child.attrs).length > 0 || text !== undefined) {
+                const node = {
+                    kind: child.name, sheet: number,
+                    ...(child.attrs['ID'] === undefined ? {} : { id: child.attrs['ID'] }),
+                    ...(child.attrs['Operand'] === undefined ? {} : { operand: child.attrs['Operand'] }),
+                    ...(child.attrs['FromID'] === undefined ? {} : { fromId: child.attrs['FromID'] }),
+                    ...(child.attrs['ToID'] === undefined ? {} : { toId: child.attrs['ToID'] }),
+                    ...(text === undefined ? {} : { text }),
+                };
+                nodes.push(node);
+            }
+            for (const nested of child.children)
+                if ('attrs' in nested)
+                    visit(nested);
+        };
+        for (const child of sheet.children)
+            if ('attrs' in child)
+                visit(child);
+    }
+    return nodes;
+}
+/**
+ * One ladder routine's rungs, as NeutralText with their comments.
+ *
+ * @param routine - The `<Routine>` element of a ladder routine.
+ * @returns One entry per rung, in written order.
+ */
+export function decodeRungs(routine) {
+    const content = firstChild(routine, 'RLLContent');
+    if (content === undefined)
+        return [];
+    return elementChildren(content, 'Rung').map(decodeRung);
+}
+/** A Structured Text routine's source lines, verbatim and in written order. */
+function decodeLines(routine) {
+    const content = firstChild(routine, 'STContent');
+    if (content === undefined)
+        return [];
+    return elementChildren(content, 'Line').map(line => nodeText(line) ?? '');
+}
+/**
+ * One rung as NeutralText, with its comment when the export carries one.
+ *
+ * @param rung - The `<Rung>` element.
+ * @returns The rung, with empty text when the export wrote none.
+ */
+function decodeRung(rung) {
+    const textElement = firstChild(rung, 'Text');
+    const text = textElement === undefined ? '' : (nodeText(textElement) ?? '').trim();
+    const comment = optionalAttribute(rung, 'Comment', '');
+    const number = Number.parseInt(attribute(rung, 'Number'), 10);
+    if (comment === '')
+        return { number, text };
+    return { number, comment, text };
+}

package/vendor/l5x/lib/model/tags.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Tag reader — controller-scoped and program-scoped tags, with the scope and
+ * data-type filters the tool schema declares.
+ *
+ * Scope is carried on every entry rather than implied by grouping, because one
+ * flat list answers both "what does the controller own" and "what does this
+ * program own" without the caller re-nesting it.
+ */
+import type { L5xDocument, L5xTag } from './types.ts';
+import { type XmlElement } from './xml.ts';
+/**
+ * List tags, filtered by scope and data type.
+ *
+ * A scope of `controller` selects only the controller's tags; any other
+ * non-empty scope selects only that program's; an empty scope selects both, with
+ * the controller's first. The scope match is exact and case-sensitive except for
+ * the literal `controller`, which is matched case-insensitively so `Controller`
+ * from a caller still selects the controller's tags.
+ *
+ * @param document - The parsed project.
+ * @param scope - `controller`, a program name, or empty for all.
+ * @param dataType - Data type to restrict to; empty keeps every type.
+ * @returns Matching tags, in written order.
+ */
+export declare function listTags(document: L5xDocument, scope?: string, dataType?: string): readonly L5xTag[];
+/**
+ * Find one tag by name, searching controller scope first and then each program.
+ *
+ * @param document - The parsed project.
+ * @param tagName - Tag name to find.
+ * @returns The tag, or undefined when no scope declares it.
+ */
+export declare function findTag(document: L5xDocument, tagName: string): L5xTag | undefined;
+/**
+ * Read every tag of a controller's scopes.
+ *
+ * @param controller - The controller element.
+ * @returns The controller's tags first, then each program's, in written order.
+ */
+export declare function buildTags(controller: XmlElement): readonly L5xTag[];
+/**
+ * One tag entry.
+ *
+ * Only the fields the export actually declares are emitted, so a caller can
+ * tell "declared as false" (`constant` absent) from "declared true".
+ *
+ * @param tag - The `<Tag>` element.
+ * @param scope - The owning scope's name.
+ * @returns The tag entry.
+ */
+export declare function parseTag(tag: XmlElement, scope: string): L5xTag;

package/vendor/l5x/lib/model/tags.js

@@ -0,0 +1,119 @@
+/**
+ * Tag reader — controller-scoped and program-scoped tags, with the scope and
+ * data-type filters the tool schema declares.
+ *
+ * Scope is carried on every entry rather than implied by grouping, because one
+ * flat list answers both "what does the controller own" and "what does this
+ * program own" without the caller re-nesting it.
+ */
+import { controllerElementOf } from "./parse.js";
+import { descriptionOf, programElements } from "./module.js";
+import { elementChildren, firstChild, optionalAttribute, presentAttribute } from "./xml.js";
+/** The scope name the controller's own tags report. */
+const CONTROLLER_SCOPE = 'controller';
+/**
+ * List tags, filtered by scope and data type.
+ *
+ * A scope of `controller` selects only the controller's tags; any other
+ * non-empty scope selects only that program's; an empty scope selects both, with
+ * the controller's first. The scope match is exact and case-sensitive except for
+ * the literal `controller`, which is matched case-insensitively so `Controller`
+ * from a caller still selects the controller's tags.
+ *
+ * @param document - The parsed project.
+ * @param scope - `controller`, a program name, or empty for all.
+ * @param dataType - Data type to restrict to; empty keeps every type.
+ * @returns Matching tags, in written order.
+ */
+export function listTags(document, scope = '', dataType = '') {
+    const tags = selectScope(buildTags(controllerElementOf(document)), scope);
+    if (dataType === '')
+        return tags;
+    return tags.filter(tag => tag.dataType === dataType);
+}
+/**
+ * The tags one scope selects.
+ *
+ * A scope of `controller` selects only the controller's tags; any other
+ * non-empty scope selects only that program's; an empty scope selects both. The
+ * scope match is exact and case-sensitive except for the literal `controller`,
+ * which is matched case-insensitively so `Controller` from a caller still
+ * selects the controller's tags.
+ *
+ * @param tags - Every tag of the project.
+ * @param scope - `controller`, a program name, or empty for all.
+ * @returns The matching tags, in their original order.
+ */
+function selectScope(tags, scope) {
+    if (scope === '')
+        return tags;
+    if (scope.toLowerCase() === CONTROLLER_SCOPE)
+        return tags.filter(tag => tag.scope === CONTROLLER_SCOPE);
+    return tags.filter(tag => tag.scope === scope);
+}
+/**
+ * Find one tag by name, searching controller scope first and then each program.
+ *
+ * @param document - The parsed project.
+ * @param tagName - Tag name to find.
+ * @returns The tag, or undefined when no scope declares it.
+ */
+export function findTag(document, tagName) {
+    return buildTags(controllerElementOf(document)).find(tag => tag.name === tagName);
+}
+/**
+ * Read every tag of a controller's scopes.
+ *
+ * @param controller - The controller element.
+ * @returns The controller's tags first, then each program's, in written order.
+ */
+export function buildTags(controller) {
+    const results = [];
+    for (const tag of controllerTags(controller))
+        results.push(parseTag(tag, CONTROLLER_SCOPE));
+    for (const program of programElements(controller)) {
+        const programName = optionalAttribute(program, 'Name', '');
+        for (const tag of programTags(program))
+            results.push(parseTag(tag, programName));
+    }
+    return results;
+}
+/** The controller's `<Tag>` elements, in written order. */
+function controllerTags(controller) {
+    const tags = firstChild(controller, 'Tags');
+    return tags === undefined ? [] : elementChildren(tags, 'Tag');
+}
+/** One program's `<Tag>` elements, in written order. */
+function programTags(program) {
+    const tags = firstChild(program, 'Tags');
+    return tags === undefined ? [] : elementChildren(tags, 'Tag');
+}
+/**
+ * One tag entry.
+ *
+ * Only the fields the export actually declares are emitted, so a caller can
+ * tell "declared as false" (`constant` absent) from "declared true".
+ *
+ * @param tag - The `<Tag>` element.
+ * @param scope - The owning scope's name.
+ * @returns The tag entry.
+ */
+export function parseTag(tag, scope) {
+    const entry = {
+        name: optionalAttribute(tag, 'Name', ''),
+        dataType: optionalAttribute(tag, 'DataType', ''),
+        scope,
+    };
+    const description = descriptionOf(tag);
+    if (description !== '')
+        entry.description = description;
+    const radix = presentAttribute(tag, 'Radix');
+    if (radix !== undefined)
+        entry.radix = radix;
+    if (tag.attrs['Constant'] === 'true')
+        entry.constant = true;
+    const externalAccess = presentAttribute(tag, 'ExternalAccess');
+    if (externalAccess !== undefined)
+        entry.externalAccess = externalAccess;
+    return entry;
+}

package/vendor/l5x/lib/model/types.d.ts

@@ -0,0 +1,304 @@
+/**
+ * The parsed-document seam: what a Studio 5000 `.l5x` export becomes once it is
+ * parsed, and what reading it yields.
+ *
+ * Types only — parsing, the read functions, and their errors live beside this
+ * file. A document is lossless JSON with no XML nodes in it: an SDK caller, a
+ * Remote caller, and an in-process reader all see the same vocabulary, and no
+ * payload carries raw XML. Absent means absent: an entry omits a field the
+ * export did not supply rather than filling it with a placeholder, because the
+ * reference server's JSON omits it too.
+ */
+/** One controller-scoped or program-scoped tag. */
+export interface L5xTag {
+    /** Tag name as declared. */
+    readonly name: string;
+    /** Declared data type, e.g. `BOOL`, `DINT`, `Motor_UDT`. */
+    readonly dataType: string;
+    /** Owning scope: the literal `controller`, or the declaring program's name. */
+    readonly scope: string;
+    /** Description, from the `Description` attribute or the child element. */
+    readonly description?: string;
+    /** Radix the export declares, when it declares one. */
+    readonly radix?: string;
+    /** Present and true only when the export marks the tag `Constant="true"`. */
+    readonly constant?: boolean;
+    /** External-access setting, when the export declares one. */
+    readonly externalAccess?: string;
+}
+/** One member of a user-defined type. */
+export interface L5xUdtMember {
+    /** Member name. */
+    readonly name: string;
+    /** Declared data type. */
+    readonly dataType: string;
+    /** Array length, present only when the member declares a non-zero dimension. */
+    readonly dimension?: number;
+    /** Description, when the member has one. */
+    readonly description?: string;
+    /** Radix the export declares, when it declares one. */
+    readonly radix?: string;
+    /** Backing member a BIT member addresses, when the export declares one. */
+    readonly target?: string;
+    /** Bit position inside the backing member, when the export declares one. */
+    readonly bitNumber?: number;
+}
+/** One user-defined type, with the members that are not hidden. */
+export interface L5xUdt {
+    /** Type name. */
+    readonly name: string;
+    /** Description, empty string when the type has none. */
+    readonly description: string;
+    /** Visible members in declaration order. */
+    readonly members: readonly L5xUdtMember[];
+}
+/** One parameter of an add-on instruction. */
+export interface L5xAoiParameter {
+    /** Parameter name. */
+    readonly name: string;
+    /** Declared data type. */
+    readonly dataType: string;
+    /** `Input`, `Output`, `InOut`, or whatever usage the export declares. */
+    readonly usage: string;
+    /** Description, when the parameter has one. */
+    readonly description?: string;
+    /** Present and true only when the export marks the parameter `Required="true"`. */
+    readonly required?: boolean;
+    /** Present and false only when the export marks the parameter `Visible="false"`. */
+    readonly visible?: boolean;
+}
+/** One local tag declared inside an add-on instruction. */
+export interface L5xAoiLocalTag {
+    /** Local tag name. */
+    readonly name: string;
+    /** Declared data type. */
+    readonly dataType: string;
+    /** Description, when the local tag has one. */
+    readonly description?: string;
+}
+/** One ladder rung. */
+export interface L5xRung {
+    /** Rung number as the export's `Number` attribute states it. */
+    readonly number: number;
+    /** Rung comment, when the export carries one. */
+    readonly comment?: string;
+    /** The rung as compact NeutralText, e.g. `XIC(Motor_Start)OTE(Motor_Run);`. */
+    readonly text: string;
+}
+/** Routine body: language-specific, and the discriminant is the routine's `type`. */
+export type L5xRoutineBody = 
+/** Ladder body: one entry per rung, in the export's order. */
+{
+    readonly type: 'RLL';
+    readonly rungs: readonly L5xRung[];
+}
+/** Structured Text body, exactly the routine's lines joined with `\n`. */
+ | {
+    readonly type: 'ST';
+    readonly code: string;
+}
+/** Function Block diagram nodes and connections; execution semantics remain partial. */
+ | {
+    readonly type: 'FBD';
+    readonly nodes: readonly L5xDiagramNode[];
+}
+/** Sequential Function Chart elements and connections; execution semantics remain partial. */
+ | {
+    readonly type: 'SFC';
+    readonly nodes: readonly L5xDiagramNode[];
+}
+/** Any other language the port does not decompose; the note names it. */
+ | {
+    readonly type: 'other';
+    readonly note: string;
+};
+export interface L5xDiagramNode {
+    readonly kind: string;
+    readonly sheet: number;
+    readonly id?: string;
+    readonly operand?: string;
+    readonly fromId?: string;
+    readonly toId?: string;
+    readonly text?: string;
+}
+/** One routine as a listing entry: enough to choose it, not its logic. */
+export interface L5xRoutineInfo {
+    /** Program the routine belongs to. */
+    readonly program: string;
+    /** Routine name. */
+    readonly name: string;
+    /** Language code as written, e.g. `RLL`, `ST`, `FBD`. */
+    readonly type: string;
+    /** Description, empty string when the routine has none. */
+    readonly description: string;
+    /** Ladder rungs in the routine; present only for `RLL`. */
+    readonly rungCount?: number;
+    /** Structured Text lines in the routine; present only for `ST`. */
+    readonly lineCount?: number;
+}
+/** One routine with its body. */
+export interface L5xRoutine {
+    /** Program the routine belongs to. */
+    readonly program: string;
+    /** Routine name. */
+    readonly name: string;
+    /** Language code as written. */
+    readonly type: string;
+    /** Description, empty string when the routine has none. */
+    readonly description: string;
+    /** The decoded body. */
+    readonly body: L5xRoutineBody;
+}
+/** One add-on instruction as a listing entry. */
+export interface L5xAoiInfo {
+    /** Instruction name. */
+    readonly name: string;
+    /** Description, empty string when it has none. */
+    readonly description: string;
+    /** Revision the export declares, empty string when it declares none. */
+    readonly revision: string;
+}
+/** One add-on instruction with its interface and internal logic. */
+export interface L5xAoiDefinition extends L5xAoiInfo {
+    /** Vendor the export declares, empty string when it declares none. */
+    readonly vendor: string;
+    /** Parameters in declaration order. */
+    readonly parameters: readonly L5xAoiParameter[];
+    /** Local tags in declaration order. */
+    readonly localTags: readonly L5xAoiLocalTag[];
+    /** Internal routines in declaration order. */
+    readonly routines: readonly L5xRoutine[];
+}
+/** One program's summary. */
+export interface L5xProgram {
+    /** Program name. */
+    readonly name: string;
+    /** Name of the program's main routine, empty string when the export omits it. */
+    readonly mainRoutine: string;
+    /** Description, empty string when the program has none. */
+    readonly description: string;
+}
+/** One task's scheduling summary. */
+export interface L5xTask {
+    /** Task name. */
+    readonly name: string;
+    /** Task type as written, e.g. `CONTINUOUS`, `PERIODIC`, `EVENT`. */
+    readonly type: string;
+    /** Period, empty string when the export declares none. */
+    readonly rate: string;
+    /** Priority as written, empty string when the export declares none. */
+    readonly priority: string;
+    /** Description, empty string when the task has none. */
+    readonly description: string;
+    /** Names of the programs the task schedules, in the export's order. */
+    readonly programs: readonly string[];
+}
+/** One I/O module. */
+export interface L5xModule {
+    /** Module name. */
+    readonly name: string;
+    /** Catalog number, empty string when the export declares none. */
+    readonly catalogNumber: string;
+    /** Parent module name, empty string for a module the controller owns directly. */
+    readonly parentModule: string;
+    /** Description, when the module has one. */
+    readonly description?: string;
+    /** First port's `Address`, which is the slot for a chassis module. */
+    readonly slot?: string;
+    /** Present and true only when the export marks the module `Inhibited="true"`. */
+    readonly inhibited?: boolean;
+}
+/** Alarm metadata found in an export; trigger semantics are not inferred. */
+export interface L5xAlarm {
+    readonly name: string;
+    readonly kind: string;
+    readonly description: string;
+}
+/** The controller-level summary a project listing reports. */
+export interface L5xControllerSummary {
+    /** Controller name as the export declares it. */
+    readonly name: string;
+    /** Processor type as the export declares it, e.g. `1756-L83E`. */
+    readonly processorType: string;
+    /** Description, empty string when the controller has none. */
+    readonly description: string;
+    /** Major revision as written, empty string when the export omits it. */
+    readonly majorRev: string;
+    /** Minor revision as written, empty string when the export omits it. */
+    readonly minorRev: string;
+}
+/**
+ * A parsed `.l5x` document.
+ *
+ * Reading it is pure: the same text always yields the same entries, so a caller
+ * may parse once and run every read against the result.
+ */
+export interface L5xDocument {
+    /** Controller metadata. */
+    readonly controller: L5xControllerSummary;
+    /** Programs in the export's order. */
+    readonly programs: readonly L5xProgram[];
+    /** Tasks in the export's order. */
+    readonly tasks: readonly L5xTask[];
+    /** Ladder and Structured Text routines of every program, in export order. */
+    readonly routines: readonly L5xRoutine[];
+    /** Controller-scoped tags first, then each program's, in export order. */
+    readonly tags: readonly L5xTag[];
+    /** User-defined types in the export's order. */
+    readonly udts: readonly L5xUdt[];
+    /** Add-on instruction definitions in the export's order. */
+    readonly aois: readonly L5xAoiDefinition[];
+    /** I/O modules in the export's order. */
+    readonly modules: readonly L5xModule[];
+    /** Alarm declarations recognized structurally in the export. */
+    readonly alarms: readonly L5xAlarm[];
+}
+/** One place a symbol appears. */
+export interface L5xSymbolReference {
+    /** Program holding the reference; absent when the reference is inside an AOI. */
+    readonly program?: string;
+    /** Add-on instruction holding the reference; absent for a program routine. */
+    readonly aoi?: string;
+    /** Routine holding the reference. */
+    readonly routine: string;
+    /** Rung number, for a ladder reference. */
+    readonly rung?: number;
+    /** Line number, for a Structured Text reference. */
+    readonly line?: number;
+    /** The rung text or source line the symbol was found in. */
+    readonly context: string;
+}
+/** One symbol and every place it appears. */
+export interface L5xSymbolUsage {
+    /** The symbol as it was written, including any dotted member path. */
+    readonly symbol: string;
+    /** The references, in the order the routines were scanned. */
+    readonly references: readonly L5xSymbolReference[];
+}
+/** What a project listing reports. */
+export interface L5xProjectSummary {
+    /** Controller name. */
+    readonly controller: string;
+    /** Processor type, e.g. `1756-L83E`. */
+    readonly processorType: string;
+    /** Description, empty string when the controller has none. */
+    readonly description: string;
+    /** Firmware as `major.minor`, empty when the export declares no revision. */
+    readonly firmware: string;
+    /** Programs, in written order. */
+    readonly programs: readonly L5xProgram[];
+    /** Tasks, in written order. */
+    readonly tasks: readonly L5xTask[];
+    /** How many user-defined types the project defines. */
+    readonly udtCount: number;
+    /** Those type names, in written order. */
+    readonly udts: readonly string[];
+    /** How many add-on instructions the project defines. */
+    readonly aoiCount: number;
+    /** Those instruction names, in written order. */
+    readonly aois: readonly string[];
+    /** How many I/O modules the controller owns. */
+    readonly moduleCount: number;
+    /** How many tags exist across every scope. */
+    readonly tagCount: number;
+}

package/vendor/l5x/lib/model/types.js

@@ -0,0 +1,12 @@
+/**
+ * The parsed-document seam: what a Studio 5000 `.l5x` export becomes once it is
+ * parsed, and what reading it yields.
+ *
+ * Types only — parsing, the read functions, and their errors live beside this
+ * file. A document is lossless JSON with no XML nodes in it: an SDK caller, a
+ * Remote caller, and an in-process reader all see the same vocabulary, and no
+ * payload carries raw XML. Absent means absent: an entry omits a field the
+ * export did not supply rather than filling it with a placeholder, because the
+ * reference server's JSON omits it too.
+ */
+export {};