@aria-framework/ai 0.12.0 → 0.12.1

package/index.js

@@ -207,6 +207,11 @@ module.exports = {
   // Speed history. Lazy for the same reason as the others: it needs the db-worker driver contract,
   // which is an optional peer.
   get createSpeedStore() { return require('./speedStore').createSpeedStore; },
+  // EXPORTED SO A CONSUMER CAN ASSERT ITS TABLE MATCHES. An app writes its own migration, which is
+  // a hand copy of this DDL — and a copy with nothing comparing it to the original is the failure
+  // mode this repo has already documented twice. providerSchemaFor and usageSchemaFor exist for the
+  // same reason; leaving this one out meant a drift would surface as an INSERT throwing at runtime.
+  get speedSchemaFor() { return require('./speedStore').schemaFor; },
   // No database behind health, so it loads eagerly like the rest of the seam.
   ...require('./health'),
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aria-framework/ai",
   "description": "Aria App Framework — AI module. A dependency-injected model seam (createAiClient) over several providers (LM Studio / OpenAI-compatible / Anthropic), with a fact-preservation guard, generic Polish and Generate writing engines, and a browser polish widget. Prompts and config stay in the consuming app.",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "license": "UNLICENSED",
   "private": false,
   "publishConfig": {

package/speedStore.js

@@ -33,6 +33,22 @@ function createSpeedStore(opts = {}) {
 
   const num = (v) => (v == null || v === '' || Number.isNaN(Number(v)) ? null : Number(v));
 
+  /**
+   * `YYYY-MM-DD HH:MM:SS` in UTC — what `datetime('now')` produces, and what every other timestamp
+   * column in a consuming app already holds.
+   *
+   * toISOString() was the obvious thing to write and the wrong thing to store. Apps parse these
+   * columns with `new Date(String(ts).replace(' ', 'T') + 'Z')`; given an ISO string there is no
+   * space to replace, so the 'Z' is appended to one already there and the result is Invalid Date —
+   * silently, because the helper checks isNaN and returns ''. Sorting is worse: 'T' (0x54) sorts
+   * after ' ' (0x20), so an ISO row and a datetime('now') row from the same second compare wrong.
+   */
+  const stamp = (d) => {
+    const p2 = (n) => String(n).padStart(2, '0');
+    return `${d.getUTCFullYear()}-${p2(d.getUTCMonth() + 1)}-${p2(d.getUTCDate())} `
+      + `${p2(d.getUTCHours())}:${p2(d.getUTCMinutes())}:${p2(d.getUTCSeconds())}`;
+  };
+
   return {
     table,
 
@@ -50,7 +66,7 @@ function createSpeedStore(opts = {}) {
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         [
           String(entry.endpoint || ''),
-          (entry.at || now()).toISOString(),
+          stamp(entry.at || now()),
           num(entry.tokensPerSec),
           num(entry.coldMs),
           num(entry.runTokens),
@@ -80,15 +96,29 @@ function createSpeedStore(opts = {}) {
       const ids = (endpoints || []).map((e) => String(e)).filter(Boolean);
       if (!ids.length) return {};
       const capped = Math.max(1, Math.min(500, Number(limit) || DEFAULT_LIMIT));
-      const rows = await driver.all(
-        `SELECT * FROM ${table} WHERE endpoint IN (${ids.map(() => '?').join(', ')}) ORDER BY id DESC`,
-        ids
-      );
+      // LIMITED PER ENDPOINT, IN SQL. A single `WHERE endpoint IN (...) ORDER BY id DESC` reads
+      // every retained row for every endpoint and throws most of them away in JS — at the 200-row
+      // bound with eight endpoints that is 1600 rows, `error` text included, marshalled across the
+      // worker boundary to draw eight 88-pixel lines. It also cannot use the (endpoint, id DESC)
+      // index for a global ordering, so it sorts in a temp b-tree as well.
+      //
+      // UNION ALL of per-endpoint selects rather than a window function: it reads the same on both
+      // engines and needs no version floor.
+      // EACH BRANCH IN A SUBQUERY, and aliased. A bare `... ORDER BY id DESC LIMIT n UNION ALL ...`
+      // is a syntax error — the ORDER BY binds to the compound, not the branch — and Postgres
+      // additionally requires a name for a subquery in FROM. Both engines accept this form.
+      const sql = ids
+        .map((_, i) => `SELECT * FROM (SELECT * FROM ${table} WHERE endpoint = ? `
+          + `ORDER BY id DESC LIMIT ${capped}) AS s${i}`)
+        .join(' UNION ALL ');
+      const rows = await driver.all(sql, ids);
       const out = {};
       for (const row of rows) {
         const bucket = out[row.endpoint] || (out[row.endpoint] = { latest: null, points: [] });
-        if (!bucket.latest) bucket.latest = row;          // rows arrive newest first
-        if (bucket.points.length < capped) bucket.points.push(row);
+        // Newest first WITHIN each endpoint's block, which is all this needs — the blocks
+        // themselves may arrive in any order.
+        if (!bucket.latest) bucket.latest = row;
+        bucket.points.push(row);
       }
       // Reversed at the end so a caller draws left-to-right in time without thinking about it.
       for (const id of Object.keys(out)) out[id].points.reverse();
@@ -102,9 +132,15 @@ function createSpeedStore(opts = {}) {
      * history, and one checked hourly should not be able to bury it. Age-based pruning gets that
      * backwards for exactly the endpoints whose trend matters most.
      */
-    async prune({ keepPerEndpoint = 200 } = {}) {
+    async prune({ keepPerEndpoint = 200, endpoint = null } = {}) {
       const keep = Math.max(10, Math.min(5000, Number(keepPerEndpoint) || 200));
-      const ids = await driver.all(`SELECT DISTINCT endpoint FROM ${table}`, []);
+      // ONE ENDPOINT WHEN THE CALLER KNOWS WHICH. Pruning on write swept every endpoint in the
+      // table every time — 1 + 2N queries to delete at most one row belonging to one of them, since
+      // none of the others can have grown since their own last write. With eight endpoints that was
+      // seventeen worker round trips inside a request, for one deletion.
+      const ids = endpoint
+        ? [{ endpoint: String(endpoint) }]
+        : await driver.all(`SELECT DISTINCT endpoint FROM ${table}`, []);
       let removed = 0;
       for (const { endpoint } of ids) {
         const cutoff = await driver.get(