@coldsmirk/inkstone-codemirror 0.8.3 → 0.10.0

package/README.md

@@ -1,16 +1,18 @@
 # @coldsmirk/inkstone-codemirror
 
-Framework-agnostic [CodeMirror 6](https://codemirror.net/) plumbing: a controlled editor host (create-once, external-value reconcile, in-place theme swap), the standard document extension bundle, lazy per-language grammar loading, and precise [MiniJinja](https://github.com/mitsuhiko/minijinja) template support with schema-driven context completion.
+Framework-agnostic [CodeMirror 6](https://codemirror.net/) plumbing: controlled editor and merge-view hosts (create-once, external-value reconcile, in-place theme swap), the standard document extension bundle, lazy per-language grammar loading, and precise [MiniJinja](https://github.com/mitsuhiko/minijinja) template support with schema-driven context completion.
 
 Part of [inkstone](https://github.com/coldsmirk/inkstone). For a drop-in React component use [`@coldsmirk/inkstone-react`](https://www.npmjs.com/package/@coldsmirk/inkstone-react)'s `<CodeMirrorEditor>`, which is built on this package; reach for this layer to wire the same plumbing into your own components (any framework).
 
 ## What you get
 
 - **`ControlledEditorHost`** — the controlled-editor lifecycle solved once: the view is created once, external value changes reconcile into the document without resetting cursor/undo, and theme/extension swaps happen in place.
+- **`ControlledMergeHost`** — the same discipline for [`@codemirror/merge`](https://github.com/codemirror/merge)'s side-by-side `MergeView`: both documents reconcile per side without caret resets or callback echo, dynamic extensions swap in place on both editors, and every merge-level option (`orientation`, `revertControls`, `collapseUnchanged`, …) passes straight through. Policy-free — pin either side read-only via `originalExtensions` / `modifiedExtensions` to match how your documents are controlled.
 - **`documentExtensions(options)`** — the standard document editing bundle (history, brackets, completion UI, optional line numbers / wrapping / search), so hosts start from working defaults instead of a bare `EditorState`.
 - **`codeMirrorLanguages` / `loadLanguage(language)`** — the supported `CodeMirrorLanguage` names and their lazy loaders: one dynamic `import()` per grammar, so only the selected language is fetched, never the whole catalog. Two tiers back the ids: the official `@codemirror/lang-*` (Lezer) parsers where upstream ships one, plus the full [`@codemirror/legacy-modes`](https://github.com/codemirror/legacy-modes) catalog (stream-mode highlighting) for everything upstream never wrote a Lezer grammar for — `shell`, `dockerfile`, `ini` / `env` / `properties`, `toml`, `nginx`, `powershell`, `lua`, and a hundred more.
-- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`; the SQL family — `-sql` plus every dialect id: `-mysql`, `-pgsql`, `-sqlite`, `-mssql`, `-mariadb`, `-plsql`, `-cassandra`, `-hive`, `-sparksql`, `-gql`, `-gpsql`, `-esper`; and the config/deploy hosts `-toml`, `-ini`, `-env`, `-shell`, `-dockerfile`, `-nginx`) that overlay MiniJinja tooling on the host grammar. A linter flags non-MiniJinja tags; autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
+- **MiniJinja** — `language: "minijinja"` for standalone templates, or `minijinja-<host>` mixed variants (`minijinja-html`, `-xml`, `-json`, `-yaml`, `-css`, `-scss`, `-sass`, `-less`, `-markdown`; the SQL family — `-sql` plus every dialect id: `-mysql`, `-pgsql`, `-sqlite`, `-mssql`, `-mariadb`, `-plsql`, `-cassandra`, `-hive`, `-sparksql`, `-gql`, `-gpsql`, `-esper`; and the config/deploy hosts `-toml`, `-ini`, `-env`, `-shell`, `-dockerfile`, `-nginx`) that overlay MiniJinja tooling on the host grammar. A parser adapter supports MiniJinja whitespace control, dotted namespace assignments, and comma-separated `set` assignments beyond the upstream Jinja grammar; a linter flags non-MiniJinja tags, and autocomplete is restricted to MiniJinja's real tags / filters / tests / functions.
 - **Context completion** — `normalizeContext({ schema })` (JSON Schema) or `normalizeContext({ sample })` (representative value) builds an `EditorContext`; dispatch it with `setMinijinjaContext` to make `{{ }}` / `{% if %}` / `{% for %}` complete the render context's variables and walk member access (`user.address.city`). `minijinjaContextField`, `resolveMembers`, and `typeAtPath` expose the underlying pieces.
+- **SQL schema completion** — dispatch `setSqlSchema.of({ tables })` for dialect-aware table and column completion in the Lezer-backed `sql`, `mysql`, `pgsql`, `sqlite`, `mssql`, `mariadb`, `plsql`, and `cassandra` languages plus their `minijinja-*` variants. Legacy stream-mode SQL languages do not consume schemas. Controlled hosts install the data channel eagerly, so the schema may arrive before the lazy grammar.
 - **`searchPhrasesZhCn`** — an opt-in `EditorState.phrases` table localizing the search panel to Simplified Chinese.
 
 ## Install
@@ -20,7 +22,7 @@ pnpm add @coldsmirk/inkstone-codemirror \
   @codemirror/state @codemirror/view @codemirror/language @codemirror/autocomplete @codemirror/commands @codemirror/search
 ```
 
-The `@codemirror/*` packages are **peer dependencies** on purpose: `@codemirror/state` breaks at runtime if two copies load, so your app owns the single copy and every extension is guaranteed to be built against it. Node.js >= 22 for build / SSR hosts.
+The `@codemirror/*` packages are **peer dependencies** on purpose: `@codemirror/state` breaks at runtime if two copies load, so your app owns the single copy and every extension is guaranteed to be built against it. Node.js >= 24 for build / SSR hosts.
 
 ## Quick start
 
@@ -38,6 +40,29 @@ const host = new ControlledEditorHost({
 host.setValue(remoteValue);
 ```
 
+For a side-by-side diff:
+
+```ts
+import { EditorState } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { ControlledMergeHost, documentExtensions } from "@coldsmirk/inkstone-codemirror";
+
+const diff = new ControlledMergeHost({
+  parent: document.querySelector("#diff")!,
+  original: before,
+  modified: after,
+  extensions: [documentExtensions({ showLineNumbers: true })],
+  // The original side follows setOriginal only — no change channel, so lock it.
+  originalExtensions: [EditorState.readOnly.of(true), EditorView.editable.of(false)],
+  onModifiedChange: next => save(next),
+  revertControls: "a-to-b"
+});
+
+// Both sides reconcile externally, same rules as setValue.
+diff.setOriginal(nextBefore);
+diff.setModified(nextAfter);
+```
+
 For MiniJinja with context completion:
 
 ```ts
@@ -47,6 +72,11 @@ import { loadLanguage, normalizeContext, setMinijinjaContext } from "@coldsmirk/
 view.dispatch({ effects: setMinijinjaContext.of(normalizeContext({ schema })) });
 ```
 
+The controlled hosts install both context and SQL-schema fields before any grammar resolves, so
+applications may dispatch either effect immediately and load/reconfigure the grammar later.
+Hand-built `EditorState` instances should install `minijinjaContextField` / `sqlSchemaField`
+explicitly when they need the same ordering.
+
 The completion is **structural** — it walks the declared shape (member access along a literal path), not types produced by filters or arithmetic. For a Rust backend the schema is nearly free: derive it from the same `serde` struct you render with via [`schemars`](https://docs.rs/schemars), and the completion can't drift from the real context.
 
 ## License

package/dist/context-BJzyiP0A.js

@@ -0,0 +1,389 @@
+import { StateEffect, StateField } from "@codemirror/state";
+//#region src/context.ts
+const ANY = { kind: "any" };
+const NULL = { kind: "null" };
+const MAX_DEREF = 100;
+const setMinijinjaContext = StateEffect.define();
+const minijinjaContextField = StateField.define({
+	create() {
+		return null;
+	},
+	update(value, transaction) {
+		let next = value;
+		for (const effect of transaction.effects) if (effect.is(setMinijinjaContext)) next = effect.value;
+		return next;
+	}
+});
+function normalizeContext(input) {
+	if ("schema" in input) return fromJsonSchema(input.schema);
+	return {
+		root: fromSample(input.sample),
+		defs: {}
+	};
+}
+function resolveMembers(ir, path, scope) {
+	if (path.length === 0) {
+		const top = membersOf(ir, ir.root);
+		if (!scope || scope.size === 0) return top;
+		return [...[...scope].map(([name, type]) => {
+			return {
+				name,
+				type,
+				required: true,
+				nullable: false
+			};
+		}), ...top.filter((member) => !scope.has(member.name))];
+	}
+	const type = typeAtPath(ir, path, scope);
+	return type ? membersOf(ir, type) : [];
+}
+function typeAtPath(ir, path, scope) {
+	const [first, ...rest] = path;
+	if (first === void 0) return deref(ir, ir.root);
+	let type = scope?.get(first) ?? stepInto(ir, ir.root, first);
+	for (const key of rest) {
+		if (type === null) return null;
+		type = stepInto(ir, type, key);
+	}
+	return type === null ? null : deref(ir, type);
+}
+function elementType(ir, type) {
+	const resolved = deref(ir, type);
+	return resolved.kind === "array" ? deref(ir, resolved.element) : null;
+}
+function followRefs(type, lookup) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		const next = lookup(current.name);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+function deref(ir, type) {
+	return followRefs(type, (name) => ir.defs[name] ?? null) ?? ANY;
+}
+function stepInto(ir, type, key) {
+	const resolved = deref(ir, type);
+	if (resolved.kind !== "object") return null;
+	const field = resolved.fields[key];
+	return field ? field.type : null;
+}
+function membersOf(ir, type) {
+	const resolved = deref(ir, type);
+	if (resolved.kind !== "object") return [];
+	return Object.entries(resolved.fields).map(([name, field]) => {
+		return {
+			name,
+			type: field.type,
+			required: field.required,
+			nullable: field.nullable,
+			doc: field.doc
+		};
+	});
+}
+const REF_PREFIXES = ["#/$defs/", "#/definitions/"];
+function fromJsonSchema(schema) {
+	if (!isObject(schema)) return {
+		root: ANY,
+		defs: {}
+	};
+	const context = {
+		raw: {
+			...asObject(schema.definitions),
+			...asObject(schema.$defs)
+		},
+		defs: Object.create(null),
+		resolving: /* @__PURE__ */ new Set(),
+		tainted: /* @__PURE__ */ new Set(),
+		cyclic: /* @__PURE__ */ new Set(),
+		dependents: /* @__PURE__ */ new Map(),
+		converting: []
+	};
+	for (const name of Object.keys(context.raw)) defType(name, context);
+	if (context.tainted.size > 0) {
+		const queue = [...context.tainted];
+		const pending = new Set(queue);
+		let head = 0;
+		let budget = (Object.keys(context.raw).length + 1) ** 2;
+		while (head < queue.length && budget > 0) {
+			budget -= 1;
+			const name = queue[head];
+			head += 1;
+			if (name === void 0) break;
+			pending.delete(name);
+			context.converting.push(name);
+			const next = convert(context.raw[name], context);
+			context.converting.pop();
+			if (JSON.stringify(next) !== JSON.stringify(context.defs[name])) {
+				context.defs[name] = next;
+				const stale = [...context.dependents.get(name) ?? []].filter((reader) => !pending.has(reader));
+				for (const dependent of stale) {
+					pending.add(dependent);
+					queue.push(dependent);
+				}
+			}
+		}
+	}
+	return {
+		root: convert(schema, context),
+		defs: context.defs
+	};
+}
+function defType(name, context) {
+	const reader = context.converting.at(-1);
+	if (reader !== void 0 && reader !== name) {
+		const readers = context.dependents.get(name);
+		if (readers) readers.add(reader);
+		else context.dependents.set(name, /* @__PURE__ */ new Set([reader]));
+	}
+	if (Object.hasOwn(context.defs, name)) return context.defs[name] ?? null;
+	if (context.resolving.has(name)) {
+		for (const pending of context.converting) context.tainted.add(pending);
+		const cycleStart = context.converting.lastIndexOf(name);
+		if (cycleStart === -1) context.cyclic.add(name);
+		else for (const member of context.converting.slice(cycleStart)) context.cyclic.add(member);
+		return null;
+	}
+	if (!Object.hasOwn(context.raw, name)) return null;
+	context.resolving.add(name);
+	context.converting.push(name);
+	const type = convert(context.raw[name], context);
+	context.converting.pop();
+	context.resolving.delete(name);
+	context.defs[name] = type;
+	return type;
+}
+function convert(node, context) {
+	if (typeof node === "boolean" || !isObject(node)) return ANY;
+	const ref = refName(node.$ref);
+	const reference = ref === null ? null : {
+		kind: "ref",
+		name: ref
+	};
+	if (Array.isArray(node.allOf)) {
+		const branches = node.allOf.map((entry) => convert(entry, context));
+		if (reference) branches.unshift(reference);
+		return requireFields(mergeAll(isObject(node.properties) ? [...branches, objectType(node, context)] : branches, context, "all"), node.required, context);
+	}
+	const union = node.anyOf ?? node.oneOf;
+	if (Array.isArray(union)) {
+		const viable = union.filter((branch) => unionBranchKind(branch, context) !== "impossible");
+		const nonNull = viable.filter((branch) => unionBranchKind(branch, context) !== "null");
+		if (viable.length === 0) return ANY;
+		if (nonNull.length === 0) return NULL;
+		const merged = nonNull.length === 1 ? convert(nonNull[0], context) : mergeAll(nonNull.map((entry) => convert(entry, context)), context, "any");
+		const withOwn = isObject(node.properties) ? mergeAll([merged, objectType(node, context)], context, "all") : merged;
+		return requireFields(reference ? mergeAll([reference, withOwn], context, "all") : withOwn, node.required, context);
+	}
+	if (reference) {
+		const hasProperties = isObject(node.properties);
+		if (!(hasProperties || Array.isArray(node.required) || primaryType(node) === "object")) return reference;
+		return requireFields(hasProperties ? mergeAll([reference, objectType(node, context)], context, "all") : reference, node.required, context);
+	}
+	if (Array.isArray(node.enum)) return {
+		kind: "enum",
+		values: node.enum.filter(isLiteral)
+	};
+	if ("const" in node && isLiteral(node.const)) return {
+		kind: "enum",
+		values: [node.const]
+	};
+	const type = primaryType(node);
+	if (isObjectShape(node)) return objectType(node, context);
+	if (type === "array") return {
+		kind: "array",
+		element: convert((Array.isArray(node.prefixItems) ? node.prefixItems[0] : void 0) ?? (Array.isArray(node.items) ? node.items[0] : node.items), context)
+	};
+	if (type === "string") return { kind: "string" };
+	if (type === "integer" || type === "number") return { kind: "number" };
+	if (type === "boolean") return { kind: "boolean" };
+	if (type === "null") return NULL;
+	return ANY;
+}
+function isObjectShape(node) {
+	return primaryType(node) === "object" || isObject(node.properties);
+}
+function objectType(node, context) {
+	const properties = asObject(node.properties);
+	const required = new Set(Array.isArray(node.required) ? node.required.filter((name) => typeof name === "string") : []);
+	const fields = Object.create(null);
+	for (const [name, sub] of Object.entries(properties)) fields[name] = {
+		type: convert(sub, context),
+		required: required.has(name),
+		nullable: isNullable(sub, context),
+		doc: description(sub)
+	};
+	return {
+		kind: "object",
+		fields
+	};
+}
+function mergeAll(types, context, mode) {
+	const [only] = types;
+	if (only && types.length === 1) return only;
+	const fields = Object.create(null);
+	const appearances = /* @__PURE__ */ new Map();
+	let branches = 0;
+	for (const type of types) {
+		const resolved = derefFully(type, context);
+		if (resolved?.kind === "object") {
+			branches += 1;
+			for (const [name, field] of Object.entries(resolved.fields)) {
+				const existing = fields[name];
+				fields[name] = existing ? mergeField(existing, field, mode) : field;
+				appearances.set(name, (appearances.get(name) ?? 0) + 1);
+			}
+		}
+	}
+	if (branches > 0) {
+		if (mode === "any") {
+			for (const [name, field] of Object.entries(fields)) if (field.required && appearances.get(name) !== types.length) fields[name] = {
+				...field,
+				required: false
+			};
+		}
+		return {
+			kind: "object",
+			fields
+		};
+	}
+	return types.find((type) => type.kind !== "any") ?? ANY;
+}
+function requireFields(type, required, context) {
+	const names = Array.isArray(required) ? required.filter((name) => typeof name === "string") : [];
+	if (names.length === 0) return type;
+	const resolved = type.kind === "ref" ? derefNonCyclic(type, context) : type;
+	if (resolved === null || resolved.kind !== "object") return type;
+	const fields = Object.assign(Object.create(null), resolved.fields);
+	let changed = false;
+	for (const name of names) {
+		const field = fields[name];
+		if (field && !field.required) {
+			fields[name] = {
+				...field,
+				required: true
+			};
+			changed = true;
+		}
+	}
+	return changed ? {
+		kind: "object",
+		fields
+	} : type;
+}
+function mergeField(existing, incoming, mode) {
+	return {
+		type: incoming.type,
+		required: mode === "all" ? existing.required || incoming.required : existing.required && incoming.required,
+		nullable: mode === "all" ? existing.nullable && incoming.nullable : existing.nullable || incoming.nullable,
+		doc: incoming.doc ?? existing.doc
+	};
+}
+function derefFully(type, context) {
+	return followRefs(type, (name) => defType(name, context));
+}
+function derefNonCyclic(type, context) {
+	let current = type;
+	for (let i = 0; i < MAX_DEREF && current.kind === "ref"; i++) {
+		if (context.cyclic.has(current.name)) return null;
+		const next = defType(current.name, context);
+		if (!next) return null;
+		current = next;
+	}
+	return current.kind === "ref" ? null : current;
+}
+function fromSample(value, ancestors = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || value === void 0) return ANY;
+	if (typeof value === "object") {
+		if (ancestors.has(value)) return ANY;
+		ancestors.add(value);
+		const type = Array.isArray(value) ? sampleArrayType(value, ancestors) : sampleObjectType(value, ancestors);
+		ancestors.delete(value);
+		return type;
+	}
+	if (typeof value === "string") return { kind: "string" };
+	if (typeof value === "number") return { kind: "number" };
+	if (typeof value === "boolean") return { kind: "boolean" };
+	return ANY;
+}
+function sampleArrayType(value, ancestors) {
+	return {
+		kind: "array",
+		element: value.length > 0 ? fromSample(value[0], ancestors) : ANY
+	};
+}
+function sampleObjectType(value, ancestors) {
+	const fields = Object.create(null);
+	for (const [name, member] of Object.entries(value)) fields[name] = {
+		type: fromSample(member, ancestors),
+		required: true,
+		nullable: member === null
+	};
+	return {
+		kind: "object",
+		fields
+	};
+}
+function refName(ref) {
+	if (typeof ref !== "string") return null;
+	for (const prefix of REF_PREFIXES) if (ref.startsWith(prefix)) return decodeURIComponent(ref.slice(prefix.length)).replaceAll("~1", "/").replaceAll("~0", "~");
+	return null;
+}
+function primaryType(node) {
+	const { type } = node;
+	if (typeof type === "string") return type;
+	if (Array.isArray(type)) {
+		const nonNull = type.find((entry) => typeof entry === "string" && entry !== "null");
+		if (typeof nonNull === "string") return nonNull;
+		return type.includes("null") ? "null" : null;
+	}
+	return null;
+}
+function isNullable(node, context) {
+	const pending = [node];
+	const seenRefs = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (!isObject(current)) continue;
+		const { type } = current;
+		if (type === "null" || Array.isArray(type) && type.includes("null")) return true;
+		const ref = refName(current.$ref);
+		if (ref !== null && !seenRefs.has(ref) && Object.hasOwn(context.raw, ref)) {
+			seenRefs.add(ref);
+			pending.push(context.raw[ref]);
+			continue;
+		}
+		const union = current.anyOf ?? current.oneOf;
+		if (Array.isArray(union)) pending.push(...union);
+	}
+	return false;
+}
+function unionBranchKind(branch, context) {
+	const seenRefs = /* @__PURE__ */ new Set();
+	let current = branch;
+	for (let i = 0; i < MAX_DEREF; i++) {
+		if (current === false) return "impossible";
+		if (!isObject(current)) return "other";
+		if (current.type === "null" || Array.isArray(current.type) && current.type.length === 1 && current.type[0] === "null") return "null";
+		const ref = refName(current.$ref);
+		if (ref === null || seenRefs.has(ref) || !Object.hasOwn(context.raw, ref)) return "other";
+		seenRefs.add(ref);
+		current = context.raw[ref];
+	}
+	return "other";
+}
+function description(node) {
+	return isObject(node) && typeof node.description === "string" ? node.description : void 0;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asObject(value) {
+	return isObject(value) ? value : {};
+}
+function isLiteral(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+//#endregion
+export { setMinijinjaContext as a, resolveMembers as i, minijinjaContextField as n, typeAtPath as o, normalizeContext as r, elementType as t };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { Extension, StateField } from "@codemirror/state";
 import { EditorView } from "@codemirror/view";
 import { LanguageSupport } from "@codemirror/language";
+import { DirectMergeConfig, MergeConfig, MergeConfig as MergeConfig$1, MergeView, MergeView as MergeView$1 } from "@codemirror/merge";
 
 //#region src/context.d.ts
 /**
@@ -61,8 +62,9 @@ type EditorContext = {
  * Reactively set (or clear) the render-context schema an editor completes against. Dispatch this
  * effect — `setMinijinjaContext.of(normalizeContext(...))`, or `.of(null)` to turn it off — to
  * update completion without recreating the editor, matching the create-once discipline used
- * throughout the toolkit. Defined here (not with the MiniJinja grammar) so it and the field stay
- * in the always-loaded chunk, leaving the grammar lazily code-split.
+ * throughout the toolkit. Controlled editor hosts install the field before any lazy grammar
+ * resolves; a hand-built EditorState should install {@link minijinjaContextField} itself when it
+ * needs to dispatch this effect before adding the MiniJinja support.
  */
 declare const setMinijinjaContext: import("@codemirror/state").StateEffectType<IrSchema | null>;
 /**
@@ -84,9 +86,12 @@ declare function normalizeContext(input: EditorContext): IrSchema;
  */
 declare function resolveMembers(ir: IrSchema, path: readonly string[], scope?: ReadonlyMap<string, IrType>): Member[];
 /**
- * The type at a declared property path, or null if the path leaves the walkable shape.
+ * The type at a declared property path, or null if the path leaves the walkable shape. As in
+ * {@link resolveMembers}, the first segment may resolve against a `scope` binding before falling
+ * back to the root — so a nested `{% for child in parent.children %}` can walk the `parent` its
+ * enclosing loop bound.
  */
-declare function typeAtPath(ir: IrSchema, path: readonly string[]): IrType | null;
+declare function typeAtPath(ir: IrSchema, path: readonly string[], scope?: ReadonlyMap<string, IrType>): IrType | null;
 //#endregion
 //#region src/controlled-host.d.ts
 interface ControlledEditorOptions {
@@ -551,4 +556,130 @@ declare const codeMirrorLanguages: readonly CodeMirrorLanguage[];
  */
 declare function loadLanguage(language: CodeMirrorLanguage): Promise<Extension>;
 //#endregion
-export { type CodeMirrorLanguage, ControlledEditorHost, type ControlledEditorOptions, type DocumentExtensionsOptions, type EditorContext, type IrField, type IrSchema, type IrType, type Member, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, typeAtPath };
+//#region src/merge-host.d.ts
+interface ControlledMergeOptions extends MergeConfig$1 {
+  /**
+   * The element the merge view mounts into.
+   */
+  parent: HTMLElement;
+  /**
+   * Document or shadow root the merge view is mounted in. Required when `parent` lives outside
+   * the global document because the two editors are created before the merge DOM is attached.
+   */
+  root?: DirectMergeConfig["root"];
+  /**
+   * Initial text of the original document (editor A — the left side in the default
+   * orientation).
+   */
+  original: string;
+  /**
+   * Initial text of the modified document (editor B).
+   */
+  modified: string;
+  /**
+   * Called with the full original document after every edit made *in* editor A — user
+   * typing, or a `revertControls: "b-to-a"` copy. Not called for
+   * {@link ControlledMergeHost.setOriginal} reconciliations. Leave editor A read-only
+   * (via {@link ControlledMergeOptions.originalExtensions}) when nothing consumes this.
+   */
+  onOriginalChange?: (value: string) => void;
+  /**
+   * Called with the full modified document after every edit made *in* editor B — user
+   * typing, or a `revertControls: "a-to-b"` copy. Not called for
+   * {@link ControlledMergeHost.setModified} reconciliations.
+   */
+  onModifiedChange?: (value: string) => void;
+  /**
+   * Static extensions applied to both editors, fixed for the merge view's lifetime.
+   */
+  extensions?: Extension[];
+  /**
+   * Static extensions for editor A only — the place to make the original side read-only
+   * (`EditorState.readOnly.of(true)`, `EditorView.editable.of(false)`).
+   */
+  originalExtensions?: Extension[];
+  /**
+   * Static extensions for editor B only.
+   */
+  modifiedExtensions?: Extension[];
+  /**
+   * Extensions that change at runtime (theme, language config …), applied to both editors
+   * and swapped in place via {@link ControlledMergeHost.reconfigure}.
+   */
+  dynamicExtensions?: Extension[];
+}
+/**
+ * A controlled CodeMirror 6 merge view — {@link ControlledEditorHost}'s discipline applied to
+ * `@codemirror/merge`'s side-by-side {@link MergeView}:
+ *
+ * - **External value reconcile, per side.** {@link setOriginal} / {@link setModified} diff the
+ * incoming value against the live document and dispatch a minimal replace, so a store-driven
+ * update never resets the caret and never echoes back through the change callbacks.
+ * - **In-place reconfiguration.** `dynamicExtensions` live in one {@link Compartment} per
+ * editor; {@link reconfigure} swaps both (light/dark theme, language options) without
+ * rebuilding the view. Merge-level options (`orientation`, `revertControls`,
+ * `collapseUnchanged` …) reconfigure through {@link MergeView.reconfigure} on {@link view}.
+ *
+ * Policy-free plumbing: neither side is read-only by default — wire that through
+ * `originalExtensions` / `modifiedExtensions` to match how the documents are controlled.
+ * Framework-agnostic, same as `ControlledEditorHost`.
+ */
+declare class ControlledMergeHost {
+  private readonly originalCompartment;
+  private readonly modifiedCompartment;
+  private silent;
+  readonly view: MergeView$1;
+  constructor(options: ControlledMergeOptions);
+  private reconcile;
+  /**
+   * Reconcile an externally-changed original value into editor A without resetting its caret.
+   * No-op when the document already matches; the write never re-enters `onOriginalChange`.
+   */
+  setOriginal(value: string): void;
+  /**
+   * Reconcile an externally-changed modified value into editor B without resetting its caret.
+   * No-op when the document already matches; the write never re-enters `onModifiedChange`.
+   */
+  setModified(value: string): void;
+  /**
+   * Swap the dynamic extensions (theme, language configuration) in place, on both editors.
+   */
+  reconfigure(dynamicExtensions: Extension[]): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/sql-schema.d.ts
+/**
+ * A database's completable surface. Table keys may be schema-qualified (`"analytics.events"`);
+ * unqualified keys complete against `defaultSchema` per `@codemirror/lang-sql` semantics.
+ */
+interface SqlSchema {
+  /**
+   * Table name (optionally schema-qualified) → column names, in declaration order.
+   */
+  readonly tables: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Table whose columns complete unqualified (no `table.` prefix).
+   */
+  readonly defaultTable?: string;
+  /**
+   * Schema whose tables complete unqualified.
+   */
+  readonly defaultSchema?: string;
+}
+/**
+ * Reactively set (or clear) the database schema SQL completion reads. Dispatch
+ * `setSqlSchema.of(schema)` — or `.of(null)` to turn table/column completion off — to update a
+ * live editor without recreating it, matching the create-once discipline used throughout the
+ * toolkit.
+ */
+declare const setSqlSchema: import("@codemirror/state").StateEffectType<SqlSchema | null>;
+/**
+ * Holds the schema that SQL table/column completion reads. Controlled editor hosts install it
+ * eagerly; the `sql`-family language supports also include it for hand-built editors. `null`
+ * (the default) means no schema — keyword completion still works, table/column completion stays
+ * off.
+ */
+declare const sqlSchemaField: StateField<SqlSchema | null>;
+//#endregion
+export { type CodeMirrorLanguage, ControlledEditorHost, type ControlledEditorOptions, ControlledMergeHost, type ControlledMergeOptions, type DocumentExtensionsOptions, type EditorContext, type IrField, type IrSchema, type IrType, type Member, type MergeConfig, type MergeView, type SqlSchema, codeMirrorLanguages, documentExtensions, loadLanguage, minijinjaContextField, normalizeContext, resolveMembers, searchPhrasesZhCn, setMinijinjaContext, setSqlSchema, sqlSchemaField, typeAtPath };