@willcgage/module-schematic 0.103.0 → 0.106.0

package/dist/index.cjs

@@ -1698,7 +1698,7 @@ var FAST_TRACKS_N_ME55_CROSSOVERS = [
     trackSpacing: {
       inches: spacing,
       source: manufacturer,
-      note: `${spec}. \u26A0\uFE0F Free-moN \xA72.0 requires ${FREEMO_TRACK_SPACING_INCHES}\u2033 \u2014 this fixture is built to ${spacing}\u2033, ${(FREEMO_TRACK_SPACING_INCHES - spacing).toFixed(3)}\u2033 tighter, and cannot be built to another spacing.`
+      note: `${spec}. ${spacing}\u2033, and the fixture cannot be built to another spacing. \u26A0\uFE0F THIS IS NOT A DEPARTURE FROM THE STANDARD. Free-moN \xA72.0 fixes ${FREEMO_TRACK_SPACING_INCHES}\u2033 at the ENDPLATE \u2014 "double track endplates must have a track spacing of 1.125 inches", with track perpendicular, straight and level for 4\u2033 from the outside face. What the two mains do in between is the module builder's business, and every real double crossover pinches them closer. Earlier wording here called the fixture "tighter than the standard", which reads as non-conformance and is wrong.`
     }
   };
 });
@@ -2176,6 +2176,31 @@ function turnoutClosure(size, opts = {}) {
     }
   };
 }
+function crossoverAssembly(part) {
+  const overall = part.overallLength?.inches;
+  const spacing = part.trackSpacing?.inches;
+  const n = part.frogNumber;
+  if (!overall || !spacing || !n) return null;
+  const lengthInches = overall * (part.piecesPerAssembly ?? 1);
+  const tan = part.actualAngle ? Math.tan(part.actualAngle.deg * Math.PI / 180) : 1 / n;
+  if (!(tan > 0)) return null;
+  const crossingRunInches = spacing / tan;
+  const mid = lengthInches / 2;
+  const half = crossingRunInches / 2;
+  return {
+    lengthInches,
+    spacingInches: spacing,
+    crossingRunInches,
+    pointsAtInches: [mid - half, mid + half],
+    scissorsAtInches: mid
+  };
+}
+function weakestOf(...ds) {
+  const rank = ["measured", "manufacturer", "derived", "unverified"];
+  let worst = 0;
+  for (const d of ds) if (d) worst = Math.max(worst, rank.indexOf(d.source));
+  return rank[worst];
+}
 function partGeometryGap(part) {
   if (part.kind === "flex") return null;
   if (part.kind === "bumper") return null;
@@ -2186,8 +2211,13 @@ function partGeometryGap(part) {
     if (part.arcDegrees == null) return "no arc \u2014 the radius alone does not say how far it turns";
     return null;
   }
-  if (part.kind === "crossover")
-    return "a crossover fixture builds one HALF of the assembly (piecesPerAssembly), so its published lengths describe a piece, not the finished part \u2014 the geometry of the whole crossover is not yet derivable from them";
+  if (part.kind === "crossover") {
+    if (!part.overallLength) return "no overall length \u2014 nothing says how long the assembly is";
+    if (!part.trackSpacing)
+      return "no track spacing \u2014 a crossover is defined by how far apart the two tracks it joins are";
+    if (part.frogNumber == null) return "no frog number \u2014 the crossing angle is unknown";
+    return null;
+  }
   if (part.kind === "crossing") return "crossing geometry is not modelled yet";
   if (part.kind === "curved-turnout")
     return "a curved turnout needs both radii AND its points/frog landmarks; only the radii are published";
@@ -2230,6 +2260,30 @@ function partGeometry(part, library = BUILT_IN_TRACK_PARTS) {
       divergingEndMeasured: false
     };
   }
+  if (part.kind === "crossover") {
+    const g = crossoverAssembly(part);
+    if (!g) return null;
+    return {
+      joints: [
+        { id: "a1", role: "crossoverEnd", x: 0, y: 0, angleDeg: 180 },
+        { id: "b1", role: "crossoverEnd", x: g.lengthInches, y: 0, angleDeg: 0 },
+        { id: "a2", role: "crossoverEnd", x: 0, y: g.spacingInches, angleDeg: 180 },
+        { id: "b2", role: "crossoverEnd", x: g.lengthInches, y: g.spacingInches, angleDeg: 0 }
+      ],
+      // ⭐ FOUR ROUTES, and that is the whole point. From either end of either
+      // track a train can run straight on or cross to the other — which is what
+      // makes this ONE assembly rather than four turnouts that happen to be near
+      // each other.
+      routes: [
+        ["a1", "b1"],
+        ["a2", "b2"],
+        ["a1", "b2"],
+        ["a2", "b1"]
+      ],
+      source: weakestOf(part.overallLength, part.trackSpacing),
+      divergingEndMeasured: false
+    };
+  }
   const N = part.frogNumber;
   const points = part.pointsOffset;
   const overall = part.overallLength;
@@ -2325,6 +2379,30 @@ function pieceRoutePaths(piece, library = BUILT_IN_TRACK_PARTS) {
     pts[pts.length - 1] = { x: b.x, y: b.y };
     return [{ route: ["a", "b"], points: pts }];
   }
+  if (part.kind === "crossover") {
+    const g = crossoverAssembly(part);
+    if (g) {
+      const [p1, p2] = g.pointsAtInches;
+      const S = g.spacingInches;
+      const L = g.lengthInches;
+      const yOf = (id) => id.endsWith("2") ? S : 0;
+      return geo.routes.map((route) => {
+        const [from, to] = route;
+        const y0 = yOf(from);
+        const y1 = yOf(to);
+        const x0 = from.startsWith("a") ? 0 : L;
+        const x1 = to.startsWith("a") ? 0 : L;
+        if (y0 === y1)
+          return { route, points: [place(x0, y0), place(x1, y1)] };
+        const west = Math.min(x0, x1) === 0;
+        const [xa, xb] = west ? [p1, p2] : [p2, p1];
+        return {
+          route,
+          points: [place(x0, y0), place(xa, y0), place(xb, y1), place(x1, y1)]
+        };
+      });
+    }
+  }
   for (const route of geo.routes) {
     const a = at(route[0]);
     const b = at(route[1]);
@@ -2693,7 +2771,11 @@ function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS)
         route.closedBy = here.piece;
         break;
       }
-      const pick = opts.find((r) => r.includes("through")) ?? opts[0];
+      const sameTrack = (r) => {
+        const other = r[0] === here.joint ? r[1] : r[0];
+        return other.slice(-1) === here.joint.slice(-1);
+      };
+      const pick = (partOf(here.piece)?.kind === "crossover" ? opts.find(sameTrack) : void 0) ?? opts.find((r) => r.includes("through")) ?? opts[0];
       const exitJoint = pick[0] === here.joint ? pick[1] : pick[0];
       const exit = byKey.get(`${here.piece}.${exitJoint}`);
       const part = partOf(here.piece);
@@ -2816,7 +2898,11 @@ function graphToDoc(pieces, input) {
   const main = walk.routes.find((r) => r.id === "main");
   const walk2 = input.start2 ? walkTrackGraph(graph, pieces, input.start2, library) : null;
   const main2 = walk2?.routes.find((r) => r.id === "main") ?? null;
-  const claimed = new Set(walk.routes.flatMap((r) => r.pieces));
+  const sharedByDesign = (id) => {
+    const piece = pieces.find((p) => p.id === id);
+    return library.find((p) => p.id === piece?.partId)?.kind === "crossover";
+  };
+  const claimed = new Set(walk.routes.flatMap((r) => r.pieces).filter((p) => !sharedByDesign(p)));
   if (main2 && main2.pieces.some((p) => claimed.has(p))) {
     warnings.push(
       "Main 2 starts on track that Main 1 already runs along \u2014 they are one run, not two"
@@ -2933,6 +3019,74 @@ function graphToDoc(pieces, input) {
       ...part ? { partId: part.id } : {}
     });
   }
+  const crossoverSpans = (() => {
+    const found = [];
+    const routesAll = [
+      ...walk.routes.map((r) => ({ r, prefix: "" })),
+      ...twoMains ? walk2.routes.map((r) => ({ r, prefix: "main2:" })) : []
+    ];
+    const seen = /* @__PURE__ */ new Map();
+    for (const { r, prefix } of routesAll) {
+      for (const sp of r.spans) {
+        const piece = pieceById.get(sp.piece);
+        const part = piece ? library.find((p) => p.id === piece.partId) : void 0;
+        if (!part || part.kind !== "crossover") continue;
+        const g = crossoverAssembly(part);
+        if (!g) continue;
+        const [p1, p2] = g.pointsAtInches;
+        const west = sp.entryJoint.startsWith("a");
+        const at = west ? [sp.fromPos + p1, sp.fromPos + p2] : [sp.fromPos + (g.lengthInches - p2), sp.fromPos + (g.lengthInches - p1)];
+        const track = sp.entryJoint.endsWith("2") ? 2 : 1;
+        const routeId = r.id === "main" && prefix ? "main2:main" : `${prefix}${r.id}`;
+        const rec = seen.get(sp.piece) ?? { piece: sp.piece, part, byTrack: /* @__PURE__ */ new Map() };
+        rec.byTrack.set(track, { routeId, at });
+        seen.set(sp.piece, rec);
+      }
+    }
+    for (const rec of seen.values()) if (rec.byTrack.size === 2) found.push(rec);
+    return found;
+  })();
+  for (const xo of crossoverSpans) {
+    const one = xo.byTrack.get(1);
+    const two = xo.byTrack.get(2);
+    const onA = trackIdOf.get(one.routeId) ?? MAIN_TRACK_ID;
+    const onB = trackIdOf.get(two.routeId) ?? MAIN2_TRACK_ID;
+    const legs = [
+      { id: `${xo.piece}-a`, from: [onA, one.at[0]], to: [onB, two.at[1]] },
+      { id: `${xo.piece}-b`, from: [onB, two.at[0]], to: [onA, one.at[1]] }
+    ];
+    for (const leg of legs) {
+      tracks.push({
+        id: leg.id,
+        role: "crossover",
+        // The connector lives between the mains, so it takes Main 2's lane —
+        // the same lane the 1-D model has always drawn a crossover in.
+        lane: main2Lane ?? 1,
+        fromPos: round(Math.min(leg.from[1], leg.to[1])),
+        toPos: round(Math.max(leg.from[1], leg.to[1])),
+        trackName: xo.part.name ?? "Crossover",
+        crossoverPartId: xo.part.id
+      });
+      turnouts.push(
+        {
+          id: `${leg.id}-1`,
+          pos: round(leg.from[1]),
+          onTrack: leg.from[0],
+          divergeTrack: leg.id,
+          name: xo.part.name ?? "Crossover",
+          ...xo.part.frogNumber != null ? { size: xo.part.frogNumber } : {}
+        },
+        {
+          id: `${leg.id}-2`,
+          pos: round(leg.to[1]),
+          onTrack: leg.to[0],
+          divergeTrack: leg.id,
+          name: xo.part.name ?? "Crossover",
+          ...xo.part.frogNumber != null ? { size: xo.part.frogNumber } : {}
+        }
+      );
+    }
+  }
   turnouts.sort((a, b) => a.pos - b.pos);
   for (const t of tracks) {
     if (t.role === "main") continue;
@@ -3028,7 +3182,29 @@ function moduleConversionReport(doc, library = BUILT_IN_TRACK_PARTS) {
   const straight = placeableTurnoutParts(library, ["turnout"]);
   const curved = placeableTurnoutParts(library, ["curved-turnout"]);
   const blockers = [];
+  const assemblyPart = /* @__PURE__ */ new Map();
+  for (const t of doc.tracks ?? []) {
+    if (t.role !== "crossover" || !t.crossoverPartId) continue;
+    const part = library.find((p) => p.id === t.crossoverPartId);
+    if (!part || part.kind !== "crossover" || partGeometryGap(part)) continue;
+    for (const sw of doc.turnouts ?? [])
+      if (sw.divergeTrack === t.id) assemblyPart.set(sw.id, part);
+  }
   const turnouts = (doc.turnouts ?? []).map((t) => {
+    const asm = assemblyPart.get(t.id);
+    if (asm)
+      return {
+        id: t.id,
+        name: t.name,
+        pos: t.pos,
+        size: t.size,
+        statedPartId: t.partId,
+        partId: asm.id,
+        from: "assembly",
+        source: partGeometry(asm, library)?.source ?? null,
+        why: null,
+        candidates: []
+      };
     const wantCurved = t.curved === true;
     const pool = wantCurved ? curved : straight;
     const base = {
@@ -3115,9 +3291,17 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
       "this module's mainline is drawn with bends, and laying it as pieces would need each bend's radius \u2014 convert it once curved runs are supported"
     );
   const partById = new Map(library.map((p) => [p.id, p]));
+  const inAssembly = /* @__PURE__ */ new Set();
+  for (const t of doc.tracks ?? []) {
+    if (t.role !== "crossover" || !t.crossoverPartId) continue;
+    const part = partById.get(t.crossoverPartId);
+    if (!part || part.kind !== "crossover" || partGeometryGap(part)) continue;
+    for (const sw of doc.turnouts ?? []) if (sw.divergeTrack === t.id) inAssembly.add(sw.id);
+  }
   const chosen = /* @__PURE__ */ new Map();
   const unknown = [];
   for (const t of report.turnouts) {
+    if (inAssembly.has(t.id)) continue;
     const id = answers.overrides?.[t.id] ?? (t.partId ? t.partId : answers.turnoutPartId) ?? null;
     const part = id ? partById.get(id) : void 0;
     if (!part || partGeometryGap(part)) unknown.push(t.id);
@@ -3200,19 +3384,26 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
     const divergeId = geom.joints.find((j) => j.role === "diverge")?.id ?? "diverge";
     return { t, piece, span, divergeId };
   };
+  const aimEndAt = (piece, to) => {
+    const dx = to.x - piece.x;
+    const dy = to.y - piece.y;
+    const len = Math.hypot(dx, dy);
+    if (!(len > 0)) return;
+    piece.rotationDeg = Math.atan2(dy, dx) * 180 / Math.PI;
+    piece.lengthInches = len;
+  };
   const layFlex = (label, hostY, fromPos, toPos, occupied, cuts) => {
     const out = flexPieces({ fromPos, toPos, maxPieceInches: maxPiece, occupied, cuts: cuts ?? null });
-    out.forEach(
-      (f, i) => pieces.push({
-        id: `f-${label}-${i}`,
-        partId: flexId,
-        x: f.fromPos,
-        y: hostY,
-        rotationDeg: 0,
-        lengthInches: r3(f.lengthInches)
-      })
-    );
-    return out;
+    const placed = out.map((f, i) => ({
+      id: `f-${label}-${i}`,
+      partId: flexId,
+      x: f.fromPos,
+      y: hostY,
+      rotationDeg: 0,
+      lengthInches: r3(f.lengthInches)
+    }));
+    pieces.push(...placed);
+    return placed;
   };
   const turnoutsOn = (trackId, hostY) => {
     const laid = turnouts.filter((t) => t.onTrack === trackId && chosen.has(t.id)).map((t) => layTurnout(t, hostY)).sort((a, b) => a.span.fromPos - b.span.fromPos);
@@ -3225,19 +3416,64 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
         clashed.add(cur.t.id);
         const gap = Math.abs(cur.t.pos - prev.t.pos);
         const body = prev.span.toPos - prev.span.fromPos;
+        const asm = trackById.get(cur.t.divergeTrack)?.role === "crossover";
         notLaid.push({
           id: cur.t.divergeTrack,
-          why: `${prev.t.name || prev.t.id} and ${cur.t.name || cur.t.id} are ${gap.toFixed(1)}\u2033 apart on the same track, but the turnout chosen is ${body.toFixed(1)}\u2033 long \u2014 their mouldings would overlap, which is why this is sold as one assembly rather than two turnouts`
+          why: asm ? `this is a crossover \u2014 one assembly, not ${gap.toFixed(1)}\u2033 between two separate turnouts. Laying it needs the crossover product itself; pick one on the track and it can be placed as the single piece it is` : `${prev.t.name || prev.t.id} and ${cur.t.name || cur.t.id} are ${gap.toFixed(1)}\u2033 apart on the same track, but the turnout chosen is ${body.toFixed(1)}\u2033 long \u2014 their mouldings would overlap, so they cannot both be where the document puts them`
         });
       }
     }
     return laid.filter((l) => !clashed.has(l.t.id));
   };
+  const assemblies = (() => {
+    const out = [];
+    const byPart = /* @__PURE__ */ new Map();
+    for (const t of tracks) {
+      if (t.role !== "crossover" || !t.crossoverPartId) continue;
+      const list = byPart.get(t.crossoverPartId) ?? [];
+      list.push(t);
+      byPart.set(t.crossoverPartId, list);
+    }
+    for (const [partId, connectors] of byPart) {
+      const part = partById.get(partId);
+      if (!part || part.kind !== "crossover" || partGeometryGap(part)) continue;
+      const geom = crossoverAssembly(part);
+      if (!geom) continue;
+      const trackIds = new Set(connectors.map((c) => c.id));
+      const mine = turnouts.filter((t) => trackIds.has(t.divergeTrack));
+      if (!mine.length) continue;
+      const centre = mine.reduce((a, t) => a + t.pos, 0) / mine.length;
+      const x0 = centre - geom.lengthInches / 2;
+      const spread = Math.max(...mine.map((t) => t.pos)) - Math.min(...mine.map((t) => t.pos));
+      if (Math.abs(spread - geom.crossingRunInches) > 0.05)
+        warnings.push(
+          `this document puts the crossover's point-sets ${spread.toFixed(2)}\u2033 apart, but a ${part.name ?? partId} is ${geom.crossingRunInches.toFixed(2)}\u2033 \u2014 the assembly is laid to its own dimensions, centred where the document has it`
+        );
+      out.push({ part, geom, x0, trackIds, turnoutIds: new Set(mine.map((t) => t.id)) });
+    }
+    return out;
+  })();
+  const assemblyTracks = new Set(assemblies.flatMap((a) => [...a.trackIds]));
   const main = trackById.get(MAIN_TRACK_ID) ?? tracks.find((t) => t.role === "main");
   if (!main) return refuse("this module's document has no mainline to convert");
   const mains = [main, ...tracks.filter((t) => t.role === "main" && t.id !== main.id)];
   const laidTurnouts = /* @__PURE__ */ new Map();
   const done = /* @__PURE__ */ new Set();
+  const mainY = laneOffsetAt(mains[0]?.lane ?? 0, 0);
+  for (const [i, a] of assemblies.entries()) {
+    pieces.push({
+      id: `xo-${i}`,
+      partId: a.part.id,
+      x: r3(a.x0),
+      y: mainY,
+      rotationDeg: 0,
+      ...a.part.name ? { name: a.part.name } : {}
+    });
+  }
+  const assemblySpans = assemblies.map((a) => ({
+    fromPos: a.x0,
+    toPos: a.x0 + a.geom.lengthInches
+  }));
   for (const m of mains) {
     const y = laneOffsetAt(m.lane ?? 0, 0);
     const on = turnoutsOn(m.id, y);
@@ -3245,9 +3481,32 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
       pieces.push(l.piece);
       laidTurnouts.set(l.t.id, l);
     }
-    layFlex(m.id, y, m.fromPos ?? 0, m.toPos ?? mainLen, on.map((l) => l.span), m.flexCuts);
+    const laidFlex = layFlex(
+      m.id,
+      y,
+      m.fromPos ?? 0,
+      m.toPos ?? mainLen,
+      [...on.map((l) => l.span), ...assemblySpans],
+      m.flexCuts
+    );
+    if (m !== mains[0]) {
+      for (const a of assemblies) {
+        const west = a.x0;
+        const east = a.x0 + a.geom.lengthInches;
+        const target = mainY + a.geom.spacingInches;
+        for (const f of laidFlex) {
+          const end = f.x + (f.lengthInches ?? 0);
+          if (Math.abs(end - west) < 1e-6) aimEndAt(f, { x: west, y: target });
+          else if (Math.abs(f.x - east) < 1e-6) {
+            f.y = target;
+            aimEndAt(f, { x: end, y });
+          }
+        }
+      }
+    }
     done.add(m.id);
   }
+  for (const id of assemblyTracks) done.add(id);
   let progressed = true;
   while (progressed) {
     progressed = false;
@@ -4042,6 +4301,7 @@ exports.buildTransition = buildTransition;
 exports.carCapacity = carCapacity;
 exports.checkEndplateWidth = checkEndplateWidth;
 exports.clearancePointPastFrogInches = clearancePointPastFrogInches;
+exports.crossoverAssembly = crossoverAssembly;
 exports.crossoverPinches = crossoverPinches;
 exports.deriveEndplatePoses = deriveEndplatePoses;
 exports.deriveGraphDoc = deriveGraphDoc;