vehicle-path2 1.0.5 → 1.0.7

package/dist/useVehicleEvents-DcNmJGRn.js

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