aimeat 1.40.1 → 2.1.0

package/dist/static/sdk-libs/dist/aimeat-work.js

@@ -0,0 +1,213 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/work/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-work.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/config.js
+  function cfg() {
+    return window.__AIMEAT_SDK_CFG__ || { nodeId: "", baseUrl: "" };
+  }
+  function resolveNodeUrl() {
+    const meta = document.querySelector('meta[name="aimeat-node"]');
+    if (meta) return (meta.getAttribute("content") || "").replace(/\/$/, "");
+    if (location.protocol === "http:" || location.protocol === "https:") return location.origin;
+    return cfg().baseUrl;
+  }
+  var NODE_URL = resolveNodeUrl();
+  var APEX_URL = cfg().baseUrl;
+  var NODE_ID = cfg().nodeId;
+  var HEARTBEAT_MS = cfg().heartbeatMs || 3e4;
+
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/work/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-work.js");
+  async function publicFetch(path) {
+    const r = await fetch(NODE_URL + path);
+    return r.json();
+  }
+  var work = {
+    // ── Catalogue (public, no auth) ──
+    // Browse action catalogue
+    async catalogue(opts) {
+      const params = new URLSearchParams();
+      if (opts?.search) params.set("search", opts.search);
+      if (opts?.category) params.set("category", opts.category);
+      if (opts?.page) params.set("page", String(opts.page));
+      if (opts?.per_page) params.set("per_page", String(opts.per_page));
+      const qs = params.toString();
+      const res = await publicFetch("/v1/catalogue" + (qs ? "?" + qs : ""));
+      if (!res.ok) throw new Error(res.error?.message || "Failed to browse catalogue");
+      return res.data;
+    },
+    // Get action details
+    async getAction(actionId) {
+      const res = await publicFetch("/v1/catalogue/" + encodeURIComponent(actionId));
+      if (!res.ok) {
+        if (res.error?.code === "NOT_FOUND") return null;
+        throw new Error(res.error?.message || "Failed to get action");
+      }
+      return res.data;
+    },
+    // Browse agent directory
+    async agents(opts) {
+      const params = new URLSearchParams();
+      if (opts?.page) params.set("page", String(opts.page));
+      if (opts?.per_page) params.set("per_page", String(opts.per_page));
+      const qs = params.toString();
+      const res = await publicFetch("/v1/catalogue/agents" + (qs ? "?" + qs : ""));
+      if (!res.ok) throw new Error(res.error?.message || "Failed to list agents");
+      return res.data;
+    },
+    // Get node stats
+    async stats() {
+      const res = await publicFetch("/v1/stats");
+      if (!res.ok) throw new Error(res.error?.message || "Failed to get stats");
+      return res.data;
+    },
+    // Catalogue change detection hash
+    async hash() {
+      const res = await publicFetch("/v1/catalogue/hash");
+      if (!res.ok) throw new Error(res.error?.message || "Failed to get hash");
+      return res.data;
+    },
+    // ── Work Requests (Tier 1, JWT auth) ──
+    // Submit a work request
+    async request(actionId, providerGaii, input, opts) {
+      const body = {
+        action_id: actionId,
+        provider_gaii: providerGaii,
+        input,
+        ...opts
+      };
+      const res = await authFetch2("/v1/work/request", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to submit work request");
+      return res.data;
+    },
+    // Submit batch work requests
+    async batch(requests) {
+      const res = await authFetch2("/v1/work/batch", {
+        method: "POST",
+        body: JSON.stringify({ requests })
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to submit batch");
+      return res.data;
+    },
+    // ── Provider Inbox ──
+    // Get pending work items (provider perspective)
+    async inbox() {
+      const res = await authFetch2("/v1/work/inbox");
+      if (!res.ok) throw new Error(res.error?.message || "Failed to get inbox");
+      return res.data;
+    },
+    // ── Work Status & Actions ──
+    // Get work status by tracking code
+    async status(trackingCode) {
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode));
+      if (!res.ok) throw new Error(res.error?.message || "Failed to get work status");
+      return res.data;
+    },
+    // Accept work (provider)
+    async accept(trackingCode) {
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode) + "/accept", {
+        method: "POST"
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to accept work");
+      return res.data;
+    },
+    // Mark work as in_progress (provider)
+    async progress(trackingCode) {
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode) + "/progress", {
+        method: "POST"
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to update progress");
+      return res.data;
+    },
+    // Reject work (provider)
+    async reject(trackingCode, reason) {
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode) + "/reject", {
+        method: "POST",
+        body: JSON.stringify({ reason })
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to reject work");
+      return res.data;
+    },
+    // Deliver work output (provider)
+    async deliver(trackingCode, output, metadata) {
+      const body = (
+        /** @type {Record<string, any>} */
+        { output }
+      );
+      if (metadata) body.metadata = metadata;
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode) + "/deliver", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to deliver work");
+      return res.data;
+    },
+    // Rate a delivery (requester)
+    async rate(trackingCode, rating, comment) {
+      const body = (
+        /** @type {Record<string, any>} */
+        { rating }
+      );
+      if (comment) body.comment = comment;
+      const res = await authFetch2("/v1/work/" + encodeURIComponent(trackingCode) + "/rate", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) throw new Error(res.error?.message || "Failed to rate work");
+      return res.data;
+    },
+    // ── Convenience: Poll for completion ──
+    async waitFor(trackingCode, opts) {
+      const interval = opts?.interval || 2e3;
+      const timeout = opts?.timeout || 6e4;
+      const start = Date.now();
+      while (Date.now() - start < timeout) {
+        const data = await work.status(trackingCode);
+        if (data.status === "delivered" || data.status === "rated" || data.status === "completed") {
+          return data;
+        }
+        if (data.status === "rejected" || data.status === "expired" || data.status === "failed") {
+          throw new Error("Work " + data.status + ": " + (data.output || trackingCode));
+        }
+        await new Promise((r) => setTimeout(r, interval));
+      }
+      throw new Error("Work timed out after " + timeout + "ms");
+    }
+  };
+  attach("work", work);
+})();

package/dist/static/sdk-libs/dist/aimeat-workflows.js

@@ -0,0 +1,147 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/workflows/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-workflows.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // src/static/sdk-libs/_core/session.js
+  function getSession(libLabel) {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before " + (libLabel || "this library"));
+    }
+    const s = auth.getSession();
+    if (!s) throw new Error("Not logged in. Call AIMEAT.auth.login() first.");
+    return s;
+  }
+  function authFetch(path, opts, libLabel) {
+    return getSession(libLabel).fetch(path, opts);
+  }
+  function makeSession(libLabel) {
+    return {
+      getSession: () => getSession(libLabel),
+      authFetch: (path, opts) => authFetch(path, opts, libLabel)
+    };
+  }
+
+  // src/static/sdk-libs/_core/namespace.js
+  function namespace() {
+    if (!window.AIMEAT) window.AIMEAT = {};
+    return window.AIMEAT;
+  }
+  function attach(key, value) {
+    const ns = namespace();
+    ns[key] = value;
+    return ns;
+  }
+
+  // src/static/sdk-libs/workflows/index.js
+  var { authFetch: authFetch2 } = makeSession("aimeat-workflows.js");
+  async function call(path, opts) {
+    const res = await authFetch2(path, opts);
+    if (!res.ok) {
+      const err = (
+        /** @type {Error & { code?: string, details?: unknown }} */
+        new Error(res.error && res.error.message || "Workflow request failed")
+      );
+      err.code = res.error && res.error.code;
+      err.details = res.error && res.error.details;
+      throw err;
+    }
+    return res.data;
+  }
+  var workflows = {
+    // ── definitions ──
+    // List the owner's workflow definitions. { includeHealth: true } inlines each workflow's
+    // run-health trend (avoids a per-workflow health() fan-out on list views).
+    async list(opts) {
+      const qs = opts && opts.includeHealth ? "?include=health" : "";
+      return call("/v1/workflows" + qs);
+    },
+    async get(id) {
+      return call("/v1/workflows/" + encodeURIComponent(id));
+    },
+    // Create or update. def = { title, description, trigger, vars, steps, on_step_fail:'inspect', ... }.
+    // Rejected (error.details.errors[]) unless the graph is a DAG and every agent step's offer is
+    // workflow-compatible. Steps may also be actions: export-out / trigger-geai / human-input.
+    async save(id, def) {
+      return call("/v1/workflows/" + encodeURIComponent(id), { method: "PUT", body: JSON.stringify(def) });
+    },
+    async remove(id, opts) {
+      const qs = opts && opts.withRuns ? "?withRuns=true" : "";
+      return call("/v1/workflows/" + encodeURIComponent(id) + qs, { method: "DELETE" });
+    },
+    // The derived structural graph (nodes + edges + memory keys each step reads/writes) — feed a canvas.
+    async blueprint(id) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/blueprint");
+    },
+    async health(id) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/health");
+    },
+    // ── runs ──
+    // mode: 'signals' (evaluate signals only, no dispatch — instant health check) | 'full' (execute).
+    // sandbox: true namespaces every key under wf-test.<runId>. so a test run never clobbers prod.
+    async run(id, opts) {
+      const body = {
+        mode: opts && opts.mode === "full" ? "full" : "signals-only",
+        target: opts && opts.sandbox ? "sandbox" : "live",
+        vars: opts && opts.vars || void 0
+      };
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/run", { method: "POST", body: JSON.stringify(body) });
+    },
+    async runs(id) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/runs");
+    },
+    async getRun(id, runId) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/runs/" + encodeURIComponent(runId));
+    },
+    async cancel(id, runId) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/runs/" + encodeURIComponent(runId) + "/cancel", { method: "POST" });
+    },
+    // ── human-in-the-loop ──
+    // Every step across the owner's active runs currently waiting for a human answer:
+    // [{ workflowId, runId, stepId, workflowTitle, question:{prompt,options,...}, askedAt, deadline }].
+    async pendingInputs() {
+      return call("/v1/workflows/pending-inputs");
+    },
+    // Answer a waiting-human step. answer = { picks: ['option-id'], other?: 'free text' }. 409 when the
+    // step is not parked (already answered / timed out); the run advances on success.
+    async answer(id, runId, stepId, answer) {
+      return call("/v1/workflows/" + encodeURIComponent(id) + "/runs/" + encodeURIComponent(runId) + "/steps/" + encodeURIComponent(stepId) + "/answer", { method: "POST", body: JSON.stringify(answer) });
+    },
+    // ── live watching ──
+    // Re-fetch a run whenever the 'workflows' SSE domain ticks (via aimeat-live when loaded; falls back
+    // to polling every pollMs, default 5000). cb(run) fires on every fetch; returns a stop() function.
+    // Stops itself automatically when the run reaches a terminal state.
+    watchRun(id, runId, cb, opts) {
+      let stopped = false;
+      let unsub = null;
+      let timer = null;
+      const TERMINAL = { done: 1, partial: 1, red: 1, cancelled: 1 };
+      const pull = async () => {
+        if (stopped) return;
+        try {
+          const run = await workflows.getRun(id, runId);
+          cb(run);
+          if (run && TERMINAL[run.status]) stop();
+        } catch {
+        }
+      };
+      const stop = () => {
+        if (stopped) return;
+        stopped = true;
+        if (unsub) try {
+          unsub();
+        } catch {
+        }
+        if (timer) clearInterval(timer);
+      };
+      if (window.AIMEAT.live && typeof window.AIMEAT.live.subscribe === "function") {
+        unsub = window.AIMEAT.live.subscribe(["workflows"], pull);
+      } else {
+        timer = setInterval(pull, opts && opts.pollMs || 5e3);
+      }
+      pull();
+      return stop;
+    }
+  };
+  attach("workflows", workflows);
+})();

package/dist/static/sdk-libs/editor/index.js

@@ -0,0 +1,229 @@
+/**
+ * @file editor/index.js
+ * @description The aimeat-editor library (SDK-libs migration Phase 1). Mounts a CodeMirror 6 markdown
+ *   editor (dynamic esm.sh import, pinned codemirror@6.0.2) with markdown highlighting + a one-dark
+ *   theme in dark mode, falling back to a plain auto-growing <textarea> when the CDN import fails or
+ *   times out — so the editor always works. Exposes a uniform adapter (getValue/setValue/wrap/
+ *   prefixLine/focus) a toolbar + save flows target regardless of engine; split() adds a live preview
+ *   pane through AIMEAT.md.renderRich. Componentized ESM source esbuild bundles to the IIFE served,
+ *   unchanged, at /v1/libs/aimeat-editor.js. Ported verbatim from lib-editor.ts; the CDN import
+ *   specifiers are held in variables so tsc/esbuild leave them as runtime dynamic imports.
+ * @structure imports attach (namespace); injectCss/loadCM; mount()/toolbar()/split(); attach('editor', …).
+ * @usage <script src="/v1/libs/aimeat-markdown.js"></script><script src="/v1/libs/aimeat-editor.js"></script>
+ *   const { adapter } = AIMEAT.editor.split(host, { value: md, onChange: t => dirty = true });
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-editor.ts (SDK-libs migration Phase 1).
+ */
+import { attach } from '../_core/namespace.js';
+
+var BT = String.fromCharCode(96); // backtick
+var FENCE = BT + BT + BT;
+
+// CDN import specifiers held in variables so tsc can't resolve them (Promise<any>) and esbuild
+// leaves them as runtime dynamic imports (not bundled) — the browser imports them at mount time.
+var CM_URL = 'https://esm.sh/codemirror@6.0.2'; // exact pin — the "@6" range resolves to a CM5 build on esm.sh
+var CM_MD_URL = 'https://esm.sh/@codemirror/lang-markdown@6';
+var CM_DARK_URL = 'https://esm.sh/@codemirror/theme-one-dark@6';
+
+var CSS = '.aimeat-ed-host .cm-editor{border:1px solid var(--color-base-300,#3a3a3a);border-radius:8px;font-size:.95rem;background:transparent;}' +
+  '.aimeat-ed-host .cm-editor.cm-focused{outline:none;border-color:var(--color-primary,#4f9eff);}' +
+  '.aimeat-ed-host .cm-scroller{min-height:280px;max-height:70vh;overflow:auto;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;line-height:1.6;}' +
+  '.aimeat-ed-host textarea.aimeat-ed-ta{width:100%;border:1px solid var(--color-base-300,#3a3a3a);border-radius:8px;background:transparent;' +
+  'font-family:ui-monospace,Menlo,Consolas,monospace;font-size:.92rem;line-height:1.6;color:inherit;min-height:280px;padding:.7rem;outline:none;resize:vertical;}' +
+  '.aimeat-ed-loading{color:var(--color-base-content,#888);opacity:.7;font-size:.85rem;padding:.8rem;border:1px dashed var(--color-base-300,#3a3a3a);border-radius:8px;}' +
+  '.aimeat-ed-toolbar{display:flex;gap:.15rem;flex-wrap:wrap;align-items:center;padding:.35rem .4rem;margin:0 0 .8rem;' +
+  'border:1px solid var(--color-base-300,#3a3a3a);border-radius:8px;}' +
+  '.aimeat-ed-tb{border:none;background:transparent;border-radius:5px;cursor:pointer;padding:.25rem .5rem;font-size:.82rem;color:inherit;min-height:28px;}' +
+  '.aimeat-ed-tb:hover{background:var(--color-base-200,rgba(128,128,128,.15));}' +
+  '.aimeat-ed-sep{width:1px;align-self:stretch;background:var(--color-base-300,#3a3a3a);margin:.15rem .25rem;}' +
+  '.aimeat-ed-split{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:1.2rem;align-items:start;}' +
+  '.aimeat-ed-preview{border-left:1px solid var(--color-base-300,#3a3a3a);padding-left:1.2rem;min-height:280px;max-height:70vh;overflow-y:auto;}' +
+  '@media (max-width:1099px){.aimeat-ed-split{grid-template-columns:1fr;}' +
+  '.aimeat-ed-preview{border-left:none;border-top:1px solid var(--color-base-300,#3a3a3a);padding:1rem 0 0;max-height:none;}}';
+function injectCss() {
+  if (document.getElementById('aimeat-editor-styles')) return;
+  var s = document.createElement('style');
+  s.id = 'aimeat-editor-styles';
+  s.textContent = CSS;
+  (document.head || document.documentElement).appendChild(s);
+}
+
+var _cmModsP = null;
+function loadCM() {
+  if (_cmModsP) return _cmModsP;
+  _cmModsP = Promise.race([
+    Promise.all([
+      import(CM_URL),
+      import(CM_MD_URL).catch(function () { return null; }),
+      import(CM_DARK_URL).catch(function () { return null; }),
+    ]),
+    new Promise(function (_, rej) { setTimeout(function () { rej(new Error('editor cdn timeout')); }, 10000); }),
+  ]).catch(function (e) { _cmModsP = null; throw e; });
+  return _cmModsP;
+}
+
+function wrapSelTa(ta, before, after, placeholder) {
+  var s = ta.selectionStart, e = ta.selectionEnd, val = ta.value;
+  var sel = val.slice(s, e) || placeholder || '';
+  ta.value = val.slice(0, s) + before + sel + (after || '') + val.slice(e);
+  ta.focus(); ta.selectionStart = s + before.length; ta.selectionEnd = s + before.length + sel.length;
+  ta.dispatchEvent(new Event('input'));
+}
+function linePrefixTa(ta, prefix) {
+  var s = ta.selectionStart, val = ta.value;
+  var ls = val.lastIndexOf('\n', s - 1) + 1;
+  ta.value = val.slice(0, ls) + prefix + val.slice(ls);
+  ta.focus(); ta.selectionStart = ta.selectionEnd = s + prefix.length;
+  ta.dispatchEvent(new Event('input'));
+}
+
+// Mount an editor into host. Returns an adapter usable before the async CM mount resolves
+// (getValue falls back to the initial text until an engine is live).
+function mount(host, opts) {
+  opts = opts || {};
+  injectCss();
+  host.classList.add('aimeat-ed-host');
+  var A = {
+    host: host,
+    cm: /** @type {any} */ (null),
+    ta: /** @type {any} */ (null),
+    _initial: opts.value || '',
+    getValue: function () {
+      if (this.cm) return this.cm.state.doc.toString();
+      if (this.ta) return this.ta.value;
+      return this._initial;
+    },
+    setValue: function (text) {
+      text = text == null ? '' : String(text);
+      if (this.cm) this.cm.dispatch({ changes: { from: 0, to: this.cm.state.doc.length, insert: text } });
+      else if (this.ta) { this.ta.value = text; this.ta.dispatchEvent(new Event('input')); }
+      else this._initial = text;
+    },
+    focus: function () { if (this.cm) this.cm.focus(); else if (this.ta) this.ta.focus(); },
+    wrap: function (before, after, ph) {
+      if (this.cm) {
+        var st = this.cm.state, sel = st.selection.main;
+        var chosen = st.sliceDoc(sel.from, sel.to) || ph || '';
+        this.cm.dispatch({
+          changes: { from: sel.from, to: sel.to, insert: before + chosen + (after || '') },
+          selection: { anchor: sel.from + before.length, head: sel.from + before.length + chosen.length },
+        });
+        this.cm.focus();
+      } else if (this.ta) wrapSelTa(this.ta, before, after, ph);
+    },
+    prefixLine: function (prefix) {
+      if (this.cm) {
+        var st = this.cm.state, line = st.doc.lineAt(st.selection.main.head);
+        this.cm.dispatch({ changes: { from: line.from, insert: prefix } });
+        this.cm.focus();
+      } else if (this.ta) linePrefixTa(this.ta, prefix);
+    },
+    destroy: function () {
+      if (this.cm) { this.cm.destroy(); this.cm = null; }
+      this.ta = null;
+      host.innerHTML = '';
+    },
+  };
+  host.innerHTML = '';
+  var loading = document.createElement('div');
+  loading.className = 'aimeat-ed-loading';
+  loading.textContent = 'Loading editor…';
+  host.appendChild(loading);
+  function emit() { if (opts.onChange) opts.onChange(A.getValue()); }
+  function mountTa() {
+    if (A.cm || A.ta || !host.isConnected) return;
+    var ta = document.createElement('textarea');
+    ta.className = 'aimeat-ed-ta';
+    ta.placeholder = opts.placeholder || 'Write in markdown…';
+    ta.value = A._initial;
+    ta.addEventListener('input', emit);
+    host.innerHTML = ''; host.appendChild(ta); A.ta = ta;
+  }
+  loadCM().then(function (mods) {
+    if (A.ta || A.cm || !host.isConnected) return;
+    var cmr = mods[0], mdm = mods[1], darkm = mods[2];
+    var base = [cmr.basicSetup, cmr.EditorView.lineWrapping,
+      cmr.EditorView.updateListener.of(function (u) { if (u.docChanged) emit(); })];
+    var exts = base.slice();
+    try { if (mdm && mdm.markdown) exts.push(mdm.markdown()); } catch { /* markdown ext optional */ }
+    if (darkm && darkm.oneDark && document.documentElement.getAttribute('data-theme') === 'dark') exts.push(darkm.oneDark);
+    var view;
+    try { view = new cmr.EditorView({ doc: A._initial, extensions: exts }); }
+    catch { view = new cmr.EditorView({ doc: A._initial, extensions: base }); } // dual-instance ext mismatch → plain setup
+    host.innerHTML = ''; host.appendChild(view.dom); A.cm = view;
+  }).catch(function () { mountTa(); });
+  return A;
+}
+
+function toolbar(A) {
+  injectCss();
+  function b(label, title, fn) {
+    var btn = document.createElement('button');
+    btn.type = 'button'; btn.className = 'aimeat-ed-tb'; btn.textContent = label; btn.title = title;
+    btn.addEventListener('click', function (ev) { ev.preventDefault(); fn(); });
+    return btn;
+  }
+  function sep() { var s = document.createElement('span'); s.className = 'aimeat-ed-sep'; return s; }
+  var bar = document.createElement('div');
+  bar.className = 'aimeat-ed-toolbar';
+  [
+    b('B', 'Bold', function () { A.wrap('**', '**', 'bold'); }),
+    b('I', 'Italic', function () { A.wrap('*', '*', 'italic'); }),
+    b('S̶', 'Strikethrough', function () { A.wrap('~~', '~~', 'text'); }),
+    sep(),
+    b('H1', 'Heading 1', function () { A.prefixLine('# '); }),
+    b('H2', 'Heading 2', function () { A.prefixLine('## '); }),
+    b('H3', 'Heading 3', function () { A.prefixLine('### '); }),
+    sep(),
+    b('•', 'Bullet list', function () { A.prefixLine('- '); }),
+    b('1.', 'Numbered list', function () { A.prefixLine('1. '); }),
+    b('☐', 'Todo', function () { A.prefixLine('- [ ] '); }),
+    b('❝', 'Quote', function () { A.prefixLine('> '); }),
+    sep(),
+    b('</>', 'Code block', function () { A.wrap('\n' + FENCE + '\n', '\n' + FENCE + '\n', 'code'); }),
+    b('🧜', 'Mermaid diagram', function () { A.wrap('\n' + FENCE + 'mermaid\n', '\n' + FENCE + '\n', 'graph TD\n  A[Start] --> B[End]'); }),
+    b('🧩', 'Live data (aimeat-memory block)', function () { A.wrap('\n' + FENCE + 'aimeat-memory\nkey: ', '\n' + FENCE + '\n', 'livedata.my-table'); }),
+    b('🔗', 'Link', function () { A.wrap('[', '](https://)', 'link text'); }),
+    b('―', 'Divider', function () { A.prefixLine('\n---\n'); }),
+  ].forEach(function (n) { bar.appendChild(n); });
+  return bar;
+}
+
+// Editor + live preview side by side (stacked below 1100px). The preview renders through
+// AIMEAT.md.renderRich when aimeat-markdown.js is loaded, else AIMEAT.md.render, else plain text.
+function renderPreview(target, text) {
+  var md = window.AIMEAT && window.AIMEAT.md;
+  if (md && typeof md.renderRich === 'function') { md.renderRich(text, target); return; }
+  if (md && typeof md.render === 'function') { md.render(text, target); return; }
+  target.innerHTML = '';
+  var pre = document.createElement('pre');
+  pre.style.whiteSpace = 'pre-wrap';
+  pre.textContent = text;
+  target.appendChild(pre);
+}
+function split(host, opts) {
+  opts = opts || {};
+  injectCss();
+  host.innerHTML = '';
+  var wrap = document.createElement('div');
+  wrap.className = 'aimeat-ed-split';
+  var edPane = document.createElement('div');
+  var pvPane = document.createElement('div');
+  pvPane.className = 'aimeat-ed-preview';
+  wrap.appendChild(edPane); wrap.appendChild(pvPane);
+  host.appendChild(wrap);
+  var timer = null;
+  var debounce = opts.previewDebounceMs || 350;
+  var A = mount(edPane, {
+    value: opts.value, placeholder: opts.placeholder,
+    onChange: function (t) {
+      if (opts.onChange) opts.onChange(t);
+      clearTimeout(timer);
+      timer = setTimeout(function () { if (pvPane.isConnected) renderPreview(pvPane, t); }, debounce);
+    },
+  });
+  renderPreview(pvPane, opts.value || '');
+  return { adapter: A, editorEl: edPane, previewEl: pvPane };
+}
+
+attach('editor', { mount: mount, toolbar: toolbar, split: split });