@runium/core 0.0.9 → 0.1.1

package/index.js

@@ -0,0 +1,594 @@
+import { readFile as x, writeFile as M, mkdir as j } from "node:fs/promises";
+import { EventEmitter as v } from "node:events";
+import q from "bcx-expression-evaluator";
+import K from "ajv/dist/2020.js";
+import U from "ajv-keywords";
+import { spawn as F } from "node:child_process";
+import { createWriteStream as w } from "node:fs";
+import { resolve as I, dirname as P } from "node:path";
+class p extends Error {
+  code;
+  payload;
+  constructor(t, s, r = null) {
+    super(t), this.code = s, this.payload = r;
+  }
+}
+function At(e) {
+  return !!e && e instanceof p;
+}
+var Y = ((e) => (e.READ_JSON = "file-read-json", e.WRITE_JSON = "file-write-json", e))(Y || {});
+async function _t(e) {
+  try {
+    const t = await x(e, { encoding: "utf-8" });
+    return JSON.parse(t);
+  } catch (t) {
+    throw new p(`Can not read JSON file ${e}`, "file-read-json", { path: e, original: t });
+  }
+}
+async function It(e, t) {
+  try {
+    await M(e, JSON.stringify(t, null, 2), { encoding: "utf-8" });
+  } catch (s) {
+    throw new p(`Can not write JSON file ${e}`, "file-write-json", { path: e, data: t, original: s });
+  }
+}
+const V = String.raw`"\$unwrap\((.*)\)"`;
+var J = ((e) => (e.MACRO_APPLY_ERROR = "macro-apply-error", e))(J || {});
+function $t(e, t) {
+  const s = Object.keys(t), r = String.raw`\$(${s.join("|")})\(([^()]*(?:\([^()]*\)[^()]*)*)\)`, i = (o) => {
+    const a = new RegExp(r, "g");
+    let c = o, n = !0;
+    for (; n; ) n = !1, c = c.replace(a, (u, A, N) => {
+      n = !0;
+      const y = [];
+      let _ = 0, S = "";
+      for (const g of N) g === "," && _ === 0 ? (y.push(S.trim()), S = "") : (g === "(" && _++, g === ")" && _--, S += g);
+      y.push(S.trim());
+      const G = y.map((g) => g ? i(g) : "");
+      try {
+        return t[A](...G);
+      } catch (g) {
+        throw new p(`Can not apply macro "${A}"`, "macro-apply-error", { type: A, args: y, original: g });
+      }
+    });
+    return c;
+  };
+  return (function(o) {
+    const a = new RegExp(V, "g");
+    return o.replace(a, (c, n) => n.trim());
+  })(s.length ? i(e) : e);
+}
+var f = ((e) => (e.IMMEDIATE = "immediate", e.DEFERRED = "deferred", e.IGNORE = "ignore", e))(f || {}), d = ((e) => (e.EMIT_EVENT = "emit-event", e.START_TASK = "start-task", e.RESTART_TASK = "restart-task", e.STOP_TASK = "stop-task", e.STOP_PROJECT = "stop-project", e.ENABLE_TRIGGER = "enable-trigger", e.DISABLE_TRIGGER = "disable-trigger", e))(d || {}), T = ((e) => (e.DEFAULT = "default", e))(T || {}), l = ((e) => (e.EVENT = "event", e.TIMEOUT = "timeout", e.INTERVAL = "interval", e))(l || {}), m = ((e) => (e.ALWAYS = "always", e.ON_FAILURE = "on-failure", e))(m || {}), B = ((e) => (e.INCORRECT_DATA = "project-config-incorrect-data", e.TASKS_CIRCULAR_DEPENDENCY = "project-config-tasks-circular-dependency", e.TASK_NOT_EXISTS = "project-config-task-not-exists", e.TRIGGER_NOT_EXISTS = "project-config-trigger-not-exists", e))(B || {});
+const H = /* @__PURE__ */ new Set(["start-task", "restart-task", "stop-task"]), W = /* @__PURE__ */ new Set(["enable-trigger", "disable-trigger"]), X = new Set(Object.values(d)), z = new Set(Object.values(l));
+function b(e) {
+  return H.has(e.type);
+}
+function O(e) {
+  return W.has(e.type);
+}
+function Z(e) {
+  return !X.has(e.type);
+}
+function Q(e) {
+  return !z.has(e.type);
+}
+const C = new K({ allowUnionTypes: !0, allErrors: !0, verbose: !0 });
+function tt(e) {
+  const t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set();
+  for (const i of e.tasks) s.add(i.id), t.set(i.id, []);
+  const r = new Set(e.triggers?.map((i) => i.id) || []);
+  for (const i of e.tasks) {
+    for (const o of i.dependencies || []) {
+      if (!s.has(o.taskId)) throw new p(`Task "${i.id}" depends on not existing task "${o.taskId}"`, "project-config-task-not-exists", { taskId: i.id, dependency: { ...o }, scope: "dependencies" });
+      t.get(o.taskId).push(i.id);
+    }
+    for (const o of i.handlers || []) {
+      if (b(o.action) && !s.has(o.action.taskId)) throw new p(`Task "${i.id}" handler action uses not existing task "${o.action.taskId}"`, "project-config-task-not-exists", { taskId: i.id, handler: { ...o }, scope: "handlers" });
+      if (O(o.action) && !r.has(o.action.triggerId)) throw new p(`Task "${i.id}" handler action uses not existing trigger "${o.action.triggerId}"`, "project-config-trigger-not-exists", { taskId: i.id, handler: { ...o }, scope: "handlers" });
+    }
+  }
+  for (const i of e.triggers || []) {
+    if (b(i.action) && !s.has(i.action.taskId)) throw new p(`Trigger "${i.id}" action uses not existing task "${i.action.taskId}"`, "project-config-task-not-exists", { trigger: { ...i }, scope: "triggers" });
+    if (O(i.action) && !r.has(i.action.triggerId)) throw new p(`Trigger "${i.id}" action uses not existing trigger "${i.action.triggerId}"`, "project-config-trigger-not-exists", { trigger: { ...i }, scope: "triggers" });
+  }
+  (function(i) {
+    const o = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), c = (n) => {
+      if (a.has(n)) {
+        const u = [...a, n].join(" -> ");
+        throw new p(`Project config tasks circular dependency detected ${u}`, "project-config-tasks-circular-dependency", { task: n, dependencies: [...a] });
+      }
+      if (!o.has(n)) {
+        a.add(n);
+        for (const u of i.get(n) || []) c(u);
+        a.delete(n), o.add(n);
+      }
+    };
+    for (const n of i.keys()) o.has(n) || c(n);
+  })(t);
+}
+function et(e, t) {
+  (function(s, r) {
+    const i = C.compile(r || {});
+    if (!i(s)) throw new p("Incorrect project config data", "project-config-incorrect-data", { errors: i.errors });
+  })(e, t), tt(e);
+}
+U(C, ["uniqueItemProperties"]);
+var h = ((e) => (e.IDLE = "idle", e.STARTING = "starting", e.STARTED = "started", e.COMPLETED = "completed", e.FAILED = "failed", e.STOPPING = "stopping", e.STOPPED = "stopped", e))(h || {}), k = ((e) => (e.STATE_CHANGE = "state-change", e.STDOUT = "stdout", e.STDERR = "stderr", e))(k || {});
+const jt = -1;
+class D extends v {
+  constructor(t) {
+    super(), this.options = t;
+  }
+}
+class st extends D {
+  constructor(t) {
+    super(t), this.options = t, this.setMaxListeners(50), this.options.env = { ...process.env, ...t.env || {} }, this.options.cwd = I(process.cwd(), t.cwd || "");
+  }
+  state = { status: "idle", pid: -1, timestamp: Date.now(), iteration: 0 };
+  process = null;
+  stdoutStream = null;
+  stderrStream = null;
+  ttlTimer = null;
+  getState() {
+    return { ...this.state };
+  }
+  getOptions() {
+    return { ...this.options };
+  }
+  canStart() {
+    const { status: t } = this.state;
+    return t !== "started" && t !== "starting" && t !== "stopping";
+  }
+  async start() {
+    if (this.canStart()) {
+      this.updateState({ status: "starting", iteration: this.state.iteration + 1, pid: -1, exitCode: void 0, error: void 0 });
+      try {
+        await this.initLogStreams();
+        const { cwd: t, command: s, arguments: r = [], env: i, shell: o = !0 } = this.options;
+        this.process = F(s, r, { cwd: t, env: i, shell: o, stdio: ["ignore", "pipe", "pipe"] }), this.addProcessListeners(), this.setTTLTimer(), this.updateState({ status: "started", pid: this.process.pid });
+      } catch (t) {
+        this.onError(t);
+      }
+    }
+  }
+  canStop() {
+    const { status: t } = this.state;
+    return !!this.process && t === "started";
+  }
+  async stop(t = "") {
+    if (this.canStop()) return this.updateState({ status: "stopping", reason: t }), new Promise((s) => {
+      const r = this.options.stopSignal || "SIGTERM";
+      this.process.kill(r), this.process.on("exit", () => {
+        s();
+      });
+    });
+  }
+  async restart() {
+    await this.stop("restart"), this.start();
+  }
+  updateState(t) {
+    const s = { ...this.state, ...t, timestamp: Date.now() };
+    this.state = Object.fromEntries(Object.entries(s).filter(([r, i]) => i !== void 0)), this.emit("state-change", this.getState()), this.emit(this.state.status, this.getState());
+  }
+  async initLogStreams() {
+    const { stdout: t = null, stderr: s = null } = this.options.log || {};
+    if (t) {
+      const r = I(t);
+      await j(P(r), { recursive: !0 }), this.stdoutStream = w(t, { flags: "w" });
+    }
+    if (s) {
+      const r = I(s);
+      await j(P(r), { recursive: !0 }), this.stderrStream = w(s, { flags: "w" });
+    }
+  }
+  setTTLTimer() {
+    const { ttl: t } = this.options;
+    t && this.process && (this.ttlTimer = setTimeout(() => {
+      this.stop("ttl");
+    }, t));
+  }
+  addProcessListeners() {
+    this.process && (this.process.stdout?.on("data", (t) => this.onStdOutData(t)), this.process.stderr?.on("data", (t) => this.onStdErrData(t)), this.process.on("exit", (t) => this.onExit(t)), this.process.on("error", (t) => this.onError(t)));
+  }
+  onStdOutData(t) {
+    const s = t.toString();
+    this.emit("stdout", s), this.stdoutStream && this.stdoutStream.write(s);
+  }
+  onStdErrData(t) {
+    const s = t.toString();
+    this.emit("stderr", s), this.stderrStream && this.stderrStream.write(s);
+  }
+  onExit(t) {
+    const s = t !== null ? t : -1;
+    this.updateState({ status: s === 0 ? "completed" : s === -1 ? "stopped" : "failed", exitCode: s }), this.cleanup();
+  }
+  onError(t) {
+    this.updateState({ status: "failed", error: t }), this.cleanup();
+  }
+  cleanup() {
+    this.ttlTimer && (clearTimeout(this.ttlTimer), this.ttlTimer = null), this.process && (this.process.removeAllListeners(), this.process.stdout?.removeAllListeners(), this.process.stderr?.removeAllListeners(), this.process = null), this.stdoutStream && (this.stdoutStream.end(), this.stdoutStream = null), this.stderrStream && (this.stderrStream.end(), this.stderrStream = null);
+  }
+}
+var rt = ((e) => (e.ACTION_TYPE_ALREADY_USED = "project-schema-action-type-already-used", e.TASK_TYPE_ALREADY_USED = "project-schema-task-type-already-used", e.TRIGGER_TYPE_ALREADY_USED = "project-schema-trigger-type-already-used", e))(rt || {});
+const $ = /^[a-zA-Z0-9_-]+$/, it = { id: { type: "string", pattern: $.source }, name: { type: "string" }, type: { type: "string" }, mode: { $ref: "#/$defs/Runium_TaskStartMode" }, dependencies: { type: "array", items: { $ref: "#/$defs/Runium_TaskDependency" } }, handlers: { type: "array", items: { $ref: "#/$defs/Runium_TaskHandler" } }, restart: { $ref: "#/$defs/Runium_TaskRestartPolicy" } }, E = { id: { type: "string", pattern: $.source }, action: { $ref: "#/$defs/Runium_Action" }, disabled: { type: "boolean" } };
+function L(e, t) {
+  return { type: "object", properties: { ...structuredClone(it), type: { const: e }, options: { ...structuredClone(t) } }, required: ["id", "options"], additionalProperties: !1 };
+}
+function ot(e, t) {
+  return { type: "object", properties: { type: { type: "string", const: e }, ...t ? { payload: t } : {} }, required: ["type", ...t ? ["payload"] : []], additionalProperties: !1 };
+}
+function nt(e, t) {
+  const s = t ? { payload: t } : {}, r = t ? ["payload"] : [];
+  return { type: "object", properties: { ...structuredClone(E), type: { type: "string", const: e }, ...s }, required: ["id", "type", "action", ...r], additionalProperties: !1 };
+}
+function at() {
+  const e = { $schema: "https://json-schema.org/draft/2020-12/schema", $id: "https://example.com/schemas/project.json", title: "Project", type: "object", properties: { id: { type: "string", pattern: $.source }, name: { type: "string" }, tasks: { type: "array", items: { oneOf: [{ $ref: "#/$defs/Runium_TaskConfig" }] }, minItems: 1, uniqueItemProperties: ["id"] }, triggers: { type: "array", items: { $ref: "#/$defs/Runium_Trigger" }, uniqueItemProperties: ["id"] } }, required: ["id", "tasks"], additionalProperties: !1, $defs: { Runium_EnvValue: { type: ["string", "number", "boolean"] }, Runium_Env: { type: "object", additionalProperties: { $ref: "#/$defs/Runium_EnvValue" } }, Runium_TaskStartMode: { type: "string", enum: Object.values(f) }, Runium_TaskHandler: { type: "object", properties: { action: { $ref: "#/$defs/Runium_Action" }, condition: { $ref: "#/$defs/Runium_TaskStateCondition" } }, required: ["action", "condition"], additionalProperties: !1 }, Runium_TaskStateCondition: { oneOf: [{ type: "string" }, { type: "boolean" }, { $ref: "#/$defs/Runium_TaskState" }] }, Runium_TaskState: { type: "object", properties: { status: { $ref: "#/$defs/Runium_TaskStatus" }, iteration: { type: "number", minimum: 0 }, exitCode: { type: "number", minimum: 0 }, reason: { type: "string" } }, additionalProperties: !1 }, Runium_TaskStatus: { type: "string", enum: Object.values(h) }, Runium_TaskDependency: { type: "object", properties: { taskId: { type: "string" }, condition: { $ref: "#/$defs/Runium_TaskStateCondition" } }, required: ["taskId", "condition"], additionalProperties: !1 }, Runium_Trigger: { oneOf: [{ $ref: "#/$defs/Runium_TriggerEvent" }, { $ref: "#/$defs/Runium_TriggerInterval" }, { $ref: "#/$defs/Runium_TriggerTimeout" }] }, Runium_TriggerEvent: { type: "object", properties: { ...structuredClone(E), type: { const: l.EVENT }, event: { type: "string" } }, required: ["id", "type", "event", "action"], additionalProperties: !1 }, Runium_TriggerInterval: { type: "object", properties: { ...structuredClone(E), type: { const: l.INTERVAL }, interval: { type: "number", minimum: 0 } }, required: ["id", "type", "interval", "action"], additionalProperties: !1 }, Runium_TriggerTimeout: { type: "object", properties: { ...structuredClone(E), type: { const: l.TIMEOUT }, timeout: { type: "number", minimum: 0 } }, required: ["id", "type", "timeout", "action"], additionalProperties: !1 }, Runium_Action: { oneOf: [{ $ref: "#/$defs/Runium_ActionEmitEvent" }, { $ref: "#/$defs/Runium_ActionProcessTask" }, { $ref: "#/$defs/Runium_ActionStopProject" }, { $ref: "#/$defs/Runium_ActionToggleTrigger" }] }, Runium_ActionEmitEvent: { type: "object", properties: { type: { type: "string", const: d.EMIT_EVENT }, event: { type: "string" } }, required: ["type", "event"], additionalProperties: !1 }, Runium_ActionProcessTask: { type: "object", properties: { type: { type: "string", enum: [d.START_TASK, d.RESTART_TASK, d.STOP_TASK] }, taskId: { type: "string" } }, required: ["type", "taskId"], additionalProperties: !1 }, Runium_ActionStopProject: { type: "object", properties: { type: { type: "string", const: d.STOP_PROJECT } }, required: ["type"], additionalProperties: !1 }, Runium_ActionToggleTrigger: { type: "object", properties: { type: { type: "string", enum: [d.ENABLE_TRIGGER, d.DISABLE_TRIGGER] }, triggerId: { type: "string" } }, required: ["type", "triggerId"], additionalProperties: !1 }, Runium_TaskConfig: { ...L(T.DEFAULT, { $ref: "#/$defs/Runium_TaskOptions" }) }, Runium_TaskOptions: { type: "object", properties: { command: { type: "string" }, arguments: { type: "array", items: { type: "string" } }, shell: { type: "boolean" }, cwd: { type: "string" }, env: { $ref: "#/$defs/Runium_Env" }, ttl: { type: "number" }, log: { $ref: "#/$defs/Runium_TaskLog" }, stopSignal: { type: "string" } }, required: ["command"], additionalProperties: !1 }, Runium_TaskRestartPolicy: { oneOf: [{ $ref: "#/$defs/Runium_TaskRestartPolicyAlways" }, { $ref: "#/$defs/Runium_TaskRestartPolicyOnFailure" }] }, Runium_TaskRestartPolicyAlways: { type: "object", required: ["policy"], properties: { policy: { const: m.ALWAYS }, delay: { type: "number" } }, additionalProperties: !1 }, Runium_TaskRestartPolicyOnFailure: { type: "object", required: ["policy"], properties: { policy: { const: m.ON_FAILURE }, delay: { type: "number" }, maxRetries: { type: "number" } }, additionalProperties: !1 }, Runium_TaskLog: { type: "object", properties: { stdout: { type: ["string", "null"] }, stderr: { type: ["string", "null"] } }, additionalProperties: !1 } } };
+  return Object.freeze(e);
+}
+function ct(e, t) {
+  let s = structuredClone(e);
+  return t.project && (s = (function(r, i) {
+    return i && (r.properties = { ...i.properties || {}, ...r.properties }, r.required = Array.from(/* @__PURE__ */ new Set([...r.required ?? [], ...i.required ?? []]))), r;
+  })(s, t.project)), t.definitions && (s = (function(r, i) {
+    return i && (r.$defs = { ...i, ...r.$defs }), r;
+  })(s, t.definitions)), t.tasks && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.properties.tasks.items.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "";
+        return r.$defs[n]?.properties?.type?.const || T.DEFAULT;
+      })), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new p(`Task type "${n.type}" already used in project schema`, "project-schema-task-type-already-used", { type: n.type });
+        a[c] = L(n.type, n.options), r.properties.tasks.items.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.tasks)), t.actions && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.$defs.Runium_Action.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "", u = r.$defs[n]?.properties?.type;
+        return u?.enum || [u?.const];
+      }).flat()), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new p(`Action type "${n.type}" already used in project schema`, "project-schema-action-type-already-used", { type: n.type });
+        a[c] = ot(n.type, n.payload), r.$defs.Runium_Action.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.actions)), t.triggers && (s = (function(r, i) {
+    if (i) {
+      const o = new Set(r.$defs.Runium_Trigger.oneOf.map((c) => {
+        const n = c.$ref.split("/").pop() || "";
+        return r.$defs[n]?.properties?.type?.const;
+      })), a = {};
+      for (const [c, n] of Object.entries(i)) {
+        if (o.has(n.type)) throw new p(`Trigger type "${n.type}" already used in project schema`, "project-schema-trigger-type-already-used", { type: n.type });
+        a[c] = nt(n.type, n.payload), r.$defs.Runium_Trigger.oneOf.push({ $ref: `#/$defs/${c}` }), o.add(n.type);
+      }
+      r.$defs = { ...a, ...r.$defs };
+    }
+    return r;
+  })(s, t.triggers)), Object.freeze(s);
+}
+class R {
+  project;
+  id;
+  action;
+  disabled;
+  constructor(t, s) {
+    this.id = t.id, this.action = t.action, this.disabled = t.disabled ?? !1, this.project = s;
+  }
+  getId() {
+    return this.id;
+  }
+  isDisabled() {
+    return this.disabled;
+  }
+}
+class pt extends R {
+  event;
+  constructor(t, s) {
+    super(t, s), this.event = t.event;
+  }
+  enable() {
+    this.project.on(this.event, this.handler), this.disabled = !1;
+  }
+  disable() {
+    this.project.off(this.event, this.handler), this.disabled = !0;
+  }
+  handler = () => {
+    this.project.processAction(this.action);
+  };
+}
+class dt extends R {
+  interval;
+  intervalId = null;
+  constructor(t, s) {
+    super(t, s), this.interval = t.interval;
+  }
+  enable() {
+    this.intervalId = setInterval(() => {
+      this.project.processAction(this.action);
+    }, this.interval), this.disabled = !1;
+  }
+  disable() {
+    this.intervalId && clearInterval(this.intervalId), this.disabled = !0, this.intervalId = null;
+  }
+}
+class ut extends R {
+  timeout;
+  timeoutId = null;
+  constructor(t, s) {
+    super(t, s), this.timeout = t.timeout;
+  }
+  enable() {
+    this.timeoutId = setTimeout(() => {
+      this.project.processAction(this.action);
+    }, this.timeout), this.disabled = !1;
+  }
+  disable() {
+    this.timeoutId && clearTimeout(this.timeoutId), this.disabled = !0, this.timeoutId = null;
+  }
+}
+var gt = ((e) => (e.STATE_CHANGE = "state-change", e.START_TASK = "start-task", e.RESTART_TASK = "restart-task", e.STOP_TASK = "stop-task", e.PROCESS_ACTION = "process-action", e.ENABLE_TRIGGER = "enable-trigger", e.DISABLE_TRIGGER = "disable-trigger", e.TASK_STATE_CHANGE = "task-state-change", e.TASK_STDOUT = "task-stdout", e.TASK_STDERR = "task-stderr", e))(gt || {}), ht = ((e) => (e.IDLE = "idle", e.STARTING = "starting", e.STARTED = "started", e.STOPPING = "stopping", e.STOPPED = "stopped", e))(ht || {}), lt = ((e) => (e.ACTION_PROCESSOR_ALREADY_REGISTERED = "project-action-processor-already-registered", e.ACTION_PROCESSOR_INCORRECT = "project-action-processor-incorrect", e.TASK_PROCESSOR_NOT_FOUND = "project-task-processor-not-found", e.TASK_PROCESSOR_ALREADY_REGISTERED = "project-task-processor-already-registered", e.TASK_PROCESSOR_INCORRECT = "project-task-processor-incorrect", e.TRIGGER_PROCESSOR_ALREADY_REGISTERED = "project-trigger-processor-already-registered", e.TRIGGER_PROCESSOR_INCORRECT = "project-trigger-processor-incorrect", e))(lt || {});
+class wt extends v {
+  constructor(t) {
+    super(), this.config = t;
+  }
+  schema = at();
+  taskProcessors = /* @__PURE__ */ new Map([[T.DEFAULT, st]]);
+  actionProcessors = /* @__PURE__ */ new Map();
+  triggerProcessors = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  triggers = /* @__PURE__ */ new Map();
+  state = { timestamp: Date.now(), status: "idle" };
+  validate() {
+    et(this.config, this.schema);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setConfig(t) {
+    this.config = { ...t };
+  }
+  getState() {
+    return { ...this.state };
+  }
+  async start() {
+    if (this.state.status !== "idle" && this.state.status !== "stopped") return;
+    this.validate(), this.initTasks(), this.initTriggers(), this.updateState({ status: "starting" });
+    const t = this.getTasksStartOrder();
+    for (const s of t) if (this.tasks.has(s)) {
+      const { instance: r, config: i } = this.tasks.get(s), { mode: o = f.IMMEDIATE, dependencies: a = [] } = i;
+      o === f.IMMEDIATE && a.length === 0 && r.start();
+    }
+    this.updateState({ status: "started" });
+  }
+  async stop(t = "") {
+    if (this.state.status !== "started" && this.state.status !== "starting") return;
+    this.updateState({ status: "stopping", reason: t }), this.cleanupTriggers();
+    const s = this.getTasksStartOrder().reverse(), r = [];
+    for (const i of s) if (this.tasks.has(i)) {
+      const { instance: o } = this.tasks.get(i), { status: a } = o.getState();
+      a === h.STARTED && r.push(o.stop("project-stop"));
+    }
+    await Promise.allSettled(r), this.updateState({ status: "stopped" });
+  }
+  extendValidationSchema(t) {
+    this.schema = ct(this.schema, t);
+  }
+  registerAction(t, s) {
+    if (this.actionProcessors.has(t)) throw new p(`Action processor for type "${t}" already registered`, "project-action-processor-already-registered", { type: t });
+    if (typeof s != "function") throw new p(`Action processor for type "${t}" must be a function`, "project-action-processor-incorrect", { type: t });
+    this.actionProcessors.set(t, s);
+  }
+  registerTask(t, s) {
+    if (this.taskProcessors.has(t)) throw new p(`Task processor for type "${t}" already registered`, "project-task-processor-already-registered", { type: t });
+    if (!(s.prototype instanceof D)) throw new p(`Task processor for type "${t}" must be a subclass of "RuniumTask"`, "project-task-processor-incorrect", { type: t });
+    this.taskProcessors.set(t, s);
+  }
+  registerTrigger(t, s) {
+    if (this.triggerProcessors.has(t)) throw new p(`Trigger processor for type "${t}" already registered`, "project-trigger-processor-already-registered", { type: t });
+    if (!(s.prototype instanceof R)) throw new p(`Trigger processor for type "${t}" must be a subclass of "RuniumTrigger"`, "project-trigger-processor-incorrect", { type: t });
+    this.triggerProcessors.set(t, s);
+  }
+  updateState(t) {
+    this.state = { ...this.state, ...t, timestamp: Date.now() }, this.emit("state-change", this.getState()), this.emit(this.state.status, this.getState());
+  }
+  initTasks() {
+    this.tasks.clear();
+    for (const t of this.config.tasks) {
+      const s = t.type || T.DEFAULT, r = this.taskProcessors.get(s);
+      if (!r) throw new p(`Task processor for type "${s}" not found`, "project-task-processor-not-found", { type: s });
+      const i = new r(t.options);
+      i.on(k.STATE_CHANGE, (o) => {
+        this.emit("task-state-change", t.id, o), this.onTaskStateChange(t.id, o);
+      }), i.on(k.STDOUT, (o) => {
+        this.emit("task-stdout", t.id, o);
+      }), i.on(k.STDERR, (o) => {
+        this.emit("task-stderr", t.id, o);
+      }), this.tasks.set(t.id, { instance: i, config: t, dependencies: [...t.dependencies || []], dependents: null });
+    }
+  }
+  getTasksStartOrder() {
+    const t = [], s = /* @__PURE__ */ new Set(), r = (i) => {
+      if (s.has(i)) return;
+      s.add(i);
+      const { dependencies: o = [] } = this.tasks.get(i) || {};
+      for (const a of o) this.tasks.has(a.taskId) && r(a.taskId);
+      t.push(i);
+    };
+    for (const i of this.tasks.keys()) r(i);
+    return t;
+  }
+  onTaskStateChange(t, s) {
+    const { config: r, instance: i } = this.tasks.get(t), o = this.getDependentTasks(t);
+    for (const a of o) this.isDependentTaskReady(a) && this.startTask(a);
+    if (s.status === h.COMPLETED || s.status === h.FAILED) {
+      const { restart: a } = r;
+      if (a && s.exitCode !== -1) {
+        const { policy: c } = a;
+        if (c === m.ALWAYS || c === m.ON_FAILURE && s.exitCode !== 0) {
+          const { maxRetries: n = 1 / 0, delay: u = 0 } = a;
+          s.iteration <= n && setTimeout(i.restart.bind(i), u);
+        }
+      }
+    }
+    (r.handlers || []).forEach((a) => {
+      this.checkTaskStateCondition(a.condition, s) && this.processAction(a.action);
+    });
+  }
+  checkTaskStateCondition(t, s) {
+    return typeof t == "string" ? q.evaluate(t, s) === !0 : typeof t == "object" ? Object.entries(t).every(([r, i]) => s[r] === i) : typeof t == "boolean" && t;
+  }
+  async startTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t), { status: r } = s.getState();
+      if (r !== h.STARTED && r !== h.STARTING && r !== h.STOPPING) return this.emit("start-task", t), s.start();
+    }
+  }
+  async stopTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t), { status: r } = s.getState();
+      if (r === h.STARTED) return this.emit("stop-task", t), s.stop("action-stop");
+    }
+  }
+  async restartTask(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t);
+      return this.emit("restart-task", t), s.restart();
+    }
+  }
+  getTaskState(t) {
+    if (this.tasks.has(t)) {
+      const { instance: s } = this.tasks.get(t);
+      return s.getState();
+    }
+    return null;
+  }
+  isDependentTaskReady(t) {
+    if (this.tasks.has(t)) {
+      const { dependencies: s = [], config: r } = this.tasks.get(t);
+      if (r.mode === f.IGNORE) return !1;
+      for (const { taskId: i, condition: o } of s) {
+        const { instance: a } = this.tasks.get(i);
+        if (!this.checkTaskStateCondition(o, a.getState())) return !1;
+      }
+      return !0;
+    }
+    return !1;
+  }
+  getDependentTasks(t) {
+    let s = [];
+    if (this.tasks.has(t)) {
+      const { dependents: r } = this.tasks.get(t);
+      if (r) s = r;
+      else {
+        for (const [i, { dependencies: o }] of this.tasks) for (const a of o) a.taskId === t && s.push(i);
+        this.tasks.get(t).dependents = s;
+      }
+    }
+    return s;
+  }
+  processAction(t) {
+    if (this.emit("process-action", t), Z(t)) {
+      const s = this.actionProcessors.get(t.type);
+      s && s(t.payload || {});
+    } else switch (t.type) {
+      case d.START_TASK:
+        this.startTask(t.taskId);
+        break;
+      case d.RESTART_TASK:
+        this.restartTask(t.taskId);
+        break;
+      case d.STOP_TASK:
+        this.stopTask(t.taskId);
+        break;
+      case d.EMIT_EVENT:
+        this.emit(t.event);
+        break;
+      case d.STOP_PROJECT:
+        this.stop("action");
+        break;
+      case d.ENABLE_TRIGGER:
+        this.enableTrigger(t.triggerId);
+        break;
+      case d.DISABLE_TRIGGER:
+        this.disableTrigger(t.triggerId);
+    }
+  }
+  initTriggers() {
+    const t = { processAction: this.processAction.bind(this), on: this.on.bind(this), off: this.off.bind(this) };
+    let s = null;
+    for (const r of this.config.triggers || []) {
+      if (Q(r)) {
+        const i = this.triggerProcessors.get(r.type);
+        i && (s = new i(r, t));
+      } else switch (r.type) {
+        case l.EVENT:
+          s = new pt(r, t);
+          break;
+        case l.INTERVAL:
+          s = new dt(r, t);
+          break;
+        case l.TIMEOUT:
+          s = new ut(r, t);
+      }
+      s && (this.triggers.set(r.id, s), r.disabled !== !0 && s.enable());
+    }
+  }
+  cleanupTriggers() {
+    for (const t in this.triggers) {
+      const s = this.triggers.get(t);
+      s && s.disable();
+    }
+    this.triggers.clear();
+  }
+  enableTrigger(t) {
+    const s = this.triggers.get(t);
+    s && (this.emit("enable-trigger", t), s.enable());
+  }
+  disableTrigger(t) {
+    const s = this.triggers.get(t);
+    s && (this.emit("disable-trigger", t), s.disable());
+  }
+}
+export {
+  pt as EventTrigger,
+  Y as FileErrorCode,
+  $ as ID_REGEX,
+  dt as IntervalTrigger,
+  J as MacrosErrorCode,
+  wt as Project,
+  d as ProjectActionType,
+  B as ProjectConfigErrorCode,
+  lt as ProjectErrorCode,
+  gt as ProjectEvent,
+  rt as ProjectSchemaErrorCode,
+  ht as ProjectStatus,
+  m as ProjectTaskRestartPolicyType,
+  f as ProjectTaskStartMode,
+  T as ProjectTaskType,
+  l as ProjectTriggerType,
+  p as RuniumError,
+  D as RuniumTask,
+  R as RuniumTrigger,
+  jt as SILENT_EXIT_CODE,
+  st as Task,
+  k as TaskEvent,
+  h as TaskStatus,
+  ut as TimeoutTrigger,
+  $t as applyMacros,
+  ct as extendProjectSchema,
+  at as getProjectSchema,
+  Z as isCustomAction,
+  Q as isCustomTrigger,
+  b as isProcessTaskAction,
+  At as isRuniumError,
+  O as isToggleTriggerAction,
+  _t as readJsonFile,
+  et as validateProject,
+  It as writeJsonFile
+};

package/package.json

@@ -1,35 +1,23 @@
 {
   "name": "@runium/core",
-  "version": "0.0.9",
+  "version": "0.1.1",
   "description": "Runium Core",
   "author": "TheBeastApp",
   "license": "MIT",
   "type": "module",
-  "scripts": {
-    "build": "vite build",
-    "lint": "eslint ./src --ext .ts",
-    "lint:fix": "eslint ./src --ext .ts --fix",
-    "format": "prettier --write \"src/**/*.ts\""
+  "main": "./index.js",
+  "module": "./index.js",
+  "files": [
+    "index.js"
+  ],
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    }
   },
   "dependencies": {
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
     "bcx-expression-evaluator": "^1.2.1"
-  },
-  "devDependencies": {
-    "@types/node": "^22.18.0",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.1.3",
-    "prettier": "^3.2.5",
-    "rollup-plugin-terser": "^7.0.2",
-    "terser": "^5.44.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3",
-    "vite": "^7.1.12",
-    "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-externalize-deps": "^0.10.0"
   }
-}
+}

package/.eslintrc.json

@@ -1,30 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es2022": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:prettier/recommended"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": 2022,
-    "sourceType": "module"
-  },
-  "plugins": ["@typescript-eslint", "prettier"],
-  "rules": {
-    "prettier/prettier": "error",
-    "@typescript-eslint/no-unused-vars": [
-      "error",
-      {
-        "argsIgnorePattern": "^_",
-        "varsIgnorePattern": "^_"
-      }
-    ],
-    "@typescript-eslint/no-explicit-any": "warn",
-    "no-console": "warn"
-  },
-  "ignorePatterns": ["dist/", "node_modules/"]
-}