@effect-opcua/codegen 0.1.0-alpha.0

package/dist/compile/structures.mjs

@@ -0,0 +1,220 @@
+import { issue } from "../diagnostics.mjs";
+import { nodeOpcuaFieldName, sanitizeCamel, sanitizePascal } from "./names.mjs";
+import { isDynamicScalarDataType, isUnsupportedArrayRank, scalarSchema } from "./builtin-types.mjs";
+import { typeFallbackSeverity } from "./policy.mjs";
+
+//#region src/compile/structures.ts
+const compileStructures = (config, definitions, enums, invalidEnums) => {
+	const issues = [];
+	const unsupportedSeverity = typeFallbackSeverity(config);
+	const rawStructures = /* @__PURE__ */ new Map();
+	const invalidStructures = /* @__PURE__ */ new Set();
+	const structureNames = /* @__PURE__ */ new Map();
+	const nameGroups = /* @__PURE__ */ new Map();
+	for (const [nodeId, definition] of definitions) {
+		if (definition._tag !== "Structure") continue;
+		rawStructures.set(nodeId, definition);
+		const name = sanitizePascal(definition.name);
+		if (!name) {
+			invalidStructures.add(nodeId);
+			issues.push(issue("structure.emptyName", {
+				severity: "error",
+				message: `Structure ${nodeId} has no usable generated name`,
+				nodeId
+			}));
+			continue;
+		}
+		structureNames.set(nodeId, name);
+		nameGroups.set(name, [...nameGroups.get(name) ?? [], nodeId]);
+	}
+	for (const [name, nodeIds] of nameGroups) if (nodeIds.length > 1) {
+		for (const nodeId of nodeIds) invalidStructures.add(nodeId);
+		issues.push(issue("structure.nameCollision", {
+			severity: "error",
+			message: `Multiple structure DataTypes generate ${name}`,
+			generatedPath: [name],
+			cause: { candidates: nodeIds }
+		}));
+	}
+	for (const [nodeId, definition] of rawStructures) {
+		const name = structureNames.get(nodeId) ?? nodeId;
+		if (definition.structureType === "Union") {
+			invalidStructures.add(nodeId);
+			issues.push(issue("datatype.unionUnsupported", {
+				severity: unsupportedSeverity,
+				message: `Union DataType ${name} is not generated`,
+				nodeId,
+				generatedPath: [name]
+			}));
+		}
+		if (definition.structureType === "Unknown") {
+			invalidStructures.add(nodeId);
+			issues.push(issue("datatype.definitionUnsupported", {
+				severity: unsupportedSeverity,
+				message: `Structure DataType ${name} has unsupported structure type`,
+				nodeId,
+				generatedPath: [name]
+			}));
+		}
+	}
+	const validFieldNames = /* @__PURE__ */ new Map();
+	for (const [nodeId, definition] of rawStructures) {
+		if (invalidStructures.has(nodeId)) continue;
+		const name = structureNames.get(nodeId);
+		const generatedNames = /* @__PURE__ */ new Map();
+		const fieldNames = [];
+		for (const [index, field] of definition.fields.entries()) {
+			let fieldName = sanitizeCamel(field.name);
+			if (!fieldName) {
+				fieldName = `_field${index + 1}`;
+				issues.push(issue("structure.fieldEmptyName", {
+					message: `Structure ${name} has a field without a usable generated name`,
+					nodeId,
+					generatedPath: [name, fieldName]
+				}));
+			}
+			generatedNames.set(fieldName, [...generatedNames.get(fieldName) ?? [], field.name]);
+			fieldNames.push(fieldName);
+		}
+		const collision = [...generatedNames].find(([, candidates]) => candidates.length > 1);
+		if (collision) {
+			invalidStructures.add(nodeId);
+			issues.push(issue("structure.fieldNameCollision", {
+				severity: "error",
+				message: `Structure ${name} has colliding generated field ${collision[0]}`,
+				nodeId,
+				generatedPath: [name, collision[0]],
+				cause: { candidates: collision[1] }
+			}));
+			continue;
+		}
+		validFieldNames.set(nodeId, fieldNames);
+	}
+	const recursiveFields = recursiveStructureFields(rawStructures);
+	const structures = /* @__PURE__ */ new Map();
+	for (const [nodeId, definition] of rawStructures) {
+		if (invalidStructures.has(nodeId)) continue;
+		const name = structureNames.get(nodeId);
+		const fieldNames = validFieldNames.get(nodeId);
+		const fields = definition.fields.map((field, index) => {
+			const fieldName = fieldNames[index];
+			const recursive = recursiveFields.get(nodeId)?.has(field.dataTypeNodeId);
+			if (recursive) issues.push(issue("structure.recursiveField", {
+				severity: unsupportedSeverity,
+				message: `Structure ${name} has recursive field ${field.name}`,
+				nodeId,
+				generatedPath: [name, fieldName]
+			}));
+			return {
+				name: fieldName,
+				encodedName: nodeOpcuaFieldName(field.name),
+				originalName: field.name,
+				optional: field.isOptional === true,
+				schema: recursive ? { _tag: "Unknown" } : fieldSchema({
+					ownerNodeId: nodeId,
+					fieldNodeId: field.dataTypeNodeId,
+					valueRank: field.valueRank,
+					definitions,
+					rawStructures,
+					structureNames,
+					invalidStructures,
+					enums,
+					invalidEnums,
+					issues,
+					unsupportedSeverity
+				})
+			};
+		});
+		structures.set(nodeId, {
+			name,
+			dataTypeNodeId: nodeId,
+			browseName: definition.name,
+			fields
+		});
+	}
+	return {
+		structures,
+		invalidStructures,
+		issues
+	};
+};
+const fieldSchema = (input) => {
+	if (isUnsupportedArrayRank(input.valueRank)) {
+		input.issues.push(issue("structure.unsupportedField", {
+			severity: input.unsupportedSeverity,
+			message: `Structure field has unsupported array rank ${input.valueRank}`,
+			nodeId: input.ownerNodeId
+		}));
+		return { _tag: "Unknown" };
+	}
+	const isArray = input.valueRank === 1;
+	const wrapArray = (schema) => isArray ? {
+		_tag: "Array",
+		item: schema
+	} : schema;
+	const scalar = scalarSchema(input.fieldNodeId);
+	if (scalar) return wrapArray({
+		_tag: "Scalar",
+		schema: scalar
+	});
+	const enumDefinition = input.enums.get(input.fieldNodeId);
+	if (enumDefinition) return wrapArray({
+		_tag: "Enum",
+		name: enumDefinition.name
+	});
+	if (input.invalidEnums.has(input.fieldNodeId)) return wrapArray({
+		_tag: "Scalar",
+		schema: "Number"
+	});
+	const structureName = input.structureNames.get(input.fieldNodeId);
+	if (structureName && !input.invalidStructures.has(input.fieldNodeId)) return wrapArray({
+		_tag: "Structure",
+		name: structureName
+	});
+	if (isDynamicScalarDataType(input.fieldNodeId)) {
+		input.issues.push(issue("structure.unsupportedField", {
+			severity: input.unsupportedSeverity,
+			message: `Structure field references dynamic scalar DataType ${input.fieldNodeId}`,
+			nodeId: input.ownerNodeId
+		}));
+		return wrapArray({ _tag: "Unknown" });
+	}
+	if (input.rawStructures.get(input.fieldNodeId)?.structureType === "Union" || input.invalidStructures.has(input.fieldNodeId)) {
+		input.issues.push(issue("structure.unsupportedField", {
+			severity: input.unsupportedSeverity,
+			message: `Structure field references unsupported DataType ${input.fieldNodeId}`,
+			nodeId: input.ownerNodeId
+		}));
+		return { _tag: "Unknown" };
+	}
+	if (!input.definitions.has(input.fieldNodeId)) input.issues.push(issue("structure.unsupportedField", {
+		severity: input.unsupportedSeverity,
+		message: `Structure field references DataType without definition ${input.fieldNodeId}`,
+		nodeId: input.ownerNodeId
+	}));
+	return { _tag: "Unknown" };
+};
+const recursiveStructureFields = (structures) => {
+	const result = /* @__PURE__ */ new Map();
+	const dependencies = /* @__PURE__ */ new Map();
+	for (const [nodeId, structure] of structures) dependencies.set(nodeId, structure.fields.map((field) => field.dataTypeNodeId).filter((fieldNodeId) => structures.has(fieldNodeId)));
+	for (const [nodeId, structure] of structures) for (const field of structure.fields) {
+		if (!structures.has(field.dataTypeNodeId)) continue;
+		if (reaches(field.dataTypeNodeId, nodeId, dependencies, /* @__PURE__ */ new Set())) {
+			const set = result.get(nodeId) ?? /* @__PURE__ */ new Set();
+			set.add(field.dataTypeNodeId);
+			result.set(nodeId, set);
+		}
+	}
+	return result;
+};
+const reaches = (current, target, dependencies, seen) => {
+	if (current === target) return true;
+	if (seen.has(current)) return false;
+	seen.add(current);
+	return (dependencies.get(current) ?? []).some((next) => reaches(next, target, dependencies, seen));
+};
+
+//#endregion
+export { compileStructures };
+//# sourceMappingURL=structures.mjs.map

package/dist/compile/structures.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"structures.mjs","names":["issues: CodegenIssue[]","fieldNames: string[]","fields: StructureFieldDefinition[]"],"sources":["../../src/compile/structures.ts"],"sourcesContent":["import type { OpcuaSession } from \"@effect-opcua/client\";\n\nimport { issue } from \"../diagnostics.js\";\nimport type { CodegenIssue } from \"../types.js\";\nimport type {\n  EnumDefinition,\n  NormalizedCodegenConfig,\n  SchemaExpression,\n  StructureDefinition,\n  StructureFieldDefinition,\n} from \"../internal/types.js\";\nimport {\n  isDynamicScalarDataType,\n  isUnsupportedArrayRank,\n  scalarSchema,\n} from \"./builtin-types.js\";\nimport { nodeOpcuaFieldName, sanitizeCamel, sanitizePascal } from \"./names.js\";\nimport { typeFallbackSeverity } from \"./policy.js\";\n\ntype OpcuaDataTypeDefinition = OpcuaSession.OpcuaDataTypeDefinition;\ntype OpcuaStructureDefinition = OpcuaSession.OpcuaStructureDefinition;\n\nexport type StructureGraph = {\n  readonly structures: ReadonlyMap<string, StructureDefinition>;\n  readonly invalidStructures: ReadonlySet<string>;\n  readonly issues: readonly CodegenIssue[];\n};\n\nexport const compileStructures = (\n  config: NormalizedCodegenConfig,\n  definitions: ReadonlyMap<string, OpcuaDataTypeDefinition>,\n  enums: ReadonlyMap<string, EnumDefinition>,\n  invalidEnums: ReadonlySet<string>,\n): StructureGraph => {\n  const issues: CodegenIssue[] = [];\n  const unsupportedSeverity = typeFallbackSeverity(config);\n  const rawStructures = new Map<string, OpcuaStructureDefinition>();\n  const invalidStructures = new Set<string>();\n  const structureNames = new Map<string, string>();\n  const nameGroups = new Map<string, string[]>();\n\n  for (const [nodeId, definition] of definitions) {\n    if (definition._tag !== \"Structure\") continue;\n    rawStructures.set(nodeId, definition);\n    const name = sanitizePascal(definition.name);\n    if (!name) {\n      invalidStructures.add(nodeId);\n      issues.push(\n        issue(\"structure.emptyName\", {\n          severity: \"error\",\n          message: `Structure ${nodeId} has no usable generated name`,\n          nodeId,\n        }),\n      );\n      continue;\n    }\n    structureNames.set(nodeId, name);\n    nameGroups.set(name, [...(nameGroups.get(name) ?? []), nodeId]);\n  }\n\n  for (const [name, nodeIds] of nameGroups) {\n    if (nodeIds.length > 1) {\n      for (const nodeId of nodeIds) invalidStructures.add(nodeId);\n      issues.push(\n        issue(\"structure.nameCollision\", {\n          severity: \"error\",\n          message: `Multiple structure DataTypes generate ${name}`,\n          generatedPath: [name],\n          cause: { candidates: nodeIds },\n        }),\n      );\n    }\n  }\n\n  for (const [nodeId, definition] of rawStructures) {\n    const name = structureNames.get(nodeId) ?? nodeId;\n    if (definition.structureType === \"Union\") {\n      invalidStructures.add(nodeId);\n      issues.push(\n        issue(\"datatype.unionUnsupported\", {\n          severity: unsupportedSeverity,\n          message: `Union DataType ${name} is not generated`,\n          nodeId,\n          generatedPath: [name],\n        }),\n      );\n    }\n    if (definition.structureType === \"Unknown\") {\n      invalidStructures.add(nodeId);\n      issues.push(\n        issue(\"datatype.definitionUnsupported\", {\n          severity: unsupportedSeverity,\n          message: `Structure DataType ${name} has unsupported structure type`,\n          nodeId,\n          generatedPath: [name],\n        }),\n      );\n    }\n  }\n\n  const validFieldNames = new Map<string, readonly string[]>();\n  for (const [nodeId, definition] of rawStructures) {\n    if (invalidStructures.has(nodeId)) continue;\n    const name = structureNames.get(nodeId)!;\n    const generatedNames = new Map<string, string[]>();\n    const fieldNames: string[] = [];\n    for (const [index, field] of definition.fields.entries()) {\n      let fieldName = sanitizeCamel(field.name);\n      if (!fieldName) {\n        fieldName = `_field${index + 1}`;\n        issues.push(\n          issue(\"structure.fieldEmptyName\", {\n            message: `Structure ${name} has a field without a usable generated name`,\n            nodeId,\n            generatedPath: [name, fieldName],\n          }),\n        );\n      }\n      generatedNames.set(fieldName, [\n        ...(generatedNames.get(fieldName) ?? []),\n        field.name,\n      ]);\n      fieldNames.push(fieldName);\n    }\n    const collision = [...generatedNames].find(\n      ([, candidates]) => candidates.length > 1,\n    );\n    if (collision) {\n      invalidStructures.add(nodeId);\n      issues.push(\n        issue(\"structure.fieldNameCollision\", {\n          severity: \"error\",\n          message: `Structure ${name} has colliding generated field ${collision[0]}`,\n          nodeId,\n          generatedPath: [name, collision[0]],\n          cause: { candidates: collision[1] },\n        }),\n      );\n      continue;\n    }\n    validFieldNames.set(nodeId, fieldNames);\n  }\n\n  const recursiveFields = recursiveStructureFields(rawStructures);\n  const structures = new Map<string, StructureDefinition>();\n  for (const [nodeId, definition] of rawStructures) {\n    if (invalidStructures.has(nodeId)) continue;\n    const name = structureNames.get(nodeId)!;\n    const fieldNames = validFieldNames.get(nodeId)!;\n    const fields: StructureFieldDefinition[] = definition.fields.map(\n      (field, index) => {\n        const fieldName = fieldNames[index]!;\n        const recursive = recursiveFields\n          .get(nodeId)\n          ?.has(field.dataTypeNodeId);\n        if (recursive) {\n          issues.push(\n            issue(\"structure.recursiveField\", {\n              severity: unsupportedSeverity,\n              message: `Structure ${name} has recursive field ${field.name}`,\n              nodeId,\n              generatedPath: [name, fieldName],\n            }),\n          );\n        }\n        return {\n          name: fieldName,\n          encodedName: nodeOpcuaFieldName(field.name),\n          originalName: field.name,\n          optional: field.isOptional === true,\n          schema: recursive\n            ? { _tag: \"Unknown\" }\n            : fieldSchema({\n                ownerNodeId: nodeId,\n                fieldNodeId: field.dataTypeNodeId,\n                valueRank: field.valueRank,\n                definitions,\n                rawStructures,\n                structureNames,\n                invalidStructures,\n                enums,\n                invalidEnums,\n                issues,\n                unsupportedSeverity,\n              }),\n        };\n      },\n    );\n    structures.set(nodeId, {\n      name,\n      dataTypeNodeId: nodeId,\n      browseName: definition.name,\n      fields,\n    });\n  }\n\n  return { structures, invalidStructures, issues };\n};\n\nconst fieldSchema = (input: {\n  readonly ownerNodeId: string;\n  readonly fieldNodeId: string;\n  readonly valueRank?: number;\n  readonly definitions: ReadonlyMap<string, OpcuaDataTypeDefinition>;\n  readonly rawStructures: ReadonlyMap<string, OpcuaStructureDefinition>;\n  readonly structureNames: ReadonlyMap<string, string>;\n  readonly invalidStructures: ReadonlySet<string>;\n  readonly enums: ReadonlyMap<string, EnumDefinition>;\n  readonly invalidEnums: ReadonlySet<string>;\n  readonly issues: CodegenIssue[];\n  readonly unsupportedSeverity: \"error\" | \"warning\";\n}): SchemaExpression => {\n  if (isUnsupportedArrayRank(input.valueRank)) {\n    input.issues.push(\n      issue(\"structure.unsupportedField\", {\n        severity: input.unsupportedSeverity,\n        message: `Structure field has unsupported array rank ${input.valueRank}`,\n        nodeId: input.ownerNodeId,\n      }),\n    );\n    return { _tag: \"Unknown\" };\n  }\n\n  const isArray = input.valueRank === 1;\n  const wrapArray = (\n    schema: Exclude<SchemaExpression, { readonly _tag: \"Array\" }>,\n  ) => (isArray ? ({ _tag: \"Array\", item: schema } as const) : schema);\n  const scalar = scalarSchema(input.fieldNodeId);\n  if (scalar) return wrapArray({ _tag: \"Scalar\", schema: scalar });\n\n  const enumDefinition = input.enums.get(input.fieldNodeId);\n  if (enumDefinition) {\n    return wrapArray({ _tag: \"Enum\", name: enumDefinition.name });\n  }\n  if (input.invalidEnums.has(input.fieldNodeId)) {\n    return wrapArray({ _tag: \"Scalar\", schema: \"Number\" });\n  }\n\n  const structureName = input.structureNames.get(input.fieldNodeId);\n  if (structureName && !input.invalidStructures.has(input.fieldNodeId)) {\n    return wrapArray({ _tag: \"Structure\", name: structureName });\n  }\n\n  if (isDynamicScalarDataType(input.fieldNodeId)) {\n    input.issues.push(\n      issue(\"structure.unsupportedField\", {\n        severity: input.unsupportedSeverity,\n        message: `Structure field references dynamic scalar DataType ${input.fieldNodeId}`,\n        nodeId: input.ownerNodeId,\n      }),\n    );\n    return wrapArray({ _tag: \"Unknown\" });\n  }\n\n  if (\n    input.rawStructures.get(input.fieldNodeId)?.structureType === \"Union\" ||\n    input.invalidStructures.has(input.fieldNodeId)\n  ) {\n    input.issues.push(\n      issue(\"structure.unsupportedField\", {\n        severity: input.unsupportedSeverity,\n        message: `Structure field references unsupported DataType ${input.fieldNodeId}`,\n        nodeId: input.ownerNodeId,\n      }),\n    );\n    return { _tag: \"Unknown\" };\n  }\n\n  if (!input.definitions.has(input.fieldNodeId)) {\n    input.issues.push(\n      issue(\"structure.unsupportedField\", {\n        severity: input.unsupportedSeverity,\n        message: `Structure field references DataType without definition ${input.fieldNodeId}`,\n        nodeId: input.ownerNodeId,\n      }),\n    );\n  }\n  return { _tag: \"Unknown\" };\n};\n\nconst recursiveStructureFields = (\n  structures: ReadonlyMap<string, OpcuaStructureDefinition>,\n) => {\n  const result = new Map<string, Set<string>>();\n  const dependencies = new Map<string, readonly string[]>();\n  for (const [nodeId, structure] of structures) {\n    dependencies.set(\n      nodeId,\n      structure.fields\n        .map((field) => field.dataTypeNodeId)\n        .filter((fieldNodeId) => structures.has(fieldNodeId)),\n    );\n  }\n  for (const [nodeId, structure] of structures) {\n    for (const field of structure.fields) {\n      if (!structures.has(field.dataTypeNodeId)) continue;\n      if (reaches(field.dataTypeNodeId, nodeId, dependencies, new Set())) {\n        const set = result.get(nodeId) ?? new Set<string>();\n        set.add(field.dataTypeNodeId);\n        result.set(nodeId, set);\n      }\n    }\n  }\n  return result;\n};\n\nconst reaches = (\n  current: string,\n  target: string,\n  dependencies: ReadonlyMap<string, readonly string[]>,\n  seen: Set<string>,\n): boolean => {\n  if (current === target) return true;\n  if (seen.has(current)) return false;\n  seen.add(current);\n  return (dependencies.get(current) ?? []).some((next) =>\n    reaches(next, target, dependencies, seen),\n  );\n};\n"],"mappings":";;;;;;AA4BA,MAAa,qBACX,QACA,aACA,OACA,iBACmB;CACnB,MAAMA,SAAyB,EAAE;CACjC,MAAM,sBAAsB,qBAAqB,OAAO;CACxD,MAAM,gCAAgB,IAAI,KAAuC;CACjE,MAAM,oCAAoB,IAAI,KAAa;CAC3C,MAAM,iCAAiB,IAAI,KAAqB;CAChD,MAAM,6BAAa,IAAI,KAAuB;AAE9C,MAAK,MAAM,CAAC,QAAQ,eAAe,aAAa;AAC9C,MAAI,WAAW,SAAS,YAAa;AACrC,gBAAc,IAAI,QAAQ,WAAW;EACrC,MAAM,OAAO,eAAe,WAAW,KAAK;AAC5C,MAAI,CAAC,MAAM;AACT,qBAAkB,IAAI,OAAO;AAC7B,UAAO,KACL,MAAM,uBAAuB;IAC3B,UAAU;IACV,SAAS,aAAa,OAAO;IAC7B;IACD,CAAC,CACH;AACD;;AAEF,iBAAe,IAAI,QAAQ,KAAK;AAChC,aAAW,IAAI,MAAM,CAAC,GAAI,WAAW,IAAI,KAAK,IAAI,EAAE,EAAG,OAAO,CAAC;;AAGjE,MAAK,MAAM,CAAC,MAAM,YAAY,WAC5B,KAAI,QAAQ,SAAS,GAAG;AACtB,OAAK,MAAM,UAAU,QAAS,mBAAkB,IAAI,OAAO;AAC3D,SAAO,KACL,MAAM,2BAA2B;GAC/B,UAAU;GACV,SAAS,yCAAyC;GAClD,eAAe,CAAC,KAAK;GACrB,OAAO,EAAE,YAAY,SAAS;GAC/B,CAAC,CACH;;AAIL,MAAK,MAAM,CAAC,QAAQ,eAAe,eAAe;EAChD,MAAM,OAAO,eAAe,IAAI,OAAO,IAAI;AAC3C,MAAI,WAAW,kBAAkB,SAAS;AACxC,qBAAkB,IAAI,OAAO;AAC7B,UAAO,KACL,MAAM,6BAA6B;IACjC,UAAU;IACV,SAAS,kBAAkB,KAAK;IAChC;IACA,eAAe,CAAC,KAAK;IACtB,CAAC,CACH;;AAEH,MAAI,WAAW,kBAAkB,WAAW;AAC1C,qBAAkB,IAAI,OAAO;AAC7B,UAAO,KACL,MAAM,kCAAkC;IACtC,UAAU;IACV,SAAS,sBAAsB,KAAK;IACpC;IACA,eAAe,CAAC,KAAK;IACtB,CAAC,CACH;;;CAIL,MAAM,kCAAkB,IAAI,KAAgC;AAC5D,MAAK,MAAM,CAAC,QAAQ,eAAe,eAAe;AAChD,MAAI,kBAAkB,IAAI,OAAO,CAAE;EACnC,MAAM,OAAO,eAAe,IAAI,OAAO;EACvC,MAAM,iCAAiB,IAAI,KAAuB;EAClD,MAAMC,aAAuB,EAAE;AAC/B,OAAK,MAAM,CAAC,OAAO,UAAU,WAAW,OAAO,SAAS,EAAE;GACxD,IAAI,YAAY,cAAc,MAAM,KAAK;AACzC,OAAI,CAAC,WAAW;AACd,gBAAY,SAAS,QAAQ;AAC7B,WAAO,KACL,MAAM,4BAA4B;KAChC,SAAS,aAAa,KAAK;KAC3B;KACA,eAAe,CAAC,MAAM,UAAU;KACjC,CAAC,CACH;;AAEH,kBAAe,IAAI,WAAW,CAC5B,GAAI,eAAe,IAAI,UAAU,IAAI,EAAE,EACvC,MAAM,KACP,CAAC;AACF,cAAW,KAAK,UAAU;;EAE5B,MAAM,YAAY,CAAC,GAAG,eAAe,CAAC,MACnC,GAAG,gBAAgB,WAAW,SAAS,EACzC;AACD,MAAI,WAAW;AACb,qBAAkB,IAAI,OAAO;AAC7B,UAAO,KACL,MAAM,gCAAgC;IACpC,UAAU;IACV,SAAS,aAAa,KAAK,iCAAiC,UAAU;IACtE;IACA,eAAe,CAAC,MAAM,UAAU,GAAG;IACnC,OAAO,EAAE,YAAY,UAAU,IAAI;IACpC,CAAC,CACH;AACD;;AAEF,kBAAgB,IAAI,QAAQ,WAAW;;CAGzC,MAAM,kBAAkB,yBAAyB,cAAc;CAC/D,MAAM,6BAAa,IAAI,KAAkC;AACzD,MAAK,MAAM,CAAC,QAAQ,eAAe,eAAe;AAChD,MAAI,kBAAkB,IAAI,OAAO,CAAE;EACnC,MAAM,OAAO,eAAe,IAAI,OAAO;EACvC,MAAM,aAAa,gBAAgB,IAAI,OAAO;EAC9C,MAAMC,SAAqC,WAAW,OAAO,KAC1D,OAAO,UAAU;GAChB,MAAM,YAAY,WAAW;GAC7B,MAAM,YAAY,gBACf,IAAI,OAAO,EACV,IAAI,MAAM,eAAe;AAC7B,OAAI,UACF,QAAO,KACL,MAAM,4BAA4B;IAChC,UAAU;IACV,SAAS,aAAa,KAAK,uBAAuB,MAAM;IACxD;IACA,eAAe,CAAC,MAAM,UAAU;IACjC,CAAC,CACH;AAEH,UAAO;IACL,MAAM;IACN,aAAa,mBAAmB,MAAM,KAAK;IAC3C,cAAc,MAAM;IACpB,UAAU,MAAM,eAAe;IAC/B,QAAQ,YACJ,EAAE,MAAM,WAAW,GACnB,YAAY;KACV,aAAa;KACb,aAAa,MAAM;KACnB,WAAW,MAAM;KACjB;KACA;KACA;KACA;KACA;KACA;KACA;KACA;KACD,CAAC;IACP;IAEJ;AACD,aAAW,IAAI,QAAQ;GACrB;GACA,gBAAgB;GAChB,YAAY,WAAW;GACvB;GACD,CAAC;;AAGJ,QAAO;EAAE;EAAY;EAAmB;EAAQ;;AAGlD,MAAM,eAAe,UAYG;AACtB,KAAI,uBAAuB,MAAM,UAAU,EAAE;AAC3C,QAAM,OAAO,KACX,MAAM,8BAA8B;GAClC,UAAU,MAAM;GAChB,SAAS,8CAA8C,MAAM;GAC7D,QAAQ,MAAM;GACf,CAAC,CACH;AACD,SAAO,EAAE,MAAM,WAAW;;CAG5B,MAAM,UAAU,MAAM,cAAc;CACpC,MAAM,aACJ,WACI,UAAW;EAAE,MAAM;EAAS,MAAM;EAAQ,GAAa;CAC7D,MAAM,SAAS,aAAa,MAAM,YAAY;AAC9C,KAAI,OAAQ,QAAO,UAAU;EAAE,MAAM;EAAU,QAAQ;EAAQ,CAAC;CAEhE,MAAM,iBAAiB,MAAM,MAAM,IAAI,MAAM,YAAY;AACzD,KAAI,eACF,QAAO,UAAU;EAAE,MAAM;EAAQ,MAAM,eAAe;EAAM,CAAC;AAE/D,KAAI,MAAM,aAAa,IAAI,MAAM,YAAY,CAC3C,QAAO,UAAU;EAAE,MAAM;EAAU,QAAQ;EAAU,CAAC;CAGxD,MAAM,gBAAgB,MAAM,eAAe,IAAI,MAAM,YAAY;AACjE,KAAI,iBAAiB,CAAC,MAAM,kBAAkB,IAAI,MAAM,YAAY,CAClE,QAAO,UAAU;EAAE,MAAM;EAAa,MAAM;EAAe,CAAC;AAG9D,KAAI,wBAAwB,MAAM,YAAY,EAAE;AAC9C,QAAM,OAAO,KACX,MAAM,8BAA8B;GAClC,UAAU,MAAM;GAChB,SAAS,sDAAsD,MAAM;GACrE,QAAQ,MAAM;GACf,CAAC,CACH;AACD,SAAO,UAAU,EAAE,MAAM,WAAW,CAAC;;AAGvC,KACE,MAAM,cAAc,IAAI,MAAM,YAAY,EAAE,kBAAkB,WAC9D,MAAM,kBAAkB,IAAI,MAAM,YAAY,EAC9C;AACA,QAAM,OAAO,KACX,MAAM,8BAA8B;GAClC,UAAU,MAAM;GAChB,SAAS,mDAAmD,MAAM;GAClE,QAAQ,MAAM;GACf,CAAC,CACH;AACD,SAAO,EAAE,MAAM,WAAW;;AAG5B,KAAI,CAAC,MAAM,YAAY,IAAI,MAAM,YAAY,CAC3C,OAAM,OAAO,KACX,MAAM,8BAA8B;EAClC,UAAU,MAAM;EAChB,SAAS,0DAA0D,MAAM;EACzE,QAAQ,MAAM;EACf,CAAC,CACH;AAEH,QAAO,EAAE,MAAM,WAAW;;AAG5B,MAAM,4BACJ,eACG;CACH,MAAM,yBAAS,IAAI,KAA0B;CAC7C,MAAM,+BAAe,IAAI,KAAgC;AACzD,MAAK,MAAM,CAAC,QAAQ,cAAc,WAChC,cAAa,IACX,QACA,UAAU,OACP,KAAK,UAAU,MAAM,eAAe,CACpC,QAAQ,gBAAgB,WAAW,IAAI,YAAY,CAAC,CACxD;AAEH,MAAK,MAAM,CAAC,QAAQ,cAAc,WAChC,MAAK,MAAM,SAAS,UAAU,QAAQ;AACpC,MAAI,CAAC,WAAW,IAAI,MAAM,eAAe,CAAE;AAC3C,MAAI,QAAQ,MAAM,gBAAgB,QAAQ,8BAAc,IAAI,KAAK,CAAC,EAAE;GAClE,MAAM,MAAM,OAAO,IAAI,OAAO,oBAAI,IAAI,KAAa;AACnD,OAAI,IAAI,MAAM,eAAe;AAC7B,UAAO,IAAI,QAAQ,IAAI;;;AAI7B,QAAO;;AAGT,MAAM,WACJ,SACA,QACA,cACA,SACY;AACZ,KAAI,YAAY,OAAQ,QAAO;AAC/B,KAAI,KAAK,IAAI,QAAQ,CAAE,QAAO;AAC9B,MAAK,IAAI,QAAQ;AACjB,SAAQ,aAAa,IAAI,QAAQ,IAAI,EAAE,EAAE,MAAM,SAC7C,QAAQ,MAAM,QAAQ,cAAc,KAAK,CAC1C"}

package/dist/compile/type-graph.d.mts

@@ -0,0 +1,20 @@
+import { CodegenIssue } from "../types.mjs";
+import { OpcuaDataTypeDefinitionResult as OpcuaDataTypeDefinitionResult$1 } from "../client/src/OpcuaSession.mjs";
+import "../client/src/index.mjs";
+import { EnumDefinition, NormalizedCodegenConfig, StructureDefinition } from "../internal/types.mjs";
+import { SurfaceNode } from "./names.mjs";
+
+//#region src/compile/type-graph.d.ts
+type OpcuaDataTypeDefinitionResult = OpcuaDataTypeDefinitionResult$1;
+type TypeGraph = {
+  readonly enums: ReadonlyMap<string, EnumDefinition>;
+  readonly structures: ReadonlyMap<string, StructureDefinition>;
+  readonly invalidEnums: ReadonlySet<string>;
+  readonly invalidStructures: ReadonlySet<string>;
+  readonly issues: readonly CodegenIssue[];
+};
+declare const compileReachableTypes: (config: NormalizedCodegenConfig, variableNodes: readonly SurfaceNode[], dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>) => TypeGraph;
+declare const dataTypeResultMap: (results: readonly OpcuaDataTypeDefinitionResult[]) => Map<string, OpcuaDataTypeDefinitionResult$1>;
+//#endregion
+export { TypeGraph, compileReachableTypes, dataTypeResultMap };
+//# sourceMappingURL=type-graph.d.mts.map

package/dist/compile/type-graph.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-graph.d.mts","names":[],"sources":["../../src/compile/type-graph.ts"],"sourcesContent":[],"mappings":";;;;;;;KAgBK,6BAAA,GAAgC;KAEzB,SAAA;kBACM,oBAAoB;EAHjC,SAAA,UAAA,EAIkB,WAJW,CAAA,MAAA,EAIS,mBAJN,CAAA;EAEzB,SAAA,YAAS,EAGI,WAHJ,CAAA,MAAA,CAAA;EACiB,SAAA,iBAAA,EAGR,WAHQ,CAAA,MAAA,CAAA;EAApB,SAAA,MAAA,EAAA,SAIU,YAJV,EAAA;CACyB;AAApB,cAMV,qBANU,EAAA,CAAA,MAAA,EAOb,uBAPa,EAAA,aAAA,EAAA,SAQG,WARH,EAAA,EAAA,eAAA,EASJ,WATI,CAAA,MAAA,EASgB,6BAThB,CAAA,EAAA,GAUpB,SAVoB;AACE,cAiCZ,iBAjCY,EAAA,CAAA,OAAA,EAAA,SAkCL,6BAlCK,EAAA,EAAA,GAkC0B,GAlC1B,CAAA,MAAA,EAkC0B,+BAlC1B,CAAA"}

package/dist/compile/type-graph.mjs

@@ -0,0 +1,78 @@
+import { issue } from "../diagnostics.mjs";
+import { requiresDataTypeDefinition } from "./builtin-types.mjs";
+import { compileEnums } from "./enums.mjs";
+import { typeFallbackSeverity } from "./policy.mjs";
+import { compileStructures } from "./structures.mjs";
+
+//#region src/compile/type-graph.ts
+const compileReachableTypes = (config, variableNodes, dataTypeResults) => {
+	const issues = [];
+	const rawDefinitions = reachableDefinitions(config, variableNodes, dataTypeResults, issues);
+	const enumGraph = compileEnums(rawDefinitions);
+	const structureGraph = compileStructures(config, rawDefinitions, enumGraph.enums, enumGraph.invalidEnums);
+	return {
+		enums: enumGraph.enums,
+		structures: structureGraph.structures,
+		invalidEnums: enumGraph.invalidEnums,
+		invalidStructures: structureGraph.invalidStructures,
+		issues: [
+			...issues,
+			...enumGraph.issues,
+			...structureGraph.issues
+		]
+	};
+};
+const dataTypeResultMap = (results) => new Map(results.map((result) => [result.dataTypeNodeId, result]));
+const reachableDefinitions = (config, variableNodes, dataTypeResults, issues) => {
+	const unsupportedSeverity = typeFallbackSeverity(config);
+	const queue = variableNodes.flatMap((item) => item.node.dataTypeNodeId !== void 0 ? [item.node.dataTypeNodeId] : []).filter(requiresDataTypeDefinition);
+	const seen = /* @__PURE__ */ new Set();
+	const definitions = /* @__PURE__ */ new Map();
+	while (queue.length > 0) {
+		const dataTypeNodeId = queue.shift();
+		if (seen.has(dataTypeNodeId)) continue;
+		seen.add(dataTypeNodeId);
+		const result = dataTypeResults.get(dataTypeNodeId);
+		if (!result) {
+			issues.push(issue("datatype.definitionMissing", {
+				severity: unsupportedSeverity,
+				message: `Missing DataTypeDefinition for ${dataTypeNodeId}`,
+				nodeId: dataTypeNodeId
+			}));
+			continue;
+		}
+		if (result._tag === "Missing") {
+			issues.push(issue("datatype.definitionMissing", {
+				severity: unsupportedSeverity,
+				message: `Missing DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,
+				nodeId: dataTypeNodeId
+			}));
+			continue;
+		}
+		if (result._tag === "Unsupported") {
+			issues.push(issue("datatype.definitionUnsupported", {
+				severity: unsupportedSeverity,
+				message: `Unsupported DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,
+				nodeId: dataTypeNodeId
+			}));
+			continue;
+		}
+		if (result._tag === "Failure") {
+			issues.push(issue("datatype.definitionFailure", {
+				severity: unsupportedSeverity,
+				message: `Failed to read DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,
+				nodeId: dataTypeNodeId
+			}));
+			continue;
+		}
+		definitions.set(dataTypeNodeId, result.definition);
+		if (result.definition._tag === "Structure") {
+			for (const field of result.definition.fields) if (requiresDataTypeDefinition(field.dataTypeNodeId)) queue.push(field.dataTypeNodeId);
+		}
+	}
+	return definitions;
+};
+
+//#endregion
+export { compileReachableTypes, dataTypeResultMap };
+//# sourceMappingURL=type-graph.mjs.map

package/dist/compile/type-graph.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-graph.mjs","names":["issues: CodegenIssue[]"],"sources":["../../src/compile/type-graph.ts"],"sourcesContent":["import type { OpcuaSession } from \"@effect-opcua/client\";\n\nimport { issue } from \"../diagnostics.js\";\nimport type { CodegenIssue } from \"../types.js\";\nimport type {\n  EnumDefinition,\n  NormalizedCodegenConfig,\n  StructureDefinition,\n} from \"../internal/types.js\";\nimport { requiresDataTypeDefinition } from \"./builtin-types.js\";\nimport { compileEnums } from \"./enums.js\";\nimport type { SurfaceNode } from \"./names.js\";\nimport { typeFallbackSeverity } from \"./policy.js\";\nimport { compileStructures } from \"./structures.js\";\n\ntype OpcuaDataTypeDefinition = OpcuaSession.OpcuaDataTypeDefinition;\ntype OpcuaDataTypeDefinitionResult = OpcuaSession.OpcuaDataTypeDefinitionResult;\n\nexport type TypeGraph = {\n  readonly enums: ReadonlyMap<string, EnumDefinition>;\n  readonly structures: ReadonlyMap<string, StructureDefinition>;\n  readonly invalidEnums: ReadonlySet<string>;\n  readonly invalidStructures: ReadonlySet<string>;\n  readonly issues: readonly CodegenIssue[];\n};\n\nexport const compileReachableTypes = (\n  config: NormalizedCodegenConfig,\n  variableNodes: readonly SurfaceNode[],\n  dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>,\n): TypeGraph => {\n  const issues: CodegenIssue[] = [];\n  const rawDefinitions = reachableDefinitions(\n    config,\n    variableNodes,\n    dataTypeResults,\n    issues,\n  );\n  const enumGraph = compileEnums(rawDefinitions);\n  const structureGraph = compileStructures(\n    config,\n    rawDefinitions,\n    enumGraph.enums,\n    enumGraph.invalidEnums,\n  );\n  return {\n    enums: enumGraph.enums,\n    structures: structureGraph.structures,\n    invalidEnums: enumGraph.invalidEnums,\n    invalidStructures: structureGraph.invalidStructures,\n    issues: [...issues, ...enumGraph.issues, ...structureGraph.issues],\n  };\n};\n\nexport const dataTypeResultMap = (\n  results: readonly OpcuaDataTypeDefinitionResult[],\n) => new Map(results.map((result) => [result.dataTypeNodeId, result]));\n\nconst reachableDefinitions = (\n  config: NormalizedCodegenConfig,\n  variableNodes: readonly SurfaceNode[],\n  dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>,\n  issues: CodegenIssue[],\n): ReadonlyMap<string, OpcuaDataTypeDefinition> => {\n  const unsupportedSeverity = typeFallbackSeverity(config);\n  const queue = variableNodes\n    .flatMap((item) =>\n      item.node.dataTypeNodeId !== undefined ? [item.node.dataTypeNodeId] : [],\n    )\n    .filter(requiresDataTypeDefinition);\n  const seen = new Set<string>();\n  const definitions = new Map<string, OpcuaDataTypeDefinition>();\n\n  while (queue.length > 0) {\n    const dataTypeNodeId = queue.shift()!;\n    if (seen.has(dataTypeNodeId)) continue;\n    seen.add(dataTypeNodeId);\n    const result = dataTypeResults.get(dataTypeNodeId);\n    if (!result) {\n      issues.push(\n        issue(\"datatype.definitionMissing\", {\n          severity: unsupportedSeverity,\n          message: `Missing DataTypeDefinition for ${dataTypeNodeId}`,\n          nodeId: dataTypeNodeId,\n        }),\n      );\n      continue;\n    }\n    if (result._tag === \"Missing\") {\n      issues.push(\n        issue(\"datatype.definitionMissing\", {\n          severity: unsupportedSeverity,\n          message: `Missing DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,\n          nodeId: dataTypeNodeId,\n        }),\n      );\n      continue;\n    }\n    if (result._tag === \"Unsupported\") {\n      issues.push(\n        issue(\"datatype.definitionUnsupported\", {\n          severity: unsupportedSeverity,\n          message: `Unsupported DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,\n          nodeId: dataTypeNodeId,\n        }),\n      );\n      continue;\n    }\n    if (result._tag === \"Failure\") {\n      issues.push(\n        issue(\"datatype.definitionFailure\", {\n          severity: unsupportedSeverity,\n          message: `Failed to read DataTypeDefinition for ${dataTypeNodeId}: ${result.reason}`,\n          nodeId: dataTypeNodeId,\n        }),\n      );\n      continue;\n    }\n    definitions.set(dataTypeNodeId, result.definition);\n    if (result.definition._tag === \"Structure\") {\n      for (const field of result.definition.fields) {\n        if (requiresDataTypeDefinition(field.dataTypeNodeId)) {\n          queue.push(field.dataTypeNodeId);\n        }\n      }\n    }\n  }\n\n  return definitions;\n};\n"],"mappings":";;;;;;;AA0BA,MAAa,yBACX,QACA,eACA,oBACc;CACd,MAAMA,SAAyB,EAAE;CACjC,MAAM,iBAAiB,qBACrB,QACA,eACA,iBACA,OACD;CACD,MAAM,YAAY,aAAa,eAAe;CAC9C,MAAM,iBAAiB,kBACrB,QACA,gBACA,UAAU,OACV,UAAU,aACX;AACD,QAAO;EACL,OAAO,UAAU;EACjB,YAAY,eAAe;EAC3B,cAAc,UAAU;EACxB,mBAAmB,eAAe;EAClC,QAAQ;GAAC,GAAG;GAAQ,GAAG,UAAU;GAAQ,GAAG,eAAe;GAAO;EACnE;;AAGH,MAAa,qBACX,YACG,IAAI,IAAI,QAAQ,KAAK,WAAW,CAAC,OAAO,gBAAgB,OAAO,CAAC,CAAC;AAEtE,MAAM,wBACJ,QACA,eACA,iBACA,WACiD;CACjD,MAAM,sBAAsB,qBAAqB,OAAO;CACxD,MAAM,QAAQ,cACX,SAAS,SACR,KAAK,KAAK,mBAAmB,SAAY,CAAC,KAAK,KAAK,eAAe,GAAG,EAAE,CACzE,CACA,OAAO,2BAA2B;CACrC,MAAM,uBAAO,IAAI,KAAa;CAC9B,MAAM,8BAAc,IAAI,KAAsC;AAE9D,QAAO,MAAM,SAAS,GAAG;EACvB,MAAM,iBAAiB,MAAM,OAAO;AACpC,MAAI,KAAK,IAAI,eAAe,CAAE;AAC9B,OAAK,IAAI,eAAe;EACxB,MAAM,SAAS,gBAAgB,IAAI,eAAe;AAClD,MAAI,CAAC,QAAQ;AACX,UAAO,KACL,MAAM,8BAA8B;IAClC,UAAU;IACV,SAAS,kCAAkC;IAC3C,QAAQ;IACT,CAAC,CACH;AACD;;AAEF,MAAI,OAAO,SAAS,WAAW;AAC7B,UAAO,KACL,MAAM,8BAA8B;IAClC,UAAU;IACV,SAAS,kCAAkC,eAAe,IAAI,OAAO;IACrE,QAAQ;IACT,CAAC,CACH;AACD;;AAEF,MAAI,OAAO,SAAS,eAAe;AACjC,UAAO,KACL,MAAM,kCAAkC;IACtC,UAAU;IACV,SAAS,sCAAsC,eAAe,IAAI,OAAO;IACzE,QAAQ;IACT,CAAC,CACH;AACD;;AAEF,MAAI,OAAO,SAAS,WAAW;AAC7B,UAAO,KACL,MAAM,8BAA8B;IAClC,UAAU;IACV,SAAS,yCAAyC,eAAe,IAAI,OAAO;IAC5E,QAAQ;IACT,CAAC,CACH;AACD;;AAEF,cAAY,IAAI,gBAAgB,OAAO,WAAW;AAClD,MAAI,OAAO,WAAW,SAAS,aAC7B;QAAK,MAAM,SAAS,OAAO,WAAW,OACpC,KAAI,2BAA2B,MAAM,eAAe,CAClD,OAAM,KAAK,MAAM,eAAe;;;AAMxC,QAAO"}

package/dist/compile/variables.d.mts

@@ -0,0 +1,16 @@
+import { CodegenIssue } from "../types.mjs";
+import { OpcuaDataTypeDefinitionResult as OpcuaDataTypeDefinitionResult$1 } from "../client/src/OpcuaSession.mjs";
+import "../client/src/index.mjs";
+import { NormalizedCodegenConfig, VariableDefinition } from "../internal/types.mjs";
+import { SurfaceNode } from "./names.mjs";
+import { TypeGraph } from "./type-graph.mjs";
+
+//#region src/compile/variables.d.ts
+type OpcuaDataTypeDefinitionResult = OpcuaDataTypeDefinitionResult$1;
+declare const compileVariables: (config: NormalizedCodegenConfig, variableNodes: readonly SurfaceNode[], typeGraph: TypeGraph, dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>) => {
+  variables: VariableDefinition[];
+  issues: CodegenIssue[];
+};
+//#endregion
+export { compileVariables };
+//# sourceMappingURL=variables.d.mts.map

package/dist/compile/variables.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.d.mts","names":[],"sources":["../../src/compile/variables.ts"],"sourcesContent":[],"mappings":";;;;;;;;KAoBK,6BAAA,GAAgC;cAExB,2BACH,iDACgB,0BACb,4BACM,oBAAoB;;EANlC,MAAA,cAAA,EAAA;AAEL,CAAA"}

package/dist/compile/variables.mjs

@@ -0,0 +1,110 @@
+import { issue } from "../diagnostics.mjs";
+import { displayPath } from "./names.mjs";
+import { isDynamicScalarDataType, isUnsupportedArrayRank, scalarSchema } from "./builtin-types.mjs";
+import { typeFallbackSeverity } from "./policy.mjs";
+
+//#region src/compile/variables.ts
+const compileVariables = (config, variableNodes, typeGraph, dataTypeResults) => {
+	const issues = [];
+	const variables = [];
+	for (const item of variableNodes) {
+		const access = variableAccess(item.node);
+		if (access._tag === "Skip") {
+			issues.push(issue(access.issueCode, {
+				message: `Skipped ${access.label} variable ${displayPath(item.path)}`,
+				path: item.path,
+				generatedPath: item.generatedPath,
+				nodeId: item.node.nodeId
+			}));
+			continue;
+		}
+		const codec = variableCodec(config, item.node, typeGraph, dataTypeResults);
+		if (codec.issue) issues.push({
+			...codec.issue,
+			path: item.path,
+			generatedPath: item.generatedPath,
+			nodeId: item.node.nodeId
+		});
+		variables.push({
+			path: item.path,
+			generatedPath: item.generatedPath,
+			nodeId: item.node.nodeId,
+			codec: codec.codec,
+			access: access.value
+		});
+	}
+	return {
+		variables,
+		issues
+	};
+};
+const variableCodec = (config, node, typeGraph, dataTypeResults) => {
+	const dataTypeNodeId = node.dataTypeNodeId;
+	const isArray = node.valueRank === 1;
+	const unsupportedSeverity = typeFallbackSeverity(config);
+	if (isUnsupportedArrayRank(node.valueRank)) return {
+		codec: { _tag: "Dynamic" },
+		issue: issue("codec.unsupportedArrayRank", {
+			severity: unsupportedSeverity,
+			message: `Variable has unsupported array rank ${node.valueRank}`
+		})
+	};
+	const structure = dataTypeNodeId ? typeGraph.structures.get(dataTypeNodeId) : void 0;
+	if (structure) return { codec: isArray ? {
+		_tag: "StructureArray",
+		name: structure.name
+	} : {
+		_tag: "Structure",
+		name: structure.name
+	} };
+	const enumDefinition = dataTypeNodeId ? typeGraph.enums.get(dataTypeNodeId) : void 0;
+	if (enumDefinition) return { codec: isArray ? {
+		_tag: "EnumArray",
+		name: enumDefinition.name
+	} : {
+		_tag: "Enum",
+		name: enumDefinition.name
+	} };
+	if (dataTypeNodeId && typeGraph.invalidEnums.has(dataTypeNodeId)) return { codec: isArray ? {
+		_tag: "SchemaArray",
+		element: "Number"
+	} : {
+		_tag: "Schema",
+		schema: "Number"
+	} };
+	const scalar = scalarSchema(dataTypeNodeId);
+	if (scalar) return { codec: isArray ? {
+		_tag: "SchemaArray",
+		element: scalar
+	} : {
+		_tag: "Schema",
+		schema: scalar
+	} };
+	if (isDynamicScalarDataType(dataTypeNodeId)) return { codec: { _tag: "Dynamic" } };
+	const result = dataTypeNodeId ? dataTypeResults.get(dataTypeNodeId) : void 0;
+	const directDefinition = result?._tag === "Success" ? result.definition : void 0;
+	const isUnion = directDefinition?._tag === "Structure" && directDefinition.structureType === "Union";
+	return {
+		codec: { _tag: "Dynamic" },
+		issue: issue(isUnion ? "datatype.unionUnsupported" : "codec.dynamicFallback", {
+			severity: unsupportedSeverity,
+			message: isUnion ? `Variable uses unsupported union DataType ${dataTypeNodeId}` : `Variable uses dynamic codec fallback for DataType ${dataTypeNodeId ?? "unknown"}`
+		})
+	};
+};
+const variableAccess = (node) => {
+	const effective = node.userAccessLevel ?? node.accessLevel;
+	if (effective && !effective.readable && !effective.writable) return {
+		_tag: "Skip",
+		label: "not-accessible",
+		issueCode: "variable.notAccessibleSkipped"
+	};
+	return {
+		_tag: "Emit",
+		value: effective?.writable === true ? effective.readable ? "readWrite" : "write" : "read"
+	};
+};
+
+//#endregion
+export { compileVariables };
+//# sourceMappingURL=variables.mjs.map

package/dist/compile/variables.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.mjs","names":["issues: CodegenIssue[]","variables: VariableDefinition[]"],"sources":["../../src/compile/variables.ts"],"sourcesContent":["import type { OpcuaSession } from \"@effect-opcua/client\";\n\nimport { issue } from \"../diagnostics.js\";\nimport type { CodegenIssue } from \"../types.js\";\nimport type {\n  DiscoveredNode,\n  NormalizedCodegenConfig,\n  VariableCodecExpression,\n  VariableDefinition,\n} from \"../internal/types.js\";\nimport {\n  isDynamicScalarDataType,\n  isUnsupportedArrayRank,\n  scalarSchema,\n} from \"./builtin-types.js\";\nimport { displayPath } from \"./names.js\";\nimport type { SurfaceNode } from \"./names.js\";\nimport { typeFallbackSeverity } from \"./policy.js\";\nimport type { TypeGraph } from \"./type-graph.js\";\n\ntype OpcuaDataTypeDefinitionResult = OpcuaSession.OpcuaDataTypeDefinitionResult;\n\nexport const compileVariables = (\n  config: NormalizedCodegenConfig,\n  variableNodes: readonly SurfaceNode[],\n  typeGraph: TypeGraph,\n  dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>,\n) => {\n  const issues: CodegenIssue[] = [];\n  const variables: VariableDefinition[] = [];\n  for (const item of variableNodes) {\n    const access = variableAccess(item.node);\n    if (access._tag === \"Skip\") {\n      issues.push(\n        issue(access.issueCode, {\n          message: `Skipped ${access.label} variable ${displayPath(item.path)}`,\n          path: item.path,\n          generatedPath: item.generatedPath,\n          nodeId: item.node.nodeId,\n        }),\n      );\n      continue;\n    }\n\n    const codec = variableCodec(config, item.node, typeGraph, dataTypeResults);\n    if (codec.issue) {\n      issues.push({\n        ...codec.issue,\n        path: item.path,\n        generatedPath: item.generatedPath,\n        nodeId: item.node.nodeId,\n      });\n    }\n    variables.push({\n      path: item.path,\n      generatedPath: item.generatedPath,\n      nodeId: item.node.nodeId,\n      codec: codec.codec,\n      access: access.value,\n    });\n  }\n  return { variables, issues };\n};\n\nconst variableCodec = (\n  config: NormalizedCodegenConfig,\n  node: DiscoveredNode,\n  typeGraph: TypeGraph,\n  dataTypeResults: ReadonlyMap<string, OpcuaDataTypeDefinitionResult>,\n): {\n  readonly codec: VariableCodecExpression;\n  readonly issue?: CodegenIssue;\n} => {\n  const dataTypeNodeId = node.dataTypeNodeId;\n  const isArray = node.valueRank === 1;\n  const unsupportedSeverity = typeFallbackSeverity(config);\n  if (isUnsupportedArrayRank(node.valueRank)) {\n    return {\n      codec: { _tag: \"Dynamic\" },\n      issue: issue(\"codec.unsupportedArrayRank\", {\n        severity: unsupportedSeverity,\n        message: `Variable has unsupported array rank ${node.valueRank}`,\n      }),\n    };\n  }\n\n  const structure = dataTypeNodeId\n    ? typeGraph.structures.get(dataTypeNodeId)\n    : undefined;\n  if (structure) {\n    return {\n      codec: isArray\n        ? { _tag: \"StructureArray\", name: structure.name }\n        : { _tag: \"Structure\", name: structure.name },\n    };\n  }\n\n  const enumDefinition = dataTypeNodeId\n    ? typeGraph.enums.get(dataTypeNodeId)\n    : undefined;\n  if (enumDefinition) {\n    return {\n      codec: isArray\n        ? { _tag: \"EnumArray\", name: enumDefinition.name }\n        : { _tag: \"Enum\", name: enumDefinition.name },\n    };\n  }\n\n  if (dataTypeNodeId && typeGraph.invalidEnums.has(dataTypeNodeId)) {\n    return {\n      codec: isArray\n        ? { _tag: \"SchemaArray\", element: \"Number\" }\n        : { _tag: \"Schema\", schema: \"Number\" },\n    };\n  }\n\n  const scalar = scalarSchema(dataTypeNodeId);\n  if (scalar) {\n    return {\n      codec: isArray\n        ? { _tag: \"SchemaArray\", element: scalar }\n        : { _tag: \"Schema\", schema: scalar },\n    };\n  }\n\n  if (isDynamicScalarDataType(dataTypeNodeId)) {\n    return { codec: { _tag: \"Dynamic\" } };\n  }\n\n  const result = dataTypeNodeId\n    ? dataTypeResults.get(dataTypeNodeId)\n    : undefined;\n  const directDefinition =\n    result?._tag === \"Success\" ? result.definition : undefined;\n  const isUnion =\n    directDefinition?._tag === \"Structure\" &&\n    directDefinition.structureType === \"Union\";\n  return {\n    codec: { _tag: \"Dynamic\" },\n    issue: issue(\n      isUnion ? \"datatype.unionUnsupported\" : \"codec.dynamicFallback\",\n      {\n        severity: unsupportedSeverity,\n        message: isUnion\n          ? `Variable uses unsupported union DataType ${dataTypeNodeId}`\n          : `Variable uses dynamic codec fallback for DataType ${dataTypeNodeId ?? \"unknown\"}`,\n      },\n    ),\n  };\n};\n\nconst variableAccess = (\n  node: DiscoveredNode,\n):\n  | {\n      readonly _tag: \"Emit\";\n      readonly value: VariableDefinition[\"access\"];\n    }\n  | {\n      readonly _tag: \"Skip\";\n      readonly label: \"not-accessible\";\n      readonly issueCode: \"variable.notAccessibleSkipped\";\n    } => {\n  const effective = node.userAccessLevel ?? node.accessLevel;\n  if (effective && !effective.readable && !effective.writable) {\n    return {\n      _tag: \"Skip\",\n      label: \"not-accessible\",\n      issueCode: \"variable.notAccessibleSkipped\",\n    };\n  }\n  return {\n    _tag: \"Emit\",\n    value:\n      effective?.writable === true\n        ? effective.readable\n          ? \"readWrite\"\n          : \"write\"\n        : \"read\",\n  };\n};\n"],"mappings":";;;;;;AAsBA,MAAa,oBACX,QACA,eACA,WACA,oBACG;CACH,MAAMA,SAAyB,EAAE;CACjC,MAAMC,YAAkC,EAAE;AAC1C,MAAK,MAAM,QAAQ,eAAe;EAChC,MAAM,SAAS,eAAe,KAAK,KAAK;AACxC,MAAI,OAAO,SAAS,QAAQ;AAC1B,UAAO,KACL,MAAM,OAAO,WAAW;IACtB,SAAS,WAAW,OAAO,MAAM,YAAY,YAAY,KAAK,KAAK;IACnE,MAAM,KAAK;IACX,eAAe,KAAK;IACpB,QAAQ,KAAK,KAAK;IACnB,CAAC,CACH;AACD;;EAGF,MAAM,QAAQ,cAAc,QAAQ,KAAK,MAAM,WAAW,gBAAgB;AAC1E,MAAI,MAAM,MACR,QAAO,KAAK;GACV,GAAG,MAAM;GACT,MAAM,KAAK;GACX,eAAe,KAAK;GACpB,QAAQ,KAAK,KAAK;GACnB,CAAC;AAEJ,YAAU,KAAK;GACb,MAAM,KAAK;GACX,eAAe,KAAK;GACpB,QAAQ,KAAK,KAAK;GAClB,OAAO,MAAM;GACb,QAAQ,OAAO;GAChB,CAAC;;AAEJ,QAAO;EAAE;EAAW;EAAQ;;AAG9B,MAAM,iBACJ,QACA,MACA,WACA,oBAIG;CACH,MAAM,iBAAiB,KAAK;CAC5B,MAAM,UAAU,KAAK,cAAc;CACnC,MAAM,sBAAsB,qBAAqB,OAAO;AACxD,KAAI,uBAAuB,KAAK,UAAU,CACxC,QAAO;EACL,OAAO,EAAE,MAAM,WAAW;EAC1B,OAAO,MAAM,8BAA8B;GACzC,UAAU;GACV,SAAS,uCAAuC,KAAK;GACtD,CAAC;EACH;CAGH,MAAM,YAAY,iBACd,UAAU,WAAW,IAAI,eAAe,GACxC;AACJ,KAAI,UACF,QAAO,EACL,OAAO,UACH;EAAE,MAAM;EAAkB,MAAM,UAAU;EAAM,GAChD;EAAE,MAAM;EAAa,MAAM,UAAU;EAAM,EAChD;CAGH,MAAM,iBAAiB,iBACnB,UAAU,MAAM,IAAI,eAAe,GACnC;AACJ,KAAI,eACF,QAAO,EACL,OAAO,UACH;EAAE,MAAM;EAAa,MAAM,eAAe;EAAM,GAChD;EAAE,MAAM;EAAQ,MAAM,eAAe;EAAM,EAChD;AAGH,KAAI,kBAAkB,UAAU,aAAa,IAAI,eAAe,CAC9D,QAAO,EACL,OAAO,UACH;EAAE,MAAM;EAAe,SAAS;EAAU,GAC1C;EAAE,MAAM;EAAU,QAAQ;EAAU,EACzC;CAGH,MAAM,SAAS,aAAa,eAAe;AAC3C,KAAI,OACF,QAAO,EACL,OAAO,UACH;EAAE,MAAM;EAAe,SAAS;EAAQ,GACxC;EAAE,MAAM;EAAU,QAAQ;EAAQ,EACvC;AAGH,KAAI,wBAAwB,eAAe,CACzC,QAAO,EAAE,OAAO,EAAE,MAAM,WAAW,EAAE;CAGvC,MAAM,SAAS,iBACX,gBAAgB,IAAI,eAAe,GACnC;CACJ,MAAM,mBACJ,QAAQ,SAAS,YAAY,OAAO,aAAa;CACnD,MAAM,UACJ,kBAAkB,SAAS,eAC3B,iBAAiB,kBAAkB;AACrC,QAAO;EACL,OAAO,EAAE,MAAM,WAAW;EAC1B,OAAO,MACL,UAAU,8BAA8B,yBACxC;GACE,UAAU;GACV,SAAS,UACL,4CAA4C,mBAC5C,qDAAqD,kBAAkB;GAC5E,CACF;EACF;;AAGH,MAAM,kBACJ,SAUO;CACP,MAAM,YAAY,KAAK,mBAAmB,KAAK;AAC/C,KAAI,aAAa,CAAC,UAAU,YAAY,CAAC,UAAU,SACjD,QAAO;EACL,MAAM;EACN,OAAO;EACP,WAAW;EACZ;AAEH,QAAO;EACL,MAAM;EACN,OACE,WAAW,aAAa,OACpB,UAAU,WACR,cACA,UACF;EACP"}

package/dist/compile.d.mts

@@ -0,0 +1,9 @@
+import { CodegenError } from "./errors.mjs";
+import { CodegenModel, DiscoveryModel, NormalizedCodegenConfig } from "./internal/types.mjs";
+import { Effect } from "effect";
+
+//#region src/compile.d.ts
+declare const compile: (config: NormalizedCodegenConfig, discovery: DiscoveryModel) => Effect.Effect<CodegenModel, CodegenError>;
+//#endregion
+export { compile };
+//# sourceMappingURL=compile.d.mts.map

package/dist/compile.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.mts","names":[],"sources":["../src/compile.ts"],"sourcesContent":[],"mappings":";;;;;cAkBa,kBACH,oCACG,mBACV,MAAA,CAAO,OAAO,cAAY,YAAA"}

package/dist/compile.mjs

@@ -0,0 +1,29 @@
+import { codegenError } from "./errors.mjs";
+import { sortIssues } from "./diagnostics.mjs";
+import { pathIssues, surfaceNodes } from "./compile/names.mjs";
+import { assembleModel, modelIssues } from "./compile/model.mjs";
+import { compileReachableTypes, dataTypeResultMap } from "./compile/type-graph.mjs";
+import { compileVariables } from "./compile/variables.mjs";
+import { Effect } from "effect";
+
+//#region src/compile.ts
+const compile = (config, discovery) => Effect.gen(function* () {
+	const issues = [...discovery.issues];
+	const nodes = surfaceNodes(discovery);
+	issues.push(...pathIssues(nodes));
+	yield* failOnFatalIssues(issues);
+	const variableNodes = nodes.filter((item) => item.node.nodeClass === "Variable");
+	const dataTypeResults = dataTypeResultMap(discovery.dataTypeDefinitions);
+	const typeGraph = compileReachableTypes(config, variableNodes, dataTypeResults);
+	issues.push(...typeGraph.issues);
+	const variableResult = compileVariables(config, variableNodes, typeGraph, dataTypeResults);
+	issues.push(...variableResult.issues);
+	issues.push(...modelIssues(variableResult.variables, typeGraph));
+	yield* failOnFatalIssues(issues);
+	return assembleModel(variableResult.variables, typeGraph, sortIssues(issues));
+});
+const failOnFatalIssues = (issues) => issues.some((item) => item.severity === "error") ? Effect.fail(codegenError({ _tag: "Compile" }, sortIssues(issues))) : Effect.void;
+
+//#endregion
+export { compile };
+//# sourceMappingURL=compile.mjs.map

package/dist/compile.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.mjs","names":["issues: CodegenIssue[]"],"sources":["../src/compile.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { sortIssues } from \"./diagnostics.js\";\nimport { codegenError } from \"./errors.js\";\nimport { assembleModel, modelIssues } from \"./compile/model.js\";\nimport { pathIssues, surfaceNodes } from \"./compile/names.js\";\nimport {\n  compileReachableTypes,\n  dataTypeResultMap,\n} from \"./compile/type-graph.js\";\nimport { compileVariables } from \"./compile/variables.js\";\nimport type { CodegenIssue } from \"./types.js\";\nimport type {\n  CodegenModel,\n  DiscoveryModel,\n  NormalizedCodegenConfig,\n} from \"./internal/types.js\";\n\nexport const compile = (\n  config: NormalizedCodegenConfig,\n  discovery: DiscoveryModel,\n): Effect.Effect<CodegenModel, import(\"./errors.js\").CodegenError> =>\n  Effect.gen(function* () {\n    const issues: CodegenIssue[] = [...discovery.issues];\n    const nodes = surfaceNodes(discovery);\n    issues.push(...pathIssues(nodes));\n    yield* failOnFatalIssues(issues);\n\n    const variableNodes = nodes.filter(\n      (item) => item.node.nodeClass === \"Variable\",\n    );\n    const dataTypeResults = dataTypeResultMap(discovery.dataTypeDefinitions);\n    const typeGraph = compileReachableTypes(\n      config,\n      variableNodes,\n      dataTypeResults,\n    );\n    issues.push(...typeGraph.issues);\n\n    const variableResult = compileVariables(\n      config,\n      variableNodes,\n      typeGraph,\n      dataTypeResults,\n    );\n    issues.push(...variableResult.issues);\n    issues.push(...modelIssues(variableResult.variables, typeGraph));\n    yield* failOnFatalIssues(issues);\n\n    return assembleModel(\n      variableResult.variables,\n      typeGraph,\n      sortIssues(issues),\n    );\n  });\n\nconst failOnFatalIssues = (issues: readonly CodegenIssue[]) =>\n  issues.some((item) => item.severity === \"error\")\n    ? Effect.fail(codegenError({ _tag: \"Compile\" }, sortIssues(issues)))\n    : Effect.void;\n"],"mappings":";;;;;;;;;AAkBA,MAAa,WACX,QACA,cAEA,OAAO,IAAI,aAAa;CACtB,MAAMA,SAAyB,CAAC,GAAG,UAAU,OAAO;CACpD,MAAM,QAAQ,aAAa,UAAU;AACrC,QAAO,KAAK,GAAG,WAAW,MAAM,CAAC;AACjC,QAAO,kBAAkB,OAAO;CAEhC,MAAM,gBAAgB,MAAM,QACzB,SAAS,KAAK,KAAK,cAAc,WACnC;CACD,MAAM,kBAAkB,kBAAkB,UAAU,oBAAoB;CACxE,MAAM,YAAY,sBAChB,QACA,eACA,gBACD;AACD,QAAO,KAAK,GAAG,UAAU,OAAO;CAEhC,MAAM,iBAAiB,iBACrB,QACA,eACA,WACA,gBACD;AACD,QAAO,KAAK,GAAG,eAAe,OAAO;AACrC,QAAO,KAAK,GAAG,YAAY,eAAe,WAAW,UAAU,CAAC;AAChE,QAAO,kBAAkB,OAAO;AAEhC,QAAO,cACL,eAAe,WACf,WACA,WAAW,OAAO,CACnB;EACD;AAEJ,MAAM,qBAAqB,WACzB,OAAO,MAAM,SAAS,KAAK,aAAa,QAAQ,GAC5C,OAAO,KAAK,aAAa,EAAE,MAAM,WAAW,EAAE,WAAW,OAAO,CAAC,CAAC,GAClE,OAAO"}

package/dist/config.d.mts

@@ -0,0 +1,12 @@
+import { CodegenConfig } from "./types.mjs";
+import { CodegenError } from "./errors.mjs";
+import { NormalizedCodegenConfig } from "./internal/types.mjs";
+import { Effect } from "effect";
+
+//#region src/config.d.ts
+declare const defineConfig: (config: CodegenConfig) => CodegenConfig;
+declare const loadConfig: (path?: string) => Effect.Effect<NormalizedCodegenConfig, CodegenError>;
+declare const normalizeConfig: (config: unknown) => Effect.Effect<NormalizedCodegenConfig, CodegenError>;
+//#endregion
+export { defineConfig, loadConfig, normalizeConfig };
+//# sourceMappingURL=config.d.mts.map

package/dist/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;cAiBa,uBAAwB,kBAAgB;cAExC,+BAEV,MAAA,CAAO,OAAO,yBAAuB,YAAA;cAkC3B,sCAEV,MAAA,CAAO,OAAO,yBAAuB,YAAA"}