altium-toolkit 1.1.2 → 1.1.22

package/src/ui/SchematicSvgRenderer.mjs

@@ -12,12 +12,15 @@ import { SchematicDirectiveRenderer } from './SchematicDirectiveRenderer.mjs'
 import { SchematicShapeRenderer } from './SchematicShapeRenderer.mjs'
 import { SchematicPinSvgRenderer } from './SchematicPinSvgRenderer.mjs'
 import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+import { SchematicLineColorResolver } from './SchematicLineColorResolver.mjs'
 import { SchematicSheetChromeRenderer } from './SchematicSheetChromeRenderer.mjs'
 import { SchematicContentLayout } from './SchematicContentLayout.mjs'
 import { SchematicOwnerPinLabelLayout } from './SchematicOwnerPinLabelLayout.mjs'
 import { SchematicRegionRenderer } from './SchematicRegionRenderer.mjs'
 import { SchematicSheetSymbolRenderer } from './SchematicSheetSymbolRenderer.mjs'
 import { SchematicImageRenderer } from './SchematicImageRenderer.mjs'
+import { SchematicNativeFooterPartitioner } from './SchematicNativeFooterPartitioner.mjs'
+import { SchematicOwnerPinMarkerLineThemer } from './SchematicOwnerPinMarkerLineThemer.mjs'
 import { TextGeometrySidecarBuilder } from './TextGeometrySidecarBuilder.mjs'
 import { SchematicRenderOpsSidecarBuilder } from './SchematicRenderOpsSidecarBuilder.mjs'
 import { SchematicProjectParameterResolver } from '../core/altium/SchematicProjectParameterResolver.mjs'
@@ -28,6 +31,11 @@ const SECTION_HEADING_MIN_FONT_SIZE = 18
 const SECTION_HEADING_BASELINE_LIFT_RATIO = 0.36
 const SECTION_HEADING_LINE_Y_TOLERANCE = 0.75
 const SECTION_HEADING_LINE_X_PADDING = 15
+const BODY_TEXT_ASCENT_RATIO = 0.72
+const BODY_TEXT_DESCENT_RATIO = 0.14
+const BODY_TEXT_FLAT_DESCENT_RATIO = 0
+const BODY_TEXT_MIN_SEPARATOR_SPAN_RATIO = 0.3
+const BODY_TEXT_DESCENDER_PATTERN = /[gjpqyQ_,;]/
 
 /**
  * Renders normalized schematic models into presentational SVG.
@@ -38,7 +46,7 @@ export class SchematicSvgRenderer {
     /**
      * Renders a normalized schematic model into SVG markup.
      * @param {{ fileName?: string, summary: { title?: string }, schematic?: { sheet: { width: number, height: number, sourceWidth?: number, sourceHeight?: number, paperSize?: string, borderOn?: boolean, titleBlockOn?: boolean, marginWidth?: number, xZones?: number, yZones?: number, titleBlock?: { title?: string, revision?: string, documentNumber?: string, sheetNumber?: string, sheetTotal?: string, date?: string, drawnBy?: string } }, lines: { x1: number, y1: number, x2: number, y2: number, color: string, width: number, lineStyle?: number, isBus?: boolean, ownerIndex?: string, renderOrder?: number, recordType?: string }[], polygons?: { points: { x: number, y: number }[], color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], rectangles?: { x: number, y: number, width: number, height: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], regions?: { x: number, y: number, width: number, height: number, color: string, fill: string, renderOrder?: number }[], ellipses?: { x: number, y: number, radiusX: number, radiusY: number, color: string, fill: string, isSolid: boolean, transparent: boolean, lineWidth: number, ownerIndex?: string, renderOrder?: number }[], arcs?: { x: number, y: number, radius: number, startAngle: number, endAngle: number, color: string, width: number, ownerIndex?: string, renderOrder?: number }[], directives?: { x: number, y: number, color: string, name: string, orientation?: number }[], texts: { x: number, y: number, text: string, color: string, recordType?: string, style?: number, fontSize?: number, fontFamily?: string, fontWeight?: number, fontStyle?: string, rotation?: number, sourceOrientation?: number, isMirrored?: boolean, anchor?: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }[], components: { x: number, y: number, designator: string }[], pins?: { x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor?: string, labelMode?: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex?: string }[], ports?: { x: number, y: number, width: number, height: number, name: string, fill: string, color: string, direction?: 'left' | 'right' | 'up' | 'down', shape?: 'single' | 'double' | 'plain' }[], crosses?: { x: number, y: number, size: number, color: string }[] } }} documentModel
-     * @param {{ projectParameters?: Record<string, string | number | boolean | null | undefined> }} options Render options.
+     * @param {{ projectParameters?: Record<string, string | number | boolean | null | undefined>, colorizeImages?: boolean, colorize_images?: boolean }} options Render options.
      * @returns {string}
      */
     static render(documentModel, options = {}) {
@@ -66,7 +74,9 @@ export class SchematicSvgRenderer {
             renderedSheet.contentSheet === schematic.sheet
                 ? schematic
                 : { ...schematic, sheet: renderedSheet.contentSheet }
-        const allTexts = schematic.texts || []
+        const allTexts = SchematicSvgRenderer.#filterDrawableSchematicTexts(
+            schematic.texts || []
+        )
         const lines = (schematic.lines || []).slice(0, 2500)
         const polygons = (schematic.polygons || []).slice(0, 1000)
         const rectangles = (schematic.rectangles || []).slice(0, 500)
@@ -146,25 +156,6 @@ export class SchematicSvgRenderer {
             renderedSchematic,
             contentClipId
         )
-        const ownerlessLines = lines.filter((line) => !line.ownerIndex)
-        const ownerlessPolygons = polygons.filter(
-            (polygon) => !polygon.ownerIndex
-        )
-        const ownerlessRectangles = rectangles.filter(
-            (rectangle) => !rectangle.ownerIndex
-        )
-        const ownerlessRoundedRectangles = roundedRectangles.filter(
-            (rectangle) => !rectangle.ownerIndex
-        )
-        const ownerlessEllipses = ellipses.filter(
-            (ellipse) => !ellipse.ownerIndex
-        )
-        const ownerlessArcs = arcs.filter((arc) => !arc.ownerIndex)
-        const ownerlessBeziers = beziers.filter((bezier) => !bezier.ownerIndex)
-        const ownerlessPies = pies.filter((pie) => !pie.ownerIndex)
-        const ownerlessIeeeSymbols = ieeeSymbols.filter(
-            (symbol) => !symbol.ownerIndex
-        )
         const resolvedTexts = texts.map((text) =>
             text.recordType === '17'
                 ? {
@@ -178,6 +169,77 @@ export class SchematicSvgRenderer {
                   }
                 : text
         )
+        const partitionedPrimitives =
+            SchematicNativeFooterPartitioner.partitionPrimitives(
+                {
+                    lines,
+                    polygons,
+                    rectangles,
+                    roundedRectangles,
+                    ellipses,
+                    arcs,
+                    beziers,
+                    pies,
+                    ieeeSymbols,
+                    texts: resolvedTexts,
+                    images
+                },
+                renderedSchematic.sheet
+            )
+        const contentMarkerThemedLines =
+            SchematicOwnerPinMarkerLineThemer.theme(
+                partitionedPrimitives.content.lines,
+                pins
+            )
+        const contentLines = SchematicSvgRenderer.#themeFooterChromeLines(
+            contentMarkerThemedLines,
+            renderedSheet.sheet,
+            contentHeight
+        )
+        const contentPolygons = partitionedPrimitives.content.polygons
+        const contentRectangles = partitionedPrimitives.content.rectangles
+        const contentRoundedRectangles =
+            partitionedPrimitives.content.roundedRectangles
+        const contentEllipses = partitionedPrimitives.content.ellipses
+        const contentArcs = partitionedPrimitives.content.arcs
+        const contentBeziers = partitionedPrimitives.content.beziers
+        const contentPies = partitionedPrimitives.content.pies
+        const contentIeeeSymbols = partitionedPrimitives.content.ieeeSymbols
+        const contentTexts = partitionedPrimitives.content.texts
+        const contentImages = partitionedPrimitives.content.images
+        const footerPrimitives = partitionedPrimitives.footer
+        const foregroundOwnerlessLines =
+            SchematicSvgRenderer.#collectForegroundOwnerlessLines(
+                contentLines,
+                contentPolygons,
+                contentRectangles,
+                contentRoundedRectangles,
+                contentEllipses,
+                contentPies
+            )
+        const ownerlessLines = contentLines.filter(
+            (line) => !line.ownerIndex && !foregroundOwnerlessLines.has(line)
+        )
+        const ownerlessPolygons = contentPolygons.filter(
+            (polygon) => !polygon.ownerIndex
+        )
+        const ownerlessRectangles = contentRectangles.filter(
+            (rectangle) => !rectangle.ownerIndex
+        )
+        const ownerlessRoundedRectangles = contentRoundedRectangles.filter(
+            (rectangle) => !rectangle.ownerIndex
+        )
+        const ownerlessEllipses = contentEllipses.filter(
+            (ellipse) => !ellipse.ownerIndex
+        )
+        const ownerlessArcs = contentArcs.filter((arc) => !arc.ownerIndex)
+        const ownerlessBeziers = contentBeziers.filter(
+            (bezier) => !bezier.ownerIndex
+        )
+        const ownerlessPies = contentPies.filter((pie) => !pie.ownerIndex)
+        const ownerlessIeeeSymbols = contentIeeeSymbols.filter(
+            (symbol) => !symbol.ownerIndex
+        )
         const polygonMarkup = ownerlessPolygons
             .map((polygon, index) =>
                 SchematicSvgRenderer.#appendSvgAttributes(
@@ -357,18 +419,33 @@ export class SchematicSvgRenderer {
             .join('')
         const ownerGeometryMarkup =
             SchematicSvgRenderer.#buildOwnerGeometryMarkup(
-                lines,
-                polygons,
-                rectangles,
-                roundedRectangles,
-                ellipses,
-                arcs,
-                beziers,
-                pies,
-                ieeeSymbols,
+                contentLines,
+                contentPolygons,
+                contentRectangles,
+                contentRoundedRectangles,
+                contentEllipses,
+                contentArcs,
+                contentBeziers,
+                contentPies,
+                contentIeeeSymbols,
                 contentHeight,
                 semanticContext
             )
+        const foregroundLineMarkup = [...foregroundOwnerlessLines]
+            .map((line, index) =>
+                SchematicSvgRenderer.#buildSchematicLineMarkup(
+                    line,
+                    contentHeight,
+                    SchematicSvgRenderer.#primitiveIndex(
+                        semanticContext,
+                        'lines',
+                        line,
+                        index
+                    ),
+                    semanticContext
+                )
+            )
+            .join('')
         const sheetSymbolMarkup =
             SchematicSheetSymbolRenderer.buildSheetSymbolMarkup(
                 sheetSymbols,
@@ -390,7 +467,7 @@ export class SchematicSvgRenderer {
         const resolvedAuthoredJunctions =
             SchematicSvgRenderer.#resolveAuthoredSchematicJunctions(
                 authoredJunctions,
-                lines
+                contentLines
             )
         const authoredJunctionMarkup = resolvedAuthoredJunctions
             .map((junction) =>
@@ -401,18 +478,85 @@ export class SchematicSvgRenderer {
             )
             .join('')
         const imageMarkup = SchematicImageRenderer.buildMarkup(
-            images,
-            contentHeight
+            contentImages,
+            contentHeight,
+            {
+                colorizeImages: renderOptions.colorizeImages,
+                title:
+                    renderModel?.summary?.title ||
+                    renderedSchematic?.sheet?.titleBlock?.title ||
+                    renderModel?.fileName ||
+                    ''
+            }
         )
         const markerDefsMarkup =
-            SchematicSvgRenderer.#buildSchematicLineMarkerDefs(lines)
+            SchematicSvgRenderer.#buildSchematicLineMarkerDefs(contentLines)
+        const ownerTextBodyBounds =
+            SchematicSvgRenderer.#collectOwnerTextBodyBounds(
+                contentLines,
+                contentPolygons,
+                contentRectangles,
+                contentRoundedRectangles,
+                contentEllipses,
+                contentArcs,
+                contentPies
+            )
 
-        const textMarkup = resolvedTexts
+        const textMarkup = contentTexts
             .map((text, index) =>
                 SchematicSvgRenderer.#buildSchematicTextMarkup(
                     text,
                     contentHeight,
-                    lines,
+                    contentLines,
+                    pins,
+                    SchematicSvgRenderer.#primitiveIndex(
+                        semanticContext,
+                        'texts',
+                        text,
+                        index
+                    ),
+                    semanticContext,
+                    ownerTextBodyBounds
+                )
+            )
+            .join('')
+        const nativeFooterLines = SchematicSvgRenderer.#themeFooterChromeLines(
+            footerPrimitives.lines,
+            renderedSheet.sheet,
+            contentHeight
+        )
+        const nativeFooterOwnerGeometryMarkup =
+            SchematicSvgRenderer.#buildOwnerGeometryMarkup(
+                nativeFooterLines,
+                footerPrimitives.polygons,
+                footerPrimitives.rectangles,
+                footerPrimitives.roundedRectangles,
+                footerPrimitives.ellipses,
+                footerPrimitives.arcs,
+                footerPrimitives.beziers,
+                footerPrimitives.pies,
+                footerPrimitives.ieeeSymbols,
+                contentHeight,
+                semanticContext
+            )
+        const nativeFooterImageMarkup = SchematicImageRenderer.buildMarkup(
+            footerPrimitives.images,
+            contentHeight,
+            {
+                colorizeImages: renderOptions.colorizeImages,
+                title:
+                    renderModel?.summary?.title ||
+                    renderedSchematic?.sheet?.titleBlock?.title ||
+                    renderModel?.fileName ||
+                    ''
+            }
+        )
+        const nativeFooterTextMarkup = footerPrimitives.texts
+            .map((text, index) =>
+                SchematicSvgRenderer.#buildSchematicTextMarkup(
+                    text,
+                    contentHeight,
+                    contentLines,
                     pins,
                     SchematicSvgRenderer.#primitiveIndex(
                         semanticContext,
@@ -424,6 +568,36 @@ export class SchematicSvgRenderer {
                 )
             )
             .join('')
+        const nativeFooterMargin = Math.max(
+            Number(renderedSchematic?.sheet?.marginWidth || 20),
+            10
+        )
+        const nativeFooterOffsetX = partitionedPrimitives.footerBounds
+            ? Math.max(
+                  width -
+                      nativeFooterMargin -
+                      partitionedPrimitives.footerBounds.maxX,
+                  0
+              )
+            : 0
+        const nativeFooterTransform =
+            nativeFooterOffsetX > 0.01
+                ? ' transform="translate(' +
+                  formatNumber(nativeFooterOffsetX) +
+                  ' 0)"'
+                : ''
+        const nativeFooterMarkup =
+            nativeFooterOwnerGeometryMarkup ||
+            nativeFooterImageMarkup ||
+            nativeFooterTextMarkup
+                ? '<g class="schematic-native-footer" stroke-linecap="round"' +
+                  nativeFooterTransform +
+                  '>' +
+                  nativeFooterOwnerGeometryMarkup +
+                  nativeFooterImageMarkup +
+                  nativeFooterTextMarkup +
+                  '</g>'
+                : ''
 
         const componentMarkup = drawableComponents
             .map((component, index) =>
@@ -451,6 +625,21 @@ export class SchematicSvgRenderer {
                 texts,
                 pins
             )
+        const compactExternalNumberLabelSides =
+            SchematicOwnerPinLabelLayout.collectCompactExternalNumberLabelSides(
+                pins
+            )
+        const internalNumberLabelBoxes =
+            SchematicOwnerPinLabelLayout.collectInternalNumberLabelBoxes(
+                pins,
+                contentRectangles
+            )
+        const overlappingExternalNumberLabelKeys =
+            SchematicOwnerPinLabelLayout.collectOverlappingExternalNumberLabelKeys(
+                pins,
+                contentTexts,
+                internalNumberLabelBoxes
+            )
         const pinMarkup = pins
             .map((pin, index) =>
                 SchematicSvgRenderer.#appendSvgAttributes(
@@ -460,7 +649,10 @@ export class SchematicSvgRenderer {
                         renderedSheet.contentSheet,
                         rotatedVerticalNumberOwners,
                         explicitOwnerPinNameLabels,
-                        explicitOwnerPinLabelOffsets
+                        explicitOwnerPinLabelOffsets,
+                        compactExternalNumberLabelSides,
+                        internalNumberLabelBoxes,
+                        overlappingExternalNumberLabelKeys
                     ),
                     SchematicSvgRenderer.#semanticAttributes(
                         'pin',
@@ -504,10 +696,10 @@ export class SchematicSvgRenderer {
             )
             .join('')
         const junctionMarkup = SchematicJunctionRenderer.buildMarkup(
-            lines,
+            contentLines,
             crosses,
             ports,
-            resolvedTexts.filter((text) => text.recordType === '17'),
+            contentTexts.filter((text) => text.recordType === '17'),
             contentHeight,
             resolvedAuthoredJunctions
         )
@@ -590,6 +782,9 @@ export class SchematicSvgRenderer {
             '<g class="schematic-owner-geometry" stroke-linecap="round">' +
             ownerGeometryMarkup +
             '</g>' +
+            '<g class="schematic-foreground-lines" stroke-linecap="round">' +
+            foregroundLineMarkup +
+            '</g>' +
             '<g class="schematic-sheet-symbols">' +
             sheetSymbolMarkup +
             '</g>' +
@@ -626,6 +821,7 @@ export class SchematicSvgRenderer {
             '</g>' +
             '</g>' +
             frameMarkup +
+            nativeFooterMarkup +
             '<g class="schematic-regions">' +
             regionMarkup +
             '</g>' +
@@ -636,7 +832,7 @@ export class SchematicSvgRenderer {
     /**
      * Normalizes schematic SVG export options.
      * @param {Record<string, unknown>} options Raw render options.
-     * @returns {{ includeViewBox: boolean, documentId: string, documentVersion: string, includeTextGeometrySidecar: boolean, includeRenderOperationsSidecar: boolean, renderOperationProfile: string }}
+     * @returns {{ includeViewBox: boolean, documentId: string, documentVersion: string, colorizeImages: boolean, includeTextGeometrySidecar: boolean, includeRenderOperationsSidecar: boolean, renderOperationProfile: string }}
      */
     static #normalizeRenderOptions(options) {
         const includeViewBox =
@@ -648,6 +844,9 @@ export class SchematicSvgRenderer {
             documentVersion: String(
                 options?.documentVersion || options?.documentVer || ''
             ),
+            colorizeImages:
+                options?.colorizeImages === true ||
+                options?.colorize_images === true,
             includeTextGeometrySidecar:
                 options?.includeTextGeometrySidecar === true ||
                 options?.textGeometry === 'sidecar',
@@ -660,6 +859,106 @@ export class SchematicSvgRenderer {
         }
     }
 
+    /**
+     * Removes unresolved simple Altium special-string placeholders from
+     * drawable text while preserving values resolved by project parameters.
+     * @param {object[]} texts Schematic text rows.
+     * @returns {object[]}
+     */
+    static #filterDrawableSchematicTexts(texts) {
+        return (texts || []).filter(
+            (text) =>
+                !SchematicSvgRenderer.#isUnresolvedSimpleSpecialStringText(text)
+        )
+    }
+
+    /**
+     * Uses sheet-frame chrome color for native footer linework so recovered
+     * template cells match the synthesized frame and zone separators.
+     * @param {object[]} lines Schematic line primitives.
+     * @param {{ width?: number, borderOn?: boolean, marginWidth?: number }} sheet Sheet metadata.
+     * @param {number} sheetHeight Rendered sheet height for projection.
+     * @returns {object[]}
+     */
+    static #themeFooterChromeLines(lines, sheet, sheetHeight) {
+        return (lines || []).map((line) =>
+            SchematicSvgRenderer.#isFooterChromeLine(line, sheet, sheetHeight)
+                ? {
+                      ...line,
+                      color: 'var(--schematic-sheet-frame-stroke)'
+                  }
+                : line
+        )
+    }
+
+    /**
+     * Returns true for neutral owner-drawn title-block lines in the bottom
+     * right footer band.
+     * @param {{ x1?: number, y1?: number, x2?: number, y2?: number, color?: string, ownerIndex?: string }} line Schematic line candidate.
+     * @param {{ width?: number, borderOn?: boolean, marginWidth?: number }} sheet Sheet metadata.
+     * @param {number} sheetHeight Rendered sheet height for projection.
+     * @returns {boolean}
+     */
+    static #isFooterChromeLine(line, sheet, sheetHeight) {
+        if (!sheet?.borderOn || !String(line?.ownerIndex || '').trim()) {
+            return false
+        }
+        if (
+            SchematicColorResolver.resolveColor(
+                line.color,
+                '--schematic-default-ink-color'
+            ) !== 'var(--schematic-text-color)'
+        ) {
+            return false
+        }
+
+        const width = Number(sheet?.width || 0)
+        const height = Number(sheetHeight || 0)
+        const x1 = Number(line?.x1)
+        const x2 = Number(line?.x2)
+        const y1 = Number(line?.y1)
+        const y2 = Number(line?.y2)
+
+        if (
+            !Number.isFinite(width) ||
+            !Number.isFinite(height) ||
+            !Number.isFinite(x1) ||
+            !Number.isFinite(x2) ||
+            !Number.isFinite(y1) ||
+            !Number.isFinite(y2) ||
+            width <= 0 ||
+            height <= 0
+        ) {
+            return false
+        }
+
+        const margin = Math.max(Number(sheet?.marginWidth || 20), 10)
+        const lineLength = Math.hypot(x2 - x1, y2 - y1)
+        const minChromeLineLength = Math.max(margin * 0.6, 12)
+
+        if (lineLength < minChromeLineLength) {
+            return false
+        }
+
+        const footerBandHeight = Math.max(margin * 6, 120)
+        const footerTop = Math.max(height - footerBandHeight, margin)
+        const projectedY1 = projectSchematicY(height, y1)
+        const projectedY2 = projectSchematicY(height, y2)
+        const minProjectedY = Math.min(projectedY1, projectedY2)
+        const maxX = Math.max(x1, x2)
+
+        return minProjectedY >= footerTop && maxX >= width * 0.5
+    }
+
+    /**
+     * Returns true when a text row still contains one bare special string.
+     * @param {object} text Schematic text row.
+     * @returns {boolean}
+     */
+    static #isUnresolvedSimpleSpecialStringText(text) {
+        return /^[.=][A-Za-z_][\w.-]*$/u.test(String(text?.text || '').trim())
+    }
+
     /**
      * Renders root SVG viewBox attributes according to export options.
      * @param {{ includeViewBox: boolean }} options Normalized options.
@@ -1560,6 +1859,311 @@ export class SchematicSvgRenderer {
         return height + margin * 2
     }
 
+    /**
+     * Collects ownerless line primitives that were authored after an
+     * owner-linked fill they overlap. These are symbol decoration strokes
+     * stored outside the owner group and must paint above the body fill.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x1: number, y1: number, x2: number, y2: number }[]} lines Line primitives.
+     * @param {{ ownerIndex?: string, renderOrder?: number, points?: { x: number, y: number }[] }[]} polygons Polygon primitives.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x: number, y: number, width: number, height: number }[]} rectangles Rectangle primitives.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x: number, y: number, width: number, height: number }[]} roundedRectangles Rounded rectangle primitives.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x: number, y: number, radiusX: number, radiusY: number }[]} ellipses Ellipse primitives.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x: number, y: number, radius: number, radiusY?: number }[]} pies Pie primitives.
+     * @returns {Set<object>}
+     */
+    static #collectForegroundOwnerlessLines(
+        lines,
+        polygons,
+        rectangles,
+        roundedRectangles,
+        ellipses,
+        pies
+    ) {
+        const ownerFillBounds = SchematicSvgRenderer.#collectOwnerFillBounds(
+            polygons,
+            rectangles,
+            roundedRectangles,
+            ellipses,
+            pies
+        )
+
+        if (!ownerFillBounds.length) {
+            return new Set()
+        }
+
+        return new Set(
+            (lines || []).filter((line) =>
+                SchematicSvgRenderer.#isForegroundOwnerlessLine(
+                    line,
+                    ownerFillBounds
+                )
+            )
+        )
+    }
+
+    /**
+     * Collects sortable bounds for owner-linked fill primitives.
+     * @param {object[]} polygons Polygon primitives.
+     * @param {object[]} rectangles Rectangle primitives.
+     * @param {object[]} roundedRectangles Rounded rectangle primitives.
+     * @param {object[]} ellipses Ellipse primitives.
+     * @param {object[]} pies Pie primitives.
+     * @returns {{ bounds: { minX: number, minY: number, maxX: number, maxY: number }, renderOrder: number }[]}
+     */
+    static #collectOwnerFillBounds(
+        polygons,
+        rectangles,
+        roundedRectangles,
+        ellipses,
+        pies
+    ) {
+        return [
+            ...(polygons || []),
+            ...(rectangles || []),
+            ...(roundedRectangles || []),
+            ...(ellipses || []),
+            ...(pies || [])
+        ]
+            .filter((primitive) => primitive?.ownerIndex)
+            .map((primitive) => ({
+                bounds: SchematicSvgRenderer.#primitiveBounds(primitive),
+                renderOrder:
+                    SchematicSvgRenderer.#resolvePrimitiveRenderOrder(primitive)
+            }))
+            .filter(
+                (entry) =>
+                    entry.bounds &&
+                    Number.isFinite(entry.renderOrder) &&
+                    entry.renderOrder < Number.MAX_SAFE_INTEGER
+            )
+    }
+
+    /**
+     * Collects unprojected owner body envelopes used to identify text that is
+     * drawn inside a component body instead of on surrounding wires or sheet
+     * chrome.
+     * @param {object[]} lines Line primitives.
+     * @param {object[]} polygons Polygon primitives.
+     * @param {object[]} rectangles Rectangle primitives.
+     * @param {object[]} roundedRectangles Rounded rectangle primitives.
+     * @param {object[]} ellipses Ellipse primitives.
+     * @param {object[]} arcs Arc primitives.
+     * @param {object[]} pies Pie primitives.
+     * @returns {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>}
+     */
+    static #collectOwnerTextBodyBounds(
+        lines,
+        polygons,
+        rectangles,
+        roundedRectangles,
+        ellipses,
+        arcs,
+        pies
+    ) {
+        const ownerBounds = new Map()
+
+        for (const primitive of [
+            ...(lines || []),
+            ...(polygons || []),
+            ...(rectangles || []),
+            ...(roundedRectangles || []),
+            ...(ellipses || []),
+            ...(arcs || []),
+            ...(pies || [])
+        ]) {
+            SchematicSvgRenderer.#extendOwnerTextBodyBounds(
+                ownerBounds,
+                primitive
+            )
+        }
+
+        return ownerBounds
+    }
+
+    /**
+     * Extends the body-bounds map with one owner-linked primitive.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerBounds Owner bounds map.
+     * @param {object} primitive Primitive candidate.
+     * @returns {void}
+     */
+    static #extendOwnerTextBodyBounds(ownerBounds, primitive) {
+        const ownerIndex = String(primitive?.ownerIndex || '').trim()
+        const bounds = SchematicSvgRenderer.#primitiveBounds(primitive)
+
+        if (!ownerIndex || !bounds) {
+            return
+        }
+
+        const current = ownerBounds.get(ownerIndex)
+
+        if (!current) {
+            ownerBounds.set(ownerIndex, { ...bounds })
+            return
+        }
+
+        current.minX = Math.min(current.minX, bounds.minX)
+        current.minY = Math.min(current.minY, bounds.minY)
+        current.maxX = Math.max(current.maxX, bounds.maxX)
+        current.maxY = Math.max(current.maxY, bounds.maxY)
+    }
+
+    /**
+     * Returns true when one ownerless line should paint above an overlapping
+     * owner fill because the native stream authored it later.
+     * @param {{ ownerIndex?: string, renderOrder?: number, x1: number, y1: number, x2: number, y2: number }} line Line primitive.
+     * @param {{ bounds: { minX: number, minY: number, maxX: number, maxY: number }, renderOrder: number }[]} ownerFillBounds Fill bounds.
+     * @returns {boolean}
+     */
+    static #isForegroundOwnerlessLine(line, ownerFillBounds) {
+        if (line?.ownerIndex) {
+            return false
+        }
+
+        const renderOrder = Number(line?.renderOrder)
+        if (!Number.isFinite(renderOrder)) {
+            return false
+        }
+
+        const lineBounds = SchematicSvgRenderer.#primitiveBounds(line)
+        if (!lineBounds) {
+            return false
+        }
+
+        return ownerFillBounds.some(
+            (fill) =>
+                renderOrder > fill.renderOrder &&
+                SchematicSvgRenderer.#boundsIntersect(
+                    lineBounds,
+                    fill.bounds,
+                    0.5
+                )
+        )
+    }
+
+    /**
+     * Resolves an unprojected coordinate envelope for one schematic primitive.
+     * @param {object} primitive Primitive.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #primitiveBounds(primitive) {
+        if (Array.isArray(primitive?.points) && primitive.points.length > 0) {
+            return SchematicSvgRenderer.#pointBounds(primitive.points)
+        }
+
+        if (
+            Number.isFinite(Number(primitive?.x1)) &&
+            Number.isFinite(Number(primitive?.y1)) &&
+            Number.isFinite(Number(primitive?.x2)) &&
+            Number.isFinite(Number(primitive?.y2))
+        ) {
+            return SchematicSvgRenderer.#pointBounds([
+                { x: Number(primitive.x1), y: Number(primitive.y1) },
+                { x: Number(primitive.x2), y: Number(primitive.y2) }
+            ])
+        }
+
+        if (
+            Number.isFinite(Number(primitive?.x)) &&
+            Number.isFinite(Number(primitive?.y)) &&
+            Number.isFinite(Number(primitive?.width)) &&
+            Number.isFinite(Number(primitive?.height))
+        ) {
+            const x = Number(primitive.x)
+            const y = Number(primitive.y)
+            const x2 = x + Number(primitive.width)
+            const y2 = y + Number(primitive.height)
+
+            return {
+                minX: Math.min(x, x2),
+                minY: Math.min(y, y2),
+                maxX: Math.max(x, x2),
+                maxY: Math.max(y, y2)
+            }
+        }
+
+        if (
+            Number.isFinite(Number(primitive?.x)) &&
+            Number.isFinite(Number(primitive?.y)) &&
+            Number.isFinite(Number(primitive?.radiusX)) &&
+            Number.isFinite(Number(primitive?.radiusY))
+        ) {
+            const x = Number(primitive.x)
+            const y = Number(primitive.y)
+            const radiusX = Math.abs(Number(primitive.radiusX))
+            const radiusY = Math.abs(Number(primitive.radiusY))
+
+            return {
+                minX: x - radiusX,
+                minY: y - radiusY,
+                maxX: x + radiusX,
+                maxY: y + radiusY
+            }
+        }
+
+        if (
+            Number.isFinite(Number(primitive?.x)) &&
+            Number.isFinite(Number(primitive?.y)) &&
+            Number.isFinite(Number(primitive?.radius))
+        ) {
+            const x = Number(primitive.x)
+            const y = Number(primitive.y)
+            const radiusX = Math.abs(Number(primitive.radius))
+            const radiusY = Math.abs(Number(primitive.radiusY ?? radiusX))
+
+            return {
+                minX: x - radiusX,
+                minY: y - radiusY,
+                maxX: x + radiusX,
+                maxY: y + radiusY
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * Resolves bounds for a point list.
+     * @param {{ x: number, y: number }[]} points Points.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #pointBounds(points) {
+        const numericPoints = (points || [])
+            .map((point) => ({
+                x: Number(point?.x),
+                y: Number(point?.y)
+            }))
+            .filter(
+                (point) => Number.isFinite(point.x) && Number.isFinite(point.y)
+            )
+
+        if (!numericPoints.length) {
+            return null
+        }
+
+        return {
+            minX: Math.min(...numericPoints.map((point) => point.x)),
+            minY: Math.min(...numericPoints.map((point) => point.y)),
+            maxX: Math.max(...numericPoints.map((point) => point.x)),
+            maxY: Math.max(...numericPoints.map((point) => point.y))
+        }
+    }
+
+    /**
+     * Returns true when two unprojected coordinate bounds overlap.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number }} left Left bounds.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number }} right Right bounds.
+     * @param {number} tolerance Coordinate tolerance.
+     * @returns {boolean}
+     */
+    static #boundsIntersect(left, right, tolerance = 0) {
+        return (
+            left.maxX >= right.minX - tolerance &&
+            left.minX <= right.maxX + tolerance &&
+            left.maxY >= right.minY - tolerance &&
+            left.minY <= right.maxY + tolerance
+        )
+    }
+
     /**
      * Builds interleaved owner geometry so symbol-internal primitives preserve
      * their recovered Altium paint order instead of batching fills ahead of all
@@ -1900,12 +2504,7 @@ export class SchematicSvgRenderer {
             '" y2="' +
             formatNumber(projectSchematicY(sheetHeight, line.y2)) +
             '" stroke="' +
-            escapeHtml(
-                SchematicColorResolver.resolveColor(
-                    line.color,
-                    '--schematic-default-ink-color'
-                )
-            ) +
+            escapeHtml(SchematicLineColorResolver.resolveColor(line)) +
             '" stroke-width="' +
             formatNumber(
                 SchematicSvgRenderer.#resolveSchematicLineWidth(line)
@@ -2015,6 +2614,7 @@ export class SchematicSvgRenderer {
      * @param {{ x: number, y: number, length: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
      * @param {number} index Stable primitive index.
      * @param {object | undefined} semanticContext Semantic lookup context.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
      * @returns {string}
      */
     static #buildSchematicTextMarkup(
@@ -2023,7 +2623,8 @@ export class SchematicSvgRenderer {
         lines,
         pins,
         index = 0,
-        semanticContext = undefined
+        semanticContext = undefined,
+        ownerTextBodyBounds = new Map()
     ) {
         const matchedOwnerPin =
             SchematicOwnerPinLabelLayout.findExplicitOwnerPinLabelMatch(
@@ -2063,7 +2664,8 @@ export class SchematicSvgRenderer {
             text,
             sheetHeight,
             lines,
-            matchedOwnerPin
+            matchedOwnerPin,
+            ownerTextBodyBounds
         )
 
         return SchematicSvgRenderer.#appendSvgAttributes(
@@ -2098,13 +2700,15 @@ export class SchematicSvgRenderer {
      * @param {number} sheetHeight
      * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines
      * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
      * @returns {{ x: number, y: number, anchor: 'start' | 'middle' | 'end' }}
      */
     static #resolveSchematicTextPlacement(
         text,
         sheetHeight,
         lines,
-        matchedOwnerPin
+        matchedOwnerPin,
+        ownerTextBodyBounds
     ) {
         const mirroredOwnerPinPlacement =
             SchematicOwnerPinLabelLayout.resolveMirroredOwnerPinLabelPlacement(
@@ -2112,6 +2716,7 @@ export class SchematicSvgRenderer {
                 matchedOwnerPin
             )
         const sourceY = mirroredOwnerPinPlacement?.y ?? text.y
+        const x = mirroredOwnerPinPlacement?.x ?? text.x
         const projectedY = projectSchematicY(sheetHeight, sourceY)
         const fontSize =
             SchematicTypography.resolveViewerFontSize(text.fontSize) || 0
@@ -2123,14 +2728,500 @@ export class SchematicSvgRenderer {
                 fontSize,
                 matchedOwnerPin
             )
+        const ownerBodyBaselineOffset =
+            SchematicSvgRenderer.#resolveOwnerBodyTextBaselineOffset(
+                text,
+                x,
+                sourceY,
+                fontSize,
+                matchedOwnerPin,
+                ownerTextBodyBounds
+            )
+
+        const unclampedY = projectedY - baselineLift + ownerBodyBaselineOffset
 
         return {
-            x: mirroredOwnerPinPlacement?.x ?? text.x,
-            y: projectedY - baselineLift,
+            x,
+            y: SchematicSvgRenderer.#clampOwnerBodyTextBaseline(
+                text,
+                x,
+                sourceY,
+                unclampedY,
+                sheetHeight,
+                fontSize,
+                matchedOwnerPin,
+                ownerTextBodyBounds,
+                lines
+            ),
             anchor: text.anchor || 'start'
         }
     }
 
+    /**
+     * Keeps free schematic body annotations inside the owner body cell they
+     * were authored over, including ownerless overlay text used by some
+     * symbols for truth-table and switch-state labels.
+     * @param {{ x: number, y: number, text: string, ownerIndex?: string, recordType?: string, rotation?: number }} text Text primitive.
+     * @param {number} x Render X coordinate.
+     * @param {number} sourceY Unprojected source Y coordinate.
+     * @param {number} projectedY Candidate SVG baseline.
+     * @param {number} sheetHeight Rendered sheet height.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin Matched pin label, if any.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines Line primitives.
+     * @returns {number}
+     */
+    static #clampOwnerBodyTextBaseline(
+        text,
+        x,
+        sourceY,
+        projectedY,
+        sheetHeight,
+        fontSize,
+        matchedOwnerPin,
+        ownerTextBodyBounds,
+        lines
+    ) {
+        const bounds = SchematicSvgRenderer.#resolveOwnerBodyTextCellBounds(
+            text,
+            x,
+            sourceY,
+            fontSize,
+            matchedOwnerPin,
+            ownerTextBodyBounds,
+            lines
+        )
+
+        if (!bounds) {
+            return projectedY
+        }
+
+        return SchematicSvgRenderer.#clampTextBaselineToBounds(
+            text,
+            projectedY,
+            bounds,
+            sheetHeight,
+            fontSize
+        )
+    }
+
+    /**
+     * Resolves the owner body or internal owner body cell containing text.
+     * @param {{ ownerIndex?: string, recordType?: string, rotation?: number }} text Text primitive.
+     * @param {number} x Render X coordinate.
+     * @param {number} sourceY Unprojected source Y coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin Matched pin label, if any.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines Line primitives.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolveOwnerBodyTextCellBounds(
+        text,
+        x,
+        sourceY,
+        fontSize,
+        matchedOwnerPin,
+        ownerTextBodyBounds,
+        lines
+    ) {
+        const bounds = SchematicSvgRenderer.#resolveOwnerBodyTextBounds(
+            text,
+            x,
+            sourceY,
+            fontSize,
+            matchedOwnerPin,
+            ownerTextBodyBounds
+        )
+
+        if (!bounds) {
+            return null
+        }
+
+        return (
+            SchematicSvgRenderer.#resolveOwnerBodyTextLineCellBounds(
+                text,
+                x,
+                sourceY,
+                fontSize,
+                bounds,
+                lines
+            ) || bounds
+        )
+    }
+
+    /**
+     * Resolves the owner body containing one free text primitive.
+     * @param {{ ownerIndex?: string, recordType?: string, rotation?: number }} text Text primitive.
+     * @param {number} x Render X coordinate.
+     * @param {number} sourceY Unprojected source Y coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin Matched pin label, if any.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolveOwnerBodyTextBounds(
+        text,
+        x,
+        sourceY,
+        fontSize,
+        matchedOwnerPin,
+        ownerTextBodyBounds
+    ) {
+        if (matchedOwnerPin) return null
+        if (text.recordType !== '4') return null
+        if (SchematicSvgRenderer.#normalizeDegrees(text.rotation) !== 0) {
+            return null
+        }
+        if (!Number.isFinite(fontSize) || fontSize <= 0) return null
+
+        const ownerIndex = String(text.ownerIndex || '').trim()
+        const tolerance = Math.max(fontSize * 0.4, 1)
+        const explicitBounds = ownerIndex
+            ? ownerTextBodyBounds.get(ownerIndex)
+            : null
+
+        if (
+            explicitBounds &&
+            SchematicSvgRenderer.#containsPointWithTolerance(
+                explicitBounds,
+                x,
+                sourceY,
+                tolerance
+            )
+        ) {
+            return explicitBounds
+        }
+
+        if (ownerIndex) {
+            return null
+        }
+
+        return SchematicSvgRenderer.#findContainingOwnerBodyBounds(
+            ownerTextBodyBounds,
+            x,
+            sourceY,
+            tolerance
+        )
+    }
+
+    /**
+     * Finds the smallest owner body containing one ownerless overlay label.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @param {number} x Text X coordinate.
+     * @param {number} y Text baseline Y coordinate.
+     * @param {number} tolerance Coordinate tolerance.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #findContainingOwnerBodyBounds(
+        ownerTextBodyBounds,
+        x,
+        y,
+        tolerance
+    ) {
+        let bestBounds = null
+        let bestArea = Number.POSITIVE_INFINITY
+
+        for (const bounds of ownerTextBodyBounds.values()) {
+            if (
+                !SchematicSvgRenderer.#containsPointWithTolerance(
+                    bounds,
+                    x,
+                    y,
+                    tolerance
+                )
+            ) {
+                continue
+            }
+
+            const area =
+                Math.max(Number(bounds.maxX) - Number(bounds.minX), 0) *
+                Math.max(Number(bounds.maxY) - Number(bounds.minY), 0)
+
+            if (area < bestArea) {
+                bestArea = area
+                bestBounds = bounds
+            }
+        }
+
+        return bestBounds
+    }
+
+    /**
+     * Resolves the internal horizontal-line cell containing one text label.
+     * @param {number} x Text X coordinate.
+     * @param {number} y Text Y coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number }} bounds Owner body bounds.
+     * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines Line primitives.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolveOwnerBodyTextLineCellBounds(
+        text,
+        x,
+        y,
+        fontSize,
+        bounds,
+        lines
+    ) {
+        const separators =
+            SchematicSvgRenderer.#collectOwnerBodyHorizontalSeparators(
+                x,
+                fontSize,
+                bounds,
+                lines
+            )
+
+        if (separators.length === 0) {
+            return null
+        }
+
+        const edges = [
+            Number(bounds.minY),
+            ...separators,
+            Number(bounds.maxY)
+        ].sort((left, right) => left - right)
+        const tolerance = Math.max(fontSize * 0.4, 1)
+        const descent =
+            fontSize * SchematicSvgRenderer.#resolveBodyTextDescentRatio(text)
+        const sampleY = y + (fontSize * BODY_TEXT_ASCENT_RATIO - descent) / 2
+
+        for (let index = 0; index < edges.length - 1; index += 1) {
+            const minY = edges[index]
+            const maxY = edges[index + 1]
+
+            if (sampleY >= minY && sampleY <= maxY) {
+                return {
+                    minX: bounds.minX,
+                    maxX: bounds.maxX,
+                    minY,
+                    maxY
+                }
+            }
+        }
+
+        for (let index = 0; index < edges.length - 1; index += 1) {
+            const minY = edges[index]
+            const maxY = edges[index + 1]
+
+            if (sampleY >= minY - tolerance && sampleY <= maxY + tolerance) {
+                return {
+                    minX: bounds.minX,
+                    maxX: bounds.maxX,
+                    minY,
+                    maxY
+                }
+            }
+        }
+
+        return null
+    }
+
+    /**
+     * Collects horizontal separators that behave like internal body cell rows.
+     * @param {number} x Text X coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number }} bounds Owner body bounds.
+     * @param {{ x1: number, y1: number, x2: number, y2: number, lineStyle?: number }[]} lines Line primitives.
+     * @returns {number[]}
+     */
+    static #collectOwnerBodyHorizontalSeparators(x, fontSize, bounds, lines) {
+        const tolerance = Math.max(fontSize * 0.4, 1)
+        const bodyWidth = Math.max(Number(bounds.maxX) - Number(bounds.minX), 0)
+        const minSpan = Math.max(
+            bodyWidth * BODY_TEXT_MIN_SEPARATOR_SPAN_RATIO,
+            fontSize * 1.5
+        )
+        const separators = new Set()
+
+        for (const line of lines || []) {
+            const y1 = Number(line?.y1)
+            const y2 = Number(line?.y2)
+            const x1 = Number(line?.x1)
+            const x2 = Number(line?.x2)
+
+            if (
+                !Number.isFinite(x1) ||
+                !Number.isFinite(x2) ||
+                !Number.isFinite(y1) ||
+                !Number.isFinite(y2) ||
+                Math.abs(y1 - y2) > tolerance
+            ) {
+                continue
+            }
+
+            const minX = Math.min(x1, x2)
+            const maxX = Math.max(x1, x2)
+            const span = maxX - minX
+
+            if (span < minSpan) continue
+            if (y1 <= bounds.minY + tolerance) continue
+            if (y1 >= bounds.maxY - tolerance) continue
+            if (minX < bounds.minX - tolerance) continue
+            if (maxX > bounds.maxX + tolerance) continue
+            if (x < minX - tolerance || x > maxX + tolerance) continue
+
+            separators.add(Number(formatNumber(y1)))
+        }
+
+        return [...separators].sort((left, right) => left - right)
+    }
+
+    /**
+     * Clamps a projected SVG text baseline so its visual box stays in bounds.
+     * @param {{ text?: string, resolvedText?: string }} text Text primitive.
+     * @param {number} y Candidate SVG baseline.
+     * @param {{ minY: number, maxY: number }} bounds Unprojected source bounds.
+     * @param {number} sheetHeight Rendered sheet height.
+     * @param {number} fontSize Viewer font size.
+     * @returns {number}
+     */
+    static #clampTextBaselineToBounds(text, y, bounds, sheetHeight, fontSize) {
+        const top = projectSchematicY(sheetHeight, bounds.maxY)
+        const bottom = projectSchematicY(sheetHeight, bounds.minY)
+        const ascent = fontSize * BODY_TEXT_ASCENT_RATIO
+        const descent =
+            fontSize * SchematicSvgRenderer.#resolveBodyTextDescentRatio(text)
+        const visualHeight = ascent + descent
+
+        if (bottom - top < visualHeight) {
+            return (top + bottom) / 2 + (ascent - descent) / 2
+        }
+
+        let resolvedY = y
+        const visualTop = resolvedY - ascent
+        if (visualTop < top) {
+            resolvedY += top - visualTop
+        }
+
+        const visualBottom = resolvedY + descent
+        if (visualBottom > bottom) {
+            resolvedY -= visualBottom - bottom
+        }
+
+        return resolvedY
+    }
+
+    /**
+     * Estimates the descent needed for body-cell text clamping.
+     * @param {{ text?: string, resolvedText?: string }} text Text primitive.
+     * @returns {number}
+     */
+    static #resolveBodyTextDescentRatio(text) {
+        const value = String(text?.resolvedText ?? text?.text ?? '')
+
+        return BODY_TEXT_DESCENDER_PATTERN.test(value)
+            ? BODY_TEXT_DESCENT_RATIO
+            : BODY_TEXT_FLAT_DESCENT_RATIO
+    }
+
+    /**
+     * Returns true when a point falls inside bounds with tolerance.
+     * @param {{ minX: number, minY: number, maxX: number, maxY: number }} bounds Bounds.
+     * @param {number} x X coordinate.
+     * @param {number} y Y coordinate.
+     * @param {number} tolerance Coordinate tolerance.
+     * @returns {boolean}
+     */
+    static #containsPointWithTolerance(bounds, x, y, tolerance) {
+        const numericX = Number(x)
+        const numericY = Number(y)
+
+        return (
+            Number.isFinite(numericX) &&
+            Number.isFinite(numericY) &&
+            numericX >= bounds.minX - tolerance &&
+            numericX <= bounds.maxX + tolerance &&
+            numericY >= bounds.minY - tolerance &&
+            numericY <= bounds.maxY + tolerance
+        )
+    }
+
+    /**
+     * Adds the SVG baseline correction for mirrored owner-local symbol text
+     * authored with the native orientation that stores the top of the text run.
+     * Baseline-oriented mirrored labels already use SVG-like y coordinates.
+     * @param {{ ownerIndex?: string, recordType?: string, rotation?: number, sourceOrientation?: number, isMirrored?: boolean }} text Text primitive.
+     * @param {number} x Render X coordinate.
+     * @param {number} sourceY Unprojected source Y coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin Matched pin label, if any.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @returns {number}
+     */
+    static #resolveOwnerBodyTextBaselineOffset(
+        text,
+        x,
+        sourceY,
+        fontSize,
+        matchedOwnerPin,
+        ownerTextBodyBounds
+    ) {
+        if (
+            !SchematicSvgRenderer.#isOwnerBodyBaselineText(
+                text,
+                x,
+                sourceY,
+                fontSize,
+                matchedOwnerPin,
+                ownerTextBodyBounds
+            )
+        ) {
+            return 0
+        }
+
+        return fontSize
+    }
+
+    /**
+     * Returns true when one text primitive is a top-origin mirrored owner-local
+     * symbol annotation sitting inside its owner's drawable body.
+     * @param {{ ownerIndex?: string, recordType?: string, rotation?: number, sourceOrientation?: number, isMirrored?: boolean }} text Text primitive.
+     * @param {number} x Render X coordinate.
+     * @param {number} sourceY Unprojected source Y coordinate.
+     * @param {number} fontSize Viewer font size.
+     * @param {{ x: number, y: number, name?: string, ownerIndex?: string, orientation: 'left' | 'right' | 'top' | 'bottom' } | null} matchedOwnerPin Matched pin label, if any.
+     * @param {Map<string, { minX: number, minY: number, maxX: number, maxY: number }>} ownerTextBodyBounds Owner body bounds keyed by owner index.
+     * @returns {boolean}
+     */
+    static #isOwnerBodyBaselineText(
+        text,
+        x,
+        sourceY,
+        fontSize,
+        matchedOwnerPin,
+        ownerTextBodyBounds
+    ) {
+        if (matchedOwnerPin) return false
+        if (text.recordType !== '4') return false
+        if (!text.isMirrored) return false
+        if (Number(text.sourceOrientation ?? 0) !== 2) return false
+        if (SchematicSvgRenderer.#normalizeDegrees(text.rotation) !== 0) {
+            return false
+        }
+        if (!Number.isFinite(fontSize) || fontSize <= 0) return false
+
+        const ownerIndex = String(text.ownerIndex || '').trim()
+        if (!ownerIndex) return false
+
+        const bounds = ownerTextBodyBounds.get(ownerIndex)
+        if (!bounds) return false
+
+        const numericX = Number(x)
+        const numericY = Number(sourceY)
+        const tolerance = Math.max(fontSize * 0.4, 1)
+
+        return (
+            Number.isFinite(numericX) &&
+            Number.isFinite(numericY) &&
+            numericX >= bounds.minX - tolerance &&
+            numericX <= bounds.maxX + tolerance &&
+            numericY >= bounds.minY - tolerance &&
+            numericY <= bounds.maxY + tolerance
+        )
+    }
+
     /**
      * Lifts large section headings clear of authored dash-dot frame baselines.
      * @param {{ x: number, y: number, ownerIndex?: string, recordType?: string, fontSize?: number, rotation?: number }} text
@@ -2229,11 +3320,18 @@ export class SchematicSvgRenderer {
 
     /**
      * Builds one schematic cross marker.
-     * @param {{ x: number, y: number, size: number, color: string }} cross
+     * @param {{ x: number, y: number, size: number, color: string, symbolName?: string }} cross
      * @param {number} sheetHeight
      * @returns {string}
      */
     static #buildSchematicCrossMarkup(cross, sheetHeight) {
+        if (String(cross.symbolName || '').toLowerCase() === 'checkbox') {
+            return SchematicSvgRenderer.#buildSchematicCheckboxMarkup(
+                cross,
+                sheetHeight
+            )
+        }
+
         const x = cross.x
         const y = projectSchematicY(sheetHeight, cross.y)
         const half = Math.max(Number(cross.size || 6), 4) / 2
@@ -2273,6 +3371,64 @@ export class SchematicSvgRenderer {
         )
     }
 
+    /**
+     * Builds one checkbox-shaped no-ERC marker.
+     * @param {{ x: number, y: number, size: number, color: string }} cross
+     * @param {number} sheetHeight
+     * @returns {string}
+     */
+    static #buildSchematicCheckboxMarkup(cross, sheetHeight) {
+        const x = Number(cross.x)
+        const y = projectSchematicY(sheetHeight, cross.y)
+        const size = Math.max(Number(cross.size || 6), 4)
+        const left = x - 1
+        const top = y - size - 7
+        const color = escapeHtml(
+            SchematicColorResolver.resolveColor(
+                cross.color,
+                '--schematic-alert-color'
+            )
+        )
+
+        return (
+            '<g class="schematic-cross schematic-cross--checkbox"><line x1="' +
+            formatNumber(x) +
+            '" y1="' +
+            formatNumber(y) +
+            '" x2="' +
+            formatNumber(left) +
+            '" y2="' +
+            formatNumber(top + size) +
+            '" stroke="' +
+            color +
+            '" /><rect x="' +
+            formatNumber(left) +
+            '" y="' +
+            formatNumber(top) +
+            '" width="' +
+            formatNumber(size) +
+            '" height="' +
+            formatNumber(size) +
+            '" fill="none" stroke="' +
+            color +
+            '" /><polyline points="' +
+            formatNumber(left + size * 0.2) +
+            ',' +
+            formatNumber(top + size * 0.5) +
+            ' ' +
+            formatNumber(left + size * 0.5) +
+            ',' +
+            formatNumber(top + size * 0.8) +
+            ' ' +
+            formatNumber(left + size * 0.9666666667) +
+            ',' +
+            formatNumber(top + size * 0.2) +
+            '" fill="none" stroke="' +
+            color +
+            '" /></g>'
+        )
+    }
+
     /**
      * Builds one authored schematic junction dot.
      * @param {{ x: number, y: number, color: string }} junction
@@ -2287,7 +3443,7 @@ export class SchematicSvgRenderer {
             formatNumber(projectSchematicY(sheetHeight, junction.y)) +
             '" r="2.4" fill="' +
             escapeHtml(
-                SchematicColorResolver.resolveColor(
+                SchematicColorResolver.resolveNonTextColor(
                     junction.color,
                     '--schematic-default-ink-color'
                 )
@@ -2321,30 +3477,13 @@ export class SchematicSvgRenderer {
     static #resolveAuthoredSchematicJunctionColor(junction, lines) {
         const connectedLine = lines.find(
             (line) =>
-                SchematicSvgRenderer.#isElectricalSchematicLine(line) &&
+                SchematicLineColorResolver.isElectricalLine(line) &&
                 SchematicSvgRenderer.#schematicLineContainsPoint(line, junction)
         )
 
         return connectedLine?.color || junction.color
     }
 
-    /**
-     * Returns true when one normalized line can carry schematic net color.
-     * @param {{ ownerIndex?: string, isBus?: boolean, recordType?: string } | null | undefined} line
-     * @returns {boolean}
-     */
-    static #isElectricalSchematicLine(line) {
-        if (line?.ownerIndex || line?.isBus === true) {
-            return false
-        }
-
-        if (!Object.prototype.hasOwnProperty.call(line || {}, 'recordType')) {
-            return true
-        }
-
-        return !['6', '7', '26'].includes(String(line.recordType || ''))
-    }
-
     /**
      * Returns true when one schematic line segment contains the given point.
      * @param {{ x1: number, y1: number, x2: number, y2: number }} line