synabun 2.0.9 → 2.1.0

package/neural-interface/public/shared/skills/ss-creation.js

@@ -0,0 +1,219 @@
+// ═══════════════════════════════════════════
+// SynaBun — AI skill creation: what a request is (P3)
+// ═══════════════════════════════════════════
+//
+// The request the Studio's Create place (and the Assistant's `skill` tool) sends to start drafting a skill with AI:
+// the owner's words, an optional example of a good result, the sources the draft is made from, the options, and the
+// worker that drafts it. The server checks it with the same function (lib/skills/creation.js) before anything runs:
+// one reading of a request for the page and the server. No DOM and no imports.
+//
+//   describe      the owner's words only
+//   conversation  one session transcript of Claude Code, Codex or OpenCode (read by the server, as data)
+//   url           a web page, read by the server with the SynaBun browser before the worker starts (as data)
+//   repo          a registered project, read by the server: its file tree, docs, manifests and the files named
+//   memory        a recall over SynaBun's memory
+//   import        an imported skill (a staged import), or a skill of the catalog or the library, as the starting point
+
+export const SOURCE_KINDS = Object.freeze(['describe', 'conversation', 'url', 'repo', 'memory', 'import']);
+export const CONVERSATION_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode']);
+/**
+ * Who drafts: Claude Code only. A drafting worker reads hostile sources, so it is held to its folder with file tools
+ * only (lib/skills/draft-confinement.js), which Claude Code enforces before any permission mode; Codex starts MCP
+ * servers outside its sandbox and OpenCode answers its own permission prompts, so neither can be held there yet.
+ */
+/** The providers a drafting run can be held to its folder on (lib/skills/draft-confinement.js draftConfinementSupport). */
+export const DRAFT_PROVIDERS = Object.freeze(['claude-code', 'codex', 'opencode']);
+export const CREATION_TARGET_RUNTIMES = Object.freeze(['claude', 'codex', 'opencode', 'agents']);
+
+/** The stages of a creation, in order; the last four end it. */
+export const CREATION_STAGES = Object.freeze(['queued', 'gathering', 'drafting', 'checking', 'submitting', 'done', 'failed', 'cancelled', 'interrupted']);
+export const ACTIVE_CREATION_STAGES = Object.freeze(['queued', 'gathering', 'drafting', 'checking', 'submitting']);
+export const isActiveCreation = (state) => ACTIVE_CREATION_STAGES.includes(String(state || ''));
+
+export const CREATION_LIMITS = Object.freeze({
+  promptChars: 8000, exampleChars: 8000, nameChars: 64, sources: 5,
+  urlChars: 2000, queryChars: 500, memoryLimit: { min: 1, max: 20, default: 10 },
+  paths: 20, pathChars: 512, sessionIdChars: 128, labelChars: 200, targets: 8, projectPathChars: 2000,
+  // The drafting worker's work time (minutes of work, not of waiting) and its spend ceiling when a budget is set.
+  maxMinutes: { min: 20, max: 90, default: 30 },
+  budgetUsd: { min: 0.5, max: 20, default: 3 },
+});
+
+const NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const SESSION_RE = /^[A-Za-z0-9_.:-]{6,128}$/;
+const STAGING_RE = /^[0-9a-f]{24}$/;
+const SKILL_RE = /^skl_[0-9a-f]{20}$/;
+const ARTIFACT_RE = /^art_[0-9a-f]{20}$/;
+const MODEL_RE = /^[A-Za-z0-9._:/@[\]-]{1,200}$/;
+const EFFORT_RE = /^[a-z]{2,20}$/;
+const ACCOUNT_RE = /^[A-Za-z0-9_-]{1,64}$/;
+
+const str = (v) => (typeof v === 'string' ? v : '');
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+
+/** A relative path inside a project: no absolute path, no "..", forward slashes. */
+export function relativePathProblem(p) {
+  const s = str(p);
+  if (!s.trim()) return 'empty';
+  if (s.length > CREATION_LIMITS.pathChars) return 'too-long';
+  if (s.startsWith('/') || s.startsWith('~') || /^[A-Za-z]:/.test(s) || s.includes('\\') || s.includes('\0')) return 'absolute';
+  if (s.split('/').some((part) => part === '..')) return 'parent';
+  return null;
+}
+
+/**
+ * A web address the server may open for a draft: http or https, no user name or password in it, and nothing a URL
+ * parser would quietly drop (a line break, a tab, a control character or a space): what is checked is what is opened.
+ */
+export function urlProblem(u) {
+  const s = str(u).trim();
+  if (!s) return 'empty';
+  if (s.length > CREATION_LIMITS.urlChars) return 'too-long';
+  if (/[\s\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(s)) return 'invalid';
+  let parsed;
+  try { parsed = new URL(s); } catch { return 'invalid'; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return 'scheme';
+  if (parsed.username || parsed.password) return 'credentials';
+  return null;
+}
+
+/** The address as the browser will open it (the parser's own spelling), or '' when urlProblem() refuses it. */
+export function normalizedUrl(u) {
+  if (urlProblem(u)) return '';
+  try { return new URL(str(u).trim()).href; } catch { return ''; }
+}
+
+function normalizeSource(raw, i, problems) {
+  const at = `sources[${i}]`;
+  if (!isObject(raw)) { problems.push({ field: at, code: 'source-shape' }); return null; }
+  const kind = raw.kind;
+  if (!SOURCE_KINDS.includes(kind)) { problems.push({ field: `${at}.kind`, code: 'source-kind' }); return null; }
+  const label = str(raw.label).slice(0, CREATION_LIMITS.labelChars);
+  if (kind === 'describe') return { kind };
+  if (kind === 'conversation') {
+    const provider = raw.provider;
+    if (!CONVERSATION_PROVIDERS.includes(provider)) problems.push({ field: `${at}.provider`, code: 'conversation-provider' });
+    const sessionId = str(raw.sessionId).trim();
+    if (!SESSION_RE.test(sessionId)) problems.push({ field: `${at}.sessionId`, code: 'conversation-session' });
+    const project = str(raw.project).trim() || null;
+    return { kind, provider, sessionId, project, label };
+  }
+  if (kind === 'url') {
+    const url = str(raw.url).trim();
+    const why = urlProblem(url);
+    if (why) problems.push({ field: `${at}.url`, code: `url-${why}` });
+    return { kind, url: why ? url : normalizedUrl(url), label };
+  }
+  if (kind === 'repo') {
+    const project = str(raw.project).trim();
+    if (!project) problems.push({ field: `${at}.project`, code: 'repo-project' });
+    const paths = Array.isArray(raw.paths) ? raw.paths : [];
+    if (paths.length > CREATION_LIMITS.paths) problems.push({ field: `${at}.paths`, code: 'repo-paths-many' });
+    const clean = [];
+    paths.slice(0, CREATION_LIMITS.paths).forEach((p, j) => {
+      const why = relativePathProblem(p);
+      if (why) problems.push({ field: `${at}.paths[${j}]`, code: `repo-path-${why}` });
+      else if (!clean.includes(p)) clean.push(p);
+    });
+    return { kind, project, paths: clean, label };
+  }
+  if (kind === 'memory') {
+    const query = str(raw.query).trim();
+    if (!query) problems.push({ field: `${at}.query`, code: 'memory-query' });
+    else if (query.length > CREATION_LIMITS.queryChars) problems.push({ field: `${at}.query`, code: 'memory-query-long' });
+    const { min, max, default: dflt } = CREATION_LIMITS.memoryLimit;
+    const limit = Number.isInteger(raw.limit) ? Math.min(max, Math.max(min, raw.limit)) : dflt;
+    const project = str(raw.project).trim() || null;
+    return { kind, query, limit, project, label };
+  }
+  // import: exactly one of a staged import, a library skill, a catalog entry.
+  const given = ['stagingId', 'skillId', 'artifactId'].filter((k) => raw[k] !== undefined && raw[k] !== null && raw[k] !== '');
+  if (given.length !== 1) { problems.push({ field: at, code: 'import-one' }); return { kind, label }; }
+  const key = given[0];
+  const value = str(raw[key]);
+  const ok = key === 'stagingId' ? STAGING_RE.test(value) : key === 'skillId' ? SKILL_RE.test(value) : ARTIFACT_RE.test(value);
+  if (!ok) problems.push({ field: `${at}.${key}`, code: 'import-id' });
+  return { kind, [key]: value, label };
+}
+
+/**
+ * Check and normalize a creation request.
+ * @param {object} body
+ * @param {{ submitDefault?: boolean }} [o] whether the draft goes to Review by itself when the request does not say
+ *   (the Studio: yes; the Assistant: no, it looks first)
+ * @returns {{ ok: boolean, request: object, problems: { field: string, code: string }[] }}
+ */
+export function normalizeCreationRequest(body, { submitDefault = true } = {}) {
+  const problems = [];
+  const b = isObject(body) ? body : {};
+  const prompt = str(b.prompt).trim();
+  if (prompt.length > CREATION_LIMITS.promptChars) problems.push({ field: 'prompt', code: 'prompt-long' });
+  const example = str(b.example).trim();
+  if (example.length > CREATION_LIMITS.exampleChars) problems.push({ field: 'example', code: 'example-long' });
+  const name = str(b.name).trim();
+  if (name && (name.length > CREATION_LIMITS.nameChars || !NAME_RE.test(name))) problems.push({ field: 'name', code: 'name-format' });
+  const invocation = b.invocation === 'manual' ? 'manual' : 'auto';
+  const rawSources = Array.isArray(b.sources) ? b.sources : [];
+  if (rawSources.length > CREATION_LIMITS.sources) problems.push({ field: 'sources', code: 'sources-many' });
+  const sources = rawSources.slice(0, CREATION_LIMITS.sources).map((s, i) => normalizeSource(s, i, problems)).filter((s) => s && s.kind !== 'describe');
+  if (!prompt && !sources.length) problems.push({ field: 'prompt', code: 'prompt-required' });
+  // The worker that drafts: a provider, a model (or its default), an effort; null leaves it to the owner's route.
+  let target = null;
+  if (b.target !== undefined && b.target !== null) {
+    const t = isObject(b.target) ? b.target : {};
+    if (!DRAFT_PROVIDERS.includes(t.provider)) problems.push({ field: 'target.provider', code: 'target-provider' });
+    const model = str(t.model).trim();
+    if (model && !MODEL_RE.test(model)) problems.push({ field: 'target.model', code: 'target-model' });
+    const effort = str(t.effort).trim();
+    if (effort && !EFFORT_RE.test(effort)) problems.push({ field: 'target.effort', code: 'target-effort' });
+    target = { provider: t.provider, model: model || null, effort: effort || null };
+  }
+  const mm = CREATION_LIMITS.maxMinutes;
+  const maxMinutes = Number.isFinite(Number(b.maxMinutes)) && Number(b.maxMinutes) > 0 ? Math.min(mm.max, Math.max(mm.min, Math.round(Number(b.maxMinutes)))) : mm.default;
+  const bu = CREATION_LIMITS.budgetUsd;
+  const budgetUsd = Number.isFinite(Number(b.budgetUsd)) && Number(b.budgetUsd) > 0 ? Math.min(bu.max, Math.max(bu.min, Number(b.budgetUsd))) : bu.default;
+  // Where the owner may install it, as the Review card and the install plan read a target (lib/skills/deploy.js
+  // normalizeTarget): a runtime, user or project scope, an account, a project's path. Kept whole; what is not one
+  // is refused here (the server also checks that a project is registered).
+  const targets = [];
+  const rawTargets = Array.isArray(b.targets) ? b.targets : [];
+  if (rawTargets.length > CREATION_LIMITS.targets) problems.push({ field: 'targets', code: 'targets-many' });
+  rawTargets.slice(0, CREATION_LIMITS.targets).forEach((t, i) => {
+    const at = `targets[${i}]`;
+    if (!isObject(t) || !CREATION_TARGET_RUNTIMES.includes(t.runtime)) { problems.push({ field: `${at}.runtime`, code: 'targets-runtime' }); return; }
+    const scope = t.scope === undefined || t.scope === null || t.scope === '' ? 'user' : t.scope;
+    if (scope !== 'user' && scope !== 'project') { problems.push({ field: `${at}.scope`, code: 'targets-scope' }); return; }
+    if (t.runtime === 'agents' && scope !== 'user') { problems.push({ field: `${at}.scope`, code: 'targets-agents-scope' }); return; }
+    const accountId = t.accountId === undefined || t.accountId === null || t.accountId === '' ? 'default' : t.accountId;
+    if (typeof accountId !== 'string' || !ACCOUNT_RE.test(accountId)) { problems.push({ field: `${at}.accountId`, code: 'targets-account' }); return; }
+    let projectPath = null;
+    if (scope === 'project') {
+      projectPath = str(t.projectPath).trim();
+      const absolute = projectPath.startsWith('/') || /^[A-Za-z]:[\\/]/.test(projectPath);
+      if (!projectPath || !absolute || projectPath.length > CREATION_LIMITS.projectPathChars || /[\u0000-\u001f\u007f]/.test(projectPath)) { problems.push({ field: `${at}.projectPath`, code: 'targets-project' }); return; }
+    }
+    const key = scope === 'project' ? `${t.runtime}:project:${projectPath}` : `${t.runtime}:user:${accountId}`;
+    if (targets.some((x) => x.key === key)) return;
+    targets.push({ key, runtime: t.runtime, scope, accountId, ...(projectPath ? { projectPath } : {}) });
+  });
+  const submit = typeof b.submit === 'boolean' ? b.submit : submitDefault;
+  return {
+    ok: problems.length === 0,
+    request: { prompt, example, name, invocation, sources, target, maxMinutes, budgetUsd: Math.round(budgetUsd * 100) / 100, targets: targets.length ? targets.map(({ key: _k, ...t }) => t) : [{ runtime: 'claude', scope: 'user', accountId: 'default' }], submit },
+    problems,
+  };
+}
+
+/** Where a source came from, in a few words (a chip's label when the request carries none). */
+export function sourceSummary(source) {
+  if (!isObject(source)) return '';
+  if (source.label) return source.label;
+  switch (source.kind) {
+    case 'conversation': return `${source.provider} ${String(source.sessionId || '').slice(0, 8)}`;
+    case 'url': { try { const u = new URL(source.url); return `${u.hostname}${u.pathname === '/' ? '' : u.pathname}`.slice(0, 80); } catch { return String(source.url || '').slice(0, 80); } }
+    case 'repo': { const parts = String(source.project || '').split(/[\\/]/).filter(Boolean); return `${parts[parts.length - 1] || source.project}${source.paths?.length ? ` (${source.paths.length})` : ''}`; }
+    case 'memory': return `“${String(source.query || '').slice(0, 60)}”`;
+    case 'import': return source.stagingId ? 'import' : source.skillId || 'catalog';
+    default: return '';
+  }
+}

package/neural-interface/public/shared/skills/ss-dialog.js

@@ -0,0 +1,130 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio: questions asked inside the panel
+// ═══════════════════════════════════════════
+//
+// The Studio panel is above the page's other layers, so its questions are drawn inside it, over its content:
+// a modal dialog (role alertdialog, aria-modal, labelled by its title and described by its text). While one is
+// open, no key reaches the page under it (taken at the window in the capture phase): Escape answers "cancel"
+// and goes no further (the panel's own Escape, which closes things, never sees it). Inside it a key does what
+// it does where it is (a field, a dropdown) and stops there; Tab stays inside, the arrows move between buttons. A click on the dim area outside answers "cancel" too. One question at a
+// time: a second one gives the first up (it answers null). When it is answered the keyboard goes back to where
+// it was.
+
+const KEY_EVENTS = ['keydown', 'keyup', 'keypress'];
+let _open = null;   // { giveUp }
+
+/** Whether a question is open in a Studio panel now. */
+export const dialogOpen = () => !!_open;
+
+/** Give up the open question (it answers null), if there is one. */
+export function closeDialog() { _open?.giveUp(); }
+
+/**
+ * Ask a question inside the panel.
+ * @param {object} o
+ * @param {HTMLElement} o.host the panel it is drawn in
+ * @param {string} o.title
+ * @param {(string|Node)[]} [o.lines] the text, a paragraph each (a string is text, never markup)
+ * @param {{ id: string, label: string, kind?: 'primary'|'danger'|'plain', disabled?: boolean }[]} o.buttons left to right
+ * @param {string} [o.focus] the button the keyboard starts on (default: the last one that is not danger)
+ * @param {string|null} [o.cancelId] what Escape and a click outside answer; null: they answer null
+ * @param {HTMLElement|null} [o.extra] more content after the text (a checkbox, a list)
+ * @param {(answer: string, ui: object) => boolean} [o.accept] called before the answer is given: false keeps it open
+ * @returns {Promise<string|null>} the id of the button, or `cancelId` / null
+ */
+export function askInPanel({ host, title, lines = [], buttons, focus = null, cancelId = 'cancel', extra = null, accept = null, wide = false }) {
+  return new Promise((resolve) => {
+    _open?.giveUp();
+    const before = document.activeElement;
+    const overlay = document.createElement('div');
+    overlay.className = 'ss-file-dialog-overlay ss-dlg-overlay';
+    const backdrop = document.createElement('div');
+    backdrop.className = 'ss-fd-backdrop';
+    const box = document.createElement('div');
+    box.className = `ss-file-dialog ss-dlg${wide ? ' ss-dlg--wide' : ''}`;
+    const uid = `ss-dlg-${Math.random().toString(36).slice(2, 8)}`;
+    box.setAttribute('role', 'alertdialog');
+    box.setAttribute('aria-modal', 'true');
+    box.setAttribute('aria-labelledby', `${uid}-title`);
+    box.setAttribute('aria-describedby', `${uid}-body`);
+    const head = document.createElement('div');
+    head.className = 'ss-dlg-title';
+    head.id = `${uid}-title`;
+    head.textContent = title;
+    const body = document.createElement('div');
+    body.className = 'ss-dlg-body';
+    body.id = `${uid}-body`;
+    for (const line of lines.filter((l) => l !== null && l !== undefined && l !== '')) {
+      if (typeof line === 'string') { const p = document.createElement('p'); p.textContent = line; body.append(p); }
+      else body.append(line);
+    }
+    if (extra) body.append(extra);
+    const bar = document.createElement('div');
+    bar.className = 'ss-dlg-actions';
+    const byId = new Map();
+    for (const b of buttons) {
+      const node = document.createElement('button');
+      node.type = 'button';
+      node.className = `ss-dlg-btn${b.kind ? ` ss-dlg-btn--${b.kind}` : ''}`;
+      node.textContent = b.label;
+      node.dataset.answer = b.id;
+      if (b.disabled) node.disabled = true;
+      node.addEventListener('click', () => done(b.id));
+      bar.append(node);
+      byId.set(b.id, node);
+    }
+    box.append(head, body, bar);
+    overlay.append(backdrop, box);
+
+    const enabled = () => [...bar.querySelectorAll('button')].filter((b) => !b.disabled);
+    const focusables = () => [...box.querySelectorAll('button:not(:disabled), input:not(:disabled):not([type="hidden"]), textarea:not(:disabled), [tabindex="0"]')];
+    // At the window, before anything: a key meant for the page under the question goes nowhere. Escape answers.
+    const outside = (event) => {
+      if (box.contains(event.target)) return;
+      event.stopPropagation();
+      if (event.type !== 'keydown') return;
+      if (event.key === 'Escape') { event.preventDefault(); done(cancelId); return; }
+      if (event.key === 'Tab') { event.preventDefault(); (focusables()[0])?.focus(); }
+    };
+    // Inside it, a key first does what it does where it is (a field, a dropdown), then stops at the question.
+    const inside = (event) => {
+      event.stopPropagation();
+      if (event.type !== 'keydown' || event.defaultPrevented || event.ctrlKey || event.metaKey || event.altKey) return;
+      if (event.key === 'Escape') { event.preventDefault(); done(cancelId); return; }
+      const list = enabled();
+      const index = list.indexOf(document.activeElement);
+      if ((event.key === 'ArrowRight' || event.key === 'ArrowLeft') && index >= 0) {
+        event.preventDefault();
+        list[(index + (event.key === 'ArrowLeft' ? -1 : 1) + list.length) % list.length]?.focus();
+        return;
+      }
+      if (event.key === 'Tab') {
+        const all = focusables();
+        const at = all.indexOf(document.activeElement);
+        event.preventDefault();
+        all[(at + (event.shiftKey ? -1 : 1) + all.length) % all.length]?.focus();
+      }
+    };
+    for (const type of KEY_EVENTS) box.addEventListener(type, inside);
+    let answered = false;
+    const ui = { box, body, bar, byId, setDisabled: (id, on) => { const n = byId.get(id); if (n) n.disabled = !!on; } };
+    function done(answer, { replaced = false } = {}) {
+      if (answered) return;
+      if (!replaced && answer !== cancelId && answer !== null && typeof accept === 'function' && accept(answer, ui) === false) return;
+      answered = true;
+      if (_open === handle) _open = null;
+      for (const type of KEY_EVENTS) window.removeEventListener(type, outside, true);
+      overlay.remove();
+      if (!replaced && before?.isConnected) before.focus({ preventScroll: true });
+      resolve(answer);
+    }
+    const handle = { giveUp: () => done(null, { replaced: true }) };
+    _open = handle;
+    backdrop.addEventListener('click', () => done(cancelId));
+    for (const type of KEY_EVENTS) window.addEventListener(type, outside, true);
+    host.append(overlay);
+    const start = (focus && byId.get(focus)) || [...buttons].reverse().map((b) => byId.get(b.id)).find((n) => n && !n.disabled && !n.classList.contains('ss-dlg-btn--danger')) || enabled()[0];
+    start?.focus({ preventScroll: true });
+    ui.done = done;
+  });
+}

package/neural-interface/public/shared/skills/ss-doc.js

@@ -0,0 +1,173 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Skills Studio: a file as it is on disk and as it is edited
+// ═══════════════════════════════════════════
+//
+// A <textarea> holds every line break as "\n" and shows a byte-order mark as an invisible first character. A
+// file is edited in that form, and written back as it was: the mark when it had one, and each line that is
+// still there with the line ending it had (a file that mixes CRLF and LF keeps the mix). A line the user wrote
+// takes the ending most of the file uses. Opening a file, switching tabs or saving it unchanged writes nothing
+// new: the bytes that come back are the bytes that were read.
+//
+// Also here: whether bytes are text that can be edited at all (a PNG cannot), and the revision of a text. No
+// DOM and no imports: loaded by `node --test` as it is, and by the server for the text check.
+
+export const BOM = '';
+
+/** The lines of a text with the line break that ends each one ('' for the last). `\r\n`, `\n` and a lone `\r` are breaks. */
+export function splitLines(text) {
+  const s = String(text ?? '');
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 13) {
+      const eol = s.charCodeAt(i + 1) === 10 ? '\r\n' : '\r';
+      lines.push({ text: s.slice(start, i), eol });
+      i += eol.length - 1;
+      start = i + 1;
+    } else if (c === 10) {
+      lines.push({ text: s.slice(start, i), eol: '\n' });
+      start = i + 1;
+    }
+  }
+  lines.push({ text: s.slice(start), eol: '' });
+  return lines;
+}
+
+/** The line ending most lines of a text end with ("\n" when none leads, or there are none). */
+export function dominantEol(lines) {
+  let crlf = 0; let lf = 0; let cr = 0;
+  for (const line of lines) {
+    if (line.eol === '\r\n') crlf++;
+    else if (line.eol === '\n') lf++;
+    else if (line.eol === '\r') cr++;
+  }
+  if (crlf > lf && crlf >= cr) return '\r\n';
+  if (cr > lf && cr > crlf) return '\r';
+  return '\n';
+}
+
+/**
+ * The text as it is edited: no byte-order mark, every line break "\n".
+ * @returns {{ text: string, bom: boolean, eol: '\n' | '\r\n' | '\r', mixed: boolean }}
+ */
+export function toEditing(raw) {
+  const s = String(raw ?? '');
+  const bom = s.charCodeAt(0) === 0xFEFF;
+  const lines = splitLines(bom ? s.slice(1) : s);
+  const kinds = new Set(lines.filter((l) => l.eol).map((l) => l.eol));
+  return { text: lines.map((l) => l.text).join('\n'), bom, eol: dominantEol(lines), mixed: kinds.size > 1 };
+}
+
+/** Whether the edited text is what the file holds (line endings and the byte-order mark aside). */
+export function sameAsSaved(savedRaw, editedText) {
+  return toEditing(savedRaw).text === String(editedText ?? '').replace(/\r\n?/g, '\n');
+}
+
+/** Edits further apart than this many changed lines in the middle of a file get the file's own ending, not each line's. */
+export const MAX_ALIGNED_EDITS = 1000;
+
+/**
+ * The lines two lists have in common, in order (a longest common subsequence, by Myers' algorithm): pairs of
+ * indexes `[i in a, j in b]`. Null when the lists differ by more than `maxEdits` inserted or removed lines.
+ */
+export function commonLines(a, b, maxEdits = MAX_ALIGNED_EDITS) {
+  const n = a.length; const m = b.length;
+  const maxD = Math.min(n + m, maxEdits);
+  const off = maxD + 1;
+  const v = new Int32Array(2 * maxD + 3);
+  const trace = [];   // trace[d]: v for k in [-d-1, d+1] as it was when step d began
+  for (let d = 0; d <= maxD; d++) {
+    trace.push(v.slice(off - d - 1, off + d + 2));
+    for (let k = -d; k <= d; k += 2) {
+      let x = (k === -d || (k !== d && v[off + k - 1] < v[off + k + 1])) ? v[off + k + 1] : v[off + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) { x++; y++; }
+      v[off + k] = x;
+      if (x >= n && y >= m) {
+        // Back through the steps: every diagonal move is a line both lists keep.
+        const kept = [];
+        let cx = n; let cy = m;
+        for (let s = d; s >= 0; s--) {
+          const win = trace[s];
+          const at = (kk) => win[kk + s + 1];
+          const kk = cx - cy;
+          const prevK = (kk === -s || (kk !== s && at(kk - 1) < at(kk + 1))) ? kk + 1 : kk - 1;
+          const px = at(prevK);
+          const py = px - prevK;
+          while (cx > px && cy > py) { kept.push([cx - 1, cy - 1]); cx--; cy--; }
+          if (s > 0) { cx = px; cy = py; }
+        }
+        return kept.reverse();
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * The text to write: the edited text with the file's byte-order mark and line endings put back.
+ * @param {string} savedRaw the file as it was read (or last saved)
+ * @param {string} editedText the editor's text ("\n" line breaks)
+ * @returns {string} exactly `savedRaw` when nothing but line breaks differs
+ */
+export function fromEditing(savedRaw, editedText) {
+  const saved = String(savedRaw ?? '');
+  const edited = String(editedText ?? '').replace(/\r\n?/g, '\n');
+  const bom = saved.charCodeAt(0) === 0xFEFF;
+  const before = splitLines(bom ? saved.slice(1) : saved);
+  const beforeText = before.map((l) => l.text);
+  const after = edited.split('\n');
+  if (beforeText.join('\n') === edited) return saved;
+  const fallback = dominantEol(before);
+  const eols = new Array(after.length).fill(null);
+  // The same lines at the start and at the end keep their endings; what lies between is aligned line by line.
+  let head = 0;
+  const shorter = Math.min(before.length, after.length);
+  while (head < shorter && beforeText[head] === after[head]) { eols[head] = before[head].eol; head++; }
+  let tail = 0;
+  while (tail < shorter - head && beforeText[before.length - 1 - tail] === after[after.length - 1 - tail]) {
+    eols[after.length - 1 - tail] = before[before.length - 1 - tail].eol;
+    tail++;
+  }
+  const midBefore = beforeText.slice(head, before.length - tail);
+  const midAfter = after.slice(head, after.length - tail);
+  if (midBefore.length && midAfter.length) {
+    const kept = commonLines(midBefore, midAfter, MAX_ALIGNED_EDITS);
+    if (kept) for (const [i, j] of kept) eols[head + j] = before[head + i].eol;
+  }
+  const last = after.length - 1;
+  const out = after.map((line, i) => {
+    let eol = eols[i];
+    if (i === last) eol = '';
+    else if (!eol) eol = fallback;   // a new line, or one that was last and is not any more
+    return line + eol;
+  });
+  return (bom ? BOM : '') + out.join('');
+}
+
+// ── Text or not ──
+
+const TEXT_DECODER = typeof TextDecoder === 'function' ? new TextDecoder('utf-8', { fatal: true }) : null;
+
+/**
+ * Whether bytes are text the editor can show and write back unchanged: UTF-8, and no control byte a text file
+ * does not hold (NUL and the like; tab, line breaks, form feed and escape are text). A PNG, a PDF, a font, a
+ * compiled program are not.
+ * @param {Uint8Array} bytes
+ */
+export function isEditableText(bytes) {
+  if (!bytes || typeof bytes.length !== 'number') return false;
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    if (b < 0x09 || (b > 0x0D && b < 0x20 && b !== 0x1B)) return false;
+  }
+  if (!TEXT_DECODER) return true;
+  try { TEXT_DECODER.decode(bytes); return true; } catch { return false; }
+}
+
+/** A string that came back from a server that decoded bytes as UTF-8 without checking: it holds what decoding replaced. */
+export function looksDecodedFromBinary(text) {
+  const s = String(text ?? '');
+  return s.includes('\u0000') || s.includes('�');
+}