@kalada/codemirror 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @kalada/codemirror
 
-Thin CodeMirror 6 lifecycle and protocol translation for `@kalada/language-service`.
+Reusable CodeMirror 6 lifecycle and tooling integration, with a backward-compatible Kalada facade.
 
 ```ts
 const session = createKaladaEditorSession({
@@ -15,6 +15,131 @@ including undo and redo, become monotonic language-service revisions. `replaceDo
 `refreshEnvironment`, and `dispose` preserve request identity and stale/cancellation checks. Dispose is
 idempotent; destroying a view detaches it without closing the session.
 
+### Kalada bridge failures
+
+The bridge assumes exclusive ownership of its URI and a truthful, synchronous `getDocument`.
+If a detached update throws, it rethrows the original error and does not notify for that attempt.
+When the service still exactly matches the previous URI/version/text and no neutral snapshot change
+intervened, the provisional snapshot is restored. When the service matches the latest neutral snapshot
+(including committed nested edits), that state remains usable. Successful descendants retain FIFO
+notifications with their exact historical service snapshots. Unmatched or unobservable state makes
+the session terminally failed; intervening environment refreshes or edits are never rolled back.
+
+An attached bridge exception is always terminal, even after a service commit: CodeMirror cannot undo
+its view update and may disable the throwing plugin. The original exception is reported through
+CodeMirror's exception sink (`EditorView.exceptionSink`); `view.dispatch` need not throw. Subsequent
+replacement, formatting, environment refresh and attachment explicitly fail. Tooling is invalidated
+without dispatch inside the plugin update; presentation cleanup runs after the update boundary.
+Earlier successful transactions in a batch still notify, but the failed and later transactions do not.
+No further service synchronization or tooling publication occurs, and disposal remains idempotent.
+There is no retry, compensating update, or close/reopen recovery. Arbitrary lying/proxy services and
+transactional redesign are outside this bounded contract.
+
 CodeMirror packages are peers so consumers use one set of state classes. This package has no parser,
 schema traversal, inference, evaluation, filesystem, or network behavior. Tooltips use DOM text nodes,
 and the extension includes keyboard completion, keyboard hover, Escape handling, and accessible labels.
+
+## Language-neutral entry point
+
+```ts
+import { createEditorSession, type EditorProvider } from "@kalada/codemirror/editor";
+import { EditorView } from "@codemirror/view";
+
+// Independent color fixture: no Kalada language-service contracts.
+const provider: EditorProvider = {
+  diagnostics: ({ snapshot }) => ({
+    ...snapshot,
+    value: snapshot.text === "red" ? [] : [
+      { from: 0, to: snapshot.text.length, severity: "warning", message: "Expected red" },
+    ],
+  }),
+  completion: ({ snapshot }) => ({
+    ...snapshot,
+    value: [{ label: "red", edit: { from: 0, to: snapshot.text.length, text: "red" } }],
+  }),
+  hover: ({ snapshot }) => ({
+    ...snapshot, value: { from: 0, to: snapshot.text.length, content: "A color" },
+  }),
+  format: ({ snapshot }) => ({
+    ...snapshot, value: { from: 0, to: snapshot.text.length, text: snapshot.text.trim() },
+  }),
+};
+const session = createEditorSession({
+  document: { uri: "memory:///color.txt", version: 1, text: "red" }, provider,
+  ariaLabel: "Color source", onDocumentChange: (snapshot) => console.log(snapshot.text),
+});
+const view = new EditorView({ doc: session.getSnapshot().text, extensions: session.extension, parent });
+const didFormat = await session.format();
+```
+
+`EditorSessionOptions` accepts `document`, optional `provider`, `ariaLabel`, presentation `extensions`,
+and `onDocumentChange`. `EditorSession` exposes `extension`, `getSnapshot`, `replaceDocument`,
+`refreshEnvironment`, `format`, and `dispose`. Each provider capability is optional; no provider is
+required for editing/history. Neutral sessions own their snapshots, not a compiler's open-document store.
+The Kalada facade still owns its language-service URI, callback snapshots and synchronous `format(): boolean`.
+
+Providers receive `{ snapshot, signal }` plus a source offset for completion/hover. Return `null` or
+`{ uri, version, environmentGeneration, value }`, synchronously or as a native Promise. Tag results
+with the **captured request snapshot**, never a later snapshot. `format()` returns `boolean` for sync
+providers and `Promise<boolean>` for async providers (false if absent, detached, invalid or stale).
+Rejected promises are discarded; synchronous provider exceptions remain visible to callers/CodeMirror.
+Signals abort superseded feature requests and requests invalidated by edits, environment refresh,
+detach or disposal. Identity is rechecked after provider return and immediately before completion apply.
+Call `refreshEnvironment()` whenever external catalogs, bindings or admission evidence change.
+Providers should return immutable result payloads and honor cancellation to avoid wasted work.
+Neutral completion providers own candidate filtering and ordering; CodeMirror does not re-filter
+those results against replacement text. The Kalada facade retains its existing fuzzy filtering/boosts.
+
+Diagnostics are animation-frame scheduled. Returned ranges and edits must be ordered, bounded,
+half-open **UTF-16 source offsets**, including CRLF, and may not split CRLF or surrogate pairs.
+Invalid entries are dropped and invalid formatting edits return false. Editing uses the document's
+detected line separator; replacement can switch it. Use consistently separated documents (mixed
+line endings are not supported losslessly). Hover accepts plain text or `{ heading, text: string[] }`
+sections, never HTML. Consumers may supply trusted CodeMirror presentation extensions, but these
+do not determine embedded routing. One session attaches to at most one view; view destruction permits
+reattachment with the current text. Disposal does not destroy the host's view; later view edits are inert
+with respect to the disposed session. Host change-callback exceptions are isolated.
+
+The neutral runtime and declaration graph imports only CodeMirror, not Kalada language contracts,
+parsers, ASTs or component catalogs. The package retains its language-service dependency for the legacy
+root entry: subpath isolation is not a claim that npm omits that dependency. Packed smoke runs ESM/CJS,
+declaration checking and neutral browser bundling with the Kalada language packages removed.
+
+## Formbar FSX: diagnostics first, runtime still explicitly applied
+
+Formbar's `@formbar/fsx-authoring` provides `compileFsx(source, options)`, **not** a complete tooling
+language service. An FSX host can supply just diagnostics initially:
+
+```ts
+import { compileFsx } from "@formbar/fsx-authoring";
+import { createEditorSession, type EditorProvider } from "@kalada/codemirror/editor";
+
+const provider: EditorProvider = {
+  diagnostics: ({ snapshot, signal }) => {
+    const compiled = compileFsx(snapshot.text, authoringOptions());
+    if (signal.aborted) return null;
+    return { ...snapshot, value: toEditorDiagnostics(compiled) };
+  },
+};
+```
+
+This is integration guidance, not a shipped Formbar adapter. `authoringOptions` is host-owned renderer,
+binding and admission evidence; `toEditorDiagnostics` is a host adapter over the installed compiler's
+actual result schema, producing `{ from, to, severity, message }`. Preserve its half-open UTF-16 offsets;
+do not convert them to code-point indexes or normalize CRLF first. The host's existing **Apply** action
+should compile/apply `session.getSnapshot().text` separately. Diagnostic requests must not mount a
+renderer or change runtime state. On catalog/evidence changes, update host options and refresh the session.
+FSX owns attribute guest slots: any future completion/hover/format adapter must route through those
+slots with captured host/guest identity and map returned edits back to host source. This editor neither
+extends the v1 diagnostic-routing protocol into a full language service nor supplies production FSX completion.
+
+## Projection and future UPDF
+
+The existing projection representation is an AST/data JSON API, not a new textual grammar. A consumer
+may edit a serialized structured representation using its chosen JSON tooling and validate against the
+actual projection API. Serialization, parse validation, AST conversion and explicit application belong
+to that consumer; this package does not invent a projection syntax.
+
+UPDF integration needs an agreed declarative syntax/parser and tooling provider before completion,
+hover or formatting can be promised. Component catalogs and runtime evaluation stay outside the editor.
+Embedded routing belongs to the host-language adapter; optional syntax highlighting is presentation only.

package/dist/chunk-GCHU6EL7.js

@@ -0,0 +1,566 @@
+import { history, historyKeymap } from '@codemirror/commands';
+import { StateEffect, StateField, Compartment, EditorState, Transaction, EditorSelection, Text } from '@codemirror/state';
+import { showTooltip, ViewPlugin, EditorView, keymap, hoverTooltip, closeHoverTooltips } from '@codemirror/view';
+import { autocompletion, completionKeymap, closeCompletion } from '@codemirror/autocomplete';
+import { setDiagnostics } from '@codemirror/lint';
+
+// 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";
+  return "\n";
+}
+function textForEditor(text) {
+  return Text.of(text.split(/\r\n|\r|\n/u));
+}
+function textFromEditor(document, lineSeparator) {
+  return document.sliceString(0, document.length, lineSeparator);
+}
+var setKeyboardTooltip = StateEffect.define();
+var keyboardTooltipField = 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) => 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 [
+      autocompletion({ override: [(context) => this.complete(context)] }),
+      hoverTooltip((view, offset) => this.hover(view, offset)),
+      this.hoverIntentExtension(),
+      keyboardTooltipField,
+      keymap.of([
+        ...completionKeymap,
+        { key: "Mod-Shift-h", run: (view) => this.keyboardHover(view) },
+        {
+          key: "Escape",
+          run: (view) => {
+            this.clear(view);
+            view.focus();
+            return true;
+          }
+        }
+      ])
+    ];
+  }
+  hoverIntentExtension() {
+    return 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, diagnostics = false) {
+    this.invalidate();
+    closeCompletion(view);
+    const interactions = { effects: [setKeyboardTooltip.of(null), closeHoverTooltips] };
+    if (diagnostics) view.dispatch(interactions, setDiagnostics(view.state, []));
+    else view.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(
+            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: 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
+function createEditorSession(options) {
+  return new NeutralEditorSession(options);
+}
+var NeutralEditorSession = class {
+  extension;
+  snapshot;
+  attached = null;
+  disposed = false;
+  failed = false;
+  failureView = null;
+  notifications = [];
+  publishingChanges = false;
+  changing = 0;
+  separator = new 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: EditorSelection.cursor(0),
+      annotations: Transaction.addToHistory.of(true),
+      effects: separator === view.state.lineBreak ? void 0 : this.separator.reconfigure(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 [
+      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.
+      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 EditorState.lineSeparator.of(detectLineSeparator(session.snapshot.text));
+        }
+      }),
+      history(),
+      this.tooling.extension(),
+      keymap.of(historyKeymap),
+      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");
+  }
+};
+
+export { NeutralEditorSession, createEditorSession };
+//# sourceMappingURL=chunk-GCHU6EL7.js.map
+//# sourceMappingURL=chunk-GCHU6EL7.js.map