@vascend/talos 0.1.0 → 0.1.1

package/dist/vendor/computer-use/package.json

@@ -1 +1 @@
-{"type":"commonjs","private":true}
+{"type":"commonjs","private":true}

package/dist/vendor/computer-use/rac/atomic-input.js

@@ -1,91 +1,91 @@
-'use strict';
-
-const MAX_OPERATIONS = 12;
-const MAX_TEXT = 4000;
-
-const KEY_ALIASES = Object.freeze({
-  ctrl: 'Ctrl', control: 'Ctrl', shift: 'Shift', alt: 'Alt',
-  space: 'Space', tab: 'Tab', esc: 'Esc', escape: 'Esc',
-  enter: 'Enter', return: 'Enter', backspace: 'Backspace', delete: 'Delete', del: 'Delete',
-  home: 'Home', end: 'End', left: 'ArrowLeft', arrowleft: 'ArrowLeft',
-  up: 'ArrowUp', arrowup: 'ArrowUp', right: 'ArrowRight', arrowright: 'ArrowRight',
-  down: 'ArrowDown', arrowdown: 'ArrowDown',
-});
-
-function normalizeKey(value) {
-  const raw = String(value || '').trim();
-  if (!raw) return null;
-  const alias = KEY_ALIASES[raw.toLowerCase()];
-  if (alias) return alias;
-  if (/^[a-z0-9]$/i.test(raw)) return raw.toUpperCase();
-  return null;
-}
-
-function normalizeShortcut(keys) {
-  const source = Array.isArray(keys)
-    ? keys
-    : String(keys || '').split(/[+\s]+/).filter(Boolean);
-  if (!source.length || source.length > 4) {
-    return { ok: false, code: 'BAD_SHORTCUT', error: 'Una scorciatoia richiede da uno a quattro tasti.' };
-  }
-  const normalized = [];
-  for (const value of source) {
-    const key = normalizeKey(value);
-    if (!key) return { ok: false, code: 'BAD_SHORTCUT', error: `Tasto non ammesso: ${String(value)}` };
-    if (!normalized.includes(key)) normalized.push(key);
-  }
-  return { ok: true, keys: normalized };
-}
-
-function normalizeAtomicOperations(value) {
-  if (!Array.isArray(value) || !value.length || value.length > MAX_OPERATIONS) {
-    return { ok: false, code: 'BAD_OPERATIONS', error: `Servono da 1 a ${MAX_OPERATIONS} operazioni.` };
-  }
-  const operations = [];
-  for (const raw of value) {
-    const type = String(raw && raw.type || '').trim().toLowerCase();
-    if (type === 'shortcut') {
-      const shortcut = normalizeShortcut(raw.keys);
-      if (!shortcut.ok) return shortcut;
-      operations.push({ type, keys: shortcut.keys });
-      continue;
-    }
-    if (type === 'text') {
-      const text = String(raw && raw.text != null ? raw.text : '');
-      if (!text || text.length > MAX_TEXT || /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(text)) {
-        return { ok: false, code: 'BAD_TEXT', error: `Il testo deve contenere da 1 a ${MAX_TEXT} caratteri stampabili.` };
-      }
-      operations.push({ type, text });
-      continue;
-    }
-    if (type === 'mouse') {
-      const dx = Number(raw && raw.dx || 0);
-      const dy = Number(raw && raw.dy || 0);
-      const scroll = Number(raw && raw.scroll || 0);
-      if (![dx, dy, scroll].every(Number.isInteger)
-        || Math.abs(dx) > 1000 || Math.abs(dy) > 1000 || Math.abs(scroll) > 5) {
-        return { ok: false, code: 'BAD_MOUSE', error: 'Mouse fuori range: dx/dy ±1000, scroll ±5.' };
-      }
-      operations.push({ type, dx, dy, scroll });
-      continue;
-    }
-    if (type === 'click') {
-      const button = String(raw && raw.button || 'left').toLowerCase();
-      if (!['left', 'right', 'middle'].includes(button)) {
-        return { ok: false, code: 'BAD_BUTTON', error: 'Pulsante ammesso: left, right o middle.' };
-      }
-      operations.push({ type, button });
-      continue;
-    }
-    return { ok: false, code: 'BAD_OPERATION', error: `Operazione non ammessa: ${type || '(vuota)'}` };
-  }
-  return { ok: true, operations };
-}
-
-module.exports = {
-  MAX_OPERATIONS,
-  MAX_TEXT,
-  normalizeKey,
-  normalizeShortcut,
-  normalizeAtomicOperations,
-};
+'use strict';
+
+const MAX_OPERATIONS = 12;
+const MAX_TEXT = 4000;
+
+const KEY_ALIASES = Object.freeze({
+  ctrl: 'Ctrl', control: 'Ctrl', shift: 'Shift', alt: 'Alt',
+  space: 'Space', tab: 'Tab', esc: 'Esc', escape: 'Esc',
+  enter: 'Enter', return: 'Enter', backspace: 'Backspace', delete: 'Delete', del: 'Delete',
+  home: 'Home', end: 'End', left: 'ArrowLeft', arrowleft: 'ArrowLeft',
+  up: 'ArrowUp', arrowup: 'ArrowUp', right: 'ArrowRight', arrowright: 'ArrowRight',
+  down: 'ArrowDown', arrowdown: 'ArrowDown',
+});
+
+function normalizeKey(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return null;
+  const alias = KEY_ALIASES[raw.toLowerCase()];
+  if (alias) return alias;
+  if (/^[a-z0-9]$/i.test(raw)) return raw.toUpperCase();
+  return null;
+}
+
+function normalizeShortcut(keys) {
+  const source = Array.isArray(keys)
+    ? keys
+    : String(keys || '').split(/[+\s]+/).filter(Boolean);
+  if (!source.length || source.length > 4) {
+    return { ok: false, code: 'BAD_SHORTCUT', error: 'Una scorciatoia richiede da uno a quattro tasti.' };
+  }
+  const normalized = [];
+  for (const value of source) {
+    const key = normalizeKey(value);
+    if (!key) return { ok: false, code: 'BAD_SHORTCUT', error: `Tasto non ammesso: ${String(value)}` };
+    if (!normalized.includes(key)) normalized.push(key);
+  }
+  return { ok: true, keys: normalized };
+}
+
+function normalizeAtomicOperations(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_OPERATIONS) {
+    return { ok: false, code: 'BAD_OPERATIONS', error: `Servono da 1 a ${MAX_OPERATIONS} operazioni.` };
+  }
+  const operations = [];
+  for (const raw of value) {
+    const type = String(raw && raw.type || '').trim().toLowerCase();
+    if (type === 'shortcut') {
+      const shortcut = normalizeShortcut(raw.keys);
+      if (!shortcut.ok) return shortcut;
+      operations.push({ type, keys: shortcut.keys });
+      continue;
+    }
+    if (type === 'text') {
+      const text = String(raw && raw.text != null ? raw.text : '');
+      if (!text || text.length > MAX_TEXT || /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/.test(text)) {
+        return { ok: false, code: 'BAD_TEXT', error: `Il testo deve contenere da 1 a ${MAX_TEXT} caratteri stampabili.` };
+      }
+      operations.push({ type, text });
+      continue;
+    }
+    if (type === 'mouse') {
+      const dx = Number(raw && raw.dx || 0);
+      const dy = Number(raw && raw.dy || 0);
+      const scroll = Number(raw && raw.scroll || 0);
+      if (![dx, dy, scroll].every(Number.isInteger)
+        || Math.abs(dx) > 1000 || Math.abs(dy) > 1000 || Math.abs(scroll) > 5) {
+        return { ok: false, code: 'BAD_MOUSE', error: 'Mouse fuori range: dx/dy ±1000, scroll ±5.' };
+      }
+      operations.push({ type, dx, dy, scroll });
+      continue;
+    }
+    if (type === 'click') {
+      const button = String(raw && raw.button || 'left').toLowerCase();
+      if (!['left', 'right', 'middle'].includes(button)) {
+        return { ok: false, code: 'BAD_BUTTON', error: 'Pulsante ammesso: left, right o middle.' };
+      }
+      operations.push({ type, button });
+      continue;
+    }
+    return { ok: false, code: 'BAD_OPERATION', error: `Operazione non ammessa: ${type || '(vuota)'}` };
+  }
+  return { ok: true, operations };
+}
+
+module.exports = {
+  MAX_OPERATIONS,
+  MAX_TEXT,
+  normalizeKey,
+  normalizeShortcut,
+  normalizeAtomicOperations,
+};

package/dist/vendor/computer-use/rac/grammatica.js

@@ -1,101 +1,101 @@
-'use strict';
-
-// MCP-RAC — grammatica computer-use v0.1 (spec §6.4).
-//
-// Un'azione e' un blocco:
-//
-//   ACTION <observation_id> ttl=<ms>
-//   <dx> <dy> <scroll> ; K1 ; K2 ; ... ; K6 END
-//
-// Il primo segmento e' il MOVIMENTO (relativo, distribuito sull'orizzonte);
-// i successivi sono KEYSET: l'insieme dei tasti tenuti premuti per 33 ms.
-// `_` e' il keyset vuoto (tutto rilasciato). Le chiavi assenti si rilasciano.
-//
-// La grammatica e' volutamente povera: niente Enter, niente Canc, niente tasto
-// Windows. Non e' una dimenticanza — e' il primo strato di sicurezza (spec §13):
-// le azioni irreversibili non devono essere ESPRIMIBILI nel canale reattivo,
-// prima ancora che vietate da una policy.
-
-const LIMITI = Object.freeze({
-  MOUSE_DELTA: 1000,        // dx, dy in [-1000, 1000]
-  SCROLL: 5,                // scroll in [-5, 5]
-  TASTI_PER_CHUNK: 4,       // spec §13: "max quattro tasti/chunk"
-  CHUNK_PER_AZIONE: 6,      // 6 keyset da 33 ms = orizzonte 200 ms
-  TTL_MASSIMO_MS: 250,      // oltre la lease il chunk non ha senso
-  CHUNK_MS: 33,             // durata nominale di un keyset
-  ORIZZONTE_MS: 200,
-  BUFFER_MASSIMO: 16 * 1024,
-});
-
-// L'alfabeto completo dei tasti ammessi. Un token fuori da qui non e' "un tasto
-// sconosciuto da inoltrare": e' un errore di grammatica che avvelena l'azione.
-const TASTI_INTERNI = (() => {
-  const out = new Set(['Shift', 'Ctrl', 'Alt', 'Space', 'Tab', 'Esc', 'LB', 'RB', 'MB']);
-  for (let c = 65; c <= 90; c += 1) out.add(String.fromCharCode(c)); // A..Z
-  for (let d = 0; d <= 9; d += 1) out.add(String(d));                // 0..9
-  return out;
-})();
-// Un Set congelato resta modificabile tramite add/delete. Esponiamo quindi una
-// fotografia realmente immutabile e teniamo il Set usato dalla validazione
-// chiuso nel modulo.
-const TASTI = Object.freeze([...TASTI_INTERNI].sort());
-
-function interoIn(testo, min, max) {
-  if (!/^-?\d+$/.test(testo)) return null;
-  const n = Number(testo);
-  return n >= min && n <= max ? n : null;
-}
-
-// "ACTION 184 ttl=250" -> { observationId, ttlMs } | { errore }
-function analizzaIntestazione(riga) {
-  const m = /^ACTION\s+(\d+)\s+ttl=(\d+)$/.exec(String(riga || '').trim());
-  if (!m) return { errore: 'intestazione malformata' };
-  const observationNumber = Number(m[1]);
-  const ttlMs = Number(m[2]);
-  if (!Number.isSafeInteger(observationNumber)) return { errore: 'observation_id fuori limite' };
-  if (ttlMs <= 0 || ttlMs > LIMITI.TTL_MASSIMO_MS) {
-    return { errore: `ttl fuori limite (1..${LIMITI.TTL_MASSIMO_MS})` };
-  }
-  return { observationId: m[1], ttlMs };
-}
-
-// "92 0 0" -> { tipo: 'mouse', dx, dy, scroll } | { errore }
-function analizzaMouse(segmento) {
-  const parti = String(segmento || '').trim().split(/\s+/);
-  if (parti.length !== 3) return { errore: 'il movimento vuole esattamente dx dy scroll' };
-  const dx = interoIn(parti[0], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
-  const dy = interoIn(parti[1], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
-  const scroll = interoIn(parti[2], -LIMITI.SCROLL, LIMITI.SCROLL);
-  if (dx === null || dy === null || scroll === null) return { errore: 'movimento fuori range' };
-  return { tipo: 'mouse', dx, dy, scroll };
-}
-
-// "Shift W" | "_" -> { tipo: 'keyset', tasti: [...] } | { errore }
-// I tasti si normalizzano ordinati e senza duplicati: {W,Shift} e {Shift,W}
-// sono lo stesso stato fisico, e l'esecutore confronta insiemi.
-function analizzaKeyset(segmento) {
-  const testo = String(segmento || '').trim();
-  if (testo === '_') return { tipo: 'keyset', tasti: [] };
-  if (!testo) return { errore: 'keyset vuoto: usa _ per rilasciare tutti i tasti' };
-  const token = testo.split(/\s+/);
-  if (token.length > LIMITI.TASTI_PER_CHUNK) {
-    return { errore: `piu' di ${LIMITI.TASTI_PER_CHUNK} tasti in un chunk` };
-  }
-  const visti = new Set();
-  for (const t of token) {
-    if (!TASTI_INTERNI.has(t)) return { errore: `tasto fuori alfabeto: ${t}` };
-    visti.add(t);
-  }
-  return { tipo: 'keyset', tasti: [...visti].sort() };
-}
-
-// Serializzazione, per il simulatore e i replay: da azione strutturata al testo
-// che il decoder emetterebbe. Round-trip garantito dai test.
-function serializza(azione) {
-  const testa = `ACTION ${azione.observationId} ttl=${azione.ttlMs}\n`;
-  const mouse = `${azione.mouse.dx} ${azione.mouse.dy} ${azione.mouse.scroll}`;
-  const keyset = azione.keyset.map((k) => (k.length ? k.join(' ') : '_'));
-  return testa + [mouse, ...keyset].join(' ; ') + ' ;\nEND';
-}
-
-module.exports = { LIMITI, TASTI, analizzaIntestazione, analizzaMouse, analizzaKeyset, serializza };
+'use strict';
+
+// MCP-RAC — grammatica computer-use v0.1 (spec §6.4).
+//
+// Un'azione e' un blocco:
+//
+//   ACTION <observation_id> ttl=<ms>
+//   <dx> <dy> <scroll> ; K1 ; K2 ; ... ; K6 END
+//
+// Il primo segmento e' il MOVIMENTO (relativo, distribuito sull'orizzonte);
+// i successivi sono KEYSET: l'insieme dei tasti tenuti premuti per 33 ms.
+// `_` e' il keyset vuoto (tutto rilasciato). Le chiavi assenti si rilasciano.
+//
+// La grammatica e' volutamente povera: niente Enter, niente Canc, niente tasto
+// Windows. Non e' una dimenticanza — e' il primo strato di sicurezza (spec §13):
+// le azioni irreversibili non devono essere ESPRIMIBILI nel canale reattivo,
+// prima ancora che vietate da una policy.
+
+const LIMITI = Object.freeze({
+  MOUSE_DELTA: 1000,        // dx, dy in [-1000, 1000]
+  SCROLL: 5,                // scroll in [-5, 5]
+  TASTI_PER_CHUNK: 4,       // spec §13: "max quattro tasti/chunk"
+  CHUNK_PER_AZIONE: 6,      // 6 keyset da 33 ms = orizzonte 200 ms
+  TTL_MASSIMO_MS: 250,      // oltre la lease il chunk non ha senso
+  CHUNK_MS: 33,             // durata nominale di un keyset
+  ORIZZONTE_MS: 200,
+  BUFFER_MASSIMO: 16 * 1024,
+});
+
+// L'alfabeto completo dei tasti ammessi. Un token fuori da qui non e' "un tasto
+// sconosciuto da inoltrare": e' un errore di grammatica che avvelena l'azione.
+const TASTI_INTERNI = (() => {
+  const out = new Set(['Shift', 'Ctrl', 'Alt', 'Space', 'Tab', 'Esc', 'LB', 'RB', 'MB']);
+  for (let c = 65; c <= 90; c += 1) out.add(String.fromCharCode(c)); // A..Z
+  for (let d = 0; d <= 9; d += 1) out.add(String(d));                // 0..9
+  return out;
+})();
+// Un Set congelato resta modificabile tramite add/delete. Esponiamo quindi una
+// fotografia realmente immutabile e teniamo il Set usato dalla validazione
+// chiuso nel modulo.
+const TASTI = Object.freeze([...TASTI_INTERNI].sort());
+
+function interoIn(testo, min, max) {
+  if (!/^-?\d+$/.test(testo)) return null;
+  const n = Number(testo);
+  return n >= min && n <= max ? n : null;
+}
+
+// "ACTION 184 ttl=250" -> { observationId, ttlMs } | { errore }
+function analizzaIntestazione(riga) {
+  const m = /^ACTION\s+(\d+)\s+ttl=(\d+)$/.exec(String(riga || '').trim());
+  if (!m) return { errore: 'intestazione malformata' };
+  const observationNumber = Number(m[1]);
+  const ttlMs = Number(m[2]);
+  if (!Number.isSafeInteger(observationNumber)) return { errore: 'observation_id fuori limite' };
+  if (ttlMs <= 0 || ttlMs > LIMITI.TTL_MASSIMO_MS) {
+    return { errore: `ttl fuori limite (1..${LIMITI.TTL_MASSIMO_MS})` };
+  }
+  return { observationId: m[1], ttlMs };
+}
+
+// "92 0 0" -> { tipo: 'mouse', dx, dy, scroll } | { errore }
+function analizzaMouse(segmento) {
+  const parti = String(segmento || '').trim().split(/\s+/);
+  if (parti.length !== 3) return { errore: 'il movimento vuole esattamente dx dy scroll' };
+  const dx = interoIn(parti[0], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
+  const dy = interoIn(parti[1], -LIMITI.MOUSE_DELTA, LIMITI.MOUSE_DELTA);
+  const scroll = interoIn(parti[2], -LIMITI.SCROLL, LIMITI.SCROLL);
+  if (dx === null || dy === null || scroll === null) return { errore: 'movimento fuori range' };
+  return { tipo: 'mouse', dx, dy, scroll };
+}
+
+// "Shift W" | "_" -> { tipo: 'keyset', tasti: [...] } | { errore }
+// I tasti si normalizzano ordinati e senza duplicati: {W,Shift} e {Shift,W}
+// sono lo stesso stato fisico, e l'esecutore confronta insiemi.
+function analizzaKeyset(segmento) {
+  const testo = String(segmento || '').trim();
+  if (testo === '_') return { tipo: 'keyset', tasti: [] };
+  if (!testo) return { errore: 'keyset vuoto: usa _ per rilasciare tutti i tasti' };
+  const token = testo.split(/\s+/);
+  if (token.length > LIMITI.TASTI_PER_CHUNK) {
+    return { errore: `piu' di ${LIMITI.TASTI_PER_CHUNK} tasti in un chunk` };
+  }
+  const visti = new Set();
+  for (const t of token) {
+    if (!TASTI_INTERNI.has(t)) return { errore: `tasto fuori alfabeto: ${t}` };
+    visti.add(t);
+  }
+  return { tipo: 'keyset', tasti: [...visti].sort() };
+}
+
+// Serializzazione, per il simulatore e i replay: da azione strutturata al testo
+// che il decoder emetterebbe. Round-trip garantito dai test.
+function serializza(azione) {
+  const testa = `ACTION ${azione.observationId} ttl=${azione.ttlMs}\n`;
+  const mouse = `${azione.mouse.dx} ${azione.mouse.dy} ${azione.mouse.scroll}`;
+  const keyset = azione.keyset.map((k) => (k.length ? k.join(' ') : '_'));
+  return testa + [mouse, ...keyset].join(' ; ') + ' ;\nEND';
+}
+
+module.exports = { LIMITI, TASTI, analizzaIntestazione, analizzaMouse, analizzaKeyset, serializza };