@tsplc/opcua 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,681 @@
+// packages/opcua/src/native.ts
+import"reflect-metadata";
+var [client, certificates] = await Promise.all([
+  import("node-opcua-client"),
+  import("node-opcua-certificate-manager")
+]);
+var {
+  AttributeIds,
+  DataType,
+  VariantArrayType,
+  MessageSecurityMode,
+  OPCUAClient,
+  SecurityPolicy,
+  UserTokenType,
+  TimestampsToReturn,
+  BrowseDirection,
+  makeResultMask,
+  NodeClass,
+  ObjectIds,
+  resolveNodeId
+} = client;
+var { OPCUACertificateManager } = certificates;
+
+// packages/opcua/src/discovery.ts
+var MAX_DISCOVERY_DEPTH = 15;
+var MAX_DISCOVERY_NODES = 1e4;
+async function* browseReferences(session, nodeId) {
+  let result = await session.browse({
+    browseDirection: BrowseDirection.Forward,
+    includeSubtypes: true,
+    nodeId,
+    referenceTypeId: "HierarchicalReferences",
+    resultMask: makeResultMask("NodeClass | BrowseName")
+  });
+  try {
+    while (true) {
+      if (!result.statusCode.isGood()) {
+        throw new Error(`Browse failed for ${nodeId}: ${result.statusCode.toString()}`);
+      }
+      yield* result.references ?? [];
+      if (!result.continuationPoint?.length) {
+        return;
+      }
+      result = await session.browseNext(result.continuationPoint, false);
+    }
+  } finally {
+    if (result.continuationPoint?.length) {
+      await session.browseNext(result.continuationPoint, true);
+    }
+  }
+}
+var discoverVariables = async (session, paths) => {
+  const expectedPaths = new Set(paths);
+  const roots = [...new Set(paths.map((path) => path.split(".")[0]))];
+  const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const globalListMarker = new RegExp(`\\.(?:${roots.map(escape).join("|")})\\.`);
+  const nodes = new Map;
+  const visited = new Set;
+  const queue = [
+    { nodeId: ObjectIds.ObjectsFolder, path: "", depth: 0 }
+  ];
+  for (let cursor = 0;cursor < queue.length; cursor++) {
+    const { nodeId, path, depth } = queue[cursor];
+    const id = resolveNodeId(nodeId).toString();
+    if (visited.has(id)) {
+      continue;
+    }
+    if (depth > MAX_DISCOVERY_DEPTH || visited.size >= MAX_DISCOVERY_NODES) {
+      throw new Error("OPC UA address space exceeds the discovery limit");
+    }
+    visited.add(id);
+    const references = [];
+    for await (const reference of browseReferences(session, id))
+      references.push(reference);
+    const rootScope = references.some((reference) => roots.includes(reference.browseName.name ?? ""));
+    for (const reference of references) {
+      const { name } = reference.browseName;
+      if (!name || ["Server", "Types", "Aliases"].includes(name) || rootScope && !roots.includes(name)) {
+        continue;
+      }
+      const parentName = path.slice(path.lastIndexOf(".") + 1);
+      const childName = name.startsWith(`${parentName}[`) ? name.slice(parentName.length) : name;
+      const childPath = /^\[\d+\]$/.test(childName) ? `${path}${childName}` : `${path}.${name}`;
+      const marker = childPath.search(globalListMarker);
+      const variablePath = marker < 0 ? "" : childPath.slice(marker + 1);
+      const childId = reference.nodeId.toString();
+      if (reference.nodeClass === NodeClass.Variable && expectedPaths.has(variablePath)) {
+        const existing = nodes.get(variablePath);
+        if (existing && existing !== childId) {
+          throw new Error(`Ambiguous OPC UA binding: ${variablePath}`);
+        }
+        nodes.set(variablePath, childId);
+        continue;
+      }
+      if (reference.nodeClass === NodeClass.Object || reference.nodeClass === NodeClass.Variable) {
+        if (variablePath && !paths.some((path) => path.startsWith(variablePath + ".") || path.startsWith(variablePath + "[")))
+          continue;
+        queue.push({ nodeId: childId, path: childPath, depth: depth + 1 });
+      }
+    }
+  }
+  return nodes;
+};
+// packages/opcua/src/variables.ts
+var BATCH_SIZE = 50;
+var isInteger = (min, max) => (value) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+var scalarTypes = {
+  BOOL: {
+    accepts: (value) => typeof value === "boolean",
+    dataType: DataType.Boolean
+  },
+  BYTE: { accepts: isInteger(0, 255), dataType: DataType.Byte },
+  DINT: {
+    accepts: isInteger(-2147483648, 2147483647),
+    dataType: DataType.Int32
+  },
+  DWORD: { accepts: isInteger(0, 4294967295), dataType: DataType.UInt32 },
+  INT: { accepts: isInteger(-32768, 32767), dataType: DataType.Int16 },
+  LREAL: {
+    accepts: (value) => typeof value === "number" && Number.isFinite(value),
+    dataType: DataType.Double
+  },
+  REAL: {
+    accepts: (value) => typeof value === "number" && Number.isFinite(value),
+    dataType: DataType.Float
+  },
+  SINT: { accepts: isInteger(-128, 127), dataType: DataType.SByte },
+  UDINT: { accepts: isInteger(0, 4294967295), dataType: DataType.UInt32 },
+  UINT: { accepts: isInteger(0, 65535), dataType: DataType.UInt16 },
+  USINT: { accepts: isInteger(0, 255), dataType: DataType.Byte },
+  WORD: { accepts: isInteger(0, 65535), dataType: DataType.UInt16 }
+};
+var scalarTypeFor = (type) => {
+  const capacity = /^STRING\((\d+)\)$/.exec(type)?.[1];
+  if (capacity === undefined) {
+    return scalarTypes[type];
+  }
+  return {
+    accepts: (value) => typeof value === "string" && !value.includes("\x00") && Buffer.byteLength(value, "utf8") <= Number(capacity),
+    dataType: DataType.String
+  };
+};
+var byteBufferLength = (type) => {
+  const match = /^ARRAY\[0\.\.(\d+)\] OF BYTE$/.exec(type);
+  return match ? Number(match[1]) + 1 : null;
+};
+var byteArrayValue = (value, length) => {
+  const bytes = value instanceof Uint8Array ? Array.from(value) : value;
+  if (!Array.isArray(bytes) || bytes.length !== length) {
+    return null;
+  }
+  return bytes.every(isInteger(0, 255)) ? bytes : null;
+};
+var badReading = (status) => ({
+  quality: "bad",
+  status,
+  value: null
+});
+var toReading = (variable, data) => {
+  if (!data.statusCode.isGood()) {
+    return badReading(data.statusCode.toString());
+  }
+  const value = data.value.value;
+  const bufferLength = byteBufferLength(variable.type);
+  if (bufferLength !== null) {
+    const bytes = byteArrayValue(value, bufferLength);
+    const typeMatches = data.value.dataType === DataType.Byte && data.value.arrayType === VariantArrayType.Array || data.value.dataType === DataType.ByteString && data.value.arrayType === VariantArrayType.Scalar;
+    if (!typeMatches || !bytes) {
+      return badReading("Unexpected OPC UA byte buffer type or length");
+    }
+    return {
+      quality: "good",
+      status: data.statusCode.toString(),
+      value: bytes
+    };
+  }
+  const scalar = typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+  if (!scalar || data.value.dataType !== scalarTypeFor(variable.type)?.dataType || data.value.arrayType !== VariantArrayType.Scalar) {
+    return badReading("Unexpected OPC UA data type");
+  }
+  return { quality: "good", status: data.statusCode.toString(), value };
+};
+var readVariables = async (session, nodes, selected) => {
+  const readings = Object.fromEntries(selected.map(({ path }) => [
+    path,
+    { quality: "unavailable", status: "Symbol not published", value: null }
+  ]));
+  const bound = selected.flatMap((variable) => {
+    const nodeId = nodes.get(variable.path);
+    return nodeId ? [{ nodeId, variable }] : [];
+  });
+  const batches = Array.from({ length: Math.ceil(bound.length / BATCH_SIZE) }, (_, index) => bound.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE));
+  await Promise.all(batches.map(async (batch) => {
+    const values = await session.read(batch.map(({ nodeId }) => ({ attributeId: AttributeIds.Value, nodeId })), 0);
+    if (values.length !== batch.length) {
+      throw new Error("Incomplete OPC UA read response");
+    }
+    for (const [index, { variable }] of batch.entries()) {
+      const data = values[index];
+      if (!data) {
+        throw new Error("Missing OPC UA value in read response");
+      }
+      readings[variable.path] = toReading(variable, data);
+    }
+  }));
+  return readings;
+};
+
+class VariableWriteError extends Error {
+  results;
+  constructor(results, cause) {
+    super("PLC write did not succeed for every field; inspect results before retrying", { cause });
+    this.name = "VariableWriteError";
+    this.results = results;
+  }
+}
+var notAttempted = (updates) => updates.map(({ variable }) => ({
+  path: variable.path,
+  status: "Not attempted",
+  written: false
+}));
+var prepareWrite = (session, nodes, { variable, value }) => {
+  const nodeId = nodes.get(variable.path);
+  if (!nodeId) {
+    throw new Error(`Symbol not published: ${variable.path}`);
+  }
+  const invalid = new Error(`Invalid ${variable.type} value for ${variable.path}`);
+  const bufferLength = byteBufferLength(variable.type);
+  if (bufferLength === null) {
+    const scalarType = scalarTypeFor(variable.type);
+    if (!scalarType?.accepts(value)) {
+      throw invalid;
+    }
+    const request = {
+      attributeId: AttributeIds.Value,
+      nodeId,
+      value: {
+        value: {
+          arrayType: VariantArrayType.Scalar,
+          dataType: scalarType.dataType,
+          value
+        }
+      }
+    };
+    return () => Promise.resolve(request);
+  }
+  const bytes = byteArrayValue(value, bufferLength);
+  if (!bytes) {
+    throw invalid;
+  }
+  return async () => {
+    const [current] = await session.read([{ attributeId: AttributeIds.Value, nodeId }], 0);
+    if (!current || toReading(variable, current).quality !== "good") {
+      throw new Error(`Cannot determine byte-buffer representation: ${variable.path}`);
+    }
+    return {
+      attributeId: AttributeIds.Value,
+      nodeId,
+      value: {
+        value: {
+          arrayType: current.value.arrayType,
+          dataType: current.value.dataType,
+          value: Buffer.from(bytes)
+        }
+      }
+    };
+  };
+};
+var writeVariables = async (session, nodes, updates) => {
+  const prepared = updates.map((update) => prepareWrite(session, nodes, update));
+  const requests = await Promise.all(prepared.map((build) => build()));
+  const results = [];
+  for (let offset = 0;offset < requests.length; offset += BATCH_SIZE) {
+    const batch = requests.slice(offset, offset + BATCH_SIZE);
+    const batchUpdates = updates.slice(offset, offset + batch.length);
+    const remaining = updates.slice(offset + batch.length);
+    const statuses = await session.write(batch).catch((cause) => {
+      throw new VariableWriteError([
+        ...results,
+        ...batchUpdates.map(({ variable }) => ({
+          path: variable.path,
+          status: "Unknown write outcome",
+          written: null
+        })),
+        ...notAttempted(remaining)
+      ], cause);
+    });
+    for (const [index, { variable }] of batchUpdates.entries()) {
+      const status = statuses[index];
+      results.push({
+        path: variable.path,
+        status: status?.toString() ?? "Missing write result",
+        written: status ? status.isGood() : null
+      });
+    }
+    if (statuses.length !== batch.length || results.some(({ written }) => written !== true)) {
+      throw new VariableWriteError([...results, ...notAttempted(remaining)]);
+    }
+  }
+  return results;
+};
+// packages/opcua/src/variable-manager.ts
+var newBranch = () => ({ children: new Map, kind: "branch" });
+var fieldKeys = (field) => (field.match(/[^.[\]]+|\[\d+\]/g) ?? []).map((part) => part.startsWith("[") ? Number(part.slice(1, -1)) : part);
+var buildSchemas = (variables) => {
+  const schemas = new Map;
+  for (const variable of variables) {
+    if (!variable.field)
+      continue;
+    const name = variable.path.slice(0, -(variable.field.length + 1));
+    const schema = schemas.get(name) ?? { fields: [], root: newBranch() };
+    schemas.set(name, schema);
+    schema.fields.push(variable);
+    const keys = fieldKeys(variable.field);
+    const leafKey = keys.pop();
+    if (leafKey === undefined) {
+      throw new Error(`Empty PLC field: ${variable.path}`);
+    }
+    const parent = keys.reduce((branch, key) => {
+      const child = branch.children.get(key) ?? newBranch();
+      if (child.kind !== "branch") {
+        throw new Error(`Conflicting PLC field: ${variable.path}`);
+      }
+      branch.children.set(key, child);
+      return child;
+    }, schema.root);
+    parent.children.set(leafKey, { kind: "leaf", variable });
+  }
+  return schemas;
+};
+var arrayKeys = (branch) => [...branch.children.keys()].filter((key) => typeof key === "number").sort((a, b) => a - b);
+var assemble = (node, readings) => {
+  if (node.kind === "leaf") {
+    const reading = readings[node.variable.path];
+    if (reading?.quality !== "good" || reading.value === null) {
+      throw new Error(`Cannot read ${node.variable.path}: ${reading?.status ?? "Missing value"}`);
+    }
+    return reading.value;
+  }
+  const keys = arrayKeys(node);
+  if (keys.length) {
+    return keys.map((key) => {
+      const child = node.children.get(key);
+      if (!child) {
+        throw new Error(`Missing PLC array element: ${key}`);
+      }
+      return assemble(child, readings);
+    });
+  }
+  return Object.fromEntries([...node.children].map(([key, child]) => [key, assemble(child, readings)]));
+};
+var collectUpdates = (node, patch, path) => {
+  if (node.kind === "leaf") {
+    return [{ value: patch, variable: node.variable }];
+  }
+  if (!patch || typeof patch !== "object" || !Array.isArray(patch) && Object.getPrototypeOf(patch) !== Object.prototype && Object.getPrototypeOf(patch) !== null) {
+    throw new Error(`Expected an object patch for ${path}`);
+  }
+  const keys = arrayKeys(node);
+  if (!keys.length && Array.isArray(patch)) {
+    throw new Error(`Expected a struct patch for ${path}`);
+  }
+  return Object.keys(patch).flatMap((key) => {
+    const value = Reflect.get(patch, key);
+    const index = Number(key);
+    const arrayKey = keys.length && Number.isInteger(index) && index >= 0 && String(index) === key ? keys[index] : undefined;
+    const child = keys.length ? node.children.get(arrayKey ?? -1) : node.children.get(key);
+    if (!child) {
+      throw new Error(`Unknown PLC field or array index: ${path}.${key}`);
+    }
+    return collectUpdates(child, value, `${path}.${key}`);
+  });
+};
+var createVariableManager = (connection, variables) => {
+  const schemas = buildSchemas(variables);
+  const schemaFor = (name) => {
+    const schema = schemas.get(name);
+    if (!schema) {
+      throw new Error(`Unknown PLC variable: ${name}`);
+    }
+    return schema;
+  };
+  return {
+    async get(name) {
+      const schema = schemaFor(name);
+      const binding = connection.getVariableSession();
+      const readings = await readVariables(binding.session, binding.nodes, schema.fields);
+      if (connection.getVariableSession() !== binding) {
+        throw new Error("PLC session changed during read");
+      }
+      return assemble(schema.root, readings);
+    },
+    async set(name, patch) {
+      const schema = schemaFor(name);
+      const updates = collectUpdates(schema.root, patch, name);
+      if (!updates.length) {
+        throw new Error(`Empty PLC patch: ${name}`);
+      }
+      const { session, nodes } = connection.getVariableSession();
+      return await writeVariables(session, nodes, updates);
+    }
+  };
+};
+// packages/opcua/src/machines.ts
+import { z } from "zod";
+var createMachineClient = (definition, options) => ({
+  telemetry: {
+    read: async () => {
+      const fields = Object.entries(definition.telemetry);
+      const values = await options.read([
+        definition.versionPath,
+        ...fields.map(([, field]) => field.path)
+      ]);
+      if (values.length !== fields.length + 1 || values[0] !== definition.version)
+        throw new Error("Machine interface version differs from the generated contract.");
+      const snapshot = Object.fromEntries(fields.map(([name], index) => [name, values[index + 1]]));
+      return z.custom((value) => typeof value === "object" && value !== null && fields.every(([name, field]) => {
+        const item = Reflect.get(value, name);
+        return typeof item === field.kind && (field.kind !== "number" || typeof item === "number" && Number.isFinite(item));
+      })).parse(snapshot);
+    }
+  }
+});
+
+// packages/opcua/src/client.ts
+var connectPlc = async (options) => {
+  const secure = options.security !== "None";
+  const client = OPCUAClient.create({
+    applicationName: options.applicationName ?? "tsPLC",
+    clientCertificateManager: new OPCUACertificateManager({
+      rootFolder: options.certificateDirectory,
+      automaticallyAcceptUnknownCertificate: false
+    }),
+    connectionStrategy: { maxRetry: 0 },
+    defaultTransactionTimeout: 5000,
+    transportTimeout: 5000,
+    keepSessionAlive: true,
+    endpointMustExist: false,
+    securityMode: secure ? MessageSecurityMode.SignAndEncrypt : MessageSecurityMode.None,
+    securityPolicy: secure ? SecurityPolicy.Basic256Sha256 : SecurityPolicy.None
+  });
+  try {
+    await client.connect(options.endpoint);
+    const session = await client.createSession(options.credentials ? {
+      type: UserTokenType.UserName,
+      userName: options.credentials.username,
+      password: options.credentials.password
+    } : { type: UserTokenType.Anonymous });
+    return { session, disconnect: () => client.disconnect() };
+  } catch (error) {
+    await client.disconnect();
+    throw error;
+  }
+};
+var connectMachine = async (definition, options) => {
+  const connection = await connectPlc(options);
+  try {
+    const paths = [
+      definition.versionPath,
+      ...Object.values(definition.telemetry).map((field) => field.path)
+    ];
+    const nodes = await discoverVariables(connection.session, paths);
+    const readNodes = paths.map((path) => {
+      const nodeId = nodes.get(path);
+      if (!nodeId)
+        throw new Error(`Machine symbol is not published: ${path}`);
+      return { nodeId, attributeId: AttributeIds.Value };
+    });
+    const read = async (selected) => {
+      const requests = selected.map((path) => {
+        const nodeId = nodes.get(path);
+        if (!nodeId)
+          throw new Error(`Unknown machine symbol: ${path}`);
+        return { nodeId, attributeId: AttributeIds.Value };
+      });
+      const values = await connection.session.read(requests, 0);
+      if (values.length !== requests.length || values.some((value) => !value.statusCode.isGood()))
+        throw new Error("Machine telemetry read failed");
+      return values.map((value) => value.value.value);
+    };
+    const machine = createMachineClient(definition, { read });
+    await machine.telemetry.read();
+    return {
+      telemetry: {
+        ...machine.telemetry,
+        subscribe: async (listener, onError) => {
+          const subscription = await connection.session.createSubscription2({
+            requestedPublishingInterval: 100,
+            requestedLifetimeCount: 100,
+            requestedMaxKeepAliveCount: 10,
+            maxNotificationsPerPublish: 100,
+            publishingEnabled: true,
+            priority: 0
+          });
+          let disposed = false, reading = false;
+          const refresh = () => {
+            if (disposed || reading)
+              return;
+            reading = true;
+            machine.telemetry.read().then((value) => {
+              if (!disposed)
+                listener(value);
+            }).catch(onError).finally(() => {
+              reading = false;
+            });
+          };
+          try {
+            const monitored = await subscription.monitorItems(readNodes, { samplingInterval: 100, discardOldest: true, queueSize: 1 }, TimestampsToReturn.Both);
+            monitored.on("changed", refresh);
+            subscription.on("error", onError);
+            refresh();
+            return {
+              unsubscribe: async () => {
+                disposed = true;
+                await subscription.terminate();
+              }
+            };
+          } catch (error) {
+            await subscription.terminate();
+            throw error;
+          }
+        }
+      },
+      disconnect: connection.disconnect
+    };
+  } catch (error) {
+    await connection.disconnect();
+    throw error;
+  }
+};
+// packages/opcua/src/plc.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// packages/opcua/src/contract.ts
+var contractVariables = (contract, published) => {
+  const selected = published && new Set(published);
+  return contract.symbols.filter((symbol) => !selected || selected.has(`${symbol.gvl}.${symbol.name}`)).flatMap((symbol) => {
+    const fields = contract.typeFields[symbol.type];
+    if (!fields && symbol.type.startsWith("ARRAY["))
+      return [
+        {
+          description: "",
+          device: symbol.name,
+          field: "",
+          path: `${symbol.gvl}.${symbol.name}`,
+          type: symbol.type
+        }
+      ];
+    if (!fields)
+      throw new Error(`Missing generated fields for ${symbol.type}.`);
+    return fields.map(({ field, type, description }) => ({
+      description,
+      device: symbol.name,
+      field,
+      path: `${symbol.gvl}.${symbol.name}${field.startsWith("[") ? "" : "."}${field}`,
+      type
+    }));
+  });
+};
+
+// packages/opcua/src/snapshot.ts
+var unavailableSnapshot = (error) => ({
+  connected: false,
+  error,
+  updatedAt: null,
+  values: {}
+});
+
+// packages/opcua/src/plc.ts
+var pollIntervalMs = 1000;
+var reconnectDelayMs = 2000;
+var staleAfterMs = 5000;
+var sleep = (ms, signal) => delay(ms, undefined, { signal }).catch(() => {
+  return;
+});
+var createPlc = (options) => {
+  const variables = contractVariables(options.contract, options.publication);
+  let state = unavailableSnapshot("Waiting for the PLC");
+  let binding = null;
+  const currentBinding = () => {
+    if (!binding)
+      throw new Error("PLC is not connected");
+    return binding;
+  };
+  const snapshot = () => state.updatedAt && Date.now() - Date.parse(state.updatedAt) > staleAfterMs ? unavailableSnapshot("PLC data is stale; waiting for a fresh read") : state;
+  const poll = async (signal) => {
+    const client = await connectPlc(options);
+    const clear = () => {
+      binding = null;
+    };
+    signal.addEventListener("abort", clear, { once: true });
+    try {
+      client.session.on("session_closed", clear);
+      signal.throwIfAborted();
+      const nodes = await discoverVariables(client.session, variables.map(({ path }) => path));
+      if (!nodes.size)
+        throw new Error("No declared PLC symbols are published. Check the downloaded program and OPC UA symbol configuration.");
+      options.log?.info(`Connected to the PLC (${nodes.size} symbols)`);
+      signal.throwIfAborted();
+      binding = { nodes, session: client.session };
+      while (!signal.aborted) {
+        const values = await readVariables(client.session, nodes, variables);
+        signal.throwIfAborted();
+        state = { connected: true, error: null, updatedAt: new Date().toISOString(), values };
+        await sleep(pollIntervalMs, signal);
+      }
+    } finally {
+      clear();
+      signal.removeEventListener("abort", clear);
+      await client.disconnect();
+    }
+  };
+  const run = async (signal) => {
+    while (!signal.aborted) {
+      try {
+        await poll(signal);
+      } catch (error) {
+        if (signal.aborted)
+          return;
+        const message = error instanceof Error ? error.message : "OPC UA connection failed";
+        if (state.error !== message)
+          options.log?.warn("PLC connection unavailable; retrying", error);
+        state = unavailableSnapshot(message);
+      }
+      await sleep(reconnectDelayMs, signal);
+    }
+  };
+  return {
+    run,
+    snapshot,
+    ...createVariableManager({ getVariableSession: currentBinding }, variables),
+    read: async (paths) => {
+      const selected = new Set(paths);
+      const current = currentBinding();
+      const readings = await readVariables(current.session, current.nodes, variables.filter(({ path }) => selected.has(path)));
+      if (binding !== current)
+        throw new Error("PLC session changed during read");
+      return readings;
+    },
+    write: async (values) => {
+      const current = currentBinding();
+      const byPath = new Map(variables.map((variable) => [variable.path, variable]));
+      return writeVariables(current.session, current.nodes, [...values].map(([path, value]) => {
+        const variable = byPath.get(path);
+        if (!variable)
+          throw new Error(`Unknown or unpublished PLC variable ${path}`);
+        return { variable, value };
+      }));
+    },
+    session: () => currentBinding().session,
+    machine: (definition) => createMachineClient(definition, {
+      read: (paths) => {
+        const { values } = snapshot();
+        return paths.map((path) => {
+          const reading = values[path];
+          if (reading?.quality !== "good")
+            throw new Error(`PLC telemetry unavailable: ${path}`);
+          return reading.value;
+        });
+      }
+    })
+  };
+};
+export {
+  AttributeIds,
+  DataType,
+  VariableWriteError,
+  connectMachine,
+  connectPlc,
+  contractVariables,
+  createMachineClient,
+  createPlc,
+  createVariableManager,
+  discoverVariables,
+  readVariables,
+  unavailableSnapshot,
+  writeVariables
+};
+
+//# debugId=5B6F261ED0979A6864756E2164756E21
+//# sourceMappingURL=index.js.map