astra/am3352-sbc

design/vendor/bus-lanes-candidate.d.ts

// Generated by dts-bundle-generator v9.5.1

interface Point {
	x: number;
	y: number;
	color?: string;
	label?: string;
	layer?: string;
	step?: number;
}
interface Line {
	points: {
		x: number;
		y: number;
	}[];
	strokeWidth?: number;
	strokeColor?: string;
	strokeDash?: string | number[];
	zIndex?: number;
	layer?: string;
	step?: number;
	label?: string;
}
interface InfiniteLine {
	directionVector: {
		x: number;
		y: number;
	};
	origin: {
		x: number;
		y: number;
	};
	strokeWidth?: number;
	strokeColor?: string;
	strokeDash?: string | number[];
	layer?: string;
	step?: number;
	label?: string;
}
interface Rect {
	center: {
		x: number;
		y: number;
	};
	width: number;
	height: number;
	ccwRotationDegrees?: number;
	fill?: string;
	stroke?: string;
	color?: string;
	layer?: string;
	step?: number;
	label?: string;
}
interface Circle {
	center: {
		x: number;
		y: number;
	};
	radius: number;
	fill?: string;
	stroke?: string;
	layer?: string;
	step?: number;
	label?: string;
}
interface Polygon {
	points: {
		x: number;
		y: number;
	}[];
	fill?: string;
	stroke?: string;
	strokeWidth?: number;
	color?: string;
	layer?: string;
	step?: number;
	label?: string;
}
interface Arrow {
	start: {
		x: number;
		y: number;
	};
	end: {
		x: number;
		y: number;
	};
	doubleSided?: boolean;
	color?: string;
	label?: string;
	inlineLabel?: string;
}
type NinePointAnchor = "center" | "top_left" | "top_center" | "top_right" | "center_left" | "center_right" | "bottom_left" | "bottom_center" | "bottom_right";
interface Text$1 {
	x: number;
	y: number;
	text: string;
	anchorSide?: NinePointAnchor;
	color?: string;
	fontSize?: number;
	layer?: string;
	step?: number;
}
interface GraphicsObject {
	points?: Point[];
	lines?: Line[];
	infiniteLines?: InfiniteLine[];
	rects?: Rect[];
	circles?: Circle[];
	polygons?: Polygon[];
	arrows?: Arrow[];
	texts?: Text$1[];
	coordinateSystem?: "cartesian" | "screen";
	title?: string;
}
declare class BaseSolver {
	MAX_ITERATIONS: number;
	solved: boolean;
	failed: boolean;
	iterations: number;
	progress: number;
	error: string | null;
	activeSubSolver?: BaseSolver | null;
	failedSubSolvers?: BaseSolver[];
	timeToSolve?: number;
	stats: Record<string, any>;
	_setupDone: boolean;
	getSolverName(): string;
	setup(): void;
	/** Override this method to perform setup logic */
	_setup(): void;
	/** DO NOT OVERRIDE! Override _step() instead */
	step(): void;
	/** Override this method to implement solver logic */
	_step(): void;
	getConstructorParams(): void;
	/**
	 * Override this method to return the standardized output of the solver.
	 * This method should only be called after the solver has completed successfully.
	 * Returns null by default - solvers with outputs should override this method.
	 */
	getOutput(): any;
	solve(): void;
	visualize(): GraphicsObject;
	/**
	 * Called when the solver is about to fail, but we want to see if we have an
	 * "acceptable" or "passable" solution. Mostly used for optimizers that
	 * have an aggressive early stopping criterion.
	 */
	tryFinalAcceptance(): void;
	/**
	 * A lightweight version of the visualize method that can be used to stream
	 * progress
	 */
	preview(): GraphicsObject;
}
/** Board-space geometry: right-handed XY, +X right, +Y up; positions and widths in mm. */
interface Point$1 {
	x: number;
	y: number;
}
export interface Terminal extends Point$1 {
	layer: string;
	pcb_port_id?: string;
	pointId?: string;
	layers?: string[];
}
export interface Connection {
	name: string;
	source_trace_id?: string;
	pointsToConnect: Terminal[];
	nominalTraceWidth?: number;
	width?: number;
}
export interface Bus {
	busId: string;
	name?: string;
	connectionNames: string[];
	/** Maximum total planar copper per member, including supplied fanouts, in mm. */
	maxLength?: number;
	/** Minimum total planar copper per member, including supplied fanouts, in mm. */
	minLength?: number;
	maxLengthSkew?: number;
	traceWidth?: number;
	preferredLayer?: string;
	preferredLayers?: string[];
	allowedLayers?: string[];
}
export interface Wire extends Point$1 {
	route_type: "wire";
	layer: string;
	width: number;
}
export interface Via extends Point$1 {
	route_type: "via";
	from_layer: string;
	to_layer: string;
	layers?: string[];
	via_diameter?: number;
	via_hole_diameter?: number;
}
export interface Trace {
	/** Ending vertex indices of chords generated by the smooth tuner. */
	curvedSegments?: number[];
	/** Inclusive handoff vertex indices; independently tune only outside this shared corridor. */
	coupledSection?: [
		number,
		number
	];
	type: "pcb_trace";
	pcb_trace_id: string;
	connection_name?: string;
	source_trace_id?: string;
	route: (Wire | Via)[];
}
export interface Obstacle {
	type?: string;
	componentId?: string;
	shape?: "circle";
	ccwRotationDegrees?: number;
	center: Point$1;
	width: number;
	height: number;
	layers: string[];
	connectedTo: string[];
}
/** Structural SimpleRouteJson boundary; unknown routing primitives are rejected. */
export interface SimpleRouteJson {
	layerCount: number;
	/** Allowed signal carrier layers; fixed copper and pad dogbones may use other physical layers. */
	allowedLayers?: string[];
	minTraceWidth: number;
	minViaPadDiameter?: number;
	minViaHoleDiameter?: number;
	minViaHoleEdgeToViaHoleEdgeClearance?: number;
	allowBlindAndBuriedVias?: boolean;
	bounds: {
		minX: number;
		maxX: number;
		minY: number;
		maxY: number;
	};
	connections: Connection[];
	obstacles: Obstacle[];
	traces?: Trace[];
	buses?: Bus[];
	defaultObstacleMargin?: number;
	minTraceToPadEdgeClearance?: number;
	minBoardEdgeClearance?: number;
	outline?: Point$1[];
	differentialPairs?: Array<{
		connectionNames: [
			string,
			string
		];
		lengthTolerance: number;
		traceGap?: number;
		maxUncoupledLength?: number;
	}>;
}
export interface SolverOptions {
	smoothTuning?: boolean;
	denseSearch?: boolean;
	maxLaneIterations?: number;
	maxSearchIterations?: number;
}
/** Routes on an implicit clearance-offset visibility graph in board-world mm.
 * Every step expands a geometric vertex or commits a complete lane. */
export declare class BusLanesSolver extends BaseSolver {
	private readonly terminalLayers;
	readonly input: SimpleRouteJson;
	readonly options: SolverOptions;
	phase: string;
	failureCode: string | null;
	traces: Trace[];
	private widths;
	private fixed;
	private orders;
	private attempt;
	private lane;
	private search?;
	private bestPartial;
	private pairedTraces;
	private pairIndex;
	private congestionPass;
	private conflictingLanes;
	private independent?;
	private independentAttempted;
	private pairedNetwork?;
	private pairedNetworkAttempted;
	private negotiated?;
	private reservePackageExits?;
	private pairSearch?;
	private reportedRoutes?;
	private lengthStats?;
	constructor(input: SimpleRouteJson, options?: SolverOptions, terminalLayers?: ReadonlyMap<string, string[]>);
	/** Rematch freshly computed carrier geometry after a pipeline refinement.
	 * The ordinary output validator still checks every endpoint and copper edge. */
	static forRefinement(input: SimpleRouteJson, traces: Trace[], options?: SolverOptions): BusLanesSolver;
	/** Accept already matched candidates through the ordinary output validator. */
	static forValidation(input: SimpleRouteJson, traces: Trace[], options?: SolverOptions): BusLanesSolver;
	getConstructorParams(): (SimpleRouteJson | SolverOptions)[];
	getOutput(): {
		traces: Trace[];
		layerCount: number;
		allowedLayers?: string[];
		minTraceWidth: number;
		minViaPadDiameter?: number;
		minViaHoleDiameter?: number;
		minViaHoleEdgeToViaHoleEdgeClearance?: number;
		allowBlindAndBuriedVias?: boolean;
		bounds: {
			minX: number;
			maxX: number;
			minY: number;
			maxY: number;
		};
		connections: Connection[];
		obstacles: Obstacle[];
		buses?: Bus[];
		defaultObstacleMargin?: number;
		minTraceToPadEdgeClearance?: number;
		minBoardEdgeClearance?: number;
		outline?: Point$1[];
		differentialPairs?: Array<{
			connectionNames: [
				string,
				string
			];
			lengthTolerance: number;
			traceGap?: number;
			maxUncoupledLength?: number;
		}>;
	};
	private fail;
	tryFinalAcceptance(): void;
	private initialize;
	private get useNegotiation();
	private coupledPairs;
	private routePair;
	private scene;
	private startLane;
	private retry;
	private route;
	private match;
	private validateOutput;
	_step(): void;
	visualize(): GraphicsObject;
}
export interface BusLanesPipelineOptions extends SolverOptions {
	fanout?: "auto" | "none";
}
/** Board-world points in mm, +X right, +Y up. Adds only local terminal vias;
 * the interconnect solver retains its strict fixed-layer contract. */
export declare class BusLanesPipelineSolver extends BaseSolver {
	readonly input: SimpleRouteJson;
	readonly options: BusLanesPipelineOptions;
	phase: string;
	traces: Trace[];
	failureCode: string | null;
	private acceptedTraces?;
	private envelopeOptimization?;
	/** Runs only after a complete accepted route exists. A budget interrupt or
	 * exception restores that private snapshot, never mutable work-in-progress. */
	protected optimizeEnvelope(): Generator<void, void>;
	private finishAccepted;
	private sharedPackages?;
	private backwardPackages?;
	private child?;
	private escapes;
	private attempt;
	private completedLanes;
	private remainingInput?;
	private followingInput?;
	private siteRematch?;
	private packageCoupling?;
	private terminalLayers;
	constructor(input: SimpleRouteJson, options?: BusLanesPipelineOptions);
	getConstructorParams(): (SimpleRouteJson | BusLanesPipelineOptions)[];
	getOutput(): {
		traces: Trace[];
		layerCount: number;
		allowedLayers?: string[];
		minTraceWidth: number;
		minViaPadDiameter?: number;
		minViaHoleDiameter?: number;
		minViaHoleEdgeToViaHoleEdgeClearance?: number;
		allowBlindAndBuriedVias?: boolean;
		bounds: {
			minX: number;
			maxX: number;
			minY: number;
			maxY: number;
		};
		connections: Connection[];
		obstacles: Obstacle[];
		buses?: Bus[];
		defaultObstacleMargin?: number;
		minTraceToPadEdgeClearance?: number;
		minBoardEdgeClearance?: number;
		outline?: Point$1[];
		differentialPairs?: Array<{
			connectionNames: [
				string,
				string
			];
			lengthTolerance: number;
			traceGap?: number;
			maxUncoupledLength?: number;
		}>;
	};
	tryFinalAcceptance(): void;
	private childOptions;
	private finishPackageCoupling;
	private prepare;
	_step(): void;
	visualize(): GraphicsObject;
}
/** Check physical coupling outside native package/fanout regions, independently
 * of coupledSection annotations. Local breakouts are measured separately by
 * pairCouplingReports; a shortened annotation cannot hide a separated trunk. */
export declare function exteriorPairSpacingReports(input: SimpleRouteJson, traces: Trace[]): ({
	matched: boolean;
	maxExteriorEdgeGapMm: null;
	maxSamplingErrorMm: null;
	separatedExteriorLengthMm: null;
	connectionNames: [
		string,
		string
	];
	applicable: boolean;
} | {
	matched: boolean;
	maxExteriorEdgeGapMm: number | null;
	maxSamplingErrorMm: number;
	separatedExteriorLengthMm: number;
	connectionNames: [
		string,
		string
	];
	applicable: boolean;
})[];
export declare function busLengthReports(input: SimpleRouteJson, traces: Trace[]): {
	busId: string;
	minLengthMm: number | null;
	aboveMinimumLength: boolean;
	maxLengthMm: number | null;
	withinLengthLimit: boolean;
	toleranceMm: number | null;
	skewMm: number | null;
	matched: boolean;
	lengths: {
		name: string;
		carrierLengthMm: number | null;
		fixedLengthMm: number;
		totalLengthMm: number | null;
	}[];
}[];
export declare function pairLengthReports(input: SimpleRouteJson, traces: Trace[]): {
	busId: string;
	minLengthMm: number | null;
	aboveMinimumLength: boolean;
	maxLengthMm: number | null;
	withinLengthLimit: boolean;
	toleranceMm: number | null;
	skewMm: number | null;
	matched: boolean;
	lengths: {
		name: string;
		carrierLengthMm: number | null;
		fixedLengthMm: number;
		totalLengthMm: number | null;
	}[];
}[];

export {
	Point$1 as Point,
};

export {};