@willcgage/module-schematic 0.92.1 → 0.93.0

package/dist/index.d.cts

@@ -459,6 +459,16 @@ interface ModuleSchematicDoc {
             piece: string;
             joint: string;
         };
+        /** Where MAIN 2 starts, on a double-track module — the joint the endplate's
+         * SECOND track arrives at. Absent = single track.
+         *
+         * Two starts rather than a list because a document has exactly two mains,
+         * `main` and `main2`. This mirrors the thing downstream instead of inventing
+         * a generality nothing can read. */
+        start2?: {
+            piece: string;
+            joint: string;
+        } | null;
     } | null;
 }
 /** A benchwork-outline vertex, module-local inches. The edge from this vertex
@@ -2644,6 +2654,11 @@ interface GraphWalk {
      * sentence, so a caller can act on it (and say it ONCE) instead of matching
      * on prose. */
     danglingDiverges: string[];
+    /** Pieces this walk never got to. ⚠️ "Unreached BY THIS WALK" is not the same
+     * as "unreachable": a double-track module's second main is unreached by the
+     * first walk and perfectly well connected. Ids, so a caller running more than
+     * one walk can tell the difference. */
+    unreached: string[];
 }
 /**
  * Walk the graph from an endplate and read the topology off it.
@@ -2686,6 +2701,11 @@ interface GraphDocInput {
         piece: string;
         joint: string;
     };
+    /** Where MAIN 2 begins, on a double-track module. Absent = single track. */
+    start2?: {
+        piece: string;
+        joint: string;
+    } | null;
     /**
      * The rest of the document — module id, endplate identities, the benchwork,
      * industries and signals. Merged UNDERNEATH the derived keys, so the graph

package/dist/index.d.ts

@@ -459,6 +459,16 @@ interface ModuleSchematicDoc {
             piece: string;
             joint: string;
         };
+        /** Where MAIN 2 starts, on a double-track module — the joint the endplate's
+         * SECOND track arrives at. Absent = single track.
+         *
+         * Two starts rather than a list because a document has exactly two mains,
+         * `main` and `main2`. This mirrors the thing downstream instead of inventing
+         * a generality nothing can read. */
+        start2?: {
+            piece: string;
+            joint: string;
+        } | null;
     } | null;
 }
 /** A benchwork-outline vertex, module-local inches. The edge from this vertex
@@ -2644,6 +2654,11 @@ interface GraphWalk {
      * sentence, so a caller can act on it (and say it ONCE) instead of matching
      * on prose. */
     danglingDiverges: string[];
+    /** Pieces this walk never got to. ⚠️ "Unreached BY THIS WALK" is not the same
+     * as "unreachable": a double-track module's second main is unreached by the
+     * first walk and perfectly well connected. Ids, so a caller running more than
+     * one walk can tell the difference. */
+    unreached: string[];
 }
 /**
  * Walk the graph from an endplate and read the topology off it.
@@ -2686,6 +2701,11 @@ interface GraphDocInput {
         piece: string;
         joint: string;
     };
+    /** Where MAIN 2 begins, on a double-track module. Absent = single track. */
+    start2?: {
+        piece: string;
+        joint: string;
+    } | null;
     /**
      * The rest of the document — module id, endplate identities, the benchwork,
      * industries and signals. Merged UNDERNEATH the derived keys, so the graph

package/dist/index.js

@@ -2441,6 +2441,7 @@ function snapPiece(moving, others, library = BUILT_IN_TRACK_PARTS, withinInches
   };
 }
 var danglingDivergeWarning = (id) => `the route diverging at ${id} is not connected to anything`;
+var unreachedWarning = (id) => `${id} is not reachable from the endplate \u2014 nothing connects it`;
 function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS) {
   const byKey = new Map(graph.joints.map((j) => [j.key, j]));
   const pieceById = new Map(pieces.map((p) => [p.id, p]));
@@ -2578,11 +2579,14 @@ function walkTrackGraph(graph, pieces, startAt, library = BUILT_IN_TRACK_PARTS)
     if (sw && !sw.divergeRoute) sw.divergeRoute = r.id;
   }
   const reached = new Set(routes.flatMap((r) => r.pieces));
+  const unreached = [];
   for (const p of pieces)
-    if (!reached.has(p.id) && !graph.unplaceable.some((u) => u.piece === p.id))
-      warnings.push(`${p.id} is not reachable from the endplate \u2014 nothing connects it`);
+    if (!reached.has(p.id) && !graph.unplaceable.some((u) => u.piece === p.id)) {
+      warnings.push(unreachedWarning(p.id));
+      unreached.push(p.id);
+    }
   for (const c of graph.conflicts) warnings.push(c.reason);
-  return { routes, turnouts, warnings, danglingDiverges };
+  return { routes, turnouts, warnings, danglingDiverges, unreached };
 }
 function resolveGraphAnchor(anchor, walk, pieces, library = BUILT_IN_TRACK_PARTS) {
   const piece = pieces.find((p) => p.id === anchor.piece);
@@ -2611,14 +2615,29 @@ function graphToDoc(pieces, input) {
   const epA = endplates[0];
   const epB = endplates[1];
   const main = walk.routes.find((r) => r.id === "main");
-  const lengthInches = round(main.toPos);
-  const branches = walk.routes.filter((r) => r.id !== "main" && r.pieces.length);
+  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));
+  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"
+    );
+  }
+  const twoMains = !!main2 && !main2.pieces.some((p) => claimed.has(p));
+  const main2Lane = twoMains ? (graph.joints.find((j) => j.key === `${input.start2.piece}.${input.start2.joint}`)?.y ?? 1) >= 0 ? 1 : -1 : 0;
+  const lengthInches = round(Math.max(main.toPos, twoMains ? main2.toPos : 0));
+  const branches = [
+    ...walk.routes.filter((r) => r.id !== "main" && r.pieces.length),
+    ...twoMains ? walk2.routes.filter((r) => r.id !== "main" && r.pieces.length).map((r) => ({ ...r, id: `main2:${r.id}`, bornAt: r.bornAt })) : []
+  ];
   const trackIdOf = /* @__PURE__ */ new Map([["main", MAIN_TRACK_ID]]);
+  if (twoMains) trackIdOf.set("main2:main", MAIN2_TRACK_ID);
   for (const r of branches) trackIdOf.set(r.id, r.pieces[0]);
   const laneOf = (r) => {
     const side = Math.sign(r.lateral) || 1;
     const sameSide = branches.filter((x) => (Math.sign(x.lateral) || 1) === side).sort((a, b) => Math.abs(a.lateral) - Math.abs(b.lateral));
-    return side * (sameSide.indexOf(r) + 1);
+    const taken = side === main2Lane ? 1 : 0;
+    return side * (sameSide.indexOf(r) + 1 + taken);
   };
   const tracks = [
     {
@@ -2627,7 +2646,20 @@ function graphToDoc(pieces, input) {
       lane: 0,
       from: epA?.id ?? "A",
       ...epB ? { to: epB.id } : {}
-    }
+    },
+    ...twoMains ? [
+      {
+        id: MAIN2_TRACK_ID,
+        role: "main",
+        lane: main2Lane,
+        from: epA?.id ?? "A",
+        ...epB ? { to: epB.id } : {},
+        // ⚠️ Its own extent, because a second main need not run the whole
+        // module: on a transition module it starts or stops partway.
+        fromPos: round(Math.min(main2.fromPos, main2.toPos)),
+        toPos: round(Math.max(main2.fromPos, main2.toPos))
+      }
+    ] : []
   ];
   for (const r of branches) {
     const id = trackIdOf.get(r.id);
@@ -2645,9 +2677,29 @@ function graphToDoc(pieces, input) {
       ...meta.moduleTrackId != null ? { moduleTrackId: meta.moduleTrackId } : {}
     });
   }
+  if (walk2) {
+    const seen = /* @__PURE__ */ new Set([
+      ...walk.routes.flatMap((r) => r.pieces),
+      ...walk2.routes.flatMap((r) => r.pieces)
+    ]);
+    const covered = new Set([...walk.unreached, ...walk2.unreached].filter((id) => seen.has(id)));
+    const drop = new Set([...covered].map(unreachedWarning));
+    const d2 = new Set(walk2.danglingDiverges.map(danglingDivergeWarning));
+    for (let i = warnings.length - 1; i >= 0; i--) if (drop.has(warnings[i])) warnings.splice(i, 1);
+    for (const w of walk2.warnings)
+      if (!d2.has(w) && !drop.has(w) && !warnings.includes(w)) warnings.push(w);
+  }
   const pieceById = new Map(pieces.map((p) => [p.id, p]));
   const turnouts = [];
-  for (const t of walk.turnouts) {
+  const allTurnouts = [
+    ...walk.turnouts,
+    ...twoMains ? walk2.turnouts.map((t) => ({
+      ...t,
+      onRoute: t.onRoute === "main" ? "main2:main" : `main2:${t.onRoute}`,
+      divergeRoute: t.divergeRoute ? `main2:${t.divergeRoute}` : null
+    })) : []
+  ];
+  for (const t of allTurnouts) {
     const diverge = t.divergeRoute ? trackIdOf.get(t.divergeRoute) : void 0;
     if (!diverge) {
       warnings.push(
@@ -2729,7 +2781,13 @@ function deriveGraphDoc(doc, library = BUILT_IN_TRACK_PARTS) {
       ...t.moduleTrackId != null ? { moduleTrackId: t.moduleTrackId } : {}
     };
   }
-  const out = graphToDoc(g.pieces, { startAt: g.startAt, base: doc, meta, library });
+  const out = graphToDoc(g.pieces, {
+    startAt: g.startAt,
+    start2: g.start2 ?? null,
+    base: doc,
+    meta,
+    library
+  });
   return { doc: out.doc, warnings: out.warnings };
 }
 function frogCasting(cl, opts = {}) {