@schemd/core 0.1.0

package/dist/layout.js

@@ -0,0 +1,592 @@
+import { CLASSICAL_GATE_KINDS, SchematicSyntaxError } from './types.js';
+import { mathLabelGlyphLength } from './math-label.js';
+export const PORT_HOTSPOT_RADIUS = 4;
+export const SCHEMATIC_OBSTACLE_CLEARANCE = 12;
+export const SCHEMATIC_BRIDGE_RADIUS = 5;
+const MAX_OBSTACLE_PASSES = 16;
+const CROSSING_BUCKET_SIZE = 64;
+const DESIGNATOR_BASELINE_GAP = 10;
+const LABEL_BASELINE_GAP = 19;
+const TEXT_ASCENT_GUTTER = 12;
+const TEXT_DESCENT_GUTTER = 5;
+const TEXT_ADVANCE = 7;
+const TEXT_HORIZONTAL_GUTTER = 4;
+const PASSIVE_INPUT_PORTS = new Set(['in', 'left', 'l']);
+const PASSIVE_OUTPUT_PORTS = new Set(['out', 'right', 'r']);
+const DIODE_ANODE_PORTS = new Set(['anode', 'a']);
+const DIODE_CATHODE_PORTS = new Set(['cathode', 'k', 'c']);
+const TRANSISTOR_CONTROL_PORTS = new Set(['base', 'gate', 'b', 'g']);
+const TRANSISTOR_UPPER_PORTS = new Set(['collector', 'drain', 'c', 'd']);
+const TRANSISTOR_LOWER_PORTS = new Set(['emitter', 'source', 'e', 's']);
+function formatNumber(value) {
+    const rounded = Math.abs(value) < 0.0005 ? 0 : Number(value.toFixed(3));
+    return String(rounded);
+}
+export function distributedCoordinate(index, count, span) {
+    return ((index + 1) * span) / (count + 1) - span / 2;
+}
+export function classicalGateHeight(component) {
+    return Math.max(48, Math.max(component.inputs, component.outputs) * 16);
+}
+function isClassicalGate(component) {
+    return CLASSICAL_GATE_KINDS.includes(component.kind);
+}
+function indexedPortPoint(component, port) {
+    const output = port.startsWith('out');
+    const count = output ? component.outputs : component.inputs;
+    const suffix = port.match(/\d+$/)?.[0];
+    const index = suffix === undefined ? 0 : Number(suffix) - 1;
+    return {
+        x: component.x + (output ? 48 : -48),
+        y: component.y + distributedCoordinate(index, count, classicalGateHeight(component))
+    };
+}
+export function positionIcPin(component, side, index) {
+    const pins = component.pins[side];
+    if (!Number.isInteger(index) || index < 0 || index >= pins.length) {
+        throw new RangeError(`IC pin index ${index} is outside ${component.id}.${side}.`);
+    }
+    if (side === 'left' || side === 'right') {
+        return {
+            x: component.x +
+                (side === 'left' ? -component.bodyWidth / 2 - 16 : component.bodyWidth / 2 + 16),
+            y: component.y + distributedCoordinate(index, pins.length, component.bodyHeight)
+        };
+    }
+    return {
+        x: component.x + distributedCoordinate(index, pins.length, component.bodyWidth),
+        y: component.y +
+            (side === 'top' ? -component.bodyHeight / 2 - 16 : component.bodyHeight / 2 + 16)
+    };
+}
+function findIcPin(component, port) {
+    const sides = ['left', 'right', 'top', 'bottom'];
+    for (const side of sides) {
+        const index = component.pins[side].indexOf(port);
+        if (index >= 0)
+            return positionIcPin(component, side, index);
+    }
+    return undefined;
+}
+function icPinPoint(component, port) {
+    if (port === 'in' || port === 'out') {
+        const canonical = findIcPin(component, `${port}1`);
+        if (canonical !== undefined)
+            return canonical;
+        const aliasSides = port === 'in' ? ['left', 'top'] : ['right', 'bottom'];
+        for (const side of aliasSides) {
+            if (component.pins[side].length > 0)
+                return positionIcPin(component, side, 0);
+        }
+        return undefined;
+    }
+    return findIcPin(component, port);
+}
+export function resolvePortPoint(component, port) {
+    if (isClassicalGate(component))
+        return indexedPortPoint(component, port);
+    const left = { x: component.x - 42, y: component.y };
+    const right = { x: component.x + 42, y: component.y };
+    switch (component.kind) {
+        case 'resistor':
+        case 'capacitor':
+        case 'inductor':
+            if (PASSIVE_INPUT_PORTS.has(port))
+                return left;
+            if (PASSIVE_OUTPUT_PORTS.has(port))
+                return right;
+            break;
+        case 'diode':
+            if (DIODE_ANODE_PORTS.has(port))
+                return left;
+            if (DIODE_CATHODE_PORTS.has(port))
+                return right;
+            break;
+        case 'transistor':
+            if (TRANSISTOR_CONTROL_PORTS.has(port))
+                return left;
+            if (TRANSISTOR_UPPER_PORTS.has(port)) {
+                return { x: component.x + 42, y: component.y - 22 };
+            }
+            if (TRANSISTOR_LOWER_PORTS.has(port)) {
+                return { x: component.x + 42, y: component.y + 22 };
+            }
+            break;
+        case 'port':
+            if (port === 'in')
+                return left;
+            if (port === 'out')
+                return right;
+            break;
+        case 'ground':
+            if (port === 'in')
+                return { x: component.x, y: component.y - 42 };
+            break;
+        case 'hadamard':
+        case 'qgate':
+            if (port === 'in')
+                return { x: component.x - 48, y: component.y };
+            if (port === 'out')
+                return { x: component.x + 48, y: component.y };
+            break;
+        case 'cnot':
+            if (port === 'in')
+                return left;
+            if (port === 'out')
+                return right;
+            if (port === 'control')
+                return { x: component.x, y: component.y - 16 };
+            if (port === 'target')
+                return { x: component.x, y: component.y + 16 };
+            break;
+        case 'ic': {
+            const point = icPinPoint(component, port);
+            if (point !== undefined)
+                return point;
+            break;
+        }
+    }
+    throw new Error(`Validated port ${component.id}.${port} is missing.`);
+}
+function namedPort(component, id) {
+    return { id, point: resolvePortPoint(component, id) };
+}
+export function enumerateComponentPorts(component) {
+    if (isClassicalGate(component)) {
+        return [
+            ...Array.from({ length: component.inputs }, (_, index) => namedPort(component, `in${index + 1}`)),
+            ...Array.from({ length: component.outputs }, (_, index) => namedPort(component, `out${index + 1}`))
+        ];
+    }
+    switch (component.kind) {
+        case 'resistor':
+        case 'capacitor':
+        case 'inductor':
+        case 'port':
+        case 'hadamard':
+        case 'qgate':
+            return [namedPort(component, 'in'), namedPort(component, 'out')];
+        case 'diode':
+            return [namedPort(component, 'anode'), namedPort(component, 'cathode')];
+        case 'transistor': {
+            const bipolar = component.transistorType === 'npn' || component.transistorType === 'pnp';
+            return bipolar
+                ? [
+                    namedPort(component, 'base'),
+                    namedPort(component, 'collector'),
+                    namedPort(component, 'emitter')
+                ]
+                : [
+                    namedPort(component, 'gate'),
+                    namedPort(component, 'drain'),
+                    namedPort(component, 'source')
+                ];
+        }
+        case 'ground':
+            return [namedPort(component, 'in')];
+        case 'cnot':
+            return [
+                namedPort(component, 'in'),
+                namedPort(component, 'out'),
+                namedPort(component, 'control'),
+                namedPort(component, 'target')
+            ];
+        case 'ic': {
+            const sides = ['left', 'right', 'top', 'bottom'];
+            return sides.flatMap((side) => component.pins[side].map((id, index) => ({
+                id,
+                point: positionIcPin(component, side, index)
+            })));
+        }
+    }
+}
+function endpointPoint(endpoint, components) {
+    const component = components.get(endpoint.componentId);
+    if (component === undefined) {
+        throw new Error(`Validated component ${endpoint.componentId} is missing.`);
+    }
+    return resolvePortPoint(component, endpoint.port);
+}
+function samePoint(left, right) {
+    return Math.abs(left.x - right.x) < 0.0005 && Math.abs(left.y - right.y) < 0.0005;
+}
+function compactOrthogonalPoints(points) {
+    const deduplicated = [];
+    for (const point of points) {
+        if (!samePoint(deduplicated.at(-1) ?? { x: Number.NaN, y: Number.NaN }, point)) {
+            deduplicated.push(point);
+        }
+    }
+    let index = 1;
+    while (index < deduplicated.length - 1) {
+        const previous = deduplicated[index - 1];
+        const current = deduplicated[index];
+        const next = deduplicated[index + 1];
+        if ((previous.x === current.x && current.x === next.x) ||
+            (previous.y === current.y && current.y === next.y)) {
+            deduplicated.splice(index, 1);
+            continue;
+        }
+        index += 1;
+    }
+    return deduplicated;
+}
+function orthogonalPath(points) {
+    const first = points[0];
+    let path = `M ${formatNumber(first.x)} ${formatNumber(first.y)}`;
+    for (let index = 1; index < points.length; index += 1) {
+        const previous = points[index - 1];
+        const point = points[index];
+        if (previous.y === point.y)
+            path += ` H ${formatNumber(point.x)}`;
+        else
+            path += ` V ${formatNumber(point.y)}`;
+    }
+    return path;
+}
+function expandedComponentRectangle(component, clearance) {
+    const { halfWidth, halfHeight } = componentHalfExtents(component);
+    return {
+        minX: component.x - halfWidth - clearance,
+        minY: component.y - halfHeight - clearance,
+        maxX: component.x + halfWidth + clearance,
+        maxY: component.y + halfHeight + clearance
+    };
+}
+export function componentObstacleRectangle(component, clearance = SCHEMATIC_OBSTACLE_CLEARANCE) {
+    if (!Number.isFinite(clearance) || clearance < 0) {
+        throw new RangeError('Component obstacle clearance must be a finite non-negative number.');
+    }
+    return expandedComponentRectangle(component, clearance);
+}
+function segmentIntersectsRectangle(start, end, rectangle) {
+    if (start.y === end.y) {
+        return (start.y > rectangle.minY &&
+            start.y < rectangle.maxY &&
+            Math.max(start.x, end.x) > rectangle.minX &&
+            Math.min(start.x, end.x) < rectangle.maxX);
+    }
+    return (start.x > rectangle.minX &&
+        start.x < rectangle.maxX &&
+        Math.max(start.y, end.y) > rectangle.minY &&
+        Math.min(start.y, end.y) < rectangle.maxY);
+}
+function candidateCollisionCount(points, obstacles) {
+    let collisions = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        for (const obstacle of obstacles) {
+            if (segmentIntersectsRectangle(points[index - 1], points[index], obstacle))
+                collisions += 1;
+        }
+    }
+    return collisions;
+}
+function candidateLength(points) {
+    let length = 0;
+    for (let index = 1; index < points.length; index += 1) {
+        length +=
+            Math.abs(points[index].x - points[index - 1].x) +
+                Math.abs(points[index].y - points[index - 1].y);
+    }
+    return length;
+}
+function detourRoute(routeStart, routeEnd, obstacle, obstacles) {
+    const candidates = [
+        [
+            routeStart,
+            { x: routeStart.x, y: obstacle.minY },
+            { x: routeEnd.x, y: obstacle.minY },
+            routeEnd
+        ],
+        [
+            routeStart,
+            { x: routeStart.x, y: obstacle.maxY },
+            { x: routeEnd.x, y: obstacle.maxY },
+            routeEnd
+        ],
+        [
+            routeStart,
+            { x: obstacle.minX, y: routeStart.y },
+            { x: obstacle.minX, y: routeEnd.y },
+            routeEnd
+        ],
+        [
+            routeStart,
+            { x: obstacle.maxX, y: routeStart.y },
+            { x: obstacle.maxX, y: routeEnd.y },
+            routeEnd
+        ]
+    ];
+    return [...candidates].sort((left, right) => {
+        const collisionDifference = candidateCollisionCount(left, obstacles) - candidateCollisionCount(right, obstacles);
+        if (collisionDifference !== 0)
+            return collisionDifference;
+        return candidateLength(left) - candidateLength(right);
+    })[0];
+}
+function avoidComponentObstacles(points, obstacles) {
+    let routed = compactOrthogonalPoints(points);
+    for (let pass = 0; pass < MAX_OBSTACLE_PASSES; pass += 1) {
+        let collision;
+        for (let segmentIndex = 1; segmentIndex < routed.length && collision === undefined; segmentIndex += 1) {
+            for (const obstacle of obstacles) {
+                if (segmentIntersectsRectangle(routed[segmentIndex - 1], routed[segmentIndex], obstacle)) {
+                    collision = { segmentIndex, obstacle };
+                    break;
+                }
+            }
+        }
+        if (collision === undefined)
+            break;
+        routed = compactOrthogonalPoints(detourRoute(routed[0], routed.at(-1), collision.obstacle, obstacles));
+    }
+    return routed;
+}
+export function routeConnection(connection, components) {
+    const start = endpointPoint(connection.from, components);
+    const end = endpointPoint(connection.to, components);
+    const sx = formatNumber(start.x);
+    const sy = formatNumber(start.y);
+    const ex = formatNumber(end.x);
+    const ey = formatNumber(end.y);
+    if (connection.curve === 'bezier') {
+        const middleX = (start.x + end.x) / 2;
+        const controlA = { x: middleX, y: start.y };
+        const controlB = { x: middleX, y: end.y };
+        return {
+            d: `M ${sx} ${sy} C ${formatNumber(controlA.x)} ${formatNumber(controlA.y)}, ${formatNumber(controlB.x)} ${formatNumber(controlB.y)}, ${ex} ${ey}`,
+            points: [start, controlA, controlB, end]
+        };
+    }
+    if (connection.curve === 'ortho') {
+        const middleX = (start.x + end.x) / 2;
+        const cornerA = { x: middleX, y: start.y };
+        const cornerB = { x: middleX, y: end.y };
+        const obstacles = Array.from(components.values())
+            .filter((component) => component.id !== connection.from.componentId && component.id !== connection.to.componentId)
+            .map((component) => componentObstacleRectangle(component));
+        const points = avoidComponentObstacles([start, cornerA, cornerB, end], obstacles);
+        return {
+            d: orthogonalPath(points),
+            points: points
+        };
+    }
+    return { d: `M ${sx} ${sy} L ${ex} ${ey}`, points: [start, end] };
+}
+function axisSegments(route, routeIndex) {
+    const segments = [];
+    for (let index = 1; index < route.points.length; index += 1) {
+        const start = route.points[index - 1];
+        const end = route.points[index];
+        if (start.x === end.x && start.y !== end.y) {
+            segments.push({ routeIndex, segmentIndex: index - 1, start, end, orientation: 'vertical' });
+        }
+        else if (start.y === end.y && start.x !== end.x) {
+            segments.push({ routeIndex, segmentIndex: index - 1, start, end, orientation: 'horizontal' });
+        }
+    }
+    return segments;
+}
+function segmentBucketKeys(segment) {
+    const minX = Math.floor(Math.min(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+    const maxX = Math.floor(Math.max(segment.start.x, segment.end.x) / CROSSING_BUCKET_SIZE);
+    const minY = Math.floor(Math.min(segment.start.y, segment.end.y) / CROSSING_BUCKET_SIZE);
+    const maxY = Math.floor(Math.max(segment.start.y, segment.end.y) / CROSSING_BUCKET_SIZE);
+    const keys = [];
+    for (let x = minX; x <= maxX; x += 1) {
+        for (let y = minY; y <= maxY; y += 1)
+            keys.push(`${x}:${y}`);
+    }
+    return keys;
+}
+function segmentCrossing(left, right) {
+    if (left.orientation === right.orientation)
+        return undefined;
+    const horizontal = left.orientation === 'horizontal' ? left : right;
+    const vertical = left.orientation === 'vertical' ? left : right;
+    const point = { x: vertical.start.x, y: horizontal.start.y };
+    if (point.x <= Math.min(horizontal.start.x, horizontal.end.x) ||
+        point.x >= Math.max(horizontal.start.x, horizontal.end.x) ||
+        point.y <= Math.min(vertical.start.y, vertical.end.y) ||
+        point.y >= Math.max(vertical.start.y, vertical.end.y)) {
+        return undefined;
+    }
+    return point;
+}
+function bridgedOrthogonalPath(route, crossings) {
+    if (crossings.size === 0)
+        return route;
+    const first = route.points[0];
+    let path = `M ${formatNumber(first.x)} ${formatNumber(first.y)}`;
+    const boundsPoints = [...route.points];
+    for (let index = 1; index < route.points.length; index += 1) {
+        const start = route.points[index - 1];
+        const end = route.points[index];
+        const segmentCrossings = [...(crossings.get(index - 1) ?? [])];
+        const horizontal = start.y === end.y;
+        const direction = Math.sign(horizontal ? end.x - start.x : end.y - start.y);
+        const coordinate = horizontal ? 'x' : 'y';
+        segmentCrossings.sort((left, right) => direction * (left[coordinate] - right[coordinate]));
+        if (horizontal) {
+            for (const crossing of segmentCrossings) {
+                const before = crossing.x - direction * SCHEMATIC_BRIDGE_RADIUS;
+                const after = crossing.x + direction * SCHEMATIC_BRIDGE_RADIUS;
+                path += ` H ${formatNumber(before)} A ${SCHEMATIC_BRIDGE_RADIUS} ${SCHEMATIC_BRIDGE_RADIUS} 0 0 ${direction > 0 ? 1 : 0} ${formatNumber(after)} ${formatNumber(crossing.y)}`;
+                boundsPoints.push({ x: crossing.x, y: crossing.y - SCHEMATIC_BRIDGE_RADIUS });
+            }
+            path += ` H ${formatNumber(end.x)}`;
+        }
+        else {
+            for (const crossing of segmentCrossings) {
+                const before = crossing.y - direction * SCHEMATIC_BRIDGE_RADIUS;
+                const after = crossing.y + direction * SCHEMATIC_BRIDGE_RADIUS;
+                path += ` V ${formatNumber(before)} A ${SCHEMATIC_BRIDGE_RADIUS} ${SCHEMATIC_BRIDGE_RADIUS} 0 0 ${direction > 0 ? 0 : 1} ${formatNumber(crossing.x)} ${formatNumber(after)}`;
+                boundsPoints.push({ x: crossing.x + SCHEMATIC_BRIDGE_RADIUS, y: crossing.y });
+            }
+            path += ` V ${formatNumber(end.y)}`;
+        }
+    }
+    return {
+        d: path,
+        points: boundsPoints
+    };
+}
+export function routeConnections(connections, components) {
+    const routes = connections.map((connection) => routeConnection(connection, components));
+    const buckets = new Map();
+    const crossingsByRoute = new Map();
+    for (let routeIndex = 0; routeIndex < routes.length; routeIndex += 1) {
+        const route = routes[routeIndex];
+        for (const segment of axisSegments(route, routeIndex)) {
+            const visited = new Set();
+            for (const key of segmentBucketKeys(segment)) {
+                for (const previous of buckets.get(key) ?? []) {
+                    const identity = `${previous.routeIndex}:${previous.segmentIndex}`;
+                    if (visited.has(identity))
+                        continue;
+                    visited.add(identity);
+                    const crossing = segmentCrossing(segment, previous);
+                    if (crossing === undefined)
+                        continue;
+                    let routeCrossings = crossingsByRoute.get(routeIndex);
+                    if (routeCrossings === undefined) {
+                        routeCrossings = new Map();
+                        crossingsByRoute.set(routeIndex, routeCrossings);
+                    }
+                    const points = routeCrossings.get(segment.segmentIndex) ?? [];
+                    if (!points.some((point) => samePoint(point, crossing)))
+                        points.push(crossing);
+                    routeCrossings.set(segment.segmentIndex, points);
+                }
+            }
+        }
+        for (const segment of axisSegments(route, routeIndex)) {
+            for (const key of segmentBucketKeys(segment)) {
+                const bucket = buckets.get(key) ?? [];
+                bucket.push(segment);
+                buckets.set(key, bucket);
+            }
+        }
+    }
+    return routes.map((route, index) => bridgedOrthogonalPath(route, crossingsByRoute.get(index) ?? new Map()));
+}
+function componentHalfExtents(component) {
+    let halfWidth;
+    let halfHeight;
+    if (isClassicalGate(component)) {
+        halfWidth = 48;
+        halfHeight = classicalGateHeight(component) / 2;
+    }
+    else {
+        switch (component.kind) {
+            case 'resistor':
+            case 'capacitor':
+            case 'inductor':
+                halfWidth = 42;
+                halfHeight = 18;
+                break;
+            case 'diode':
+                halfWidth = 42;
+                halfHeight = component.diodeType === 'led' ? 30 : 20;
+                break;
+            case 'transistor':
+                halfWidth = 42;
+                halfHeight = 38;
+                break;
+            case 'port':
+                halfWidth = 42;
+                halfHeight = 18;
+                break;
+            case 'ground':
+                halfWidth = 22;
+                halfHeight = 42;
+                break;
+            case 'hadamard':
+            case 'qgate':
+                halfWidth = 48;
+                halfHeight = 30;
+                break;
+            case 'cnot':
+                halfWidth = 42;
+                halfHeight = 26;
+                break;
+            case 'ic':
+                halfWidth = component.bodyWidth / 2 + 16;
+                halfHeight = component.bodyHeight / 2 + 16;
+                break;
+        }
+    }
+    return { halfWidth, halfHeight };
+}
+export function componentTextAnchors(component) {
+    const { halfHeight } = componentHalfExtents(component);
+    return {
+        designatorY: -halfHeight - DESIGNATOR_BASELINE_GAP,
+        labelY: halfHeight + LABEL_BASELINE_GAP,
+        designatorWidth: Array.from(component.id).length * TEXT_ADVANCE,
+        labelWidth: mathLabelGlyphLength(component.label) * TEXT_ADVANCE
+    };
+}
+export function componentRectangle(component) {
+    const { halfWidth } = componentHalfExtents(component);
+    const anchors = componentTextAnchors(component);
+    const textHalfWidth = Math.max(anchors.designatorWidth, anchors.labelWidth) / 2 + TEXT_HORIZONTAL_GUTTER;
+    const boundedHalfWidth = Math.max(halfWidth, textHalfWidth);
+    const rectangle = {
+        minX: component.x - boundedHalfWidth,
+        minY: component.y + anchors.designatorY - TEXT_ASCENT_GUTTER,
+        maxX: component.x + boundedHalfWidth,
+        maxY: component.y + anchors.labelY + TEXT_DESCENT_GUTTER
+    };
+    for (const port of enumerateComponentPorts(component)) {
+        rectangle.minX = Math.min(rectangle.minX, port.point.x - PORT_HOTSPOT_RADIUS);
+        rectangle.minY = Math.min(rectangle.minY, port.point.y - PORT_HOTSPOT_RADIUS);
+        rectangle.maxX = Math.max(rectangle.maxX, port.point.x + PORT_HOTSPOT_RADIUS);
+        rectangle.maxY = Math.max(rectangle.maxY, port.point.y + PORT_HOTSPOT_RADIUS);
+    }
+    return rectangle;
+}
+function rectangleInsideBounds(rectangle, bounds) {
+    return (rectangle.minX >= 0 &&
+        rectangle.minY >= 0 &&
+        rectangle.maxX <= bounds.width &&
+        rectangle.maxY <= bounds.height);
+}
+function pointInsideBounds(point, bounds) {
+    return point.x >= 0 && point.y >= 0 && point.x <= bounds.width && point.y <= bounds.height;
+}
+export function validateDocumentGeometry(document, fence) {
+    for (const component of document.components) {
+        if (!rectangleInsideBounds(componentRectangle(component), fence.bounds)) {
+            throw new SchematicSyntaxError(`${component.id} geometry exceeds the declared ${fence.bounds.width}x${fence.bounds.height} bounds.`, component.line);
+        }
+    }
+    const components = new Map(document.components.map((component) => [component.id, component]));
+    const routedConnections = routeConnections(document.connections, components);
+    for (const [index, connection] of document.connections.entries()) {
+        const routed = routedConnections[index];
+        if (!routed.points.every((point) => pointInsideBounds(point, fence.bounds))) {
+            throw new SchematicSyntaxError('Connection trace exceeds the declared schematic bounds.', connection.line);
+        }
+    }
+}

package/dist/limits.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hard compiler budgets shared by the parser, renderer, and Marked integration.
+ *
+ * `parseSchematic` and `renderSchematic` enforce these limits for one diagram.
+ * `schematicMarkedExtension` additionally enforces them cumulatively across all
+ * schematic fences encountered during one Marked document pass.
+ *
+ * @packageDocumentation
+ */
+/** Maximum UTF-16 source characters accepted in one compilation pass. */
+export declare const MAX_SCHEMATIC_SOURCE_CHARACTERS = 131072;
+/** Maximum component declarations accepted in one document. */
+export declare const MAX_SCHEMATIC_COMPONENTS = 512;
+/** Maximum directed connections accepted in one document. */
+export declare const MAX_SCHEMATIC_CONNECTIONS = 2048;
+/** Maximum UTF-8 bytes the bounded SVG writer may emit. */
+export declare const MAX_SCHEMATIC_SVG_OUTPUT_BYTES = 2097152;
+/** Frozen runtime-readable form of every compiler allocation ceiling. */
+export declare const SCHEMATIC_LIMITS: Readonly<{
+    sourceCharacters: 131072;
+    components: 512;
+    connections: 2048;
+    svgOutputBytes: 2097152;
+}>;
+/**
+ * Return the exact UTF-8 byte length without allocating an encoded copy.
+ *
+ * @param value - JavaScript string whose encoded output cost is required.
+ * @returns Number of UTF-8 bytes, including four-byte astral code points.
+ */
+export declare function utf8ByteLength(value: string): number;

package/dist/limits.js

@@ -0,0 +1,25 @@
+export const MAX_SCHEMATIC_SOURCE_CHARACTERS = 131_072;
+export const MAX_SCHEMATIC_COMPONENTS = 512;
+export const MAX_SCHEMATIC_CONNECTIONS = 2_048;
+export const MAX_SCHEMATIC_SVG_OUTPUT_BYTES = 2_097_152;
+export const SCHEMATIC_LIMITS = Object.freeze({
+    sourceCharacters: MAX_SCHEMATIC_SOURCE_CHARACTERS,
+    components: MAX_SCHEMATIC_COMPONENTS,
+    connections: MAX_SCHEMATIC_CONNECTIONS,
+    svgOutputBytes: MAX_SCHEMATIC_SVG_OUTPUT_BYTES
+});
+export function utf8ByteLength(value) {
+    let bytes = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x7f)
+            bytes += 1;
+        else if (codePoint <= 0x7ff)
+            bytes += 2;
+        else if (codePoint <= 0xffff)
+            bytes += 3;
+        else
+            bytes += 4;
+    }
+    return bytes;
+}

package/dist/marked-extension.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Type-only Marked adapter for compiling fenced `schemd` diagrams during SSR.
+ *
+ * The module imports no Marked runtime. Its factory returns ordinary extension
+ * hooks to a host-owned parser and enforces both per-diagram compiler ceilings
+ * and cumulative limits across each Markdown document pass.
+ *
+ * @packageDocumentation
+ */
+import type { MarkedExtension } from 'marked';
+import { type SchematicMarkedOptions } from './types.js';
+/**
+ * Create a bounded Marked extension that compiles `schemd` fences into inline SVG.
+ *
+ * The returned extension keeps aggregate per-document budgets in closure state,
+ * resets them from Marked's `preprocess` hook, and recognizes only the canonical
+ * `schemd` language identifier.
+ *
+ * @param options - Output mode, accessible-title fallback, dynamic mode resolver,
+ *   and trusted server-side diagnostic renderer.
+ * @returns A Marked extension suitable for a server-owned `Marked` instance.
+ */
+export declare function schematicMarkedExtension(options?: SchematicMarkedOptions): MarkedExtension;