@volter/teams 0.1.33 → 0.1.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/teams",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "type": "module",
   "description": "Volter Teams, the neutral team plane: machine identity and daemon core, the local door and server link, admission from machine grants, product doors, and the Teams server's neutral routes (company RFC 0008).",
   "license": "MIT",

package/server/core.mjs

@@ -64,8 +64,8 @@ export async function maintain(api){const now=api.clock.nowMs();
   // they go (a backlog of them filled the database).
   const parts=await api.store.query(`SELECT p.team_id,p.capture_id,p.part_index FROM capture_parts p JOIN captures c ON c.team_id=p.team_id AND c.id=p.capture_id WHERE c.state='committed' LIMIT ${PART_PRUNE_BATCH}`,[]);
   for(let at=0;at<parts.length;at+=50)await api.store.transaction(parts.slice(at,at+50).map(({team_id,capture_id,part_index})=>({sql:'DELETE FROM capture_parts WHERE team_id=? AND capture_id=? AND part_index=?',params:[team_id,capture_id,part_index]})));
-  // Every capture writes its session a new version with a full copy of its messages, so versions pile up (hundreds
-  // per session) until listing them outgrew a Worker's memory. Kept: each session's current version, the newest
+  // Every capture writes its session a new version (its messages are carried, not copied: schema 9), so versions pile
+  // up (hundreds per session) until listing them outgrew a Worker's memory. Kept: each session's current version, the newest
   // version from each of its sources (the next capture and a correlation read that one), and every version an
   // unexpired list, search or history cursor names. The rest go, a bounded batch per run.
   const stale=await api.store.query(`SELECT v.team_id,v.session_id,v.revision FROM session_versions v JOIN sessions s ON s.team_id=v.team_id AND s.id=v.session_id
@@ -74,7 +74,12 @@ export async function maintain(api){const now=api.clock.nowMs();
     AND NOT EXISTS (SELECT 1 FROM cursors c, json_each(c.snapshot_json) j WHERE c.team_id=v.team_id AND c.kind IN ('list','search') AND c.expires_at>? AND json_extract(j.value,'$[0]')=v.session_id AND json_extract(j.value,'$[1]')=v.revision)
     AND NOT EXISTS (SELECT 1 FROM cursors c WHERE c.team_id=v.team_id AND c.kind='history' AND c.expires_at>? AND json_extract(c.snapshot_json,'$.session_id')=v.session_id AND json_extract(c.snapshot_json,'$.revision')=v.revision)
     LIMIT ${VERSION_PRUNE_BATCH}`,[now,now]);
-  for(const {team_id,session_id,revision} of stale)await api.store.transaction(['messages','session_artifacts','session_versions'].map(table=>({sql:`DELETE FROM ${table} WHERE team_id=? AND session_id=? AND revision=?`,params:[team_id,session_id,revision]})));
+  // A message row lives from the version that wrote it until one that changed it (schema 9), so a row a later version
+  // still holds moves to the next version that holds it before its own goes; the rest go with the version.
+  for(const {team_id,session_id,revision} of stale)await api.store.transaction([
+    {sql:'UPDATE messages SET revision=(SELECT MIN(k.revision) FROM session_versions k WHERE k.team_id=messages.team_id AND k.session_id=messages.session_id AND k.revision>messages.revision AND k.revision<COALESCE(messages.until_revision,messages.revision+1)) WHERE team_id=? AND session_id=? AND revision=? AND EXISTS (SELECT 1 FROM session_versions k WHERE k.team_id=messages.team_id AND k.session_id=messages.session_id AND k.revision>messages.revision AND k.revision<COALESCE(messages.until_revision,messages.revision+1))',params:[team_id,session_id,revision]},
+    ...['messages','session_artifacts','session_versions'].map(table=>({sql:`DELETE FROM ${table} WHERE team_id=? AND session_id=? AND revision=?`,params:[team_id,session_id,revision]})),
+  ]);
   await api.store.transaction([
         {sql:'DELETE FROM cursors WHERE expires_at<=?',params:[now]},
         {sql:'DELETE FROM global_cursors WHERE expires_at<=?',params:[now]},

package/server/migrations/009.mjs

@@ -0,0 +1,8 @@
+// Schema migration 009 (SQLite DDL), applied in order by store-core migrate().
+export default `-- Schema 9: a message row is written once and read by every version it belongs to. A row is part of each version
+-- of its session from \`revision\` up to, not including, \`until_revision\`: open (OPEN_REVISION) while the session's
+-- current version still holds it, closed at the revision of the version that changed or dropped it. A row without one
+-- (every row written before schema 9) belongs to its own revision only. A capture writes only the messages that
+-- changed; a version that changes no message writes none.
+ALTER TABLE messages ADD COLUMN until_revision INTEGER;
+`;

package/server/migrations/index.mjs

@@ -7,4 +7,9 @@ import m005 from './005.mjs';
 import m006 from './006.mjs';
 import m007 from './007.mjs';
 import m008 from './008.mjs';
-export const MIGRATIONS = [m001, m002, m003, m004, m005, m006, m007, m008];
+import m009 from './009.mjs';
+export const MIGRATIONS = [m001, m002, m003, m004, m005, m006, m007, m008, m009];
+/** A message row's `until_revision` while its session's current version still holds it (schema 9). */
+export const OPEN_REVISION = Number.MAX_SAFE_INTEGER;
+/** SQL: message row `m` belongs to the version at revision ?1 (bind the revision twice). */
+export const MESSAGE_AT = (m = 'm') => `${m}.revision<=? AND ?<COALESCE(${m}.until_revision,${m}.revision+1)`;

package/viewer/viewer.mjs

@@ -17,6 +17,20 @@ let waiting = null;
 
 const embedded = window.parent !== window;
 const ask = (type) => { if (embedded) window.parent.postMessage({ type }, '*'); };
+// Where a failure is reported: the session this page shows, once it knows it (the server logs it under the token's member).
+let reportTo = null;
+/**
+ * A failure this page cannot recover from by itself (a read, the follow, the page's own code): shown as a plain line,
+ * posted to the host as `viewer-error` { stage, status, message }, and sent to the server's log.
+ */
+function failed(stage, error, statusCode = null) {
+  const message = String(error?.message ?? error ?? 'unknown error').slice(0, 400);
+  status(message);
+  if (embedded) window.parent.postMessage({ type: 'viewer-error', stage, status: statusCode, message }, '*');
+  if (reportTo && token) fetch(reportTo, { method: 'POST', keepalive: true, headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ stage, status: statusCode, message }) }).catch(() => {});
+}
+window.addEventListener('error', (event) => failed('page', event.error ?? event.message));
+window.addEventListener('unhandledrejection', (event) => failed('page', event.reason));
 // The host's style, as supercode-ui is themed: its `--volter-*` brand tokens and `--scui-*` component tokens, set on
 // the session's root (every component reads them from an ancestor). Nothing else is taken from the host.
 function applyTheme(properties) {
@@ -120,8 +134,9 @@ async function showSession(session, control) {
   stylesheet.rel = 'stylesheet';
   stylesheet.href = '/view/session-view.css';
   document.head.append(stylesheet);
-  const { mountSessionView } = await import('/view/session-view.mjs');
   const base = `${location.origin}/api/v1/teams/${encodeURIComponent(session.team)}/sessions/${encodeURIComponent(session.id)}`;
+  reportTo = `${base}/viewer-errors`;
+  const { mountSessionView } = await import('/view/session-view.mjs').catch((error) => { throw Object.assign(error, { stage: 'load' }); });
   const element = $('session');
   element.hidden = false;
   const view = mountSessionView(element, {
@@ -159,7 +174,7 @@ async function showSession(session, control) {
   const read = () => (reading ??= (async () => {
     try {
       const response = await fetch(`${base}/messages?tail=300`, { headers: await headers() });
-      if (!response.ok) throw new Error(`reading the session failed (${response.status})`);
+      if (!response.ok) throw Object.assign(new Error(`reading the session failed (${response.status})`), { stage: 'read', status: response.status });
       const body = await response.json();
       apply(body);
       return body;
@@ -173,7 +188,7 @@ async function showSession(session, control) {
     try {
       if (!cursor) cursor = String((await read()).event_cursor ?? '') || null;
       const response = await fetch(`${base}/events?${cursor ? `after=${encodeURIComponent(cursor)}` : 'tail=1'}`, { headers: await headers() });
-      if (!response.ok) throw new Error(`following the session failed (${response.status})`);
+      if (!response.ok) throw Object.assign(new Error(`following the session failed (${response.status})`), { stage: 'follow', status: response.status });
       view.update({ live: true });
       status('');
       const reader = response.body.getReader();
@@ -193,12 +208,14 @@ async function showSession(session, control) {
           // The server ends a stream it can no longer resume (a slow reader, a retired cursor): start from a snapshot.
           if (event.terminal && event.type === 'resync_required') cursor = null;
           if (event.type === 'snapshot') apply(event.data);
-          else if (event.type === 'session_changed') read().catch((error) => status(error.message));
+          else if (event.type === 'session_changed') read().catch((error) => failed('read', error, error.status ?? null));
           else if (event.type === 'session_deleted') { view.update({ live: false, status: 'error', error: 'This session was deleted.' }); return; }
         }
       }
     } catch (error) {
-      status(error.message);
+      failed(error.stage ?? 'follow', error, error.status ?? null);
+      // Nothing drawn yet: the transcript says why instead of loading forever.
+      if (!cursor) view.update({ status: 'error', error: error.message });
     }
     view.update({ live: false });
     await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -320,4 +337,4 @@ async function showFolder(connect, root, control) {
   await list(base);
 }
 
-main().catch((error) => status(error.message));
+main().catch((error) => failed(error?.stage ?? 'start', error, error?.status ?? null));