@sakibcoolz/core 0.1.2 → 0.2.0

package/dist/validation.js

@@ -1,10 +1,14 @@
-import { componentKinds, portsCompatible, } from './scene.js';
+import { checkPorts, portCapacity, portKinds, isRelationship, relationshipKinds, SCENE_DOCUMENT_TYPE, isBuiltInKind, isNamespacedType, dataTypes, modbusAreas, protocols, viewKinds, ownValue, } from './scene.js';
 import { quaternionFromEuler } from './quaternion.js';
 import { isKnownUnit } from './units.js';
+import { valueFitsDataType } from './telemetry.js';
 import { tupleToQuaternion, tupleToVector } from './vectors.js';
 export const defaultSceneLimits = {
     maxComponents: 10_000,
     maxConnections: 20_000,
+    maxAssociations: 20_000,
+    maxDataSources: 1_000,
+    maxVariables: 20_000,
     maxBindings: 20_000,
     maxIdLength: 128,
     maxProperties: 64,
@@ -15,16 +19,72 @@ const sceneKeys = {
     1: ['version', 'components', 'connections'],
     2: ['schemaVersion', 'units', 'components', 'connections', 'tagBindings'],
     3: ['schemaVersion', 'units', 'components', 'connections', 'tagBindings', 'underlay'],
+    4: ['schemaVersion', 'documentType', 'units', 'project', 'components', 'connections', 'associations', 'dataSources', 'runtimeVariables', 'tagBindings', 'underlay', 'views', 'extensions'],
 };
+const projectKeys = ['id', 'name', 'revision', 'description'];
+const viewLayoutKeys = ['symbols', 'routes'];
+const symbolKeys = ['x', 'y', 'rotation', 'hidden'];
+/** Drawing coordinates (ADR-0026) stay within ±1,000,000 units; a route has 2 to 1,000 points. */
+const MAX_VIEW_COORDINATE = 1_000_000;
+const MAX_ROUTE_POINTS = 1_000;
 const underlayKeys = ['svg', 'position', 'width', 'rotation', 'opacity'];
 const componentKeys = {
     1: ['id', 'kind', 'position', 'rotation', 'properties'],
     2: ['id', 'type', 'position', 'rotation', 'scale', 'properties'],
     3: ['id', 'type', 'parentId', 'position', 'rotation', 'scale', 'properties'],
+    4: ['id', 'name', 'type', 'typeVersion', 'manufacturer', 'model', 'parentId', 'position', 'rotation', 'scale', 'properties', 'labels', 'extensions'],
 };
+/** Deepest nesting accepted inside one extension value, and most values in all extensions of a scene (ADR-0021). */
+const MAX_EXTENSION_DEPTH = 16;
+const MAX_EXTENSION_VALUES = 10_000;
+/** Most JSON values in one variable address. Each address has its own budget, so `maxVariables` bounds the total. */
+const MAX_ADDRESS_VALUES = 64;
+/** Reverse-DNS namespace for extension keys, e.g. `com.example.app`. */
+const NAMESPACE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i;
+/** Keys that would reach an object's prototype if copied naively. */
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const SECRET_WORDS = ['password', 'passwd', 'passphrase', 'secret', 'credential', 'apikey', 'accesskey', 'privatekey'];
+/** True for a key that names a credential: scene documents carry references to secrets, never secrets (ADR-0021). */
+export function isSecretKey(key) {
+    const k = key.toLowerCase().replace(/[-_.\s]/g, '');
+    // "auth" only as a whole name or "authorization…": as a substring it would catch "author" (T-096).
+    return k === 'pwd' || k === 'auth' || k.startsWith('authorization') || k.endsWith('token') || SECRET_WORDS.some((w) => k.includes(w));
+}
 /** Accepted deviation of a rotation quaternion's length from 1; larger values are rejected, never renormalised. */
 const UNIT_TOLERANCE = 1e-6;
-const connectionKeys = ['id', 'from', 'to'];
+const connectionKeys = {
+    1: ['id', 'from', 'to'],
+    2: ['id', 'from', 'to'],
+    3: ['id', 'from', 'to'],
+    4: ['id', 'domain', 'relationship', 'from', 'to', 'properties'],
+};
+const associationKeys = ['id', 'relationship', 'from', 'to', 'properties'];
+const dataSourceKeys = ['id', 'name', 'protocol', 'deviceId', 'endpointRef', 'properties'];
+const variableKeys = ['id', 'name', 'componentId', 'dataType', 'unit', 'access', 'source', 'scaling', 'command'];
+const commandKeys = ['min', 'max', 'step', 'confirm'];
+const variableSourceKeys = ['dataSourceId', 'variable', 'address'];
+const scalingKeys = ['kind', 'rawMin', 'rawMax', 'min', 'max'];
+const opcUaKeys = ['nodeId', 'namespaceUri'];
+const modbusKeys = ['area', 'address', 'unitId', 'byteOrder', 'wordOrder', 'bit'];
+/** Registers a Modbus value spans (ADR-0024); `string` is not addressable in Modbus. */
+const MODBUS_REGISTERS = { bool: 1, int16: 1, uint16: 1, int32: 2, uint32: 2, float32: 2, float64: 4 };
+/** `scheme://user:password@host`: an endpoint carrying credentials. */
+const URL_WITH_USER_INFO = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*@/i;
+/** A URL query or matrix parameter named like a credential, e.g. `?password=…` or `;token=…` (T-096). */
+const SECRET_PARAMETER = /[?&;]([^=&;#]*)=/g;
+/** Whether an endpoint reference carries a credential: user info (also after leading spaces) or a secret-named parameter. */
+function endpointCarriesSecret(ref) {
+    return URL_WITH_USER_INFO.test(ref.trim()) || [...ref.matchAll(SECRET_PARAMETER)].some((m) => isSecretKey(decodeSafe(m[1])));
+}
+const decodeSafe = (text) => {
+    try {
+        return decodeURIComponent(text);
+    }
+    catch {
+        return text;
+    }
+};
+const MAX_UNIT_LENGTH = 32;
 const bindingKeys = {
     property: ['id', 'tagId', 'kind', 'instanceId', 'property', 'unit'],
     flow: ['id', 'tagId', 'kind', 'connectionId', 'unit'],
@@ -148,6 +208,11 @@ function readProperties(value, path, limits, errors) {
     let valid = true;
     for (const [key, v] of entries) {
         const propertyPath = `${path}.${key}`;
+        if (isSecretKey(key)) {
+            errors.push({ code: 'SECRET_FIELD', path: propertyPath, message: `"${key}" looks like a credential; store a reference in the host instead.` });
+            valid = false;
+            continue;
+        }
         if (typeof v === 'string') {
             if (v.length > limits.maxStringLength) {
                 errors.push({ code: 'LIMIT_EXCEEDED', path: propertyPath, message: `String longer than ${limits.maxStringLength} characters.` });
@@ -165,12 +230,161 @@ function readProperties(value, path, limits, errors) {
     }
     return valid ? properties : undefined;
 }
+/** A non-empty string no longer than the string limit. */
+function readText(value, path, limits, errors) {
+    if (typeof value !== 'string' || value.length === 0) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a non-empty string.' });
+        return undefined;
+    }
+    if (value.length > limits.maxStringLength) {
+        errors.push({ code: 'LIMIT_EXCEEDED', path, message: `String longer than ${limits.maxStringLength} characters.` });
+        return undefined;
+    }
+    return value;
+}
+/** Defines a key as plain data, so keys such as "__proto__" never touch the prototype. */
+function put(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: true, writable: true, configurable: true });
+}
+function readProject(value, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path: 'project', message: 'Expected a project object.' });
+        return undefined;
+    }
+    checkKeys(value, projectKeys, 'project', errors);
+    const project = {};
+    if (value.id !== undefined) {
+        const id = readId(value.id, 'project.id', limits, errors);
+        if (id !== undefined)
+            project.id = id;
+    }
+    for (const key of ['name', 'revision', 'description']) {
+        if (value[key] !== undefined) {
+            const text = readText(value[key], `project.${key}`, limits, errors);
+            if (text !== undefined)
+                project[key] = text;
+        }
+    }
+    return project;
+}
+/** Identification labels: string keys to string values, no credentials (ADR-0021). */
+function readLabels(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected an object of labels.' });
+        return undefined;
+    }
+    const entries = Object.entries(value);
+    if (entries.length > limits.maxProperties) {
+        errors.push({ code: 'LIMIT_EXCEEDED', path, message: `More than ${limits.maxProperties} labels.` });
+        return undefined;
+    }
+    const labels = {};
+    for (const [key, v] of entries) {
+        const labelPath = `${path}.${key}`;
+        if (key.length === 0 || key.length > limits.maxIdLength) {
+            errors.push({ code: 'INVALID_FIELD', path: labelPath, message: `Label names must be 1 to ${limits.maxIdLength} characters.` });
+            continue;
+        }
+        if (isSecretKey(key)) {
+            errors.push({ code: 'SECRET_FIELD', path: labelPath, message: `"${key}" looks like a credential; store a reference in the host instead.` });
+            continue;
+        }
+        if (typeof v !== 'string') {
+            errors.push({ code: 'INVALID_FIELD', path: labelPath, message: 'Expected a string label.' });
+            continue;
+        }
+        if (v.length > limits.maxStringLength) {
+            errors.push({ code: 'LIMIT_EXCEEDED', path: labelPath, message: `String longer than ${limits.maxStringLength} characters.` });
+            continue;
+        }
+        put(labels, key, v);
+    }
+    return labels;
+}
+/**
+ * Extensions: reverse-DNS namespaces to plain JSON, bounded in depth and size, with no prototype
+ * keys and no credentials anywhere inside (ADR-0021). Returns a fresh copy.
+ */
+function readExtensions(value, path, budget, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected an object keyed by namespace.' });
+        return undefined;
+    }
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+        if (!NAMESPACE.test(key)) {
+            errors.push({ code: 'INVALID_FIELD', path: `${path}.${key}`, message: 'Extension keys must be reverse-DNS namespaces such as "com.example.app".' });
+            continue;
+        }
+        const copy = readJson(v, `${path}.${key}`, 1, budget, limits, errors);
+        if (copy !== undefined)
+            put(out, key, copy);
+    }
+    return out;
+}
+function readJson(value, path, depth, budget, limits, errors) {
+    if (--budget.left < 0) {
+        if (budget.left === -1)
+            errors.push({ code: 'LIMIT_EXCEEDED', path, message: budget.exceeded });
+        return undefined;
+    }
+    if (depth > MAX_EXTENSION_DEPTH) {
+        errors.push({ code: 'LIMIT_EXCEEDED', path, message: `Extension values nest deeper than ${MAX_EXTENSION_DEPTH} levels.` });
+        return undefined;
+    }
+    if (value === null || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (Number.isFinite(value))
+            return plusZero(value);
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a finite number.' });
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        if (value.length <= limits.maxStringLength)
+            return value;
+        errors.push({ code: 'LIMIT_EXCEEDED', path, message: `String longer than ${limits.maxStringLength} characters.` });
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        for (let i = 0; i < value.length; i++) {
+            const item = readJson(value[i], `${path}[${i}]`, depth + 1, budget, limits, errors);
+            if (item === undefined)
+                return undefined;
+            out.push(item);
+        }
+        return out;
+    }
+    if (isObject(value)) {
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            const keyPath = `${path}.${key}`;
+            if (FORBIDDEN_KEYS.has(key)) {
+                errors.push({ code: 'INVALID_FIELD', path: keyPath, message: `"${key}" is not allowed as a key.` });
+                return undefined;
+            }
+            if (isSecretKey(key)) {
+                errors.push({ code: 'SECRET_FIELD', path: keyPath, message: `"${key}" looks like a credential; store a reference in the host instead.` });
+                return undefined;
+            }
+            const item = readJson(v, keyPath, depth + 1, budget, limits, errors);
+            if (item === undefined)
+                return undefined;
+            put(out, key, item);
+        }
+        return out;
+    }
+    errors.push({ code: 'INVALID_FIELD', path, message: 'Expected plain JSON.' });
+    return undefined;
+}
 /**
  * Reads one component in the input's own schema version and returns it in the current model.
- * Version 3 uses named { x, y, z } / { x, y, z, w } objects. Version 2 uses arrays. Version 1 uses
- * `kind` and Euler XYZ radians and has no scale. Older versions migrate to the version 3 objects.
+ * Versions 3 and 4 use named { x, y, z } / { x, y, z, w } objects; version 4 adds identity, labels and
+ * extensions. Version 2 uses arrays. Version 1 uses `kind` and Euler XYZ radians and has no scale.
+ * Older versions migrate to the current model.
  */
-function readComponent(value, path, version, limits, errors) {
+function readComponent(value, path, version, limits, errors, extensionBudget, resolveType) {
     if (!isObject(value)) {
         errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a component object.' });
         return undefined;
@@ -180,14 +394,18 @@ function readComponent(value, path, version, limits, errors) {
     const id = readId(value.id, `${path}.id`, limits, errors);
     const typeField = version === 1 ? 'kind' : 'type';
     const type = value[typeField];
-    if (!componentKinds.includes(type)) {
-        errors.push({ code: 'UNKNOWN_COMPONENT_KIND', path: `${path}.${typeField}`, message: `Unknown component type ${describe(type)}.` });
+    if (!isBuiltInKind(type) && !isNamespacedType(type)) {
+        // Bare names belong to the SDK; a host's own types are namespaced (ADR-0022).
+        errors.push({ code: 'UNKNOWN_COMPONENT_KIND', path: `${path}.${typeField}`, message: `Unknown component type ${describe(type)}; custom types are namespaced, such as "com.example.part".` });
+    }
+    else if (resolveType ? !resolveType(type) : !isBuiltInKind(type)) {
+        errors.push({ code: 'UNKNOWN_COMPONENT_KIND', path: `${path}.${typeField}`, message: `Unknown component type ${describe(type)}; no definition is registered for it.` });
     }
     let position;
     let rotation;
     let scale;
-    const parentId = version === 3 && value.parentId !== undefined ? readId(value.parentId, `${path}.parentId`, limits, errors) : undefined;
-    if (version === 3) {
+    const parentId = version >= 3 && value.parentId !== undefined ? readId(value.parentId, `${path}.parentId`, limits, errors) : undefined;
+    if (version >= 3) {
         position = readVectorObject(value.position, `${path}.position`, errors);
         rotation = readQuaternionObject(value.rotation, `${path}.rotation`, errors);
         scale = readVectorObject(value.scale, `${path}.scale`, errors, true);
@@ -208,9 +426,32 @@ function readComponent(value, path, version, limits, errors) {
         }
     }
     const properties = readProperties(value.properties, `${path}.properties`, limits, errors);
+    const identity = {};
+    if (version === 4) {
+        for (const key of ['name', 'typeVersion', 'manufacturer', 'model']) {
+            if (value[key] !== undefined) {
+                const text = readText(value[key], `${path}.${key}`, limits, errors);
+                if (text !== undefined)
+                    identity[key] = text;
+            }
+        }
+        if (value.labels !== undefined)
+            identity.labels = readLabels(value.labels, `${path}.labels`, limits, errors);
+        if (value.extensions !== undefined)
+            identity.extensions = readExtensions(value.extensions, `${path}.extensions`, extensionBudget, limits, errors);
+    }
     if (errors.length > before || !id || !position || !rotation || !scale || !properties)
         return undefined;
-    return { id, type: type, ...(parentId ? { parentId } : {}), position, rotation, scale, properties };
+    return {
+        id,
+        type: type,
+        ...(parentId ? { parentId } : {}),
+        position,
+        rotation,
+        scale,
+        properties,
+        ...identity,
+    };
 }
 function readEndpoint(value, path, limits, errors) {
     if (!isObject(value)) {
@@ -225,19 +466,338 @@ function readEndpoint(value, path, limits, errors) {
         return undefined;
     return { instanceId, portId };
 }
-function readConnection(value, path, limits, errors) {
+/** Edge data on a connection or association (ADR-0023): property value rules, and no credential-like names. */
+function readEdgeProperties(value, path, limits, errors) {
+    const properties = readProperties(value, path, limits, errors);
+    for (const key of Object.keys(properties ?? {})) {
+        if (isSecretKey(key))
+            errors.push({ code: 'SECRET_FIELD', path: `${path}.${key}`, message: `"${key}" looks like a credential; store a reference in the host instead.` });
+    }
+    return properties;
+}
+function readAssociation(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected an association object.' });
+        return undefined;
+    }
+    const before = errors.length;
+    checkKeys(value, associationKeys, path, errors);
+    const id = readId(value.id, `${path}.id`, limits, errors);
+    if (!isRelationship(value.relationship)) {
+        errors.push({ code: 'INVALID_FIELD', path: `${path}.relationship`, message: `Expected a relationship: one of ${relationshipKinds.join(', ')}, or a namespaced name such as "com.example.supervises".` });
+    }
+    const from = readId(value.from, `${path}.from`, limits, errors);
+    const to = readId(value.to, `${path}.to`, limits, errors);
+    const properties = value.properties !== undefined ? readEdgeProperties(value.properties, `${path}.properties`, limits, errors) : undefined;
+    if (errors.length > before || !id || !from || !to)
+        return undefined;
+    return { id, relationship: value.relationship, from, to, ...(properties ? { properties } : {}) };
+}
+function readDataSource(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a data source object.' });
+        return undefined;
+    }
+    const before = errors.length;
+    checkKeys(value, dataSourceKeys, path, errors);
+    const id = readId(value.id, `${path}.id`, limits, errors);
+    const source = {};
+    if (value.name !== undefined)
+        source.name = readText(value.name, `${path}.name`, limits, errors);
+    if (protocols.includes(value.protocol) || isNamespacedType(value.protocol))
+        source.protocol = value.protocol;
+    else
+        errors.push({ code: 'INVALID_FIELD', path: `${path}.protocol`, message: `Unknown protocol ${describe(value.protocol)}; expected one of ${protocols.join(', ')}, or a namespaced name such as "com.vendor.bus".` });
+    if (value.deviceId !== undefined)
+        source.deviceId = readId(value.deviceId, `${path}.deviceId`, limits, errors);
+    if (value.endpointRef !== undefined) {
+        const ref = readText(value.endpointRef, `${path}.endpointRef`, limits, errors);
+        if (ref !== undefined && endpointCarriesSecret(ref)) {
+            errors.push({ code: 'SECRET_FIELD', path: `${path}.endpointRef`, message: 'The endpoint carries a user name or password; store a reference the host resolves instead.' });
+        }
+        else if (ref !== undefined)
+            source.endpointRef = ref;
+    }
+    if (value.properties !== undefined)
+        source.properties = readEdgeProperties(value.properties, `${path}.properties`, limits, errors);
+    if (errors.length > before || !id)
+        return undefined;
+    return { id, ...source };
+}
+function readFinite(value, path, errors) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return plusZero(value);
+    errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a finite number.' });
+    return undefined;
+}
+/** Reads a variable; its address stays plain JSON here and is checked against its source's protocol in `checkAcquisition`. */
+function readVariable(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a runtime variable object.' });
+        return undefined;
+    }
+    const before = errors.length;
+    checkKeys(value, variableKeys, path, errors);
+    const id = readId(value.id, `${path}.id`, limits, errors);
+    const variable = {};
+    if (value.name !== undefined)
+        variable.name = readText(value.name, `${path}.name`, limits, errors);
+    if (value.componentId !== undefined)
+        variable.componentId = readId(value.componentId, `${path}.componentId`, limits, errors);
+    if (dataTypes.includes(value.dataType))
+        variable.dataType = value.dataType;
+    else
+        errors.push({ code: 'INVALID_FIELD', path: `${path}.dataType`, message: `Unknown data type ${describe(value.dataType)}; expected one of ${dataTypes.join(', ')}.` });
+    if (value.unit !== undefined) {
+        if (typeof value.unit === 'string' && value.unit.length <= MAX_UNIT_LENGTH)
+            variable.unit = value.unit;
+        else
+            errors.push({ code: 'INVALID_FIELD', path: `${path}.unit`, message: `Expected a unit of at most ${MAX_UNIT_LENGTH} characters.` });
+    }
+    if (value.access === 'read' || value.access === 'readWrite')
+        variable.access = value.access;
+    else
+        errors.push({ code: 'INVALID_FIELD', path: `${path}.access`, message: `Expected access "read" or "readWrite".` });
+    if (value.source !== undefined) {
+        const s = value.source;
+        if (!isObject(s))
+            errors.push({ code: 'INVALID_FIELD', path: `${path}.source`, message: 'Expected a source object.' });
+        else {
+            checkKeys(s, variableSourceKeys, `${path}.source`, errors);
+            const dataSourceId = readId(s.dataSourceId, `${path}.source.dataSourceId`, limits, errors);
+            const name = s.variable !== undefined ? readText(s.variable, `${path}.source.variable`, limits, errors) : undefined;
+            let address;
+            if (s.address !== undefined) {
+                if (!isObject(s.address))
+                    errors.push({ code: 'INVALID_ADDRESS', path: `${path}.source.address`, message: 'Expected an address object.' });
+                else
+                    address = readJson(s.address, `${path}.source.address`, 1, { left: MAX_ADDRESS_VALUES, exceeded: `An address holds more than ${MAX_ADDRESS_VALUES} values.` }, limits, errors);
+            }
+            if (dataSourceId)
+                variable.source = { dataSourceId, ...(name !== undefined ? { variable: name } : {}), ...(address !== undefined ? { address: address } : {}) };
+        }
+    }
+    if (value.scaling !== undefined) {
+        const sc = value.scaling;
+        if (!isObject(sc))
+            errors.push({ code: 'INVALID_FIELD', path: `${path}.scaling`, message: 'Expected a scaling object.' });
+        else {
+            checkKeys(sc, scalingKeys, `${path}.scaling`, errors);
+            if (sc.kind !== 'linear')
+                errors.push({ code: 'INVALID_FIELD', path: `${path}.scaling.kind`, message: 'Expected scaling kind "linear".' });
+            const [rawMin, rawMax, min, max] = ['rawMin', 'rawMax', 'min', 'max'].map((k) => readFinite(sc[k], `${path}.scaling.${k}`, errors));
+            if (rawMin !== undefined && rawMax !== undefined && rawMin === rawMax)
+                errors.push({ code: 'INVALID_FIELD', path: `${path}.scaling.rawMax`, message: 'rawMin and rawMax must differ.' });
+            if (rawMin !== undefined && rawMax !== undefined && min !== undefined && max !== undefined)
+                variable.scaling = { kind: 'linear', rawMin, rawMax, min, max };
+        }
+    }
+    if (value.command !== undefined)
+        variable.command = readCommand(value.command, `${path}.command`, limits, errors);
+    if (variable.dataType && variable.access)
+        checkCommand(variable, value, path, errors);
+    if (errors.length > before || !id)
+        return undefined;
+    return { id, ...variable };
+}
+function readCommand(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a command limits object.' });
+        return undefined;
+    }
+    checkKeys(value, commandKeys, path, errors);
+    const command = {};
+    for (const key of ['min', 'max', 'step'])
+        if (value[key] !== undefined)
+            command[key] = readFinite(value[key], `${path}.${key}`, errors);
+    if (value.confirm !== undefined)
+        command.confirm = readText(value.confirm, `${path}.confirm`, limits, errors);
+    return command;
+}
+/**
+ * The command boundary's document rules (ADR-0029 §2): only a `readWrite` variable has limits; it
+ * needs a source; strings cannot be commanded; numeric types are bounded within their data type.
+ */
+function checkCommand(variable, value, path, errors) {
+    const bad = (field, message) => {
+        errors.push({ code: 'INVALID_FIELD', path: `${path}${field}`, message });
+    };
+    if (variable.access === 'read') {
+        if (value.command !== undefined)
+            bad('.command', 'Only a "readWrite" variable takes command limits.');
+        return;
+    }
+    if (variable.dataType === 'string')
+        return bad('.access', 'A string variable cannot be commanded (ADR-0029).');
+    if (value.source === undefined)
+        bad('.source', 'A writable variable needs a source the host writes to.');
+    const command = variable.command;
+    if (value.command === undefined)
+        return bad('.command', 'A writable variable needs command limits (ADR-0029).');
+    if (!command)
+        return;
+    if (command.step !== undefined && !(command.step > 0))
+        bad('.command.step', 'The step must be greater than zero.');
+    if (variable.dataType === 'bool') {
+        for (const key of ['min', 'max'])
+            if (command[key] !== undefined)
+                bad(`.command.${key}`, 'An on/off variable takes no minimum or maximum.');
+        return;
+    }
+    // Unbounded setpoints are refused: both limits, in order, and within the data type.
+    for (const key of ['min', 'max']) {
+        const limit = command[key];
+        if (limit === undefined) {
+            if (value.command && isObject(value.command) && value.command[key] === undefined)
+                bad(`.command.${key}`, `A numeric writable variable needs a ${key === 'min' ? 'minimum' : 'maximum'}.`);
+        }
+        else if (!valueFitsDataType(limit, variable.dataType, !!variable.scaling))
+            bad(`.command.${key}`, `${limit} does not fit ${variable.dataType}.`);
+    }
+    if (command.min !== undefined && command.max !== undefined && !(command.min < command.max))
+        bad('.command.max', 'The maximum must be greater than the minimum.');
+}
+/** Keys anywhere in plain JSON that name a credential. */
+function secretKeys(value, path, errors) {
+    if (Array.isArray(value))
+        value.forEach((v, i) => secretKeys(v, `${path}[${i}]`, errors));
+    else if (value !== null && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            if (isSecretKey(k))
+                errors.push({ code: 'SECRET_FIELD', path: `${path}.${k}`, message: `"${k}" looks like a credential; store a reference in the host instead.` });
+            else
+                secretKeys(v, `${path}.${k}`, errors);
+        }
+    }
+}
+/** Address rules per protocol (ADR-0024); every problem is `INVALID_ADDRESS` at the field's path. */
+function checkAddress(protocol, variable, path, options, errors) {
+    const address = variable.source?.address;
+    const bad = (at, message) => {
+        errors.push({ code: 'INVALID_ADDRESS', path: at ? `${path}.${at}` : path, message });
+    };
+    const isInt = (v, lo, hi) => typeof v === 'number' && Number.isInteger(v) && v >= lo && v <= hi;
+    if (protocol === 'host') {
+        if (address !== undefined)
+            bad('', 'A host source reads by tag id or `variable`; it takes no address.');
+        return;
+    }
+    if (protocol === 'opcua' || protocol === 'modbus-tcp' || protocol === 'modbus-rtu') {
+        if (address === undefined)
+            return bad('', `A ${protocol} source needs an address.`);
+        if (protocol === 'opcua') {
+            for (const key of Object.keys(address))
+                if (!opcUaKeys.includes(key))
+                    bad(key, `Unknown OPC UA address field "${key}".`);
+            if (typeof address.nodeId !== 'string' || address.nodeId.length === 0)
+                bad('nodeId', 'Expected a node id such as "ns=2;s=Line2.Speed".');
+            if (address.namespaceUri !== undefined && (typeof address.namespaceUri !== 'string' || address.namespaceUri.length === 0))
+                bad('namespaceUri', 'Expected a namespace URI.');
+            return;
+        }
+        for (const key of Object.keys(address))
+            if (!modbusKeys.includes(key))
+                bad(key, `Unknown Modbus address field "${key}".`);
+        const area = address.area;
+        if (!modbusAreas.includes(area))
+            return bad('area', `Expected an area: ${modbusAreas.join(', ')}.`);
+        if (!isInt(address.unitId, 0, 255))
+            bad('unitId', 'Expected a unit id 0–255.');
+        if (address.byteOrder !== undefined && address.byteOrder !== 'big' && address.byteOrder !== 'little')
+            bad('byteOrder', 'Expected "big" or "little".');
+        if (address.wordOrder !== undefined && address.wordOrder !== 'high-first' && address.wordOrder !== 'low-first')
+            bad('wordOrder', 'Expected "high-first" or "low-first".');
+        const registers = MODBUS_REGISTERS[variable.dataType];
+        if (registers === undefined)
+            return bad('', `A ${variable.dataType} cannot be read from Modbus.`);
+        if ((area === 'coil' || area === 'discrete') && variable.dataType !== 'bool')
+            bad('area', `A ${area} holds only bool, not ${variable.dataType}.`);
+        if (!isInt(address.address, 0, 65535))
+            bad('address', 'Expected an address 0–65535.');
+        else if (address.address + registers - 1 > 65535)
+            bad('address', `A ${variable.dataType} spans ${registers} registers and does not fit below 65536.`);
+        if (address.bit !== undefined) {
+            if (!isInt(address.bit, 0, 15))
+                bad('bit', 'Expected a bit 0–15.');
+            else if (variable.dataType !== 'bool' || (area !== 'holding' && area !== 'input'))
+                bad('bit', 'A bit applies only to a bool in a holding or input register.');
+        }
+        return;
+    }
+    // A host's own protocol: plain JSON, checked by the host when it can.
+    if (address === undefined)
+        return;
+    secretKeys(address, `${path}`, errors);
+    for (const message of options.validateAddress?.(protocol, address) ?? [])
+        bad('', message);
+}
+/** References and address rules of data sources and runtime variables (ADR-0024). */
+function checkAcquisition(scene, options, errors) {
+    const components = new Set(scene.components.map((c) => c.id));
+    const sources = new Map();
+    scene.dataSources?.forEach((s, i) => {
+        const path = `dataSources[${i}]`;
+        if (sources.has(s.id))
+            errors.push({ code: 'DUPLICATE_DATA_SOURCE_ID', path: `${path}.id`, message: `Duplicate data source id "${s.id}".` });
+        else
+            sources.set(s.id, s);
+        if (s.deviceId !== undefined && !components.has(s.deviceId))
+            errors.push({ code: 'UNKNOWN_INSTANCE', path: `${path}.deviceId`, message: `No component "${s.deviceId}".` });
+    });
+    const ids = new Set();
+    scene.runtimeVariables?.forEach((v, i) => {
+        const path = `runtimeVariables[${i}]`;
+        if (ids.has(v.id)) {
+            errors.push({ code: 'DUPLICATE_VARIABLE_ID', path: `${path}.id`, message: `Duplicate runtime variable id "${v.id}".` });
+            return;
+        }
+        ids.add(v.id);
+        if (v.componentId !== undefined && !components.has(v.componentId))
+            errors.push({ code: 'UNKNOWN_INSTANCE', path: `${path}.componentId`, message: `No component "${v.componentId}".` });
+        if (!v.source)
+            return;
+        const source = sources.get(v.source.dataSourceId);
+        if (!source) {
+            errors.push({ code: 'UNKNOWN_DATA_SOURCE', path: `${path}.source.dataSourceId`, message: `No data source "${v.source.dataSourceId}".` });
+            return;
+        }
+        checkAddress(source.protocol, v, `${path}.source.address`, options, errors);
+    });
+}
+function readConnection(value, path, version, limits, errors) {
     if (!isObject(value)) {
         errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a connection object.' });
         return undefined;
     }
     const before = errors.length;
-    checkKeys(value, connectionKeys, path, errors);
+    checkKeys(value, connectionKeys[version], path, errors);
     const id = readId(value.id, `${path}.id`, limits, errors);
     const from = readEndpoint(value.from, `${path}.from`, limits, errors);
     const to = readEndpoint(value.to, `${path}.to`, limits, errors);
+    // Version 4 fields (ADR-0023); older versions reject them as unknown keys above.
+    const extra = {};
+    if (version === 4) {
+        if (value.domain !== undefined) {
+            if (portKinds.includes(value.domain))
+                extra.domain = value.domain;
+            else
+                errors.push({ code: 'INVALID_FIELD', path: `${path}.domain`, message: `Unknown connection domain ${describe(value.domain)}; expected one of ${portKinds.join(', ')}.` });
+        }
+        if (value.relationship !== undefined) {
+            if (isRelationship(value.relationship))
+                extra.relationship = value.relationship;
+            else
+                errors.push({ code: 'INVALID_FIELD', path: `${path}.relationship`, message: `Unknown relationship ${describe(value.relationship)}; expected one of ${relationshipKinds.join(', ')}, or a namespaced name such as "com.example.supervises".` });
+        }
+        if (value.properties !== undefined) {
+            const properties = readEdgeProperties(value.properties, `${path}.properties`, limits, errors);
+            if (properties)
+                extra.properties = properties;
+        }
+    }
     if (errors.length > before || !id || !from || !to)
         return undefined;
-    return { id, from, to };
+    return { id, ...extra, from, to };
 }
 function readBinding(value, path, limits, errors) {
     if (!isObject(value)) {
@@ -272,6 +832,7 @@ function readBinding(value, path, limits, errors) {
 function checkBindings(scene, options, errors) {
     const components = new Map(scene.components.map((c) => [c.id, c]));
     const connections = new Set(scene.connections.map((c) => c.id));
+    const variables = new Map((scene.runtimeVariables ?? []).map((v) => [v.id, v]));
     const ids = new Set();
     const targets = new Set();
     scene.tagBindings?.forEach((binding, i) => {
@@ -290,7 +851,7 @@ function checkBindings(scene, options, errors) {
                 return;
             }
             if (options.resolveBindable) {
-                quantity = options.resolveBindable(owner.type)?.[binding.property];
+                quantity = ownValue(options.resolveBindable(owner.type), binding.property);
                 if (!quantity) {
                     errors.push({ code: 'UNBINDABLE_PROPERTY', path: `${path}.property`, message: `A ${owner.type} has no bindable property "${binding.property}".` });
                     return;
@@ -306,6 +867,20 @@ function checkBindings(scene, options, errors) {
             quantity = 'flow';
             target = JSON.stringify(['flow', binding.connectionId]);
         }
+        const variable = variables.get(binding.tagId);
+        if (variable) {
+            // The tag is described (ADR-0024): its data type must fit the property, and its unit applies when the binding gives none.
+            const fits = variable.dataType === 'string' ? false : quantity === undefined ? true : (quantity === 'boolean') === (variable.dataType === 'bool');
+            if (!fits) {
+                const needs = quantity === 'boolean' ? 'a bool' : quantity ? `a number (${quantity})` : 'a bool or a number';
+                errors.push({ code: 'TYPE_MISMATCH', path: `${path}.tagId`, message: `Tag "${binding.tagId}" is ${variable.dataType}, but this binding needs ${needs}.` });
+                return;
+            }
+            if (quantity && binding.unit === undefined && variable.unit !== undefined && !isKnownUnit(quantity, variable.unit)) {
+                errors.push({ code: 'INVALID_UNIT', path: `${path}.tagId`, message: `Tag "${binding.tagId}" is in "${variable.unit}", which is not accepted for ${quantity}.` });
+                return;
+            }
+        }
         if (quantity && !isKnownUnit(quantity, binding.unit)) {
             errors.push({ code: 'INVALID_UNIT', path: `${path}.unit`, message: `Unit "${binding.unit}" is not accepted for ${quantity}.` });
             return;
@@ -327,11 +902,12 @@ function readList(value, path, max, errors, read) {
         return undefined;
     }
     const items = [];
-    value.forEach((item, i) => {
-        const parsed = read(item, `${path}[${i}]`);
+    // Every index, not forEach: a hole in a sparse array (`[, x]`) is an invalid entry, as `null` is in JSON.
+    for (let i = 0; i < value.length; i++) {
+        const parsed = read(value[i], `${path}[${i}]`);
         if (parsed)
             items.push(parsed);
-    });
+    }
     return items;
 }
 function checkReferences(scene, options, errors) {
@@ -368,7 +944,7 @@ function checkReferences(scene, options, errors) {
         }
     });
     const connectionIds = new Set();
-    const occupied = new Set();
+    const occupied = new Map();
     const pairs = new Set();
     const endpointKey = (e) => JSON.stringify([e.instanceId, e.portId]);
     scene.connections.forEach((connection, i) => {
@@ -399,8 +975,13 @@ function checkReferences(scene, options, errors) {
             errors.push({ code: 'SELF_CONNECTION', path, message: 'A component cannot connect to itself.' });
             return;
         }
-        if (!portsCompatible(fromPort, toPort)) {
-            errors.push({ code: 'INCOMPATIBLE_PORTS', path, message: 'Port domains or nominal sizes do not match.' });
+        const check = checkPorts(fromPort, toPort);
+        if (!check.ok) {
+            errors.push({ code: 'INCOMPATIBLE_PORTS', path, message: `Incompatible ports: ${check.reason}.` });
+            return;
+        }
+        if (connection.domain !== undefined && connection.domain !== fromPort.kind) {
+            errors.push({ code: 'INCOMPATIBLE_PORTS', path: `${path}.domain`, message: `The connection is marked ${connection.domain}, but its ports are ${fromPort.kind} ports.` });
             return;
         }
         const fromKey = endpointKey(connection.from);
@@ -411,28 +992,173 @@ function checkReferences(scene, options, errors) {
             return;
         }
         let free = true;
-        for (const [side, key] of [['from', fromKey], ['to', toKey]]) {
-            if (occupied.has(key)) {
-                errors.push({ code: 'PORT_OCCUPIED', path: `${path}.${side}`, message: 'Port already has a connection.' });
+        for (const [side, key, port] of [['from', fromKey, fromPort], ['to', toKey, toPort]]) {
+            const capacity = portCapacity(port);
+            if ((occupied.get(key) ?? 0) >= capacity) {
+                errors.push({ code: 'PORT_OCCUPIED', path: `${path}.${side}`, message: capacity === 1 ? 'Port already has a connection.' : `Port already has ${capacity} connections, its maximum.` });
                 free = false;
             }
         }
         if (!free)
             return;
         pairs.add(pair);
-        occupied.add(fromKey);
-        occupied.add(toKey);
+        occupied.set(fromKey, (occupied.get(fromKey) ?? 0) + 1);
+        occupied.set(toKey, (occupied.get(toKey) ?? 0) + 1);
+    });
+    // Associations (ADR-0023): ids share the connections' namespace; directed, so only an identical
+    // (from, to, relationship) repeats.
+    const facts = new Set();
+    scene.associations?.forEach((a, i) => {
+        const path = `associations[${i}]`;
+        if (connectionIds.has(a.id)) {
+            errors.push({ code: 'DUPLICATE_CONNECTION_ID', path: `${path}.id`, message: `Duplicate connection or association id "${a.id}".` });
+            return;
+        }
+        connectionIds.add(a.id);
+        let known = true;
+        for (const side of ['from', 'to']) {
+            if (!componentsById.has(a[side])) {
+                errors.push({ code: 'UNKNOWN_INSTANCE', path: `${path}.${side}`, message: `No component "${a[side]}".` });
+                known = false;
+            }
+        }
+        if (!known)
+            return;
+        if (a.from === a.to) {
+            errors.push({ code: 'SELF_CONNECTION', path, message: 'A component cannot be associated with itself.' });
+            return;
+        }
+        const fact = JSON.stringify([a.from, a.to, a.relationship]);
+        if (facts.has(fact)) {
+            errors.push({ code: 'DUPLICATE_EDGE', path, message: `"${a.from}" already ${a.relationship} "${a.to}".` });
+            return;
+        }
+        facts.add(fact);
     });
 }
 /**
- * Validates an untrusted value as a scene and returns it in the current (version 3) model.
- * Version 1 (`version: 1`) and version 2 (array vectors) input is migrated deterministically and
- * reported via `migratedFrom`.
- * Never mutates or repairs the input: on success it returns a fresh copy, otherwise every error
- * found, in input order, with paths in the input's own field names. Reference checks (ids, ports,
- * compatibility, occupancy, scale policy) run only once the structure is valid. Each port accepts
- * one connection.
+ * Reads the optional 2D layouts (ADR-0026): per view, symbol placements by component id and routes by
+ * connection id. Structure only; `checkViews` checks that the ids exist.
  */
+function readViews(value, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path: 'views', message: 'Expected an object of views.' });
+        return undefined;
+    }
+    checkKeys(value, [...viewKinds], 'views', errors);
+    const views = {};
+    for (const kind of viewKinds) {
+        if (value[kind] === undefined)
+            continue;
+        const layout = readViewLayout(value[kind], `views.${kind}`, limits, errors);
+        if (layout)
+            views[kind] = layout;
+    }
+    return views;
+}
+function readViewLayout(value, path, limits, errors) {
+    if (!isObject(value)) {
+        errors.push({ code: 'INVALID_FIELD', path, message: 'Expected a view layout object.' });
+        return undefined;
+    }
+    checkKeys(value, viewLayoutKeys, path, errors);
+    const layout = {};
+    const coordinate = (v, at) => {
+        if (typeof v !== 'number' || !Number.isFinite(v) || Math.abs(v) > MAX_VIEW_COORDINATE) {
+            errors.push({ code: 'INVALID_FIELD', path: at, message: `Expected a finite number within ±${MAX_VIEW_COORDINATE}.` });
+            return undefined;
+        }
+        return v === 0 ? 0 : v; // -0 is written as 0, so read it as 0
+    };
+    const entries = (field, max) => {
+        const record = value[field];
+        if (record === undefined)
+            return undefined;
+        const at = `${path}.${field}`;
+        if (!isObject(record)) {
+            errors.push({ code: 'INVALID_FIELD', path: at, message: 'Expected an object keyed by id.' });
+            return undefined;
+        }
+        const list = Object.entries(record);
+        if (list.length > max) {
+            errors.push({ code: 'LIMIT_EXCEEDED', path: at, message: `More than ${max} entries.` });
+            return undefined;
+        }
+        return list.filter(([key]) => readId(key, `${at}.${key}`, limits, errors) !== undefined).map(([key, v]) => [key, v, `${at}.${key}`]);
+    };
+    const symbolEntries = entries('symbols', limits.maxComponents);
+    if (symbolEntries) {
+        const symbols = {};
+        for (const [id, v, at] of symbolEntries) {
+            if (!isObject(v)) {
+                errors.push({ code: 'INVALID_FIELD', path: at, message: 'Expected a symbol placement object.' });
+                continue;
+            }
+            const before = errors.length;
+            checkKeys(v, symbolKeys, at, errors);
+            const x = coordinate(v.x, `${at}.x`), y = coordinate(v.y, `${at}.y`);
+            if (v.rotation !== undefined && !(v.rotation === 0 || v.rotation === 90 || v.rotation === 180 || v.rotation === 270)) {
+                errors.push({ code: 'INVALID_FIELD', path: `${at}.rotation`, message: 'Expected a rotation of 0, 90, 180 or 270.' });
+            }
+            if (v.hidden !== undefined && v.hidden !== true)
+                errors.push({ code: 'INVALID_FIELD', path: `${at}.hidden`, message: 'Expected true, or no field.' });
+            if (errors.length > before || x === undefined || y === undefined)
+                continue;
+            put(symbols, id, { x, y, ...(v.rotation !== undefined ? { rotation: v.rotation } : {}), ...(v.hidden ? { hidden: true } : {}) });
+        }
+        layout.symbols = symbols;
+    }
+    const routeEntries = entries('routes', limits.maxConnections + limits.maxAssociations);
+    if (routeEntries) {
+        const routes = {};
+        for (const [id, v, at] of routeEntries) {
+            if (!isObject(v)) {
+                errors.push({ code: 'INVALID_FIELD', path: at, message: 'Expected a route object.' });
+                continue;
+            }
+            checkKeys(v, ['points'], at, errors);
+            const points = v.points;
+            if (!Array.isArray(points) || points.length < 2 || points.length > MAX_ROUTE_POINTS) {
+                errors.push({ code: 'INVALID_FIELD', path: `${at}.points`, message: `Expected 2 to ${MAX_ROUTE_POINTS} points.` });
+                continue;
+            }
+            const read = [];
+            for (let i = 0; i < points.length; i++) {
+                const p = points[i];
+                if (!Array.isArray(p) || p.length !== 2) {
+                    errors.push({ code: 'INVALID_FIELD', path: `${at}.points[${i}]`, message: 'Expected an [x, y] point.' });
+                    continue;
+                }
+                const x = coordinate(p[0], `${at}.points[${i}][0]`), y = coordinate(p[1], `${at}.points[${i}][1]`);
+                if (x !== undefined && y !== undefined)
+                    read.push([x, y]);
+            }
+            if (read.length === points.length)
+                put(routes, id, { points: read });
+        }
+        layout.routes = routes;
+    }
+    return layout;
+}
+/** Every placed symbol is a component, and every route a connection or association (ADR-0026). */
+function checkViews(scene, errors) {
+    if (!scene.views)
+        return;
+    const components = new Set(scene.components.map((c) => c.id));
+    const edges = new Set([...scene.connections.map((c) => c.id), ...(scene.associations ?? []).map((a) => a.id)]);
+    for (const kind of viewKinds) {
+        const layout = scene.views[kind];
+        for (const id of Object.keys(layout?.symbols ?? {})) {
+            if (!components.has(id))
+                errors.push({ code: 'UNKNOWN_VIEW_REFERENCE', path: `views.${kind}.symbols.${id}`, message: `No component "${id}" to place.` });
+        }
+        for (const id of Object.keys(layout?.routes ?? {})) {
+            if (!edges.has(id))
+                errors.push({ code: 'UNKNOWN_VIEW_REFERENCE', path: `views.${kind}.routes.${id}`, message: `No connection or association "${id}" to route.` });
+        }
+    }
+}
+/** Reads the optional reference drawing (ADR-0012); sanitizing is the host's `validateUnderlay`. */
 function readUnderlay(value, limits, options, errors) {
     if (!isObject(value)) {
         errors.push({ code: 'INVALID_FIELD', path: 'underlay', message: 'Expected an underlay object.' });
@@ -471,6 +1197,15 @@ function readUnderlay(value, limits, options, errors) {
     }
     return { svg, position: { x, z }, width, rotation, opacity };
 }
+/**
+ * Validates an untrusted value as a scene and returns it in the current (version 4) model.
+ * Version 1 (`version: 1`), version 2 (array vectors) and version 3 input is migrated
+ * deterministically and reported via `migratedFrom` (ADR-0021).
+ * Never mutates or repairs the input: on success it returns a fresh copy, otherwise every error
+ * found, in input order, with paths in the input's own field names. Reference checks (ids, ports,
+ * compatibility, occupancy, scale policy) run only once the structure is valid. Each port accepts
+ * one connection.
+ */
 export function validateScene(input, options) {
     const limits = { ...defaultSceneLimits, ...options.limits };
     const errors = [];
@@ -480,10 +1215,13 @@ export function validateScene(input, options) {
     let version;
     if ('schemaVersion' in input) {
         // Unsupported numbers are reported and read with the newest rules.
-        version = input.schemaVersion === 2 ? 2 : 3;
-        if (input.schemaVersion !== 2 && input.schemaVersion !== 3) {
+        version = input.schemaVersion === 2 || input.schemaVersion === 3 ? input.schemaVersion : 4;
+        if (input.schemaVersion !== 2 && input.schemaVersion !== 3 && input.schemaVersion !== 4) {
             errors.push({ code: 'UNSUPPORTED_VERSION', path: 'schemaVersion', message: `Unsupported schemaVersion ${describe(input.schemaVersion)}.` });
         }
+        if (input.schemaVersion === 4 && input.documentType !== SCENE_DOCUMENT_TYPE) {
+            errors.push({ code: 'INVALID_FIELD', path: 'documentType', message: `Expected documentType "${SCENE_DOCUMENT_TYPE}".` });
+        }
         if (input.units !== 'm') {
             errors.push({ code: 'INVALID_FIELD', path: 'units', message: 'Expected units "m".' });
         }
@@ -495,19 +1233,48 @@ export function validateScene(input, options) {
         }
     }
     checkKeys(input, sceneKeys[version], '', errors);
-    const components = readList(input.components, 'components', limits.maxComponents, errors, (item, path) => readComponent(item, path, version, limits, errors));
-    const connections = readList(input.connections, 'connections', limits.maxConnections, errors, (item, path) => readConnection(item, path, limits, errors));
+    const extensionBudget = { left: MAX_EXTENSION_VALUES, exceeded: `Extensions hold more than ${MAX_EXTENSION_VALUES} values.` };
+    const project = version === 4 && input.project !== undefined ? readProject(input.project, limits, errors) : undefined;
+    const components = readList(input.components, 'components', limits.maxComponents, errors, (item, path) => readComponent(item, path, version, limits, errors, extensionBudget, options.resolveType));
+    const connections = readList(input.connections, 'connections', limits.maxConnections, errors, (item, path) => readConnection(item, path, version, limits, errors));
+    const associations = version === 4 && input.associations !== undefined
+        ? readList(input.associations, 'associations', limits.maxAssociations, errors, (item, path) => readAssociation(item, path, limits, errors))
+        : undefined;
+    const dataSources = version === 4 && input.dataSources !== undefined
+        ? readList(input.dataSources, 'dataSources', limits.maxDataSources, errors, (item, path) => readDataSource(item, path, limits, errors))
+        : undefined;
+    const runtimeVariables = version === 4 && input.runtimeVariables !== undefined
+        ? readList(input.runtimeVariables, 'runtimeVariables', limits.maxVariables, errors, (item, path) => readVariable(item, path, limits, errors))
+        : undefined;
     const tagBindings = version !== 1 && input.tagBindings !== undefined
         ? readList(input.tagBindings, 'tagBindings', limits.maxBindings, errors, (item, path) => readBinding(item, path, limits, errors))
         : undefined;
-    const underlay = version === 3 && input.underlay !== undefined ? readUnderlay(input.underlay, limits, options, errors) : undefined;
+    const underlay = version >= 3 && input.underlay !== undefined ? readUnderlay(input.underlay, limits, options, errors) : undefined;
+    const views = version === 4 && input.views !== undefined ? readViews(input.views, limits, errors) : undefined;
+    const extensions = version === 4 && input.extensions !== undefined ? readExtensions(input.extensions, 'extensions', extensionBudget, limits, errors) : undefined;
     if (errors.length > 0 || !components || !connections)
         return { ok: false, errors };
-    const scene = { schemaVersion: 3, units: 'm', components, connections, ...(tagBindings ? { tagBindings } : {}), ...(underlay ? { underlay } : {}) };
+    const scene = {
+        schemaVersion: 4,
+        documentType: SCENE_DOCUMENT_TYPE,
+        units: 'm',
+        ...(project ? { project } : {}),
+        components,
+        connections,
+        ...(associations ? { associations } : {}),
+        ...(dataSources ? { dataSources } : {}),
+        ...(runtimeVariables ? { runtimeVariables } : {}),
+        ...(tagBindings ? { tagBindings } : {}),
+        ...(underlay ? { underlay } : {}),
+        ...(views ? { views } : {}),
+        ...(extensions ? { extensions } : {}),
+    };
     checkReferences(scene, options, errors);
+    checkViews(scene, errors);
     checkBindings(scene, options, errors);
+    checkAcquisition(scene, options, errors);
     if (errors.length > 0)
         return { ok: false, errors };
-    return version === 3 ? { ok: true, scene } : { ok: true, scene, migratedFrom: version };
+    return version === 4 ? { ok: true, scene } : { ok: true, scene, migratedFrom: version };
 }
 //# sourceMappingURL=validation.js.map