vehicle-path2 1.0.2 → 1.0.3

package/dist/useVehicleEvents-Lf_yySwI.js

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