@willcgage/module-schematic 0.108.0 → 0.109.0

package/dist/index.cjs

@@ -2929,27 +2929,49 @@ function graphToDoc(pieces, input) {
   const epA = endplates[0];
   const epB = endplates[1];
   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 start2Key = input.start2 ? `${input.start2.piece}.${input.start2.joint}` : null;
+  const start2IsOpenEnd = !!start2Key && graph.open.includes(start2Key);
+  const walk2 = input.start2 && start2IsOpenEnd ? walkTrackGraph(graph, pieces, input.start2, library) : null;
+  const main2FromBranch = (() => {
+    if (!start2Key || start2IsOpenEnd) return null;
+    const conn = graph.connections.find((c) => c.a === start2Key || c.b === start2Key);
+    if (!conn) return null;
+    const otherKey = conn.a === start2Key ? conn.b : conn.a;
+    const piece = graph.joints.find((j) => j.key === otherKey)?.piece;
+    return walk.routes.find((r) => r.id !== "main" && r.pieces[0] === piece) ?? null;
+  })();
+  const main2 = walk2?.routes.find((r) => r.id === "main") ?? main2FromBranch;
   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))) {
+  const mainPieces = new Set(main.pieces.filter((p) => !sharedByDesign(p)));
+  if (!main2FromBranch && main2 && main2.pieces.some((p) => mainPieces.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 twoMains = !!main2 && (!!main2FromBranch || !main2.pieces.some((p) => mainPieces.has(p)));
+  const main2AsBranch = walk2 && main2 && twoMains ? walk.routes.find(
+    (r) => r.id !== "main" && r.pieces.some((p) => main2.pieces.includes(p))
+  ) ?? null : null;
+  const main2Lane = twoMains ? (
+    // A branch-born main reaches its lane after an easement, so its SIDE is
+    // how far the run gets laterally, not where its first joint sits.
+    (main2FromBranch ? main2FromBranch.lateral : graph.joints.find((j) => j.key === start2Key)?.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 })) : []
+    ...walk.routes.filter(
+      (r) => r.id !== "main" && r.pieces.length && r.id !== main2FromBranch?.id && r.id !== main2AsBranch?.id
+    ),
+    ...walk2 ? 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);
+  if (twoMains) {
+    trackIdOf.set(main2FromBranch ? main2FromBranch.id : "main2:main", MAIN2_TRACK_ID);
+    if (main2AsBranch) trackIdOf.set(main2AsBranch.id, MAIN2_TRACK_ID);
+  }
   for (const r of branches) trackIdOf.set(r.id, r.pieces[0]);
   const emitted = /* @__PURE__ */ new Set();
   const uniqueBranches = branches.filter((r) => {
@@ -2980,8 +3002,11 @@ function graphToDoc(pieces, input) {
         id: MAIN2_TRACK_ID,
         role: "main",
         lane: main2Lane,
-        from: epA?.id ?? "A",
-        ...epB ? { to: epB.id } : {},
+        // ⚠️ Only a main that CROSSES the endplates says so. A transition
+        // module's second main begins at a turnout partway along and ends
+        // at one endplate or neither; claiming A→B would tell the catalogue
+        // it presents two tracks at an end where it presents one.
+        ...main2FromBranch ? {} : { 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)),
@@ -3026,7 +3051,7 @@ function graphToDoc(pieces, input) {
   const turnouts = [];
   const allTurnouts = [
     ...walk.turnouts,
-    ...twoMains ? walk2.turnouts.map((t) => ({
+    ...walk2 ? walk2.turnouts.map((t) => ({
       ...t,
       onRoute: t.onRoute === "main" ? "main2:main" : `main2:${t.onRoute}`,
       divergeRoute: t.divergeRoute ? `main2:${t.divergeRoute}` : null
@@ -3056,7 +3081,7 @@ function graphToDoc(pieces, input) {
     const found = [];
     const routesAll = [
       ...walk.routes.map((r) => ({ r, prefix: "" })),
-      ...twoMains ? walk2.routes.map((r) => ({ r, prefix: "main2:" })) : []
+      ...walk2 ? walk2.routes.map((r) => ({ r, prefix: "main2:" })) : []
     ];
     const seen = /* @__PURE__ */ new Map();
     for (const { r, prefix } of routesAll) {
@@ -3281,15 +3306,6 @@ function moduleConversionReport(doc, library = BUILT_IN_TRACK_PARTS) {
       candidates
     };
   });
-  const mainIds = new Set((doc.tracks ?? []).filter((t) => t.role === "main").map((t) => t.id));
-  for (const t of doc.turnouts ?? []) {
-    if (!mainIds.has(t.divergeTrack)) continue;
-    blockers.push({
-      kind: "turnout-opens-a-main",
-      ref: t.id,
-      why: `${t.name || t.id} opens ${t.divergeTrack}, which is a main \u2014 a main that begins at a turnout cannot be laid as pieces yet, and converting anyway would drop both it and the turnout`
-    });
-  }
   for (const c of doc.crossings ?? [])
     blockers.push({
       kind: "crossing",
@@ -3518,18 +3534,52 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
     fromPos: a.x0,
     toPos: a.x0 + a.geom.lengthInches
   }));
+  const attachment = /* @__PURE__ */ new Map();
+  for (const t of turnouts) {
+    const m = mains.find((x) => x.id === t.divergeTrack && x.id !== main.id);
+    if (!m) continue;
+    const from = m.fromPos ?? 0;
+    const to = m.toPos ?? mainLen;
+    if (from > 0 && Math.abs(t.pos - from) < 0.01) attachment.set(m.id, { sw: t, at: "from" });
+    else if (Math.abs(t.pos - to) < 0.01) attachment.set(m.id, { sw: t, at: "to" });
+    else
+      notLaid.push({
+        id: m.id,
+        why: `${t.name || t.id} joins ${m.id} at ${t.pos}\u2033, which is neither end of it \u2014 two mains joined partway along are a crossover, and this document has no connector track between them to lay one from`
+      });
+  }
   for (const m of mains) {
+    if (attachment.get(m.id)?.at === "from") continue;
     const y = laneOffsetAt(m.lane ?? 0, 0);
     const on = turnoutsOn(m.id, y);
     for (const l of on) {
       pieces.push(l.piece);
       laidTurnouts.set(l.t.id, l);
     }
+    let endPos = m.toPos ?? mainLen;
+    const closeAt = attachment.get(m.id);
+    if (closeAt?.at === "to") {
+      const l = laidTurnouts.get(closeAt.sw.id);
+      const fj = l ? jointAt(l.piece, l.divergeId) : null;
+      if (fj) {
+        const closing = transition(
+          `${m.id}-close`,
+          { x: fj.x, y: fj.y, headingDeg: fj.headingDeg },
+          y,
+          -1
+        );
+        if (closing) {
+          pieces.push(closing);
+          const e = jointAt(closing, "b");
+          if (e) endPos = e.x;
+        } else endPos = fj.x;
+      }
+    }
     const laidFlex = layFlex(
       m.id,
       y,
       m.fromPos ?? 0,
-      m.toPos ?? mainLen,
+      endPos,
       [...on.map((l) => l.span), ...assemblySpans],
       m.flexCuts
     );
@@ -3663,13 +3713,19 @@ function docToGraph(doc, answers = {}, library = BUILT_IN_TRACK_PARTS) {
   };
   const startAt = startOf(main);
   if (!startAt) return refuse("nothing was laid on the mainline, so the module has no starting point");
-  const second = mains[1] ? startOf(mains[1]) : null;
-  return {
-    graph: { pieces, startAt, ...second ? { start2: second } : {} },
-    refused: null,
-    notLaid,
-    warnings
-  };
+  const second = mains[1] ? attachment.get(mains[1].id)?.at === "from" ? (() => {
+    const l = laidTurnouts.get(attachment.get(mains[1].id).sw.id);
+    return l ? { piece: l.piece.id, joint: l.divergeId } : null;
+  })() : startOf(mains[1]) : null;
+  const graph = { pieces, startAt, ...second ? { start2: second } : {} };
+  const derived = graphToDoc(pieces, {
+    startAt,
+    start2: second ?? null,
+    base: doc,
+    library
+  });
+  warnings.push(...derived.warnings);
+  return { graph, refused: null, notLaid, warnings };
 }
 function frogCasting(cl, opts = {}) {
   const g = opts.gaugeInches ?? RAIL_GAUGE_INCHES;