@jigs.design/compiler 0.1.2 → 0.3.0

package/README.md

@@ -1,10 +1,10 @@
 # @jigs.design/compiler
 
-Today's Jigs compiler: the parser, the checker against a catalog, the code generator, recipe libraries, and the SEARCH/REPLACE edit helpers. `@jigs.design/server` and `@jigs.design/prompt` use it. You import it for tooling, not to run a session.
+Today's Jigs compiler: the parser, the checker against a catalog, the code generator, jig libraries, and the SEARCH/REPLACE edit helpers. `@jigs.design/server` and `@jigs.design/prompt` use it. You import it for tooling, not to run a session.
 
-It parses embedded code with [acorn](https://github.com/acornjs/acorn) in strict mode, the mode programs run in, and checks names and the JavaScript subset. It has no built-in catalog. Every caller passes one, and its prop kinds are boolean, enum, handler, number, rows and string.
+Its diagnostics are the `Diagnostic` type from `@jigs.design/protocol`, the shape the server sends; it imports that package's types and nothing else from it. It parses embedded code with [acorn](https://github.com/acornjs/acorn) in strict mode, the mode programs run in, and checks names and the JavaScript subset. It has no built-in catalog. Every caller passes one, and its prop kinds are boolean, enum, handler, number, rows and string.
 
-The [language RFC](../../docs/language-v2/rfc.md) plans its next changes. It evolves in place, behind the same server API.
+It evolves in place, behind the same server API. The [language plan's record](../../.agent-docs/notes/language-v2-2026-10.md) says what each phase changed, and `.agent-docs/deferred.md` what is set aside.
 
 ## Exports
 
@@ -12,18 +12,18 @@ The [language RFC](../../docs/language-v2/rfc.md) plans its next changes. It evo
 | ---------------------------------------------------------- | ---------------------------------------------------------------- |
 | `parseJigs`                                                | Source to a document tree. Tolerates a prefix cut off mid-stream |
 | `compileJigs`                                              | Checks a document against a catalog and generates its program    |
-| `compileLibrary`                                           | Compiles recipes into a library a document can use               |
-| `recipeSignature`                                          | A recipe's props and slot, as the prompt lists them              |
+| `compileLibrary`                                           | Compiles jigs into a library a document can use                  |
+| `jigSignature`                                             | A jig's props and slot, as the prompt lists them                 |
 | `isEditReply`, `parseEdits`, `applyEdits`, `SEARCH_MARKER` | Recognise and apply a reply made of SEARCH/REPLACE edits         |
 | `CompileCatalog`, `ComponentSpec`, `PropSpec`              | What the compiler checks against                                 |
 
 ## Source
 
 - `src/parse.ts`, `src/ast.ts`: the parser and its tree.
-- `src/compile.ts`: checking, recipes and diagnostics.
+- `src/compile.ts`: checking, jig libraries and diagnostics.
 - `src/script.ts`, `src/check-code.ts`: embedded code read with acorn, and the checks on it.
 - `src/suggest.ts`: the nearest name, for "did you mean".
 - `src/codegen.ts`: the JavaScript the sandbox runs.
 - `src/patch.ts`: SEARCH/REPLACE edits.
-- `src/spec.ts`, `src/signature.ts`: catalog specs and recipe signatures.
+- `src/spec.ts`, `src/signature.ts`: catalog specs and jig signatures.
 - `src/test-catalog.ts`: the catalog the tests run against.

package/dist/block-hoist.d.ts

@@ -0,0 +1,2 @@
+import "./ast.js";
+import "./compile.js";

package/dist/check-code.d.ts

@@ -1,4 +1,6 @@
-import { Diagnostic } from "./compile.js";
+import "./ast.js";
+import { Finding } from "./compile.js";
+import "./block-hoist.js";
 import { ProcedureCall } from "./script.js";
 //#region src/check-code.d.ts
 /** A procedure call in the document, by line, for the server to check against its host. */
@@ -10,7 +12,7 @@ export interface ProcedureUse extends Omit<ProcedureCall, "end" | "offset"> {
   start?: number;
 }
 /** Where a diagnostic points: a line, and a range in the source when the code has one. */
-type Place = Pick<Diagnostic, "end" | "line" | "start">;
+type Place = Pick<Finding, "end" | "line" | "start">;
 /** A step of `DataRead.path` into each element of an array, as an `<each>` item takes. */
 export declare const ELEMENT = "[]";
 /**

package/dist/check-code.js

@@ -277,18 +277,18 @@ function readBody(statements, define, outer) {
 * Checks every piece of code in the page and its defines, adding to
 * `diagnostics`, and returns the procedure calls it saw, in source order.
 */
-function checkCode(tree, defines, pageStatements, diagnostics, hoists, dropped = /* @__PURE__ */ new Set()) {
+function checkCode(tree, defines, pageStatements, findings, hoists, dropped = /* @__PURE__ */ new Set()) {
 	const procedures = [];
 	const reads = [];
 	const report = (place, code, message, fix) => {
-		const diagnostic = {
+		const finding = {
 			code,
 			...place,
 			message,
-			severity: "warning"
+			severity: "error"
 		};
-		if (fix !== void 0) diagnostic.fix = fix;
-		diagnostics.push(diagnostic);
+		if (fix !== void 0) finding.fix = fix;
+		findings.push(finding);
 	};
 	const checkSnippet = (snippet, body, scope) => {
 		const facts = factsOf(snippet);

package/dist/codegen.d.ts

@@ -1,3 +1,5 @@
+import "./ast.js";
+import "./compile.js";
 //#region src/codegen.d.ts
 /** What the sandbox runs: a JavaScript program plus the text it displays. */
 export interface ProgramOutput {

package/dist/codegen.js

@@ -62,15 +62,15 @@ const fragment = (children) => `__jigs.jsx(${[
 const documentLines = { line: String };
 const libraryLines = { line: () => "__jigsAt" };
 function generateProgram(statements, tree, defines = []) {
-	const diagnostics = [];
+	const findings = [];
 	const constants = {};
 	let nextConstant = 0;
 	const invalid = (code, line, message) => {
-		diagnostics.push({
+		findings.push({
 			code,
 			line,
 			message,
-			severity: "warning"
+			severity: "error"
 		});
 	};
 	/** Statement lines, run in order, plus a `let` for every name they declare. */
@@ -195,7 +195,7 @@ function generateProgram(statements, tree, defines = []) {
 	const functions = defines.map((def) => genDefine(def));
 	const children = genChildren(tree, documentLines);
 	return {
-		diagnostics,
+		findings,
 		output: {
 			code: [
 				"\"use strict\";",

package/dist/compile.d.ts

@@ -3,6 +3,7 @@ import { ExprNode, PropValue, Statement, TextNode } from "./ast.js";
 import { CompileCatalog } from "./spec.js";
 import { ProgramOutput } from "./codegen.js";
 import { DataRead, ProcedureUse } from "./check-code.js";
+import { Diagnostic, Severity } from "@jigs.design/protocol";
 //#region src/compile.d.ts
 type DiagnosticCode = "coerced" | "handle_field" | "hook_placement" | "invalid_control" | "invalid_define" | "invalid_expression" | "invalid_literal" | "invalid_statement" | "missing_declarations" | "missing_prop" | "mutate_in_render" | "outer_reference" | "query_options" | "repaired" | "shadows_library" | "unclosed" | "undefined_compare" | "undefined_reference" | "unexpected_children" | "unknown_component" | "unknown_prop" | "unstable_input" | "unsupported_syntax" | "use_before_declare";
 /** Replace `[start, end)` of the source with `text`. */
@@ -21,20 +22,25 @@ export interface Fix {
   /** What the fix does, such as "Replace with `q.status === "pending"`". */
   title: string;
 }
-export interface Diagnostic {
+/**
+ * A diagnostic while the compiler works: flat offsets into the source being
+ * compiled, and a fix as offset edits, so `applyFixes` can apply it. The
+ * result reports each as a `Diagnostic`.
+ */
+export interface Finding {
   code: DiagnosticCode;
-  /** The 1-based column of `start` on its line. */
-  column?: number;
   /** Just past what the diagnostic is about, as an offset into the source. */
   end?: number;
   fix?: Fix;
   /** The line of `start` when there is one. */
   line: number;
   message: string;
-  severity: "info" | "warning";
+  severity: Severity;
   /** The first character of what the diagnostic is about, as an offset into the source. */
   start?: number;
 }
+/** What `compileJigs` reports: the shape the server sends and the eval results store. */
+type Diagnostic$1 = Diagnostic<DiagnosticCode>;
 interface RenderElement {
   children: Array<RenderNode>;
   component: string;
@@ -104,7 +110,7 @@ export interface CompiledDefine {
   name: string;
   origin: "doc" | "library";
   /**
-   * The procedure calls in a library recipe's source, by its lines. Empty
+   * The procedure calls in a library jig's source, by its lines. Empty
    * for a document's own define: those are on the document's result.
    */
   procedures: ReadonlyArray<ProcedureUse>;
@@ -124,28 +130,28 @@ export interface Program {
   tree: Array<RenderNode>;
 }
 /** A reusable component written in Jigs: source with exactly one `<define>`. */
-export interface Recipe {
+export interface Jig {
   name: string;
   source: string;
 }
-/** Recipes compiled against one catalog, ready to use in documents. */
+/** Jigs compiled against one catalog, ready to use in documents. */
 export type Library = ReadonlyMap<string, CompiledDefine>;
 export interface CompileOptions {
   /** The components a document may use. */
   catalog: CompileCatalog;
-  /** Recipes in scope, from `compileLibrary` with the same catalog. */
+  /** Jigs in scope, from `compileLibrary` with the same catalog. */
   library?: Library;
 }
 export interface CompileResult {
   defines: ReadonlyArray<CompiledDefine>;
-  diagnostics: Array<Diagnostic>;
-  /** The recipes this document was compiled against. */
+  diagnostics: Array<Diagnostic$1>;
+  /** The jigs this document was compiled against. */
   library: ReadonlyMap<string, CompiledDefine>;
   output: ProgramOutput;
   /**
    * Every `useQuery`, `useMutation` and `useAction` call in the parsed
    * code of the document and its defines, in line order: nothing in
-   * prose or in string literals. Recipes' calls are on the library's
+   * prose or in string literals. Library jigs' calls are on the library's
    * defines.
    */
   procedures: ReadonlyArray<ProcedureUse>;
@@ -159,19 +165,19 @@ export interface CompileResult {
   source: string;
 }
 /**
- * Compiles `recipes` against `catalog`, in order: a recipe may use the ones
- * before it. Throws when a recipe has any diagnostic. Cached per catalog and
- * recipe list.
+ * Compiles `jigs` against `catalog`, in order: a jig may use the ones
+ * before it. Throws when a jig has any diagnostic. Cached per catalog and
+ * jig list.
  */
-export declare function compileLibrary(recipes: ReadonlyArray<Recipe>, catalog: CompileCatalog): Library;
+export declare function compileLibrary(jigs: ReadonlyArray<Jig>, catalog: CompileCatalog): Library;
 /**
- * Compiles a document. A warning that carries a fix is applied rather than
+ * Compiles a document. An error that carries a fix is applied rather than
  * sent to the model: the fixed source is compiled again, and when it has
  * exactly the problems left that the fixes did not cover, its program is
- * used and those warnings become `info`, as a quoted number on a number prop
+ * used and those errors become `info`, as a quoted number on a number prop
  * already is. Diagnostics, procedures and their spans stay those of `source`,
  * which is what the model wrote and what the session keeps.
  */
 export declare function compileJigs(source: string, options: CompileOptions): CompileResult;
 //#endregion
-export {};
+export { Diagnostic$1 as Diagnostic };

package/dist/compile.js

@@ -1,6 +1,6 @@
 import { analyze } from "./script.js";
 import { generateProgram, isBindingName } from "./codegen.js";
-import { columnAt, lineAt, sourceRange } from "./offsets.js";
+import { lineAt, rangeIn, sourceRange, spanIn } from "./offsets.js";
 import { closest, nearest } from "./suggest.js";
 import { checkCode } from "./check-code.js";
 import { parseJigs } from "./parse.js";
@@ -58,7 +58,7 @@ function hookMisuse(code, kind, block) {
 	return null;
 }
 const NO_LIBRARY = /* @__PURE__ */ new Map();
-/** Libraries by catalog, then by recipe list. */
+/** Libraries by catalog, then by jig list. */
 const libraryCache = /* @__PURE__ */ new WeakMap();
 function propSpec(spec, name) {
 	const props = spec.props;
@@ -109,37 +109,37 @@ function treeHasSlot(nodes) {
 	}
 	return false;
 }
-function readDefine(node, diagnostics, libraryNames, components) {
+function readDefine(node, findings, libraryNames, components) {
 	const nameProp = node.props.find((prop) => prop.name === "name");
 	const name = nameProp !== void 0 && nameProp.shorthand !== true && nameProp.value.kind === "literal" && typeof nameProp.value.value === "string" ? nameProp.value.value : null;
 	if (name === null) {
-		diagnostics.push({
+		findings.push({
 			code: "invalid_define",
 			...placeOf(node),
 			message: `<define> needs name="componentName"; it was removed`,
-			severity: "warning"
+			severity: "error"
 		});
 		return null;
 	}
 	if (componentSpec(components, name) !== void 0 || RESERVED_TAGS.has(name)) {
-		diagnostics.push({
+		findings.push({
 			code: "invalid_define",
 			...placeOf(node),
 			message: `<define name="${name}"> clashes with <${name}>; it was removed`,
-			severity: "warning"
+			severity: "error"
 		});
 		return null;
 	}
 	if (!isBindingName(name)) {
-		diagnostics.push({
+		findings.push({
 			code: "invalid_define",
 			...placeOf(node),
 			message: `<define name="${name}"> is not a usable component name; it was removed`,
-			severity: "warning"
+			severity: "error"
 		});
 		return null;
 	}
-	if (libraryNames.has(name)) diagnostics.push({
+	if (libraryNames.has(name)) findings.push({
 		code: "shadows_library",
 		...placeOf(node),
 		message: `<define name="${name}"> overrides the library component`,
@@ -150,38 +150,38 @@ function readDefine(node, diagnostics, libraryNames, components) {
 	for (const prop of node.props) {
 		if (prop === nameProp) continue;
 		if (prop.name === "key") {
-			diagnostics.push({
+			findings.push({
 				code: "invalid_define",
 				...placeOf(node, prop),
 				message: `<define name="${name}"> prop "key" is reserved for the instance; it was removed`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
 		if (prop.name === "name") {
-			diagnostics.push({
+			findings.push({
 				code: "invalid_define",
 				...placeOf(node, prop),
 				message: `<define name="${name}"> cannot take a prop called "name", which names the define itself; call it "title" or "label". It was removed`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
 		if (prop.name === "children" || !isBindingName(prop.name)) {
-			diagnostics.push({
+			findings.push({
 				code: "invalid_define",
 				...placeOf(node, prop),
 				message: `<define name="${name}"> prop "${prop.name}" is not a usable name; it was removed`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
 		if (seen.has(prop.name)) {
-			diagnostics.push({
+			findings.push({
 				code: "invalid_define",
 				...placeOf(node, prop),
 				message: `<define name="${name}"> prop "${prop.name}" is duplicated; the later one was removed`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
@@ -355,13 +355,13 @@ function placeOfCode(code) {
 	};
 }
 const codeAt = (value) => value?.kind === "expr" ? value.at : void 0;
-function validateControl(node, name, children, statements, diagnostics) {
-	const warn = (code, message, prop) => {
-		diagnostics.push({
+function validateControl(node, name, children, statements, findings) {
+	const reject = (code, message, prop) => {
+		findings.push({
 			code,
 			...placeOf(node, prop),
 			message,
-			severity: "warning"
+			severity: "error"
 		});
 	};
 	const props = new Map(node.props.map((prop) => [prop.name, prop.value]));
@@ -369,21 +369,21 @@ function validateControl(node, name, children, statements, diagnostics) {
 		if (controlProps[name].some((allowed) => allowed === prop.name)) continue;
 		const fix = name === "each" && prop.name === "key" ? dropAttribute(node, index) : null;
 		if (fix === null) {
-			warn("unknown_prop", `<${name}> has no prop "${prop.name}"`, prop);
+			reject("unknown_prop", `<${name}> has no prop "${prop.name}"`, prop);
 			continue;
 		}
-		diagnostics.push({
+		findings.push({
 			code: "unknown_prop",
 			...placeOf(node, prop),
 			fix,
 			message: "<each> has no prop \"key\": items are keyed by their own `id` or `key`",
-			severity: "warning"
+			severity: "error"
 		});
 	}
 	if (name === "if") {
 		const test = asCode(props.get("test"));
 		if (test === null) {
-			warn("invalid_control", "<if> needs test={condition}; it was removed");
+			reject("invalid_control", "<if> needs test={condition}; it was removed");
 			return [];
 		}
 		const testAt = codeAt(props.get("test"));
@@ -399,14 +399,14 @@ function validateControl(node, name, children, statements, diagnostics) {
 	const items = asCode(props.get("of"));
 	const itemsAt = codeAt(props.get("of"));
 	if (items === null) {
-		warn("invalid_control", "<each> needs of={list}; it was removed");
+		reject("invalid_control", "<each> needs of={list}; it was removed");
 		return [];
 	}
 	const binding = (prop, fallback) => {
 		const value = props.get(prop);
 		if (value === void 0) return fallback;
 		if (value.kind === "literal" && isBindingName(String(value.value))) return String(value.value);
-		warn("invalid_control", `<each ${prop}> must be a plain variable name like "item"; using ${fallback === null ? "none" : `"${fallback}"`}`);
+		reject("invalid_control", `<each ${prop}> must be a plain variable name like "item"; using ${fallback === null ? "none" : `"${fallback}"`}`);
 		return fallback;
 	};
 	return [{
@@ -422,25 +422,25 @@ function validateControl(node, name, children, statements, diagnostics) {
 }
 function validateSlot(node, state) {
 	if (!state.inDefine) {
-		state.diagnostics.push({
+		state.findings.push({
 			code: "invalid_define",
 			...placeOf(node),
 			message: "<slot> is only allowed inside <define>; it was removed",
-			severity: "warning"
+			severity: "error"
 		});
 		return [];
 	}
-	for (const prop of node.props) state.diagnostics.push({
+	for (const prop of node.props) state.findings.push({
 		code: "unknown_prop",
 		...placeOf(node, prop),
 		message: `<slot> has no prop "${prop.name}"`,
-		severity: "warning"
+		severity: "error"
 	});
-	if (node.children.length > 0) state.diagnostics.push({
+	if (node.children.length > 0) state.findings.push({
 		code: "unexpected_children",
 		...placeOf(node),
 		message: "<slot> takes no children; they were dropped",
-		severity: "warning"
+		severity: "error"
 	});
 	return [{
 		line: node.line,
@@ -448,15 +448,15 @@ function validateSlot(node, state) {
 	}];
 }
 /** Keeps the first `<slot/>` that survived validation and drops the rest. */
-function trimExtraSlots(nodes, defineName, diagnostics, seen) {
+function trimExtraSlots(nodes, defineName, findings, seen) {
 	return nodes.flatMap((node) => {
 		if (node.type === "slot") {
 			if (seen.count > 0) {
-				diagnostics.push({
+				findings.push({
 					code: "invalid_define",
 					...placeOf(node),
 					message: `<${defineName}> already has a <slot>; this one was removed`,
-					severity: "warning"
+					severity: "error"
 				});
 				return [];
 			}
@@ -465,7 +465,7 @@ function trimExtraSlots(nodes, defineName, diagnostics, seen) {
 		}
 		if (node.type === "call" || node.type === "each" || node.type === "element" || node.type === "if") return [{
 			...node,
-			children: trimExtraSlots(node.children, defineName, diagnostics, seen)
+			children: trimExtraSlots(node.children, defineName, findings, seen)
 		}];
 		return [node];
 	});
@@ -480,11 +480,11 @@ function validateCall(node, def, state, scope) {
 	for (const prop of node.props) {
 		if (prop.name === "key") {
 			if (prop.value.kind === "literal" && typeof prop.value.value !== "string" && typeof prop.value.value !== "number") {
-				state.diagnostics.push({
+				state.findings.push({
 					code: "invalid_literal",
 					...placeOf(node, prop),
 					message: `<${def.name} key={${JSON.stringify(prop.value.value)}}> must be a string or number`,
-					severity: "warning"
+					severity: "error"
 				});
 				continue;
 			}
@@ -494,17 +494,17 @@ function validateCall(node, def, state, scope) {
 		const spec = known.get(prop.name);
 		if (spec === void 0) {
 			const near = nearest(prop.name, known.keys(), 1)[0];
-			state.diagnostics.push({
+			state.findings.push({
 				code: "unknown_prop",
 				...placeOf(node, prop),
 				message: near === void 0 ? `<${def.name}> has no prop "${prop.name}"` : `<${def.name}> has no prop "${prop.name}"; did you mean ${near}?`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
 		if (spec.kind === "number" && prop.value.kind === "literal" && typeof prop.value.value === "string" && NUMERIC.test(prop.value.value)) {
 			const value = Number(prop.value.value);
-			state.diagnostics.push({
+			state.findings.push({
 				code: "coerced",
 				...placeOf(node, prop),
 				message: `<${def.name} ${writtenProp(prop)}> is text; it was read as ${prop.name}={${String(value)}}. Write numbers in braces`,
@@ -517,27 +517,27 @@ function validateCall(node, def, state, scope) {
 			continue;
 		}
 		if (prop.value.kind === "literal" && spec.kind !== null && typeof prop.value.value !== spec.kind) {
-			state.diagnostics.push({
+			state.findings.push({
 				code: "invalid_literal",
 				...placeOf(node, prop),
 				message: `<${def.name} ${writtenProp(prop)}> does not match a ${spec.kind} value`,
-				severity: "warning"
+				severity: "error"
 			});
 			continue;
 		}
 		props[prop.name] = prop.value;
 	}
-	for (const spec of def.props) if (spec.required && !Object.hasOwn(props, spec.name)) state.diagnostics.push({
+	for (const spec of def.props) if (spec.required && !Object.hasOwn(props, spec.name)) state.findings.push({
 		code: "missing_prop",
 		...placeOf(node),
 		message: `<${def.name}> is missing required prop "${spec.name}"`,
-		severity: "warning"
+		severity: "error"
 	});
-	if (!def.hasSlot && def.incomplete !== true && children.length > 0) state.diagnostics.push({
+	if (!def.hasSlot && def.incomplete !== true && children.length > 0) state.findings.push({
 		code: "unexpected_children",
 		...placeOf(node),
 		message: `<${def.name}> has no <slot>, so its children were dropped`,
-		severity: "warning"
+		severity: "error"
 	});
 	return [{
 		children: def.hasSlot ? children : [],
@@ -562,14 +562,14 @@ function validateNodes(nodes, state, scope) {
 			if (misuse !== null) {
 				const inBlock = scope.block === "each" || scope.block === "if";
 				const hoist = inBlock ? state.hoists.byStart.get(node.start) : void 0;
-				const diagnostic = {
+				const finding = {
 					code: inBlock ? "invalid_statement" : "hook_placement",
 					...placeOfCode(node),
 					message: `${misuse.message}${hoist?.reason === null || hoist?.reason === void 0 ? "" : `; it can't move out by itself, as it ${hoist.reason}`}. The statement was removed`,
-					severity: "warning"
+					severity: "error"
 				};
-				if (hoist?.fix) diagnostic.fix = hoist.fix;
-				state.diagnostics.push(diagnostic);
+				if (hoist?.fix) finding.fix = hoist.fix;
+				state.findings.push(finding);
 				for (const name of misuse.declared) state.dropped.add(name);
 				return [];
 			}
@@ -585,11 +585,11 @@ function validateNodes(nodes, state, scope) {
 		if (node.type === "expr") {
 			const misuse = hookMisuse(node.code, "expression", scope.block);
 			if (misuse !== null) {
-				state.diagnostics.push({
+				state.findings.push({
 					code: "hook_placement",
 					...placeOfCode(node),
 					message: `${misuse.message}. The expression was removed`,
-					severity: "warning"
+					severity: "error"
 				});
 				return [];
 			}
@@ -597,11 +597,11 @@ function validateNodes(nodes, state, scope) {
 		}
 		if (node.type !== "element") return [node];
 		if (node.name === "define") {
-			state.diagnostics.push({
+			state.findings.push({
 				code: "invalid_define",
 				...placeOf(node),
 				message: "<define> is only allowed at the top level; it was removed",
-				severity: "warning"
+				severity: "error"
 			});
 			return [];
 		}
@@ -612,18 +612,18 @@ function validateNodes(nodes, state, scope) {
 				block: node.name,
 				statements
 			});
-			return validateControl(node, node.name, children, statements, state.diagnostics);
+			return validateControl(node, node.name, children, statements, state.findings);
 		}
 		const defined = state.defines.get(node.name);
 		if (defined !== void 0) return validateCall(node, defined, state, scope);
 		const children = validateNodes(node.children, state, scope);
 		const spec = componentSpec(state.catalog, node.name);
 		if (spec === void 0) {
-			state.diagnostics.push({
+			state.findings.push({
 				code: "unknown_component",
 				...placeOf(node),
 				message: unknownComponentMessage(node.name, state.defines, state.catalog),
-				severity: "warning"
+				severity: "error"
 			});
 			return children;
 		}
@@ -634,29 +634,29 @@ function validateNodes(nodes, state, scope) {
 			const propDefinition = propSpec(spec, prop.name);
 			if (propDefinition === void 0) {
 				const wrap = flexWrap(node, prop, state.catalog);
-				const diagnostic = {
+				const finding = {
 					code: "unknown_prop",
 					...placeOf(node, prop),
 					message: wrap === null ? unknownPropMessage(component, prop.name, spec.props) : `<${component}> has no prop "flex"; wrap it in <box ${wrap.written}>`,
-					severity: "warning"
+					severity: "error"
 				};
-				if (wrap !== null) diagnostic.fix = wrap.fix;
-				state.diagnostics.push(diagnostic);
+				if (wrap !== null) finding.fix = wrap.fix;
+				state.findings.push(finding);
 				continue;
 			}
 			const misuse = prop.value.kind === "expr" ? hookMisuse(prop.value.code, "expression", scope.block) : null;
 			if (misuse !== null) {
-				state.diagnostics.push({
+				state.findings.push({
 					code: "hook_placement",
 					...placeOf(node, prop),
 					message: `<${component} ${prop.name}={…}>: ${misuse.message}. The prop was removed`,
-					severity: "warning"
+					severity: "error"
 				});
 				continue;
 			}
 			const coerced = coerceNumber(propDefinition, prop.value);
 			if (coerced !== null && coerced.kind === "literal") {
-				state.diagnostics.push({
+				state.findings.push({
 					code: "coerced",
 					...placeOf(node, prop),
 					message: `<${component} ${writtenProp(prop)}> is text; it was read as ${prop.name}={${String(coerced.value)}}. Write numbers in braces`,
@@ -666,22 +666,22 @@ function validateNodes(nodes, state, scope) {
 				continue;
 			}
 			if (prop.value.kind === "literal" && !isValidValue(propDefinition, prop.value.value)) {
-				state.diagnostics.push({
+				state.findings.push({
 					code: "invalid_literal",
 					...placeOf(node, prop),
 					message: `<${component} ${writtenProp(prop)}> does not match ${describe(propDefinition, prop.value.value)}`,
-					severity: "warning"
+					severity: "error"
 				});
 				continue;
 			}
 			props[prop.name] = prop.value;
 		}
 		const allowsChildren = spec.children !== "none";
-		if (!allowsChildren && children.length > 0) state.diagnostics.push({
+		if (!allowsChildren && children.length > 0) state.findings.push({
 			code: "unexpected_children",
 			...placeOf(node),
 			message: `<${component}> takes no children; they were dropped`,
-			severity: "warning"
+			severity: "error"
 		});
 		return [{
 			children: allowsChildren ? children : [],
@@ -738,7 +738,7 @@ function emittedDefines(tree, docDefines, available) {
 }
 /**
 * Static call sites in the document tree and in document-local define bodies.
-* A tag inside a library recipe is not counted again.
+* A tag inside a library jig is not counted again.
 */
 function countUses(tree, docDefines) {
 	const counts = /* @__PURE__ */ new Map();
@@ -756,7 +756,7 @@ function countUses(tree, docDefines) {
 }
 function compileDocument(source, library, components) {
 	const document = parseJigs(source);
-	const diagnostics = [...document.repairs.map((repair) => ({
+	const findings = [...document.repairs.map((repair) => ({
 		code: "repaired",
 		...placeOf(repair),
 		message: repair.message,
@@ -765,7 +765,7 @@ function compileDocument(source, library, components) {
 		code: "unclosed",
 		...placeOf(error),
 		message: error.message,
-		severity: "warning"
+		severity: "error"
 	}))];
 	const libraryNames = new Set(library.keys());
 	const docDefines = [];
@@ -774,14 +774,14 @@ function compileDocument(source, library, components) {
 	const docNames = /* @__PURE__ */ new Set();
 	for (const node of document.children) {
 		if (node.type === "element" && node.name === "define") {
-			const def = readDefine(node, diagnostics, libraryNames, components);
+			const def = readDefine(node, findings, libraryNames, components);
 			if (def === null) continue;
 			if (docNames.has(def.name)) {
-				diagnostics.push({
+				findings.push({
 					code: "invalid_define",
 					...placeOf(node),
 					message: `<define name="${def.name}"> is already defined; this one was removed`,
-					severity: "warning"
+					severity: "error"
 				});
 				continue;
 			}
@@ -801,8 +801,8 @@ function compileDocument(source, library, components) {
 		catalog: components,
 		defineName: null,
 		defines: available,
-		diagnostics,
 		dropped,
+		findings,
 		hoists,
 		inDefine: false,
 		ordinals: /* @__PURE__ */ new Map()
@@ -813,15 +813,15 @@ function compileDocument(source, library, components) {
 			catalog: components,
 			defineName: def.name,
 			defines: available,
-			diagnostics,
 			dropped,
+			findings,
 			hoists,
 			inDefine: true,
 			ordinals: /* @__PURE__ */ new Map()
 		}, {
 			block: "define",
 			statements
-		}), def.name, diagnostics, { count: 0 });
+		}), def.name, findings, { count: 0 });
 		def.statements = statements;
 	}
 	const statements = [];
@@ -831,11 +831,11 @@ function compileDocument(source, library, components) {
 			statements.push(statement);
 			continue;
 		}
-		diagnostics.push({
+		findings.push({
 			code: "hook_placement",
 			...placeOfCode(statement),
 			message: `${misuse.message}. The statement was removed`,
-			severity: "warning"
+			severity: "error"
 		});
 		for (const name of misuse.declared) dropped.add(name);
 	}
@@ -843,17 +843,14 @@ function compileDocument(source, library, components) {
 		block: null,
 		statements
 	});
-	const uses = checkCode(tree, docDefines, statements, diagnostics, hoists, dropped);
+	const uses = checkCode(tree, docDefines, statements, findings, hoists, dropped);
 	const generated = generateProgram(statements, tree, emittedDefines(tree, docDefines, available));
-	diagnostics.push(...generated.diagnostics);
-	for (const diagnostic of diagnostics) if (diagnostic.start !== void 0) {
-		diagnostic.line = lineAt(source, diagnostic.start);
-		diagnostic.column = columnAt(source, diagnostic.start);
-	}
-	diagnostics.sort((a, b) => a.line - b.line);
+	findings.push(...generated.findings);
+	for (const finding of findings) if (finding.start !== void 0) finding.line = lineAt(source, finding.start);
+	findings.sort((a, b) => a.line - b.line);
 	return {
 		defines: docDefines,
-		diagnostics,
+		findings,
 		library,
 		output: generated.output,
 		procedures: uses.procedures,
@@ -868,14 +865,14 @@ function compileDocument(source, library, components) {
 }
 function buildLibrary(list, components) {
 	const built = /* @__PURE__ */ new Map();
-	for (const recipe of list) {
-		if (built.has(recipe.name)) throw new Error(`Recipe name "${recipe.name}" is duplicated`);
-		const result = compileDocument(recipe.source, built, components);
-		const problem = result.diagnostics[0];
-		if (problem !== void 0) throw new Error(`Recipe "${recipe.name}" failed to compile: line ${problem.line}: ${problem.message}`);
+	for (const jig of list) {
+		if (built.has(jig.name)) throw new Error(`Jig name "${jig.name}" is duplicated`);
+		const result = compileDocument(jig.source, built, components);
+		const problem = result.findings[0];
+		if (problem !== void 0) throw new Error(`Jig "${jig.name}" failed to compile: line ${problem.line}: ${problem.message}`);
 		const def = result.defines[0];
-		if (result.defines.length !== 1 || def === void 0) throw new Error(`Recipe "${recipe.name}" must contain exactly one <define>`);
-		if (def.name !== recipe.name) throw new Error(`Recipe "${recipe.name}" defines <${def.name}> instead`);
+		if (result.defines.length !== 1 || def === void 0) throw new Error(`Jig "${jig.name}" must contain exactly one <define>`);
+		if (def.name !== jig.name) throw new Error(`Jig "${jig.name}" defines <${def.name}> instead`);
 		built.set(def.name, {
 			...def,
 			origin: "library",
@@ -885,17 +882,17 @@ function buildLibrary(list, components) {
 	return built;
 }
 /**
-* Compiles `recipes` against `catalog`, in order: a recipe may use the ones
-* before it. Throws when a recipe has any diagnostic. Cached per catalog and
-* recipe list.
+* Compiles `jigs` against `catalog`, in order: a jig may use the ones
+* before it. Throws when a jig has any diagnostic. Cached per catalog and
+* jig list.
 */
-function compileLibrary(recipes, catalog) {
-	const byRecipes = libraryCache.get(catalog) ?? /* @__PURE__ */ new WeakMap();
-	libraryCache.set(catalog, byRecipes);
-	const existing = byRecipes.get(recipes);
+function compileLibrary(jigs, catalog) {
+	const byJigs = libraryCache.get(catalog) ?? /* @__PURE__ */ new WeakMap();
+	libraryCache.set(catalog, byJigs);
+	const existing = byJigs.get(jigs);
 	if (existing !== void 0) return existing;
-	const built = buildLibrary(recipes, catalog);
-	byRecipes.set(recipes, built);
+	const built = buildLibrary(jigs, catalog);
+	byJigs.set(jigs, built);
 	return built;
 }
 /** `source` with the fixes' edits applied. */
@@ -917,34 +914,57 @@ function applyFixes(source, fixes) {
 		text
 	};
 }
-const problems = (diagnostics) => diagnostics.filter((diagnostic) => diagnostic.severity === "warning").length;
+const problems = (findings) => findings.filter((finding) => finding.severity === "error").length;
+/** `finding` as a `Diagnostic`, its spans counted in `source`. */
+function toDiagnostic(source, finding) {
+	const diagnostic = {
+		code: finding.code,
+		message: finding.message,
+		severity: finding.severity,
+		span: spanIn(source, finding)
+	};
+	if (finding.fix !== void 0) diagnostic.fix = {
+		edits: finding.fix.edits.map((edit) => ({
+			span: rangeIn(source, edit.start, edit.end),
+			text: edit.text
+		})),
+		title: finding.fix.title
+	};
+	return diagnostic;
+}
+/** `document`'s result, reporting `findings` as diagnostics of `source`. */
+function withDiagnostics({ findings: _, ...result }, source, findings) {
+	return {
+		...result,
+		diagnostics: findings.map((finding) => toDiagnostic(source, finding))
+	};
+}
 /**
-* Compiles a document. A warning that carries a fix is applied rather than
+* Compiles a document. An error that carries a fix is applied rather than
 * sent to the model: the fixed source is compiled again, and when it has
 * exactly the problems left that the fixes did not cover, its program is
-* used and those warnings become `info`, as a quoted number on a number prop
+* used and those errors become `info`, as a quoted number on a number prop
 * already is. Diagnostics, procedures and their spans stay those of `source`,
 * which is what the model wrote and what the session keeps.
 */
 function compileJigs(source, options) {
 	const library = options.library ?? NO_LIBRARY;
 	const result = compileDocument(source, library, options.catalog);
-	const fixes = new Set(result.diagnostics.flatMap((diagnostic) => diagnostic.severity === "warning" && diagnostic.fix !== void 0 ? [diagnostic.fix] : []));
-	if (fixes.size === 0) return result;
+	const fixes = new Set(result.findings.flatMap((finding) => finding.severity === "error" && finding.fix !== void 0 ? [finding.fix] : []));
+	if (fixes.size === 0) return withDiagnostics(result, source, result.findings);
 	const patched = applyFixes(source, [...fixes]);
 	const fixed = compileDocument(patched.text, library, options.catalog);
-	const covered = result.diagnostics.filter((diagnostic) => diagnostic.fix !== void 0 && patched.applied.has(diagnostic.fix)).length;
-	if (problems(fixed.diagnostics) !== problems(result.diagnostics) - covered) return result;
-	return {
+	const covered = result.findings.filter((finding) => finding.fix !== void 0 && patched.applied.has(finding.fix)).length;
+	if (problems(fixed.findings) !== problems(result.findings) - covered) return withDiagnostics(result, source, result.findings);
+	return withDiagnostics({
 		...fixed,
-		diagnostics: result.diagnostics.map((diagnostic) => diagnostic.fix !== void 0 && patched.applied.has(diagnostic.fix) ? {
-			...diagnostic,
-			message: `${diagnostic.message}; the compiler made that change`,
-			severity: "info"
-		} : diagnostic),
 		procedures: result.procedures,
 		reads: result.reads
-	};
+	}, source, result.findings.map((finding) => finding.fix !== void 0 && patched.applied.has(finding.fix) ? {
+		...finding,
+		message: `${finding.message}; the compiler made that change`,
+		severity: "info"
+	} : finding));
 }
 //#endregion
 export { compileJigs, compileLibrary };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { columnAt, lineAt } from "./offsets.js";
+import { columnAt, lineAt, rangeIn, spanIn } from "./offsets.js";
 import { JigsNode, Statement } from "./ast.js";
 import { CompileCatalog, ComponentSpec, PropSpec } from "./spec.js";
 import { ProgramOutput } from "./codegen.js";
-import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, Library, Program, Recipe, RenderNode, compileJigs, compileLibrary } from "./compile.js";
+import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, Jig, Library, Program, RenderNode, compileJigs, compileLibrary } from "./compile.js";
 import { DataRead, ELEMENT, ProcedureUse } from "./check-code.js";
 import { Hoisted, hoistDeclarations } from "./hoist.js";
 import { parseJigs } from "./parse.js";
 import { nearest } from "./suggest.js";
-import { recipeSignature } from "./signature.js";
+import { jigSignature } from "./signature.js";
 import { Edit, EditFailure, EditFailureReason, SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
-export { type CompileCatalog, type CompileOptions, type CompileResult, type CompiledDefine, type ComponentSpec, type DataRead, type Diagnostic, ELEMENT, type Edit, type EditFailure, type EditFailureReason, type Hoisted, type JigsNode, type Library, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, type Recipe, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parseJigs, recipeSignature };
+export { type CompileCatalog, type CompileOptions, type CompileResult, type CompiledDefine, type ComponentSpec, type DataRead, type Diagnostic, ELEMENT, type Edit, type EditFailure, type EditFailureReason, type Hoisted, type Jig, type JigsNode, type Library, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };

package/dist/index.js

@@ -1,9 +1,9 @@
-import { columnAt, lineAt } from "./offsets.js";
+import { columnAt, lineAt, rangeIn, spanIn } from "./offsets.js";
 import { nearest } from "./suggest.js";
 import { ELEMENT } from "./check-code.js";
 import { parseJigs } from "./parse.js";
 import { hoistDeclarations } from "./hoist.js";
 import { compileJigs, compileLibrary } from "./compile.js";
-import { recipeSignature } from "./signature.js";
+import { jigSignature } from "./signature.js";
 import { SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
-export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parseJigs, recipeSignature };
+export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, spanIn };

package/dist/offsets.d.ts

@@ -1,3 +1,4 @@
+import { Span } from "@jigs.design/protocol";
 //#region src/offsets.d.ts
 /**
  * Where text the parser cut out sits in the source. Each entry is
@@ -15,4 +16,12 @@ export interface Range {
 export declare function columnAt(source: string, offset: number): number;
 /** The 1-based line of `offset` in `source`. */
 export declare function lineAt(source: string, offset: number): number;
+/** The span of `[start, end)` in `source`: its line, column and range. */
+export declare function rangeIn(source: string, start: number, end: number): Span;
+/** The span of `place` in `source`: its line, and its range and column when it has one. */
+export declare function spanIn(source: string, place: {
+  end?: number;
+  line: number;
+  start?: number;
+}): Span;
 //#endregion

package/dist/offsets.js

@@ -36,5 +36,18 @@ function lineAt(source, offset) {
 	for (let newline = source.indexOf("\n"); newline !== -1 && newline < offset; newline = source.indexOf("\n", newline + 1)) line++;
 	return line;
 }
+/** The span of `[start, end)` in `source`: its line, column and range. */
+function rangeIn(source, start, end) {
+	return {
+		column: columnAt(source, start),
+		end,
+		line: lineAt(source, start),
+		start
+	};
+}
+/** The span of `place` in `source`: its line, and its range and column when it has one. */
+function spanIn(source, place) {
+	return place.start === void 0 || place.end === void 0 ? { line: place.line } : rangeIn(source, place.start, place.end);
+}
 //#endregion
-export { columnAt, extendMap, lineAt, sliceMap, sourceOffset, sourceRange };
+export { columnAt, extendMap, lineAt, rangeIn, sliceMap, sourceOffset, sourceRange, spanIn };

package/dist/patch.d.ts

@@ -13,11 +13,13 @@ export declare function isEditReply(text: string): boolean | null;
 export declare function parseEdits(text: string): Array<Edit>;
 /**
  * Why an edit was rejected. `missing`: its SEARCH is not in the document.
- * `ambiguous`: its SEARCH is there more than once. `malformed`: the block
- * itself is broken. `broken`: it applied, but the result needs parser repairs
- * the document did not (see `editBreakage`); the server reports this one.
+ * `ambiguous`: its SEARCH is there more than once. `overlapping`: its SEARCH
+ * spans lines an earlier edit of the same reply also changes. `malformed`:
+ * the block itself is broken. `broken`: it applied, but the result needs
+ * parser repairs the document did not (see `editBreakage`); the server
+ * reports this one.
  */
-export type EditFailureReason = "ambiguous" | "broken" | "malformed" | "missing";
+export type EditFailureReason = "ambiguous" | "broken" | "malformed" | "missing" | "overlapping";
 export interface EditFailure {
   /** For `broken`: the repairs the edited document needs and the base did not. */
   breakage?: ReadonlyArray<{
@@ -25,8 +27,13 @@ export interface EditFailure {
     message: string;
   }>;
   failed: Edit;
-  /** For `ambiguous`: the line each match starts on. */
+  /**
+   * For `ambiguous`: the line each match starts on. For `overlapping`: the
+   * line the earlier edit's SEARCH starts on, then this one's.
+   */
   lines?: ReadonlyArray<number>;
+  /** For `overlapping`: the earlier edit whose lines this one also changes. */
+  overlaps?: Edit;
   reason: EditFailureReason;
 }
 export type ApplyResult = (EditFailure & {
@@ -36,10 +43,15 @@ export type ApplyResult = (EditFailure & {
   text: string;
 };
 /**
- * Applies edits in order. Each SEARCH must appear in the document exactly
- * once, exactly or ignoring indentation; an empty SEARCH appends. Stops at
- * the first edit that doesn't match, matches more than once, or whose
- * REPLACE still contains edit markers.
+ * Applies a reply's edits to the document it was written against. Every
+ * SEARCH is located in that document first, exactly or ignoring
+ * indentation, and must be there once; the replacements are then made from
+ * the end, so one edit's REPLACE never moves or breaks another's anchor. An
+ * empty SEARCH appends. A SEARCH that is not in the document, or that spans
+ * lines an earlier edit's SEARCH spans, applies to the text as the edits
+ * before it leave it when it is there once, as edits written one after
+ * another; the edits after it anchor to that text. Otherwise it fails as
+ * `missing` or `overlapping`. Stops at the first edit that fails.
  */
 export declare function applyEdits(base: string, edits: ReadonlyArray<Edit>): ApplyResult;
 /**

package/dist/patch.js

@@ -40,18 +40,39 @@ function parseEdits(text) {
 	}
 	return edits;
 }
-/** Starts of every line range in `lines` matching `search` when leading and trailing whitespace is ignored. */
-function findLoose(lines, search) {
-	const target = search.map((line) => line.trim());
-	const starts = [];
-	for (let start = 0; start + target.length <= lines.length; start++) if (target.every((line, offset) => lines[start + offset]?.trim() === line)) starts.push(start);
-	return starts;
+/** Every line range of `text` matching `search` when leading and trailing whitespace is ignored. */
+function findLoose(text, search) {
+	const lines = text.split("\n");
+	const target = search.split("\n").map((line) => line.trim());
+	const offsets = [];
+	let offset = 0;
+	for (const line of lines) {
+		offsets.push(offset);
+		offset += line.length + 1;
+	}
+	const ranges = [];
+	for (let start = 0; start + target.length <= lines.length; start++) {
+		const last = start + target.length - 1;
+		if (target.every((line, index) => lines[start + index]?.trim() === line)) ranges.push({
+			end: (offsets[last] ?? 0) + (lines[last]?.length ?? 0),
+			start: offsets[start] ?? 0
+		});
+	}
+	return ranges;
 }
-/** Every index at which `search` occurs in `text`, without overlaps. */
+/** Every range at which `search` occurs in `text`, without overlaps. */
 function findExact(text, search) {
-	const indexes = [];
-	for (let index = text.indexOf(search); index !== -1; index = text.indexOf(search, index + search.length)) indexes.push(index);
-	return indexes;
+	const ranges = [];
+	for (let index = text.indexOf(search); index !== -1; index = text.indexOf(search, index + search.length)) ranges.push({
+		end: index + search.length,
+		start: index
+	});
+	return ranges;
+}
+/** Where `search` is in `text`: exactly if it is there, else ignoring indentation. */
+function locate(text, search) {
+	const exact = findExact(text, search);
+	return exact.length > 0 ? exact : findLoose(text, search);
 }
 const lineAt = (text, index) => text.slice(0, index).split("\n").length;
 const MARKERS = /* @__PURE__ */ new Set([
@@ -61,13 +82,31 @@ const MARKERS = /* @__PURE__ */ new Set([
 ]);
 const hasMarker = (text) => text.split("\n").some((line) => MARKERS.has(line.trim()));
 /**
-* Applies edits in order. Each SEARCH must appear in the document exactly
-* once, exactly or ignoring indentation; an empty SEARCH appends. Stops at
-* the first edit that doesn't match, matches more than once, or whose
-* REPLACE still contains edit markers.
+* `text` with the anchored replacements made from the end, so none moves
+* another's range, then the appends in order.
+*/
+function applyAnchored(text, anchored, appended) {
+	let result = text;
+	const fromEnd = anchored.toSorted((a, b) => b.range.start - a.range.start);
+	for (const place of fromEnd) result = result.slice(0, place.range.start) + place.edit.replace + result.slice(place.range.end);
+	for (const replace of appended) result = `${result.trimEnd()}\n${replace}`;
+	return result;
+}
+/**
+* Applies a reply's edits to the document it was written against. Every
+* SEARCH is located in that document first, exactly or ignoring
+* indentation, and must be there once; the replacements are then made from
+* the end, so one edit's REPLACE never moves or breaks another's anchor. An
+* empty SEARCH appends. A SEARCH that is not in the document, or that spans
+* lines an earlier edit's SEARCH spans, applies to the text as the edits
+* before it leave it when it is there once, as edits written one after
+* another; the edits after it anchor to that text. Otherwise it fails as
+* `missing` or `overlapping`. Stops at the first edit that fails.
 */
 function applyEdits(base, edits) {
 	let text = base;
+	let anchored = [];
+	let appended = [];
 	for (const edit of edits) {
 		if (hasMarker(edit.replace)) return {
 			failed: edit,
@@ -75,42 +114,49 @@ function applyEdits(base, edits) {
 			reason: "malformed"
 		};
 		if (edit.search.trim() === "") {
-			text = `${text.trimEnd()}\n${edit.replace}`;
+			appended.push(edit.replace);
 			continue;
 		}
-		const exact = findExact(text, edit.search);
-		if (exact.length > 1) return {
+		const ranges = locate(text, edit.search);
+		if (ranges.length > 1) return {
 			failed: edit,
-			lines: exact.map((index) => lineAt(text, index)),
+			lines: ranges.map((range) => lineAt(text, range.start)),
 			ok: false,
 			reason: "ambiguous"
 		};
-		const [index] = exact;
-		if (index !== void 0) {
-			text = text.slice(0, index) + edit.replace + text.slice(index + edit.search.length);
+		const [range] = ranges;
+		const overlap = range === void 0 ? void 0 : anchored.find((other) => range.start < other.range.end && other.range.start < range.end);
+		if (range !== void 0 && overlap === void 0) {
+			anchored.push({
+				edit,
+				range
+			});
 			continue;
 		}
-		const lines = text.split("\n");
-		const searchLines = edit.search.split("\n");
-		const starts = findLoose(lines, searchLines);
-		if (starts.length > 1) return {
+		const edited = applyAnchored(text, anchored, appended);
+		const later = locate(edited, edit.search);
+		const [found] = later;
+		if (found === void 0 || later.length > 1) return range === void 0 || overlap === void 0 ? {
 			failed: edit,
-			lines: starts.map((start) => start + 1),
 			ok: false,
-			reason: "ambiguous"
-		};
-		const [start] = starts;
-		if (start === void 0) return {
+			reason: "missing"
+		} : {
 			failed: edit,
+			lines: [lineAt(text, overlap.range.start), lineAt(text, range.start)],
 			ok: false,
-			reason: "missing"
+			overlaps: overlap.edit,
+			reason: "overlapping"
 		};
-		lines.splice(start, searchLines.length, ...edit.replace.split("\n"));
-		text = lines.join("\n");
+		text = edited;
+		anchored = [{
+			edit,
+			range: found
+		}];
+		appended = [];
 	}
 	return {
 		ok: true,
-		text
+		text: applyAnchored(text, anchored, appended)
 	};
 }
 /** Diagnostic codes the parser reports when it changed the source to make it parse. */

package/dist/signature.d.ts

@@ -1,5 +1,5 @@
-import { Recipe } from "./compile.js";
+import { Jig } from "./compile.js";
 //#region src/signature.d.ts
 /** `<statCard label value delta={0} note="">…</statCard>` when the define has a slot. */
-export declare function recipeSignature(recipe: Recipe): string;
+export declare function jigSignature(jig: Jig): string;
 //#endregion

package/dist/signature.js

@@ -14,12 +14,12 @@ function hasSlot(nodes) {
 	return false;
 }
 /** `<statCard label value delta={0} note="">…</statCard>` when the define has a slot. */
-function recipeSignature(recipe) {
-	const define = parseJigs(recipe.source).children.find((node) => node.type === "element" && node.name === "define");
-	if (define === void 0) return `<${recipe.name}>`;
+function jigSignature(jig) {
+	const define = parseJigs(jig.source).children.find((node) => node.type === "element" && node.name === "define");
+	if (define === void 0) return `<${jig.name}>`;
 	const attrs = define.props.filter((prop) => prop.name !== "name").map((prop) => formatAttr(prop));
-	const open = attrs.length === 0 ? `<${recipe.name}>` : `<${recipe.name} ${attrs.join(" ")}>`;
-	return hasSlot(define.children) ? `${open}…</${recipe.name}>` : open;
+	const open = attrs.length === 0 ? `<${jig.name}>` : `<${jig.name} ${attrs.join(" ")}>`;
+	return hasSlot(define.children) ? `${open}…</${jig.name}>` : open;
 }
 //#endregion
-export { recipeSignature };
+export { jigSignature };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jigs.design/compiler",
-  "version": "0.1.2",
-  "description": "Today's Jigs compiler: parser, checker against a catalog, code generator, recipes, and the edit helpers. The v2 rewrite replaces it.",
+  "version": "0.3.0",
+  "description": "Today's Jigs compiler: parser, checker against a catalog, code generator, jig libraries, and the edit helpers. The v2 rewrite replaces it.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,6 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "acorn": "8.19.0"
+    "acorn": "8.19.0",
+    "@jigs.design/protocol": "0.3.0"
   }
 }