From 6d9416e37667aeacab658c552c9aa498e8bacb0d Mon Sep 17 00:00:00 2001 From: seveibar Date: Wed, 29 Jul 2026 23:12:27 -0700 Subject: [PATCH 1/3] Add bus fanout plane termination props --- README.md | 7 ++++ generated/COMPONENT_TYPES.md | 64 +++++++++++++++++++++++++++++++----- generated/PROPS_OVERVIEW.md | 31 +++++++++++++++++ lib/components/bus.ts | 50 +++++++++++++++++++++++++--- tests/bus.test.ts | 19 +++++++++-- 5 files changed, 155 insertions(+), 16 deletions(-) diff --git a/README.md b/README.md index b3cdb0bb..86a81ccc 100644 --- a/README.md +++ b/README.md @@ -458,6 +458,13 @@ export interface BusProps { name?: string; /** Trace names or port selectors for the connections in the bus. */ connections: string[]; + /** + * How this bus should terminate during fanout. + * + * Plane termination escapes each source pad to a local via on the selected + * layer instead of routing the bus to the breakout boundary. + */ + fanoutTermination?: BusFanoutTermination; } ``` diff --git a/generated/COMPONENT_TYPES.md b/generated/COMPONENT_TYPES.md index 90272095..74e82de6 100644 --- a/generated/COMPONENT_TYPES.md +++ b/generated/COMPONENT_TYPES.md @@ -155,6 +155,35 @@ export const pcbCoordinate = calcString.or(baseDistance) export { length } ``` +### fanoutBoundaryPadding + +```typescript +export interface DirectionalFanoutBoundaryPadding { + top?: Distance + right?: Distance + bottom?: Distance + left?: Distance +} +/** + * Padding between the union of the fanout source pads and the shared boundary + * where fanout traces terminate. Omitted directional values are treated as + * zero. + */ +export type FanoutBoundaryPadding = Distance | DirectionalFanoutBoundaryPadding + +const nonnegativeDistance = distance.refine((value) => value >= 0, { + message: "Fanout boundary padding cannot be negative", +}) +export const fanoutBoundaryPadding = z.union([ + nonnegativeDistance, + z.object({ + top: nonnegativeDistance.optional(), + right: nonnegativeDistance.optional(), + bottom: nonnegativeDistance.optional(), + left: nonnegativeDistance.optional(), + }), +``` + ### footprintProp ```typescript @@ -1148,10 +1177,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { connections?: string[] reroute?: boolean busFanoutDirections?: Record + fanoutBoundaryPadding?: FanoutBoundaryPadding } /** - * Fanout direction for each named bus in this phase. `center` leaves the - * direction unconstrained. + * Padding between the union of the fanout source pads and the shared + * boundary where fanout traces terminate. */ export const autoroutingPhaseProps = z .object({ @@ -1173,6 +1203,7 @@ export const autoroutingPhaseProps = z connections: z.array(z.string()).optional(), reroute: z.boolean().optional(), busFanoutDirections: z.record(busFanoutDirection).optional(), + fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), }) ``` @@ -1263,10 +1294,12 @@ export interface BreakoutProps paddingRight?: Distance paddingTop?: Distance paddingBottom?: Distance + fanoutBoundaryPadding?: FanoutBoundaryPadding } /** - * Autorouter used to escape the components inside the breakout boundary. - * Defaults to the multilayer fanout autorouter. + * Padding between the union of the fanout source pads and the shared + * boundary where fanout traces terminate. This is independent of the + * breakout group's layout padding. */ export const breakoutProps = subcircuitGroupProps.extend({ autorouter: autorouterProp.default("fanout"), @@ -1275,6 +1308,7 @@ export const breakoutProps = subcircuitGroupProps.extend({ paddingRight: distance.optional(), paddingTop: distance.optional(), paddingBottom: distance.optional(), + fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), }) ``` @@ -1295,6 +1329,10 @@ export const breakoutPointProps = pcbLayoutProps ### bus ```typescript +export type BusFanoutTermination = + | { + type: "boundary" + } /** * Declares a group of connections that an autorouter should keep together. * Each connection may be a trace name or a port selector. @@ -1302,12 +1340,20 @@ export const breakoutPointProps = pcbLayoutProps export interface BusProps { name?: string connections: string[] + fanoutTermination?: BusFanoutTermination } -/** Trace names or port selectors for the connections in the bus. */ -export const busProps = z.object({ - name: z.string().optional(), - connections: z.array(z.string()).min(2), -}) +/** + * How this bus should terminate during fanout. + * + * Plane termination escapes each source pad to a local via on the selected + * layer instead of routing the bus to the breakout boundary. + */ +export const busProps = z + .object({ + name: z.string().optional(), + connections: z.array(z.string()).min(1), + fanoutTermination: busFanoutTermination.optional(), + }) ``` ### cadassembly diff --git a/generated/PROPS_OVERVIEW.md b/generated/PROPS_OVERVIEW.md index dc969ebb..971df7af 100644 --- a/generated/PROPS_OVERVIEW.md +++ b/generated/PROPS_OVERVIEW.md @@ -210,6 +210,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { * direction unconstrained. */ busFanoutDirections?: Record + /** + * Padding between the union of the fanout source pads and the shared + * boundary where fanout traces terminate. + */ + fanoutBoundaryPadding?: FanoutBoundaryPadding } @@ -408,11 +413,22 @@ export interface BreakoutPointProps export interface BreakoutProps extends Omit { + /** + * Autorouter used to escape the components inside the breakout boundary. + * Defaults to the multilayer fanout autorouter. + */ + autorouter?: AutorouterProp padding?: Distance paddingLeft?: Distance paddingRight?: Distance paddingTop?: Distance paddingBottom?: Distance + /** + * Padding between the union of the fanout source pads and the shared + * boundary where fanout traces terminate. This is independent of the + * breakout group's layout padding. + */ + fanoutBoundaryPadding?: FanoutBoundaryPadding } @@ -420,6 +436,13 @@ export interface BusProps { name?: string /** Trace names or port selectors for the connections in the bus. */ connections: string[] + /** + * How this bus should terminate during fanout. + * + * Plane termination escapes each source pad to a local via on the selected + * layer instead of routing the bus to the breakout boundary. + */ + fanoutTermination?: BusFanoutTermination } @@ -878,6 +901,14 @@ export interface DiodeProps } +export interface DirectionalFanoutBoundaryPadding { + top?: Distance + right?: Distance + bottom?: Distance + left?: Distance +} + + export interface DrcCheckProps { name?: string checkFn: CustomDrcCheckFn diff --git a/lib/components/bus.ts b/lib/components/bus.ts index 242be75e..456c03f4 100644 --- a/lib/components/bus.ts +++ b/lib/components/bus.ts @@ -1,8 +1,18 @@ +import { layer_ref, type LayerRefInput } from "circuit-json" import { expectTypesMatch } from "lib/typecheck" import { z } from "zod" export type BusName = string +export type BusFanoutTermination = + | { + type: "boundary" + } + | { + type: "plane" + layer: LayerRefInput + } + /** * Declares a group of connections that an autorouter should keep together. * Each connection may be a trace name or a port selector. @@ -11,12 +21,44 @@ export interface BusProps { name?: string /** Trace names or port selectors for the connections in the bus. */ connections: string[] + /** + * How this bus should terminate during fanout. + * + * Plane termination escapes each source pad to a local via on the selected + * layer instead of routing the bus to the breakout boundary. + */ + fanoutTermination?: BusFanoutTermination } -export const busProps = z.object({ - name: z.string().optional(), - connections: z.array(z.string()).min(2), -}) +const busFanoutTermination = z.discriminatedUnion("type", [ + z.object({ type: z.literal("boundary") }), + z.object({ + type: z.literal("plane"), + layer: layer_ref, + }), +]) + +export const busProps = z + .object({ + name: z.string().optional(), + connections: z.array(z.string()).min(1), + fanoutTermination: busFanoutTermination.optional(), + }) + .superRefine((props, ctx) => { + if ( + props.connections.length < 2 && + props.fanoutTermination?.type !== "plane" + ) { + ctx.addIssue({ + code: z.ZodIssueCode.too_small, + minimum: 2, + type: "array", + inclusive: true, + message: "Boundary-routed buses must contain at least two connections", + path: ["connections"], + }) + } + }) type InferredBusProps = z.input expectTypesMatch(true) diff --git a/tests/bus.test.ts b/tests/bus.test.ts index 0fee5925..a60ce732 100644 --- a/tests/bus.test.ts +++ b/tests/bus.test.ts @@ -2,15 +2,28 @@ import { expect, test } from "bun:test" import { busProps, type BusProps } from "lib/components/bus" test("busProps accepts two or more connection references", () => { - const rawProps: BusProps = { + const rawProps = { name: "DATA", connections: ["D0", ".U1 > .D1"], - } + } satisfies BusProps expect(busProps.parse(rawProps)).toEqual(rawProps) }) -test("busProps rejects a single connection", () => { +test("busProps accepts a source-only plane connection", () => { + const rawProps = { + name: "GROUND_A1", + connections: ["GND_A1"], + fanoutTermination: { + type: "plane", + layer: "inner1", + }, + } satisfies BusProps + + expect(busProps.parse(rawProps)).toEqual(rawProps) +}) + +test("busProps rejects a single boundary connection", () => { expect( busProps.safeParse({ name: "DATA", From 2f2e9c4955af2475cfbcb54aa9097bdcbbf53579 Mon Sep 17 00:00:00 2001 From: seveibar Date: Wed, 29 Jul 2026 23:35:37 -0700 Subject: [PATCH 2/3] Add configurable fanout routing layers --- README.md | 5 +++++ generated/COMPONENT_TYPES.md | 6 ++++-- generated/PROPS_OVERVIEW.md | 5 +++++ lib/components/autoroutingphase.ts | 7 +++++++ tests/autoroutingphase.test.ts | 9 +++++++++ 5 files changed, 30 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 86a81ccc..f0251495 100644 --- a/README.md +++ b/README.md @@ -352,6 +352,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { * boundary where fanout traces terminate. */ fanoutBoundaryPadding?: FanoutBoundaryPadding; + /** + * Copper layers available to boundary-terminated fanout buses. Plane + * terminations still use the layer declared on their bus. + */ + fanoutRoutingLayers?: LayerRefInput[]; } ``` diff --git a/generated/COMPONENT_TYPES.md b/generated/COMPONENT_TYPES.md index 74e82de6..c6621124 100644 --- a/generated/COMPONENT_TYPES.md +++ b/generated/COMPONENT_TYPES.md @@ -1178,10 +1178,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { reroute?: boolean busFanoutDirections?: Record fanoutBoundaryPadding?: FanoutBoundaryPadding + fanoutRoutingLayers?: LayerRefInput[] } /** - * Padding between the union of the fanout source pads and the shared - * boundary where fanout traces terminate. + * Copper layers available to boundary-terminated fanout buses. Plane + * terminations still use the layer declared on their bus. */ export const autoroutingPhaseProps = z .object({ @@ -1204,6 +1205,7 @@ export const autoroutingPhaseProps = z reroute: z.boolean().optional(), busFanoutDirections: z.record(busFanoutDirection).optional(), fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), + fanoutRoutingLayers: z.array(layer_ref).min(1).optional(), }) ``` diff --git a/generated/PROPS_OVERVIEW.md b/generated/PROPS_OVERVIEW.md index 971df7af..cc1d00fa 100644 --- a/generated/PROPS_OVERVIEW.md +++ b/generated/PROPS_OVERVIEW.md @@ -215,6 +215,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { * boundary where fanout traces terminate. */ fanoutBoundaryPadding?: FanoutBoundaryPadding + /** + * Copper layers available to boundary-terminated fanout buses. Plane + * terminations still use the layer declared on their bus. + */ + fanoutRoutingLayers?: LayerRefInput[] } diff --git a/lib/components/autoroutingphase.ts b/lib/components/autoroutingphase.ts index c2723b7c..97fa58c7 100644 --- a/lib/components/autoroutingphase.ts +++ b/lib/components/autoroutingphase.ts @@ -1,5 +1,6 @@ import { expectTypesMatch } from "lib/typecheck" import { z } from "zod" +import { layer_ref, type LayerRefInput } from "circuit-json" import { type FanoutBoundaryPadding, fanoutBoundaryPadding, @@ -47,6 +48,11 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { * boundary where fanout traces terminate. */ fanoutBoundaryPadding?: FanoutBoundaryPadding + /** + * Copper layers available to boundary-terminated fanout buses. Plane + * terminations still use the layer declared on their bus. + */ + fanoutRoutingLayers?: LayerRefInput[] } const busFanoutDirection = z.union([ @@ -75,6 +81,7 @@ export const autoroutingPhaseProps = z reroute: z.boolean().optional(), busFanoutDirections: z.record(busFanoutDirection).optional(), fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), + fanoutRoutingLayers: z.array(layer_ref).min(1).optional(), }) .superRefine((value, ctx) => { if ( diff --git a/tests/autoroutingphase.test.ts b/tests/autoroutingphase.test.ts index 33f69363..e27d77d9 100644 --- a/tests/autoroutingphase.test.ts +++ b/tests/autoroutingphase.test.ts @@ -42,6 +42,15 @@ test("autorouting phase accepts per-bus fanout directions", () => { expect(autoroutingPhaseProps.parse(raw)).toEqual(raw) }) +test("autorouting phase accepts fanout routing layers", () => { + const parsed = autoroutingPhaseProps.parse({ + autorouter: "fanout", + fanoutRoutingLayers: ["top", { name: "inner3" }, "bottom"], + }) + + expect(parsed.fanoutRoutingLayers).toEqual(["top", "inner3", "bottom"]) +}) + test("autorouting phase accepts scalar fanout boundary padding", () => { const raw = { autorouter: "fanout", From 3c21b0fdde71811b8fca0767296826c234f0f3fc Mon Sep 17 00:00:00 2001 From: seveibar Date: Thu, 30 Jul 2026 12:28:31 -0700 Subject: [PATCH 3/3] Replace fanout bus termination with pour net map --- README.md | 20 ++++++------ generated/COMPONENT_TYPES.md | 33 +++++++++----------- generated/PROPS_OVERVIEW.md | 20 ++++++------ lib/components/autoroutingphase.ts | 22 +++++++++++-- lib/components/bus.ts | 50 +++--------------------------- tests/autoroutingphase.test.ts | 12 +++++++ tests/bus.test.ts | 22 ------------- 7 files changed, 71 insertions(+), 108 deletions(-) diff --git a/README.md b/README.md index f0251495..aaeacc72 100644 --- a/README.md +++ b/README.md @@ -353,10 +353,19 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { */ fanoutBoundaryPadding?: FanoutBoundaryPadding; /** - * Copper layers available to boundary-terminated fanout buses. Plane - * terminations still use the layer declared on their bus. + * Copper layers available to boundary-terminated fanout buses. Source-only + * traces whose nets are mapped by `fanoutPourNetMap` terminate on their + * mapped plane layer. */ fanoutRoutingLayers?: LayerRefInput[]; + /** + * Maps copper layers to the net or nets poured on them. During fanout, + * source-only traces on those nets drop to the mapped layer instead of + * routing to the breakout boundary. + * + * This is inferred from `` components when omitted. + */ + fanoutPourNetMap?: FanoutPourNetMap; } ``` @@ -463,13 +472,6 @@ export interface BusProps { name?: string; /** Trace names or port selectors for the connections in the bus. */ connections: string[]; - /** - * How this bus should terminate during fanout. - * - * Plane termination escapes each source pad to a local via on the selected - * layer instead of routing the bus to the breakout boundary. - */ - fanoutTermination?: BusFanoutTermination; } ``` diff --git a/generated/COMPONENT_TYPES.md b/generated/COMPONENT_TYPES.md index c6621124..4bf31f42 100644 --- a/generated/COMPONENT_TYPES.md +++ b/generated/COMPONENT_TYPES.md @@ -1179,10 +1179,14 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { busFanoutDirections?: Record fanoutBoundaryPadding?: FanoutBoundaryPadding fanoutRoutingLayers?: LayerRefInput[] + fanoutPourNetMap?: FanoutPourNetMap } /** - * Copper layers available to boundary-terminated fanout buses. Plane - * terminations still use the layer declared on their bus. + * Maps copper layers to the net or nets poured on them. During fanout, + * source-only traces on those nets drop to the mapped layer instead of + * routing to the breakout boundary. + * + * This is inferred from `` components when omitted. */ export const autoroutingPhaseProps = z .object({ @@ -1206,6 +1210,9 @@ export const autoroutingPhaseProps = z busFanoutDirections: z.record(busFanoutDirection).optional(), fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), fanoutRoutingLayers: z.array(layer_ref).min(1).optional(), + fanoutPourNetMap: z + .record(layer_ref, z.union([z.string(), z.array(z.string()).min(1)])) + .optional(), }) ``` @@ -1331,10 +1338,6 @@ export const breakoutPointProps = pcbLayoutProps ### bus ```typescript -export type BusFanoutTermination = - | { - type: "boundary" - } /** * Declares a group of connections that an autorouter should keep together. * Each connection may be a trace name or a port selector. @@ -1342,20 +1345,12 @@ export type BusFanoutTermination = export interface BusProps { name?: string connections: string[] - fanoutTermination?: BusFanoutTermination } -/** - * How this bus should terminate during fanout. - * - * Plane termination escapes each source pad to a local via on the selected - * layer instead of routing the bus to the breakout boundary. - */ -export const busProps = z - .object({ - name: z.string().optional(), - connections: z.array(z.string()).min(1), - fanoutTermination: busFanoutTermination.optional(), - }) +/** Trace names or port selectors for the connections in the bus. */ +export const busProps = z.object({ + name: z.string().optional(), + connections: z.array(z.string()).min(2), +}) ``` ### cadassembly diff --git a/generated/PROPS_OVERVIEW.md b/generated/PROPS_OVERVIEW.md index cc1d00fa..db2c5db7 100644 --- a/generated/PROPS_OVERVIEW.md +++ b/generated/PROPS_OVERVIEW.md @@ -216,10 +216,19 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { */ fanoutBoundaryPadding?: FanoutBoundaryPadding /** - * Copper layers available to boundary-terminated fanout buses. Plane - * terminations still use the layer declared on their bus. + * Copper layers available to boundary-terminated fanout buses. Source-only + * traces whose nets are mapped by `fanoutPourNetMap` terminate on their + * mapped plane layer. */ fanoutRoutingLayers?: LayerRefInput[] + /** + * Maps copper layers to the net or nets poured on them. During fanout, + * source-only traces on those nets drop to the mapped layer instead of + * routing to the breakout boundary. + * + * This is inferred from `` components when omitted. + */ + fanoutPourNetMap?: FanoutPourNetMap } @@ -441,13 +450,6 @@ export interface BusProps { name?: string /** Trace names or port selectors for the connections in the bus. */ connections: string[] - /** - * How this bus should terminate during fanout. - * - * Plane termination escapes each source pad to a local via on the selected - * layer instead of routing the bus to the breakout boundary. - */ - fanoutTermination?: BusFanoutTermination } diff --git a/lib/components/autoroutingphase.ts b/lib/components/autoroutingphase.ts index 97fa58c7..e2238f0a 100644 --- a/lib/components/autoroutingphase.ts +++ b/lib/components/autoroutingphase.ts @@ -1,6 +1,6 @@ import { expectTypesMatch } from "lib/typecheck" import { z } from "zod" -import { layer_ref, type LayerRefInput } from "circuit-json" +import { layer_ref, type LayerRef, type LayerRefInput } from "circuit-json" import { type FanoutBoundaryPadding, fanoutBoundaryPadding, @@ -23,6 +23,10 @@ export type BusFanoutDirection = direction: NinePointAnchor } +export type FanoutPourNetMap = Partial< + Record, string | string[]> +> + export interface AutoroutingPhaseProps extends RoutingTolerances { key?: any name?: string @@ -49,10 +53,19 @@ export interface AutoroutingPhaseProps extends RoutingTolerances { */ fanoutBoundaryPadding?: FanoutBoundaryPadding /** - * Copper layers available to boundary-terminated fanout buses. Plane - * terminations still use the layer declared on their bus. + * Copper layers available to boundary-terminated fanout buses. Source-only + * traces whose nets are mapped by `fanoutPourNetMap` terminate on their + * mapped plane layer. */ fanoutRoutingLayers?: LayerRefInput[] + /** + * Maps copper layers to the net or nets poured on them. During fanout, + * source-only traces on those nets drop to the mapped layer instead of + * routing to the breakout boundary. + * + * This is inferred from `` components when omitted. + */ + fanoutPourNetMap?: FanoutPourNetMap } const busFanoutDirection = z.union([ @@ -82,6 +95,9 @@ export const autoroutingPhaseProps = z busFanoutDirections: z.record(busFanoutDirection).optional(), fanoutBoundaryPadding: fanoutBoundaryPadding.optional(), fanoutRoutingLayers: z.array(layer_ref).min(1).optional(), + fanoutPourNetMap: z + .record(layer_ref, z.union([z.string(), z.array(z.string()).min(1)])) + .optional(), }) .superRefine((value, ctx) => { if ( diff --git a/lib/components/bus.ts b/lib/components/bus.ts index 456c03f4..242be75e 100644 --- a/lib/components/bus.ts +++ b/lib/components/bus.ts @@ -1,18 +1,8 @@ -import { layer_ref, type LayerRefInput } from "circuit-json" import { expectTypesMatch } from "lib/typecheck" import { z } from "zod" export type BusName = string -export type BusFanoutTermination = - | { - type: "boundary" - } - | { - type: "plane" - layer: LayerRefInput - } - /** * Declares a group of connections that an autorouter should keep together. * Each connection may be a trace name or a port selector. @@ -21,44 +11,12 @@ export interface BusProps { name?: string /** Trace names or port selectors for the connections in the bus. */ connections: string[] - /** - * How this bus should terminate during fanout. - * - * Plane termination escapes each source pad to a local via on the selected - * layer instead of routing the bus to the breakout boundary. - */ - fanoutTermination?: BusFanoutTermination } -const busFanoutTermination = z.discriminatedUnion("type", [ - z.object({ type: z.literal("boundary") }), - z.object({ - type: z.literal("plane"), - layer: layer_ref, - }), -]) - -export const busProps = z - .object({ - name: z.string().optional(), - connections: z.array(z.string()).min(1), - fanoutTermination: busFanoutTermination.optional(), - }) - .superRefine((props, ctx) => { - if ( - props.connections.length < 2 && - props.fanoutTermination?.type !== "plane" - ) { - ctx.addIssue({ - code: z.ZodIssueCode.too_small, - minimum: 2, - type: "array", - inclusive: true, - message: "Boundary-routed buses must contain at least two connections", - path: ["connections"], - }) - } - }) +export const busProps = z.object({ + name: z.string().optional(), + connections: z.array(z.string()).min(2), +}) type InferredBusProps = z.input expectTypesMatch(true) diff --git a/tests/autoroutingphase.test.ts b/tests/autoroutingphase.test.ts index e27d77d9..55c7ac7a 100644 --- a/tests/autoroutingphase.test.ts +++ b/tests/autoroutingphase.test.ts @@ -51,6 +51,18 @@ test("autorouting phase accepts fanout routing layers", () => { expect(parsed.fanoutRoutingLayers).toEqual(["top", "inner3", "bottom"]) }) +test("autorouting phase accepts a fanout pour net map", () => { + const raw = { + autorouter: "fanout", + fanoutPourNetMap: { + inner1: "GND", + inner2: ["VCC_CORE", "VCC_IO"], + }, + } satisfies AutoroutingPhaseProps + + expect(autoroutingPhaseProps.parse(raw)).toEqual(raw) +}) + test("autorouting phase accepts scalar fanout boundary padding", () => { const raw = { autorouter: "fanout", diff --git a/tests/bus.test.ts b/tests/bus.test.ts index a60ce732..97c49c01 100644 --- a/tests/bus.test.ts +++ b/tests/bus.test.ts @@ -9,25 +9,3 @@ test("busProps accepts two or more connection references", () => { expect(busProps.parse(rawProps)).toEqual(rawProps) }) - -test("busProps accepts a source-only plane connection", () => { - const rawProps = { - name: "GROUND_A1", - connections: ["GND_A1"], - fanoutTermination: { - type: "plane", - layer: "inner1", - }, - } satisfies BusProps - - expect(busProps.parse(rawProps)).toEqual(rawProps) -}) - -test("busProps rejects a single boundary connection", () => { - expect( - busProps.safeParse({ - name: "DATA", - connections: ["D0"], - }).success, - ).toBe(false) -})