aimeat 2.0.0 → 2.2.0

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

@@ -0,0 +1,243 @@
+/**
+ * @file commerce/index.js
+ * @description The aimeat-commerce library (SDK-libs migration Phase 2, TARGET-033/034). Exposes
+ *   AIMEAT.commerce — checkout sessions over /v1/commerce/*, offer price reading, money formatting in
+ *   6-decimal micro-units, the x402-style 402 `accepts` surface, and the app-tool convention (manifest
+ *   read + one-call buy). Authenticated calls go through the AIMEAT.auth session; feed/getAppTools are
+ *   public. Componentized ESM source esbuild bundles to the IIFE served, unchanged, at
+ *   /v1/libs/aimeat-commerce.js. Ported verbatim from lib-commerce.ts. SECURITY: carries NO secrets —
+ *   seller PSP credentials are server-side only; NODE_URL is the apex base (APEX_URL from _core/config).
+ * @structure imports APEX_URL (config) + authFetch (session) + attach (namespace); commerceError/
+ *   normalizeItems; money helpers; checkout lifecycle; offer discovery; app-tools; attach('commerce', …).
+ * @usage <script src="/v1/libs/aimeat-auth.js"></script><script src="/v1/libs/aimeat-commerce.js"></script>
+ *   const s = await AIMEAT.commerce.buyOffer('vendor#alice@node', 'translate-doc');
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-commerce.ts (SDK-libs migration Phase 2).
+ */
+import { APEX_URL } from '../_core/config.js';
+import { makeSession } from '../_core/session.js';
+const { authFetch } = makeSession('aimeat-commerce.js');
+import { attach } from '../_core/namespace.js';
+
+const NODE_URL = APEX_URL;
+
+/** Micros per whole currency unit — money amounts are 6-decimal micro-units (matches USDC/x402). */
+const MONEY_UNIT = 1000000;
+
+/** Build an Error from a failed envelope; 402 responses carry the x402-style accepts block. */
+function commerceError(res, fallback) {
+  const e = /** @type {Error & { code?: string, paymentRequired?: boolean, accepts?: unknown, x402Version?: unknown }} */ (new Error((res.error && res.error.message) || fallback));
+  e.code = res.error && res.error.code;
+  if (res.accepts) {
+    e.paymentRequired = true;
+    e.accepts = res.accepts;         // [{ scheme, handler, currencies, description, resource }]
+    e.x402Version = res.x402Version;
+  }
+  return e;
+}
+
+/** Normalize line items: accept offerId or offer_id, default kind 'offer', quantity 1. */
+function normalizeItems(items) {
+  const arr = Array.isArray(items) ? items : [items];
+  return arr.map(function (i) {
+    const out = /** @type {Record<string, any>} */ ({ offer_id: i.offer_id || i.offerId });
+    if (i.kind) out.kind = i.kind;
+    if (i.agent) out.agent = i.agent;
+    if (i.org) out.org = i.org;
+    if (i.app) out.app = i.app;      // app-tool items (TARGET-034)
+    if (i.tool) out.tool = i.tool;
+    if (i.input) out.input = i.input; // app-tool: buyer input for the capability invoke
+    if (i.quantity) out.quantity = i.quantity;
+    return out;
+  });
+}
+
+const commerce = {
+  MONEY_UNIT: MONEY_UNIT,
+
+  // ── Money formatting (same convention as the portal's utils.js fmtMoney) ──
+
+  /** Format money micro-units as "1.50 EUR" / "0.002 USD" (≥2 decimals, up to 6 when sub-cent). */
+  fmtMoney(micros, currency) {
+    const s = ((Number(micros) || 0) / MONEY_UNIT).toFixed(6).replace(/(\.\d{2}\d*?)0+$/, '$1');
+    return currency ? s + ' ' + currency : s;
+  },
+
+  /** Format any session/offer amount currency-aware: morsels are integers, money is micro-units. */
+  fmtAmount(amount, currency) {
+    if (!currency || currency === 'morsel' || currency === 'MORSEL') {
+      return (Number(amount) || 0) + ' morsels';
+    }
+    return commerce.fmtMoney(amount, currency);
+  },
+
+  /** Parse a major-unit input ("1.50", "0,002") into integer money micro-units; null if not positive. */
+  microsFromInput(str) {
+    const n = parseFloat(String(str).replace(',', '.'));
+    if (!Number.isFinite(n) || n <= 0) return null;
+    return Math.round(n * MONEY_UNIT);
+  },
+
+  // ── Offer discovery + price reading ──
+
+  /** Public product feed: every PUBLIC, priced agent offer on the node (no login needed). */
+  async feed() {
+    const r = await fetch(NODE_URL + '/v1/commerce/feed');
+    const res = await r.json();
+    if (res.error) throw commerceError(res, 'Failed to read the commerce feed');
+    return res; // { products: [{ id: "offer:<agentGaii>:<offerId>", title, price, seller }], total }
+  },
+
+  /** Read one offer (with price/priceMoney) from an agent's published offers. */
+  async getOffer(agent, offerId) {
+    const res = await authFetch('/v1/agents/' + encodeURIComponent(agent) + '/offers');
+    if (!res.ok) throw commerceError(res, 'Failed to read offers');
+    const offers = (res.data && res.data.offers) || [];
+    return offers.find(function (o) { return o.id === offerId; }) || null;
+  },
+
+  /**
+   * The price of an offer or app-tool entry in one currency.
+   * → { amount, currency, formatted } or null when it has no price in that currency.
+   * currency omitted/'morsel' → price.morsels; 'EUR'/'USD' → priceMoney micro-units.
+   */
+  priceOf(offer, currency) {
+    if (!offer) return null;
+    if (!currency || currency === 'morsel') {
+      const m = offer.price && Number(offer.price.morsels);
+      if (!m || m <= 0) return null;
+      return { amount: m, currency: 'morsel', formatted: commerce.fmtAmount(m, 'morsel') };
+    }
+    const pm = offer.priceMoney;
+    if (!pm || pm.currency !== currency) return null;
+    return { amount: pm.amount, currency: currency, formatted: commerce.fmtMoney(pm.amount, currency) };
+  },
+
+  // ── Checkout sessions (/v1/commerce/checkout-sessions) ──
+
+  /**
+   * Open a checkout session. items: [{ agent, offer_id, quantity? }] (kind defaults to 'offer').
+   * opts: { note?, currency? } — currency 'EUR'/'USD' needs a money price + a settling handler.
+   */
+  async openCheckout(items, opts) {
+    const body = /** @type {Record<string, any>} */ ({ items: normalizeItems(items) });
+    if (opts && opts.note) body.note = opts.note;
+    if (opts && opts.currency) body.currency = opts.currency;
+    const res = await authFetch('/v1/commerce/checkout-sessions', {
+      method: 'POST', body: JSON.stringify(body),
+    });
+    if (!res.ok) throw commerceError(res, 'Failed to open checkout');
+    return res.data.session;
+  },
+
+  /** Read one of the buyer's checkout sessions. */
+  async getCheckout(id) {
+    const res = await authFetch('/v1/commerce/checkout-sessions/' + encodeURIComponent(id));
+    if (!res.ok) throw commerceError(res, 'Failed to read checkout');
+    return res.data.session;
+  },
+
+  /** The buyer's checkout sessions (purchases), newest first. */
+  async listCheckouts(opts) {
+    const qs = opts && opts.limit ? '?limit=' + opts.limit : '';
+    const res = await authFetch('/v1/commerce/checkout-sessions' + qs);
+    if (!res.ok) throw commerceError(res, 'Failed to list checkouts');
+    return res.data.sessions;
+  },
+
+  /** Replace the cart of an open session. */
+  async updateCheckout(id, items) {
+    const res = await authFetch('/v1/commerce/checkout-sessions/' + encodeURIComponent(id), {
+      method: 'PATCH', body: JSON.stringify({ items: normalizeItems(items) }),
+    });
+    if (!res.ok) throw commerceError(res, 'Failed to update checkout');
+    return res.data.session;
+  },
+
+  /** Cancel an open session. */
+  async cancelCheckout(id) {
+    const res = await authFetch('/v1/commerce/checkout-sessions/' + encodeURIComponent(id), {
+      method: 'PATCH', body: JSON.stringify({ cancel: true }),
+    });
+    if (!res.ok) throw commerceError(res, 'Failed to cancel checkout');
+    return res.data.session;
+  },
+
+  /**
+   * Complete (pay + fulfill) a session. payment: { handler?, instrument? } — omit for the
+   * node default (morsels). On 402 the thrown error has err.paymentRequired + err.accepts.
+   * Returns the completed session: session.receipt { handler, charged, fee }, session.fulfillment.
+   */
+  async completeCheckout(id, payment) {
+    const res = await authFetch('/v1/commerce/checkout-sessions/' + encodeURIComponent(id) + '/complete', {
+      method: 'POST', body: JSON.stringify(payment ? { payment: payment } : {}),
+    });
+    if (!res.ok) throw commerceError(res, 'Failed to complete checkout');
+    return res.data.session;
+  },
+
+  /** One-call purchase: open a session for one offer and complete it immediately. */
+  async buyOffer(agent, offerId, opts) {
+    const session = await commerce.openCheckout(
+      [{ agent: agent, offer_id: offerId, quantity: (opts && opts.quantity) || 1 }], opts);
+    return commerce.completeCheckout(session.id, opts && opts.payment);
+  },
+
+  /** The seller's received orders (completed sessions where you are the seller). */
+  async listOrders(opts) {
+    const qs = opts && opts.limit ? '?limit=' + opts.limit : '';
+    const res = await authFetch('/v1/commerce/orders' + qs);
+    if (!res.ok) throw commerceError(res, 'Failed to list orders');
+    return res.data.orders;
+  },
+
+  // ── App tools (TARGET-034 — priced tool calls on agent-faced apps) ──
+
+  /**
+   * Read an app's declared tool manifest: the public memory record apps.{appId}.tools under the
+   * app owner's GHII — { tools: [{ name, description, inputSchema, action_id?, agent?, price?, priceMoney? }] }.
+   * Returns null when the app declares no tools. Works logged out (public read).
+   */
+  async getAppTools(ownerGhii, appId) {
+    const url = NODE_URL + '/v1/memory/' + encodeURIComponent(ownerGhii) + '/'
+      + encodeURIComponent('apps.' + appId + '.tools');
+    const r = await fetch(url);
+    const res = await r.json();
+    if (!res.ok) {
+      if (res.error && res.error.code === 'NOT_FOUND') return null;
+      throw commerceError(res, 'Failed to read app tools');
+    }
+    return res.data.value;
+  },
+
+  /**
+   * Buy + invoke a priced app-tool through the checkout core (TARGET-034):
+   * one { kind:'app-tool', app:'ownerName/appId', tool, input } line item, opened and
+   * completed in one call. A tool bound to a capability (action_id) runs with your input and
+   * the result comes back on session.fulfillment.results[0].result; an unbound tool queues an
+   * agent TASK for the app owner instead — session.fulfillment.taskIds[0] (the deliverable
+   * arrives via the seller's task flow). The receipt shows the charge either way.
+   * One call per invocation. On a node without the resolver this throws
+   * with code 'APP_TOOL_NOT_AVAILABLE'.
+   */
+  async invokeAppTool(ref, opts) {
+    try {
+      const session = await commerce.openCheckout(
+        [{ kind: 'app-tool', app: ref.app, tool: ref.tool, input: ref.input }], opts);
+      return commerce.completeCheckout(session.id, opts && opts.payment);
+    } catch (e) {
+      // Older nodes reject the kind at validation (zod enum error naming "kind"); a node with the
+      // widened schema but no resolver answers UNKNOWN_ITEM_KIND. Both mean: not sellable here.
+      if (e.code === 'UNKNOWN_ITEM_KIND' || (e.code === 'INVALID_CHECKOUT' && /invalid enum|"kind"/i.test(String(e.message)))) {
+        const err = /** @type {Error & { code?: string, cause?: unknown }} */ (new Error('This node does not sell app-tools (app-tool resolver not enabled)'));
+        err.code = 'APP_TOOL_NOT_AVAILABLE';
+        err.cause = e;
+        throw err;
+      }
+      throw e;
+    }
+  },
+};
+
+// ── Expose globally ──
+attach('commerce', commerce);

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

@@ -0,0 +1,250 @@
+/**
+ * @file data/index.js
+ * @description The aimeat-data library (SDK-libs migration — config-path proof lib). Exposes
+ *   AIMEAT.data: the Memory API (Tier 1, JWT auth via AIMEAT.auth) with an app-creator public-read
+ *   fallback, and Micro-Memory (Tier 0.5, GET-based). This is the componentized ESM source esbuild
+ *   bundles to the IIFE served, unchanged, at /v1/libs/aimeat-data.js. It is the first migrated lib
+ *   that actually CONSUMES the shared config: `NODE_URL` (direct public/micro fetches) and `NODE_ID`
+ *   (the `creator@node` construction in get()'s fallback) come from _core/config — the exact values
+ *   the legacy string form baked in via `${config.baseUrl}` / `${config.nodeId}`.
+ * @structure imports NODE_URL/NODE_ID (config), authFetch (session), attach (namespace); data.set/
+ *   get/getEntry/update/delete/list/search/getPublic; data.micro()/microSets(); attach('data', …).
+ * @usage <script src="/v1/libs/aimeat-auth.js"></script><script src="/v1/libs/aimeat-data.js"></script>
+ *   await AIMEAT.data.set('key', { value }); await AIMEAT.data.get('key');
+ * @version-history
+ *   v1.0.0 — 2026-07-19 — Migrated from src/routes/lib-data.ts; NODE_URL/NODE_ID now from _core/config.
+ *   v1.1.0 — 2026-07-25 — Cross-namespace reads: get/getEntry/list/search take { agent, ownerScope };
+ *     list takes { meta, count } (+ data.count()). Agent-published keys live under the agent's GAII,
+ *     and an app-grant token gets no automatic owner-scope broadening, so apps had to bypass this
+ *     library entirely to read their own owner's fleet output. All options are additive.
+ */
+import { NODE_URL, NODE_ID } from '../_core/config.js';
+import { makeSession } from '../_core/session.js';
+const { authFetch } = makeSession('aimeat-data.js');
+import { attach } from '../_core/namespace.js';
+
+/**
+ * Cross-namespace read scoping, shared by get/getEntry/list/search.
+ *
+ * Agents publish under their OWN namespace (`name#owner@node`), not the owner's GHII.
+ * An owner SESSION gets owner-scope broadening automatically server-side, but an
+ * app-grant token (roles:['app']) does not — so an app reading its owner's fleet
+ * output must say so explicitly. Before these options the only way to do that was
+ * to bypass this library and hand-roll session.fetch calls.
+ *
+ * @param {{agent?: string, ownerScope?: boolean}} [opts]
+ * @returns {URLSearchParams}
+ */
+function scopeParams(opts) {
+  const p = new URLSearchParams();
+  if (opts?.agent) p.set('agent', opts.agent);
+  // `agent` already targets one namespace; sending both is contradictory (the server
+  // ignores owner_scope when agent is present), so only one goes on the wire.
+  else if (opts?.ownerScope) p.set('owner_scope', 'true');
+  return p;
+}
+
+/** Append params to a path, preserving any query string already on it. */
+function withParams(path, params) {
+  const qs = params.toString();
+  if (!qs) return path;
+  return path + (path.indexOf('?') >= 0 ? '&' : '?') + qs;
+}
+
+// ── Memory API (Tier 1, JWT auth) ──
+
+const data = {
+  // Write or upsert a memory entry
+  async set(key, value, opts) {
+    const body = { key, value, visibility: 'private', ...opts };
+    const res = await authFetch('/v1/memory', { method: 'POST', body: JSON.stringify(body) });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to set memory');
+    return res.data;
+  },
+
+  // Read a single entry (falls back to public read from app creator if not found or empty).
+  // Uses ?soft=1 so a missing key is a clean 200 (value null) — no browser-console 404 noise;
+  // the contract is unchanged: resolves null when the key does not exist.
+  // opts: { agent, ownerScope } — read from one of the owner's agents' namespaces, or
+  // across the owner's whole set (GHII + agents). Omitted → unchanged behaviour.
+  async get(key, opts) {
+    const res = await authFetch(withParams(
+      '/v1/memory/' + encodeURIComponent(key) + '?soft=1', scopeParams(opts)));
+    var val = res.ok ? res.data.value : null;
+    var isEmpty = val == null || (typeof val === 'object' && Object.keys(val).length === 0);
+    if (!isEmpty) return val;
+    // A scoped read is explicit about where to look; do not silently widen it to the
+    // app-creator's public namespace.
+    if (opts?.agent || opts?.ownerScope) return val;
+    // Fallback: try public read from app creator's namespace
+    var creator = document.querySelector('meta[name="aimeat-creator"]')?.getAttribute('content');
+    if (!creator) {
+      var m = location.pathname.match(/\/v1\/apps\/([^/]+)\//);
+      if (m) {
+        creator = decodeURIComponent(m[1]);
+        if (creator && !creator.includes('@')) creator = creator + '@' + NODE_ID;
+      }
+    }
+    if (creator) {
+      try {
+        var pub = await data.getPublic(creator, key);
+        if (pub != null) return pub;
+      } catch { /* public-read fallback is best-effort */ }
+    }
+    return val;
+  },
+
+  // Read full entry metadata. opts: { agent, ownerScope } as in get().
+  async getEntry(key, opts) {
+    const res = await authFetch(withParams(
+      '/v1/memory/' + encodeURIComponent(key), scopeParams(opts)));
+    if (!res.ok) {
+      if (res.error?.code === 'NOT_FOUND') return null;
+      throw new Error(res.error?.message || 'Failed to get memory');
+    }
+    return res.data;
+  },
+
+  // Update with optimistic locking
+  async update(key, value, version, opts) {
+    const body = { value, version, ...opts };
+    const res = await authFetch('/v1/memory/' + encodeURIComponent(key), {
+      method: 'PUT', body: JSON.stringify(body),
+    });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to update memory');
+    return res.data;
+  },
+
+  // Delete an entry
+  async delete(key) {
+    const res = await authFetch('/v1/memory/' + encodeURIComponent(key), { method: 'DELETE' });
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to delete memory');
+    return res.data;
+  },
+
+  /**
+   * List memory keys.
+   *
+   * opts:
+   *   prefix, visibility, tags   — as before
+   *   agent      — list ONE of the owner's agents' namespaces (full GAII `name#owner@node`)
+   *   ownerScope — list across the owner's GHII + every same-owner agent. An owner session
+   *                already gets this server-side; an app-grant token needs it stated.
+   *   meta       — omit every `value` and report each entry's `bytes` instead. Use this for
+   *                any listing you render as a table/board: the default response inlines
+   *                every value, so a fleet-wide prefix can be megabytes per call.
+   *   count      — return only `{ count }` (server-side COUNT, no values). A cheap
+   *                "did anything change?" probe; its cache is dropped by any memory write.
+   */
+  async list(opts) {
+    const params = scopeParams(opts);
+    if (opts?.prefix) params.set('prefix', opts.prefix);
+    if (opts?.visibility) params.set('visibility', opts.visibility);
+    if (opts?.tags) params.set('tags', opts.tags.join(','));
+    if (opts?.meta) params.set('include', 'meta');
+    if (opts?.count) params.set('count', 'true');
+    const qs = params.toString();
+    const res = await authFetch('/v1/memory' + (qs ? '?' + qs : ''));
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to list memory');
+    return res.data;
+  },
+
+  /** Cheap change probe: the number of keys under a prefix, no values transferred. */
+  async count(opts) {
+    const d = await data.list({ ...(opts || {}), count: true });
+    return (d && typeof d.count === 'number') ? d.count : null;
+  },
+
+  // Search memory entries
+  // opts: { visibility, agent, ownerScope } — scoping as in list().
+  async search(query, opts) {
+    const params = scopeParams(opts);
+    params.set('q', query);
+    if (opts?.visibility) params.set('visibility', opts.visibility);
+    const res = await authFetch('/v1/memory/search?' + params.toString());
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to search memory');
+    return res.data;
+  },
+
+  // Read another agent's public memory (no auth needed). ?soft=1: missing (or hidden)
+  // keys resolve null via a clean 200 instead of logging a console 404.
+  async getPublic(gaii, key) {
+    const url = NODE_URL + '/v1/memory/' + encodeURIComponent(gaii) + '/' + encodeURIComponent(key) + '?soft=1';
+    const r = await fetch(url);
+    const res = await r.json();
+    if (!res.ok) {
+      if (res.error?.code === 'NOT_FOUND') return null;
+      throw new Error(res.error?.message || 'Failed to read public memory');
+    }
+    return res.data.value;
+  },
+
+  // ── Micro-Memory (Tier 0.5, GET-based) ──
+  micro(setName, accessCode) {
+    const base = NODE_URL + '/v1/mm';
+
+    function mmUrl(params) {
+      const p = new URLSearchParams(params);
+      if (accessCode) p.set('access_code', accessCode);
+      return base + '?' + p.toString();
+    }
+
+    async function mmFetch(params) {
+      const r = await fetch(mmUrl(params));
+      const res = await r.json();
+      if (!res.ok) throw new Error(res.error?.message || 'Micro-memory operation failed');
+      return res.data;
+    }
+
+    return {
+      // Add or overwrite a key
+      async add(key, value) {
+        return mmFetch({ op: 'add', set: setName, key, value: typeof value === 'object' ? JSON.stringify(value) : String(value) });
+      },
+      // Modify existing key
+      async mod(key, value) {
+        return mmFetch({ op: 'mod', set: setName, key, value: typeof value === 'object' ? JSON.stringify(value) : String(value) });
+      },
+      // Delete a key
+      async del(key) {
+        return mmFetch({ op: 'del', set: setName, key });
+      },
+      // List all entries in this set
+      async list() {
+        return mmFetch({ op: 'list', set: setName });
+      },
+      // Batch add multiple key-value pairs
+      async batch(entries) {
+        const params = { op: 'batch', set: setName };
+        Object.keys(entries).forEach((k, i) => {
+          params['key' + i] = k;
+          const v = entries[k];
+          params['value' + i] = typeof v === 'object' ? JSON.stringify(v) : String(v);
+        });
+        return mmFetch(params);
+      },
+      // Configure visibility
+      async config(visibility) {
+        const params = { op: 'config', set: setName, access: visibility };
+        return mmFetch(params);
+      },
+      // Get a single key value
+      async get(key) {
+        const d = await mmFetch({ op: 'list', set: setName });
+        return d.entries?.[key] ?? null;
+      },
+    };
+  },
+
+  // List all micro-memory sets
+  async microSets() {
+    const url = NODE_URL + '/v1/mm?op=list';
+    const r = await fetch(url);
+    const res = await r.json();
+    if (!res.ok) throw new Error(res.error?.message || 'Failed to list micro-memory sets');
+    return res.data;
+  },
+};
+
+// ── Expose globally ──
+attach('data', data);

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

@@ -0,0 +1,91 @@
+// GENERATED FILE — do not edit directly. Source: src/static/sdk-libs/agentface/ (+ _core/).
+// Rebuild: pnpm build:sdk  ·  Served at /v1/libs/aimeat-agentface.js (with a per-node config prelude).
+"use strict";
+(() => {
+  // 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/agentface/index.js
+  var MAX_BYTES = 256 * 1024;
+  function getSession() {
+    const auth = window.AIMEAT && window.AIMEAT.auth;
+    if (!auth) {
+      throw new Error("AIMEAT.auth is required. Include aimeat-auth.js before aimeat-agentface.js");
+    }
+    const s = auth.getSession();
+    if (!s) {
+      throw new Error("Not signed in. AIMEATAgentFace.publish writes the face as the signed-in user — call AIMEAT.auth.login() first. Note: the node serves only the record written by the APP OWNER; another user's publish lands in their own namespace and is never served.");
+    }
+    return s;
+  }
+  function compose(doc) {
+    if (!doc || typeof doc !== "object") {
+      throw new Error("compose expects { title, sections: [{ heading, body }] }");
+    }
+    const parts = [];
+    if (doc.title) parts.push("# " + String(doc.title).trim());
+    const sections = Array.isArray(doc.sections) ? doc.sections : [];
+    for (const s of sections) {
+      if (!s || typeof s.heading !== "string" || !s.heading.trim()) {
+        throw new Error("Every section needs a non-empty string heading");
+      }
+      parts.push("## " + s.heading.trim() + "\n\n" + (typeof s.body === "string" ? s.body.trim() : ""));
+    }
+    if (parts.length === 0) throw new Error("Nothing to compose — provide a title and/or sections");
+    return parts.join("\n\n") + "\n";
+  }
+  function inferFilename() {
+    const meta = typeof document !== "undefined" && document.querySelector('meta[name="aimeat-app"]');
+    const fromMeta = meta && meta.getAttribute("content");
+    if (fromMeta && fromMeta.trim()) return fromMeta.trim();
+    const m = typeof location !== "undefined" && location.pathname.match(/\/v1\/apps\/[^/]+\/([^/?#]+\.html?)$/i);
+    if (m) return decodeURIComponent(m[1]);
+    return null;
+  }
+  var agentface = {
+    /** The convention memory key the face lives under. */
+    key(filename) {
+      return "apps." + filename + ".agentface";
+    },
+    /** The markdown composer (exposed so an app can preview what publish() will write). */
+    compose,
+    /**
+     * Publish this app's agent face: a markdown string, or { title, sections: [{ heading, body }] }.
+     * opts.app names the app filename explicitly (e.g. 'my-app.html') and overrides inference —
+     * pass it on per-app subdomain origins, where the filename is not derivable from the URL.
+     * Writes the public record apps.{filename}.agentface via the authenticated memory API.
+     */
+    async publish(input, opts) {
+      opts = opts || {};
+      const markdown = typeof input === "string" ? input : compose(input);
+      if (!markdown.trim()) throw new Error("AIMEATAgentFace.publish: the markdown content is empty");
+      if (new TextEncoder().encode(markdown).length > MAX_BYTES) {
+        throw new Error("Agent face exceeds the 256 KB cap — the node would treat it as absent. Publish a summary and link out to records instead.");
+      }
+      const filename = typeof opts.app === "string" && opts.app.trim() ? opts.app.trim() : inferFilename();
+      if (!filename) {
+        throw new Error('Cannot derive the app filename on this origin — pass { app: "your-file.html" } or add <meta name="aimeat-app" content="your-file.html"> to the page');
+      }
+      const session = getSession();
+      const key = agentface.key(filename);
+      const res = await session.fetch("/v1/memory", {
+        method: "POST",
+        body: JSON.stringify({ key, value: markdown, visibility: "public" })
+      });
+      if (!res.ok) {
+        throw new Error(res.error && res.error.message || "Failed to publish the agent face");
+      }
+      return { key, app: filename, version: res.data && res.data.version, visibility: "public" };
+    }
+  };
+  attach("agentface", agentface);
+  window.AIMEATAgentFace = agentface;
+})();