@jigs.design/compiler 0.2.0 → 0.3.1

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.
 
 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/compile.d.ts

@@ -110,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>;
@@ -130,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$1>;
-  /** The recipes this document was compiled against. */
+  /** 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>;
@@ -165,11 +165,11 @@ 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. An error that carries a fix is applied rather than
  * sent to the model: the fixed source is compiled again, and when it has

package/dist/compile.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;
@@ -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();
@@ -865,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);
+	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(`Recipe "${recipe.name}" failed to compile: line ${problem.line}: ${problem.message}`);
+		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",
@@ -882,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. */

package/dist/index.d.ts

@@ -2,11 +2,11 @@ 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, rangeIn, recipeSignature, spanIn };
+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

@@ -4,6 +4,6 @@ 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, rangeIn, recipeSignature, spanIn };
+export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, jigSignature, lineAt, nearest, parseEdits, parseJigs, rangeIn, 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.2.0",
-  "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.1",
+  "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",
@@ -26,6 +26,6 @@
   },
   "dependencies": {
     "acorn": "8.19.0",
-    "@jigs.design/protocol": "0.2.0"
+    "@jigs.design/protocol": "0.3.1"
   }
 }