@jgengine/core 0.12.0 → 0.13.0

package/dist/world/features.d.ts

@@ -291,6 +291,34 @@ export interface SkyEnvironmentConfig {
     /** Raymarched volumetric cloud layer over the sky dome. Off by default — omit for no clouds. */
     volumetricClouds?: VolumetricCloudsConfig;
 }
+/** One road a `building({ along })` frontage lines with buildings: centerline + full width. */
+export interface BuildingFrontageRoad {
+    /** Road centerline vertices in world XZ; at least two points. */
+    path: readonly EnvironmentVec2[];
+    /** Road full width in world units; lots set back from `width / 2`. */
+    width: number;
+}
+/**
+ * Street-aware placement for `building()`: instead of a grid scattered around `position`, lots are
+ * stepped along each road's frontage, offset by a consistent setback (a curb + sidewalk strip), and
+ * turned so every building FRONT faces its road. `footprint` (`w` = frontage width, `d` = depth) and
+ * `spacing` (along-road gap) are shared with the grid mode. Deterministic and bounded by `maxLots`.
+ */
+export interface BuildingFrontageConfig {
+    /** Roads whose frontage is lined with lots. */
+    roads: readonly BuildingFrontageRoad[];
+    /** Sidewalk strip between the curb (`width / 2`) and the building front, world units. Default 3. */
+    setback?: number;
+    /** Place lots on both sides of each road. Default true. */
+    bothSides?: boolean;
+    /** Clip region; lots whose center falls outside are dropped. Omit to keep every lot. */
+    area?: {
+        center?: EnvironmentVec2;
+        halfExtents: EnvironmentVec2;
+    };
+    /** Hard cap on emitted lots so a long network stays bounded. Default 400. */
+    maxLots?: number;
+}
 export interface BuildingEnvironmentConfig {
     count?: number;
     position?: EnvironmentVec2;
@@ -303,6 +331,11 @@ export interface BuildingEnvironmentConfig {
     /** Explicit per-part-kind hex colors; any part left unset falls back to the resolved `style` palette. */
     palette?: BuildingPaletteOverrides;
     seed?: string;
+    /**
+     * Street-aware placement: derive lots along the given roads' frontage (facing each street, set
+     * back by a sidewalk strip) instead of the grid around `position`. See {@link BuildingFrontageConfig}.
+     */
+    along?: BuildingFrontageConfig;
 }
 export type PadSize = readonly [number, number] | {
     radius: number;
@@ -344,7 +377,7 @@ export type OceanEnvironmentDescriptor = {
 } & Required<Pick<OceanEnvironmentConfig, "bounds" | "level" | "waveHeight" | "waveScale" | "waveSpeed" | "color">> & Pick<OceanEnvironmentConfig, "position" | "levelAt">;
 export type BuildingEnvironmentDescriptor = {
     kind: "building";
-} & Required<Pick<BuildingEnvironmentConfig, "count" | "footprint" | "stories" | "storyHeight" | "spacing" | "style">> & Pick<BuildingEnvironmentConfig, "seed" | "position" | "palette">;
+} & Required<Pick<BuildingEnvironmentConfig, "count" | "footprint" | "stories" | "storyHeight" | "spacing" | "style">> & Pick<BuildingEnvironmentConfig, "seed" | "position" | "palette" | "along">;
 export type PadEnvironmentDescriptor = {
     kind: "pad";
 } & Required<Pick<PadEnvironmentConfig, "center" | "size" | "height" | "color">> & Pick<PadEnvironmentConfig, "rotationY" | "elevation">;
@@ -509,7 +542,7 @@ export declare function ocean(config?: OceanEnvironmentConfig): OceanEnvironment
 /** Declare a road ribbon for an `environment()` world; the shell drapes and renders it over the terrain. */
 export declare function road(config: RoadEnvironmentConfig): RoadEnvironmentDescriptor;
 export declare function island(config: TerrainIslandConfig): TerrainIslandDescriptor;
-/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. */
+/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. Pass `along` to line road frontage instead of gridding around `position`. */
 export declare function building(config?: BuildingEnvironmentConfig): BuildingEnvironmentDescriptor;
 export declare function pad(config: PadEnvironmentConfig): PadEnvironmentDescriptor;
 /** Declares a biome-painted world — the whole-world alternative to a single `environment()` terrain. */

package/dist/world/features.js

@@ -228,11 +228,13 @@ export function island(config) {
     const { kind: _kind, ...descriptor } = terrain(terrainConfig);
     return { ...descriptor, kind: "island", origin };
 }
-/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. */
+/** Declares a cluster of procedurally-massed buildings for `environment()` — count, footprint, stories, style. Pass `along` to line road frontage instead of gridding around `position`. */
 export function building(config = {}) {
     return withOptional({
         kind: "building",
-        count: config.count ?? 1,
+        // In frontage mode the road network sizes the district; `count` becomes an upper bound, so a
+        // caller that just says `along` gets a filled street rather than a single grid building.
+        count: config.count ?? (config.along === undefined ? 1 : config.along.maxLots ?? 400),
         footprint: config.footprint ?? { w: 8, d: 8 },
         stories: config.stories ?? [1, 4],
         storyHeight: config.storyHeight ?? 3,
@@ -242,6 +244,7 @@ export function building(config = {}) {
         ...(config.seed === undefined ? {} : { seed: config.seed }),
         ...(config.position === undefined ? {} : { position: config.position }),
         ...(config.palette === undefined ? {} : { palette: config.palette }),
+        ...(config.along === undefined ? {} : { along: config.along }),
     });
 }
 export function pad(config) {

package/dist/world/roads.d.ts

@@ -29,12 +29,29 @@ export interface RoadRibbonOptions {
  * into a mesh, and tests can assert on it directly.
  */
 export declare function buildRoadRibbon(path: readonly RoadPoint[], width: number, sampleHeight: (x: number, z: number) => number, options?: RoadRibbonOptions): RoadRibbon;
+/** A circular exclusion zone: dashes whose midpoint falls inside are dropped (e.g. junction patches). */
+export interface DashExclusion {
+    center: RoadPoint;
+    radius: number;
+}
+/**
+ * Build a flat, ground-draped disc patch centered on `center` — the welded junction surface that
+ * covers crossing road ribbons so they read as one intersection instead of stacking/z-fighting.
+ * A triangle fan of `segments` sides (default 16), every vertex draped at `sampleHeight + elevation`.
+ * Pure geometry; the shell meshes the result with the asphalt material.
+ */
+export declare function buildJunctionPatch(center: RoadPoint, radius: number, sampleHeight: (x: number, z: number) => number, options?: {
+    elevation?: number;
+    segments?: number;
+}): RoadRibbon;
 /**
  * Split a centerline into dash sub-polylines for lane markings: `dashLength` of painted line,
  * `gapLength` of asphalt, repeated along the path's arc length. Feed each returned sub-path back
- * through {@link buildRoadRibbon} with a thin width to mesh the dashes.
+ * through {@link buildRoadRibbon} with a thin width to mesh the dashes. Pass `exclude` circles
+ * (junction patches) to interrupt the center line through intersections — any dash whose midpoint
+ * lands inside an exclusion is dropped.
  */
-export declare function dashSegments(path: readonly RoadPoint[], dashLength?: number, gapLength?: number): readonly (readonly RoadPoint[])[];
+export declare function dashSegments(path: readonly RoadPoint[], dashLength?: number, gapLength?: number, exclude?: readonly DashExclusion[]): readonly (readonly RoadPoint[])[];
 /** Result of {@link nearestOnPath}: closest point on the centerline plus distance and tangent. */
 export interface RoadSample {
     /** Closest point on the centerline. */

package/dist/world/roads.js

@@ -102,12 +102,48 @@ export function buildRoadRibbon(path, width, sampleHeight, options = {}) {
     }
     return { positions, indices };
 }
+/**
+ * Build a flat, ground-draped disc patch centered on `center` — the welded junction surface that
+ * covers crossing road ribbons so they read as one intersection instead of stacking/z-fighting.
+ * A triangle fan of `segments` sides (default 16), every vertex draped at `sampleHeight + elevation`.
+ * Pure geometry; the shell meshes the result with the asphalt material.
+ */
+export function buildJunctionPatch(center, radius, sampleHeight, options = {}) {
+    const elevation = options.elevation ?? 0.08;
+    const segments = Math.max(3, Math.floor(options.segments ?? 16));
+    if (radius <= 0)
+        return { positions: new Float32Array(0), indices: new Uint32Array(0) };
+    const [cx, cz] = center;
+    // Center vertex + one ring vertex per segment.
+    const positions = new Float32Array((segments + 1) * 3);
+    positions[0] = cx;
+    positions[1] = sampleHeight(cx, cz) + elevation;
+    positions[2] = cz;
+    for (let i = 0; i < segments; i += 1) {
+        const angle = (i / segments) * Math.PI * 2;
+        const x = cx + Math.cos(angle) * radius;
+        const z = cz + Math.sin(angle) * radius;
+        const base = (i + 1) * 3;
+        positions[base] = x;
+        positions[base + 1] = sampleHeight(x, z) + elevation;
+        positions[base + 2] = z;
+    }
+    const indices = new Uint32Array(segments * 3);
+    for (let i = 0; i < segments; i += 1) {
+        indices[i * 3] = 0;
+        indices[i * 3 + 1] = i + 1;
+        indices[i * 3 + 2] = ((i + 1) % segments) + 1;
+    }
+    return { positions, indices };
+}
 /**
  * Split a centerline into dash sub-polylines for lane markings: `dashLength` of painted line,
  * `gapLength` of asphalt, repeated along the path's arc length. Feed each returned sub-path back
- * through {@link buildRoadRibbon} with a thin width to mesh the dashes.
+ * through {@link buildRoadRibbon} with a thin width to mesh the dashes. Pass `exclude` circles
+ * (junction patches) to interrupt the center line through intersections — any dash whose midpoint
+ * lands inside an exclusion is dropped.
  */
-export function dashSegments(path, dashLength = 3, gapLength = 3) {
+export function dashSegments(path, dashLength = 3, gapLength = 3, exclude = []) {
     if (path.length < 2 || dashLength <= 0 || gapLength < 0)
         return [];
     const cumulative = [0];
@@ -136,7 +172,28 @@ export function dashSegments(path, dashLength = 3, gapLength = 3) {
         const end = Math.min(total, start + dashLength);
         if (end - start < 1e-6)
             break;
-        dashes.push([pointAt(start), pointAt(end)]);
+        const a = pointAt(start);
+        const b = pointAt(end);
+        if (exclude.length > 0) {
+            const mx = (a[0] + b[0]) / 2;
+            const mz = (a[1] + b[1]) / 2;
+            let excluded = false;
+            for (let e = 0; e < exclude.length; e += 1) {
+                const zone = exclude[e];
+                const dx = mx - zone.center[0];
+                const dz = mz - zone.center[1];
+                if (dx * dx + dz * dz <= zone.radius * zone.radius) {
+                    excluded = true;
+                    break;
+                }
+            }
+            if (excluded) {
+                if (period <= 0)
+                    break;
+                continue;
+            }
+        }
+        dashes.push([a, b]);
         if (period <= 0)
             break;
     }

package/dist/world/{pathNetwork.d.ts → streetGenerator.d.ts}

@@ -1,61 +1,61 @@
 /** A path vertex in the volume-local XZ frame. */
-export type PathVec2 = readonly [number, number];
+export type StreetVec2 = readonly [number, number];
 /** Road hierarchy, widest to narrowest — shared by the city fabric and the renderer. */
-export type PathLevel = "boulevard" | "avenue" | "street" | "lane";
+export type StreetLevel = "boulevard" | "avenue" | "street" | "lane";
 /** A path feature spanning part of an edge/street: a bridge deck over a gap or a tunnel bore under a ridge. */
-export type PathFeatureKind = "bridge" | "tunnel";
+export type StreetFeatureKind = "bridge" | "tunnel";
 /** The generator's chosen topology family: an open street `net`, or a closed `circuit` loop. */
-export type PathNetworkMode = "net" | "circuit";
+export type StreetNetworkMode = "net" | "circuit";
 /** One graph node: a junction, a dead end, or a mid-street bend, with its connection count. */
-export interface PathNode {
+export interface StreetNode {
     id: number;
     x: number;
     z: number;
     degree: number;
 }
 /** One atomic node-to-node edge — the fabric graph consumes these (welds at shared node coords). */
-export interface PathEdge {
+export interface StreetEdge {
     id: number;
     /** Endpoint node ids. */
     a: number;
     b: number;
     /** Sampled centerline; `points[0]` sits exactly on node `a`, the last on node `b`. */
-    points: PathVec2[];
+    points: StreetVec2[];
     width: number;
-    level: PathLevel;
+    level: StreetLevel;
     /** True when this edge belongs to the main closed loop (circuit mode). */
     loop: boolean;
 }
 /** A feature span carried by a street: a `[from, to]` index window into the street's `points`. */
-export interface PathFeatureSpan {
-    kind: PathFeatureKind;
+export interface StreetFeatureSpan {
+    kind: StreetFeatureKind;
     from: number;
     to: number;
     /** Ground height at each bank/portal — the deck/floor reference the renderer drapes to. */
     bankHeight: number;
 }
 /** One chained through-street: a maximal run of edges through degree-2 nodes, for rendering + furniture. */
-export interface PathStreet {
+export interface Street {
     id: number;
     /** Ordered node ids the chain visits; first === last when `loop`. */
     nodes: number[];
     /** Smoothed, turn-clamped centerline. */
-    points: PathVec2[];
+    points: StreetVec2[];
     width: number;
-    level: PathLevel;
+    level: StreetLevel;
     /** Closed chain (a circuit lap or an inner ring). */
     loop: boolean;
     /** Cul-de-sac turning bulb when the street ends at a dangling node. */
-    bulb?: PathVec2;
+    bulb?: StreetVec2;
     /** Bridge/tunnel spans along this street, if any. */
-    features: PathFeatureSpan[];
+    features: StreetFeatureSpan[];
 }
 /** One crossing of three or more streets: patch center/radius plus outgoing arm directions. */
-export interface PathJunction {
+export interface StreetJunction {
     x: number;
     z: number;
     radius: number;
-    level: PathLevel;
+    level: StreetLevel;
     /** Outgoing arm directions (radians) with the crossing street width, for crosswalks/patches. */
     arms: {
         angle: number;
@@ -63,7 +63,7 @@ export interface PathJunction {
     }[];
 }
 /** One dangling street end kept as a cul-de-sac: node position plus the heading pointing off the road. */
-export interface PathDeadEnd {
+export interface StreetDeadEnd {
     node: number;
     x: number;
     z: number;
@@ -72,29 +72,29 @@ export interface PathDeadEnd {
     width: number;
 }
 /** A resolved path feature in world-of-the-volume space: a bridge deck or tunnel bore centerline. */
-export interface PathFeature {
-    kind: PathFeatureKind;
-    points: PathVec2[];
+export interface StreetFeature {
+    kind: StreetFeatureKind;
+    points: StreetVec2[];
     width: number;
     bankHeight: number;
 }
 /** The fully-resolved network in volume-local coords. */
-export interface PathNetwork {
-    mode: PathNetworkMode;
-    nodes: PathNode[];
+export interface StreetNetwork {
+    mode: StreetNetworkMode;
+    nodes: StreetNode[];
     /** Atomic edges — feed to the block/parcel fabric. */
-    edges: PathEdge[];
+    edges: StreetEdge[];
     /** Chained through-streets — feed to the renderer, furniture, and analysis. */
-    streets: PathStreet[];
-    junctions: PathJunction[];
-    deadEnds: PathDeadEnd[];
-    bridges: PathFeature[];
-    tunnels: PathFeature[];
+    streets: Street[];
+    junctions: StreetJunction[];
+    deadEnds: StreetDeadEnd[];
+    bridges: StreetFeature[];
+    tunnels: StreetFeature[];
     /** Independent cycle count (E − V + components): 0 = pure tree, ≥1 = has loops. */
     loops: number;
 }
 /** Fully-defaulted slider set the generator reads. */
-export interface PathNetworkRules {
+export interface StreetNetworkRules {
     seed: string;
     /** 1 = regular lattice nodes; 0 = organic scatter. */
     gridness: number;
@@ -124,7 +124,7 @@ export interface PathNetworkRules {
     boulevards: number;
 }
 /** Ground sampler + feature toggles enabling bridges/tunnels; omit for a flat, feature-free network. */
-export interface PathNetworkContext {
+export interface StreetNetworkContext {
     /** Volume-local ground height sampler. */
     heightAt?: (x: number, z: number) => number;
     /** Ground below this (local) height is a gap streets bridge over. */
@@ -143,17 +143,17 @@ export interface PathNetworkContext {
  * strictly reduces the angle. Endpoints never move, so a graph node stays welded.
  * @internal
  */
-export declare function clampTurns(points: readonly PathVec2[], minRad: number, maxRad: number): PathVec2[];
+export declare function clampTurns(points: readonly StreetVec2[], minRad: number, maxRad: number): StreetVec2[];
 /** Decide which topology family the sliders call for. Circuit wins when loops dominate and both
  *  branching and mesh connectivity are low — exactly the "race track" corner of the slider space.
  *  @internal */
-export declare function pathNetworkMode(rules: PathNetworkRules): PathNetworkMode;
+export declare function streetNetworkMode(rules: StreetNetworkRules): StreetNetworkMode;
 /**
  * Resolve a full path network from its rules inside a volume of half-extents `hx`×`hz`. Deterministic
- * per `(rules.seed, hx, hz, context)`. Pass a {@link PathNetworkContext} with a ground sampler to turn
+ * per `(rules.seed, hx, hz, context)`. Pass a {@link StreetNetworkContext} with a ground sampler to turn
  * water gaps into bridges and ridges into tunnels. Coordinates are volume-local; the caller maps to
  * world space.
  *
- * @capability path-network build a deterministic road/track graph (nodes, edges, streets, junctions, bridges, tunnels) from sliders
+ * @capability street-generator build a deterministic street/track graph (nodes, edges, streets, junctions, bridges, tunnels) from sliders
  */
-export declare function buildPathNetwork(rules: PathNetworkRules, hx: number, hz: number, context?: PathNetworkContext): PathNetwork;
+export declare function generateStreets(rules: StreetNetworkRules, hx: number, hz: number, context?: StreetNetworkContext): StreetNetwork;

package/dist/world/{pathNetwork.js → streetGenerator.js}

@@ -1,5 +1,5 @@
 /**
- * The unified, seed-driven procedural PATH NETWORK — one generator that grows an entire road/track
+ * The unified, seed-driven procedural STREET GENERATOR — one engine that grows an entire street/track
  * graph inside a box volume and answers to sliders instead of hardcoded geometry. It is deliberately
  * genre-agnostic: a city street net and a closed race circuit are the *same* engine at opposite
  * slider extremes, not two code paths. Drop a volume, pick a seed, and turn the dials:
@@ -16,14 +16,14 @@
  *   BRIDGE deck; a span buried under a ridge becomes a TUNNEL bore. Both are path FEATURES on a
  *   continuous edge, so a circuit stays closed as it crosses water or pierces a hill.
  *
- * Output is two coupled views of the graph: atomic node-to-node {@link PathEdge}s (fed straight into
+ * Output is two coupled views of the graph: atomic node-to-node {@link StreetEdge}s (fed straight into
  * the block/parcel fabric — a race circuit is many edges between distinct nodes, never one fragile
- * self-loop) and chained {@link PathStreet}s (through-streets for rendering, furniture, and
+ * self-loop) and chained {@link Street}s (through-streets for rendering, furniture, and
  * junctions). Pure deterministic math — same rules + seed + volume ⇒ identical network — with bounded
  * work caps so a huge volume can never generate unbounded content. Local (volume-centered) coords;
  * the caller rotates/translates into world space.
  *
- * @capability path-network seed-driven procedural roads and race circuits from one slider-driven engine
+ * @capability street-generator seed-driven procedural streets and race circuits from one slider-driven engine
  */
 import { seededStreams } from "../random/rng.js";
 const TAU = Math.PI * 2;
@@ -369,7 +369,7 @@ function buildCircuit(rules, hx, hz, streams) {
 /** Decide which topology family the sliders call for. Circuit wins when loops dominate and both
  *  branching and mesh connectivity are low — exactly the "race track" corner of the slider space.
  *  @internal */
-export function pathNetworkMode(rules) {
+export function streetNetworkMode(rules) {
     const score = rules.loopiness * (1 - rules.branching * 0.7) * (1 - rules.connectivity * 0.7);
     return score >= 0.45 ? "circuit" : "net";
 }
@@ -396,15 +396,15 @@ function levelForStreets(chains, rules, rng) {
 }
 /**
  * Resolve a full path network from its rules inside a volume of half-extents `hx`×`hz`. Deterministic
- * per `(rules.seed, hx, hz, context)`. Pass a {@link PathNetworkContext} with a ground sampler to turn
+ * per `(rules.seed, hx, hz, context)`. Pass a {@link StreetNetworkContext} with a ground sampler to turn
  * water gaps into bridges and ridges into tunnels. Coordinates are volume-local; the caller maps to
  * world space.
  *
- * @capability path-network build a deterministic road/track graph (nodes, edges, streets, junctions, bridges, tunnels) from sliders
+ * @capability street-generator build a deterministic street/track graph (nodes, edges, streets, junctions, bridges, tunnels) from sliders
  */
-export function buildPathNetwork(rules, hx, hz, context = {}) {
+export function generateStreets(rules, hx, hz, context = {}) {
     const streams = seededStreams(`pathnet:${rules.seed}:${Math.round(hx)}:${Math.round(hz)}`);
-    const mode = pathNetworkMode(rules);
+    const mode = streetNetworkMode(rules);
     const raw = mode === "circuit" ? buildCircuit(rules, hx, hz, streams) : buildNet(rules, hx, hz, streams);
     const rawNodes = raw.nodes;
     const rawEdges = raw.edges.filter((e) => e.a !== e.b);

package/dist/world/streets.d.ts

@@ -1,5 +1,5 @@
 import type { RoadEnvironmentDescriptor } from "./features.js";
-import { type RoadPoint } from "./roads.js";
+import { type DashExclusion, type RoadPoint } from "./roads.js";
 /**
  * Offset a centerline sideways by a signed distance along its local perpendicular — the
  * building block for lanes, curb lines, and sidewalk paths. Positive offsets fall on the
@@ -107,3 +107,76 @@ export declare function roadSurfaceSampler(roads: readonly RoadEnvironmentDescri
  * band, `fraction` (0..1) picks how far along. The canonical pedestrian spawn helper.
  */
 export declare function sidewalkPoint(road: RoadEnvironmentDescriptor, side: "left" | "right", fraction: number): RoadPoint | null;
+/**
+ * The two curb lines of a road — offset polylines running along the outer edge of the asphalt on
+ * each side. Mesh these with a thin darker ribbon to give the road a curb/edge strip instead of a
+ * hard asphalt-to-terrain seam. `inset` (default 0) nudges the line inward off the raw edge so the
+ * strip straddles the border.
+ */
+export declare function curbPaths(road: RoadEnvironmentDescriptor, inset?: number): readonly [readonly RoadPoint[], readonly RoadPoint[]];
+/** A single arm of a junction: the road width plus the outward direction the road leaves the center. */
+export interface RoadApproach {
+    /** Unit vector pointing from the junction center outward along the road arm. */
+    direction: readonly [number, number];
+    /** Drivable width of the road on this arm. */
+    width: number;
+}
+/** A welded road intersection: a patch center/radius plus the arms that feed it. */
+export interface RoadJunction {
+    /** World XZ center of the intersection. */
+    center: RoadPoint;
+    /** Radius of the covering patch (covers the crossing ribbons). */
+    radius: number;
+    /** Representative surface elevation (max of the participating roads). */
+    elevation: number;
+    /** Representative asphalt color (the widest participating road's color). */
+    color: string;
+    /** Outward arms leaving the junction — one per road direction that continues past the center. */
+    approaches: readonly RoadApproach[];
+}
+/** Options for {@link findRoadJunctions}. */
+export interface RoadJunctionOptions {
+    /** Roads weld only when their elevations differ by at most this much. Default 0.12. */
+    elevationBand?: number;
+    /** Crossing points closer than this merge into a single junction. Default 6. */
+    mergeDistance?: number;
+    /** Hard cap on junctions returned so detection stays bounded. Default 256. */
+    maxJunctions?: number;
+    /** Extra scale on the patch radius past the widest arm's half-width. Default 1.15. */
+    radiusScale?: number;
+}
+/**
+ * Detect welded intersections across a set of roads: wherever two road centerlines cross (or a road
+ * terminates on another) within the same elevation band, emit a {@link RoadJunction} whose patch
+ * covers the crossing ribbons. Nearby crossings merge into one junction. Deterministic and bounded —
+ * O(roads² · segments²) with a `maxJunctions` cap — so a scene builds its intersections once.
+ */
+export declare function findRoadJunctions(roads: readonly RoadEnvironmentDescriptor[], options?: RoadJunctionOptions): readonly RoadJunction[];
+/** Circular marking-exclusion zones for the junctions, sized to hide the center line under each patch. */
+export declare function junctionExclusions(junctions: readonly RoadJunction[], pad?: number): readonly DashExclusion[];
+/** Options for {@link junctionMarkings}. */
+export interface JunctionMarkingOptions {
+    /** Emit a stop-line bar across each approach. Default true. */
+    stopLines?: boolean;
+    /** Emit crosswalk bars at each approach. Default true. */
+    crosswalks?: boolean;
+    /** Number of zebra bars per crosswalk. Default 5. */
+    crosswalkBars?: number;
+    /** Clear gap outside the patch before markings start. Default 0.6. */
+    gap?: number;
+    /** Depth (along travel) of the crosswalk band. Default 2.4. */
+    crosswalkDepth?: number;
+}
+/** Thin marking polylines for a junction: stop-line bars and crosswalk bars, ready for {@link buildRoadRibbon}. */
+export interface JunctionMarkings {
+    /** One bar per approach, perpendicular to travel just outside the patch. */
+    stopLines: readonly (readonly RoadPoint[])[];
+    /** Continental (parallel-to-travel) zebra bars, `crosswalkBars` per approach. */
+    crosswalkBars: readonly (readonly RoadPoint[])[];
+}
+/**
+ * Data-driven junction entry markings: a stop-line bar across each approach and a band of crosswalk
+ * bars just outside the welded patch. Each returned polyline is a thin centerline meant to be meshed
+ * with {@link buildRoadRibbon} at a small width. Fully skippable per-feature via the options.
+ */
+export declare function junctionMarkings(junction: RoadJunction, options?: JunctionMarkingOptions): JunctionMarkings;