opcjs-client 0.1.3

package/dist/index.cjs

@@ -0,0 +1,1177 @@
+'use strict';
+
+var base = require('@opcua/base');
+
+// src/client.ts
+var ServiceBase = class {
+  constructor(authToken, secureChannel) {
+    this.authToken = authToken;
+    this.secureChannel = secureChannel;
+  }
+  createRequestHeader() {
+    const requestHeader = new base.RequestHeader();
+    requestHeader.authenticationToken = this.authToken;
+    requestHeader.timestamp = /* @__PURE__ */ new Date();
+    requestHeader.requestHandle = 0;
+    requestHeader.returnDiagnostics = 0;
+    requestHeader.auditEntryId = "";
+    requestHeader.timeoutHint = 6e4;
+    requestHeader.additionalHeader = base.ExtensionObject.newEmpty();
+    return requestHeader;
+  }
+};
+
+// src/services/sessionService.ts
+var SessionService = class _SessionService extends ServiceBase {
+  constructor(authToken, secureChannel, configuration) {
+    super(authToken, secureChannel);
+    this.configuration = configuration;
+  }
+  async createSession() {
+    console.log("Creating session...");
+    const clientDescription = new base.ApplicationDescription();
+    clientDescription.applicationUri = this.configuration.applicationUri;
+    clientDescription.productUri = this.configuration.productUri;
+    clientDescription.applicationName = new base.LocalizedText(void 0, this.configuration.productName);
+    clientDescription.applicationType = base.ApplicationTypeEnum.Client;
+    clientDescription.gatewayServerUri = "";
+    clientDescription.discoveryProfileUri = "";
+    clientDescription.discoveryUrls = new Array();
+    const request = new base.CreateSessionRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.clientDescription = clientDescription;
+    request.serverUri = "";
+    request.endpointUrl = this.secureChannel.getEndpointUrl();
+    request.sessionName = "";
+    request.clientNonce = null;
+    request.clientCertificate = null;
+    request.requestedSessionTimeout = 6e4;
+    request.maxResponseMessageSize = 0;
+    console.log("Sending CreateSessionRequest...");
+    const response = await this.secureChannel.issueServiceRequest(request);
+    if (!response || !(response instanceof base.CreateSessionResponse)) {
+      throw new Error("Invalid response type for CreateSessionRequest");
+    }
+    const castedResponse = response;
+    if (!castedResponse || !castedResponse.sessionId || !castedResponse.authenticationToken) {
+      throw new Error("CreateSessionResponse missing SessionId or AuthenticationToken");
+    }
+    const endpoint = "opc." + this.secureChannel.getEndpointUrl();
+    const securityMode = this.secureChannel.getSecurityMode();
+    const securityPolicyUri = this.secureChannel.getSecurityPolicy();
+    const serverEndpoint = castedResponse?.serverEndpoints?.find((ep) => ep.endpointUrl === endpoint && ep.securityMode === securityMode && ep.securityPolicyUri === securityPolicyUri);
+    if (!serverEndpoint) {
+      throw new Error(`Server endpoint ${endpoint} not found in CreateSessionResponse`);
+    }
+    console.log("Session created with id:", castedResponse.sessionId.identifier);
+    return {
+      sessionId: castedResponse.sessionId.identifier,
+      authToken: castedResponse.authenticationToken,
+      endpoint: serverEndpoint
+    };
+  }
+  async activateSession(identityToken) {
+    const signatureData = new base.SignatureData();
+    signatureData.algorithm = this.secureChannel.getSecurityPolicy();
+    signatureData.signature = new Uint8Array(0);
+    const request = new base.ActivateSessionRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.clientSignature = signatureData;
+    request.clientSoftwareCertificates = new Array();
+    request.localeIds = ["en-US"];
+    request.userIdentityToken = base.ExtensionObject.newBinary(identityToken);
+    request.userTokenSignature = signatureData;
+    console.log("Sending ActivateSessionRequest...");
+    await this.secureChannel.issueServiceRequest(request);
+    console.log("Session activated.");
+  }
+  recreate(authToken) {
+    return new _SessionService(authToken, this.secureChannel, this.configuration);
+  }
+};
+
+// src/issuerConfiguration.ts
+var IssuerConfiguration = class _IssuerConfiguration {
+  constructor(resourceId, authorityUrl, authorityProfileUri, tokenEndpoint, authorizationEndpoint, requestTypes, scopes) {
+    this.resourceId = resourceId;
+    this.authorityUrl = authorityUrl;
+    this.authorityProfileUri = authorityProfileUri;
+    this.tokenEndpoint = tokenEndpoint;
+    this.authorizationEndpoint = authorizationEndpoint;
+    this.requestTypes = requestTypes;
+    this.scopes = scopes;
+  }
+  static newFrom(issuerEndpointUrl) {
+    return new _IssuerConfiguration(
+      issuerEndpointUrl["ua.resourceId"],
+      issuerEndpointUrl["ua.authorityUrl"],
+      issuerEndpointUrl["ua.authorityProfileUri"],
+      issuerEndpointUrl["ua.tokenEndpoint"],
+      issuerEndpointUrl["ua.authorizationEndpoint"],
+      issuerEndpointUrl["ua.requestTypes"],
+      issuerEndpointUrl["ua.scopes"]
+    );
+  }
+};
+
+// src/sessions/session.ts
+var Session = class {
+  constructor(sessionId, authToken, endpoint, sessionServices) {
+    this.sessionId = sessionId;
+    this.authToken = authToken;
+    this.endpoint = endpoint;
+    this.sessionServices = sessionServices;
+  }
+  async activateSession(identity) {
+    const token = identity.getUserIdentityToken();
+    const tokenType = identity.getTokenType();
+    const tokenPolicy = this.endpoint.userIdentityTokens?.find((t) => t.tokenType === tokenType);
+    if (!tokenPolicy) {
+      throw new Error(`UserIdentityToken of type ${tokenType} not supported by server`);
+    }
+    token.policyId = tokenPolicy.policyId;
+    if (tokenType === base.UserTokenTypeEnum.IssuedToken) {
+      if (!tokenPolicy.issuerEndpointUrl) {
+        throw new Error("IssuerEndpointUrl not defined for IssuedToken");
+      }
+      const issuerEndpointUrl = JSON.parse(tokenPolicy.issuerEndpointUrl);
+      const issuerConfig = IssuerConfiguration.newFrom(issuerEndpointUrl);
+      const issuerLoginCallback = identity.getIssuerLoginCallback();
+      const tokenData = await issuerLoginCallback(issuerConfig);
+      const issuerToken = token;
+      issuerToken.tokenData = new TextEncoder().encode(tokenData.json);
+    }
+    await this.sessionServices.activateSession(token);
+  }
+  getAuthToken() {
+    return this.authToken;
+  }
+};
+
+// src/sessions/sessionHandler.ts
+var SessionHandler = class {
+  sessionServices;
+  async createNewSession(identity) {
+    const ret = await this.sessionServices.createSession();
+    this.sessionServices = this.sessionServices.recreate(ret.authToken);
+    const session = new Session(ret.sessionId, ret.authToken, ret.endpoint, this.sessionServices);
+    await session.activateSession(identity);
+    return session;
+  }
+  constructor(secureChannel, configuration) {
+    this.sessionServices = new SessionService(base.NodeId.newTwoByte(0), secureChannel, configuration);
+  }
+};
+
+// src/services/attributeServiceAttributes.ts
+var AttrIdValue = 13;
+
+// src/services/attributeService.ts
+var AttributeService = class extends ServiceBase {
+  async ReadValue(nodeIds) {
+    const readValueIds = nodeIds.map((ni) => {
+      const readValueId = new base.ReadValueId();
+      readValueId.nodeId = ni;
+      readValueId.attributeId = AttrIdValue;
+      readValueId.indexRange = "";
+      readValueId.dataEncoding = new base.QualifiedName(0, "");
+      return readValueId;
+    });
+    const request = new base.ReadRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.maxAge = 6e4;
+    request.timestampsToReturn = base.TimestampsToReturnEnum.Source;
+    request.nodesToRead = readValueIds;
+    console.log("Sending ReadRequest...");
+    const response = await this.secureChannel.issueServiceRequest(request);
+    const results = new Array();
+    for (let dataValue of response.results ?? []) {
+      const result = {
+        status: dataValue.statusCode?.toString() ?? "Unknown",
+        value: dataValue.value
+      };
+      results.push(result);
+    }
+    return results;
+  }
+  constructor(authToken, secureChannel) {
+    super(authToken, secureChannel);
+  }
+};
+
+// src/readValueResult.ts
+var ReadValueResult = class {
+  constructor(value, status) {
+    this.value = value;
+    this.status = status;
+  }
+};
+
+// src/subscriptionHandlerEntry.ts
+var SubscriptionHandlerEntry = class {
+  constructor(subscriptionId, handle, id, callback) {
+    this.subscriptionId = subscriptionId;
+    this.handle = handle;
+    this.id = id;
+    this.callback = callback;
+  }
+};
+
+// src/subscriptionHandler.ts
+var SubscriptionHandler = class {
+  constructor(subscriptionService, monitoredItemService) {
+    this.subscriptionService = subscriptionService;
+    this.monitoredItemService = monitoredItemService;
+  }
+  entries = new Array();
+  nextHandle = 0;
+  async subscribe(ids, callback) {
+    if (this.entries.length > 0) {
+      throw new Error("Subscribing more than once is not implemented");
+    }
+    const subscriptionId = await this.subscriptionService.createSubscription();
+    const items = [];
+    for (let id of ids) {
+      const entry = new SubscriptionHandlerEntry(
+        subscriptionId,
+        this.nextHandle++,
+        id,
+        callback
+      );
+      this.entries.push(entry);
+      const item = {
+        id: id.toNodeId(),
+        handle: entry.handle
+      };
+      items.push(item);
+    }
+    await this.monitoredItemService.createMonitoredItems(subscriptionId, items);
+    this.publish([]);
+  }
+  async publish(acknowledgeSequenceNumbers) {
+    const acknowledgements = [];
+    for (let i = 0; i < acknowledgeSequenceNumbers.length; i++) {
+      const acknowledgement = new base.SubscriptionAcknowledgement();
+      acknowledgement.subscriptionId = this.entries[i].subscriptionId;
+      acknowledgement.sequenceNumber = acknowledgeSequenceNumbers[i];
+      acknowledgements.push(acknowledgement);
+    }
+    const response = await this.subscriptionService.publish(acknowledgements);
+    const messagesToAcknowledge = response.notificationMessage.sequenceNumber;
+    const notificationDatas = response.notificationMessage.notificationData;
+    for (let notificationData of notificationDatas) {
+      const decodedData = notificationData.data;
+      const typeNodeId = notificationData.typeId;
+      if (typeNodeId.namespace === 0 && typeNodeId.identifier === 811) {
+        const dataChangeNotification = decodedData;
+        for (let item of dataChangeNotification.monitoredItems) {
+          const clientHandle = item.clientHandle;
+          const value = item.value;
+          const entry = this.entries.find((e) => e.handle == clientHandle);
+          entry?.callback([{
+            id: entry.id,
+            value: value.value?.value
+          }]);
+        }
+      } else {
+        console.log(`The change notification data type ${typeNodeId.namespace}:${typeNodeId.identifier} is not supported.`);
+      }
+    }
+    setTimeout(() => {
+      this.publish([messagesToAcknowledge]);
+    }, 500);
+  }
+};
+var SubscriptionService = class extends ServiceBase {
+  // https://reference.opcfoundation.org/Core/Part4/v105/docs/5.14.2
+  async createSubscription() {
+    const request = new base.CreateSubscriptionRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.requestedPublishingInterval = 2e3;
+    request.requestedLifetimeCount = 36e4;
+    request.requestedMaxKeepAliveCount = 6e4;
+    request.maxNotificationsPerPublish = 200;
+    request.publishingEnabled = true;
+    request.priority = 1;
+    console.log("Sending createSubscription...");
+    const response = await this.secureChannel.issueServiceRequest(request);
+    console.log("Subscription created with id:", response.subscriptionId);
+    return response.subscriptionId;
+  }
+  // https://reference.opcfoundation.org/Core/Part4/v105/docs/5.14.5
+  async publish(acknowledgements) {
+    const request = new base.PublishRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.subscriptionAcknowledgements = acknowledgements;
+    console.log("Sending publish...");
+    const response = await this.secureChannel.issueServiceRequest(request);
+    console.log("Received publish response.");
+    return response;
+  }
+  constructor(authToken, secureChannel) {
+    super(authToken, secureChannel);
+  }
+};
+var MonitoredItemService = class extends ServiceBase {
+  async createMonitoredItems(subscriptionId, ids) {
+    const items = ids.map((ni) => {
+      const readValueId = new base.ReadValueId();
+      readValueId.nodeId = ni.id;
+      readValueId.attributeId = AttrIdValue;
+      readValueId.indexRange = "";
+      readValueId.dataEncoding = new base.QualifiedName(0, "");
+      const monitoringParameters = new base.MonitoringParameters();
+      monitoringParameters.clientHandle = ni.handle;
+      monitoringParameters.samplingInterval = 1e3;
+      monitoringParameters.filter = base.ExtensionObject.newEmpty();
+      monitoringParameters.queueSize = 100;
+      monitoringParameters.discardOldest = true;
+      const monitoredItemCreateRequest = new base.MonitoredItemCreateRequest();
+      monitoredItemCreateRequest.itemToMonitor = readValueId;
+      monitoredItemCreateRequest.requestedParameters = monitoringParameters;
+      return monitoredItemCreateRequest;
+    });
+    const request = new base.CreateMonitoredItemsRequest();
+    request.requestHeader = this.createRequestHeader();
+    request.subscriptionId = subscriptionId;
+    request.timestampsToReturn = base.TimestampsToReturnEnum.Source;
+    request.itemsToCreate = items;
+    console.log("Sending createMonitoredItems...");
+    await this.secureChannel.issueServiceRequest(request);
+  }
+  constructor(authToken, secureChannel) {
+    super(authToken, secureChannel);
+  }
+};
+
+// src/client.ts
+var Client = class {
+  constructor(endpointUrl, configuration, identity) {
+    this.configuration = configuration;
+    this.identity = identity;
+    this.endpointUrl = endpointUrl;
+  }
+  endpointUrl;
+  channel;
+  session;
+  subscriptionHandler;
+  getSession() {
+    if (!this.session) {
+      throw new Error("No session available");
+    }
+    return this.session;
+  }
+  async connect() {
+    const channel = base.ChannelFactory.createChannel(this.endpointUrl);
+    let connected = false;
+    while (!connected) {
+      console.log(`Connecting to OPC UA server at ${this.endpointUrl}...`);
+      connected = await channel.connect();
+      if (!connected) {
+        console.log("Connection failed, retrying in 2 seconds...");
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+    }
+    console.log("Connected to OPC UA server.");
+    this.channel = new base.SecureChannel(channel, this.configuration);
+    await this.channel.openSecureChannelRequest();
+    const sessionHandler = new SessionHandler(this.channel, this.configuration);
+    this.session = await sessionHandler.createNewSession(this.identity);
+    this.subscriptionHandler = new SubscriptionHandler(
+      new SubscriptionService(this.session.getAuthToken(), this.channel),
+      new MonitoredItemService(this.session.getAuthToken(), this.channel)
+    );
+  }
+  async disconnect() {
+    console.log("Disconnecting from OPC UA server...");
+    if (this.channel) {
+      await this.channel.disconnect();
+    }
+  }
+  async read(ids) {
+    const service = new AttributeService(this.getSession().getAuthToken(), this.channel);
+    const result = await service.ReadValue(ids.map((i) => i.toNodeId()));
+    return result.map((r) => new ReadValueResult(r.value, r.status));
+  }
+  async subscribe(ids, callback) {
+    this.subscriptionHandler?.subscribe(ids, callback);
+  }
+};
+
+// ../base/src/codecs/codecError.ts
+var CodecError = class _CodecError extends Error {
+  /**
+   * The encoding ID involved in the error (if applicable).
+   */
+  encodingId;
+  /**
+   * The encoding format where the error occurred (Binary, Xml, Json).
+   */
+  format;
+  /**
+   * Suggested action to resolve the error.
+   */
+  suggestedAction;
+  /**
+   * The type name involved in the error (if applicable).
+   */
+  typeName;
+  /**
+   * Original error that caused this codec error (if any).
+   */
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "CodecError";
+    this.encodingId = options?.encodingId;
+    this.format = options?.format;
+    this.suggestedAction = options?.suggestedAction;
+    this.typeName = options?.typeName;
+    this.cause = options?.cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CodecError);
+    }
+  }
+  /**
+   * Returns a detailed error message including all context.
+   */
+  toString() {
+    let result = `${this.name}: ${this.message}`;
+    if (this.encodingId) {
+      result += `
+  Encoding ID: ${this.encodingId}`;
+    }
+    if (this.format) {
+      result += `
+  Format: ${this.format}`;
+    }
+    if (this.typeName) {
+      result += `
+  Type: ${this.typeName}`;
+    }
+    if (this.suggestedAction) {
+      result += `
+  Suggested Action: ${this.suggestedAction}`;
+    }
+    return result;
+  }
+};
+
+// ../base/src/codecs/binary/binaryWriter.ts
+var EPOCH_DIFF_MS = 11644473600000n;
+var TICKS_PER_MS = 10000n;
+function selectNodeIdEncodingFormat(nodeId) {
+  if (nodeId.identifierType === 0 /* Numeric */) {
+    const id = nodeId.identifier;
+    const ns = nodeId.namespace;
+    if (ns === 0 && id >= 0 && id <= 255) {
+      return 0 /* TwoByte */;
+    }
+    if (ns >= 0 && ns <= 255 && id >= 0 && id <= 65535) {
+      return 1 /* FourByte */;
+    }
+    return 2 /* Numeric */;
+  }
+  if (nodeId.identifierType === 1 /* String */) {
+    return 3 /* String */;
+  }
+  if (nodeId.identifierType === 2 /* Guid */) {
+    return 4 /* Guid */;
+  }
+  if (nodeId.identifierType === 3 /* ByteString */) {
+    return 5 /* ByteString */;
+  }
+  throw new CodecError(`Invalid NodeId identifier type: ${nodeId.identifierType}`);
+}
+var ExpandedNodeIdMask = {
+  ServerIndexFlag: 64,
+  NamespaceUriFlag: 128
+};
+var LocalizedTextMask = {
+  LocaleFlag: 1,
+  TextFlag: 2
+};
+var DataValueMaskBits = {
+  Value: 1,
+  StatusCode: 2,
+  SourceTimestamp: 4,
+  ServerTimestamp: 8,
+  SourcePicoseconds: 16,
+  ServerPicoseconds: 32
+};
+var DiagnosticInfoMaskBits = {
+  SymbolicId: 1,
+  NamespaceUri: 2,
+  LocalizedText: 4,
+  Locale: 8,
+  AdditionalInfo: 16,
+  InnerStatusCode: 32,
+  InnerDiagnosticInfo: 64
+};
+var VariantMask = {
+  TypeMask: 63,
+  ArrayDimensions: 64,
+  Array: 128
+};
+var BinaryWriter = class {
+  buffer;
+  position;
+  getData() {
+    return this.buffer.subarray(0, this.position);
+  }
+  /** Returns the number of bytes written so far. */
+  getLength() {
+    return this.position;
+  }
+  /** Appends raw bytes to the buffer. */
+  writeBytes(data) {
+    this.ensureCapacity(data.length);
+    this.buffer.set(data, this.position);
+    this.position += data.length;
+  }
+  /**
+   * Overwrites bytes in the buffer starting at the given position.
+   * Also truncates the written length to `offset + data.length` if that
+   * is less than the current position (i.e. replaces and trims the tail).
+   */
+  writeBytesAt(data, offset) {
+    const end = offset + data.length;
+    this.ensureCapacity(Math.max(0, end - this.position));
+    this.buffer.set(data, offset);
+    if (end > this.position) {
+      this.position = end;
+    }
+  }
+  /**
+   * Inserts bytes at the given offset, shifting all subsequent content right.
+   */
+  insertBytesAt(data, offset) {
+    this.ensureCapacity(data.length);
+    this.buffer.copyWithin(offset + data.length, offset, this.position);
+    this.buffer.set(data, offset);
+    this.position += data.length;
+  }
+  /**
+   * Overwrites a UInt32 (little-endian) at the given byte offset without
+   * advancing the write position.
+   */
+  writeUInt32At(value, offset) {
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+      throw new CodecError(`UInt32 value ${value} out of range [0, 4294967295]`);
+    }
+    this.buffer.writeUInt32LE(value, offset);
+  }
+  /**
+   * Ensure buffer has enough capacity, growing if necessary.
+   */
+  ensureCapacity(additionalBytes) {
+    const required = this.position + additionalBytes;
+    if (required > this.buffer.length) {
+      const newSize = Math.max(required, this.buffer.length * 2);
+      const newBuffer = Buffer.allocUnsafe(newSize);
+      this.buffer.copy(newBuffer, 0, 0, this.position);
+      this.buffer = newBuffer;
+    }
+  }
+  writeBoolean(value) {
+    this.ensureCapacity(1);
+    this.buffer.writeUInt8(value ? 1 : 0, this.position);
+    this.position += 1;
+  }
+  writeByte(value) {
+    if (value < 0 || value > 255) {
+      throw new CodecError(`Byte value ${value} out of range [0, 255]`);
+    }
+    this.ensureCapacity(1);
+    this.buffer.writeUInt8(value, this.position);
+    this.position += 1;
+  }
+  writeSByte(value) {
+    if (value < -128 || value > 127) {
+      throw new CodecError(`SByte value ${value} out of range [-128, 127]`);
+    }
+    this.ensureCapacity(1);
+    this.buffer.writeInt8(value, this.position);
+    this.position += 1;
+  }
+  writeInt16(value) {
+    if (value < -32768 || value > 32767) {
+      throw new CodecError(`Int16 value ${value} out of range [-32768, 32767]`);
+    }
+    this.ensureCapacity(2);
+    this.buffer.writeInt16LE(value, this.position);
+    this.position += 2;
+  }
+  writeUInt16(value) {
+    if (value < 0 || value > 65535) {
+      throw new CodecError(`UInt16 value ${value} out of range [0, 65535]`);
+    }
+    this.ensureCapacity(2);
+    this.buffer.writeUInt16LE(value, this.position);
+    this.position += 2;
+  }
+  writeInt32(value) {
+    if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+      throw new CodecError(`Int32 value ${value} out of range [-2147483648, 2147483647]`);
+    }
+    this.ensureCapacity(4);
+    this.buffer.writeInt32LE(value, this.position);
+    this.position += 4;
+  }
+  writeUInt32(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+      throw new CodecError(`UInt32 value ${value} out of range [0, 4294967295]`);
+    }
+    this.ensureCapacity(4);
+    this.buffer.writeUInt32LE(value, this.position);
+    this.position += 4;
+  }
+  writeInt64(value) {
+    this.ensureCapacity(8);
+    this.buffer.writeBigInt64LE(value, this.position);
+    this.position += 8;
+  }
+  writeUInt64(value) {
+    this.ensureCapacity(8);
+    this.buffer.writeBigUInt64LE(value, this.position);
+    this.position += 8;
+  }
+  writeFloat(value) {
+    this.ensureCapacity(4);
+    this.buffer.writeFloatLE(value, this.position);
+    this.position += 4;
+  }
+  writeDouble(value) {
+    this.ensureCapacity(8);
+    this.buffer.writeDoubleLE(value, this.position);
+    this.position += 8;
+  }
+  writeString(value) {
+    if (value == null) {
+      this.writeInt32(-1);
+      return;
+    }
+    const utf8Bytes = Buffer.from(value, "utf8");
+    const length = utf8Bytes.length;
+    if (length > 16777216) {
+      throw new CodecError(
+        `String length ${length} exceeds maximum allowed length of 16,777,216 bytes`,
+        { format: "Binary", suggestedAction: "Reduce string length" }
+      );
+    }
+    this.writeInt32(length);
+    this.ensureCapacity(length);
+    utf8Bytes.copy(this.buffer, this.position);
+    this.position += length;
+  }
+  writeDateTime(value) {
+    const jsTimestamp = BigInt(value.getTime());
+    const opcTimestamp = (jsTimestamp + EPOCH_DIFF_MS) * TICKS_PER_MS;
+    this.writeInt64(opcTimestamp);
+  }
+  writeGuid(value) {
+    const hex = value.replace(/-/g, "");
+    if (hex.length !== 32) {
+      throw new CodecError(`Invalid GUID format: ${value}`);
+    }
+    this.ensureCapacity(16);
+    const data1 = parseInt(hex.substr(0, 8), 16);
+    this.buffer.writeUInt32LE(data1, this.position);
+    const data2 = parseInt(hex.substr(8, 4), 16);
+    this.buffer.writeUInt16LE(data2, this.position + 4);
+    const data3 = parseInt(hex.substr(12, 4), 16);
+    this.buffer.writeUInt16LE(data3, this.position + 6);
+    for (let i = 0; i < 8; i++) {
+      const byte = parseInt(hex.substr(16 + i * 2, 2), 16);
+      this.buffer.writeUInt8(byte, this.position + 8 + i);
+    }
+    this.position += 16;
+  }
+  writeByteString(value) {
+    if (value == null) {
+      this.writeInt32(-1);
+      return;
+    }
+    const length = value.length;
+    if (length > 16777216) {
+      throw new CodecError(
+        `ByteString length ${length} exceeds maximum allowed length of 16,777,216 bytes`,
+        { format: "Binary", suggestedAction: "Reduce ByteString length" }
+      );
+    }
+    this.writeInt32(length);
+    this.ensureCapacity(length);
+    if (Buffer.isBuffer(value)) {
+      value.copy(this.buffer, this.position);
+    } else {
+      this.buffer.set(value, this.position);
+    }
+    this.position += length;
+  }
+  writeXmlElement(value) {
+    this.writeString(value);
+  }
+  /**
+   * Write an array with Int32 length prefix.
+   * Per FR-011: -1 = null, 0 = empty, positive = element count
+   * Per FR-019: Maximum array length is 2,147,483,647 elements
+   * 
+   * @param array The array to encode (undefined for null array)
+   * @param encodeElement Function to encode each element
+   * @throws {CodecError} if array length exceeds Int32 maximum
+   * @see OPC 10000-6 Section 5.2.5 - Arrays
+   */
+  writeArray(array, encodeElement) {
+    if (array === void 0) {
+      this.writeInt32(-1);
+      return;
+    }
+    const length = array.length;
+    if (length > 2147483647) {
+      throw new CodecError(
+        `Array length ${length} exceeds maximum allowed length of 2,147,483,647 elements`,
+        { format: "Binary", suggestedAction: "Reduce array size" }
+      );
+    }
+    this.writeInt32(length);
+    for (const element of array) {
+      encodeElement(this, element);
+    }
+  }
+  // === Complex type write methods ===
+  /**
+   * Encode a NodeId in binary format using the most compact representation.
+   * @see OPC 10000-6 Tables 16-19
+   */
+  writeNodeId(value) {
+    const format = selectNodeIdEncodingFormat(value);
+    switch (format) {
+      case 0 /* TwoByte */:
+        this.writeByte(0 /* TwoByte */);
+        this.writeByte(value.identifier);
+        break;
+      case 1 /* FourByte */:
+        this.writeByte(1 /* FourByte */);
+        this.writeByte(value.namespace);
+        this.writeUInt16(value.identifier);
+        break;
+      case 2 /* Numeric */:
+        this.writeByte(2 /* Numeric */);
+        this.writeUInt16(value.namespace);
+        this.writeUInt32(value.identifier);
+        break;
+      case 3 /* String */:
+        this.writeByte(3 /* String */);
+        this.writeUInt16(value.namespace);
+        this.writeString(value.identifier);
+        break;
+      case 4 /* Guid */:
+        this.writeByte(4 /* Guid */);
+        this.writeUInt16(value.namespace);
+        this.writeGuid(value.identifier);
+        break;
+      case 5 /* ByteString */: {
+        this.writeByte(5 /* ByteString */);
+        this.writeUInt16(value.namespace);
+        const ident = value.identifier;
+        const buf = ident instanceof Uint8Array && !(ident instanceof Buffer) ? Buffer.from(ident) : ident;
+        this.writeByteString(buf);
+        break;
+      }
+      default:
+        throw new CodecError(`Unsupported NodeId encoding format: ${format}`);
+    }
+  }
+  /**
+   * Encode an ExpandedNodeId in binary format.
+   * @see OPC 10000-6 Table 20
+   */
+  writeExpandedNodeId(value) {
+    const startPos = this.position;
+    this.writeNodeId(value);
+    let encodingByte = this.buffer[startPos];
+    if (value.namespaceUri !== void 0) {
+      encodingByte |= ExpandedNodeIdMask.NamespaceUriFlag;
+    }
+    if (value.serverIndex !== void 0) {
+      encodingByte |= ExpandedNodeIdMask.ServerIndexFlag;
+    }
+    this.buffer[startPos] = encodingByte;
+    if (value.namespaceUri !== void 0) {
+      this.writeString(value.namespaceUri);
+    }
+    if (value.serverIndex !== void 0) {
+      this.writeUInt32(value.serverIndex);
+    }
+  }
+  /**
+   * Encode a StatusCode as a UInt32.
+   * @see OPC 10000-6 Section 5.2.2.16
+   */
+  writeStatusCode(value) {
+    this.writeUInt32(value);
+  }
+  /**
+   * Encode a QualifiedName as NamespaceIndex (UInt16) + Name (String).
+   * @see OPC 10000-6 Table 8
+   */
+  writeQualifiedName(value) {
+    this.writeUInt16(value.namespaceIndex);
+    this.writeString(value.name);
+  }
+  /**
+   * Encode a LocalizedText with optional locale and text.
+   * @see OPC 10000-6 Table 9
+   */
+  writeLocalizedText(value) {
+    let encodingMask = 0;
+    if (value.locale !== void 0 && value.locale !== "") {
+      encodingMask |= LocalizedTextMask.LocaleFlag;
+    }
+    if (value.text !== "") {
+      encodingMask |= LocalizedTextMask.TextFlag;
+    }
+    this.writeByte(encodingMask);
+    if (encodingMask & LocalizedTextMask.LocaleFlag) {
+      this.writeString(value.locale);
+    }
+    if (encodingMask & LocalizedTextMask.TextFlag) {
+      this.writeString(value.text);
+    }
+  }
+  /**
+   * Encode an ExtensionObject with its TypeId and body.
+   * @see OPC 10000-6 Section 5.2.2.15
+   */
+  writeExtensionObject(value, encoder) {
+    const typeId = value.typeId;
+    if ("namespaceUri" in typeId || "serverIndex" in typeId) {
+      this.writeExpandedNodeId(typeId);
+    } else {
+      this.writeNodeId(typeId);
+    }
+    this.writeByte(value.encoding);
+    switch (value.encoding) {
+      case 0 /* None */:
+        break;
+      case 1 /* Binary */:
+        if (!value.data) {
+          throw new CodecError("ExtensionObject with Binary encoding must have data");
+        }
+        const binaryData = encoder.encodeWithoutId(value.data, "binary");
+        this.writeByteString(binaryData);
+        break;
+      case 2 /* Xml */:
+        if (!value.data) {
+          throw new CodecError("ExtensionObject with Xml encoding must have data");
+        }
+        const xmlString = encoder.encodeWithoutId(value.data, "xml");
+        this.writeXmlElement(xmlString);
+        break;
+      default:
+        throw new CodecError(`Invalid ExtensionObject encoding: ${value.encoding}`);
+    }
+  }
+  /**
+   * Encode a DataValue with optional fields controlled by an encoding mask.
+   * @see OPC 10000-6 Table 26
+   */
+  writeDataValue(value, encoder) {
+    let encodingMask = 0;
+    if (value.value !== null && value.value !== void 0) {
+      encodingMask |= DataValueMaskBits.Value;
+    }
+    if (value.statusCode !== null) {
+      encodingMask |= DataValueMaskBits.StatusCode;
+    }
+    if (value.sourceTimestamp !== null) {
+      encodingMask |= DataValueMaskBits.SourceTimestamp;
+    }
+    if (value.serverTimestamp !== null) {
+      encodingMask |= DataValueMaskBits.ServerTimestamp;
+    }
+    if (value.sourcePicoseconds !== null) {
+      encodingMask |= DataValueMaskBits.SourcePicoseconds;
+    }
+    if (value.serverPicoseconds !== null) {
+      encodingMask |= DataValueMaskBits.ServerPicoseconds;
+    }
+    this.writeByte(encodingMask);
+    if (encodingMask & DataValueMaskBits.Value) {
+      this.writeVariant(value.value, encoder);
+    }
+    if (encodingMask & DataValueMaskBits.StatusCode) {
+      this.writeUInt32(value.statusCode ?? 0 /* Good */);
+    }
+    if (encodingMask & DataValueMaskBits.SourceTimestamp) {
+      this.writeDateTime(value.sourceTimestamp);
+    }
+    if (encodingMask & DataValueMaskBits.ServerTimestamp) {
+      this.writeDateTime(value.serverTimestamp);
+    }
+    if (encodingMask & DataValueMaskBits.SourcePicoseconds) {
+      this.writeUInt16(value.sourcePicoseconds);
+    }
+    if (encodingMask & DataValueMaskBits.ServerPicoseconds) {
+      this.writeUInt16(value.serverPicoseconds);
+    }
+  }
+  /**
+   * Encode a Variant with type ID, value(s), and optional array dimensions.
+   * @see OPC 10000-6 Section 5.2.2.16
+   */
+  writeVariant(value, encoder) {
+    if (value.variantType < 0 || value.variantType > 25) {
+      throw new CodecError(`Invalid Variant type ID: ${value.variantType}. Must be 0-25.`);
+    }
+    let mask = value.variantType & VariantMask.TypeMask;
+    const isArrayValue = Array.isArray(value.value);
+    if (isArrayValue) {
+      mask |= VariantMask.Array;
+    }
+    if (value.arrayDimensions !== void 0 && value.arrayDimensions.length > 0) {
+      mask |= VariantMask.ArrayDimensions;
+    }
+    this.writeByte(mask);
+    if (isArrayValue) {
+      const array = value.value;
+      this.writeInt32(array.length);
+      for (const elem of array) {
+        this.writeVariantValue(value.variantType, elem, encoder);
+      }
+    } else if (value.variantType !== 0 /* Null */) {
+      this.writeVariantValue(value.variantType, value.value, encoder);
+    }
+    if (value.arrayDimensions !== void 0 && value.arrayDimensions.length > 0) {
+      this.writeInt32(value.arrayDimensions.length);
+      for (const dim of value.arrayDimensions) {
+        this.writeInt32(dim);
+      }
+    }
+  }
+  /**
+   * Encode a DiagnosticInfo with optional fields controlled by an encoding mask.
+   * Supports recursive InnerDiagnosticInfo.
+   * @see OPC 10000-6 Table 24
+   */
+  writeDiagnosticInfo(value) {
+    let encodingMask = 0;
+    if (value.symbolicId !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.SymbolicId;
+    }
+    if (value.namespaceUri !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.NamespaceUri;
+    }
+    if (value.localizedText !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.LocalizedText;
+    }
+    if (value.locale !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.Locale;
+    }
+    if (value.additionalInfo !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.AdditionalInfo;
+    }
+    if (value.innerStatusCode !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.InnerStatusCode;
+    }
+    if (value.innerDiagnosticInfo !== null) {
+      encodingMask |= DiagnosticInfoMaskBits.InnerDiagnosticInfo;
+    }
+    this.writeByte(encodingMask);
+    if (encodingMask & DiagnosticInfoMaskBits.SymbolicId) {
+      this.writeInt32(value.symbolicId);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.NamespaceUri) {
+      this.writeInt32(value.namespaceUri);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.LocalizedText) {
+      this.writeInt32(value.localizedText);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.Locale) {
+      this.writeInt32(value.locale);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.AdditionalInfo) {
+      this.writeString(value.additionalInfo);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.InnerStatusCode) {
+      this.writeUInt32(value.innerStatusCode ?? 0 /* Good */);
+    }
+    if (encodingMask & DiagnosticInfoMaskBits.InnerDiagnosticInfo) {
+      this.writeDiagnosticInfo(value.innerDiagnosticInfo);
+    }
+  }
+  // === Private helpers ===
+  writeVariantValue(type, value, encoder) {
+    switch (type) {
+      case 0 /* Null */:
+        break;
+      case 1 /* Boolean */:
+        this.writeBoolean(value);
+        break;
+      case 2 /* SByte */:
+        this.writeSByte(value);
+        break;
+      case 3 /* Byte */:
+        this.writeByte(value);
+        break;
+      case 4 /* Int16 */:
+        this.writeInt16(value);
+        break;
+      case 5 /* UInt16 */:
+        this.writeUInt16(value);
+        break;
+      case 6 /* Int32 */:
+        this.writeInt32(value);
+        break;
+      case 7 /* UInt32 */:
+        this.writeUInt32(value);
+        break;
+      case 8 /* Int64 */:
+        this.writeInt64(value);
+        break;
+      case 9 /* UInt64 */:
+        this.writeUInt64(value);
+        break;
+      case 10 /* Float */:
+        this.writeFloat(value);
+        break;
+      case 11 /* Double */:
+        this.writeDouble(value);
+        break;
+      case 12 /* String */:
+        this.writeString(value);
+        break;
+      case 13 /* DateTime */:
+        this.writeDateTime(value);
+        break;
+      case 14 /* Guid */:
+        this.writeGuid(value);
+        break;
+      case 15 /* ByteString */:
+        this.writeByteString(value);
+        break;
+      case 16 /* XmlElement */:
+        this.writeXmlElement(value);
+        break;
+      case 17 /* NodeId */:
+        this.writeNodeId(value);
+        break;
+      case 18 /* ExpandedNodeId */:
+        this.writeExpandedNodeId(value);
+        break;
+      case 19 /* StatusCode */:
+        this.writeStatusCode(value);
+        break;
+      case 20 /* QualifiedName */:
+        this.writeQualifiedName(value);
+        break;
+      case 21 /* LocalizedText */:
+        this.writeLocalizedText(value);
+        break;
+      case 22 /* ExtensionObject */:
+        this.writeExtensionObject(value, encoder);
+        break;
+      case 23 /* DataValue */:
+        this.writeDataValue(value, encoder);
+        break;
+      case 24 /* Variant */:
+        this.writeVariant(value, encoder);
+        break;
+      case 25 /* DiagnosticInfo */:
+        this.writeDiagnosticInfo(value);
+        break;
+      default:
+        throw new CodecError(`Unsupported Variant type: ${type}`);
+    }
+  }
+  constructor(initialSize = 1024) {
+    this.buffer = Buffer.allocUnsafe(initialSize);
+    this.position = 0;
+  }
+};
+
+// src/configurationClient.ts
+var ConfigurationClient = class _ConfigurationClient extends base.Configuration {
+  static getSimple(name, company) {
+    const applicationUri = `urn:${company}:${name}`;
+    const productUri = `urn:${company}:${name}:product`;
+    const encoder = new base.Encoder();
+    encoder.registerWriterFactory("binary", () => {
+      return new BinaryWriter();
+    });
+    base.registerEncoders(encoder);
+    const decoder = new base.Decoder();
+    decoder.registerReaderFactory("binary", (data) => {
+      return new base.BinaryReader(data);
+    });
+    base.registerTypeDecoders(decoder);
+    base.registerBinaryDecoders(decoder);
+    return new _ConfigurationClient(name, applicationUri, name, productUri, encoder, decoder);
+  }
+  constructor(applicationName, applicationUri, productName, productUri, encoder, decoder) {
+    super(applicationName, applicationUri, productName, productUri, encoder, decoder);
+  }
+};
+var Id = class _Id {
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+  }
+  static newId(namespace, identifier) {
+    return new _Id(new base.NodeId(namespace, identifier));
+  }
+  toNodeId() {
+    return this.nodeId;
+  }
+  toString() {
+    return `${this.nodeId.namespace}:${this.nodeId.identifier}`;
+  }
+};
+var UserIdentity = class _UserIdentity {
+  userIdentityToken;
+  tokenType = base.UserTokenTypeEnum.Anonymous;
+  issuerLoginCallback = void 0;
+  static newAnonymous() {
+    const userIdentity = new _UserIdentity();
+    userIdentity.userIdentityToken = new base.AnonymousIdentityToken();
+    userIdentity.userIdentityToken.policyId = "anonymous";
+    userIdentity.tokenType = base.UserTokenTypeEnum.Anonymous;
+    return userIdentity;
+  }
+  static newWithUserName(userName, password) {
+    const userIdentity = new _UserIdentity();
+    const nameToken = new base.UserNameIdentityToken();
+    nameToken.userName = userName;
+    nameToken.password = new TextEncoder().encode(password);
+    userIdentity.userIdentityToken = nameToken;
+    userIdentity.tokenType = base.UserTokenTypeEnum.UserName;
+    return userIdentity;
+  }
+  static newWithIssuerToken(loginCallback) {
+    const userIdentity = new _UserIdentity();
+    const issuedToken = new base.IssuedIdentityToken();
+    issuedToken.tokenData = new TextEncoder().encode("");
+    userIdentity.userIdentityToken = issuedToken;
+    userIdentity.tokenType = base.UserTokenTypeEnum.IssuedToken;
+    userIdentity.issuerLoginCallback = loginCallback;
+    return userIdentity;
+  }
+  getUserIdentityToken() {
+    return this.userIdentityToken;
+  }
+  getTokenType() {
+    return this.tokenType;
+  }
+  getIssuerLoginCallback() {
+    if (!this.issuerLoginCallback) {
+      throw new Error("No issuer login callback defined");
+    }
+    return this.issuerLoginCallback;
+  }
+};
+
+exports.Client = Client;
+exports.ConfigurationClient = ConfigurationClient;
+exports.Id = Id;
+exports.UserIdentity = UserIdentity;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map