npm - @tsplc/server - Versions diffs - 0.0.0-stage → 0.1.0 - Mend

@tsplc/server 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/dist/serve.js ADDED Viewed

@@ -0,0 +1,711 @@
+// packages/server/src/serve.ts
+import { timingSafeEqual } from "node:crypto";
+import { setTimeout as delay2 } from "node:timers/promises";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+import { z as z2 } from "zod";
+// packages/server/src/hmi-page.ts
+var escape = (value) => value.replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+var hmiPage = (title) => `<!doctype html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${escape(title)}</title>
+<style>
+:root{--bg:#f6f7f9;--panel:#fff;--fg:#1c2026;--muted:#6b7280;--border:#d8dce3;--on:#16a34a;--off:#dc2626;--box:#2563eb;--empty:#e7e9ee;--diverter:#c9ced8}
+@media (prefers-color-scheme:dark){:root{--bg:#111318;--panel:#191c22;--fg:#e6e8ec;--muted:#9aa1ad;--border:#2c313a;--empty:#262a32;--diverter:#3a404b}}
+*{box-sizing:border-box}body{margin:0;font:15px system-ui,sans-serif;background:var(--bg);color:var(--fg)}
+header{display:flex;gap:14px;align-items:center;padding:12px 16px;background:var(--panel);border-bottom:1px solid var(--border)}
+h1{font-size:19px;margin:0;flex:1}h2{font-size:14px;margin:0 0 10px;color:var(--muted);font-weight:600}
+.pill{padding:4px 12px;border-radius:99px;color:#fff;font-weight:600;background:var(--off)}.pill.on{background:var(--on)}
+#stale{display:none;padding:12px 16px;background:var(--off);color:#fff;font-weight:600}
+main{display:grid;gap:14px;padding:14px;grid-template-columns:minmax(0,1fr) minmax(280px,380px)}
+@media (max-width:800px){main{grid-template-columns:minmax(0,1fr)}}
+section{background:var(--panel);border:1px solid var(--border);border-radius:10px;padding:14px;margin-bottom:14px}
+.controls{display:flex;flex-wrap:wrap;gap:12px;align-items:center}
+button{font:600 17px system-ui;padding:14px 28px;border:0;border-radius:9px;background:var(--diverter);color:var(--fg);cursor:pointer;touch-action:manipulation}
+button.start{background:var(--on);color:#fff}button.stop{background:var(--off);color:#fff}button:disabled{opacity:.45;cursor:default}
+label{display:flex;gap:10px;align-items:center;flex:1 1 280px}input[type=range]{flex:1;height:30px}output{min-width:3ch;font-weight:600;text-align:right}
+.strip{display:flex;flex-wrap:wrap;gap:3px;margin-bottom:14px}.strip:last-child{margin-bottom:0}
+.zone{min-width:30px;height:38px;flex:1 0 30px;display:grid;place-items:center;border-radius:4px;background:var(--empty);color:var(--muted);font-size:11px}
+.zone.diverter{outline:2px solid var(--diverter);outline-offset:-2px}.zone.occupied{background:var(--box);color:#fff;font-weight:600}.zone.stuck{background:var(--off)}
+table{width:100%;border-collapse:collapse}td,th{padding:5px 6px;text-align:left;border-bottom:1px solid var(--border);font-size:13px}
+.toggle{display:flex;flex:none;padding:7px 0;justify-content:space-between;border-bottom:1px solid var(--border)}.toggle input{width:26px;height:26px}#error{color:var(--off);font-weight:600;min-height:1.3em;margin-top:10px}
+</style></head><body>
+<header><h1>${escape(title)}</h1><span class="pill" id="running"></span><span class="pill" id="plc"></span></header>
+<div id="stale"></div>
+<main><div>
+<section><h2>Controls</h2><div class="controls" id="controls"></div><div id="error"></div></section>
+<section><h2>Line</h2><div id="line"></div></section>
+</div><div>
+<section><h2>Blocked for over a minute</h2><table><tbody id="blocked"></tbody></table></section>
+<section><h2>Switches</h2><div id="toggles"></div></section>
+</div></main>
+<script>
+const $ = (id) => document.getElementById(id);
+const row = (cells) => { const tr = document.createElement("tr"); for (const cell of cells) { const td = document.createElement("td"); td.textContent = cell; tr.append(td); } return tr; };
+let built = false, dragging = false;
+const send = async (body) => {
+  $("error").textContent = "";
+  try {
+    const response = await fetch("/hmi/control", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    if (!response.ok) $("error").textContent = (await response.json()).message;
+  } catch { $("error").textContent = "Could not reach the server"; }
+};
+const build = (controls) => {
+  for (const control of controls) {
+    if (control.kind === "toggle") {
+      const label = document.createElement("label"), input = document.createElement("input");
+      label.className = "toggle"; label.append(control.label, input);
+      input.type = "checkbox"; input.id = "control" + control.index;
+      input.onchange = () => send({ index: control.index, value: input.checked ? 1 : 0 });
+      $("toggles").append(label);
+    } else if (control.kind === "button") {
+      const button = document.createElement("button");
+      button.textContent = control.label; button.id = "control" + control.index;
+      if (control.tone) button.className = control.tone;
+      button.onclick = () => { if (!control.confirm || confirm(control.label + "?")) send({ index: control.index }); };
+      $("controls").append(button);
+    } else {
+      const label = document.createElement("label"), input = document.createElement("input"), output = document.createElement("output");
+      label.append(control.label, input, output);
+      input.type = "range"; input.min = control.min; input.max = control.max; input.id = "control" + control.index;
+      input.onpointerdown = () => { dragging = true; };
+      input.oninput = () => { output.textContent = input.value; };
+      input.onchange = () => { dragging = false; send({ index: control.index, value: Number(input.value) }); };
+      $("controls").append(label);
+    }
+  }
+};
+const render = (state) => {
+  if (!built) { build(state.controls); built = true; }
+  $("plc").textContent = state.connected ? "PLC connected" : "PLC disconnected"; $("plc").className = "pill" + (state.connected ? " on" : "");
+  $("running").textContent = state.running ? "Running" : "Stopped"; $("running").className = "pill" + (state.running ? " on" : "");
+  const stale = state.reportAgeMs === null || state.reportAgeMs > 2000;
+  const problem = !state.connected ? "No connection to the PLC: controls and values below may be out of date." : stale ? "No data from the PLC: the line view below may be out of date." : "";
+  $("stale").textContent = problem; $("stale").style.display = problem ? "block" : "none";
+  for (const control of state.controls) {
+    const element = $("control" + control.index);
+    // Stop stays available: a failed press reports its error rather than hiding the button.
+    element.disabled = !state.connected && control.tone !== "stop";
+    if (control.kind === "toggle" && control.value !== null) element.checked = control.value;
+    if (control.kind === "slider" && !dragging && control.value !== null && document.activeElement !== element) {
+      element.value = control.value; element.nextElementSibling.textContent = control.value;
+    }
+  }
+  const blocked = [];
+  $("line").replaceChildren(...state.conveyors.flatMap((conveyor) => {
+    const name = document.createElement("h2"); name.textContent = conveyor.label;
+    const strip = document.createElement("div"); strip.className = "strip";
+    conveyor.zones.forEach(({ occupied, blockedMs }, position) => {
+      const zone = document.createElement("div"), stuck = blockedMs > 60000;
+      zone.className = "zone" + (conveyor.diverters.includes(position) ? " diverter" : "") + (occupied ? " occupied" : "") + (stuck ? " stuck" : "");
+      zone.textContent = position + 1; zone.title = "Position " + (position + 1);
+      if (stuck) blocked.push(row([conveyor.label, "Position " + (position + 1), Math.round(blockedMs / 60000) + " min"]));
+      strip.append(zone);
+    });
+    return [name, strip];
+  }));
+  $("blocked").replaceChildren(...(blocked.length ? blocked : [row(["Nothing"])]));
+};
+const poll = async () => {
+  try { render(await (await fetch("/hmi/state")).json()); }
+  catch { $("stale").textContent = "No connection to the server."; $("stale").style.display = "block"; }
+  setTimeout(poll, 500);
+};
+poll();
+</script></body></html>`;
+// packages/server/src/index.ts
+import { TRPCError } from "@trpc/server";
+// packages/server/src/contract.ts
+import { createHash } from "node:crypto";
+import { z } from "zod";
+var integerTypes = {
+  SINT: [-128, 127],
+  USINT: [0, 255],
+  BYTE: [0, 255],
+  INT: [-32768, 32767],
+  UINT: [0, 65535],
+  WORD: [0, 65535],
+  DINT: [-2147483648, 2147483647],
+  UDINT: [0, 4294967295],
+  DWORD: [0, 4294967295]
+};
+var integer = (type) => (bounds = {}) => z.number().int().min(bounds.min ?? integerTypes[type][0]).max(bounds.max ?? integerTypes[type][1]).meta({ iec: type });
+var iec = {
+  SINT: integer("SINT"),
+  USINT: integer("USINT"),
+  BYTE: integer("BYTE"),
+  INT: integer("INT"),
+  UINT: integer("UINT"),
+  WORD: integer("WORD"),
+  DINT: integer("DINT"),
+  UDINT: integer("UDINT"),
+  DWORD: integer("DWORD"),
+  STRING: (capacity) => z.string().max(capacity),
+  FixedArray: (element, length) => z.array(element).length(length)
+};
+var identifier = /^(?!__proto__$)[A-Za-z_][A-Za-z0-9_]*$/;
+var isIntegerType = (value) => Object.hasOwn(integerTypes, value);
+var wireScalar = (field, label) => {
+  switch (field.kind) {
+    case "boolean":
+      return { kind: "boolean" };
+    case "string":
+      if (!Number.isInteger(field.capacity) || field.capacity < 1 || field.capacity > 2048)
+        throw new Error(`${label}: string capacity must be 1..2048 bytes.`);
+      return { kind: "string", capacity: field.capacity };
+    case "integer": {
+      const [minimum, maximum] = integerTypes[field.iec];
+      if (!Number.isInteger(field.minimum) || !Number.isInteger(field.maximum))
+        throw new Error(`${label}: integer bounds must be integers.`);
+      if (field.minimum > field.maximum)
+        throw new Error(`${label}: integer bounds are contradictory.`);
+      if (field.minimum < minimum || field.maximum > maximum)
+        throw new Error(`${label}: integer bounds do not fit ${field.iec}.`);
+      return { kind: "integer", iec: field.iec, minimum: field.minimum, maximum: field.maximum };
+    }
+    case "enum": {
+      const values = Object.entries(field.members).sort((left, right) => {
+        if (left[1] === 0)
+          return -1;
+        if (right[1] === 0)
+          return 1;
+        return left[1] - right[1];
+      });
+      if (!values.length || values.some(([name, value]) => !identifier.test(name) || !Number.isInteger(value) || value < -2147483648 || value > 2147483647))
+        throw new Error(`${label}: PLC enums require named DINT values.`);
+      if (new Set(values.map(([, value]) => value)).size !== values.length)
+        throw new Error(`${label}: PLC enum values must be distinct.`);
+      return { kind: "enum", members: Object.fromEntries(values) };
+    }
+  }
+};
+var wireRecord = (fields, label, output) => {
+  const checked = {};
+  for (const key of Object.keys(fields).sort()) {
+    const field = fields[key];
+    if (!identifier.test(key))
+      throw new Error(`${label}.${key}: use an IEC field identifier.`);
+    if (field.kind !== "array") {
+      checked[key] = wireScalar(field, `${label}.${key}`);
+      continue;
+    }
+    if (output)
+      throw new Error(`${label}.${key}: the native HTTP decoder currently supports scalar response fields only.`);
+    if (!Number.isInteger(field.length) || field.length < 1 || field.length > 256)
+      throw new Error(`${label}.${key}: arrays require one fixed length from 1 to 256.`);
+    checked[key] = {
+      kind: "array",
+      length: field.length,
+      element: wireScalar(field.element, `${label}.${key}`)
+    };
+  }
+  if (Object.keys(checked).length > 31 || output && !Object.keys(checked).length)
+    throw new Error(`${label}: response records require 1..31 fields; requests allow 0..31.`);
+  return { fields: checked };
+};
+var serviceContract = (path, kind, input, output) => {
+  if (path.split(".").some((part) => !identifier.test(part)))
+    throw new Error(`${path}: PLC procedure paths require identifier segments.`);
+  const version = createHash("sha256").update(JSON.stringify({ abi: 2, path, kind, input, output })).digest("hex").slice(0, 24);
+  return { path, kind, input, output, version };
+};
+var schemaValue = (value) => typeof value === "object" && value !== null && ("_zod" in value) && ("safeParse" in value);
+var schema = (value, label) => {
+  if (!schemaValue(value))
+    throw new Error(`${label}: provide a bounded Zod input/output schema; TypeScript number/string inference has no IEC memory layout.`);
+  return value;
+};
+var jsonSchema = z.looseObject({
+  type: z.string().optional(),
+  maxLength: z.number().optional(),
+  minItems: z.number().optional(),
+  maxItems: z.number().optional(),
+  minimum: z.number().optional(),
+  maximum: z.number().optional(),
+  iec: z.string().optional()
+});
+var metadata = (value) => jsonSchema.parse(value.meta() ?? {});
+var refSchema = z.looseObject({
+  $ref: z.string().optional(),
+  $defs: z.record(z.string(), z.unknown()).optional()
+});
+var jsonFor = (value, options) => {
+  const json = refSchema.parse(z.toJSONSchema(value, options));
+  const definition = json.$ref?.startsWith("#/$defs/") ? json.$defs?.[json.$ref.slice("#/$defs/".length)] : json;
+  return jsonSchema.parse(definition);
+};
+var scalar = (value, label) => {
+  const definition = value._zod.def;
+  if (["optional", "nullable", "union", "default", "prefault", "pipe", "catch"].includes(definition.type))
+    throw new Error(`${label}: optional, nullable, transformed and defaulted wire fields are unsupported.`);
+  if (definition.type === "enum") {
+    const entries = z.record(z.string(), z.union([z.number().int(), z.string()])).parse(Reflect.get(definition, "entries"));
+    const members = {};
+    for (const [name, value] of Object.entries(entries)) {
+      if (typeof value === "number")
+        members[name] = value;
+      else if (identifier.test(name) && entries[value] !== name)
+        throw new Error(`${label}: PLC enums require only numeric members.`);
+    }
+    return { kind: "enum", members };
+  }
+  const json = jsonFor(value, { io: "input", unrepresentable: "throw" });
+  if (json.type === "boolean")
+    return { kind: "boolean" };
+  if (json.type === "string" && json.maxLength !== undefined)
+    return { kind: "string", capacity: json.maxLength };
+  const type = metadata(value).iec;
+  if (json.type === "integer" && type !== undefined && isIntegerType(type) && json.minimum !== undefined && json.maximum !== undefined)
+    return { kind: "integer", iec: type, minimum: json.minimum, maximum: json.maximum };
+  throw new Error(`${label}: use z.boolean(), z.enum() of a numeric enum, iec.STRING(), or an integer such as iec.INT(). Optional, nullable, union, float and dynamic layouts are unsupported.`);
+};
+var record = (declared, label, output) => {
+  const piped = declared._zod.def;
+  const value = !output && piped.type === "pipe" ? schema(Reflect.get(piped, "in"), label) : declared;
+  const def = value._zod.def;
+  if (def.type !== "object")
+    throw new Error(`${label}: HTTP services require a closed object schema.`);
+  const shape = z.record(z.string(), z.custom(schemaValue)).parse(Reflect.get(def, "shape"));
+  const fields = {};
+  for (const [key, item] of Object.entries(shape)) {
+    if (item._zod.def.type !== "array") {
+      fields[key] = scalar(item, `${label}.${key}`);
+      continue;
+    }
+    const bounds = jsonFor(item, { io: "input" });
+    if (bounds.maxItems === undefined || bounds.maxItems !== bounds.minItems)
+      throw new Error(`${label}.${key}: arrays require one fixed length from 1 to 256.`);
+    fields[key] = {
+      kind: "array",
+      length: bounds.maxItems,
+      element: scalar(schema(Reflect.get(item._zod.def, "element"), `${label}.${key}`), `${label}.${key}`)
+    };
+  }
+  return wireRecord(fields, label, output);
+};
+var serviceContracts = (router) => {
+  const contracts = [];
+  const procedures = z.record(z.string(), z.unknown()).parse(router._def.procedures);
+  for (const [path, procedure] of Object.entries(procedures)) {
+    if (typeof procedure !== "function" || !("_def" in procedure))
+      throw new Error("Unsupported tRPC router metadata.");
+    const reflected = z.custom((value) => typeof value === "function" && ("_def" in value)).parse(procedure);
+    const def = reflected._def;
+    if (typeof def.meta !== "object" || def.meta === null || !("plc" in def.meta) || def.meta.plc !== true)
+      continue;
+    if (def.type !== "query" && def.type !== "mutation")
+      throw new Error(`${path}: subscriptions use a different transport; expose a query or mutation to the PLC.`);
+    if (def.inputs.length > 1)
+      throw new Error(`${path}: merge the input into one bounded object schema.`);
+    const input = record(def.inputs.length ? schema(def.inputs[0], `${path}.input`) : z.strictObject({}), `${path}.Input`, false);
+    const output = record(schema(Reflect.get(def, "output"), `${path}.output`), `${path}.Output`, true);
+    contracts.push(serviceContract(path, def.type, input, output));
+  }
+  return contracts.sort((a, b) => a.path.localeCompare(b.path));
+};
+var servicePath = (contract) => `/tsplc/services/${contract.version}/${contract.path}`;
+var validateWireRecord = (record, value) => {
+  const scalarValue = (field, value) => {
+    switch (field.kind) {
+      case "boolean":
+        return typeof value === "boolean";
+      case "integer":
+        return typeof value === "number" && Number.isInteger(value) && value >= field.minimum && value <= field.maximum;
+      case "string":
+        return typeof value === "string" && !value.includes("\x00") && new TextEncoder().encode(value).length <= field.capacity;
+      case "enum":
+        return typeof value === "number" && Object.values(field.members).includes(value);
+    }
+  };
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error("Expected a closed wire record.");
+  const entries = Object.entries(value);
+  if (entries.length !== Object.keys(record.fields).length)
+    throw new Error("Wire record fields differ from the contract.");
+  for (const [name, field] of Object.entries(record.fields)) {
+    const item = Reflect.get(value, name);
+    const valid = field.kind === "array" ? Array.isArray(item) && item.length === field.length && item.every((value) => scalarValue(field.element, value)) : scalarValue(field, item);
+    if (!valid)
+      throw new Error(`Wire field ${name} violates its PLC representation.`);
+  }
+  if (new TextEncoder().encode(JSON.stringify(value)).length > 2048)
+    throw new Error("Wire record exceeds the 2048-byte native JSON limit.");
+};
+// packages/server/src/index.ts
+var createServiceHandler = (options) => {
+  const contracts = serviceContracts(options.router);
+  const paths = new Map(contracts.map((contract) => [servicePath(contract), contract]));
+  const response = (value, status = 200) => {
+    const body = JSON.stringify(value);
+    return new Response(body, {
+      status,
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        "Content-Length": String(new TextEncoder().encode(body).length),
+        "Cache-Control": "no-store"
+      }
+    });
+  };
+  return async (request) => {
+    const path = new URL(request.url).pathname;
+    const contract = paths.get(path);
+    if (!contract)
+      return response({ error: "Unknown procedure or incompatible contract" }, 409);
+    if (request.method !== "POST")
+      return response({ error: "Use POST" }, 405);
+    const length = request.headers.get("content-length");
+    if (length !== null && (!/^\d+$/.test(length) || Number(length) > 2048))
+      return response({ error: "Request exceeds the PLC wire limit" }, 413);
+    const reader = request.body?.getReader();
+    const chunks = [];
+    let size = 0;
+    if (reader)
+      try {
+        for (;; ) {
+          const chunk = await reader.read();
+          if (chunk.done)
+            break;
+          size += chunk.value.length;
+          if (size > 2048) {
+            await reader.cancel();
+            return response({ error: "Request exceeds the PLC wire limit" }, 413);
+          }
+          chunks.push(chunk.value);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    let input;
+    try {
+      input = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      validateWireRecord(contract.input, input);
+    } catch {
+      return response({ error: "Invalid procedure input" }, 400);
+    }
+    try {
+      const context = await options.createContext(request);
+      const caller = options.router.createCaller(context, { signal: request.signal });
+      const invoke = Reflect.get(caller, contract.path);
+      if (typeof invoke !== "function")
+        throw new Error("Invalid tRPC caller.");
+      const output = await invoke(input);
+      validateWireRecord(contract.output, output);
+      return response(output);
+    } catch (cause) {
+      if (cause instanceof TRPCError) {
+        const statuses = {
+          UNAUTHORIZED: 401,
+          FORBIDDEN: 403,
+          BAD_REQUEST: 400,
+          NOT_FOUND: 404,
+          CONFLICT: 409,
+          TOO_MANY_REQUESTS: 429
+        };
+        const status = statuses[cause.code];
+        if (status === undefined)
+          options.onError?.(cause);
+        return response({ error: cause.code }, status ?? 500);
+      }
+      options.onError?.(cause);
+      return response({ error: "Procedure failed" }, 500);
+    }
+  };
+};
+// packages/server/src/opcua.ts
+import { randomBytes } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { AttributeIds, DataType, discoverVariables } from "@tsplc/opcua";
+var runOpcUaServices = async (options) => {
+  if (!options.channels.length)
+    return;
+  const dispatch = createServiceHandler(options);
+  const pending = new Map;
+  const invocations = new Set;
+  const writers = new Map;
+  const handled = new Map;
+  const epochs = new Map;
+  let activeSession;
+  let connectionError;
+  let nodes = new Map;
+  const write = async (session, path, value) => {
+    const nodeId = nodes.get(path);
+    if (!nodeId)
+      throw new Error(`Missing OPC UA service channel: ${path}`);
+    const status = await session.write({
+      nodeId,
+      attributeId: AttributeIds.Value,
+      value: { value: { dataType: DataType.String, value } }
+    });
+    if (!status.isGood())
+      throw new Error(`OPC UA service write failed: ${status.toString()}`);
+  };
+  const read = async (session, paths) => {
+    const requests = paths.map((path) => {
+      const nodeId = nodes.get(path);
+      if (!nodeId)
+        throw new Error(`Missing OPC UA service channel: ${path}`);
+      return { nodeId, attributeId: AttributeIds.Value };
+    });
+    const values = await session.read(requests, 0);
+    if (values.length !== requests.length || values.some((value) => !value.statusCode.isGood()))
+      throw new Error("OPC UA service read failed");
+    return values.map((value) => value.value.value);
+  };
+  const reply = async (session, channel, identity, body, signal) => {
+    const previous = writers.get(channel.reply) ?? Promise.resolve();
+    const writing = previous.catch(() => {
+      return;
+    }).then(async () => {
+      if (signal.aborted || activeSession !== session)
+        return;
+      await write(session, channel.reply, body);
+      await write(session, channel.replyId, identity);
+    });
+    writers.set(channel.reply, writing);
+    try {
+      await writing;
+    } finally {
+      if (writers.get(channel.reply) === writing)
+        writers.delete(channel.reply);
+    }
+  };
+  try {
+    while (!options.signal.aborted) {
+      try {
+        const session = options.getSession();
+        if (session !== activeSession) {
+          for (const work of pending.values())
+            work.controller.abort();
+          nodes = await discoverVariables(session, options.channels.flatMap((channel) => [
+            channel.request,
+            channel.requestId,
+            channel.reply,
+            channel.replyId,
+            channel.epoch
+          ]));
+          epochs.clear();
+          for (const channel of options.channels) {
+            await write(session, channel.replyId, "");
+            const epoch = randomBytes(16).toString("hex");
+            await write(session, channel.epoch, epoch);
+            epochs.set(channel.request, epoch);
+          }
+          activeSession = session;
+          handled.clear();
+          options.onReady?.(session);
+        }
+        const before = await read(session, options.channels.map((channel) => channel.requestId));
+        const batch = await read(session, options.channels.flatMap((channel) => [channel.request, channel.epoch]));
+        const after = await read(session, options.channels.map((channel) => channel.requestId));
+        for (const [index, channel] of options.channels.entries()) {
+          const identity = after[index];
+          if (typeof identity !== "string")
+            throw new Error("Invalid OPC UA service identity type");
+          const current = pending.get(channel.request);
+          if (current && current.identity !== identity)
+            current.controller.abort();
+          const request = batch[index * 2], epochValue = batch[index * 2 + 1];
+          if (epochValue === "") {
+            const epoch = randomBytes(16).toString("hex");
+            await write(session, channel.epoch, epoch);
+            epochs.set(channel.request, epoch);
+            continue;
+          }
+          if (before[index] !== identity || !identity)
+            continue;
+          const epoch = epochs.get(channel.request);
+          if (epochValue !== epoch)
+            throw new Error("OPC UA service gateway ownership changed");
+          if (typeof request !== "string" || !identity.startsWith(epoch + ":") || !request.startsWith(identity + "|"))
+            continue;
+          if (handled.get(channel.request) === identity)
+            continue;
+          handled.set(channel.request, identity);
+          const controller = new AbortController;
+          const signal = AbortSignal.any([options.signal, controller.signal]);
+          const operation = (async () => {
+            if (invocations.size >= options.channels.length * 2) {
+              await reply(session, channel, identity, `${identity}|1|{}`, signal);
+              return;
+            }
+            const invocation = dispatch(new Request("http://tsplc.internal" + channel.path, {
+              method: "POST",
+              body: request.slice(identity.length + 1),
+              signal
+            }));
+            invocations.add(invocation);
+            invocation.then(() => invocations.delete(invocation), () => invocations.delete(invocation));
+            const timer = new AbortController;
+            const response = await Promise.race([
+              invocation,
+              delay(5000, undefined, { signal: AbortSignal.any([signal, timer.signal]) }).then(() => {
+                throw new Error("OPC UA service handler timed out");
+              })
+            ]).finally(() => timer.abort());
+            const body = `${identity}|${response.ok ? 0 : 1}|${response.ok ? await response.text() : "{}"}`;
+            if (Buffer.byteLength(body, "utf8") > 2048)
+              throw new Error("OPC UA service reply exceeds 2048 bytes");
+            await reply(session, channel, identity, body, signal);
+          })().catch((error) => {
+            if (!signal.aborted)
+              options.onError(error);
+          }).finally(() => {
+            if (pending.get(channel.request)?.controller === controller)
+              pending.delete(channel.request);
+          });
+          pending.set(channel.request, { identity, controller, done: operation });
+        }
+        connectionError = undefined;
+      } catch (error) {
+        activeSession = undefined;
+        for (const work of pending.values())
+          work.controller.abort();
+        const message = error instanceof Error ? error.message : String(error);
+        if (connectionError !== message) {
+          connectionError = message;
+          options.onError(error);
+        }
+        await delay(1000, undefined, { signal: options.signal });
+      }
+      await delay(20, undefined, { signal: options.signal });
+    }
+  } catch (error) {
+    if (!options.signal.aborted)
+      throw error;
+  } finally {
+    activeSession = undefined;
+    for (const work of pending.values())
+      work.controller.abort();
+    await Promise.all([...pending.values()].map((work) => work.done));
+    await Promise.allSettled(writers.values());
+  }
+};
+// packages/server/src/serve.ts
+var hmiControlRequest = z2.strictObject({
+  index: z2.number().int().nonnegative(),
+  value: z2.number().optional()
+});
+var json = (body, status = 200) => Response.json(body, { status, headers: { "Cache-Control": "no-store" } });
+var sleep = (ms, signal) => delay2(ms, undefined, { signal }).catch(() => {
+  return;
+});
+var serve = (options) => {
+  const controller = new AbortController;
+  const { signal } = controller;
+  const expected = Buffer.from(`Bearer ${options.auth.bearerToken}`);
+  const protect = (handler) => async (request) => {
+    const actual = Buffer.from(request.headers.get("authorization") ?? "");
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected))
+      return json({ message: "Unauthorized" }, 401);
+    const origin = request.headers.get("origin");
+    if (origin !== null && !options.auth.allowedOrigins.includes(origin))
+      return json({ message: "Origin is not allowed" }, 403);
+    try {
+      return await handler(request);
+    } catch (error) {
+      options.log.warn(`Request failed: ${new URL(request.url).pathname}`, error);
+      return json({ message: "Internal server error" }, 500);
+    }
+  };
+  const routes = {
+    "/health": () => json({ plcConnected: options.plc.snapshot().connected, running: true }),
+    "/trpc/*": protect((request) => fetchRequestHandler({
+      createContext: options.createContext,
+      endpoint: "/trpc",
+      req: request,
+      router: options.router
+    })),
+    "/tsplc/services/*": protect(createServiceHandler({
+      router: options.router,
+      createContext: options.createContext,
+      onError: (error) => options.log.warn("PLC service call failed", error)
+    }))
+  };
+  if (options.hmi) {
+    const { hmi, plc } = options.hmi;
+    routes["/"] = () => new Response(hmiPage(hmi.title), { headers: { "Content-Type": "text/html; charset=utf-8" } });
+    routes["/hmi/state"] = () => json(hmi.state(plc));
+    routes["/hmi/control"] = async (request) => {
+      const origin = request.headers.get("origin");
+      if (request.method !== "POST" || origin !== null && origin !== new URL(request.url).origin && !options.auth.allowedOrigins.includes(origin))
+        return json({ message: "Control request not allowed" }, 403);
+      const parsed = hmiControlRequest.safeParse(await request.json().catch(() => null));
+      if (!parsed.success)
+        return json({ message: "Invalid control request" }, 400);
+      try {
+        await hmi.control(plc, parsed.data);
+        return json({ ok: true });
+      } catch (error) {
+        if (error instanceof RangeError)
+          return json({ message: error.message }, 400);
+        options.log.warn("HMI control failed", error);
+        return json({ message: "The PLC did not accept this command" }, 503);
+      }
+    };
+  }
+  const server = Bun.serve({
+    ...options.tls ? { tls: options.tls } : {},
+    hostname: options.hostname,
+    port: options.port,
+    routes,
+    fetch: () => json({ message: "Not found" }, 404)
+  });
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  options.log.info(`Listening on ${server.url}`);
+  const closed = Promise.all([
+    options.plc.run(signal),
+    runOpcUaServices({
+      router: options.router,
+      createContext: options.createContext,
+      channels: options.channels,
+      getSession: options.plc.session,
+      onError: (error) => options.log.warn("PLC service gateway unavailable", error),
+      onReady: () => options.log.info("PLC service gateway ready"),
+      signal
+    }),
+    ...(options.jobs ?? []).map(async (job) => {
+      while (!signal.aborted) {
+        try {
+          await job.run();
+        } catch (error) {
+          options.log.warn(`${job.name} failed`, error);
+        }
+        await sleep(job.intervalMs, signal);
+      }
+    })
+  ]).finally(async () => {
+    controller.abort();
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+    await server.stop(true);
+  });
+  return {
+    url: server.url,
+    closed: closed.then(() => {
+      return;
+    }),
+    stop: async () => {
+      stop();
+      await closed;
+    }
+  };
+};
+export {
+  serve
+};
+//# debugId=757C86D2676275DF64756E2164756E21
+//# sourceMappingURL=serve.js.map