vehicle-path2 1.0.7 → 1.0.9

package/dist/useVehicleEvents-t_p-Bwhj.js

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