@jigs.design/compiler 0.1.1 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # @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.
 
@@ -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/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",

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,20 +47,20 @@ 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 constants = {};
@@ -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,7 +190,7 @@ 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);
@@ -199,13 +199,13 @@ function generateProgram(statements, tree, defines = []) {
 		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

@@ -14,7 +14,7 @@ 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>;
@@ -123,7 +123,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;
@@ -172,6 +172,6 @@ export declare function compileLibrary(recipes: ReadonlyArray<Recipe>, catalog:
  * 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 {};

package/dist/compile.js

@@ -3,7 +3,7 @@ import { generateProgram, isBindingName } from "./codegen.js";
 import { columnAt, lineAt, sourceRange } 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`);
@@ -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"],
@@ -755,7 +755,7 @@ 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 document = parseJigs(source);
 	const diagnostics = [...document.repairs.map((repair) => ({
 		code: "repaired",
 		...placeOf(repair),
@@ -926,7 +926,7 @@ const problems = (diagnostics) => diagnostics.filter((diagnostic) => diagnostic.
 * 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] : []));
@@ -947,4 +947,4 @@ function compilePickle(source, options) {
 	};
 }
 //#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 { 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, recipeSignature };

package/dist/index.js

@@ -1,9 +1,9 @@
 import { columnAt, lineAt } 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, recipeSignature };

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.1.2",
+  "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",