@schemd/core 0.1.0

package/dist/parser.js

@@ -0,0 +1,598 @@
+import { ANALOG_KINDS, CLASSICAL_GATE_KINDS, COMPONENT_KINDS, DIODE_TYPES, GROUND_STYLES, PASSIVE_KINDS, SEMANTIC_COLORS, SCHEMATIC_SIGNAL_MARKERS, TRANSISTOR_TYPES, SchematicSyntaxError } from './types.js';
+import { validateDocumentGeometry } from './layout.js';
+import { MAX_SCHEMATIC_COMPONENTS, MAX_SCHEMATIC_CONNECTIONS, MAX_SCHEMATIC_SOURCE_CHARACTERS } from './limits.js';
+const COMPONENT_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*):([A-Za-z][A-Za-z0-9_-]*)\s+"([^"]+)"\s+at\s+\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)\s+(.+)$/;
+const CONNECTION_PATTERN = /^([A-Za-z][A-Za-z0-9_-]*)\.([A-Za-z][A-Za-z0-9_-]*)\s*->\s*([A-Za-z][A-Za-z0-9_-]*)\.([A-Za-z][A-Za-z0-9_-]*)\s+(.+)$/;
+const SCHEMD_FENCE_PATTERN = /^schemd\s+bounds="(\d+)x(\d+)"(?:\s+title="([^"]+)")?\s*$/i;
+const NUMBER_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)$/;
+const ANGLE_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:deg|grad|rad|turn)?$/i;
+const ALIAS_PATTERN = /^[a-z][a-z0-9-]{0,63}$/i;
+const PIN_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+const RESERVED_IC_PIN_NAMES = new Set(['in', 'out']);
+const MAX_IC_PINS_PER_SIDE = 64;
+const IC_MINIMUM_WIDTH = 88;
+const IC_MINIMUM_HEIGHT = 64;
+const IC_HORIZONTAL_PIN_SPACING = 22;
+const IC_VERTICAL_PIN_SPACING = 18;
+const IC_BODY_PADDING = 24;
+const MAX_FENCE_TITLE_LENGTH = 512;
+const parsedDocuments = new WeakSet();
+function freezeParsedDocument(document) {
+    for (const component of document.components) {
+        Object.freeze(component.color);
+        if (component.kind === 'ic') {
+            Object.freeze(component.pins.left);
+            Object.freeze(component.pins.right);
+            Object.freeze(component.pins.top);
+            Object.freeze(component.pins.bottom);
+            Object.freeze(component.pins);
+        }
+        Object.freeze(component);
+    }
+    for (const connection of document.connections) {
+        Object.freeze(connection.from);
+        Object.freeze(connection.to);
+        Object.freeze(connection.color);
+        Object.freeze(connection);
+    }
+    Object.freeze(document.components);
+    Object.freeze(document.connections);
+    Object.freeze(document);
+    parsedDocuments.add(document);
+    return document;
+}
+export function assertParsedSchematicDocument(document) {
+    if (!parsedDocuments.has(document)) {
+        throw new TypeError('renderSchematic requires an immutable document returned by parseSchematic.');
+    }
+}
+function includesValue(values, value) {
+    return values.includes(value);
+}
+function parseRangedNumber(value, minimum, maximum, allowPercent) {
+    const percent = allowPercent && value.endsWith('%');
+    const numeric = percent ? value.slice(0, -1) : value;
+    if (!NUMBER_PATTERN.test(numeric))
+        return false;
+    const parsed = Number(numeric);
+    return parsed >= minimum && parsed <= (percent ? 100 : maximum);
+}
+function parseAlpha(value) {
+    return parseRangedNumber(value, 0, 1, true);
+}
+function parseRgb(body) {
+    const commaSyntax = body.includes(',');
+    const slashParts = body.split('/').map((part) => part.trim());
+    if (slashParts.length > 2 || (commaSyntax && slashParts.length > 1))
+        return undefined;
+    const parsedChannels = commaSyntax
+        ? slashParts[0].split(',').map((part) => part.trim())
+        : slashParts[0].split(/\s+/);
+    const legacyAlpha = commaSyntax && parsedChannels.length === 4 ? parsedChannels[3] : undefined;
+    const rawChannels = legacyAlpha === undefined ? parsedChannels : parsedChannels.slice(0, 3);
+    const alpha = slashParts.at(1) ?? legacyAlpha;
+    if (rawChannels.length !== 3 ||
+        !rawChannels.every((channel) => parseRangedNumber(channel, 0, 255, true)) ||
+        (alpha !== undefined && !parseAlpha(alpha))) {
+        return undefined;
+    }
+    return `rgb(${rawChannels.join(' ')}${alpha === undefined ? '' : ` / ${alpha}`})`;
+}
+function parseHsl(body) {
+    const commaSyntax = body.includes(',');
+    const slashParts = body.split('/').map((part) => part.trim());
+    if (slashParts.length > 2 || (commaSyntax && slashParts.length > 1))
+        return undefined;
+    const parsedChannels = commaSyntax
+        ? slashParts[0].split(',').map((part) => part.trim())
+        : slashParts[0].split(/\s+/);
+    const legacyAlpha = commaSyntax && parsedChannels.length === 4 ? parsedChannels[3] : undefined;
+    const rawChannels = legacyAlpha === undefined ? parsedChannels : parsedChannels.slice(0, 3);
+    const alpha = slashParts.at(1) ?? legacyAlpha;
+    const [hue, saturation, lightness] = rawChannels;
+    if (rawChannels.length !== 3 ||
+        hue === undefined ||
+        !ANGLE_PATTERN.test(hue) ||
+        saturation === undefined ||
+        !saturation.endsWith('%') ||
+        !parseRangedNumber(saturation, 0, 100, true) ||
+        lightness === undefined ||
+        !lightness.endsWith('%') ||
+        !parseRangedNumber(lightness, 0, 100, true) ||
+        (alpha !== undefined && !parseAlpha(alpha))) {
+        return undefined;
+    }
+    return `hsl(${rawChannels.join(' ')}${alpha === undefined ? '' : ` / ${alpha}`})`;
+}
+export function parseSchematicColor(input, line = 1) {
+    const value = input.trim();
+    const tokenCandidate = (value.startsWith('#') ? value.slice(1) : value).toLowerCase();
+    if (includesValue(SEMANTIC_COLORS, tokenCandidate)) {
+        return { kind: 'token', value: tokenCandidate };
+    }
+    if (/^#[A-Fa-f0-9]+$/.test(value)) {
+        if (![4, 5, 7, 9].includes(value.length)) {
+            throw new SchematicSyntaxError('Hex colors require 3, 4, 6, or 8 digits.', line);
+        }
+        return { kind: 'css', value: value.toLowerCase() };
+    }
+    const functionMatch = value.match(/^(rgb|rgba|hsl|hsla)\((.*)\)$/i);
+    if (functionMatch) {
+        const functionName = functionMatch[1].toLowerCase();
+        const body = functionMatch[2];
+        const normalized = functionName.startsWith('rgb') ? parseRgb(body) : parseHsl(body);
+        if (!normalized) {
+            throw new SchematicSyntaxError(`Invalid ${functionName} color.`, line);
+        }
+        return { kind: 'css', value: normalized };
+    }
+    const alias = value.startsWith('#') ? value.slice(1) : value;
+    if (ALIAS_PATTERN.test(alias))
+        return { kind: 'alias', value: alias.toLowerCase() };
+    throw new SchematicSyntaxError('Unsafe or unsupported color expression.', line);
+}
+function parseAttributes(raw, line) {
+    const attributes = new Map();
+    if (raw === undefined)
+        return attributes;
+    if (raw.trim() === '')
+        throw new SchematicSyntaxError('Malformed component options.', line);
+    const source = raw.trim();
+    let cursor = 0;
+    while (cursor < source.length) {
+        if (cursor > 0) {
+            const separator = source.slice(cursor).match(/^\s+/);
+            if (!separator)
+                throw new SchematicSyntaxError('Malformed component options.', line);
+            cursor += separator[0].length;
+        }
+        const keyMatch = source.slice(cursor).match(/^([a-z][a-z0-9-]*)=/);
+        if (!keyMatch) {
+            throw new SchematicSyntaxError('Malformed component options.', line);
+        }
+        const key = keyMatch[1];
+        cursor += keyMatch[0].length;
+        let value;
+        if (source[cursor] === '"') {
+            const closingQuote = source.indexOf('"', cursor + 1);
+            value = source.slice(cursor + 1, closingQuote);
+            cursor = closingQuote + 1;
+        }
+        else {
+            const valueMatch = source.slice(cursor).match(/^[^\s]+/);
+            if (!valueMatch)
+                throw new SchematicSyntaxError('Malformed component options.', line);
+            value = valueMatch[0];
+            cursor += value.length;
+        }
+        if (attributes.has(key))
+            throw new SchematicSyntaxError(`Duplicate option ${key}.`, line);
+        attributes.set(key, value);
+    }
+    return attributes;
+}
+function assertOnlyAttributes(attributes, allowed, line) {
+    for (const key of attributes.keys()) {
+        if (!allowed.includes(key))
+            throw new SchematicSyntaxError(`Option ${key} is not supported.`, line);
+    }
+}
+function parseCount(value, fallback, name, line) {
+    if (value === undefined)
+        return fallback;
+    if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 32) {
+        throw new SchematicSyntaxError(`${name} must be an integer from 1 through 32.`, line);
+    }
+    return Number(value);
+}
+function splitDeclarationTail(raw, line, allowMissingColor = false) {
+    const source = raw.trim();
+    let quoteOpen = false;
+    let parentheses = 0;
+    let optionsStart = -1;
+    let optionsEnd = -1;
+    for (let index = 0; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === '"') {
+            quoteOpen = !quoteOpen;
+            continue;
+        }
+        if (quoteOpen)
+            continue;
+        if (character === '(') {
+            parentheses += 1;
+            continue;
+        }
+        if (character === ')') {
+            parentheses -= 1;
+            if (parentheses < 0)
+                throw new SchematicSyntaxError('Malformed declaration tail.', line);
+            continue;
+        }
+        if (character === '[' && parentheses === 0) {
+            if (optionsStart >= 0 || (index > 0 && !/\s/.test(source[index - 1]))) {
+                throw new SchematicSyntaxError('Malformed declaration options.', line);
+            }
+            optionsStart = index;
+            continue;
+        }
+        if (character === ']' && parentheses === 0) {
+            if (optionsStart < 0 || optionsEnd >= 0) {
+                throw new SchematicSyntaxError('Malformed declaration options.', line);
+            }
+            optionsEnd = index;
+        }
+    }
+    if (quoteOpen || parentheses !== 0) {
+        throw new SchematicSyntaxError('Malformed declaration tail.', line);
+    }
+    if (optionsStart < 0) {
+        return { color: source, options: undefined };
+    }
+    if (optionsEnd < optionsStart || source.slice(optionsEnd + 1).trim() !== '') {
+        throw new SchematicSyntaxError('Malformed declaration options.', line);
+    }
+    const color = source.slice(0, optionsStart).trim();
+    if (color === '' && !allowMissingColor) {
+        throw new SchematicSyntaxError('A declaration color is required.', line);
+    }
+    return { color, options: source.slice(optionsStart + 1, optionsEnd) };
+}
+function parseEnumOption(value, fallback, values, name, line) {
+    if (value === undefined)
+        return fallback;
+    if (!includesValue(values, value)) {
+        throw new SchematicSyntaxError(`${name} must be one of: ${values.join(', ')}.`, line);
+    }
+    return value;
+}
+function parseIcPins(attributes, line) {
+    const registered = new Set();
+    const parseSide = (side) => {
+        const source = attributes.get(side);
+        if (source === undefined || source.trim() === '')
+            return [];
+        const pins = source.split(',').map((pin) => pin.trim());
+        if (pins.length > MAX_IC_PINS_PER_SIDE) {
+            throw new SchematicSyntaxError(`${side} supports at most ${MAX_IC_PINS_PER_SIDE} IC pins.`, line);
+        }
+        for (const pin of pins) {
+            if (!PIN_NAME_PATTERN.test(pin)) {
+                throw new SchematicSyntaxError(`Invalid IC pin name ${pin || '(empty)'}.`, line);
+            }
+            if (RESERVED_IC_PIN_NAMES.has(pin)) {
+                throw new SchematicSyntaxError(`IC pin ${pin} collides with the reserved ${pin} alias. Use ${pin}1 or another pin name.`, line);
+            }
+            if (registered.has(pin)) {
+                throw new SchematicSyntaxError(`Duplicate IC pin ${pin}.`, line);
+            }
+            registered.add(pin);
+        }
+        return pins;
+    };
+    const pins = {
+        left: parseSide('left'),
+        right: parseSide('right'),
+        top: parseSide('top'),
+        bottom: parseSide('bottom')
+    };
+    if (registered.size === 0) {
+        throw new SchematicSyntaxError('An IC must declare at least one pin.', line);
+    }
+    return pins;
+}
+function integratedCircuitDimensions(pins) {
+    return {
+        bodyWidth: Math.max(IC_MINIMUM_WIDTH, Math.max(pins.top.length, pins.bottom.length) * IC_HORIZONTAL_PIN_SPACING + IC_BODY_PADDING),
+        bodyHeight: Math.max(IC_MINIMUM_HEIGHT, Math.max(pins.left.length, pins.right.length) * IC_VERTICAL_PIN_SPACING + IC_BODY_PADDING)
+    };
+}
+function commonComponent(match, color, line) {
+    return {
+        id: match[2],
+        label: match[3],
+        x: Number(match[4]),
+        y: Number(match[5]),
+        color: parseSchematicColor(color, line),
+        line
+    };
+}
+function parseComponent(match, line) {
+    const rawKind = match[1].toLowerCase();
+    if (!includesValue(COMPONENT_KINDS, rawKind)) {
+        throw new SchematicSyntaxError(`Unsupported component kind ${match[1]}.`, line);
+    }
+    const kind = rawKind;
+    const tail = splitDeclarationTail(match[6], line, kind === 'ic');
+    const attributes = parseAttributes(tail.options, line);
+    const common = commonComponent(match, tail.color === '' ? 'slate' : tail.color, line);
+    if (includesValue(PASSIVE_KINDS, kind)) {
+        assertOnlyAttributes(attributes, [], line);
+        return { kind, ...common };
+    }
+    if (includesValue(ANALOG_KINDS, kind)) {
+        switch (kind) {
+            case 'diode':
+                assertOnlyAttributes(attributes, ['type'], line);
+                return {
+                    kind,
+                    ...common,
+                    diodeType: parseEnumOption(attributes.get('type'), 'standard', DIODE_TYPES, 'type', line)
+                };
+            case 'transistor':
+                assertOnlyAttributes(attributes, ['type'], line);
+                return {
+                    kind,
+                    ...common,
+                    transistorType: parseEnumOption(attributes.get('type'), 'npn', TRANSISTOR_TYPES, 'type', line)
+                };
+            case 'port':
+                assertOnlyAttributes(attributes, [], line);
+                return { kind, ...common };
+            case 'ground':
+                assertOnlyAttributes(attributes, ['style'], line);
+                return {
+                    kind,
+                    ...common,
+                    groundStyle: parseEnumOption(attributes.get('style'), 'signal', GROUND_STYLES, 'style', line)
+                };
+        }
+    }
+    if (includesValue(CLASSICAL_GATE_KINDS, kind)) {
+        assertOnlyAttributes(attributes, ['inputs', 'outputs', 'standard'], line);
+        const standard = attributes.get('standard') ?? 'ieee';
+        if (standard !== 'ieee' && standard !== 'iec') {
+            throw new SchematicSyntaxError('standard must be ieee or iec.', line);
+        }
+        return {
+            kind,
+            ...common,
+            inputs: parseCount(attributes.get('inputs'), kind === 'not' ? 1 : 2, 'inputs', line),
+            outputs: parseCount(attributes.get('outputs'), 1, 'outputs', line),
+            standard
+        };
+    }
+    if (kind === 'ic') {
+        assertOnlyAttributes(attributes, ['left', 'right', 'top', 'bottom'], line);
+        const pins = parseIcPins(attributes, line);
+        return {
+            kind,
+            ...common,
+            pins,
+            ...integratedCircuitDimensions(pins)
+        };
+    }
+    const quantumKind = kind;
+    assertOnlyAttributes(attributes, quantumKind === 'qgate' ? ['parameter', 'matrix', 'phase'] : [], line);
+    const component = { kind: quantumKind, ...common };
+    const parameter = attributes.get('parameter');
+    const matrix = attributes.get('matrix');
+    const phase = attributes.get('phase');
+    if (parameter !== undefined)
+        component.parameter = parameter;
+    if (matrix !== undefined)
+        component.matrix = matrix;
+    if (phase !== undefined)
+        component.phase = phase;
+    return component;
+}
+function parseEndpoint(componentId, port) {
+    return { componentId, port };
+}
+function parseSignalMarker(value, option, line) {
+    if (!includesValue(SCHEMATIC_SIGNAL_MARKERS, value)) {
+        throw new SchematicSyntaxError(`${option} must be one of: ${SCHEMATIC_SIGNAL_MARKERS.join(', ')}.`, line);
+    }
+    return value;
+}
+function parseConnectionOptions(raw, line) {
+    let curve = 'line';
+    let markerStart = 'none';
+    let markerEnd = 'none';
+    if (raw === undefined || raw.trim() === '')
+        return { curve, markerStart, markerEnd };
+    const seen = new Set();
+    for (const token of raw.trim().split(/\s+/)) {
+        if (token === 'line' || token === 'bezier' || token === 'ortho') {
+            if (seen.has('curve')) {
+                throw new SchematicSyntaxError('Connection routing can only be declared once.', line);
+            }
+            curve = token;
+            seen.add('curve');
+            continue;
+        }
+        if (token === 'arrow' || token === 'dot') {
+            if (seen.has('marker-end')) {
+                throw new SchematicSyntaxError('Connection marker-end can only be declared once.', line);
+            }
+            markerEnd = token;
+            seen.add('marker-end');
+            continue;
+        }
+        const match = token.match(/^(marker-start|marker-end)=(\S+)$/);
+        if (!match) {
+            throw new SchematicSyntaxError('Connection routing options support line, bezier, ortho, arrow, dot, marker-start, and marker-end.', line);
+        }
+        const option = match[1];
+        if (seen.has(option)) {
+            throw new SchematicSyntaxError(`Connection ${option} can only be declared once.`, line);
+        }
+        const marker = parseSignalMarker(match[2], option, line);
+        if (option === 'marker-start')
+            markerStart = marker;
+        else
+            markerEnd = marker;
+        seen.add(option);
+    }
+    return { curve, markerStart, markerEnd };
+}
+function parseConnection(match, line) {
+    const tail = splitDeclarationTail(match[5], line);
+    const options = parseConnectionOptions(tail.options, line);
+    return {
+        from: parseEndpoint(match[1], match[2]),
+        to: parseEndpoint(match[3], match[4]),
+        color: parseSchematicColor(tail.color, line),
+        curve: options.curve,
+        markerStart: options.markerStart,
+        markerEnd: options.markerEnd,
+        line
+    };
+}
+function validateComponent(component, fence) {
+    if (component.x < 0 ||
+        component.x > fence.bounds.width ||
+        component.y < 0 ||
+        component.y > fence.bounds.height) {
+        throw new SchematicSyntaxError(`${component.id} is outside the declared ${fence.bounds.width}x${fence.bounds.height} bounds.`, component.line);
+    }
+}
+function validGatePort(component, port) {
+    if (port === 'in' || port === 'out')
+        return true;
+    const match = port.match(/^(in|out)([1-9]\d*)$/);
+    if (!match)
+        return false;
+    const index = Number(match[2]);
+    return match[1] === 'in'
+        ? index <= component.inputs && index >= 1
+        : index <= component.outputs && index >= 1;
+}
+function isClassicalGate(component) {
+    return CLASSICAL_GATE_KINDS.includes(component.kind);
+}
+function validIcPort(component, port) {
+    const sides = Object.values(component.pins);
+    if (port === 'in') {
+        return (sides.some((pins) => pins.includes('in1')) ||
+            component.pins.left.length > 0 ||
+            component.pins.top.length > 0);
+    }
+    if (port === 'out') {
+        return (sides.some((pins) => pins.includes('out1')) ||
+            component.pins.right.length > 0 ||
+            component.pins.bottom.length > 0);
+    }
+    return sides.some((pins) => pins.includes(port));
+}
+function validateEndpoint(endpoint, components, line) {
+    const component = components.get(endpoint.componentId);
+    if (!component)
+        throw new SchematicSyntaxError(`Unknown component ${endpoint.componentId}.`, line);
+    let valid;
+    if (isClassicalGate(component)) {
+        valid = validGatePort(component, endpoint.port);
+    }
+    else {
+        switch (component.kind) {
+            case 'resistor':
+            case 'capacitor':
+            case 'inductor':
+                valid = ['in', 'out', 'left', 'right', 'l', 'r'].includes(endpoint.port);
+                break;
+            case 'diode':
+                valid = ['anode', 'a', 'cathode', 'k', 'c'].includes(endpoint.port);
+                break;
+            case 'transistor':
+                valid = [
+                    'base',
+                    'gate',
+                    'b',
+                    'g',
+                    'collector',
+                    'drain',
+                    'c',
+                    'd',
+                    'emitter',
+                    'source',
+                    'e',
+                    's'
+                ].includes(endpoint.port);
+                break;
+            case 'port':
+            case 'hadamard':
+            case 'qgate':
+                valid = endpoint.port === 'in' || endpoint.port === 'out';
+                break;
+            case 'ground':
+                valid = endpoint.port === 'in';
+                break;
+            case 'cnot':
+                valid = ['in', 'out', 'control', 'target'].includes(endpoint.port);
+                break;
+            case 'ic':
+                valid = validIcPort(component, endpoint.port);
+                break;
+        }
+    }
+    if (!valid) {
+        throw new SchematicSyntaxError(`Port ${endpoint.componentId}.${endpoint.port} is invalid for ${component.kind}.`, line);
+    }
+}
+export function parseSchematicFence(info, defaultTitle = 'Engineering schematic') {
+    if (info === undefined || !/^schemd(?:\s|$)/i.test(info.trim())) {
+        return undefined;
+    }
+    const match = info.trim().match(SCHEMD_FENCE_PATTERN);
+    if (!match) {
+        throw new SchematicSyntaxError('schemd fences require: schemd bounds="WIDTHxHEIGHT" title="Optional title".');
+    }
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (width < 64 || height < 64 || width > 4096 || height > 4096) {
+        throw new SchematicSyntaxError('Schematic bounds must be integers from 64 through 4096.');
+    }
+    const title = match[3] ?? defaultTitle;
+    if (title.length > MAX_FENCE_TITLE_LENGTH) {
+        throw new SchematicSyntaxError('Schematic titles cannot exceed 512 characters.');
+    }
+    return { bounds: { width, height }, title };
+}
+export function parseSchematic(source, fence) {
+    if (source.length > MAX_SCHEMATIC_SOURCE_CHARACTERS) {
+        throw new SchematicSyntaxError('Schematic source exceeds the 131,072 character limit.');
+    }
+    const components = [];
+    const connections = [];
+    const componentIds = new Set();
+    for (const [lineIndex, rawLine] of source.replace(/\r\n?/g, '\n').split('\n').entries()) {
+        const line = rawLine.trim();
+        if (line === '' || line.startsWith('//'))
+            continue;
+        const lineNumber = lineIndex + 1;
+        const componentMatch = line.match(COMPONENT_PATTERN);
+        if (componentMatch) {
+            if (components.length >= MAX_SCHEMATIC_COMPONENTS) {
+                throw new SchematicSyntaxError('Schematic exceeds the 512 component limit.', lineNumber);
+            }
+            const component = parseComponent(componentMatch, lineNumber);
+            if (componentIds.has(component.id)) {
+                throw new SchematicSyntaxError(`Duplicate component ID ${component.id}.`, lineNumber);
+            }
+            validateComponent(component, fence);
+            componentIds.add(component.id);
+            components.push(component);
+            continue;
+        }
+        const connectionMatch = line.match(CONNECTION_PATTERN);
+        if (connectionMatch) {
+            if (connections.length >= MAX_SCHEMATIC_CONNECTIONS) {
+                throw new SchematicSyntaxError('Schematic exceeds the 2,048 connection limit.', lineNumber);
+            }
+            connections.push(parseConnection(connectionMatch, lineNumber));
+            continue;
+        }
+        throw new SchematicSyntaxError('Unrecognized schematic declaration.', lineNumber);
+    }
+    if (components.length === 0) {
+        throw new SchematicSyntaxError('A schematic must declare at least one component.');
+    }
+    const componentsById = new Map(components.map((component) => [component.id, component]));
+    for (const connection of connections) {
+        validateEndpoint(connection.from, componentsById, connection.line);
+        validateEndpoint(connection.to, componentsById, connection.line);
+    }
+    const document = { components, connections };
+    validateDocumentGeometry(document, fence);
+    return freezeParsedDocument(document);
+}

package/dist/renderer.d.ts

@@ -0,0 +1,44 @@
+import { type CompileSchematicOptions, type SchematicDocument } from './types.js';
+/**
+ * Legacy alias for the hard SVG allocation ceiling.
+ *
+ * @deprecated Prefer the root-exported `MAX_SCHEMATIC_SVG_OUTPUT_BYTES`.
+ */
+export declare const MAX_SVG_OUTPUT_BYTES = 2097152;
+/**
+ * Append-only SVG sink that enforces the compiler's UTF-8 output ceiling.
+ *
+ * The writer tracks encoded byte cost incrementally without allocating an
+ * intermediate `TextEncoder` buffer. Chunks are joined only after successful
+ * completion, so partial oversized output is never returned.
+ */
+export declare class BoundedSvgWriter {
+    #private;
+    /**
+     * Add one trusted SVG fragment within the hard output budget.
+     *
+     * @param chunk - Compiler-generated markup fragment.
+     * @throws {SchematicSyntaxError} When the aggregate UTF-8 size exceeds the limit.
+     */
+    append(chunk: string): void;
+    /**
+     * Join all accepted fragments into the final SVG figure.
+     *
+     * @returns Complete trusted markup in append order.
+     */
+    finish(): string;
+}
+/**
+ * Render a validated schematic AST as a bounded, accessible inline SVG figure.
+ *
+ * Geometry is revalidated against the supplied bounds before serialization.
+ * `default` compounds paths with no embedded styles, `embedded-css` adds theme
+ * and hover visuals, and `full` emits per-node event delegation attributes.
+ *
+ * @param document - Immutable AST returned by `parseSchematic` in this module instance.
+ * @param options - Intrinsic bounds, title, optional ID namespace, and output mode.
+ * @returns Complete trusted `<figure>` markup containing an inline SVG.
+ * @throws {TypeError} When `document` lacks parser provenance.
+ * @throws {SchematicSyntaxError} For invalid options, geometry, or output-budget overflow.
+ */
+export declare function renderSchematic(document: SchematicDocument, options: CompileSchematicOptions): string;