@almadar/runtime 5.6.1 → 5.8.0

package/dist/OrbitalServerRuntime.js

@@ -1,368 +1,36 @@
 import { createLogger, EventBus, createUnifiedLoader, MockPersistenceAdapter, InMemoryPersistence, preprocessSchema, StateMachineManager, createContextFromBindings, validateEventPayload, formatPayloadValidationError, EffectExecutor } from './chunk-54YR5TKO.js';
 export { InMemoryPersistence } from './chunk-54YR5TKO.js';
 import './chunk-PZ5AY32C.js';
-import { Router } from 'express';
-import * as fs from 'fs';
-import fs__default from 'fs';
-import path from 'path';
+import * as nodeModule from 'module';
 import { evaluateGuard, evaluate } from '@almadar/evaluator';
 import { isInlineTrait, isEntityCall } from '@almadar/core';
-import * as net from 'net';
-import { execSync } from 'child_process';
 
-var LocalPersistenceAdapter = class {
-  root;
-  constructor(root) {
-    this.root = root;
-    fs__default.mkdirSync(root, { recursive: true });
-  }
-  entityDir(entityType) {
-    const dir = path.join(this.root, entityType.toLowerCase());
-    fs__default.mkdirSync(dir, { recursive: true });
-    return dir;
-  }
-  filePath(entityType, id) {
-    return path.join(this.entityDir(entityType), `${id}.json`);
-  }
-  async create(entityType, data) {
-    const id = data.id || `${entityType.toLowerCase()}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    const record = { ...data, id };
-    const filePath = this.filePath(entityType, id);
-    fs__default.writeFileSync(filePath, JSON.stringify(record, null, 2), "utf-8");
-    return { id };
-  }
-  async update(entityType, id, data) {
-    const filePath = this.filePath(entityType, id);
-    let existing = { id };
-    if (fs__default.existsSync(filePath)) {
-      existing = JSON.parse(fs__default.readFileSync(filePath, "utf-8"));
-    }
-    const merged = { ...existing, ...data, id };
-    fs__default.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
-  }
-  async delete(entityType, id) {
-    const filePath = this.filePath(entityType, id);
-    if (fs__default.existsSync(filePath)) {
-      fs__default.unlinkSync(filePath);
-    }
-  }
-  async getById(entityType, id) {
-    const filePath = this.filePath(entityType, id);
-    if (!fs__default.existsSync(filePath)) return null;
-    return JSON.parse(fs__default.readFileSync(filePath, "utf-8"));
-  }
-  async list(entityType) {
-    const dir = this.entityDir(entityType);
-    if (!fs__default.existsSync(dir)) return [];
-    const files = fs__default.readdirSync(dir).filter((f) => f.endsWith(".json"));
-    const results = [];
-    for (const file of files) {
-      const content = fs__default.readFileSync(path.join(dir, file), "utf-8");
-      results.push(JSON.parse(content));
-    }
-    return results;
-  }
-  /**
-   * Remove all data for an entity type.
-   */
-  async clear(entityType) {
-    const dir = path.join(this.root, entityType.toLowerCase());
-    if (fs__default.existsSync(dir)) {
-      fs__default.rmSync(dir, { recursive: true, force: true });
-    }
-  }
-  /**
-   * Remove all local data.
-   */
-  async clearAll() {
-    if (fs__default.existsSync(this.root)) {
-      fs__default.rmSync(this.root, { recursive: true, force: true });
-      fs__default.mkdirSync(this.root, { recursive: true });
-    }
-  }
-};
-function globToRegex(glob) {
-  let regex = "";
-  let i = 0;
-  while (i < glob.length) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") {
-        regex += ".*";
-        i += 2;
-        if (glob[i] === "/") i++;
-        continue;
-      }
-      regex += "[^/]*";
-    } else if (c === "?") {
-      regex += "[^/]";
-    } else if (c === ".") {
-      regex += "\\.";
-    } else if (c === "/" || c === "-" || c === "_") {
-      regex += c;
-    } else if (/[{}()[\]^$+|\\]/.test(c)) {
-      regex += "\\" + c;
-    } else {
-      regex += c;
-    }
-    i++;
-  }
-  return new RegExp("^" + regex + "$");
-}
-function parseCronField(field, min, max) {
-  const values = /* @__PURE__ */ new Set();
-  for (const part of field.split(",")) {
-    if (part === "*") {
-      for (let i = min; i <= max; i++) values.add(i);
-    } else if (part.includes("/")) {
-      const [range, stepStr] = part.split("/");
-      const step = parseInt(stepStr, 10);
-      const start = range === "*" ? min : parseInt(range, 10);
-      for (let i = start; i <= max; i += step) values.add(i);
-    } else if (part.includes("-")) {
-      const [lo, hi] = part.split("-").map(Number);
-      for (let i = lo; i <= hi; i++) values.add(i);
-    } else {
-      values.add(parseInt(part, 10));
-    }
-  }
-  return values;
-}
-function parseCron(expression) {
-  const parts = expression.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression (expected 5 fields): ${expression}`);
-  }
-  return {
-    minute: parseCronField(parts[0], 0, 59),
-    hour: parseCronField(parts[1], 0, 23),
-    day: parseCronField(parts[2], 1, 31),
-    month: parseCronField(parts[3], 1, 12),
-    weekday: parseCronField(parts[4], 0, 6)
-  };
-}
-function cronMatches(fields, date) {
-  return fields.minute.has(date.getMinutes()) && fields.hour.has(date.getHours()) && fields.day.has(date.getDate()) && fields.month.has(date.getMonth() + 1) && fields.weekday.has(date.getDay());
-}
-function createOsHandlers(ctx) {
-  const cwd = ctx.cwd ?? process.cwd();
-  const watchers = [];
-  const intervals = [];
-  const signalHandlers = [];
-  let httpWatchActive = false;
-  const debounceConfig = /* @__PURE__ */ new Map();
-  const debounceTimers = /* @__PURE__ */ new Map();
-  function debouncedEmit(eventType, payload) {
-    const ms = debounceConfig.get(eventType);
-    if (ms !== void 0 && ms > 0) {
-      const existing = debounceTimers.get(eventType);
-      if (existing) clearTimeout(existing);
-      debounceTimers.set(
-        eventType,
-        setTimeout(() => {
-          debounceTimers.delete(eventType);
-          ctx.emitEvent(eventType, payload);
-        }, ms)
-      );
+var _resolvedNodeRequire = null;
+function nodeRequire(modulePath) {
+  if (!_resolvedNodeRequire) {
+    const evalRequire = (0, eval)('typeof require !== "undefined" ? require : null');
+    if (evalRequire) {
+      _resolvedNodeRequire = evalRequire;
     } else {
-      ctx.emitEvent(eventType, payload);
-    }
-  }
-  const resolveOnMessage = (emit, fallback) => emit?.on_message ?? fallback;
-  const handlers = {
-    osWatchFiles: (glob, options, emit) => {
-      const recursive = options.recursive !== false;
-      const pattern = globToRegex(glob);
-      const eventName = resolveOnMessage(emit, "OS_FILE_MODIFIED");
-      try {
-        const watcher = fs.watch(cwd, { recursive }, (_event, filename) => {
-          if (filename && pattern.test(filename)) {
-            debouncedEmit(eventName, {
-              file: filename,
-              glob,
-              cwd
-            });
-          }
-        });
-        watchers.push(watcher);
-      } catch (err) {
-        if (emit?.failure) {
-          ctx.emitEvent(emit.failure, {
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        console.warn("[os/watch-files] Failed to start watcher:", err);
-      }
-    },
-    osWatchProcess: (name, subcommand, emit) => {
-      const searchTerm = subcommand ? `${name} ${subcommand}` : name;
-      let wasRunning = false;
-      const startEvent = resolveOnMessage(emit, "OS_PROCESS_STARTED");
-      const exitEvent = resolveOnMessage(emit, "OS_PROCESS_EXITED");
-      const interval = setInterval(() => {
-        let isRunning = false;
-        try {
-          const result = execSync(`pgrep -f "${searchTerm}" 2>/dev/null`, {
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-          isRunning = result.trim().length > 0;
-        } catch {
-          isRunning = false;
-        }
-        if (isRunning && !wasRunning) {
-          debouncedEmit(startEvent, { process: name, subcommand: subcommand ?? null });
-        } else if (!isRunning && wasRunning) {
-          debouncedEmit(exitEvent, { process: name, subcommand: subcommand ?? null });
-        }
-        wasRunning = isRunning;
-      }, 2e3);
-      intervals.push(interval);
-    },
-    osWatchPort: (port, protocol, emit) => {
-      if (protocol !== "tcp") {
-        console.warn(`[os/watch-port] Only TCP is supported, got: ${protocol}`);
-        return;
-      }
-      let wasOpen = false;
-      const openEvent = resolveOnMessage(emit, "OS_PORT_OPENED");
-      const closeEvent = resolveOnMessage(emit, "OS_PORT_CLOSED");
-      const interval = setInterval(() => {
-        const socket = new net.Socket();
-        socket.setTimeout(1e3);
-        socket.on("connect", () => {
-          socket.destroy();
-          if (!wasOpen) {
-            wasOpen = true;
-            debouncedEmit(openEvent, { port, protocol });
-          }
-        });
-        socket.on("error", () => {
-          socket.destroy();
-          if (wasOpen) {
-            wasOpen = false;
-            debouncedEmit(closeEvent, { port, protocol });
-          }
-        });
-        socket.on("timeout", () => {
-          socket.destroy();
-          if (wasOpen) {
-            wasOpen = false;
-            debouncedEmit(closeEvent, { port, protocol });
-          }
-        });
-        socket.connect(port, "127.0.0.1");
-      }, 3e3);
-      intervals.push(interval);
-    },
-    osWatchHttp: (urlPattern, method, _emit) => {
-      if (!httpWatchActive) {
-        httpWatchActive = true;
-        console.warn(
-          `[os/watch-http] HTTP interception is only supported in compiled mode. Pattern: ${urlPattern}${method ? `, method: ${method}` : ""}`
+      const createReq = nodeModule.createRequire;
+      if (typeof createReq !== "function") {
+        throw new Error(
+          "[OrbitalServerRuntime] No synchronous require available. This branch is Node-only \u2014 invoking it from a browser indicates an isNodeEnv() guard regression upstream."
         );
       }
-    },
-    osWatchCron: (expression, emit) => {
-      let fields;
-      try {
-        fields = parseCron(expression);
-      } catch (err) {
-        if (emit?.failure) {
-          ctx.emitEvent(emit.failure, {
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        console.warn("[os/watch-cron] Invalid expression:", err);
-        return;
-      }
-      let lastFired = -1;
-      const eventName = resolveOnMessage(emit, "OS_CRON_FIRE");
-      const interval = setInterval(() => {
-        const now = /* @__PURE__ */ new Date();
-        const minuteKey = now.getFullYear() * 1e8 + now.getMonth() * 1e6 + now.getDate() * 1e4 + now.getHours() * 100 + now.getMinutes();
-        if (minuteKey !== lastFired && cronMatches(fields, now)) {
-          lastFired = minuteKey;
-          debouncedEmit(eventName, {
-            expression,
-            firedAt: now.toISOString()
-          });
-        }
-      }, 1e3);
-      intervals.push(interval);
-    },
-    osWatchSignal: (signal, emit) => {
-      const sig = signal.toUpperCase();
-      const handler = () => {
-        const eventName = emit?.on_message ?? `OS_SIGNAL_${sig}`;
-        debouncedEmit(eventName, { signal: sig });
-      };
-      try {
-        process.on(sig, handler);
-        signalHandlers.push({ signal: sig, handler });
-      } catch (err) {
-        if (emit?.failure) {
-          ctx.emitEvent(emit.failure, {
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-        console.warn(`[os/watch-signal] Cannot listen for ${sig}:`, err);
-      }
-    },
-    osWatchEnv: (variable, emit) => {
-      let lastValue = process.env[variable];
-      const eventName = resolveOnMessage(emit, "OS_ENV_CHANGED");
-      const interval = setInterval(() => {
-        const current = process.env[variable];
-        if (current !== lastValue) {
-          const previous = lastValue;
-          lastValue = current;
-          debouncedEmit(eventName, {
-            variable,
-            value: current ?? null,
-            previous: previous ?? null
-          });
-        }
-      }, 1e3);
-      intervals.push(interval);
-    },
-    osDebounce: (ms, eventType) => {
-      debounceConfig.set(eventType, ms);
-    }
-  };
-  function cleanup() {
-    for (const w of watchers) {
-      try {
-        w.close();
-      } catch {
-      }
-    }
-    watchers.length = 0;
-    for (const i of intervals) {
-      clearInterval(i);
+      _resolvedNodeRequire = createReq(import.meta.url);
     }
-    intervals.length = 0;
-    for (const { signal, handler } of signalHandlers) {
-      try {
-        process.removeListener(signal, handler);
-      } catch {
-      }
-    }
-    signalHandlers.length = 0;
-    httpWatchActive = false;
-    for (const timer of debounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    debounceTimers.clear();
   }
-  return { handlers, cleanup };
+  return _resolvedNodeRequire(modulePath);
 }
-
-// src/OrbitalServerRuntime.ts
+var _nodeRequireExt = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
 var effectLog = createLogger("almadar:runtime:effects");
 var busLog = createLogger("almadar:runtime:bus");
 var renderLog = createLogger("almadar:runtime:render-ui");
 var xOrbitalLog = createLogger("almadar:runtime:cross-orbital");
+function isNodeEnv() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
 function collectDeclaredConfigDefaults(trait) {
   if (!trait) return void 0;
   const schema = trait.config;
@@ -441,12 +109,19 @@ var OrbitalServerRuntime = class {
     } else {
       this.persistence = config.persistence || new InMemoryPersistence();
     }
-    if (config.localStorageRoot) {
+    if (config.localStorageRoot && isNodeEnv()) {
+      const { LocalPersistenceAdapter } = nodeRequire(`./LocalPersistenceAdapter${_nodeRequireExt}`);
       this.localPersistence = new LocalPersistenceAdapter(config.localStorageRoot);
     }
-    this.osHandlers = createOsHandlers({
-      emitEvent: (type, payload) => this.eventBus.emit(type, payload)
-    });
+    if (isNodeEnv()) {
+      const { createOsHandlers } = nodeRequire(`./createOsHandlers${_nodeRequireExt}`);
+      this.osHandlers = createOsHandlers({
+        emitEvent: (type, payload) => this.eventBus.emit(type, payload)
+      });
+    } else {
+      this.osHandlers = { handlers: {}, cleanup: () => {
+      } };
+    }
     this.config.effectHandlers = {
       ...this.osHandlers.handlers,
       ...this.config.effectHandlers
@@ -467,22 +142,22 @@ var OrbitalServerRuntime = class {
       return;
     }
     try {
-      const [{ fileURLToPath }, path2, fs3] = await Promise.all([
+      const [{ fileURLToPath }, path, fs] = await Promise.all([
         import('url'),
         import('path'),
         import('fs')
       ]);
       const mainEntryUrl = import.meta.resolve("@almadar/std");
       const mainEntry = fileURLToPath(mainEntryUrl);
-      let stdLibPath = path2.dirname(mainEntry);
-      while (stdLibPath !== path2.dirname(stdLibPath)) {
-        if (fs3.existsSync(path2.join(stdLibPath, "package.json"))) {
+      let stdLibPath = path.dirname(mainEntry);
+      while (stdLibPath !== path.dirname(stdLibPath)) {
+        if (fs.existsSync(path.join(stdLibPath, "package.json"))) {
           const pkg = JSON.parse(
-            fs3.readFileSync(path2.join(stdLibPath, "package.json"), "utf-8")
+            fs.readFileSync(path.join(stdLibPath, "package.json"), "utf-8")
           );
           if (pkg.name === "@almadar/std") break;
         }
-        stdLibPath = path2.dirname(stdLibPath);
+        stdLibPath = path.dirname(stdLibPath);
       }
       const basePath = this.config.loaderConfig?.basePath ?? process.cwd();
       this.loader = createUnifiedLoader({
@@ -601,20 +276,20 @@ var OrbitalServerRuntime = class {
    * Node only. Browsers must receive already-resolved schemas from their
    * server (see `getResolvedSchema()`).
    */
-  async registerFromFile(path2) {
+  async registerFromFile(path) {
     if (typeof process === "undefined" || !process.versions?.node) {
       throw new Error(
         "registerFromFile is Node-only. Browsers should receive resolved schemas from their server."
       );
     }
     const { readFile } = await import('fs/promises');
-    const raw = await readFile(path2, "utf-8");
+    const raw = await readFile(path, "utf-8");
     let schema;
     try {
       schema = JSON.parse(raw);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      throw new Error(`registerFromFile: ${path2} is not valid JSON: ${msg}`);
+      throw new Error(`registerFromFile: ${path} is not valid JSON: ${msg}`);
     }
     await this.register(schema);
   }
@@ -1654,8 +1329,8 @@ var OrbitalServerRuntime = class {
         });
         pushClientEffect(["render-ui", slot, pattern, props, priority]);
       },
-      navigate: (path2, params) => {
-        pushClientEffect(["navigate", path2, params]);
+      navigate: (path, params) => {
+        pushClientEffect(["navigate", path, params]);
       },
       notify: (message, type) => {
         if (this.config.debug) {
@@ -1934,6 +1609,12 @@ var OrbitalServerRuntime = class {
    * - POST /:orbital/events - Send event to orbital (includes data from `fetch` effects)
    */
   router() {
+    if (!isNodeEnv()) {
+      throw new Error(
+        "OrbitalServerRuntime.router() is Node-only (uses Express). For in-browser use, mount <BrowserPlayground> from @almadar/ui instead."
+      );
+    }
+    const { Router } = nodeRequire("express");
     const router = Router();
     router.get("/", (_req, res) => {
       const orbitals = Array.from(this.orbitals.entries()).map(
@@ -2092,6 +1773,6 @@ function buildMatcher(src, listenerOrbital) {
   return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
 }
 
-export { LocalPersistenceAdapter, OrbitalServerRuntime, createOrbitalServerRuntime };
+export { OrbitalServerRuntime, createOrbitalServerRuntime };
 //# sourceMappingURL=OrbitalServerRuntime.js.map
 //# sourceMappingURL=OrbitalServerRuntime.js.map