@effect-opcua/client 0.1.0-alpha.1

package/dist/internal/events/wire.mjs

@@ -0,0 +1,127 @@
+import { Effect, PubSub } from "effect";
+
+//#region src/internal/events/wire.ts
+const EventBus = {
+	publishUnsafe: (pubsub, event) => PubSub.publishUnsafe(pubsub, event),
+	wireEmitter: (emitter, mappings, pubsub) => Effect.acquireRelease(Effect.sync(() => mappings.map((mapping) => {
+		const listener = (...args) => {
+			EventBus.publishUnsafe(pubsub, mapping.make(...args));
+		};
+		emitter.on(mapping.event, listener);
+		return {
+			event: mapping.event,
+			listener
+		};
+	})), (listeners) => Effect.sync(() => {
+		for (const { event, listener } of listeners) if (emitter.off) emitter.off(event, listener);
+		else emitter.removeListener?.(event, listener);
+	}))
+};
+const wireClientEvents = (client, events) => EventBus.wireEmitter(client, [
+	{
+		event: "backoff",
+		make: (...unsafeRaw) => ({
+			_tag: "Backoff",
+			unsafeRaw
+		})
+	},
+	{
+		event: "start_reconnection",
+		make: (...unsafeRaw) => ({
+			_tag: "StartReconnection",
+			unsafeRaw
+		})
+	},
+	{
+		event: "after_reconnection",
+		make: (...unsafeRaw) => ({
+			_tag: "AfterReconnection",
+			unsafeRaw
+		})
+	},
+	{
+		event: "connection_lost",
+		make: (...unsafeRaw) => ({
+			_tag: "ConnectionLost",
+			unsafeRaw
+		})
+	},
+	{
+		event: "connection_reestablished",
+		make: (...unsafeRaw) => ({
+			_tag: "ConnectionReestablished",
+			unsafeRaw
+		})
+	}
+], events);
+const wireSessionEvents = (session, events) => EventBus.wireEmitter(session, [
+	{
+		event: "keepalive",
+		make: (unsafeRaw) => ({
+			_tag: "KeepAlive",
+			unsafeRaw
+		})
+	},
+	{
+		event: "keepalive_failure",
+		make: (unsafeRaw) => ({
+			_tag: "KeepAliveFailure",
+			unsafeRaw
+		})
+	},
+	{
+		event: "session_closed",
+		make: (unsafeRaw) => ({
+			_tag: "SessionClosed",
+			unsafeRaw
+		})
+	},
+	{
+		event: "session_restored",
+		make: () => ({ _tag: "SessionRestored" })
+	}
+], events);
+const wireSubscriptionEvents = (subscription, events) => EventBus.wireEmitter(subscription, [
+	{
+		event: "started",
+		make: (subscriptionId) => ({
+			_tag: "Started",
+			subscriptionId: Number(subscriptionId)
+		})
+	},
+	{
+		event: "terminated",
+		make: (...unsafeRaw) => ({
+			_tag: "Terminated",
+			subscriptionId: subscription.subscriptionId,
+			cause: unsafeRaw
+		})
+	},
+	{
+		event: "keepalive",
+		make: () => ({
+			_tag: "KeepAlive",
+			subscriptionId: subscription.subscriptionId
+		})
+	},
+	{
+		event: "internal_error",
+		make: (cause) => ({
+			_tag: "InternalError",
+			subscriptionId: subscription.subscriptionId,
+			cause
+		})
+	},
+	{
+		event: "status_changed",
+		make: (...unsafeRaw) => ({
+			_tag: "StatusChanged",
+			subscriptionId: subscription.subscriptionId,
+			unsafeRaw
+		})
+	}
+], events);
+
+//#endregion
+export { EventBus, wireClientEvents, wireSessionEvents, wireSubscriptionEvents };
+//# sourceMappingURL=wire.mjs.map

package/dist/internal/events/wire.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.mjs","names":[],"sources":["../../../src/internal/events/wire.ts"],"sourcesContent":["import type {\n  ClientSession,\n  ClientSubscription,\n  OPCUAClient,\n} from \"node-opcua\";\nimport { Effect, PubSub } from \"effect\";\n\nimport type {\n  OpcuaClientEvent,\n  OpcuaSessionEvent,\n  OpcuaSubscriptionEvent,\n} from \"./model.js\";\n\ntype Emitter = {\n  readonly on: (\n    event: string,\n    listener: (...args: ReadonlyArray<unknown>) => void,\n  ) => unknown;\n  readonly off?: (\n    event: string,\n    listener: (...args: ReadonlyArray<unknown>) => void,\n  ) => unknown;\n  readonly removeListener?: (\n    event: string,\n    listener: (...args: ReadonlyArray<unknown>) => void,\n  ) => unknown;\n};\n\ntype EventMapping<A> = {\n  readonly event: string;\n  readonly make: (...args: ReadonlyArray<unknown>) => A;\n};\n\nexport const EventBus = {\n  publishUnsafe: <A>(pubsub: PubSub.PubSub<A>, event: A) =>\n    PubSub.publishUnsafe(pubsub, event),\n  wireEmitter: <A>(\n    emitter: Emitter,\n    mappings: ReadonlyArray<EventMapping<A>>,\n    pubsub: PubSub.PubSub<A>,\n  ) =>\n    Effect.acquireRelease(\n      Effect.sync(() =>\n        mappings.map((mapping) => {\n          const listener = (...args: ReadonlyArray<unknown>) => {\n            EventBus.publishUnsafe(pubsub, mapping.make(...args));\n          };\n          emitter.on(mapping.event, listener);\n          return { event: mapping.event, listener };\n        }),\n      ),\n      (listeners) =>\n        Effect.sync(() => {\n          for (const { event, listener } of listeners) {\n            if (emitter.off) emitter.off(event, listener);\n            else emitter.removeListener?.(event, listener);\n          }\n        }),\n    ),\n};\n\nexport const wireClientEvents = (\n  client: OPCUAClient,\n  events: PubSub.PubSub<OpcuaClientEvent>,\n) =>\n  EventBus.wireEmitter(\n    client as unknown as Emitter,\n    [\n      {\n        event: \"backoff\",\n        make: (...unsafeRaw) => ({ _tag: \"Backoff\", unsafeRaw }) as const,\n      },\n      {\n        event: \"start_reconnection\",\n        make: (...unsafeRaw) =>\n          ({ _tag: \"StartReconnection\", unsafeRaw }) as const,\n      },\n      {\n        event: \"after_reconnection\",\n        make: (...unsafeRaw) =>\n          ({ _tag: \"AfterReconnection\", unsafeRaw }) as const,\n      },\n      {\n        event: \"connection_lost\",\n        make: (...unsafeRaw) =>\n          ({ _tag: \"ConnectionLost\", unsafeRaw }) as const,\n      },\n      {\n        event: \"connection_reestablished\",\n        make: (...unsafeRaw) =>\n          ({ _tag: \"ConnectionReestablished\", unsafeRaw }) as const,\n      },\n    ],\n    events,\n  );\n\nexport const wireSessionEvents = (\n  session: ClientSession,\n  events: PubSub.PubSub<OpcuaSessionEvent>,\n) =>\n  EventBus.wireEmitter(\n    session as unknown as Emitter,\n    [\n      {\n        event: \"keepalive\",\n        make: (unsafeRaw) => ({ _tag: \"KeepAlive\", unsafeRaw }) as const,\n      },\n      {\n        event: \"keepalive_failure\",\n        make: (unsafeRaw) => ({ _tag: \"KeepAliveFailure\", unsafeRaw }) as const,\n      },\n      {\n        event: \"session_closed\",\n        make: (unsafeRaw) => ({ _tag: \"SessionClosed\", unsafeRaw }) as const,\n      },\n      {\n        event: \"session_restored\",\n        make: () => ({ _tag: \"SessionRestored\" }) as const,\n      },\n    ],\n    events,\n  );\n\nexport const wireSubscriptionEvents = (\n  subscription: ClientSubscription,\n  events: PubSub.PubSub<OpcuaSubscriptionEvent>,\n) =>\n  EventBus.wireEmitter(\n    subscription as unknown as Emitter,\n    [\n      {\n        event: \"started\",\n        make: (subscriptionId) =>\n          ({\n            _tag: \"Started\",\n            subscriptionId: Number(subscriptionId),\n          }) as const,\n      },\n      {\n        event: \"terminated\",\n        make: (...unsafeRaw) =>\n          ({\n            _tag: \"Terminated\",\n            subscriptionId: subscription.subscriptionId,\n            cause: unsafeRaw,\n          }) as const,\n      },\n      {\n        event: \"keepalive\",\n        make: () =>\n          ({\n            _tag: \"KeepAlive\",\n            subscriptionId: subscription.subscriptionId,\n          }) as const,\n      },\n      {\n        event: \"internal_error\",\n        make: (cause) =>\n          ({\n            _tag: \"InternalError\",\n            subscriptionId: subscription.subscriptionId,\n            cause,\n          }) as const,\n      },\n      {\n        event: \"status_changed\",\n        make: (...unsafeRaw) =>\n          ({\n            _tag: \"StatusChanged\",\n            subscriptionId: subscription.subscriptionId,\n            unsafeRaw,\n          }) as const,\n      },\n    ],\n    events,\n  );\n"],"mappings":";;;AAiCA,MAAa,WAAW;CACtB,gBAAmB,QAA0B,UAC3C,OAAO,cAAc,QAAQ,MAAM;CACrC,cACE,SACA,UACA,WAEA,OAAO,eACL,OAAO,WACL,SAAS,KAAK,YAAY;EACxB,MAAM,YAAY,GAAG,SAAiC;AACpD,YAAS,cAAc,QAAQ,QAAQ,KAAK,GAAG,KAAK,CAAC;;AAEvD,UAAQ,GAAG,QAAQ,OAAO,SAAS;AACnC,SAAO;GAAE,OAAO,QAAQ;GAAO;GAAU;GACzC,CACH,GACA,cACC,OAAO,WAAW;AAChB,OAAK,MAAM,EAAE,OAAO,cAAc,UAChC,KAAI,QAAQ,IAAK,SAAQ,IAAI,OAAO,SAAS;MACxC,SAAQ,iBAAiB,OAAO,SAAS;GAEhD,CACL;CACJ;AAED,MAAa,oBACX,QACA,WAEA,SAAS,YACP,QACA;CACE;EACE,OAAO;EACP,OAAO,GAAG,eAAe;GAAE,MAAM;GAAW;GAAW;EACxD;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GAAE,MAAM;GAAqB;GAAW;EAC5C;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GAAE,MAAM;GAAqB;GAAW;EAC5C;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GAAE,MAAM;GAAkB;GAAW;EACzC;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GAAE,MAAM;GAA2B;GAAW;EAClD;CACF,EACD,OACD;AAEH,MAAa,qBACX,SACA,WAEA,SAAS,YACP,SACA;CACE;EACE,OAAO;EACP,OAAO,eAAe;GAAE,MAAM;GAAa;GAAW;EACvD;CACD;EACE,OAAO;EACP,OAAO,eAAe;GAAE,MAAM;GAAoB;GAAW;EAC9D;CACD;EACE,OAAO;EACP,OAAO,eAAe;GAAE,MAAM;GAAiB;GAAW;EAC3D;CACD;EACE,OAAO;EACP,aAAa,EAAE,MAAM,mBAAmB;EACzC;CACF,EACD,OACD;AAEH,MAAa,0BACX,cACA,WAEA,SAAS,YACP,cACA;CACE;EACE,OAAO;EACP,OAAO,oBACJ;GACC,MAAM;GACN,gBAAgB,OAAO,eAAe;GACvC;EACJ;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GACC,MAAM;GACN,gBAAgB,aAAa;GAC7B,OAAO;GACR;EACJ;CACD;EACE,OAAO;EACP,aACG;GACC,MAAM;GACN,gBAAgB,aAAa;GAC9B;EACJ;CACD;EACE,OAAO;EACP,OAAO,WACJ;GACC,MAAM;GACN,gBAAgB,aAAa;GAC7B;GACD;EACJ;CACD;EACE,OAAO;EACP,OAAO,GAAG,eACP;GACC,MAAM;GACN,gBAAgB,aAAa;GAC7B;GACD;EACJ;CACF,EACD,OACD"}

package/dist/internal/metadata/arguments.d.mts

@@ -0,0 +1,2 @@
+import { methodArgumentMetadataFromRaw, readBooleanAttribute, resolveMethodMapping } from "../method/arguments.mjs";
+export { methodArgumentMetadataFromRaw, readBooleanAttribute, resolveMethodMapping };

package/dist/internal/metadata/arguments.mjs

@@ -0,0 +1,3 @@
+import { methodArgumentMetadataFromRaw, readBooleanAttribute, resolveMethodMapping } from "../method/arguments.mjs";
+
+export { methodArgumentMetadataFromRaw, readBooleanAttribute, resolveMethodMapping };

package/dist/internal/metadata/methods.d.mts

@@ -0,0 +1,2 @@
+import { MetadataService, makeMetadataService } from "./service.mjs";
+export { type MetadataService, makeMetadataService };

package/dist/internal/metadata/methods.mjs

@@ -0,0 +1,3 @@
+import { makeMetadataService } from "./service.mjs";
+
+export { makeMetadataService };

package/dist/internal/metadata/service.d.mts

@@ -0,0 +1,23 @@
+import { AnyVariableDef, NodeIdString, VariableMetadata } from "../../OpcuaVariable.mjs";
+import "../common/node-id.mjs";
+import { OpcuaStructureRuntime } from "../structures/runtime.mjs";
+import { OpcuaAccessDeniedError, OpcuaConfigurationError, OpcuaMethodNotExecutableError, OpcuaServiceError } from "../../OpcuaError.mjs";
+import { AnyMethodDef, MethodMetadata } from "../../OpcuaMethod.mjs";
+import { OpcuaAccessBits, OpcuaMetadataAttribute, OpcuaMetadataReadFailure, OpcuaNodeMetadata, OpcuaNodeMetadataResult } from "../../OpcuaSession.mjs";
+import { ClientSession, DataType, NodeId } from "node-opcua";
+import { Effect } from "effect";
+
+//#region src/internal/metadata/service.d.ts
+type MetadataService = {
+  readonly namespaceArray: () => Effect.Effect<readonly string[], OpcuaServiceError | OpcuaConfigurationError>;
+  readonly node: (nodeId: NodeIdString) => Effect.Effect<OpcuaNodeMetadata, OpcuaServiceError | OpcuaConfigurationError>;
+  readonly nodes: (nodeIds: readonly NodeIdString[]) => Effect.Effect<readonly OpcuaNodeMetadataResult[], OpcuaServiceError | OpcuaConfigurationError>;
+  readonly variable: (def: AnyVariableDef) => Effect.Effect<VariableMetadata, OpcuaServiceError | OpcuaConfigurationError | OpcuaAccessDeniedError>;
+  readonly method: (def: AnyMethodDef) => Effect.Effect<MethodMetadata, OpcuaServiceError | OpcuaConfigurationError | OpcuaMethodNotExecutableError>;
+  readonly builtInDataType: (dataTypeNodeId: NodeId) => Effect.Effect<DataType, OpcuaServiceError | OpcuaConfigurationError>;
+  readonly invalidate: Effect.Effect<void>;
+};
+declare const makeMetadataService: (session: ClientSession, structureRuntime: OpcuaStructureRuntime) => MetadataService;
+//#endregion
+export { MetadataService, type OpcuaAccessBits, type OpcuaMetadataAttribute, type OpcuaMetadataReadFailure, type OpcuaNodeMetadata, type OpcuaNodeMetadataResult, makeMetadataService };
+//# sourceMappingURL=service.d.mts.map

package/dist/internal/metadata/service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.mts","names":[],"sources":["../../../src/internal/metadata/service.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAsEY,eAAA;EAAA,SAAA,cAAe,EAAA,GAAA,GACM,MAAA,CAAO,MADb,CAAA,SAAA,MAAA,EAAA,EAGvB,iBAHuB,GAGH,uBAHG,CAAA;EAGvB,SAAA,IAAA,EAAA,CAAA,MAAA,EAGQ,YAHR,EAAA,GAIG,MAAA,CAAO,MAJV,CAKA,iBALA,EAMA,iBANA,GAMoB,uBANpB,CAAA;EAAoB,SAAA,KAAA,EAAA,CAAA,OAAA,EAAA,SASF,YATE,EAAA,EAAA,GAUjB,MAAA,CAAO,MAVU,CAAA,SAWX,uBAXW,EAAA,EAYpB,iBAZoB,GAYA,uBAZA,CAAA;EAFS,SAAO,QAAA,EAAA,CAAA,GAAA,EAiB/B,cAjB+B,EAAA,GAkBjC,MAAA,CAAO,MAlB0B,CAmBpC,gBAnBoC,EAoBpC,iBApBoC,GAoBhB,uBApBgB,GAoBU,sBApBV,CAAA;EAK5B,SAAA,MAAA,EAAA,CAAA,GAAA,EAkBH,YAlBG,EAAA,GAmBL,MAAA,CAAO,MAnBF,CAoBR,cApBQ,EAqBR,iBArBQ,GAqBY,uBArBZ,GAqBsC,6BArBtC,CAAA;EAER,SAAA,eAAA,EAAA,CAAA,cAAA,EAsBgB,MAtBhB,EAAA,GAuBG,MAAA,CAAO,MAvBV,CAuBiB,QAvBjB,EAuB2B,iBAvB3B,GAuB+C,uBAvB/C,CAAA;EACA,SAAA,UAAA,EAuBmB,MAAA,CAAO,MAvB1B,CAAA,IAAA,CAAA;CAAoB;AAFjB,cAqCM,mBArCC,EAAA,CAAA,OAAA,EAsCH,aAtCG,EAAA,gBAAA,EAuCM,qBAvCN,EAAA,GAwCX,eAxCW"}

package/dist/internal/metadata/service.mjs

@@ -0,0 +1,416 @@
+import { isGood, normalizeLocalizedText, normalizeQualifiedName, normalizeStatusCode } from "../values/normalize.mjs";
+import { configurationError, isConfigurationError, methodNotExecutableError, serviceError } from "../../OpcuaError.mjs";
+import { Codec } from "../values/codec.mjs";
+import { accessDeniedError, codecMetadata, variableAccessCapabilities, variableMetadataFromRaw } from "../variable/operations.mjs";
+import { methodArgumentMetadataFromRaw, readBooleanAttribute, resolveMethodMapping } from "../method/arguments.mjs";
+import { AccessLevelFlag, AttributeIds, BrowseDirection, DataType, DataTypeIds, NodeClass, NodeId, NodeIdType, ReferenceTypeIds, StatusCodes, coerceNodeId } from "node-opcua";
+import { Effect } from "effect";
+
+//#region src/internal/metadata/service.ts
+const makeMetadataService = (session, structureRuntime) => {
+	let namespaceArrayCache;
+	const variableCache = /* @__PURE__ */ new Map();
+	const methodCache = /* @__PURE__ */ new Map();
+	const builtInDataTypeCache = /* @__PURE__ */ new Map();
+	const namespaceArray = () => Effect.suspend(() => {
+		if (namespaceArrayCache !== void 0) return Effect.succeed(namespaceArrayCache);
+		return readNamespaceArray(session).pipe(Effect.tap((value) => Effect.sync(() => {
+			namespaceArrayCache = value;
+		})));
+	});
+	const nodes = (nodeIds) => readManyNodeMetadata(session, namespaceArray, nodeIds);
+	const node = (nodeId) => Effect.gen(function* () {
+		const [result] = yield* nodes([nodeId]);
+		if (!result || result._tag === "Failure") return yield* Effect.fail(configurationError({
+			operation: "metadata.node",
+			nodeId,
+			cause: result?._tag === "Failure" ? result.reason : "No metadata result was returned"
+		}));
+		return result.metadata;
+	});
+	const builtInDataType = (dataTypeNodeId) => Effect.suspend(() => {
+		const key = dataTypeNodeId.toString();
+		const cached = builtInDataTypeCache.get(key);
+		if (cached !== void 0) return Effect.succeed(cached);
+		return resolveBuiltInDataType(session, dataTypeNodeId).pipe(Effect.tap((value) => Effect.sync(() => {
+			builtInDataTypeCache.set(key, value);
+		})));
+	});
+	const rawVariableMetadata = (nodeId) => Effect.suspend(() => {
+		const cached = variableCache.get(nodeId);
+		if (cached) return Effect.succeed(cached);
+		return discoverVariableMetadata(session, nodeId, builtInDataType).pipe(Effect.tap((metadata) => Effect.sync(() => {
+			variableCache.set(nodeId, metadata);
+		})));
+	});
+	const variable = (def) => Effect.gen(function* () {
+		const metadata = yield* rawVariableMetadata(def.nodeId);
+		for (const capability of variableAccessCapabilities(def.access)) {
+			const error = accessDeniedError(def.nodeId, capability, metadata.accessLevel, metadata.userAccessLevel);
+			if (error) return yield* Effect.fail(error);
+		}
+		if (Codec.requiresStructureRuntime(def.codec)) yield* structureRuntime.ensureInitialized();
+		yield* Codec.validateMetadata(def.codec, codecMetadata(metadata));
+		return metadata;
+	});
+	const rawMethodMetadata = (def) => Effect.suspend(() => {
+		const key = `${def.objectId}\u0000${def.methodId}`;
+		const cached = methodCache.get(key);
+		if (cached) return Effect.succeed(cached);
+		return discoverMethodBaseMetadata(session, def, builtInDataType).pipe(Effect.tap((metadata) => Effect.sync(() => {
+			methodCache.set(key, metadata);
+		})));
+	});
+	const method = (def) => Effect.gen(function* () {
+		const base = yield* rawMethodMetadata(def);
+		if (!base.executable || base.userExecutable === false) return yield* Effect.fail(methodNotExecutableError({
+			objectId: def.objectId,
+			methodId: def.methodId,
+			executable: base.executable,
+			userExecutable: base.userExecutable
+		}));
+		if (Object.values(def.input ?? {}).some((arg) => Codec.requiresStructureRuntime(arg.codec)) || Object.values(def.output ?? {}).some((arg) => Codec.requiresStructureRuntime(arg.codec))) yield* structureRuntime.ensureInitialized();
+		const inputMapping = yield* resolveMethodMapping("method.input", def.methodId, base.inputArguments, def.input);
+		const outputMapping = yield* resolveMethodMapping("method.output", def.methodId, base.outputArguments, def.output);
+		return {
+			...base,
+			inputMapping,
+			outputMapping
+		};
+	});
+	return {
+		namespaceArray,
+		node,
+		nodes,
+		variable,
+		method,
+		builtInDataType,
+		invalidate: Effect.sync(() => {
+			namespaceArrayCache = void 0;
+			variableCache.clear();
+			methodCache.clear();
+			builtInDataTypeCache.clear();
+		})
+	};
+};
+const readNamespaceArray = (session) => Effect.gen(function* () {
+	const dataValue = yield* Effect.tryPromise({
+		try: () => session.read({
+			nodeId: coerceNodeId("i=2255"),
+			attributeId: AttributeIds.Value
+		}, 0),
+		catch: (cause) => serviceError({
+			operation: "metadata.namespaceArray",
+			nodeId: "i=2255",
+			cause
+		})
+	});
+	if (!isGood(dataValue.statusCode)) return yield* Effect.fail(configurationError({
+		operation: "metadata.namespaceArray",
+		nodeId: "i=2255",
+		cause: normalizeStatusCode(dataValue.statusCode)
+	}));
+	const value = dataValue.value?.value;
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return yield* Effect.fail(configurationError({
+		operation: "metadata.namespaceArray",
+		nodeId: "i=2255",
+		cause: "NamespaceArray value is not a string array"
+	}));
+	return [...value];
+});
+const metadataAttributes = [
+	["NodeClass", AttributeIds.NodeClass],
+	["BrowseName", AttributeIds.BrowseName],
+	["DisplayName", AttributeIds.DisplayName],
+	["Description", AttributeIds.Description],
+	["DataType", AttributeIds.DataType],
+	["ValueRank", AttributeIds.ValueRank],
+	["ArrayDimensions", AttributeIds.ArrayDimensions],
+	["AccessLevel", AttributeIds.AccessLevel],
+	["UserAccessLevel", AttributeIds.UserAccessLevel]
+];
+const maxMetadataNodesPerRead = 50;
+const requiredMetadataAttributes = new Set(["NodeClass", "BrowseName"]);
+const readManyNodeMetadata = (session, namespaceArray, nodeIds) => Effect.gen(function* () {
+	if (nodeIds.length === 0) return [];
+	const namespaceUris = yield* namespaceArray();
+	const results = [];
+	for (const batch of chunks(nodeIds, maxMetadataNodesPerRead)) {
+		const batchResults = yield* readNodeMetadataBatch(session, namespaceUris, batch);
+		results.push(...batchResults);
+	}
+	return results;
+});
+const readNodeMetadataBatch = (session, namespaceUris, nodeIds) => Effect.gen(function* () {
+	const readPlan = nodeIds.map((nodeId) => {
+		const parsed = coerceNodeId(nodeId);
+		return {
+			nodeId,
+			parsed,
+			nodesToRead: metadataAttributes.map(([attribute, attributeId]) => ({
+				nodeId: parsed,
+				attributeId,
+				attribute
+			}))
+		};
+	});
+	const flatNodes = readPlan.flatMap((entry) => entry.nodesToRead);
+	const values = yield* Effect.tryPromise({
+		try: () => session.read(flatNodes, 0),
+		catch: (cause) => serviceError({
+			operation: "metadata.nodes",
+			cause
+		})
+	});
+	if (values.length !== flatNodes.length) return yield* Effect.fail(serviceError({
+		operation: "metadata.nodes",
+		cause: `Expected ${flatNodes.length} DataValues, got ${values.length}`
+	}));
+	let offset = 0;
+	return readPlan.map((entry) => {
+		const valuesByAttribute = /* @__PURE__ */ new Map();
+		for (const [attribute] of metadataAttributes) valuesByAttribute.set(attribute, values[offset++]);
+		const failure = metadataFailure(valuesByAttribute);
+		if (failure) return {
+			_tag: "Failure",
+			nodeId: entry.nodeId,
+			reason: failure
+		};
+		return {
+			_tag: "Success",
+			nodeId: entry.nodeId,
+			metadata: nodeMetadataFromValues(entry.nodeId, entry.parsed.namespace, namespaceUris[entry.parsed.namespace], valuesByAttribute)
+		};
+	});
+});
+const chunks = (items, size) => {
+	const result = [];
+	for (let index = 0; index < items.length; index += size) result.push([...items.slice(index, index + size)]);
+	return result;
+};
+const metadataFailure = (values) => {
+	for (const attribute of requiredMetadataAttributes) {
+		const value = values.get(attribute);
+		if (!value || !isGood(value.statusCode)) return {
+			_tag: "NonGoodStatus",
+			attribute,
+			status: normalizeStatusCode(value?.statusCode ?? StatusCodes.BadInternalError)
+		};
+	}
+	if (typeof values.get("NodeClass")?.value?.value !== "number") return {
+		_tag: "InvalidValue",
+		attribute: "NodeClass",
+		message: "NodeClass value is not numeric"
+	};
+	if (!values.get("BrowseName")?.value?.value) return {
+		_tag: "InvalidValue",
+		attribute: "BrowseName",
+		message: "BrowseName value is missing"
+	};
+};
+const nodeMetadataFromValues = (nodeId, namespaceIndex, namespaceUri, values) => {
+	const browseNameValue = values.get("BrowseName")?.value?.value;
+	const displayNameValue = values.get("DisplayName");
+	const descriptionValue = values.get("Description");
+	const nodeClassNumber = values.get("NodeClass")?.value?.value;
+	const browseName = normalizeQualifiedName(browseNameValue);
+	return {
+		nodeId,
+		nodeClass: NodeClass[nodeClassNumber] ?? String(nodeClassNumber),
+		browseName: browseName.name,
+		browseNameNamespaceIndex: browseName.namespaceIndex,
+		displayName: localizedText(displayNameValue),
+		description: localizedText(descriptionValue),
+		dataType: nodeIdValue(values.get("DataType")),
+		valueRank: numberValue(values.get("ValueRank")),
+		arrayDimensions: numberArrayValue(values.get("ArrayDimensions")),
+		accessLevel: accessBits(values.get("AccessLevel")),
+		userAccessLevel: accessBits(values.get("UserAccessLevel")),
+		namespaceIndex,
+		namespaceUri
+	};
+};
+const localizedText = (dataValue) => {
+	if (!dataValue || !isGood(dataValue.statusCode) || !dataValue.value?.value) return;
+	return normalizeLocalizedText(dataValue.value.value).text;
+};
+const nodeIdValue = (dataValue) => {
+	if (!dataValue || !isGood(dataValue.statusCode)) return void 0;
+	const value = dataValue.value?.value;
+	return value instanceof NodeId ? value.toString() : void 0;
+};
+const numberValue = (dataValue) => {
+	if (!dataValue || !isGood(dataValue.statusCode)) return void 0;
+	const value = dataValue.value?.value;
+	return typeof value === "number" ? value : void 0;
+};
+const numberArrayValue = (dataValue) => {
+	if (!dataValue || !isGood(dataValue.statusCode)) return void 0;
+	const value = dataValue.value?.value;
+	if (!Array.isArray(value) || !value.every((item) => typeof item === "number")) return;
+	return [...value];
+};
+const accessBits = (dataValue) => {
+	const value = numberValue(dataValue);
+	if (value === void 0) return void 0;
+	return {
+		readable: (value & AccessLevelFlag.CurrentRead) !== 0,
+		writable: (value & AccessLevelFlag.CurrentWrite) !== 0
+	};
+};
+const discoverVariableMetadata = (session, nodeId, builtInDataType) => Effect.gen(function* () {
+	const nodes = [
+		AttributeIds.DataType,
+		AttributeIds.ValueRank,
+		AttributeIds.ArrayDimensions,
+		AttributeIds.AccessLevel,
+		AttributeIds.UserAccessLevel
+	].map((attributeId) => ({
+		nodeId: coerceNodeId(nodeId),
+		attributeId
+	}));
+	const [dataTypeValue, valueRankValue, arrayDimensionsValue, accessLevelValue, userAccessLevelValue] = yield* Effect.tryPromise({
+		try: () => session.read(nodes, 0),
+		catch: (cause) => serviceError({
+			operation: "metadata.variable",
+			nodeId,
+			cause
+		})
+	});
+	if (!dataTypeValue || !isGood(dataTypeValue.statusCode) || !(dataTypeValue.value?.value instanceof NodeId)) return yield* Effect.fail(configurationError({
+		operation: "metadata.variable",
+		nodeId,
+		cause: "DataType is unreadable"
+	}));
+	if (!valueRankValue || !isGood(valueRankValue.statusCode) || typeof valueRankValue.value?.value !== "number") return yield* Effect.fail(configurationError({
+		operation: "metadata.variable",
+		nodeId,
+		cause: "ValueRank is unreadable"
+	}));
+	if (!accessLevelValue || !isGood(accessLevelValue.statusCode) || typeof accessLevelValue.value?.value !== "number") return yield* Effect.fail(configurationError({
+		operation: "metadata.variable",
+		nodeId,
+		cause: "AccessLevel is unreadable"
+	}));
+	const dataTypeNodeId = dataTypeValue.value.value;
+	const builtIn = yield* builtInDataType(dataTypeNodeId);
+	const userAccessLevel = userAccessLevelValue && isGood(userAccessLevelValue.statusCode) && typeof userAccessLevelValue.value?.value === "number" ? userAccessLevelValue.value.value : void 0;
+	return variableMetadataFromRaw({
+		nodeId,
+		dataTypeNodeId,
+		builtInDataType: builtIn,
+		valueRank: valueRankValue.value.value,
+		arrayDimensions: arrayDimensionsValue && isGood(arrayDimensionsValue.statusCode) && Array.isArray(arrayDimensionsValue.value?.value) ? arrayDimensionsValue.value.value : void 0,
+		accessLevel: accessLevelValue.value.value,
+		userAccessLevel
+	});
+});
+const discoverMethodBaseMetadata = (session, def, builtInDataType) => Effect.gen(function* () {
+	const methodId = yield* coerceNodeIdOrFail("metadata.method.methodId", def.methodId);
+	const argumentDefinition = yield* Effect.tryPromise({
+		try: () => session.getArgumentDefinition(methodId),
+		catch: (cause) => serviceError({
+			operation: "metadata.method.getArgumentDefinition",
+			nodeId: def.methodId,
+			cause
+		})
+	});
+	const [executable, userExecutable] = yield* readExecutableAttributes(session, def, methodId);
+	const inputArguments = yield* normalizeArguments(def.methodId, argumentDefinition.inputArguments ?? [], builtInDataType);
+	const outputArguments = yield* normalizeArguments(def.methodId, argumentDefinition.outputArguments ?? [], builtInDataType);
+	return {
+		objectId: def.objectId,
+		methodId: def.methodId,
+		executable,
+		userExecutable,
+		inputArguments,
+		outputArguments
+	};
+});
+const readExecutableAttributes = (session, def, methodId) => Effect.gen(function* () {
+	const [executableValue, userExecutableValue] = yield* Effect.tryPromise({
+		try: () => session.read([{
+			nodeId: methodId,
+			attributeId: AttributeIds.Executable
+		}, {
+			nodeId: methodId,
+			attributeId: AttributeIds.UserExecutable
+		}], 0),
+		catch: (cause) => serviceError({
+			operation: "metadata.method.executable",
+			nodeId: def.methodId,
+			cause
+		})
+	});
+	const executable = readBooleanAttribute(executableValue, "metadata.method.executable", def.methodId, true);
+	const userExecutable = readBooleanAttribute(userExecutableValue, "metadata.method.userExecutable", def.methodId, false);
+	if (isConfigurationError(executable)) return yield* Effect.fail(executable);
+	if (isConfigurationError(userExecutable)) return yield* Effect.fail(userExecutable);
+	return [executable, userExecutable];
+});
+const normalizeArguments = (methodNodeId, arguments_, builtInDataType) => Effect.forEach(arguments_, (argument) => Effect.gen(function* () {
+	const dataTypeNodeId = argument.dataType instanceof NodeId ? argument.dataType : yield* coerceNodeIdOrFail("metadata.method.argument.dataType", String(argument.dataType));
+	return methodArgumentMetadataFromRaw(argument, dataTypeNodeId, yield* builtInDataType(dataTypeNodeId));
+})).pipe(Effect.mapError((error) => isConfigurationError(error) ? configurationError({
+	operation: "metadata.method.argument",
+	nodeId: methodNodeId,
+	cause: error.reason.cause
+}) : error));
+const resolveBuiltInDataType = (session, dataTypeNodeId) => Effect.gen(function* () {
+	let current = dataTypeNodeId;
+	const visited = /* @__PURE__ */ new Set();
+	while (true) {
+		const builtIn = builtInDataTypeFromNodeId(current);
+		if (builtIn !== void 0) return builtIn;
+		const key = current.toString();
+		if (visited.has(key)) return yield* Effect.fail(configurationError({
+			operation: "metadata.builtInDataType",
+			nodeId: dataTypeNodeId.toString(),
+			cause: `DataType hierarchy contains a cycle at ${key}`
+		}));
+		visited.add(key);
+		const superType = yield* browseDataTypeSuperType(session, current);
+		if (!superType) return yield* Effect.fail(configurationError({
+			operation: "metadata.builtInDataType",
+			nodeId: dataTypeNodeId.toString(),
+			cause: `Could not resolve built-in DataType for ${dataTypeNodeId.toString()}`
+		}));
+		current = superType;
+	}
+});
+const builtInDataTypeFromNodeId = (nodeId) => {
+	if (nodeId.identifierType === NodeIdType.NUMERIC && nodeId.namespace === 0 && nodeId.value === DataTypeIds.Enumeration) return DataType.Int32;
+	if (nodeId.identifierType === NodeIdType.NUMERIC && nodeId.namespace === 0 && typeof nodeId.value === "number" && nodeId.value <= DataType.DiagnosticInfo && DataType[nodeId.value] !== void 0) return nodeId.value;
+};
+const browseDataTypeSuperType = (session, dataTypeNodeId) => Effect.tryPromise({
+	try: async () => {
+		const browse = {
+			browseDirection: BrowseDirection.Inverse,
+			includeSubtypes: false,
+			nodeId: dataTypeNodeId,
+			referenceTypeId: coerceNodeId(ReferenceTypeIds.HasSubtype),
+			resultMask: 1
+		};
+		const result = await session.browse(browse);
+		if (!isGood(result.statusCode)) throw new Error(result.statusCode.toString());
+		const nodeId = result.references?.[0]?.nodeId;
+		return nodeId ? coerceNodeId(nodeId) : void 0;
+	},
+	catch: (cause) => serviceError({
+		operation: "metadata.browseDataTypeSuperType",
+		nodeId: dataTypeNodeId.toString(),
+		cause
+	})
+});
+const coerceNodeIdOrFail = (operation, nodeId) => Effect.try({
+	try: () => coerceNodeId(nodeId),
+	catch: (cause) => configurationError({
+		operation,
+		nodeId: String(nodeId),
+		cause
+	})
+});
+
+//#endregion
+export { makeMetadataService };
+//# sourceMappingURL=service.mjs.map