@kalada/codemirror 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -1,12 +1,112 @@
 'use strict';
 
-var autocomplete = require('@codemirror/autocomplete');
 var commands = require('@codemirror/commands');
-var lint = require('@codemirror/lint');
 var state = require('@codemirror/state');
 var view = require('@codemirror/view');
+var autocomplete = require('@codemirror/autocomplete');
+var lint = require('@codemirror/lint');
 
-// src/session.ts
+// src/editor-session.ts
+
+// src/editor-presentation.ts
+function editorTooltip(hover, from, to) {
+  return {
+    pos: from,
+    end: to,
+    above: true,
+    create(view) {
+      const document = view.dom.ownerDocument;
+      const dom = document.createElement("section");
+      dom.className = "cm-editor-hover";
+      dom.setAttribute("role", "tooltip");
+      if (typeof hover.content === "string") dom.textContent = hover.content;
+      else for (const section of hover.content) appendSection(document, dom, section);
+      return { dom };
+    }
+  };
+}
+function appendSection(document, dom, section) {
+  const heading = document.createElement("strong");
+  heading.textContent = section.heading;
+  dom.append(heading);
+  const list = document.createElement("ul");
+  for (const text of section.text.length ? section.text : ["None"]) {
+    const item = document.createElement("li");
+    item.textContent = text;
+    list.append(item);
+  }
+  dom.append(list);
+}
+
+// src/editor-requests.ts
+var EditorRequests = class {
+  pending = /* @__PURE__ */ new Map();
+  // Published completion edits remain guarded until supersession, not just settlement.
+  latest = /* @__PURE__ */ new Map();
+  generation = 0;
+  start(kind, snapshot, current, alive) {
+    const previous = this.pending.get(kind);
+    const controller = new AbortController();
+    this.pending.set(kind, controller);
+    this.latest.set(kind, controller);
+    const generation = this.generation;
+    previous?.abort();
+    return {
+      snapshot,
+      signal: controller.signal,
+      settle: () => {
+        if (this.pending.get(kind) === controller) this.pending.delete(kind);
+      },
+      current: () => !controller.signal.aborted && this.latest.get(kind) === controller && generation === this.generation && alive() && sameIdentity(snapshot, current())
+    };
+  }
+  invalidate() {
+    this.generation += 1;
+    const controllers = [...this.pending.values()];
+    this.pending.clear();
+    this.latest.clear();
+    for (const controller of controllers) controller.abort();
+  }
+};
+function sameIdentity(a, b) {
+  return !!a && a.uri === b.uri && a.version === b.version && a.environmentGeneration === b.environmentGeneration;
+}
+function resolveResponse(response, ticket, publish, fallback) {
+  const accept = (result) => {
+    ticket.settle();
+    return result && ticket.current() && sameIdentity(result, ticket.snapshot) ? publish(result) : fallback;
+  };
+  if (response instanceof Promise)
+    return response.then(accept, () => {
+      ticket.settle();
+      return fallback;
+    });
+  return accept(response);
+}
+
+// src/editor-validation.ts
+function validRange(range, text) {
+  return !!range && Number.isSafeInteger(range.from) && Number.isSafeInteger(range.to) && range.from >= 0 && range.to >= range.from && range.to <= text.length && !insidePair(text, range.from) && !insidePair(text, range.to);
+}
+function insidePair(text, offset) {
+  const previous = text.charCodeAt(offset - 1);
+  const next = text.charCodeAt(offset);
+  return previous === 13 && next === 10 || previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343;
+}
+function validEdit(edit, text) {
+  return validRange(edit, text) && typeof edit.text === "string";
+}
+function sourceOffset(doc, separator, offset) {
+  return offset + (doc.lineAt(offset).number - 1) * (separator.length - 1);
+}
+function editorOffset(doc, separator, offset) {
+  for (let number = 1; number <= doc.lines; number += 1) {
+    const line = doc.line(number);
+    const start = line.from + (number - 1) * (separator.length - 1);
+    if (offset <= start + line.length) return line.from + offset - start;
+  }
+  return doc.length;
+}
 function detectLineSeparator(text) {
   if (text.includes("\r\n")) return "\r\n";
   if (text.includes("\r")) return "\r";
@@ -18,9 +118,542 @@ function textForEditor(text) {
 function textFromEditor(document, lineSeparator) {
   return document.sliceString(0, document.length, lineSeparator);
 }
+var setKeyboardTooltip = state.StateEffect.define();
+var keyboardTooltipField = state.StateField.define({
+  create: () => [],
+  update(value, transaction) {
+    let next = transaction.docChanged ? [] : value;
+    for (const effect of transaction.effects) {
+      if (effect.is(setKeyboardTooltip)) next = effect.value ? [effect.value] : [];
+    }
+    return next;
+  },
+  provide: (field) => view.showTooltip.computeN([field], (state) => state.field(field))
+});
+
+// src/editor-tooling.ts
+var EditorTooling = class {
+  requests = new EditorRequests();
+  frame = null;
+  hoverIntent = 0;
+  host;
+  provider;
+  constructor(host, provider = {}) {
+    this.host = host;
+    this.provider = provider;
+  }
+  extension() {
+    return [
+      autocomplete.autocompletion({ override: [(context) => this.complete(context)] }),
+      view.hoverTooltip((view, offset) => this.hover(view, offset)),
+      this.hoverIntentExtension(),
+      keyboardTooltipField,
+      view.keymap.of([
+        ...autocomplete.completionKeymap,
+        { key: "Mod-Shift-h", run: (view) => this.keyboardHover(view) },
+        {
+          key: "Escape",
+          run: (view) => {
+            this.clear(view);
+            view.focus();
+            return true;
+          }
+        }
+      ])
+    ];
+  }
+  hoverIntentExtension() {
+    return view.ViewPlugin.define((view) => {
+      const changed = () => {
+        this.hoverIntent += 1;
+      };
+      const events = ["mousemove", "mouseleave", "pointerdown"];
+      for (const event of events) view.dom.addEventListener(event, changed);
+      return {
+        update: (update) => {
+          if (!update.startState.selection.eq(update.state.selection)) changed();
+        },
+        destroy: () => {
+          for (const event of events) view.dom.removeEventListener(event, changed);
+        }
+      };
+    });
+  }
+  invalidate(view = this.host.view()) {
+    if (this.frame !== null && view)
+      view.dom.ownerDocument.defaultView?.cancelAnimationFrame(this.frame);
+    this.frame = null;
+    this.requests.invalidate();
+  }
+  clear(view$1, diagnostics = false) {
+    this.invalidate();
+    autocomplete.closeCompletion(view$1);
+    const interactions = { effects: [setKeyboardTooltip.of(null), view.closeHoverTooltips] };
+    if (diagnostics) view$1.dispatch(interactions, lint.setDiagnostics(view$1.state, []));
+    else view$1.dispatch(interactions);
+  }
+  schedule(view) {
+    const diagnosticsProvider = this.provider.diagnostics?.bind(this.provider);
+    const window = view.dom.ownerDocument.defaultView;
+    if (!diagnosticsProvider || !window) return;
+    const ticket = this.ticket("diagnostics", view);
+    this.frame = window.requestAnimationFrame(() => {
+      this.frame = null;
+      if (!ticket.current()) return;
+      const response = diagnosticsProvider(ticket);
+      void this.resolve(
+        response,
+        ticket,
+        (result) => {
+          const diagnostics = result.value.filter(
+            (entry) => validRange(entry, ticket.snapshot.text)
+          );
+          view.dispatch(
+            lint.setDiagnostics(
+              view.state,
+              diagnostics.map((entry) => ({
+                ...this.range(view, entry),
+                message: entry.message,
+                severity: entry.severity
+              }))
+            )
+          );
+          return true;
+        },
+        false
+      );
+    });
+  }
+  format() {
+    const view = this.host.view();
+    if (!view || !this.provider.format) return false;
+    const ticket = this.ticket("format", view);
+    return this.resolve(
+      this.provider.format(ticket),
+      ticket,
+      (result, guarded) => this.apply(view, result.value, guarded),
+      false
+    );
+  }
+  complete(context) {
+    const view = this.host.view();
+    if (!view || view.state !== context.state || !this.provider.completion) return null;
+    const ticket = this.ticket("completion", view);
+    const offset = sourceOffset(view.state.doc, view.state.lineBreak, context.pos);
+    return this.resolve(
+      this.provider.completion(ticket, offset),
+      ticket,
+      (result, guarded) => {
+        const entries = result.value.filter((item) => validEdit(item.edit, ticket.snapshot.text));
+        const first = entries[0];
+        if (!first) return null;
+        return {
+          ...this.range(view, first.edit),
+          filter: this.host.filterCompletions ?? false,
+          options: entries.map((item) => this.option(view, item, guarded))
+        };
+      },
+      null
+    );
+  }
+  option(view, item, ticket) {
+    return {
+      label: item.label,
+      type: item.type,
+      detail: item.detail,
+      boost: item.boost,
+      apply: (target) => {
+        if (target === view) this.apply(target, item.edit, ticket);
+      }
+    };
+  }
+  apply(view, edit, ticket) {
+    if (!ticket.current() || !validEdit(edit, ticket.snapshot.text)) return false;
+    view.dispatch({
+      changes: { ...this.range(view, edit), insert: textForEditor(edit.text) },
+      annotations: state.Transaction.addToHistory.of(true)
+    });
+    return true;
+  }
+  hover(view, offset, publish) {
+    if (this.host.view() !== view || !this.provider.hover) return null;
+    const intent = this.hoverIntent;
+    const selection = view.state.selection;
+    const request = this.ticket("hover", view);
+    const ticket = {
+      ...request,
+      current: () => request.current() && intent === this.hoverIntent && selection.eq(view.state.selection)
+    };
+    const source = sourceOffset(view.state.doc, view.state.lineBreak, offset);
+    return this.resolve(
+      this.provider.hover(ticket, source),
+      ticket,
+      (result, guarded) => {
+        if (!validRange(result.value, ticket.snapshot.text)) return null;
+        const range = this.range(view, result.value);
+        const tooltip = (this.host.renderHover ?? editorTooltip)(
+          result.value,
+          range.from,
+          range.to
+        );
+        if (!guarded.current()) return null;
+        publish?.(tooltip);
+        return tooltip;
+      },
+      null
+    );
+  }
+  keyboardHover(view) {
+    const tooltip = this.hover(
+      view,
+      view.state.selection.main.head,
+      (value) => view.dispatch({ effects: setKeyboardTooltip.of(value) })
+    );
+    return tooltip instanceof Promise || tooltip !== null;
+  }
+  ticket(kind, view) {
+    return this.requests.start(
+      kind,
+      this.host.snapshot(),
+      () => this.host.snapshot(),
+      () => this.host.view() === view
+    );
+  }
+  resolve(response, ticket, publish, fallback) {
+    return resolveResponse(
+      response,
+      ticket,
+      (result) => {
+        const guarded = {
+          ...ticket,
+          current: () => ticket.current() && (this.host.isCurrent?.(result) ?? true)
+        };
+        return guarded.current() ? publish(result, guarded) : fallback;
+      },
+      fallback
+    );
+  }
+  range(view, range) {
+    return {
+      from: editorOffset(view.state.doc, view.state.lineBreak, range.from),
+      to: editorOffset(view.state.doc, view.state.lineBreak, range.to)
+    };
+  }
+};
+
+// src/editor-session.ts
+var NeutralEditorSession = class {
+  extension;
+  snapshot;
+  attached = null;
+  disposed = false;
+  failed = false;
+  failureView = null;
+  notifications = [];
+  publishingChanges = false;
+  changing = 0;
+  separator = new state.Compartment();
+  tooling;
+  options;
+  bridge;
+  constructor(options, bridge = {}) {
+    this.options = options;
+    this.bridge = bridge;
+    const document = options.document;
+    if (typeof document.text !== "string" || typeof document.uri !== "string" || document.uri.length === 0 || !Number.isSafeInteger(document.version) || document.version < 0)
+      throw new TypeError("Invalid editor document");
+    this.snapshot = Object.freeze({ ...document, environmentGeneration: 0 });
+    this.tooling = new EditorTooling(
+      {
+        snapshot: () => this.snapshot,
+        view: () => this.disposed || this.failed ? null : this.attached,
+        renderHover: bridge.renderHover,
+        isCurrent: bridge.isCurrent,
+        filterCompletions: bridge.filterCompletions
+      },
+      options.provider
+    );
+    this.extension = this.createExtension();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  refreshEnvironment() {
+    this.assertOpen();
+    if (this.snapshot.environmentGeneration >= Number.MAX_SAFE_INTEGER)
+      throw new RangeError("Editor environment generation exhausted");
+    this.snapshot = Object.freeze({
+      ...this.snapshot,
+      environmentGeneration: this.snapshot.environmentGeneration + 1
+    });
+    if (!this.attached) {
+      this.tooling.invalidate();
+      return;
+    }
+    this.tooling.clear(this.attached, true);
+    this.tooling.schedule(this.attached);
+  }
+  replaceDocument(text) {
+    this.assertOpen();
+    if (typeof text !== "string") throw new TypeError("Replacement text must be a string");
+    const view = this.attached;
+    if (!view) {
+      this.changed(text);
+      return;
+    }
+    const separator = detectLineSeparator(text);
+    view.dispatch({
+      changes: { from: 0, to: view.state.doc.length, insert: textForEditor(text) },
+      selection: state.EditorSelection.cursor(0),
+      annotations: state.Transaction.addToHistory.of(true),
+      effects: separator === view.state.lineBreak ? void 0 : this.separator.reconfigure(state.EditorState.lineSeparator.of(separator))
+    });
+  }
+  format() {
+    this.assertOpen();
+    return this.tooling.format();
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.tooling.invalidate(this.attached);
+    if (this.attached && !this.failed) this.tooling.clear(this.attached, true);
+    this.attached = null;
+  }
+  createExtension() {
+    const session = this;
+    return [
+      view.ViewPlugin.define((view) => {
+        this.attach(view);
+        return {
+          update: (update) => this.update(update),
+          destroy: () => this.detach(view)
+        };
+      }),
+      // Provider callbacks may dispatch; run them only after CodeMirror leaves its update phase.
+      view.EditorView.updateListener.of(() => {
+        this.publishChanges();
+        this.cleanupFailure();
+      }),
+      this.separator.of({
+        // Resolve when CodeMirror builds a state, including reuse of a cached extension.
+        get extension() {
+          return state.EditorState.lineSeparator.of(detectLineSeparator(session.snapshot.text));
+        }
+      }),
+      commands.history(),
+      this.tooling.extension(),
+      view.keymap.of(commands.historyKeymap),
+      view.EditorView.contentAttributes.of({ "aria-label": this.options.ariaLabel ?? "Source editor" }),
+      this.options.extensions ?? []
+    ];
+  }
+  attach(view) {
+    this.assertOpen();
+    if (this.attached && this.attached !== view)
+      throw new Error("Editor session already has a view");
+    if (textFromEditor(view.state.doc, view.state.lineBreak) !== this.snapshot.text)
+      throw new Error("CodeMirror document does not match the opened document");
+    this.attached = view;
+    this.tooling.schedule(view);
+  }
+  detach(view) {
+    if (this.attached !== view) return;
+    this.attached = null;
+    this.tooling.invalidate(view);
+  }
+  update(update) {
+    if (this.disposed || this.failed || !update.docChanged) return;
+    try {
+      this.updateTransactions(update);
+    } catch (error) {
+      this.fail(update.view);
+      throw error;
+    }
+  }
+  updateTransactions(update) {
+    for (const transaction of update.transactions) {
+      if (!transaction.docChanged) continue;
+      if (textFromEditor(transaction.startState.doc, transaction.startState.lineBreak) !== this.snapshot.text)
+        throw new Error("CodeMirror and editor snapshots diverged");
+      this.changed(textFromEditor(transaction.newDoc, transaction.state.lineBreak), transaction);
+    }
+  }
+  changed(text, transaction) {
+    if (this.snapshot.version >= Number.MAX_SAFE_INTEGER)
+      throw new RangeError("Editor document revision exhausted");
+    const previous = this.snapshot;
+    const snapshot = Object.freeze({ ...previous, version: previous.version + 1, text });
+    this.snapshot = snapshot;
+    this.notifications.push(snapshot);
+    this.changing += 1;
+    let failed = false;
+    let failure;
+    try {
+      this.bridge.changed?.(snapshot, previous, transaction);
+    } catch (error) {
+      this.notifications = this.notifications.filter((pending) => pending !== snapshot);
+      this.reconcileFailure(snapshot, previous, !!transaction);
+      failed = true;
+      failure = error;
+    } finally {
+      this.changing -= 1;
+    }
+    try {
+      if (!transaction) this.publishChanges();
+    } catch (error) {
+      if (!failed) throw error;
+    }
+    if (failed) throw failure;
+  }
+  publishChanges() {
+    if (this.changing || this.publishingChanges || !this.notifications.length) return;
+    this.publishingChanges = true;
+    try {
+      while (this.notifications.length) {
+        const notifications = this.notifications;
+        this.notifications = [];
+        this.tooling.invalidate();
+        for (const snapshot of notifications) this.notifyChange(snapshot);
+      }
+    } finally {
+      this.publishingChanges = false;
+    }
+    if (!this.disposed && !this.failed && this.attached) this.tooling.schedule(this.attached);
+  }
+  reconcileFailure(attempt, previous, attached) {
+    if (attached) {
+      this.fail(this.attached);
+      return;
+    }
+    try {
+      if (this.bridge.matches?.(this.snapshot)) return;
+      if (this.snapshot === attempt && this.bridge.matches?.(previous)) {
+        this.snapshot = previous;
+        this.tooling.invalidate();
+        return;
+      }
+    } catch {
+    }
+    this.fail(null);
+    this.notifications = [];
+  }
+  fail(view) {
+    this.failed = true;
+    this.failureView = view;
+    this.tooling.invalidate(view);
+  }
+  cleanupFailure() {
+    const view = this.failureView;
+    this.failureView = null;
+    if (view) this.tooling.clear(view, true);
+  }
+  notifyChange(snapshot) {
+    try {
+      this.options.onDocumentChange?.(snapshot);
+    } catch {
+    }
+  }
+  assertOpen() {
+    if (this.disposed) throw new Error("Editor session is disposed");
+    if (this.failed) throw new Error("Editor session has failed");
+  }
+};
+
+// src/kalada-provider.ts
+var KaladaProvider = class {
+  service;
+  uri;
+  hovers = /* @__PURE__ */ new WeakMap();
+  identities = /* @__PURE__ */ new WeakMap();
+  constructor(service, uri) {
+    this.service = service;
+    this.uri = uri;
+  }
+  isCurrent(identity) {
+    const original = this.identities.get(identity);
+    return !!original && this.service.isCurrent(original);
+  }
+  diagnostics(request) {
+    const result = this.service.diagnostics(this.uri, cancellation(request));
+    if (result.kind !== "diagnostics" || !this.service.isCurrent(result)) return null;
+    return this.tagged(
+      request,
+      result,
+      result.diagnostics.map((item) => ({
+        ...item.source ? this.range(item.source.range) : { from: 0, to: 0 },
+        message: item.message,
+        severity: "error"
+      }))
+    );
+  }
+  completion(request, offset) {
+    const result = this.service.completion(
+      this.uri,
+      this.document().lineIndex.positionAt(offset),
+      cancellation(request)
+    );
+    if (result.kind !== "completion" || !this.service.isCurrent(result)) return null;
+    return this.tagged(
+      request,
+      result,
+      result.items.map((item) => ({
+        label: item.label,
+        edit: { ...this.range(item.edit.range), text: item.edit.text },
+        type: item.kind === "binding" ? "variable" : item.kind,
+        detail: `${item.support}, ${item.presence}`,
+        boost: item.support === "common" ? 10 : 0
+      }))
+    );
+  }
+  hover(request, offset) {
+    const result = this.service.hover(
+      this.uri,
+      this.document().lineIndex.positionAt(offset),
+      cancellation(request)
+    );
+    if (result.kind !== "hover" || !result.hover || !this.service.isCurrent(result)) return null;
+    const hover = { ...this.range(result.hover.range), content: "" };
+    this.hovers.set(hover, result.hover);
+    return this.tagged(request, result, hover);
+  }
+  format(request) {
+    const result = this.service.format(this.uri, cancellation(request));
+    if (result.kind !== "format" || !result.edit || !this.service.isCurrent(result)) return null;
+    return this.tagged(request, result, {
+      ...this.range(result.edit.range),
+      text: result.edit.text
+    });
+  }
+  tagged(request, original, value) {
+    const result = {
+      uri: this.uri,
+      version: request.snapshot.version,
+      environmentGeneration: request.snapshot.environmentGeneration,
+      value
+    };
+    this.identities.set(result, original);
+    return result;
+  }
+  range(source) {
+    const document = this.document();
+    return {
+      from: document.lineIndex.offsetAt(source.start),
+      to: document.lineIndex.offsetAt(source.end)
+    };
+  }
+  document() {
+    const document = this.service.getDocument(this.uri);
+    if (!document) throw new Error("Kalada editor document is not open");
+    return document;
+  }
+};
+function cancellation(request) {
+  return { cancellation: { isCancellationRequested: () => request.signal.aborted } };
+}
 
 // src/render.ts
-function hoverTooltip(info, position) {
+function hoverTooltip2(info, position) {
   return {
     pos: position,
     above: true,
@@ -30,15 +663,15 @@ function hoverTooltip(info, position) {
       dom.className = "cm-kalada-hover";
       dom.setAttribute("role", "tooltip");
       dom.setAttribute("aria-label", "Kalada expression information");
-      appendSection(document, dom, "Input editor shape", info.input.map(shapeText));
-      appendSection(document, dom, "Output Kalada semantic projection", [semanticText(info)]);
-      appendSection(document, dom, "Presence / branch conditions", [accessText(info)]);
-      appendSection(document, dom, "Limit/unknown evidence", info.evidence.map(evidenceText));
+      appendSection2(document, dom, "Input editor shape", info.input.map(shapeText));
+      appendSection2(document, dom, "Output Kalada semantic projection", [semanticText(info)]);
+      appendSection2(document, dom, "Presence / branch conditions", [accessText(info)]);
+      appendSection2(document, dom, "Limit/unknown evidence", info.evidence.map(evidenceText));
       return { dom };
     }
   };
 }
-function appendSection(document, parent, heading, values) {
+function appendSection2(document, parent, heading, values) {
   const title = document.createElement("strong");
   title.textContent = heading;
   parent.append(title);
@@ -68,6 +701,17 @@ function evidenceText(evidence) {
   return `${evidence.code} at ${evidence.path.join(".") || "root"}`;
 }
 
+// src/session-helpers.ts
+function wholeReplacement(snapshot, text) {
+  return {
+    range: {
+      start: { line: 0, character: 0 },
+      end: snapshot.lineIndex.positionAt(snapshot.text.length)
+    },
+    text
+  };
+}
+
 // src/translation.ts
 function changesToEdits(startDoc, newDoc, changes, snapshot, lineSeparator = "\n") {
   const offsets = [];
@@ -83,14 +727,6 @@ function changesToEdits(startDoc, newDoc, changes, snapshot, lineSeparator = "\n
   if (translated.every((edit) => edit !== null)) return translated;
   return [wholeDocumentEdit(snapshot, newDoc.sliceString(0, newDoc.length, lineSeparator))];
 }
-function rangeToOffsets(document, range) {
-  const from = offsetAt(document, range.start.line, range.start.character);
-  const to = offsetAt(document, range.end.line, range.end.character);
-  return from === null || to === null || from > to ? null : { from, to };
-}
-function diagnosticOffsets(document, range) {
-  return rangeToOffsets(document, range) ?? { from: 0, to: 0 };
-}
 function offsetEdit(edit, document, index) {
   const start = positionAt(document, edit.from);
   const end = positionAt(document, edit.to);
@@ -101,14 +737,6 @@ function positionAt(document, offset) {
   const line = document.lineAt(offset);
   return { line: line.number - 1, character: offset - line.from };
 }
-function offsetAt(document, line, character) {
-  if (!Number.isSafeInteger(line) || !Number.isSafeInteger(character) || line < 0 || character < 0) {
-    return null;
-  }
-  if (line >= document.lines) return null;
-  const found = document.line(line + 1);
-  return character <= found.length ? found.from + character : null;
-}
 function coalesceInserts(edits) {
   const output = [];
   for (const edit of edits) {
@@ -129,345 +757,76 @@ function wholeDocumentEdit(snapshot, text) {
   };
 }
 
-// src/session-helpers.ts
-function positionAt2(document, offset) {
-  const line = document.lineAt(offset);
-  return { line: line.number - 1, character: offset - line.from };
-}
-function translatedTooltip(result, view) {
-  const range = result.hover ? rangeToOffsets(view.state.doc, result.hover.range) : null;
-  if (!range || !result.hover) return null;
-  return { ...hoverTooltip(result.hover, range.from), end: range.to };
-}
-function translateDiagnostic(diagnostic, view) {
-  const range = diagnostic.source ? diagnosticOffsets(view.state.doc, diagnostic.source.range) : { from: 0, to: 0 };
-  return { ...range, severity: "error", message: diagnostic.message };
-}
-function animationWindow(view) {
-  const window = view.dom.ownerDocument.defaultView;
-  if (!window) throw new Error("CodeMirror view has no window");
-  return window;
-}
-function wholeReplacement(snapshot, text) {
+// src/session.ts
+function createKaladaEditorSession(options) {
+  const { service } = options;
+  const opened = service.openDocument(options.document);
+  let disposed = false;
+  const provider = new KaladaProvider(service, opened.uri);
+  const committed = /* @__PURE__ */ new WeakMap();
+  const core = new NeutralEditorSession(
+    {
+      document: opened,
+      ariaLabel: "Kalada expression editor",
+      provider,
+      onDocumentChange: (identity) => {
+        const snapshot = committed.get(identity);
+        if (snapshot) options.onDocumentChange?.(snapshot);
+      }
+    },
+    kaladaBridge(provider, (identity, snapshot) => committed.set(identity, snapshot))
+  );
   return {
-    range: {
-      start: { line: 0, character: 0 },
-      end: snapshot.lineIndex.positionAt(snapshot.text.length)
+    extension: core.extension,
+    refreshEnvironment: () => core.refreshEnvironment(),
+    replaceDocument: (text) => core.replaceDocument(text),
+    format() {
+      const formatted = core.format();
+      if (typeof formatted !== "boolean") throw new Error("Kalada formatting must be synchronous");
+      return formatted;
     },
-    text
-  };
-}
-var setKeyboardTooltip = state.StateEffect.define();
-var keyboardTooltipField = state.StateField.define({
-  create: () => [],
-  update(value, transaction) {
-    let next = value;
-    for (const effect of transaction.effects) {
-      if (effect.is(setKeyboardTooltip)) next = effect.value ? [effect.value] : [];
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      core.dispose();
+      service.closeDocument(opened.uri);
     }
-    return next;
-  },
-  provide: (field) => view.showTooltip.computeN([field], (state) => state.field(field))
-});
-
-// src/session.ts
-function createKaladaEditorSession(options) {
-  return new EditorSession(options);
+  };
 }
-var EditorSession = class {
-  extension;
-  service;
-  uri;
-  onDocumentChange;
-  lineSeparator = new state.Compartment();
-  view = null;
-  expectedText;
-  revision;
-  disposed = false;
-  viewEpoch = 0;
-  completionEpoch = 0;
-  hoverEpoch = 0;
-  diagnosticsEpoch = 0;
-  diagnosticsFrame = null;
-  constructor(options) {
-    this.service = options.service;
-    this.uri = options.document.uri;
-    this.onDocumentChange = options.onDocumentChange;
-    const opened = this.service.openDocument(options.document);
-    this.expectedText = opened.text;
-    this.revision = opened.version;
-    this.extension = this.createExtension();
-  }
-  refreshEnvironment() {
-    this.assertOpen();
-    this.invalidateRequests();
-    const view = this.view;
-    if (!view) return;
-    this.clearEditor(view, false);
-    this.scheduleDiagnostics(view);
-  }
-  replaceDocument(text) {
-    this.assertOpen();
-    if (typeof text !== "string") throw new TypeError("Replacement text must be a string");
-    const view = this.view;
-    if (view) {
-      const separator = detectLineSeparator(text);
-      view.dispatch({
-        changes: { from: 0, to: view.state.doc.length, insert: textForEditor(text) },
-        selection: state.EditorSelection.cursor(0),
-        annotations: state.Transaction.addToHistory.of(true),
-        effects: separator === view.state.lineBreak ? void 0 : this.lineSeparator.reconfigure(state.EditorState.lineSeparator.of(separator))
-      });
-      return;
-    }
-    const current = this.requireDocument();
-    const snapshot = this.service.updateDocument({
-      uri: this.uri,
-      version: this.nextRevision(),
-      edits: [wholeReplacement(current, text)]
-    });
-    this.expectedText = snapshot.text;
-    this.invalidateRequests();
-    this.notify(snapshot);
-  }
-  format() {
-    this.assertOpen();
-    const view = this.view;
-    if (!view) return false;
-    const epoch = this.completionEpoch;
-    const result = this.service.format(this.uri, {
-      cancellation: this.cancellation("completion", epoch)
-    });
-    if (result.kind !== "format" || !result.edit || !this.publishable(result, view, epoch, "completion")) {
-      return false;
-    }
-    const range = rangeToOffsets(view.state.doc, result.edit.range);
-    if (!range) return false;
-    view.dispatch({
-      changes: { ...range, insert: textForEditor(result.edit.text) },
-      annotations: state.Transaction.addToHistory.of(true)
-    });
-    return true;
-  }
-  dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.invalidateRequests();
-    this.cancelDiagnosticsFrame();
-    const view = this.view;
-    if (view) this.clearEditor(view, true);
-    this.view = null;
-    this.service.closeDocument(this.uri);
-  }
-  createExtension() {
-    const session = this;
-    const lifecycle = view.ViewPlugin.define((view) => {
-      session.attach(view);
-      return {
-        update(update) {
-          session.updateView(update);
-        },
-        destroy() {
-          session.detach(view);
-        }
-      };
-    });
-    return [
-      lifecycle,
-      this.lineSeparator.of(state.EditorState.lineSeparator.of(detectLineSeparator(this.expectedText))),
-      commands.history(),
-      autocomplete.autocompletion({ override: [(context) => this.complete(context)] }),
-      view.hoverTooltip((view, position) => this.pointerHover(view, position)),
-      keyboardTooltipField,
-      view.keymap.of([
-        ...autocomplete.completionKeymap,
-        ...commands.historyKeymap,
-        { key: "Mod-Shift-h", run: (view) => this.keyboardHover(view) },
-        { key: "Escape", run: (view) => this.clearInteractions(view) }
-      ]),
-      view.EditorView.contentAttributes.of({ "aria-label": "Kalada expression editor" })
-    ];
-  }
-  attach(view) {
-    this.assertOpen();
-    if (this.view && this.view !== view)
-      throw new Error("Kalada editor session already has a view");
-    if (textFromEditor(view.state.doc, view.state.lineBreak) !== this.expectedText) {
-      throw new Error("CodeMirror document does not match the opened Kalada document");
-    }
-    this.view = view;
-    this.viewEpoch += 1;
-    this.scheduleDiagnostics(view);
-  }
-  detach(view) {
-    if (this.view !== view) return;
-    this.cancelDiagnosticsFrame();
-    this.invalidateRequests();
-    this.view = null;
-    this.viewEpoch += 1;
-  }
-  updateView(update) {
-    if (this.disposed || !update.docChanged) return;
-    this.invalidateRequests();
-    for (const transaction of update.transactions) {
-      if (transaction.docChanged) this.applyTransaction(transaction);
-    }
-    this.expectedText = textFromEditor(update.state.doc, update.state.lineBreak);
-    this.scheduleDiagnostics(update.view);
-  }
-  applyTransaction(transaction) {
-    const current = this.requireDocument();
-    const startText = textFromEditor(transaction.startState.doc, transaction.startState.lineBreak);
-    if (current.text !== startText) {
-      throw new Error("CodeMirror and language-service snapshots diverged");
-    }
-    const edits = changesToEdits(
-      transaction.startState.doc,
-      transaction.newDoc,
-      transaction.changes,
-      current,
-      transaction.state.lineBreak
-    );
-    const snapshot = this.service.updateDocument({
-      uri: this.uri,
-      version: this.nextRevision(),
-      edits
-    });
-    if (snapshot.text !== textFromEditor(transaction.newDoc, transaction.state.lineBreak)) {
-      throw new Error("CodeMirror transaction translation changed document text");
-    }
-    this.expectedText = snapshot.text;
-    this.notify(snapshot);
-  }
-  complete(context) {
-    const view = this.view;
-    if (!view || view.state !== context.state || this.disposed) return null;
-    const epoch = ++this.completionEpoch;
-    const result = this.service.completion(this.uri, positionAt2(context.state.doc, context.pos), {
-      cancellation: this.cancellation("completion", epoch)
-    });
-    if (result.kind !== "completion" || !this.publishable(result, view, epoch, "completion")) {
-      return null;
-    }
-    const translated = result.items.map(
-      (item) => this.translateCompletion(item, result, view, epoch)
-    );
-    const available = translated.filter((entry) => entry !== null);
-    const first = available[0];
-    return first ? { from: first.from, to: first.to, options: available.map(({ option }) => option) } : null;
-  }
-  translateCompletion(item, identity, view, epoch) {
-    const range = rangeToOffsets(view.state.doc, item.edit.range);
-    if (!range) return null;
-    const option = {
-      label: item.label,
-      type: item.kind === "binding" ? "variable" : item.kind,
-      detail: `${item.support}, ${item.presence}`,
-      boost: item.support === "common" ? 10 : 0,
-      apply: (target) => this.applyCompletion(target, item, identity, epoch)
-    };
-    return { ...range, option };
-  }
-  applyCompletion(view, item, identity, epoch) {
-    if (!this.publishable(identity, view, epoch, "completion")) return;
-    const range = rangeToOffsets(view.state.doc, item.edit.range);
-    if (!range) return;
-    view.dispatch({ changes: { ...range, insert: item.edit.text } });
-  }
-  pointerHover(view, offset) {
-    return this.requestHover(view, offset);
-  }
-  keyboardHover(view) {
-    const tooltip = this.requestHover(view, view.state.selection.main.head);
-    if (!tooltip) return false;
-    view.dispatch({ effects: setKeyboardTooltip.of(tooltip) });
-    return true;
-  }
-  requestHover(view, offset) {
-    const epoch = ++this.hoverEpoch;
-    const result = this.service.hover(this.uri, positionAt2(view.state.doc, offset), {
-      cancellation: this.cancellation("hover", epoch)
-    });
-    if (result.kind !== "hover" || !result.hover || !this.publishable(result, view, epoch, "hover")) {
-      return null;
-    }
-    return translatedTooltip(result, view);
-  }
-  clearInteractions(view) {
-    this.clearEditor(view, false);
-    view.focus();
-    return true;
-  }
-  clearEditor(view$1, diagnostics) {
-    autocomplete.closeCompletion(view$1);
-    const interactions = { effects: [setKeyboardTooltip.of(null), view.closeHoverTooltips] };
-    if (diagnostics) view$1.dispatch(interactions, lint.setDiagnostics(view$1.state, []));
-    else view$1.dispatch(interactions);
-  }
-  scheduleDiagnostics(view) {
-    this.cancelDiagnosticsFrame();
-    const epoch = ++this.diagnosticsEpoch;
-    const viewEpoch = this.viewEpoch;
-    this.diagnosticsFrame = animationWindow(view).requestAnimationFrame(() => {
-      this.diagnosticsFrame = null;
-      const result = this.service.diagnostics(this.uri, {
-        cancellation: this.cancellation("diagnostics", epoch)
+function kaladaBridge(provider, committed) {
+  return {
+    filterCompletions: true,
+    isCurrent: (identity) => provider.isCurrent(identity),
+    matches(snapshot) {
+      const current = provider.service.getDocument(provider.uri);
+      return !!current && current.uri === snapshot.uri && current.version === snapshot.version && current.text === snapshot.text;
+    },
+    changed(snapshot, previous, transaction) {
+      const current = provider.service.getDocument(provider.uri);
+      if (!current || current.text !== previous.text || current.version !== previous.version)
+        throw new Error("CodeMirror and language-service snapshots diverged");
+      const updated = provider.service.updateDocument({
+        uri: provider.uri,
+        version: snapshot.version,
+        edits: transaction ? changesToEdits(
+          transaction.startState.doc,
+          transaction.newDoc,
+          transaction.changes,
+          current,
+          transaction.state.lineBreak
+        ) : [wholeReplacement(current, snapshot.text)]
       });
-      if (result.kind !== "diagnostics" || !this.publishable(result, view, epoch, "diagnostics"))
-        return;
-      if (this.viewEpoch !== viewEpoch) return;
-      view.dispatch(
-        lint.setDiagnostics(
-          view.state,
-          result.diagnostics.map((entry) => translateDiagnostic(entry, view))
-        )
-      );
-    });
-  }
-  cancelDiagnosticsFrame() {
-    if (this.diagnosticsFrame === null || !this.view) return;
-    animationWindow(this.view).cancelAnimationFrame(this.diagnosticsFrame);
-    this.diagnosticsFrame = null;
-  }
-  cancellation(kind, epoch) {
-    return {
-      isCancellationRequested: () => this.disposed || this.epoch(kind) !== epoch
-    };
-  }
-  publishable(identity, view, epoch, kind) {
-    return !this.disposed && this.view === view && this.epoch(kind) === epoch && "status" in identity && identity.status === "current" && this.service.isCurrent(identity);
-  }
-  epoch(kind) {
-    if (kind === "completion") return this.completionEpoch;
-    if (kind === "hover") return this.hoverEpoch;
-    return this.diagnosticsEpoch;
-  }
-  invalidateRequests() {
-    this.completionEpoch += 1;
-    this.hoverEpoch += 1;
-    this.diagnosticsEpoch += 1;
-  }
-  nextRevision() {
-    if (this.revision >= Number.MAX_SAFE_INTEGER)
-      throw new RangeError("Kalada document revision exhausted");
-    this.revision += 1;
-    return this.revision;
-  }
-  requireDocument() {
-    const document = this.service.getDocument(this.uri);
-    if (!document) throw new Error("Kalada editor document is not open");
-    return document;
-  }
-  notify(snapshot) {
-    try {
-      this.onDocumentChange?.(snapshot);
-    } catch {
+      if (updated.text !== snapshot.text)
+        throw new Error("CodeMirror transaction translation changed document text");
+      committed(snapshot, updated);
+    },
+    renderHover(hover, from, to) {
+      const info = provider.hovers.get(hover);
+      if (!info) throw new Error("Missing Kalada hover presentation");
+      return { ...hoverTooltip2(info, from), end: to };
     }
-  }
-  assertOpen() {
-    if (this.disposed) throw new Error("Kalada editor session is disposed");
-  }
-};
+  };
+}
 
 exports.createKaladaEditorSession = createKaladaEditorSession;
 //# sourceMappingURL=index.cjs.map