vehicle-path2 4.0.2 → 4.0.3

package/dist/index-BObuJxsC.js

@@ -0,0 +1,840 @@
+function I(t, e) {
+  const s = e.x - t.x, n = e.y - t.y;
+  return Math.sqrt(s * s + n * n);
+}
+function E(t, e) {
+  const s = e.x - t.x, n = e.y - t.y, r = Math.sqrt(s * s + n * n);
+  return r === 0 ? { x: 0, y: 0 } : { x: s / r, y: n / r };
+}
+function k(t, e) {
+  return e * (t === "proportional-40" ? 0.4 : 0.5522);
+}
+function q(t, e, s, n) {
+  const { tangentMode: r } = s;
+  let a;
+  n?.fromOffset !== void 0 ? a = b(t, n.fromOffset, n.fromIsPercentage ?? !1) : a = t.end;
+  let o;
+  n?.toOffset !== void 0 ? o = b(e, n.toOffset, n.toIsPercentage ?? !1) : o = e.start;
+  const i = E(t.start, t.end), c = E(e.start, e.end), l = I(a, o), u = k(r, l), g = { x: a.x + i.x * u, y: a.y + i.y * u }, h = { x: o.x - c.x * u, y: o.y - c.y * u };
+  return { p0: a, p1: g, p2: h, p3: o };
+}
+function K(t, e) {
+  return {
+    x: t.start.x + (t.end.x - t.start.x) * e,
+    y: t.start.y + (t.end.y - t.start.y) * e
+  };
+}
+function b(t, e, s) {
+  const n = I(t.start, t.end);
+  let r;
+  return s ? r = e : r = n > 0 ? e / n : 0, r = Math.max(0, Math.min(1, r)), K(t, r);
+}
+function P(t, e) {
+  const { p0: s, p1: n, p2: r, p3: a } = t, o = 1 - e, i = o * o, c = i * o, l = e * e, u = l * e;
+  return {
+    x: c * s.x + 3 * i * e * n.x + 3 * o * l * r.x + u * a.x,
+    y: c * s.y + 3 * i * e * n.y + 3 * o * l * r.y + u * a.y
+  };
+}
+function ae(t, e, s = 10) {
+  return I(t, e) <= s;
+}
+function z(t, e = 100) {
+  const s = [{ t: 0, distance: 0 }];
+  let n = t.p0, r = 0;
+  for (let a = 1; a <= e; a++) {
+    const o = a / e, i = P(t, o);
+    r += I(n, i), s.push({ t: o, distance: r }), n = i;
+  }
+  return s;
+}
+function W(t, e) {
+  if (e <= 0) return 0;
+  const s = t[t.length - 1].distance;
+  if (e >= s) return 1;
+  let n = 0, r = t.length - 1;
+  for (; n < r - 1; ) {
+    const u = Math.floor((n + r) / 2);
+    t[u].distance < e ? n = u : r = u;
+  }
+  const a = t[n].distance, o = t[r].distance, i = t[n].t, c = t[r].t;
+  if (o === a) return i;
+  const l = (e - a) / (o - a);
+  return i + l * (c - i);
+}
+function ce(t) {
+  return t[t.length - 1].distance;
+}
+function H(t, e = 100) {
+  let s = 0, n = t.p0;
+  for (let r = 1; r <= e; r++) {
+    const a = r / e, o = P(t, a);
+    s += I(n, o), n = o;
+  }
+  return s;
+}
+function G(t, e, s, n) {
+  const r = I(t.start, t.end);
+  return e === void 0 ? n * r : s ? Math.max(0, Math.min(e, 1)) * r : Math.max(0, Math.min(e, r));
+}
+function B(t, e, s, n) {
+  const r = I(t.start, t.end);
+  return e === void 0 ? n * r : s ? Math.max(0, Math.min(e, 1)) * r : Math.max(0, Math.min(e, r));
+}
+function J(t, e, s) {
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map();
+  for (const o of t)
+    r.set(o.id, o), a.set(o.id, I(o.start, o.end)), n.set(o.id, []);
+  for (let o = 0; o < e.length; o++) {
+    const i = e[o], c = r.get(i.fromLineId), l = r.get(i.toLineId);
+    if (!c || !l) continue;
+    const u = G(c, i.fromOffset, i.fromIsPercentage, 1), g = B(l, i.toOffset, i.toIsPercentage, 0), h = q(
+      c,
+      l,
+      s,
+      {
+        fromOffset: u,
+        fromIsPercentage: !1,
+        toOffset: g,
+        toIsPercentage: !1
+      }
+    ), p = H(h), d = {
+      curveIndex: o,
+      curveId: i.id,
+      fromLineId: i.fromLineId,
+      toLineId: i.toLineId,
+      fromOffset: u,
+      toOffset: g,
+      curveLength: p,
+      bezier: h
+    };
+    n.get(i.fromLineId).push(d);
+  }
+  return { adjacency: n, lines: r, lineLengths: a };
+}
+function V(t, e) {
+  return t.curveCount !== e.curveCount ? t.curveCount - e.curveCount : t.totalDistance - e.totalDistance;
+}
+function j(t, e, s, n, r = !1) {
+  const { adjacency: a, lines: o, lineLengths: i } = t;
+  if (!o.get(s)) return null;
+  const l = i.get(s), u = r ? n / 100 * l : n, g = [], h = /* @__PURE__ */ new Map(), p = (f, v) => `${f}:${Math.round(v)}`;
+  if (e.lineId === s && u >= e.offset) {
+    const f = u - e.offset;
+    return {
+      segments: [{
+        type: "line",
+        lineId: e.lineId,
+        startOffset: e.offset,
+        endOffset: u,
+        length: f
+      }],
+      totalDistance: f,
+      curveCount: 0
+    };
+  }
+  const d = a.get(e.lineId) || [];
+  for (const f of d) {
+    if (f.fromOffset < e.offset) continue;
+    const v = f.fromOffset - e.offset, x = v + f.curveLength, M = {
+      type: "line",
+      lineId: e.lineId,
+      startOffset: e.offset,
+      endOffset: f.fromOffset,
+      length: v
+    }, m = {
+      type: "curve",
+      curveIndex: f.curveIndex,
+      startOffset: 0,
+      endOffset: f.curveLength,
+      length: f.curveLength
+    };
+    g.push({
+      lineId: f.toLineId,
+      entryOffset: f.toOffset,
+      totalDistance: x,
+      curveCount: 1,
+      path: [M, m]
+    });
+  }
+  for (g.sort(V); g.length > 0; ) {
+    const f = g.shift(), v = p(f.lineId, f.entryOffset), x = h.get(v);
+    if (x !== void 0 && (x.curveCount < f.curveCount || x.curveCount === f.curveCount && x.distance <= f.totalDistance))
+      continue;
+    if (h.set(v, { curveCount: f.curveCount, distance: f.totalDistance }), f.lineId === s) {
+      const m = Math.abs(u - f.entryOffset);
+      if (u >= f.entryOffset) {
+        const O = {
+          type: "line",
+          lineId: s,
+          startOffset: f.entryOffset,
+          endOffset: u,
+          length: m
+        };
+        return {
+          segments: [...f.path, O],
+          totalDistance: f.totalDistance + m,
+          curveCount: f.curveCount
+        };
+      }
+    }
+    const M = a.get(f.lineId) || [];
+    for (const m of M) {
+      if (m.fromOffset < f.entryOffset) continue;
+      const O = m.fromOffset - f.entryOffset, T = f.totalDistance + O + m.curveLength, C = f.curveCount + 1, F = p(m.toLineId, m.toOffset), D = h.get(F);
+      if (D !== void 0 && (D.curveCount < C || D.curveCount === C && D.distance <= T))
+        continue;
+      const N = {
+        type: "line",
+        lineId: f.lineId,
+        startOffset: f.entryOffset,
+        endOffset: m.fromOffset,
+        length: O
+      }, R = {
+        type: "curve",
+        curveIndex: m.curveIndex,
+        startOffset: 0,
+        endOffset: m.curveLength,
+        length: m.curveLength
+      };
+      g.push({
+        lineId: m.toLineId,
+        entryOffset: m.toOffset,
+        totalDistance: T,
+        curveCount: C,
+        path: [...f.path, N, R]
+      });
+    }
+    g.sort(V);
+  }
+  return null;
+}
+function w(t, e) {
+  const s = Math.sqrt(
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
+  ), n = s > 0 ? e / s : 0;
+  return {
+    x: t.start.x + (t.end.x - t.start.x) * Math.min(1, Math.max(0, n)),
+    y: t.start.y + (t.end.y - t.start.y) * Math.min(1, Math.max(0, n))
+  };
+}
+function L(t) {
+  return Math.sqrt(
+    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
+  );
+}
+function A(t, e, s) {
+  let n = 0;
+  for (let r = 0; r < e; r++)
+    n += t.segments[r].length;
+  return n += s, n;
+}
+function Q(t, e) {
+  let s = 0;
+  for (let n = 0; n < t.segments.length; n++) {
+    const r = t.segments[n], a = s + r.length;
+    if (e < a)
+      return {
+        segmentIndex: n,
+        segmentDistance: e - s
+      };
+    if (e === a)
+      return n + 1 < t.segments.length ? {
+        segmentIndex: n + 1,
+        segmentDistance: 0
+      } : {
+        segmentIndex: n,
+        segmentDistance: r.length
+      };
+    s += r.length;
+  }
+  return null;
+}
+function ue(t, e, s, n) {
+  const a = A(
+    t,
+    e,
+    s
+  ) + n;
+  return Q(t, a);
+}
+function _(t, e, s, n) {
+  const r = L(n), a = s.length + 1, o = new Array(a);
+  o[a - 1] = {
+    lineId: t,
+    absoluteOffset: e,
+    position: w(n, e)
+  };
+  let i = e;
+  for (let c = a - 2; c >= 0; c--)
+    i = Math.min(i + s[c], r), o[c] = {
+      lineId: t,
+      absoluteOffset: i,
+      position: w(n, i)
+    };
+  return o;
+}
+function U(t, e) {
+  return {
+    ...t,
+    state: "idle"
+  };
+}
+function X(t) {
+  return {
+    vehicle: t,
+    execution: null
+  };
+}
+function fe(t, e) {
+  const s = [], n = /* @__PURE__ */ new Map();
+  for (const r of t) {
+    if (!e.get(r.lineId)) continue;
+    const o = U(r);
+    s.push(o);
+    const i = X(o);
+    n.set(r.id, i);
+  }
+  return { movingVehicles: s, stateMap: n };
+}
+function y(t, e) {
+  return { position: w(t, e), lineId: t.id, absoluteOffset: e };
+}
+function S(t, e) {
+  const s = W(t.arcLengthTable, e);
+  return { position: P(t.bezier, s) };
+}
+function Y(t, e, s, n, r, a, o) {
+  const i = s.segments[e.currentSegmentIndex], c = e.segmentDistance + n;
+  if (c >= i.length) {
+    const u = c - i.length, g = e.currentSegmentIndex + 1;
+    if (g >= s.segments.length) {
+      if (o !== void 0 && i.type === "line") {
+        const f = r.get(i.lineId), v = i.startOffset + c;
+        if (v <= o) {
+          const M = y(f, v);
+          return {
+            axleState: { ...t, ...M },
+            execution: { ...e, segmentDistance: c },
+            completed: !1
+          };
+        }
+        const x = y(f, o);
+        return {
+          axleState: { ...t, ...x },
+          execution: { ...e, segmentDistance: o - i.startOffset },
+          completed: !0
+        };
+      }
+      const d = i.type === "line" ? y(
+        r.get(i.lineId),
+        i.endOffset
+      ) : S(
+        a.get(i.curveIndex),
+        i.length
+      );
+      return {
+        axleState: { ...t, ...d },
+        execution: { ...e, segmentDistance: i.length },
+        completed: !0
+      };
+    }
+    const h = s.segments[g], p = h.type === "line" ? y(
+      r.get(h.lineId),
+      h.startOffset + u
+    ) : S(
+      a.get(h.curveIndex),
+      u
+    );
+    return {
+      axleState: { ...t, ...p },
+      execution: {
+        currentSegmentIndex: g,
+        segmentDistance: u
+      },
+      completed: !1
+    };
+  }
+  const l = i.type === "line" ? y(
+    r.get(i.lineId),
+    i.startOffset + c
+  ) : S(
+    a.get(i.curveIndex),
+    c
+  );
+  return {
+    axleState: { ...t, ...l },
+    execution: { ...e, segmentDistance: c },
+    completed: !1
+  };
+}
+function Z(t, e, s, n, r) {
+  const a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+  for (const i of e.adjacency.values())
+    for (const c of i)
+      o.set(c.curveIndex, c);
+  for (const i of t.segments)
+    if (i.type === "curve" && i.curveIndex !== void 0) {
+      const c = o.get(i.curveIndex);
+      if (c) {
+        const l = z(c.bezier);
+        a.set(i.curveIndex, { bezier: c.bezier, arcLengthTable: l });
+      } else {
+        const l = s[i.curveIndex];
+        if (l) {
+          const u = n.get(l.fromLineId), g = n.get(l.toLineId);
+          if (u && g) {
+            const h = G(u, l.fromOffset, l.fromIsPercentage, 1), p = B(g, l.toOffset, l.toIsPercentage, 0), d = q(u, g, r, {
+              fromOffset: h,
+              fromIsPercentage: !1,
+              toOffset: p,
+              toIsPercentage: !1
+            }), f = z(d);
+            a.set(i.curveIndex, { bezier: d, arcLengthTable: f });
+          }
+        }
+      }
+    }
+  return a;
+}
+function ee(t, e, s) {
+  const { graph: n, linesMap: r, curves: a, config: o } = s, i = r.get(e.targetLineId);
+  if (!i) return null;
+  const c = t.axleSpacings.reduce((f, v) => f + v, 0), u = L(i) - c;
+  if (u <= 0) return null;
+  const g = e.isPercentage ? e.targetOffset * u : Math.min(e.targetOffset, u), h = t.axles[t.axles.length - 1], p = j(
+    n,
+    { lineId: h.lineId, offset: h.absoluteOffset },
+    e.targetLineId,
+    g,
+    !1
+  );
+  if (!p) return null;
+  const d = Z(p, n, a, r, o);
+  return { path: p, curveDataMap: d };
+}
+function le(t, e) {
+  const s = t.execution, r = e.vehicleQueues.get(t.vehicle.id)?.[s.currentCommandIndex];
+  return r && e.onCommandComplete && e.onCommandComplete({
+    vehicleId: t.vehicle.id,
+    command: r,
+    finalPosition: {
+      lineId: t.vehicle.axles[t.vehicle.axles.length - 1].lineId,
+      absoluteOffset: t.vehicle.axles[t.vehicle.axles.length - 1].absoluteOffset,
+      position: t.vehicle.axles[t.vehicle.axles.length - 1].position
+    },
+    payload: r.payload
+  }), {
+    handled: !0,
+    vehicle: { ...t.vehicle, state: "waiting" },
+    newExecution: s,
+    // Keep execution state for resume
+    isWaiting: !0
+  };
+}
+function $(t, e, s, n, r, a) {
+  const o = t.map((i, c) => {
+    const l = c === t.length - 1;
+    let u;
+    if (!l) {
+      const g = e[c];
+      if (g.currentSegmentIndex < s.segments.length) {
+        const h = s.segments[g.currentSegmentIndex];
+        if (h.type === "line") {
+          const p = r.get(h.lineId);
+          p && (u = L(p));
+        }
+      }
+    }
+    return Y(i, e[c], s, n, r, a, u);
+  });
+  return {
+    axles: o.map((i) => i.axleState),
+    axleExecutions: o.map((i) => i.execution),
+    arrived: o[o.length - 1].completed
+    // axles[N-1] = rearmost menentukan arrived
+  };
+}
+function te(t) {
+  const e = t.axleExecutions[t.axleExecutions.length - 1], s = A(
+    t.path,
+    e.segmentIndex,
+    e.segmentDistance
+  );
+  return Math.max(0, t.path.totalDistance - s);
+}
+function ne(t) {
+  const e = t.axleExecutions[0], s = A(
+    t.path,
+    e.segmentIndex,
+    e.segmentDistance
+  );
+  let n = 0;
+  for (let r = 0; r < t.path.segments.length; r++) {
+    const a = t.path.segments[r];
+    if (r >= e.segmentIndex && a.type === "curve")
+      return Math.max(0, n - s);
+    n += a.length;
+  }
+  return null;
+}
+function se(t, e, s) {
+  let n = s.maxSpeed;
+  const r = Math.sqrt(2 * s.deceleration * Math.max(0, t));
+  if (n = Math.min(n, r), e !== null) {
+    const a = Math.sqrt(
+      s.minCurveSpeed ** 2 + 2 * s.deceleration * e
+    );
+    n = Math.min(n, a);
+  }
+  return Math.max(0, n);
+}
+function re(t, e, s, n, r) {
+  return t < e ? Math.min(e, t + s * r) : t > e ? Math.max(e, t - n * r) : t;
+}
+function ie(t, e, s, n, r, a) {
+  const o = te(e), i = ne(e), c = se(o, i, n), l = re(
+    s.currentSpeed,
+    c,
+    n.acceleration,
+    n.deceleration,
+    r
+  ), u = l * r, g = t.axles.map((d) => ({
+    lineId: d.lineId,
+    position: d.position,
+    absoluteOffset: d.offset
+  })), h = e.axleExecutions.map((d) => ({
+    currentSegmentIndex: d.segmentIndex,
+    segmentDistance: d.segmentDistance
+  })), p = $(g, h, e.path, u, a, e.curveDataMap);
+  return {
+    state: {
+      axles: p.axles.map((d) => ({ lineId: d.lineId, offset: d.absoluteOffset, position: d.position })),
+      axleSpacings: t.axleSpacings
+    },
+    execution: {
+      ...e,
+      axleExecutions: p.axleExecutions.map((d) => ({
+        segmentIndex: d.currentSegmentIndex,
+        segmentDistance: d.segmentDistance
+      }))
+    },
+    accelState: { currentSpeed: l },
+    arrived: p.arrived
+  };
+}
+class de {
+  graph = null;
+  graphDirty = !0;
+  linesMap = /* @__PURE__ */ new Map();
+  curvesMap = /* @__PURE__ */ new Map();
+  curveSeq = 0;
+  config;
+  constructor(e) {
+    this.config = {
+      tangentMode: e.tangentMode
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  ensureGraph() {
+    return (this.graphDirty || !this.graph) && (this.graph = J(
+      Array.from(this.linesMap.values()),
+      Array.from(this.curvesMap.values()),
+      this.config
+    ), this.graphDirty = !1), this.graph;
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  get movementConfig() {
+    return this.config;
+  }
+  get lines() {
+    return Array.from(this.linesMap.values());
+  }
+  getCurves() {
+    return Array.from(this.curvesMap.values());
+  }
+  /**
+   * Expose the graph (lazily built) for consumers that need it
+   * (e.g., scene stats, custom pathfinding).
+   */
+  getGraph() {
+    return this.ensureGraph();
+  }
+  /**
+   * Returns computed bezier for each curve by id.
+   * Internally calls ensureGraph() to guarantee beziers are computed,
+   * then iterates graph edges to build the return map.
+   */
+  getCurveBeziers() {
+    const e = this.ensureGraph(), s = /* @__PURE__ */ new Map();
+    for (const n of e.adjacency.values())
+      for (const r of n)
+        r.curveId && s.set(r.curveId, r.bezier);
+    return s;
+  }
+  // ---------------------------------------------------------------------------
+  // Scene management
+  // ---------------------------------------------------------------------------
+  /**
+   * Replace the entire scene. Graph is rebuilt lazily on first access.
+   */
+  setScene(e, s) {
+    this.linesMap.clear();
+    for (const n of e)
+      this.linesMap.set(n.id, n);
+    this.curvesMap.clear(), this.curveSeq = 0;
+    for (const n of s) {
+      const r = n.id ?? `curve-${++this.curveSeq}`;
+      this.curvesMap.set(r, { ...n, id: r });
+    }
+    this.graph = null, this.graphDirty = !0;
+  }
+  /**
+   * Add a single line. Returns false if a line with the same ID already exists.
+   */
+  addLine(e) {
+    return this.linesMap.has(e.id) ? !1 : (this.linesMap.set(e.id, e), this.graphDirty = !0, !0);
+  }
+  /**
+   * Update start and/or end coordinates of an existing line.
+   * Immutable — does not mutate the original line object.
+   */
+  updateLine(e, s) {
+    const n = this.linesMap.get(e);
+    return n ? (this.linesMap.set(e, { ...n, ...s }), this.graphDirty = !0, !0) : !1;
+  }
+  /**
+   * Update a single endpoint ('start' or 'end') of a line.
+   */
+  updateLineEndpoint(e, s, n) {
+    return this.updateLine(e, { [s]: n });
+  }
+  /**
+   * Rename a line ID and cascade the change to all connected curves.
+   * Immutable — does not mutate original objects.
+   */
+  renameLine(e, s) {
+    const n = s.trim();
+    if (!n) return { success: !1, error: "Name cannot be empty" };
+    if (n === e) return { success: !0 };
+    if (this.linesMap.has(n)) return { success: !1, error: `"${n}" already exists` };
+    const r = this.linesMap.get(e);
+    if (!r) return { success: !1, error: `Line "${e}" not found` };
+    this.linesMap.delete(e), this.linesMap.set(n, { ...r, id: n });
+    const a = [];
+    for (const [o, i] of this.curvesMap) {
+      let c = !1;
+      const l = { ...i };
+      i.fromLineId === e && (l.fromLineId = n, c = !0), i.toLineId === e && (l.toLineId = n, c = !0), c && (this.curvesMap.set(o, l), a.push(o));
+    }
+    return this.graphDirty = !0, { success: !0, renamedCurveIds: a };
+  }
+  /**
+   * Remove a line and all curves connected to it.
+   * Returns which curves were also removed.
+   */
+  removeLine(e) {
+    if (!this.linesMap.has(e)) return { success: !1, removedCurveIds: [] };
+    this.linesMap.delete(e);
+    const s = [];
+    for (const [n, r] of this.curvesMap)
+      (r.fromLineId === e || r.toLineId === e) && s.push(n);
+    for (const n of s)
+      this.curvesMap.delete(n);
+    return this.graphDirty = !0, { success: !0, removedCurveIds: s };
+  }
+  /**
+   * Add a directional curve (connection) from one line to another.
+   * Returns the curve id (auto-generated if not provided).
+   */
+  addCurve(e) {
+    const s = e.id ?? `curve-${++this.curveSeq}`;
+    return this.curvesMap.set(s, { ...e, id: s }), this.graphDirty = !0, s;
+  }
+  /**
+   * Update a curve by id. Returns false if curve not found.
+   */
+  updateCurve(e, s) {
+    const n = this.curvesMap.get(e);
+    return n ? (this.curvesMap.set(e, { ...n, ...s, id: e }), this.graphDirty = !0, !0) : !1;
+  }
+  /**
+   * Remove a curve by id. Returns false if curve not found.
+   */
+  removeCurve(e) {
+    return this.curvesMap.has(e) ? (this.curvesMap.delete(e), this.graphDirty = !0, !0) : !1;
+  }
+  // ---------------------------------------------------------------------------
+  // Path validation
+  // ---------------------------------------------------------------------------
+  /**
+   * Check if a path exists from one position to another.
+   * Both offsets are absolute pixel values.
+   */
+  canReach(e, s, n, r) {
+    const a = this.ensureGraph();
+    return j(a, { lineId: e, offset: s }, n, r) !== null;
+  }
+  // ---------------------------------------------------------------------------
+  // Vehicle operations
+  // ---------------------------------------------------------------------------
+  /**
+   * Initialize a vehicle's N-axle position on a line.
+   *
+   * @param lineId - The line to place the vehicle on
+   * @param rearOffset - Absolute distance offset untuk axle paling belakang
+   * @param vehicle - VehicleDefinition (or any object extending it with axleSpacings)
+   * @returns Initial VehiclePathState, or null if lineId does not exist
+   * @throws if axleSpacings is empty
+   */
+  initializeVehicle(e, s, n) {
+    const r = this.linesMap.get(e);
+    if (!r) return null;
+    const { axleSpacings: a } = n;
+    if (a.length === 0)
+      throw new Error("initializeVehicle: axleSpacings must have at least one entry (vehicle needs ≥2 axles)");
+    const o = a.reduce((u, g) => u + g, 0), i = L(r), c = Math.min(s, i - o);
+    return {
+      axles: _(e, c, a, r).map((u) => ({ lineId: u.lineId, offset: u.absoluteOffset, position: u.position })),
+      axleSpacings: a
+    };
+  }
+  /**
+   * Prepare a path from the vehicle's current position to a target.
+   *
+   * Must be called before moveVehicle(). Returns null if no path exists.
+   *
+   * @param vehicleState - Current vehicle state (from initializeVehicle or previous tick)
+   * @param targetLineId - ID of the target line
+   * @param targetOffset - Position on the target line
+   * @param isPercentage - If true, targetOffset is 0-1 fraction; if false, absolute distance
+   */
+  preparePath(e, s, n, r = !1) {
+    const a = this.ensureGraph(), o = e.axleSpacings.reduce((d, f) => d + f, 0), i = e.axles[e.axles.length - 1], c = {
+      lineId: i.lineId,
+      offset: i.offset,
+      axles: e.axles.map((d) => ({
+        lineId: d.lineId,
+        position: d.position,
+        absoluteOffset: d.offset
+      })),
+      axleSpacings: e.axleSpacings
+    }, l = ee(c, {
+      targetLineId: s,
+      targetOffset: n,
+      isPercentage: r
+    }, {
+      graph: a,
+      linesMap: this.linesMap,
+      curves: Array.from(this.curvesMap.values()),
+      config: this.config
+    });
+    if (!l) return null;
+    let u = n;
+    const g = this.linesMap.get(s);
+    if (g) {
+      const d = Math.max(0, L(g) - o);
+      u = r ? n * d : Math.min(n, d);
+    }
+    let h = 0;
+    const p = [
+      { segmentIndex: 0, segmentDistance: o }
+      // axles[0] = front
+    ];
+    for (let d = 0; d < e.axleSpacings.length; d++)
+      h += e.axleSpacings[d], p.push({ segmentIndex: 0, segmentDistance: o - h });
+    return {
+      path: l.path,
+      curveDataMap: l.curveDataMap,
+      axleExecutions: p,
+      targetLineId: s,
+      targetOffset: u
+    };
+  }
+  /**
+   * Advance a vehicle by `distance` along its prepared path.
+   *
+   * Call this every tick. The returned `state` and `execution` replace the
+   * previous values. When `arrived` is true, the vehicle has reached the target.
+   *
+   * @param state - Current vehicle state
+   * @param execution - Current path execution (from preparePath or previous tick)
+   * @param distance - Distance to advance this tick (speed × deltaTime)
+   */
+  moveVehicle(e, s, n) {
+    const r = e.axles.map((i) => ({
+      lineId: i.lineId,
+      position: i.position,
+      absoluteOffset: i.offset
+    })), a = s.axleExecutions.map((i) => ({
+      currentSegmentIndex: i.segmentIndex,
+      segmentDistance: i.segmentDistance
+    })), o = $(r, a, s.path, n, this.linesMap, s.curveDataMap);
+    return {
+      state: {
+        axles: o.axles.map((i) => ({ lineId: i.lineId, offset: i.absoluteOffset, position: i.position })),
+        axleSpacings: e.axleSpacings
+      },
+      execution: {
+        ...s,
+        axleExecutions: o.axleExecutions.map((i) => ({
+          segmentIndex: i.currentSegmentIndex,
+          segmentDistance: i.segmentDistance
+        }))
+      },
+      arrived: o.arrived
+    };
+  }
+  /**
+   * Advance a vehicle with physics-based acceleration/deceleration.
+   *
+   * Thin wrapper — internally calls the standalone moveVehicleWithAcceleration()
+   * function from acceleration.ts, injecting this.linesMap as the 6th argument.
+   */
+  moveVehicleWithAcceleration(e, s, n, r, a) {
+    return ie(e, s, n, r, a, this.linesMap);
+  }
+}
+export {
+  fe as A,
+  U as B,
+  ae as C,
+  $ as D,
+  ie as E,
+  E as F,
+  ee as G,
+  G as H,
+  B as I,
+  Y as J,
+  de as P,
+  re as a,
+  Q as b,
+  z as c,
+  J as d,
+  H as e,
+  ue as f,
+  L as g,
+  _ as h,
+  S as i,
+  y as j,
+  k,
+  ne as l,
+  te as m,
+  se as n,
+  q as o,
+  X as p,
+  I as q,
+  W as r,
+  j as s,
+  ce as t,
+  A as u,
+  P as v,
+  K as w,
+  b as x,
+  w as y,
+  le as z
+};