@filamind-app/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1171 @@
+// src/provenance.ts
+function stamp(value, source = "live", staleAfter, now = Date.now()) {
+  return staleAfter == null ? { value, ts: now, source } : { value, ts: now, source, staleAfter };
+}
+var UNKNOWN = { value: void 0, ts: 0, source: "unknown" };
+function isStale(s, now = Date.now()) {
+  if (!s || s.source === "unknown") return true;
+  if (s.staleAfter == null) return false;
+  return now - s.ts > s.staleAfter;
+}
+function freshness(s, now = Date.now()) {
+  if (!s || s.source === "unknown") return "unknown";
+  return isStale(s, now) ? "stale" : "ok";
+}
+
+// src/state/observable.ts
+var Observable = class {
+  constructor(_value) {
+    this._value = _value;
+  }
+  _value;
+  listeners = /* @__PURE__ */ new Set();
+  get value() {
+    return this._value;
+  }
+  set(v) {
+    this._value = v;
+    this.emit();
+  }
+  update(fn) {
+    this.set(fn(this._value));
+  }
+  /** Subscribe and receive the current value immediately. Returns an unsubscribe fn. */
+  subscribe(fn) {
+    this.listeners.add(fn);
+    fn(this._value);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  emit() {
+    for (const l of this.listeners) l(this._value);
+  }
+};
+
+// src/state/printer.ts
+var FAST_PATH = /* @__PURE__ */ new Set(["motion_report"]);
+var PrinterState = class {
+  objects = new Observable({});
+  pendingPatch = {};
+  flushTimer;
+  coalesceMs;
+  constructor(coalesceMs = 1e3) {
+    this.coalesceMs = coalesceMs;
+  }
+  /** Seed from a printer.objects.query result. */
+  seed(objects) {
+    this.objects.set(deepMerge({}, objects));
+  }
+  /** Feed notify_status_update params: `[ { <object>: { <field>: value } }, eventtime ]`. */
+  applyNotify(params) {
+    const patch = Array.isArray(params) ? params[0] : params;
+    if (!patch || typeof patch !== "object") return;
+    const fast = {};
+    let hasSlow = false;
+    for (const key of Object.keys(patch)) {
+      if (FAST_PATH.has(key)) {
+        fast[key] = patch[key];
+      } else {
+        this.pendingPatch[key] = deepMerge(this.pendingPatch[key] ?? {}, patch[key]);
+        hasSlow = true;
+      }
+    }
+    if (Object.keys(fast).length > 0) {
+      this.objects.update((o) => deepMerge(o, fast));
+    }
+    if (hasSlow && this.flushTimer === void 0) {
+      this.flushTimer = setTimeout(() => this.flush(), this.coalesceMs);
+    }
+  }
+  /** Force-apply any pending coalesced patch now (e.g. on tab focus). */
+  flush() {
+    if (this.flushTimer !== void 0) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    const patch = this.pendingPatch;
+    this.pendingPatch = {};
+    if (Object.keys(patch).length > 0) {
+      this.objects.update((o) => deepMerge(o, patch));
+    }
+  }
+};
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(target, patch) {
+  if (!isPlainObject(patch)) return target;
+  const out = { ...target };
+  for (const key of Object.keys(patch)) {
+    const next = patch[key];
+    const prev = out[key];
+    out[key] = isPlainObject(next) && isPlainObject(prev) ? deepMerge(prev, next) : next;
+  }
+  return out;
+}
+
+// src/moonraker/client.ts
+var defaultWsFactory = (url) => new WebSocket(url);
+var MoonrakerClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.makeWs = opts.wsFactory ?? defaultWsFactory;
+  }
+  opts;
+  ws;
+  _state = "idle";
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  cb = {};
+  subs = {};
+  backoff = 1e3;
+  reconnectAttempts = 0;
+  closedByUser = false;
+  hasOpened = false;
+  reconnectTimer;
+  makeWs;
+  get state() {
+    return this._state;
+  }
+  setCallbacks(cb) {
+    this.cb = cb;
+  }
+  connect() {
+    this.closedByUser = false;
+    return new Promise((resolve) => {
+      this.setState("connecting");
+      const ws = this.makeWs(this.opts.url);
+      this.ws = ws;
+      ws.onopen = () => {
+        this.backoff = 1e3;
+        this.reconnectAttempts = 0;
+        this.setState("ready");
+        this.restoreSubs();
+        if (this.hasOpened) this.cb.onReconnected?.();
+        this.hasOpened = true;
+        resolve();
+      };
+      ws.onmessage = (ev) => this.onMessage(String(ev.data));
+      ws.onerror = () => this.cb.onError?.(new Error("websocket error"));
+      ws.onclose = () => {
+        this.failAll(new Error("connection closed"));
+        if (this.closedByUser) this.setState("closed");
+        else this.scheduleReconnect();
+      };
+    });
+  }
+  close() {
+    this.closedByUser = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    this.ws?.close();
+    if (this._state !== "ready") this.setState("closed");
+  }
+  call(method, params = {}) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`moonraker request timed out: ${method}`));
+      }, this.opts.requestTimeoutMs ?? 1e4);
+      this.pending.set(id, { resolve, reject, timer });
+      this.send({ jsonrpc: "2.0", method, params, id });
+    });
+  }
+  async subscribe(objects) {
+    this.subs = { ...this.subs, ...objects };
+    await this.call("printer.objects.subscribe", { objects });
+  }
+  // --- REST file channel (the WS carries control/telemetry; binaries go over HTTP) ---
+  async upload(root, file, onProgress) {
+    const form = new FormData();
+    form.append("root", root);
+    form.append("file", file);
+    await xhrUpload(`${this.httpBase()}/server/files/upload`, form, onProgress);
+  }
+  async download(path) {
+    const res = await fetch(`${this.httpBase()}/server/files/${path}`);
+    if (!res.ok) throw new Error(`download failed: ${res.status}`);
+    return res.blob();
+  }
+  // --- internals ---
+  httpBase() {
+    return this.opts.url.replace(/^ws/, "http").replace(/\/websocket\/?$/, "");
+  }
+  send(msg) {
+    this.ws?.send(JSON.stringify(msg));
+  }
+  setState(s) {
+    this._state = s;
+    this.cb.onConnectProgress?.(s);
+  }
+  restoreSubs() {
+    if (Object.keys(this.subs).length > 0) {
+      this.call("printer.objects.subscribe", { objects: this.subs }).catch(
+        (e) => this.opts.logger?.warn("restoreSubs failed", String(e))
+      );
+    }
+  }
+  scheduleReconnect() {
+    this.reconnectAttempts += 1;
+    const max = this.opts.maxReconnectAttempts;
+    if (max !== void 0 && this.reconnectAttempts > max) {
+      this.opts.logger?.error("reconnect giving up", this.reconnectAttempts);
+      this.setState("closed");
+      return;
+    }
+    this.setState("reconnecting");
+    const jitter = this.backoff * (0.8 + Math.random() * 0.4);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      if (this.closedByUser) return;
+      this.connect().catch(() => {
+      });
+    }, jitter);
+    this.backoff = Math.min(this.backoff * 2, this.opts.maxBackoffMs ?? 3e4);
+  }
+  failAll(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  onMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof msg.id === "number" && this.pending.has(msg.id)) {
+      const p = this.pending.get(msg.id);
+      if (!p) return;
+      clearTimeout(p.timer);
+      this.pending.delete(msg.id);
+      if (msg.error) p.reject(new Error(msg.error.message ?? "rpc error"));
+      else p.resolve(msg.result);
+      return;
+    }
+    if (typeof msg.method === "string") {
+      this.cb.onUpdate?.(msg.method, msg.params);
+    }
+  }
+};
+function xhrUpload(url, form, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", url);
+    if (onProgress) {
+      xhr.upload.onprogress = (e) => {
+        if (e.lengthComputable) onProgress(Math.round(e.loaded / e.total * 100));
+      };
+    }
+    xhr.onload = () => xhr.status >= 200 && xhr.status < 300 ? resolve() : reject(new Error(`upload failed: ${xhr.status}`));
+    xhr.onerror = () => reject(new Error("upload network error"));
+    xhr.send(form);
+  });
+}
+
+// src/moonraker/subscriptions.ts
+var SUBSCRIPTION_CONTRACT_VERSION = 1;
+var NARROW_STATUS = {
+  webhooks: ["state", "state_message"],
+  print_stats: ["state", "filename", "print_duration", "total_duration", "info"],
+  virtual_sdcard: ["progress", "is_active"],
+  display_status: ["message", "progress"],
+  idle_timeout: ["state"]
+};
+var FULL_CONTROL = {
+  webhooks: ["state", "state_message"],
+  gcode_move: null,
+  toolhead: null,
+  motion_report: null,
+  print_stats: null,
+  virtual_sdcard: null,
+  display_status: null,
+  idle_timeout: ["state"],
+  pause_resume: ["is_paused"],
+  fan: null,
+  configfile: ["settings", "warnings", "save_config_pending"]
+};
+function tier(t) {
+  return t === "narrow" ? NARROW_STATUS : FULL_CONTROL;
+}
+function mergeSubscriptions(...maps) {
+  const out = {};
+  for (const map of maps) {
+    for (const key of Object.keys(map)) {
+      const fields = map[key];
+      if (out[key] === null || fields === null) out[key] = null;
+      else out[key] = Array.from(/* @__PURE__ */ new Set([...out[key] ?? [], ...fields ?? []]));
+    }
+  }
+  return out;
+}
+
+// src/printer/klippy.ts
+var KNOWN = /* @__PURE__ */ new Set([
+  "ready",
+  "startup",
+  "shutdown",
+  "error",
+  "disconnected"
+]);
+function deriveKlippyState(raw) {
+  return typeof raw === "string" && KNOWN.has(raw) ? raw : "disconnected";
+}
+function isKlippyLive(state) {
+  return state === "ready";
+}
+
+// src/printer/prompt-parser.ts
+function parseButton(rest) {
+  const [label = "", gcode = "", style = ""] = rest.split("|");
+  const out = { label: label.trim() };
+  if (gcode.trim()) out.gcode = gcode.trim();
+  if (style.trim() === "primary" || style.trim() === "secondary" || style.trim() === "warning") {
+    out.style = style.trim();
+  }
+  return out;
+}
+var PromptParser = class {
+  current = null;
+  /** Feed one notify_gcode_response line. Returns a PromptEvent at show/end, else null. */
+  feed(line) {
+    const m = /^\s*\/\/\s*action:\s*prompt_(\w+)\s?(.*)$/.exec(line);
+    if (!m) return null;
+    const verb = m[1];
+    const rest = (m[2] ?? "").trim();
+    switch (verb) {
+      case "begin":
+        this.current = { title: rest || void 0, text: [], buttons: [], footer: [] };
+        return null;
+      case "text":
+        this.current?.text.push(rest);
+        return null;
+      case "button":
+        this.current?.buttons.push(parseButton(rest));
+        return null;
+      case "footer_button":
+        this.current?.footer.push(parseButton(rest));
+        return null;
+      case "show": {
+        const dialog = this.current ?? { text: [], buttons: [], footer: [] };
+        return { type: "show", dialog };
+      }
+      case "end":
+        this.current = null;
+        return { type: "end" };
+      default:
+        return null;
+    }
+  }
+};
+
+// src/observability/logger.ts
+var Logger = class {
+  constructor(max = 200, sink) {
+    this.max = max;
+    this.sink = sink;
+  }
+  max;
+  sink;
+  ring = [];
+  log(level, msg, data) {
+    const e = data === void 0 ? { ts: Date.now(), level, msg } : { ts: Date.now(), level, msg, data };
+    this.ring.push(e);
+    if (this.ring.length > this.max) this.ring.shift();
+    this.sink?.(e);
+  }
+  debug(msg, data) {
+    this.log("debug", msg, data);
+  }
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  /** Snapshot of recent events (for the diagnostics bundle). */
+  recent() {
+    return [...this.ring];
+  }
+  clear() {
+    this.ring = [];
+  }
+};
+var NULL_LOGGER = new Logger(0);
+
+// src/remote/commands.ts
+var FILAMIND_COMMAND_EVENT = "filamind:command";
+var REMOTE_VIEWS = ["status", "control", "settings"];
+var REMOTE_MESSAGE_LEVELS = ["info", "warn"];
+var isObj = (v) => typeof v === "object" && v !== null;
+var CONTROL_BIDI = new RegExp(
+  "[\\u0000-\\u001F\\u007F-\\u009F\\u200B-\\u200F\\u202A-\\u202E\\u2066-\\u2069\\uFEFF]",
+  "g"
+);
+function sanitizeText(raw) {
+  const cleaned = Array.from(raw.replace(CONTROL_BIDI, " ")).slice(0, 280).join("").trim();
+  return cleaned.length > 0 ? cleaned : null;
+}
+function parseCommand(raw) {
+  if (!isObj(raw)) return null;
+  switch (raw.kind) {
+    case "navigate":
+      return typeof raw.view === "string" && REMOTE_VIEWS.includes(raw.view) ? { kind: "navigate", view: raw.view } : null;
+    case "message": {
+      if (typeof raw.text !== "string") return null;
+      if (typeof raw.level !== "string" || !REMOTE_MESSAGE_LEVELS.includes(raw.level))
+        return null;
+      const text = sanitizeText(raw.text);
+      return text ? { kind: "message", level: raw.level, text } : null;
+    }
+    case "locate":
+      return { kind: "locate" };
+    default:
+      return null;
+  }
+}
+function parseAgentEvent(params) {
+  const obj = Array.isArray(params) ? params[0] : params;
+  if (!isObj(obj)) return null;
+  if (typeof obj.agent !== "string" || typeof obj.event !== "string") return null;
+  return { agent: obj.agent, event: obj.event, data: obj.data };
+}
+function handleAgentCommand(ev, dispatch, opts) {
+  if (ev.event !== FILAMIND_COMMAND_EVENT) return;
+  const allow = opts?.allowFrom;
+  if (allow) {
+    const ok = typeof allow === "function" ? allow(ev.agent) : allow.includes(ev.agent);
+    if (!ok) return;
+  }
+  const cmd = parseCommand(ev.data);
+  if (cmd) dispatch(cmd);
+}
+
+// src/session/session.ts
+var FilaMindSession = class {
+  constructor(connector, opts = {}) {
+    this.connector = connector;
+    this.opts = opts;
+    this.subs = opts.subscriptions ?? FULL_CONTROL;
+    this.log = opts.logger ?? NULL_LOGGER;
+    connector.setCallbacks({
+      onUpdate: (m, p) => this.onUpdate(m, p),
+      onConnectProgress: (s) => {
+        if (s === "reconnecting" || s === "closed") this.setLive(false);
+      },
+      onReconnected: () => {
+        void this.bootstrap();
+      },
+      onError: (e) => this.log.error("connector error", e.message)
+    });
+  }
+  connector;
+  opts;
+  printer = new PrinterState();
+  klippy = new Observable("disconnected");
+  capabilities = new Observable([]);
+  /** true only when data is trustworthy as live (connected + Klippy ready). The UI dims when false. */
+  live = new Observable(false);
+  prompt = new Observable(null);
+  subs;
+  log;
+  prompts = new PromptParser();
+  bootstrapping = false;
+  /** Set/replace the active subscription set (e.g. when the dashboard's widgets change). */
+  setSubscriptions(subs) {
+    this.subs = subs;
+  }
+  async start() {
+    await this.connector.connect();
+    await this.bootstrap();
+  }
+  stop() {
+    this.connector.close();
+    this.setLive(false);
+  }
+  /** Staged init — runs on first connect AND on reconnect AND on notify_klippy_ready.
+   *  Guarded so overlapping triggers (reconnect + klippy_ready) can't interleave two seeds. */
+  async bootstrap() {
+    if (this.bootstrapping) return;
+    this.bootstrapping = true;
+    try {
+      if (this.opts.identify) {
+        await this.connector.call("server.connection.identify", { ...this.opts.identify }).catch(
+          (e) => this.log.warn("identify failed", String(e))
+        );
+      }
+      const info = await this.connector.call("server.info");
+      this.capabilities.set(info?.components ?? []);
+      const ks = deriveKlippyState(info?.klippy_state);
+      this.klippy.set(ks);
+      if (!isKlippyLive(ks)) {
+        this.setLive(false);
+        return;
+      }
+      const q = await this.connector.call(
+        "printer.objects.query",
+        { objects: this.subs }
+      );
+      this.printer.seed(q?.status ?? {});
+      await this.connector.subscribe(this.subs);
+      this.setLive(true);
+    } catch (e) {
+      this.log.error("bootstrap failed", String(e));
+      this.setLive(false);
+    } finally {
+      this.bootstrapping = false;
+    }
+  }
+  onUpdate(method, params) {
+    switch (method) {
+      case "notify_status_update":
+        this.printer.applyNotify(params);
+        break;
+      case "notify_klippy_ready":
+        this.klippy.set("ready");
+        void this.bootstrap();
+        break;
+      case "notify_klippy_shutdown":
+        this.klippy.set("shutdown");
+        this.setLive(false);
+        break;
+      case "notify_klippy_disconnected":
+        this.klippy.set("disconnected");
+        this.setLive(false);
+        break;
+      case "notify_gcode_response":
+        this.handleGcodeResponse(params);
+        break;
+      case "notify_agent_event": {
+        const ev = parseAgentEvent(params);
+        if (ev && this.opts.onAgentEvent) this.opts.onAgentEvent(ev);
+        break;
+      }
+    }
+  }
+  handleGcodeResponse(params) {
+    const line = Array.isArray(params) ? String(params[0]) : String(params);
+    const ev = this.prompts.feed(line);
+    if (ev) this.prompt.set(ev);
+  }
+  setLive(v) {
+    if (this.live.value !== v) this.live.set(v);
+  }
+};
+
+// src/safety/write-arbiter.ts
+var WriteRefused = class extends Error {
+  constructor(action, reason) {
+    super(`write refused (${action}): ${reason}`);
+    this.action = action;
+    this.name = "WriteRefused";
+  }
+  action;
+};
+var WriteArbiter = class {
+  constructor(guard = () => ({ ok: true }), logger) {
+    this.guard = guard;
+    this.logger = logger;
+  }
+  guard;
+  logger;
+  safeMode = new Observable(false);
+  setSafeMode(on, reason) {
+    this.safeMode.set(on);
+    this.logger?.warn(`safe-mode ${on ? "ON" : "off"}`, reason);
+  }
+  /** Run a mutation through the gate. Throws WriteRefused if blocked. */
+  async run(action, fn) {
+    if (this.safeMode.value) throw new WriteRefused(action, "safe-mode active");
+    const g = this.guard(action);
+    if (!g.ok) throw new WriteRefused(action, g.reason ?? "guard rejected");
+    this.logger?.info(`write: ${action}`);
+    return fn();
+  }
+};
+
+// src/identity/machine.ts
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+async function deriveMachineId(connector) {
+  try {
+    const res = await connector.call("machine.system_info");
+    const si = res?.system_info ?? {};
+    const stable = JSON.stringify({
+      host: si.hostname ?? "",
+      cpu: si.cpu_info?.serial_number ?? si.cpu_info?.cpu_desc ?? si.cpu_info?.processor ?? "",
+      distro: si.distribution?.name ?? ""
+    });
+    if (stable === '{"host":"","cpu":"","distro":""}') return "fm-unknown";
+    return `fm-${fnv1a(stable)}`;
+  } catch {
+    return "fm-unknown";
+  }
+}
+
+// src/backup/restore-points.ts
+function memoryRestoreStore() {
+  const byMachine = /* @__PURE__ */ new Map();
+  return {
+    list: async (m) => [...byMachine.get(m) ?? []],
+    save: async (m, p) => {
+      const arr = byMachine.get(m) ?? [];
+      arr.push(p);
+      byMachine.set(m, arr);
+    },
+    remove: async (m, id) => {
+      byMachine.set(m, (byMachine.get(m) ?? []).filter((p) => p.id !== id));
+    }
+  };
+}
+var RestorePoints = class {
+  constructor(store, machineId, retention = 20) {
+    this.store = store;
+    this.machineId = machineId;
+    this.retention = retention;
+  }
+  store;
+  machineId;
+  retention;
+  seq = 0;
+  async snapshot(scope, trigger, data, reversible = true) {
+    const seq = this.seq++;
+    const ts = Date.now();
+    const point = {
+      id: `rp-${ts}-${seq}`,
+      scope,
+      trigger,
+      ts,
+      seq,
+      reversible,
+      data
+    };
+    await this.store.save(this.machineId, point);
+    await this.prune(scope);
+    return point;
+  }
+  list() {
+    return this.store.list(this.machineId);
+  }
+  async get(id) {
+    return (await this.list()).find((p) => p.id === id);
+  }
+  /** Keep only the newest `retention` points per scope. */
+  async prune(scope) {
+    const all = await this.list();
+    const inScope = all.filter((p) => p.scope === scope).sort((a, b) => b.ts - a.ts || b.seq - a.seq);
+    for (const stale of inScope.slice(this.retention)) {
+      await this.store.remove(this.machineId, stale.id);
+    }
+  }
+};
+
+// src/registry/widget-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerWidget(def) {
+  if (registry.has(def.id)) throw new Error(`duplicate widget id: ${def.id}`);
+  registry.set(def.id, def);
+}
+function getWidget(id) {
+  return registry.get(id);
+}
+function getWidgets(target) {
+  const all = [...registry.values()];
+  if (!target) return all;
+  return all.filter((w) => !w.targets || w.targets.includes(target));
+}
+function aggregateSubscriptions(ids) {
+  const out = {};
+  for (const id of ids) {
+    const subs = registry.get(id)?.subscriptions;
+    if (!subs) continue;
+    for (const obj of Object.keys(subs)) {
+      const fields = subs[obj];
+      if (fields === null || out[obj] === null) {
+        out[obj] = null;
+      } else {
+        out[obj] = Array.from(/* @__PURE__ */ new Set([...out[obj] ?? [], ...fields ?? []]));
+      }
+    }
+  }
+  return out;
+}
+function _resetRegistry() {
+  registry.clear();
+}
+
+// src/theme/tokens.ts
+var themes = {
+  // flagship default — obsidian + gold + lapis + turquoise
+  tutankhamun: {
+    bg: "#0E0F12",
+    surface: "#17171C",
+    surface2: "#20202A",
+    border: "#3A3320",
+    text: "#F3ECD8",
+    textMuted: "#B9AE8E",
+    primary: "#D4AF37",
+    primaryContrast: "#0E0F12",
+    secondary: "#1B3A6B",
+    accent: "#2BA199",
+    success: "#2BA199",
+    warning: "#E0A92E",
+    danger: "#9E2B25"
+  },
+  // night sky + sky-lapis + gold + malachite (Eye of Horus)
+  horus: {
+    bg: "#0B1016",
+    surface: "#122430",
+    surface2: "#173040",
+    border: "#1E4256",
+    text: "#EAF2F5",
+    textMuted: "#9DB6C2",
+    primary: "#1E6FA8",
+    primaryContrast: "#06121C",
+    secondary: "#E0B84C",
+    accent: "#1E6F5C",
+    success: "#1E6F5C",
+    warning: "#E0B84C",
+    danger: "#B3432F"
+  },
+  // granite + ochre + bronze + deep red (guardian of the afterlife)
+  anubis: {
+    bg: "#1A1714",
+    surface: "#221C16",
+    surface2: "#2E251B",
+    border: "#5A3F22",
+    text: "#F4E7CE",
+    textMuted: "#C2A878",
+    primary: "#C2843B",
+    primaryContrast: "#1A1714",
+    secondary: "#7A5C2E",
+    accent: "#8C1F1A",
+    success: "#6E7C3A",
+    warning: "#D98E2B",
+    danger: "#8C1F1A"
+  }
+};
+var DEFAULT_THEME = "tutankhamun";
+function kebab(s) {
+  return s.replace(/[A-Z0-9]/g, (m) => `-${m.toLowerCase()}`);
+}
+function themeToCssVars(t) {
+  const out = {};
+  for (const [k, v] of Object.entries(t)) out[`--fm-${kebab(k)}`] = v;
+  return out;
+}
+function applyTheme(name, el) {
+  const target = el ?? (typeof document !== "undefined" ? document.documentElement : void 0);
+  if (!target) return;
+  for (const [prop, val] of Object.entries(themeToCssVars(themes[name]))) {
+    target.style.setProperty(prop, val);
+  }
+}
+
+// src/i18n/locale-meta.ts
+var LOCALES = [
+  { code: "en", name: "English", rtl: false, dir: "ltr" },
+  { code: "ar", name: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", rtl: true, dir: "rtl" },
+  { code: "de", name: "Deutsch", rtl: false, dir: "ltr" },
+  { code: "es", name: "Espa\xF1ol", rtl: false, dir: "ltr" },
+  { code: "fr", name: "Fran\xE7ais", rtl: false, dir: "ltr" },
+  { code: "ru", name: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439", rtl: false, dir: "ltr" },
+  { code: "zh-Hans", name: "\u7B80\u4F53\u4E2D\u6587", rtl: false, dir: "ltr" },
+  { code: "pt-BR", name: "Portugu\xEAs (Brasil)", rtl: false, dir: "ltr" },
+  { code: "it", name: "Italiano", rtl: false, dir: "ltr" },
+  { code: "ja", name: "\u65E5\u672C\u8A9E", rtl: false, dir: "ltr" },
+  { code: "ko", name: "\uD55C\uAD6D\uC5B4", rtl: false, dir: "ltr" },
+  { code: "pl", name: "Polski", rtl: false, dir: "ltr" },
+  { code: "tr", name: "T\xFCrk\xE7e", rtl: false, dir: "ltr" },
+  { code: "nl", name: "Nederlands", rtl: false, dir: "ltr" },
+  { code: "zh-Hant", name: "\u7E41\u9AD4\u4E2D\u6587", rtl: false, dir: "ltr" },
+  { code: "uk", name: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430", rtl: false, dir: "ltr" },
+  { code: "hi", name: "\u0939\u093F\u0928\u094D\u0926\u0940", rtl: false, dir: "ltr" },
+  { code: "vi", name: "Ti\u1EBFng Vi\u1EC7t", rtl: false, dir: "ltr" },
+  { code: "id", name: "Bahasa Indonesia", rtl: false, dir: "ltr" }
+];
+var DEFAULT_LOCALE = "en";
+var RTL_LOCALES = LOCALES.filter((l) => l.rtl).map((l) => l.code);
+function localeMeta(code) {
+  return LOCALES.find((l) => l.code === code);
+}
+function isRtl(code) {
+  return localeMeta(code)?.rtl ?? false;
+}
+function pluralCategory(locale, n) {
+  try {
+    return new Intl.PluralRules(locale).select(n);
+  } catch {
+    return n === 1 ? "one" : "other";
+  }
+}
+
+// src/i18n/translator.ts
+function lookup(catalog, key) {
+  return key.split(".").reduce(
+    (o, part) => o && typeof o === "object" ? o[part] : void 0,
+    catalog
+  );
+}
+function interpolate(s, params) {
+  if (!params) return s;
+  return s.replace(/\{(\w+)\}/g, (_m, k) => k in params ? String(params[k]) : `{${k}}`);
+}
+function translate(catalog, key, params, locale = "en") {
+  let entry = lookup(catalog, key);
+  if (entry && typeof entry === "object" && params && typeof params.count === "number") {
+    const forms = entry;
+    const cat = pluralCategory(locale, params.count);
+    entry = forms[cat] ?? forms.other ?? forms.one;
+  }
+  if (typeof entry !== "string") return key;
+  return interpolate(entry, params);
+}
+var Translator = class {
+  constructor(catalog, locale = "en") {
+    this.catalog = catalog;
+    this.locale = locale;
+  }
+  catalog;
+  locale;
+  t(key, params) {
+    return translate(this.catalog, key, params, this.locale);
+  }
+};
+function resolveMessage(catalog, m, locale = "en") {
+  const out = translate(catalog, m.code, m.params, locale);
+  return out === m.code ? m.message ?? m.code : out;
+}
+
+// src/remote/command-sender.ts
+var CommandSender = class {
+  constructor(connector, opts) {
+    this.connector = connector;
+    this.opts = opts;
+    this.log = opts.logger ?? NULL_LOGGER;
+    connector.setCallbacks({
+      // Moonraker forgets the agent identity on disconnect → re-identify on every genuine reconnect.
+      onReconnected: () => {
+        this.setIdentified(false);
+        void this.ensureIdentified().catch(() => this.scheduleRetry());
+      },
+      onConnectProgress: (s) => {
+        if (s === "reconnecting" || s === "closed") this.setIdentified(false);
+        else this.refreshReady();
+      },
+      onError: (e) => this.log.warn("command-bus connector error", e.message)
+    });
+  }
+  connector;
+  opts;
+  identified = false;
+  identifying;
+  _ready = false;
+  retryTimer;
+  retryDelayMs = 500;
+  log;
+  /** true only when the bus is connected AND identified — gate remote-control affordances on this. */
+  get ready() {
+    return this._ready;
+  }
+  /** Open the agent connection and identify once. Call alongside the app's main session start. */
+  async start() {
+    await this.connector.connect();
+    await this.ensureIdentified().catch(() => this.scheduleRetry());
+  }
+  /** Close the agent connection (call on app teardown so the socket doesn't linger). */
+  stop() {
+    this.clearRetry();
+    this.connector.close();
+    this.setIdentified(false);
+  }
+  /** Broadcast a UI-only command to the other FilaMind surfaces. Best-effort: a command issued
+   *  while the bus is down is dropped (logged), never queued/replayed — a stale "navigate" fired
+   *  minutes later would yank a screen unexpectedly. */
+  async send(cmd) {
+    if (this.connector.state !== "ready") {
+      this.log.warn("command bus not ready; dropping command", cmd.kind);
+      return;
+    }
+    try {
+      await this.ensureIdentified();
+      await this.connector.call("connection.send_event", { event: FILAMIND_COMMAND_EVENT, data: cmd });
+    } catch (e) {
+      this.log.warn("command send failed", String(e));
+    }
+  }
+  navigate(view) {
+    return this.send({ kind: "navigate", view });
+  }
+  message(level, text) {
+    return this.send({ kind: "message", level, text });
+  }
+  locate() {
+    return this.send({ kind: "locate" });
+  }
+  /** Identify as an agent once per connection; single-flight so concurrent sends don't double-identify. */
+  ensureIdentified() {
+    if (this.identified) return Promise.resolve();
+    if (this.identifying) return this.identifying;
+    this.identifying = this.connector.call("server.connection.identify", {
+      client_name: this.opts.client_name,
+      version: this.opts.version,
+      type: "agent",
+      url: this.opts.url
+    }).then(() => {
+      this.setIdentified(true);
+    }).finally(() => {
+      this.identifying = void 0;
+    });
+    return this.identifying;
+  }
+  setIdentified(v) {
+    this.identified = v;
+    if (v) {
+      this.retryDelayMs = 500;
+      this.clearRetry();
+    }
+    this.refreshReady();
+  }
+  /** Self-heal a transient identify failure while the socket stays up (Moonraker busy during a
+   *  klippy/print transition can time out identify without dropping the connection). Bounded backoff;
+   *  a genuine reconnect re-drives identify on its own, so we only retry while state is 'ready'. */
+  scheduleRetry() {
+    if (this.retryTimer || this.identified) return;
+    if (this.connector.state !== "ready") return;
+    const delay = this.retryDelayMs;
+    this.retryDelayMs = Math.min(this.retryDelayMs * 2, 1e4);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      if (this.connector.state === "ready" && !this.identified) {
+        void this.ensureIdentified().catch(() => this.scheduleRetry());
+      }
+    }, delay);
+  }
+  clearRetry() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+  }
+  /** Recompute readiness (connected + identified) and notify on change. */
+  refreshReady() {
+    const r = this.connector.state === "ready" && this.identified;
+    if (r !== this._ready) {
+      this._ready = r;
+      this.opts.onReadyChange?.(r);
+    }
+  }
+};
+
+// src/settings/settings.ts
+var SETTINGS_VERSION = 1;
+var DEFAULT_SETTINGS = {
+  version: SETTINGS_VERSION,
+  theme: DEFAULT_THEME,
+  locale: DEFAULT_LOCALE,
+  density: "comfortable",
+  motifDensity: "subtle",
+  reducedMotion: false
+};
+var DENSITIES = /* @__PURE__ */ new Set(["comfortable", "compact"]);
+var MOTIFS = /* @__PURE__ */ new Set(["off", "subtle", "full"]);
+function migrate(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return {
+    version: SETTINGS_VERSION,
+    theme: typeof r.theme === "string" && r.theme in themes ? r.theme : DEFAULT_SETTINGS.theme,
+    locale: typeof r.locale === "string" && LOCALES.some((l) => l.code === r.locale) ? r.locale : DEFAULT_SETTINGS.locale,
+    density: typeof r.density === "string" && DENSITIES.has(r.density) ? r.density : DEFAULT_SETTINGS.density,
+    motifDensity: typeof r.motifDensity === "string" && MOTIFS.has(r.motifDensity) ? r.motifDensity : DEFAULT_SETTINGS.motifDensity,
+    reducedMotion: typeof r.reducedMotion === "boolean" ? r.reducedMotion : DEFAULT_SETTINGS.reducedMotion
+  };
+}
+function memoryPersistence() {
+  let store;
+  return {
+    load: async () => store ?? {},
+    save: async (s) => {
+      store = s;
+    }
+  };
+}
+function localStoragePersistence(storageKey = "filamind.settings") {
+  return {
+    load: async () => {
+      try {
+        const raw = localStorage.getItem(storageKey);
+        return raw ? JSON.parse(raw) : {};
+      } catch {
+        return {};
+      }
+    },
+    save: async (s) => {
+      try {
+        localStorage.setItem(storageKey, JSON.stringify(s));
+      } catch {
+      }
+    }
+  };
+}
+var DB_NAMESPACE = "filamind";
+var DB_KEY = "settings";
+function moonrakerDbPersistence(connector) {
+  return {
+    load: async () => {
+      try {
+        const res = await connector.call(
+          "server.database.get_item",
+          { namespace: DB_NAMESPACE, key: DB_KEY }
+        );
+        return res?.value ?? {};
+      } catch {
+        return {};
+      }
+    },
+    save: async (s) => {
+      try {
+        await connector.call("server.database.post_item", {
+          namespace: DB_NAMESPACE,
+          key: DB_KEY,
+          value: s
+        });
+      } catch {
+      }
+    }
+  };
+}
+function roamSettings(store, remote, live) {
+  let applying = false;
+  let primed = false;
+  live.subscribe((isLive) => {
+    if (!isLive) return;
+    void remote.load().then((shared) => {
+      if (Object.keys(shared).length === 0) return;
+      applying = true;
+      store.patch(shared);
+      applying = false;
+    });
+  });
+  store.settings.subscribe((s) => {
+    if (!primed) {
+      primed = true;
+      return;
+    }
+    if (!applying) void remote.save(s);
+  });
+}
+var SettingsStore = class {
+  constructor(persistence = memoryPersistence(), initial = {}) {
+    this.persistence = persistence;
+    this.settings = new Observable(migrate({ ...DEFAULT_SETTINGS, ...initial }));
+  }
+  persistence;
+  settings;
+  get value() {
+    return this.settings.value;
+  }
+  /** Load persisted settings over the defaults (e.g. on app start). */
+  async hydrate() {
+    const loaded = await this.persistence.load();
+    this.settings.set(migrate({ ...DEFAULT_SETTINGS, ...loaded }));
+  }
+  /** Change one or more settings + persist. */
+  patch(p) {
+    this.settings.update((s) => ({ ...s, ...p }));
+    void this.persistence.save(this.settings.value);
+  }
+  reset() {
+    this.patch({ ...DEFAULT_SETTINGS });
+  }
+  export() {
+    return JSON.stringify(this.settings.value, null, 2);
+  }
+  import(json) {
+    try {
+      this.patch(migrate(JSON.parse(json)));
+    } catch {
+    }
+  }
+};
+function applySettings(s, el) {
+  applyTheme(s.theme, el);
+  return { dir: localeMeta(s.locale)?.dir ?? "ltr" };
+}
+export {
+  CommandSender,
+  DEFAULT_LOCALE,
+  DEFAULT_SETTINGS,
+  DEFAULT_THEME,
+  FILAMIND_COMMAND_EVENT,
+  FULL_CONTROL,
+  FilaMindSession,
+  LOCALES,
+  Logger,
+  MoonrakerClient,
+  NARROW_STATUS,
+  NULL_LOGGER,
+  Observable,
+  PrinterState,
+  PromptParser,
+  REMOTE_MESSAGE_LEVELS,
+  REMOTE_VIEWS,
+  RTL_LOCALES,
+  RestorePoints,
+  SETTINGS_VERSION,
+  SUBSCRIPTION_CONTRACT_VERSION,
+  SettingsStore,
+  Translator,
+  UNKNOWN,
+  WriteArbiter,
+  WriteRefused,
+  _resetRegistry,
+  aggregateSubscriptions,
+  applySettings,
+  applyTheme,
+  deepMerge,
+  deriveKlippyState,
+  deriveMachineId,
+  fnv1a,
+  freshness,
+  getWidget,
+  getWidgets,
+  handleAgentCommand,
+  isKlippyLive,
+  isRtl,
+  isStale,
+  localStoragePersistence,
+  localeMeta,
+  memoryPersistence,
+  memoryRestoreStore,
+  mergeSubscriptions,
+  migrate,
+  moonrakerDbPersistence,
+  parseAgentEvent,
+  parseCommand,
+  pluralCategory,
+  registerWidget,
+  resolveMessage,
+  roamSettings,
+  stamp,
+  themeToCssVars,
+  themes,
+  tier,
+  translate
+};