@jigs.design/compiler 0.1.1 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # @jigs.design/compiler
 
-Today's Pickle 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, 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.
 
-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.
 
@@ -10,8 +10,8 @@ The [language RFC](../../docs/language-v2/rfc.md) plans its next changes. It evo
 
 | Export                                                     | What it is                                                       |
 | ---------------------------------------------------------- | ---------------------------------------------------------------- |
-| `parsePickle`                                              | Source to a document tree. Tolerates a prefix cut off mid-stream |
-| `compilePickle`                                            | Checks a document against a catalog and generates its program    |
+| `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              |
 | `isEditReply`, `parseEdits`, `applyEdits`, `SEARCH_MARKER` | Recognise and apply a reply made of SEARCH/REPLACE edits         |

package/dist/ast.d.ts

@@ -28,7 +28,7 @@ export interface PropNode {
 }
 /** `start` and `end` cover the opening tag, or the Markdown that made the element. */
 export interface ElementNode extends Range {
-  children: Array<PickleNode>;
+  children: Array<JigsNode>;
   /** Just past its closing tag, or its own end when self-closing; absent when the parser closed it. */
   closeEnd?: number;
   line: number;
@@ -59,7 +59,7 @@ export interface Statement extends Range {
 interface StatementNode extends Statement {
   type: "statement";
 }
-export type PickleNode = ElementNode | ExprNode | StatementNode | TextNode;
+export type JigsNode = ElementNode | ExprNode | StatementNode | TextNode;
 /** Something the parser fixed or dropped so a partial document still renders. */
 export interface Repair {
   end?: number;
@@ -67,8 +67,8 @@ export interface Repair {
   message: string;
   start?: number;
 }
-export interface PickleDocument {
-  children: Array<PickleNode>;
+export interface JigsDocument {
+  children: Array<JigsNode>;
   /** Text that could not be read even though the input is complete there. */
   errors: Array<Repair>;
   repairs: Array<Repair>;

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

@@ -8,7 +8,7 @@ const ELEMENT = "[]";
 /**
 * Names that do not throw ReferenceError in the sandbox: the language's
 * built-ins, the worker's own globals that `LOCKED_GLOBALS` in
-* `@jigs.design/runtime/frame` leaves in place, and Pickle's bindings. Kept by
+* `@jigs.design/runtime/frame` leaves in place, and Jigs's bindings. Kept by
 * hand, since the compiler runs on the server; `checks.test.ts` fails if a
 * name here is one the worker locks, or exists in no JavaScript runtime.
 * `Function`, `Proxy`, `Reflect`, `WeakRef`, `FinalizationRegistry` and
@@ -45,7 +45,7 @@ const KNOWN_GLOBALS = /* @__PURE__ */ new Set([
 	"NaN",
 	"Number",
 	"Object",
-	"Pickle",
+	"Jigs",
 	"Promise",
 	"RangeError",
 	"ReferenceError",
@@ -66,9 +66,9 @@ const KNOWN_GLOBALS = /* @__PURE__ */ new Set([
 	"Uint8ClampedArray",
 	"WeakMap",
 	"WeakSet",
-	"__pickle",
-	"__pickleConstants",
-	"__pickleSafe",
+	"__jigs",
+	"__jigsConstants",
+	"__jigsSafe",
 	"arguments",
 	"atob",
 	"btoa",
@@ -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

@@ -2,7 +2,7 @@ import { analyze, isValidBinding } from "./script.js";
 //#region src/codegen.ts
 /**
 * Adds `{ key }` to single-argument `useState(...)` and `useMutation(...)`
-* calls, bare or with `Pickle.`, named after the declaration, so state and a
+* calls, bare or with `Jigs.`, named after the declaration, so state and a
 * mutation's status survive recompiles and reordering. The calls come from the
 * parser, so text that only looks like one, in a string or a comment, is left
 * alone.
@@ -32,12 +32,12 @@ function injectStateKeys(code, baseKey) {
 }
 /** Names a spec may not declare: the runtime's own bindings. */
 const RESERVED = /* @__PURE__ */ new Set([
-	"Pickle",
+	"Jigs",
 	"useMutation",
 	"useQuery",
 	"useState"
 ]);
-const isReserved = (name) => RESERVED.has(name) || name.startsWith("__pickle");
+const isReserved = (name) => RESERVED.has(name) || name.startsWith("__jigs");
 /** Whether `name` can be bound as a loop variable without hiding the runtime's own names. */
 function isBindingName(name) {
 	return !isReserved(name) && isValidBinding(name);
@@ -47,30 +47,30 @@ function statementProblem(code) {
 	const analysis = analyze(code, "statement");
 	if (!analysis.ok) return analysis.message.includes("'return' outside of function") ? "`return` can't be used in a {@body} line: the page always renders. To hide markup, wrap it in <if test={…}>. The line was removed" : `{@body} line is not valid JavaScript (${analysis.message}); it was removed`;
 	const reserved = analysis.declared.find(isReserved);
-	return reserved === void 0 ? null : `{@body} line declares "${reserved}", a name Pickle uses itself; rename it. The line was removed`;
+	return reserved === void 0 ? null : `{@body} line declares "${reserved}", a name Jigs uses itself; rename it. The line was removed`;
 }
 /** Why `code` can't be spliced in as an expression, or null when it can. */
 function expressionProblem(code) {
 	const analysis = analyze(code, "expression");
 	return analysis.ok ? null : analysis.message;
 }
-const fragment = (children) => `__pickle.jsx(${[
-	"__pickle.Fragment",
+const fragment = (children) => `__jigs.jsx(${[
+	"__jigs.Fragment",
 	"null",
 	...children
 ].join(", ")})`;
 const documentLines = { line: String };
-const libraryLines = { line: () => "__pickleAt" };
+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. */
@@ -88,7 +88,7 @@ function generateProgram(statements, tree, defines = []) {
 			for (const name of names) declared.add(name);
 			const code = injectStateKeys(statement.code, names[0] ?? `statement:${statement.line}`);
 			const run = names.length === 0 ? `(() => {\n${code}\n})();` : `({ ${names.join(", ")} } = (() => {\n${code}\nreturn { ${names.join(", ")} };\n})());`;
-			body.push(`try {\n${run}\n} catch (error) { Pickle.reportError(${lines.line(statement.line)}, error); }`);
+			body.push(`try {\n${run}\n} catch (error) { Jigs.reportError(${lines.line(statement.line)}, error); }`);
 		}
 		return declared.size > 0 ? [`let ${[...declared].join(", ")};`, ...body] : body;
 	};
@@ -123,7 +123,7 @@ function generateProgram(statements, tree, defines = []) {
 				const params = [node.item, ...node.index === null ? [] : [node.index]];
 				const iteration = [...genStatements(node.statements, lines), `return ${fragment(genChildren(node.children, lines))};`].join("\n");
 				const at = lines.line(node.line);
-				return `__pickleSafe(() => __pickle.each((${node.items}\n), (${params.join(", ")}) => {\n${iteration}\n}, ${at}), null, ${at})`;
+				return `__jigsSafe(() => __jigs.each((${node.items}\n), (${params.join(", ")}) => {\n${iteration}\n}, ${at}), null, ${at})`;
 			}
 			case "if": {
 				const problem = expressionProblem(node.test);
@@ -133,12 +133,12 @@ function generateProgram(statements, tree, defines = []) {
 				}
 				const shown = node.statements.length === 0 ? fragment(genChildren(node.children, lines)) : `(() => {\n${[...genStatements(node.statements, lines), `return ${fragment(genChildren(node.children, lines))};`].join("\n")}\n})()`;
 				const at = lines.line(node.line);
-				return `__pickleSafe(() => (${node.test}\n) ? ${shown} : null, null, ${at})`;
+				return `__jigsSafe(() => (${node.test}\n) ? ${shown} : null, null, ${at})`;
 			}
 			case "text": {
 				const key = String(nextConstant++);
 				constants[key] = node.value;
-				return `__pickleConstants[${JSON.stringify(key)}]`;
+				return `__jigsConstants[${JSON.stringify(key)}]`;
 			}
 			case "expr": {
 				const problem = expressionProblem(node.code);
@@ -146,19 +146,19 @@ function generateProgram(statements, tree, defines = []) {
 					invalid("invalid_expression", node.line, `{${node.code}} is not a valid expression (${problem}); it was removed`);
 					return null;
 				}
-				return `__pickleSafe(() => (${node.code}\n), null, ${lines.line(node.line)})`;
+				return `__jigsSafe(() => (${node.code}\n), null, ${lines.line(node.line)})`;
 			}
 			case "element": {
 				const propEntries = genPropEntries(node.props, node.line, node.component);
 				const children = genChildren(node.children, lines);
-				const element = `__pickle.jsx(${[
+				const element = `__jigs.jsx(${[
 					JSON.stringify(node.component),
 					`{ ${propEntries.props.join(", ")} }`,
 					...children
 				].join(", ")})`;
-				return propEntries.dynamic ? `__pickleSafe(() => ${element}, null, ${lines.line(node.line)})` : element;
+				return propEntries.dynamic ? `__jigsSafe(() => ${element}, null, ${lines.line(node.line)})` : element;
 			}
-			case "slot": return "__pickleChildren";
+			case "slot": return "__jigsChildren";
 			case "call": {
 				const at = lines.line(node.line);
 				const entries = node.key === null ? node.props : {
@@ -169,12 +169,12 @@ function generateProgram(statements, tree, defines = []) {
 				const childExprs = genChildren(node.children, lines);
 				const children = childExprs.length === 0 ? "null" : childExprs.length === 1 ? childExprs[0] ?? "null" : fragment(childExprs);
 				const library = node.origin === "library" ? ", true" : "";
-				return `__pickleSafe(() => __pickle.call(__pickleDef_${node.name}, { ${props.join(", ")} }, ${children}, ${at}, ${node.ordinal}, ${JSON.stringify(node.name)}${library}), null, ${at})`;
+				return `__jigsSafe(() => __jigs.call(__jigsDef_${node.name}, { ${props.join(", ")} }, ${children}, ${at}, ${node.ordinal}, ${JSON.stringify(node.name)}${library}), null, ${at})`;
 			}
 		}
 	};
 	const genBinding = (prop, lines, line) => {
-		const read = `__pickleProps.${prop.name}`;
+		const read = `__jigsProps.${prop.name}`;
 		if (prop.required || prop.defaultValue === null) return `const ${prop.name} = ${read};`;
 		if (prop.defaultValue.kind === "literal") return `const ${prop.name} = ${read} !== undefined ? ${read} : ${JSON.stringify(prop.defaultValue.value)};`;
 		const problem = expressionProblem(prop.defaultValue.code);
@@ -182,7 +182,7 @@ function generateProgram(statements, tree, defines = []) {
 			invalid("invalid_expression", line, `<define ${prop.name}={${prop.defaultValue.code}}> is not a valid expression (${problem}); the default was removed`);
 			return `const ${prop.name} = ${read};`;
 		}
-		return `const ${prop.name} = ${read} !== undefined ? ${read} : __pickleSafe(() => (${prop.defaultValue.code}\n), undefined, ${lines.line(line)});`;
+		return `const ${prop.name} = ${read} !== undefined ? ${read} : __jigsSafe(() => (${prop.defaultValue.code}\n), undefined, ${lines.line(line)});`;
 	};
 	const genDefine = (def) => {
 		const lines = def.origin === "library" ? libraryLines : documentLines;
@@ -190,22 +190,22 @@ function generateProgram(statements, tree, defines = []) {
 		const view = fragment(genChildren(def.body, lines));
 		const bodyStatements = genStatements(def.statements, lines);
 		const body = bodyStatements.length === 0 ? `return ${view};` : `return (() => {\n${bodyStatements.join("\n")}\nreturn ${view};\n})();`;
-		return `function __pickleDef_${def.name}(__pickleProps, __pickleChildren, __pickleAt) {\n${[...bindings, body].join("\n")}\n}`;
+		return `function __jigsDef_${def.name}(__jigsProps, __jigsChildren, __jigsAt) {\n${[...bindings, body].join("\n")}\n}`;
 	};
 	const functions = defines.map((def) => genDefine(def));
 	const children = genChildren(tree, documentLines);
 	return {
-		diagnostics,
+		findings,
 		output: {
 			code: [
 				"\"use strict\";",
-				"const __pickleConstants = Pickle.useConstants();",
-				"const useState = Pickle.useState, useQuery = Pickle.useQuery, useMutation = Pickle.useMutation;",
+				"const __jigsConstants = Jigs.useConstants();",
+				"const useState = Jigs.useState, useQuery = Jigs.useQuery, useMutation = Jigs.useMutation;",
 				...functions,
-				"Pickle.render(__pickle.jsx(() => {",
+				"Jigs.render(__jigs.jsx(() => {",
 				...genStatements(statements, documentLines),
-				`return __pickle.jsx(${[
-					"__pickle.Fragment",
+				`return __jigs.jsx(${[
+					"__jigs.Fragment",
 					"null",
 					...children
 				].join(",\n")});`,

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`. */
@@ -14,27 +15,32 @@ interface FixEdit {
 /**
  * A rewrite that makes a diagnostic's problem go away. The compiler attaches
  * one only when there is a single way to write it, and applies it itself:
- * see `compilePickle`.
+ * see `compileJigs`.
  */
 export interface Fix {
   edits: Array<FixEdit>;
   /** 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;
@@ -123,7 +129,7 @@ export interface Program {
   statements: Array<Statement>;
   tree: Array<RenderNode>;
 }
-/** A reusable component written in Pickle: source with exactly one `<define>`. */
+/** A reusable component written in Jigs: source with exactly one `<define>`. */
 export interface Recipe {
   name: string;
   source: string;
@@ -138,7 +144,7 @@ export interface CompileOptions {
 }
 export interface CompileResult {
   defines: ReadonlyArray<CompiledDefine>;
-  diagnostics: Array<Diagnostic>;
+  diagnostics: Array<Diagnostic$1>;
   /** The recipes this document was compiled against. */
   library: ReadonlyMap<string, CompiledDefine>;
   output: ProgramOutput;
@@ -165,13 +171,13 @@ export interface CompileResult {
  */
 export declare function compileLibrary(recipes: ReadonlyArray<Recipe>, 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 compilePickle(source: string, options: CompileOptions): CompileResult;
+export declare function compileJigs(source: string, options: CompileOptions): CompileResult;
 //#endregion
-export {};
+export { Diagnostic$1 as Diagnostic };

package/dist/compile.js

@@ -1,9 +1,9 @@
 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 { parsePickle } from "./parse.js";
+import { parseJigs } from "./parse.js";
 import { isValidValue } from "./spec.js";
 import { blockHoists } from "./block-hoist.js";
 //#region src/compile.ts
@@ -34,7 +34,7 @@ const HOOK_FORM = {
 	useState: "const [open, setOpen] = useState(false)"
 };
 /**
-* A hook used as a value, written `Pickle.useX`, called inside a handler
+* A hook used as a value, written `Jigs.useX`, called inside a handler
 * or anywhere but as a top-level declaration's initializer, or declared
 * inside `<each>` or `<if>`. Null when the code parses and uses hooks only
 * as it may, or does not parse (the parse error is reported elsewhere).
@@ -50,7 +50,7 @@ function hookMisuse(code, kind, block) {
 	if (value !== void 0) return message(`\`${value.hook}\` is not a value: call it in a {@body} line at the top of the document or of a <define>, \`${HOOK_FORM[value.hook]}\``);
 	const [call] = facts.hookCalls;
 	if (call === void 0) return null;
-	const written = call.prefixed ? `Pickle.${call.hook}` : call.hook;
+	const written = call.prefixed ? `Jigs.${call.hook}` : call.hook;
 	if (block === "each" || block === "if") return message(`${written} ${HOOK_MESSAGE[call.hook][block]}`);
 	if (call.prefixed) return message(`\`${written}\` is not supported: write \`${call.hook}\` without the prefix, \`${HOOK_FORM[call.hook]}\``);
 	if (call.place === "handler") return message(call.hook === "useMutation" ? `\`useMutation(...)\` inside a handler is not supported: declare \`${HOOK_FORM.useMutation}\` in a {@body} line at the top of the document or of a <define>, and call \`archive.mutate(input)\` from the handler` : `\`${call.hook}(...)\` inside a handler is not supported: declare it in a {@body} line at the top of the document or of a <define>, \`${HOOK_FORM[call.hook]}\`, and read it from the handler`);
@@ -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;
 		}
@@ -225,7 +225,7 @@ const TAG_ALIASES = /* @__PURE__ */ new Map([
 	["ul", "list"],
 	["view", "box"]
 ]);
-/** Tags a model writes for control flow that Pickle spells differently. */
+/** Tags a model writes for control flow that Jigs spells differently. */
 const CONTROL_HINTS = /* @__PURE__ */ new Map([
 	["elif", "There is no <elif>: add another <if> with its own test"],
 	["else", "There is no <else>: add a second <if> with the opposite test"],
@@ -243,7 +243,7 @@ function unknownComponentMessage(name, defines, components) {
 	const hint = lookupHint(name, known) ?? (alias !== void 0 && known.includes(alias) ? alias : void 0) ?? nearest(name, known, 1)[0];
 	return hint === void 0 ? `<${name}> is not in the catalog; rendering its children only` : `<${name}> is not in the catalog; did you mean <${hint}>? Rendering its children only`;
 }
-/** Props other UI libraries use, and the name Pickle uses for the same thing. */
+/** Props other UI libraries use, and the name Jigs uses for the same thing. */
 const PROP_ALIASES = /* @__PURE__ */ new Map([
 	["checked", "value"],
 	["onChangeText", "onChange"],
@@ -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 : [],
@@ -755,8 +755,8 @@ function countUses(tree, docDefines) {
 	return [...counts.values()].toSorted((a, b) => a.name.localeCompare(b.name));
 }
 function compileDocument(source, library, components) {
-	const document = parsePickle(source);
-	const diagnostics = [...document.repairs.map((repair) => ({
+	const document = parseJigs(source);
+	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,
@@ -871,7 +868,7 @@ function buildLibrary(list, components) {
 	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];
+		const problem = result.findings[0];
 		if (problem !== void 0) throw new Error(`Recipe "${recipe.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>`);
@@ -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 compilePickle(source, options) {
+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 { compileLibrary, compilePickle };
+export { compileJigs, compileLibrary };

package/dist/hoist.js

@@ -1,6 +1,6 @@
 import { lineAt } from "./offsets.js";
 import { statementOrder } from "./check-code.js";
-import { parsePickle } from "./parse.js";
+import { parseJigs } from "./parse.js";
 //#region src/hoist.ts
 const blank = (line) => (line ?? "").trim() === "";
 /** Tags whose `{@body}` lines are their own, not the page's. */
@@ -31,7 +31,7 @@ function hoistDeclarations(source) {
 	const lines = source.split("\n");
 	/** Each statement's first and last line, 0-based. */
 	const spans = [];
-	const document = parsePickle(source);
+	const document = parseJigs(source);
 	const statements = [...document.statements, ...nested(document.children)].toSorted((a, b) => a.start - b.start);
 	for (const statement of statements) {
 		const last = lineAt(source, statement.end - 1) - 1;

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { columnAt, lineAt } from "./offsets.js";
-import { PickleNode, Statement } from "./ast.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, compileLibrary, compilePickle } from "./compile.js";
+import { CompileOptions, CompileResult, CompiledDefine, Diagnostic, Library, Program, Recipe, RenderNode, compileJigs, compileLibrary } from "./compile.js";
 import { DataRead, ELEMENT, ProcedureUse } from "./check-code.js";
 import { Hoisted, hoistDeclarations } from "./hoist.js";
-import { parsePickle } from "./parse.js";
+import { parseJigs } from "./parse.js";
 import { nearest } from "./suggest.js";
 import { recipeSignature } 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 Library, type PickleNode, type ProcedureUse, type Program, type ProgramOutput, type PropSpec, type Recipe, type RenderNode, SEARCH_MARKER, type Statement, applyEdits, columnAt, compileLibrary, compilePickle, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parsePickle, 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 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 };

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 { parsePickle } from "./parse.js";
+import { parseJigs } from "./parse.js";
 import { hoistDeclarations } from "./hoist.js";
-import { compileLibrary, compilePickle } from "./compile.js";
+import { compileJigs, compileLibrary } from "./compile.js";
 import { recipeSignature } from "./signature.js";
 import { SEARCH_MARKER, applyEdits, editBreakage, isEditReply, parseEdits } from "./patch.js";
-export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileLibrary, compilePickle, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parsePickle, recipeSignature };
+export { ELEMENT, SEARCH_MARKER, applyEdits, columnAt, compileJigs, compileLibrary, editBreakage, hoistDeclarations, isEditReply, lineAt, nearest, parseEdits, parseJigs, rangeIn, recipeSignature, 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/parse.d.ts

@@ -1,7 +1,7 @@
-import { PickleDocument } from "./ast.js";
+import { JigsDocument } from "./ast.js";
 //#region src/parse.d.ts
 /**
- * Parses Pickle: Markdown blocks, catalog tags and `{@body ...}` statements.
+ * Parses Jigs: Markdown blocks, catalog tags and `{@body ...}` statements.
  *
  * Never throws. Partial input (a response that is still being written) is
  * repaired: open elements are closed and a trailing incomplete tag, expression
@@ -12,5 +12,5 @@ import { PickleDocument } from "./ast.js";
  * blank line, unless one of its attributes has a `{` still open. Since that text can't be
  * finished by more streaming, it is reported in `errors`.
  */
-export declare function parsePickle(source: string): PickleDocument;
+export declare function parseJigs(source: string): JigsDocument;
 //#endregion

package/dist/parse.js

@@ -201,7 +201,7 @@ function scanCloseTag(source, start, map) {
 	};
 }
 /**
-* Splits a run of Pickle into tags, `{expressions}` and text. While more input
+* Splits a run of Jigs into tags, `{expressions}` and text. While more input
 * may follow, an unclosed tag or `{` ends the run as `incomplete`. Once
 * `final`, nothing more can arrive: an unclosed `{` is kept as text and an
 * unclosed tag is dropped, each with a problem. `map` gives the source
@@ -436,7 +436,7 @@ function createTreeBuilder(repairs, errors) {
 	};
 	/**
 	* A Markdown block (heading, paragraph, list item) whose content is inline
-	* Pickle. `map` gives the source offsets of `content`.
+	* Jigs. `map` gives the source offsets of `content`.
 	*/
 	const inlineBlock = (name, props, content, line, final, map) => {
 		const range = sourceRange(map, 0, content.length);
@@ -488,7 +488,7 @@ const headingSizes = [
 	"md"
 ];
 /**
-* Parses Pickle: Markdown blocks, catalog tags and `{@body ...}` statements.
+* Parses Jigs: Markdown blocks, catalog tags and `{@body ...}` statements.
 *
 * Never throws. Partial input (a response that is still being written) is
 * repaired: open elements are closed and a trailing incomplete tag, expression
@@ -499,7 +499,7 @@ const headingSizes = [
 * blank line, unless one of its attributes has a `{` still open. Since that text can't be
 * finished by more streaming, it is reported in `errors`.
 */
-function parsePickle(source) {
+function parseJigs(source) {
 	const lines = source.split(/\r?\n/);
 	const lineStarts = [0];
 	for (let newline = source.indexOf("\n"); newline !== -1; newline = source.indexOf("\n", newline + 1)) lineStarts.push(newline + 1);
@@ -687,4 +687,4 @@ function parsePickle(source) {
 	};
 }
 //#endregion
-export { parsePickle };
+export { parseJigs };

package/dist/patch.d.ts

@@ -6,7 +6,7 @@ export interface Edit {
 export declare const SEARCH_MARKER = "<<<<<<< SEARCH";
 /**
  * Whether a reply is a set of edits rather than a full document. Null while
- * too little has arrived to tell (Pickle can also start with `<`).
+ * too little has arrived to tell (Jigs can also start with `<`).
  */
 export declare function isEditReply(text: string): boolean | null;
 /** Complete SEARCH/REPLACE blocks in `text`; a block still being written is skipped. */

package/dist/patch.js

@@ -5,7 +5,7 @@ const REPLACE_MARKER = ">>>>>>> REPLACE";
 const FENCE = /^`{3}[\w-]*$/;
 /**
 * Whether a reply is a set of edits rather than a full document. Null while
-* too little has arrived to tell (Pickle can also start with `<`).
+* too little has arrived to tell (Jigs can also start with `<`).
 */
 function isEditReply(text) {
 	const start = text.trimStart().replace(/^`{3}[\w-]*\n/, "");

package/dist/script.js

@@ -55,10 +55,10 @@ const LOOPS = {
 	ForStatement: "for",
 	WhileStatement: "while"
 };
-const unsupported = (syntax, advice) => `${syntax} isn't part of Pickle's JavaScript: ${advice}`;
+const unsupported = (syntax, advice) => `${syntax} isn't part of Jigs's JavaScript: ${advice}`;
 const MESSAGES = {
 	class: unsupported("`class`", "use plain objects and arrow functions"),
-	fetch: "There is no `fetch` in Pickle: read data with `useQuery` and a query the prompt lists",
+	fetch: "There is no `fetch` in Jigs: read data with `useQuery` and a query the prompt lists",
 	function: (name) => unsupported(`\`function ${name}()\``, `write \`const ${name} = (…) => …\` instead`),
 	getter: unsupported("A getter or setter", "compute the value in a {@body} line instead"),
 	import: unsupported("`import()`", "everything a spec can use is built in"),
@@ -132,11 +132,11 @@ function varNames(node, out) {
 	if (node.type === "VariableDeclaration" && node.kind === "var") for (const declarator of node.declarations) patternNames(declarator.id, out);
 	for (const child of childNodes(node)) if (!isFunction(child)) varNames(child, out);
 }
-/** The name a callee is written as, bare or as `Pickle.name`. */
+/** The name a callee is written as, bare or as `Jigs.name`. */
 function calleeName(node) {
-	return node.type === "Identifier" ? node.name : node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "Pickle" && node.property.type === "Identifier" ? node.property.name : null;
+	return node.type === "Identifier" ? node.name : node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "Jigs" && node.property.type === "Identifier" ? node.property.name : null;
 }
-/** `useQuery`, bare or as `Pickle.useQuery`. */
+/** `useQuery`, bare or as `Jigs.useQuery`. */
 function hookCallee(node) {
 	const name = calleeName(node);
 	return name === "useMutation" || name === "useQuery" || name === "useState" ? name : null;

package/dist/signature.js

@@ -1,4 +1,4 @@
-import { parsePickle } from "./parse.js";
+import { parseJigs } from "./parse.js";
 //#region src/signature.ts
 function formatAttr(prop) {
 	if (prop.shorthand === true) return prop.name;
@@ -15,7 +15,7 @@ function hasSlot(nodes) {
 }
 /** `<statCard label value delta={0} note="">…</statCard>` when the define has a slot. */
 function recipeSignature(recipe) {
-	const define = parsePickle(recipe.source).children.find((node) => node.type === "element" && node.name === "define");
+	const define = parseJigs(recipe.source).children.find((node) => node.type === "element" && node.name === "define");
 	if (define === void 0) return `<${recipe.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(" ")}>`;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jigs.design/compiler",
-  "version": "0.1.1",
-  "description": "Today's Pickle compiler: parser, checker against a catalog, code generator, recipes, and the edit helpers. The v2 rewrite replaces it.",
+  "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.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yoamomonstruos/pickle.git",
+    "url": "git+https://github.com/yoamomonstruos/jigs.git",
     "directory": "packages/compiler"
   },
   "type": "module",
@@ -25,6 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "acorn": "8.19.0"
+    "acorn": "8.19.0",
+    "@jigs.design/protocol": "0.2.0"
   }
 }