vehicle-path2 1.0.3 → 1.0.5

package/dist/useVehicleEvents-Cv-YgfXB.js

@@ -0,0 +1,931 @@
+import { useState as _, useCallback as P, useRef as A, useMemo as z, useEffect as G, createContext as ae, useContext as ue } from "react";
+import { distance as le, initializeAllVehicles as ee, buildGraph as fe, updateAxlePosition as te, handleArrival as de, prepareCommandPath as H, calculateFrontAxlePosition as re } from "./core.js";
+import { v as K, p as me, a as B, f as ge, h as he, e as ve, V as se } from "./vehicle-helpers-BXX3GPzk.js";
+import { jsx as pe } from "react/jsx-runtime";
+function N(r) {
+  return Array.isArray(r) ? { x: r[0], y: r[1] } : r;
+}
+function J(r) {
+  return {
+    id: r.id,
+    start: N(r.start),
+    end: N(r.end)
+  };
+}
+function U(r) {
+  const o = r.fromIsPercentage !== !1, x = r.toIsPercentage !== !1;
+  return {
+    fromLineId: r.from,
+    toLineId: r.to,
+    // No conversion needed - internal format is now 0-1 (same as API)
+    fromOffset: r.fromPosition,
+    fromIsPercentage: r.fromPosition !== void 0 ? o : void 0,
+    toOffset: r.toPosition,
+    toIsPercentage: r.toPosition !== void 0 ? x : void 0
+  };
+}
+function X(r) {
+  const o = r.position ?? 0, x = r.isPercentage !== !1;
+  return {
+    vehicleId: r.id,
+    lineId: r.lineId,
+    // No conversion needed - internal format is now 0-1 (same as API)
+    offset: o,
+    isPercentage: x
+  };
+}
+function Y(r) {
+  const o = r.isPercentage !== !1, x = r.targetPosition ?? 1;
+  return {
+    vehicleId: r.vehicleId,
+    targetLineId: r.targetLineId,
+    // No conversion needed - internal format is now 0-1 (same as API)
+    targetOffset: x,
+    isPercentage: o,
+    awaitConfirmation: r.wait,
+    payload: r.payload
+  };
+}
+function Pe(r) {
+  const o = [], x = /* @__PURE__ */ new Set();
+  for (const s of r.lines)
+    x.has(s.id) && o.push(`Duplicate line ID: ${s.id}`), x.add(s.id);
+  if (r.connections)
+    for (const s of r.connections) {
+      x.has(s.from) || o.push(`Connection references non-existent line: ${s.from}`), x.has(s.to) || o.push(`Connection references non-existent line: ${s.to}`);
+      const d = s.fromIsPercentage !== !1, t = s.toIsPercentage !== !1;
+      !d && s.fromPosition === void 0 && o.push("fromPosition is required when fromIsPercentage is false"), !t && s.toPosition === void 0 && o.push("toPosition is required when toIsPercentage is false"), s.fromPosition !== void 0 && (d && (s.fromPosition < 0 || s.fromPosition > 1) ? o.push(`Invalid fromPosition: ${s.fromPosition} (must be 0-1 for percentage)`) : !d && s.fromPosition < 0 && o.push(`Invalid fromPosition: ${s.fromPosition} (must be >= 0 for absolute distance)`)), s.toPosition !== void 0 && (t && (s.toPosition < 0 || s.toPosition > 1) ? o.push(`Invalid toPosition: ${s.toPosition} (must be 0-1 for percentage)`) : !t && s.toPosition < 0 && o.push(`Invalid toPosition: ${s.toPosition} (must be >= 0 for absolute distance)`));
+    }
+  return { valid: o.length === 0, errors: o };
+}
+function ne() {
+  const [r, o] = _([]), [x, s] = _([]), [d, t] = _(null), f = P((n, h) => {
+    o(n), s(h), t(null);
+  }, []), I = P((n) => {
+    const h = Pe(n);
+    if (!h.valid)
+      return t(h.errors.join("; ")), { success: !1, errors: h.errors };
+    const a = n.lines.map(J), m = n.connections?.map(U) || [];
+    return f(a, m), { success: !0 };
+  }, [f]), O = P((n) => {
+    if (r.some((a) => a.id === n.id)) {
+      const a = `Line with ID '${n.id}' already exists`;
+      return t(a), { success: !1, error: a };
+    }
+    return o((a) => [...a, J(n)]), t(null), { success: !0 };
+  }, [r]), q = P((n, h) => {
+    if (r.findIndex((m) => m.id === n) === -1) {
+      const m = `Line with ID '${n}' not found`;
+      return t(m), { success: !1, error: m };
+    }
+    return o((m) => m.map((V) => V.id !== n ? V : {
+      ...V,
+      start: h.start ? N(h.start) : V.start,
+      end: h.end ? N(h.end) : V.end
+    })), t(null), { success: !0 };
+  }, [r]), y = P((n) => {
+    if (!r.some((a) => a.id === n)) {
+      const a = `Line with ID '${n}' not found`;
+      return t(a), { success: !1, error: a };
+    }
+    return o((a) => a.filter((m) => m.id !== n)), s((a) => a.filter((m) => m.fromLineId !== n && m.toLineId !== n)), t(null), { success: !0 };
+  }, [r]), L = P((n) => {
+    const h = r.some((l) => l.id === n.from), a = r.some((l) => l.id === n.to);
+    if (!h) {
+      const l = `Line '${n.from}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    if (!a) {
+      const l = `Line '${n.to}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    const m = n.fromIsPercentage !== !1, V = n.toIsPercentage !== !1;
+    if (!m && n.fromPosition === void 0) {
+      const l = "fromPosition is required when fromIsPercentage is false";
+      return t(l), { success: !1, error: l };
+    }
+    if (!V && n.toPosition === void 0) {
+      const l = "toPosition is required when toIsPercentage is false";
+      return t(l), { success: !1, error: l };
+    }
+    if (x.some((l) => l.fromLineId === n.from && l.toLineId === n.to)) {
+      const l = `Connection from '${n.from}' to '${n.to}' already exists`;
+      return t(l), { success: !1, error: l };
+    }
+    return s((l) => [...l, U(n)]), t(null), { success: !0 };
+  }, [r, x]), v = P((n, h, a) => {
+    const m = x.findIndex((e) => e.fromLineId === n && e.toLineId === h);
+    if (m === -1) {
+      const e = `Connection from '${n}' to '${h}' not found`;
+      return t(e), { success: !1, error: e };
+    }
+    const V = x[m], Q = a.fromIsPercentage ?? V.fromIsPercentage, l = a.toIsPercentage ?? V.toIsPercentage;
+    let D;
+    a.fromOffset !== void 0 ? D = a.fromOffset : V.fromOffset !== void 0 && (D = V.fromOffset);
+    let $;
+    if (a.toOffset !== void 0 ? $ = a.toOffset : V.toOffset !== void 0 && ($ = V.toOffset), D !== void 0) {
+      if (Q !== !1 && (D < 0 || D > 1)) {
+        const e = `Invalid fromOffset: ${D} (must be 0-1 for percentage)`;
+        return t(e), { success: !1, error: e };
+      }
+      if (Q === !1 && D < 0) {
+        const e = `Invalid fromOffset: ${D} (must be >= 0 for absolute distance)`;
+        return t(e), { success: !1, error: e };
+      }
+    }
+    if ($ !== void 0) {
+      if (l !== !1 && ($ < 0 || $ > 1)) {
+        const e = `Invalid toOffset: ${$} (must be 0-1 for percentage)`;
+        return t(e), { success: !1, error: e };
+      }
+      if (l === !1 && $ < 0) {
+        const e = `Invalid toOffset: ${$} (must be >= 0 for absolute distance)`;
+        return t(e), { success: !1, error: e };
+      }
+    }
+    if (Q === !1 && D === void 0) {
+      const e = "fromOffset is required when fromIsPercentage is false";
+      return t(e), { success: !1, error: e };
+    }
+    if (l === !1 && $ === void 0) {
+      const e = "toOffset is required when toIsPercentage is false";
+      return t(e), { success: !1, error: e };
+    }
+    const w = {
+      from: n,
+      to: h,
+      fromPosition: D,
+      fromIsPercentage: Q,
+      toPosition: $,
+      toIsPercentage: l
+    };
+    return s((e) => e.map(
+      (c, u) => u === m ? U(w) : c
+    )), t(null), { success: !0 };
+  }, [x]), p = P((n, h) => {
+    if (!x.some((m) => m.fromLineId === n && m.toLineId === h)) {
+      const m = `Connection from '${n}' to '${h}' not found`;
+      return t(m), { success: !1, error: m };
+    }
+    return s((m) => m.filter((V) => !(V.fromLineId === n && V.toLineId === h))), t(null), { success: !0 };
+  }, [x]), i = P(() => {
+    o([]), s([]), t(null);
+  }, []);
+  return {
+    lines: r,
+    curves: x,
+    setScene: I,
+    addLine: O,
+    updateLine: q,
+    removeLine: y,
+    addConnection: L,
+    updateConnection: v,
+    removeConnection: p,
+    clear: i,
+    error: d,
+    _loadScene: f
+  };
+}
+function oe({ lines: r, wheelbase: o }) {
+  const [x, s] = _([]), [d, t] = _(null), f = A([]), I = P((v) => {
+    f.current = v, s(v), t(null);
+  }, []), O = P((v) => {
+    const p = Array.isArray(v) ? v : [v], i = [];
+    for (const m of p)
+      f.current.some((Q) => Q.id === m.id) && i.push(`Vehicle with ID '${m.id}' already exists`);
+    if (i.length > 0)
+      return t(i.join("; ")), { success: !1, errors: i };
+    const n = p.map(X), { vehicles: h, errors: a } = K(
+      n,
+      r,
+      o
+    );
+    return a.length > 0 ? (t(a.join("; ")), { success: !1, errors: a }) : (f.current = [...f.current, ...h], s(f.current), t(null), { success: !0 });
+  }, [r, o]), q = P((v, p) => {
+    const i = f.current.findIndex(($) => $.id === v);
+    if (i === -1) {
+      const $ = `Vehicle with ID '${v}' not found`;
+      return t($), { success: !1, error: $ };
+    }
+    const n = f.current[i];
+    if (n.state !== "idle") {
+      const $ = `Cannot update vehicle '${v}' while it is ${n.state}. Vehicle must be idle.`;
+      return t($), { success: !1, error: $ };
+    }
+    const h = p.lineId ?? n.lineId;
+    if (!r.find(($) => $.id === h)) {
+      const $ = `Line '${h}' not found`;
+      return t($), { success: !1, error: $ };
+    }
+    let m, V;
+    p.lineId !== void 0 && p.position === void 0 ? (m = 0, V = !0) : p.position !== void 0 ? (m = p.position, V = p.isPercentage ?? !0) : (m = n.offset, V = n.isPercentage);
+    const Q = {
+      vehicleId: v,
+      lineId: h,
+      offset: m,
+      isPercentage: V
+    }, { vehicles: l, errors: D } = K(
+      [Q],
+      r,
+      o
+    );
+    return D.length > 0 ? (t(D.join("; ")), { success: !1, error: D.join("; ") }) : (f.current = f.current.map(
+      ($, w) => w === i ? l[0] : $
+    ), s(f.current), t(null), { success: !0 });
+  }, [r, o]), y = P((v) => {
+    if (!f.current.some((i) => i.id === v)) {
+      const i = `Vehicle with ID '${v}' not found`;
+      return t(i), { success: !1, error: i };
+    }
+    return f.current = f.current.filter((i) => i.id !== v), s(f.current), t(null), { success: !0 };
+  }, []), L = P(() => {
+    f.current = [], s([]), t(null);
+  }, []);
+  return {
+    vehicles: x,
+    addVehicles: O,
+    updateVehicle: q,
+    removeVehicle: y,
+    clear: L,
+    error: d,
+    _loadVehicles: I
+  };
+}
+function ce({ vehicles: r, lines: o }) {
+  const [x, s] = _(/* @__PURE__ */ new Map()), [d, t] = _(null), f = A(/* @__PURE__ */ new Map()), I = P(() => f.current, []), O = P((L) => {
+    f.current = L, s(L), t(null);
+  }, []), q = P((L, v) => {
+    if (!r.some((l) => l.id === L)) {
+      const l = `Vehicle '${L}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    const i = o.find((l) => l.id === v.targetLineId);
+    if (!i) {
+      const l = `Line '${v.targetLineId}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    const n = v.isPercentage !== !1, h = le(i.start, i.end);
+    if (!n && v.targetPosition === void 0) {
+      const l = "targetPosition is required when isPercentage is false";
+      return t(l), { success: !1, error: l };
+    }
+    const a = v.targetPosition ?? 1;
+    if (n) {
+      if (a < 0 || a > 1) {
+        const l = `Invalid targetPosition: ${a} (must be 0-1 for percentage)`;
+        return t(l), { success: !1, error: l };
+      }
+    } else {
+      if (a < 0) {
+        const l = `Invalid targetPosition: ${a} (must be >= 0 for absolute distance)`;
+        return t(l), { success: !1, error: l };
+      }
+      if (a > h) {
+        const l = `Position ${a} exceeds line length ${h}`;
+        return t(l), { success: !1, error: l };
+      }
+    }
+    const m = Y({ vehicleId: L, ...v }), V = new Map(f.current), Q = V.get(L) || [];
+    return V.set(L, [...Q, m]), f.current = V, s(V), t(null), { success: !0 };
+  }, [r, o]), y = P((L) => {
+    if (L !== void 0) {
+      if (!r.some((i) => i.id === L)) {
+        const i = `Vehicle '${L}' not found`;
+        return t(i), { success: !1, error: i };
+      }
+      const p = new Map(f.current);
+      p.delete(L), f.current = p, s(p);
+    } else
+      f.current = /* @__PURE__ */ new Map(), s(/* @__PURE__ */ new Map());
+    return t(null), { success: !0 };
+  }, [r]);
+  return {
+    vehicleQueues: x,
+    getVehicleQueues: I,
+    queueMovement: q,
+    clearQueue: y,
+    error: d,
+    _loadQueues: O
+  };
+}
+function Ie({
+  vehicles: r,
+  lines: o,
+  vehicleQueues: x,
+  getVehicleQueues: s,
+  wheelbase: d,
+  tangentMode: t,
+  curves: f,
+  eventEmitter: I
+}) {
+  const [O, q] = _([]), y = A([]), L = P((w) => {
+    typeof w == "function" ? L((e) => {
+      const c = w(e);
+      return y.current = c, c;
+    }) : (y.current = w, q(w));
+  }, []), v = P(() => y.current, []), p = z(() => ({
+    wheelbase: d,
+    tangentMode: t
+  }), [d, t]), i = z(
+    () => new Map(o.map((w) => [w.id, w])),
+    [o]
+  ), n = A(/* @__PURE__ */ new Map());
+  G(() => {
+    const { movingVehicles: w, stateMap: e } = ee(r, i);
+    n.current = e;
+    const c = setTimeout(() => {
+      L(w);
+    }, 0);
+    return () => clearTimeout(c);
+  }, [r, i]);
+  const h = A(null);
+  G(() => {
+    o.length > 0 && (h.current = fe(o, f, p));
+  }, [o, f, p]);
+  const a = A(0), m = A(!1), V = P((w) => {
+    if (!m.current) return !1;
+    let e = !1;
+    for (const [, u] of n.current)
+      if (u.vehicle.state === "moving") {
+        e = !0;
+        break;
+      }
+    if (!e)
+      return !1;
+    const c = [];
+    for (const [u, g] of n.current) {
+      if (g.vehicle.state !== "moving" || !g.execution) continue;
+      const M = g.execution;
+      let C;
+      if (M.front.currentSegmentIndex < M.path.segments.length) {
+        const j = M.path.segments[M.front.currentSegmentIndex];
+        if (j.type === "line") {
+          const S = i.get(j.lineId);
+          S && (C = Math.sqrt(
+            Math.pow(S.end.x - S.start.x, 2) + Math.pow(S.end.y - S.start.y, 2)
+          ));
+        }
+      }
+      const b = te(
+        g.vehicle.rear,
+        M.rear,
+        M.path,
+        w,
+        i,
+        M.curveDataMap
+      ), T = te(
+        g.vehicle.front,
+        M.front,
+        M.path,
+        w,
+        i,
+        M.curveDataMap,
+        C
+      );
+      if (g.vehicle = {
+        ...g.vehicle,
+        rear: b.axleState,
+        front: T.axleState
+      }, g.execution.rear = b.execution, g.execution.front = T.execution, b.completed) {
+        const S = de(g, {
+          linesMap: i,
+          config: p,
+          vehicleQueues: x,
+          curves: f,
+          graphRef: h,
+          prepareCommandPath: H,
+          onCommandComplete: (k) => c.push({ type: "commandComplete", data: k }),
+          onCommandStart: (k) => c.push({ type: "commandStart", data: k })
+        });
+        g.vehicle = S.vehicle, S.newExecution !== void 0 && (g.execution = S.newExecution), S.vehicle.state !== "moving" && c.push({
+          type: "stateChange",
+          data: { vehicleId: u, from: "moving", to: S.vehicle.state }
+        });
+        const E = S.vehicle.rear.position, R = S.vehicle.front.position;
+        c.push({
+          type: "positionUpdate",
+          data: {
+            vehicleId: u,
+            rear: E,
+            front: R,
+            center: { x: (E.x + R.x) / 2, y: (E.y + R.y) / 2 },
+            angle: Math.atan2(R.y - E.y, R.x - E.x)
+          }
+        });
+      }
+    }
+    if (L((u) => u.map((g) => {
+      const M = n.current.get(g.id);
+      return M ? M.vehicle : g;
+    })), I && c.length > 0) {
+      const u = a.current;
+      setTimeout(() => {
+        a.current === u && c.forEach(({ type: g, data: M }) => {
+          I.emit(g, M);
+        });
+      }, 0);
+    }
+    for (const [, u] of n.current)
+      if (u.vehicle.state === "moving")
+        return !0;
+    return m.current = !1, !1;
+  }, [i, f, p, x, I]), Q = P(() => {
+    if (m.current) return !0;
+    const w = h.current;
+    if (!w) return !1;
+    const e = s ? s() : x, c = [];
+    let u = !1;
+    for (const [g, M] of n.current) {
+      const C = M.vehicle, b = e.get(g);
+      if (!b || b.length === 0) continue;
+      const T = b[0], S = H(C, T, { graph: w, linesMap: i, curves: f, config: p });
+      if (!S) {
+        console.warn(`No path found for vehicle ${g}`);
+        continue;
+      }
+      const E = re(S.path, 0, 0, d);
+      n.current.set(g, {
+        ...M,
+        execution: {
+          path: S.path,
+          curveDataMap: S.curveDataMap,
+          currentCommandIndex: 0,
+          rear: { currentSegmentIndex: 0, segmentDistance: 0 },
+          front: E ? { currentSegmentIndex: E.segmentIndex, segmentDistance: E.segmentDistance } : { currentSegmentIndex: 0, segmentDistance: 0 }
+        },
+        vehicle: { ...C, state: "moving" }
+      }), u = !0, C.state !== "moving" && c.push({
+        id: g,
+        fromState: C.state,
+        command: T,
+        startPosition: {
+          lineId: C.rear.lineId,
+          absoluteOffset: C.rear.absoluteOffset,
+          position: C.rear.position
+        }
+      });
+    }
+    if (!u) return !1;
+    if (m.current = !0, L((g) => g.map((M) => {
+      const C = n.current.get(M.id);
+      return C ? C.vehicle : M;
+    })), I && c.length > 0) {
+      const g = a.current;
+      setTimeout(() => {
+        a.current === g && c.forEach(({ id: M, fromState: C, command: b, startPosition: T }) => {
+          I.emit("commandStart", {
+            vehicleId: M,
+            command: b,
+            commandIndex: 0,
+            startPosition: T
+          }), I.emit("stateChange", {
+            vehicleId: M,
+            from: C,
+            to: "moving"
+          });
+        });
+      }, 0);
+    }
+    return !0;
+  }, [i, f, x, s, p, d, I]), l = P(() => {
+    a.current++, m.current = !1;
+    const { movingVehicles: w, stateMap: e } = ee(r, i);
+    n.current = e, L(w);
+  }, [r, i]), D = P((w) => {
+    const e = n.current.get(w);
+    if (!e || e.vehicle.state !== "waiting")
+      return !1;
+    const c = x.get(w), u = e.execution;
+    if (!u) return !1;
+    const g = u.currentCommandIndex + 1;
+    if (c && g < c.length) {
+      const M = h.current;
+      if (M) {
+        const C = c[g], b = { graph: M, linesMap: i, curves: f, config: p }, T = H(e.vehicle, C, b);
+        if (T) {
+          const j = re(T.path, 0, 0, d);
+          if (e.execution = {
+            path: T.path,
+            curveDataMap: T.curveDataMap,
+            currentCommandIndex: g,
+            rear: { currentSegmentIndex: 0, segmentDistance: 0 },
+            front: j ? { currentSegmentIndex: j.segmentIndex, segmentDistance: j.segmentDistance } : { currentSegmentIndex: 0, segmentDistance: 0 }
+          }, e.vehicle = { ...e.vehicle, state: "moving" }, L((S) => S.map((E) => E.id === w ? e.vehicle : E)), I) {
+            const S = a.current;
+            setTimeout(() => {
+              a.current === S && I.emit("stateChange", {
+                vehicleId: w,
+                from: "waiting",
+                to: "moving"
+              });
+            }, 0);
+          }
+          return !0;
+        }
+      }
+    }
+    if (e.vehicle = { ...e.vehicle, state: "idle" }, e.execution = null, L((M) => M.map((C) => C.id === w ? e.vehicle : C)), I) {
+      const M = a.current;
+      setTimeout(() => {
+        a.current === M && I.emit("stateChange", {
+          vehicleId: w,
+          from: "waiting",
+          to: "idle"
+        });
+      }, 0);
+    }
+    return !0;
+  }, [x, i, f, p, d, I]), $ = P(() => {
+    for (const [, w] of n.current)
+      if (w.vehicle.state === "moving")
+        return !0;
+    return !1;
+  }, []);
+  return {
+    movingVehicles: O,
+    getMovingVehicles: v,
+    prepare: Q,
+    tick: V,
+    reset: l,
+    continueVehicle: D,
+    isMoving: $,
+    isPrepared: m.current
+  };
+}
+function Se({
+  wheelbase: r,
+  tangentMode: o = "proportional-40",
+  eventEmitter: x
+}) {
+  const s = ne(), d = oe({ lines: s.lines, wheelbase: r }), t = ce({
+    vehicles: d.vehicles,
+    lines: s.lines,
+    curves: s.curves
+  }), f = Ie({
+    vehicles: d.vehicles,
+    lines: s.lines,
+    vehicleQueues: t.vehicleQueues,
+    getVehicleQueues: t.getVehicleQueues,
+    wheelbase: r,
+    tangentMode: o,
+    curves: s.curves,
+    eventEmitter: x
+  }), I = P((e) => d.vehicles.filter((c) => c.lineId === e || c.rear.lineId === e), [d.vehicles]), O = P((e) => I(e).length > 0, [I]), q = P((e) => {
+    const c = s.addLine(e);
+    return c.success ? { success: !0 } : { success: !1, error: c.error };
+  }, [s]), y = P((e, c) => {
+    const u = s.updateLine(e, c);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [s]), L = P((e) => {
+    const c = [], u = I(e);
+    u.length > 0 && (c.push({
+      type: "vehicle_on_removed_line",
+      message: `${u.length} vehicle(s) are on line '${e}'`,
+      details: {
+        lineId: e,
+        vehicleIds: u.map((C) => C.id)
+      }
+    }), u.forEach((C) => {
+      d.removeVehicle(C.id), t.clearQueue(C.id);
+    }));
+    const g = s.curves.filter(
+      (C) => C.fromLineId === e || C.toLineId === e
+    );
+    g.length > 0 && c.push({
+      type: "orphaned_connection",
+      message: `${g.length} connection(s) will be removed`,
+      details: {
+        lineId: e,
+        connectionCount: g.length
+      }
+    });
+    const M = s.removeLine(e);
+    return M.success ? {
+      success: !0,
+      warnings: c.length > 0 ? c : void 0
+    } : { success: !1, error: M.error };
+  }, [s, I, d, t]), v = P(() => {
+    s.clear(), d.clear(), t.clearQueue();
+  }, [s, d, t]), p = P((e, c, u) => {
+    const g = s.addConnection({
+      from: e,
+      to: c,
+      fromPosition: u?.fromOffset,
+      fromIsPercentage: u?.fromIsPercentage,
+      toPosition: u?.toOffset,
+      toIsPercentage: u?.toIsPercentage
+    });
+    return g.success ? { success: !0 } : { success: !1, error: g.error };
+  }, [s]), i = P((e, c, u) => {
+    const g = s.updateConnection(e, c, u);
+    return g.success ? { success: !0 } : { success: !1, error: g.error };
+  }, [s]), n = P((e, c) => {
+    const u = s.removeConnection(e, c);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [s]), h = P((e) => {
+    const c = d.addVehicles(e);
+    return c.success ? { success: !0 } : { success: !1, error: c.errors?.join("; ") };
+  }, [d]), a = P((e, c) => {
+    const u = d.updateVehicle(e, c);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [d]), m = P((e) => {
+    const c = [], u = t.vehicleQueues.get(e);
+    u && u.length > 0 && (c.push({
+      type: "movement_queue_cleared",
+      message: `${u.length} queued movement(s) will be cleared for vehicle '${e}'`,
+      details: {
+        vehicleId: e
+      }
+    }), t.clearQueue(e));
+    const g = d.removeVehicle(e);
+    return g.success ? {
+      success: !0,
+      warnings: c.length > 0 ? c : void 0
+    } : { success: !1, error: g.error };
+  }, [d, t]), V = P(() => {
+    d.clear(), t.clearQueue();
+  }, [d, t]), Q = P((e) => {
+    const c = {
+      targetLineId: e.lineId,
+      targetPosition: e.position ?? 1,
+      isPercentage: e.isPercentage,
+      wait: e.wait,
+      payload: e.payload
+    }, u = t.queueMovement(e.id, c);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [t]), l = P((e) => {
+    const c = t.clearQueue(e);
+    return c.success ? { success: !0 } : { success: !1, error: c.error };
+  }, [t]), D = P((e) => {
+    const c = [], u = [], { scene: g, vehicles: M, movements: C } = me(e);
+    g.errors.length > 0 && u.push(...g.errors), M.errors.length > 0 && u.push(...M.errors), C.errors.length > 0 && u.push(...C.errors);
+    const b = g.data.lines.map(J), T = (g.data.connections || []).map(U), j = M.data.map(X), { vehicles: S, errors: E } = K(j, b, r);
+    E.length > 0 && u.push(...E);
+    const R = /* @__PURE__ */ new Map();
+    for (const k of C.data) {
+      const Z = R.get(k.vehicleId) || [];
+      Z.push(Y(k)), R.set(k.vehicleId, Z);
+    }
+    return s._loadScene(b, T), d._loadVehicles(S), t._loadQueues(R), u.length > 0 && c.push({
+      type: "dsl_parse_error",
+      message: `DSL loading had ${u.length} error(s)`,
+      details: { errors: u }
+    }), {
+      success: !0,
+      warnings: c.length > 0 ? c : void 0
+    };
+  }, [s, d, t, r]), $ = P((e) => {
+    const c = [], u = [], g = e.lines.map(J), M = (e.connections || []).map(U), C = (e.vehicles || []).map(X), { vehicles: b, errors: T } = K(C, g, r);
+    T.length > 0 && u.push(...T);
+    const j = /* @__PURE__ */ new Map();
+    for (const S of e.movements || []) {
+      const E = j.get(S.vehicleId) || [];
+      E.push(Y({
+        vehicleId: S.vehicleId,
+        targetLineId: S.targetLineId,
+        targetPosition: S.targetPosition,
+        isPercentage: S.isPercentage,
+        wait: S.wait,
+        payload: S.payload
+      })), j.set(S.vehicleId, E);
+    }
+    return s._loadScene(g, M), d._loadVehicles(b), t._loadQueues(j), u.length > 0 && c.push({
+      type: "dsl_parse_error",
+      message: `JSON loading had ${u.length} error(s)`,
+      details: { errors: u }
+    }), {
+      success: !0,
+      warnings: c.length > 0 ? c : void 0
+    };
+  }, [s, d, t, r]), w = z(() => s.error || d.error || t.error, [s.error, d.error, t.error]);
+  return {
+    // State
+    lines: s.lines,
+    curves: s.curves,
+    vehicles: d.vehicles,
+    movingVehicles: f.movingVehicles,
+    getMovingVehicles: f.getMovingVehicles,
+    vehicleQueues: t.vehicleQueues,
+    error: w,
+    // Scene operations
+    addLine: q,
+    updateLine: y,
+    removeLine: L,
+    clearScene: v,
+    // Connection operations
+    connect: p,
+    updateConnection: i,
+    disconnect: n,
+    // Vehicle operations
+    addVehicles: h,
+    updateVehicle: a,
+    removeVehicle: m,
+    clearVehicles: V,
+    // Movement operations
+    goto: Q,
+    clearQueue: l,
+    // Animation (delegated to useVehicleMovement)
+    prepare: f.prepare,
+    tick: f.tick,
+    reset: f.reset,
+    continueVehicle: f.continueVehicle,
+    isMoving: f.isMoving,
+    // DSL Loading
+    loadFromDSL: D,
+    // JSON Loading
+    loadFromJSON: $,
+    // Utility
+    getVehiclesOnLine: I,
+    hasVehiclesOnLine: O
+  };
+}
+function F(r) {
+  return r.map((o) => ({
+    id: o.id,
+    start: o.start,
+    end: o.end
+  }));
+}
+function W(r) {
+  return r.map((o) => ({
+    from: o.fromLineId,
+    to: o.toLineId,
+    // No conversion needed - internal format is now 0-1 (same as API)
+    fromPosition: o.fromOffset,
+    fromIsPercentage: o.fromIsPercentage,
+    toPosition: o.toOffset,
+    toIsPercentage: o.toIsPercentage
+  }));
+}
+function we() {
+  const [r, o] = _(""), [x, s] = _(null), { lines: d, curves: t, setScene: f } = ne(), I = A(!1), O = A("");
+  G(() => {
+    O.current = r;
+  }, [r]), G(() => {
+    if (I.current)
+      return;
+    const v = {
+      lines: F(d),
+      connections: t.length > 0 ? W(t) : void 0
+    }, p = B(v);
+    p !== O.current && (I.current = !0, o(p), setTimeout(() => {
+      I.current = !1;
+    }, 50));
+  }, [d, t]);
+  const q = P((v) => {
+    I.current = !0, o(v);
+    try {
+      const { data: p, errors: i } = ge(v);
+      i.length > 0 && s(i.join("; "));
+      const n = f(p);
+      !n.success && n.errors ? s((h) => h ? `${h}; ${n.errors.join("; ")}` : n.errors.join("; ")) : i.length === 0 && s(null);
+    } catch (p) {
+      s(p instanceof Error ? p.message : "Invalid scene definition");
+    }
+    setTimeout(() => {
+      I.current = !1;
+    }, 50);
+  }, [f]), y = P((v) => {
+    const p = typeof v == "function" ? v(d) : v, i = W(t);
+    f({
+      lines: F(p),
+      connections: i.length > 0 ? i : void 0
+    });
+    const n = {
+      lines: F(p),
+      connections: i.length > 0 ? i : void 0
+    }, h = B(n);
+    I.current = !0, o(h), setTimeout(() => {
+      I.current = !1;
+    }, 50);
+  }, [d, t, f]), L = P((v) => {
+    const p = typeof v == "function" ? v(t) : v, i = W(p);
+    f({
+      lines: F(d),
+      connections: i.length > 0 ? i : void 0
+    });
+    const n = {
+      lines: F(d),
+      connections: i.length > 0 ? i : void 0
+    }, h = B(n);
+    I.current = !0, o(h), setTimeout(() => {
+      I.current = !1;
+    }, 50);
+  }, [d, t, f]);
+  return {
+    lines: d,
+    curves: t,
+    sceneDefinitionText: r,
+    sceneError: x,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setLines: y,
+    setCurves: L,
+    setSceneDefinitionText: q
+  };
+}
+function $e({ lines: r, wheelbase: o }) {
+  const [x, s] = _(""), [d, t] = _(null), { vehicles: f, addVehicles: I, clear: O, error: q } = oe({ lines: r, wheelbase: o }), y = A(!1), L = P((v) => {
+    y.current = !0, s(v);
+    try {
+      const { data: p, errors: i } = he(v), n = [...i];
+      O();
+      for (const h of p) {
+        const a = I(h);
+        !a.success && a.errors && n.push(...a.errors);
+      }
+      n.length > 0 ? t(n.join(`
+`)) : t(null);
+    } catch (p) {
+      t(p instanceof Error ? p.message : "Invalid initial movement");
+    }
+    setTimeout(() => {
+      y.current = !1;
+    }, 50);
+  }, [I, O]);
+  return {
+    vehicles: f,
+    initialMovementText: x,
+    movementError: d || q,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setInitialMovementText: L
+  };
+}
+function ye({ lines: r, vehicles: o }) {
+  const [x, s] = _(""), [d, t] = _([]), [f, I] = _(null), { vehicleQueues: O, queueMovement: q, clearQueue: y, error: L } = ce({
+    vehicles: o,
+    lines: r
+  }), v = A(!1), p = P((i) => {
+    v.current = !0, s(i);
+    try {
+      const { data: n, errors: h } = ve(i), a = [...h];
+      y();
+      for (const m of n) {
+        const V = q(m.vehicleId, {
+          targetLineId: m.targetLineId,
+          targetPosition: m.targetPosition,
+          isPercentage: m.isPercentage,
+          wait: m.wait,
+          payload: m.payload
+        });
+        !V.success && V.error && a.push(V.error);
+      }
+      t(n), a.length > 0 ? I(a.join(`
+`)) : I(null);
+    } catch (n) {
+      I(n instanceof Error ? n.message : "Invalid movement sequence"), t([]);
+    }
+    setTimeout(() => {
+      v.current = !1;
+    }, 50);
+  }, [q, y]);
+  return {
+    movementSequenceText: x,
+    gotoCommands: d,
+    vehicleQueues: O,
+    sequenceError: f || L,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setMovementSequenceText: p
+  };
+}
+const ie = ae(null);
+function xe() {
+  const r = ue(ie);
+  if (!r)
+    throw new Error("useVehicleEventEmitter must be used within a VehicleEventProvider");
+  return r;
+}
+function Ee() {
+  return z(() => new se(), []);
+}
+function De(r, o, x = []) {
+  const s = xe();
+  G(() => s.on(r, o), [s, r, ...x]);
+}
+function Oe({ children: r }) {
+  const o = z(() => new se(), []);
+  return /* @__PURE__ */ pe(ie.Provider, { value: o, children: r });
+}
+export {
+  ie as V,
+  Oe as a,
+  Ee as b,
+  $e as c,
+  ce as d,
+  ye as e,
+  ne as f,
+  we as g,
+  De as h,
+  xe as i,
+  Se as j,
+  oe as k,
+  Ie as u
+};