@jigs.design/server 0.1.1 → 0.1.2

package/README.md

@@ -1,15 +1,15 @@
 # @jigs.design/server
 
-`createPickleServer` turns a host into one fetch handler. That handler streams checked programs, runs queries and mutations, and serves the sandbox frame. You give it a `run` function per procedure, a `context` for each request, and a `model` function that calls your LLM.
+`createJigsServer` turns a host into one fetch handler. That handler streams checked programs, runs queries and mutations, and serves the sandbox frame. You give it a `run` function per procedure, a `context` for each request, and a `model` function that calls your LLM.
 
 Import it from server code only.
 
 ```ts
-import { createPickleServer, PickleError } from "@jigs.design/server";
+import { createJigsServer, JigsError } from "@jigs.design/server";
 import { aiSdkModel } from "@jigs.design/ai-sdk";
 import { host } from "./host";
 
-export const pickle = createPickleServer({
+export const jigs = createJigsServer({
 	host,
 	context: async (request) => ({ userId: await userIdFrom(request) }),
 	run: {
@@ -17,7 +17,7 @@ export const pickle = createPickleServer({
 			db.listOrders(ctx.userId, input.status, { signal }),
 		archiveOrder: async (input, { ctx }) => {
 			if (!(await db.archiveOrder(ctx.userId, input.id))) {
-				throw new PickleError("NOT_FOUND", "That order is gone.");
+				throw new JigsError("NOT_FOUND", "That order is gone.");
 			}
 		},
 	},
@@ -25,22 +25,22 @@ export const pickle = createPickleServer({
 	instructions: "You are Acme's order assistant. Today is 2026-10-18.",
 });
 
-// Mount it as GET, POST and OPTIONS on one route, e.g. /api/pickle.
-export const handler = pickle.handler;
+// Mount it as GET, POST and OPTIONS on one route, e.g. /api/jigs.
+export const handler = jigs.handler;
 ```
 
 The server renders the prompt from the host, calls the model, checks each streamed prefix and compiles it to a program. `instructions`, such as who the assistant is and today's date, reach every prompt: document-mode sessions, chat and repairs. When the checker finds errors, it runs repair rounds. A call carries its procedure's `kind`, and the server refuses one that does not match the host. A follow-up turn may answer with SEARCH/REPLACE edits instead of a whole document.
 
-Specs need not come from the model. `pickle.spec(name)` returns a spec your product ships in `specs`, compiled once at startup. `pickle.compile(source)` checks and compiles one a user saved.
+Specs need not come from the model. `jigs.spec(name)` returns a spec your product ships in `specs`, compiled once at startup. `jigs.compile(source)` checks and compiles one a user saved.
 
 ## Exports
 
 | Export                     | What it is                                                                          |
 | -------------------------- | ----------------------------------------------------------------------------------- |
-| `createPickleServer`       | The server: `handler`, `spec`, `compile`, `chat`, and the functions `handler` wraps |
+| `createJigsServer`         | The server: `handler`, `spec`, `compile`, `chat`, and the functions `handler` wraps |
 | `defineRun`                | Types `run` functions outside a server, to share them between two servers           |
-| `PickleError`              | Throw from `context` or `run` with a code the browser can read                      |
-| `PickleCompileError`       | What a strict `pickle.compile` rejects with, carrying the `diagnostics`             |
+| `JigsError`                | Throw from `context` or `run` with a code the browser can read                      |
+| `JigsCompileError`         | What a strict `jigs.compile` rejects with, carrying the `diagnostics`               |
 | `chatBlockText`            | Writes a chat block back as a fenced block, for the model's history                 |
 | `@jigs.design/server/node` | `nodeHandler`, for Node's `http` and Express                                        |
 
@@ -48,13 +48,13 @@ It re-exports the shared types from `@jigs.design/runtime`.
 
 ## Source
 
-- `src/server.ts`: `createPickleServer` and the request routing.
+- `src/server.ts`: `createJigsServer` and the request routing.
 - `src/session.ts`: one turn: prompt, model, checking, repair and edits.
 - `src/compile.ts`: compiling a document against the host's catalog and recipes.
 - `src/inputs.ts`, `src/literal.ts`: literal procedure inputs checked against their schemas.
-- `src/chat.ts`: chat mode, where a Markdown reply carries fenced `pickle` blocks.
+- `src/chat.ts`: chat mode, where a Markdown reply carries fenced `jigs` blocks.
 - `src/invalidation.ts`: which queries a mutation refreshes.
-- `src/pragma.ts`: the `{@pickle 0 catalog=3}` version line.
+- `src/pragma.ts`: the `{@jigs 0 catalog=3}` version line.
 - `src/node.ts`: the Node adapter.
 - `src/errors.ts`, `src/types.ts`: errors and the public types.
 

package/dist/chat.d.ts

@@ -5,7 +5,7 @@ import "@jigs.design/compiler";
 import { ChatBlock, Diagnostic, Program } from "@jigs.design/runtime";
 //#region src/chat.d.ts
 /**
- * A block as the model wrote it, for the model's history: a fenced `pickle`
+ * A block as the model wrote it, for the model's history: a fenced `jigs`
  * block with its id, and its source without the pragma line.
  */
 export declare function chatBlockText(block: ChatBlockSource): string;

package/dist/chat.js

@@ -17,13 +17,13 @@ const MAX_BLOCKS = 8;
 */
 const MAX_BLOCK_REPAIRS = 3;
 /**
-* Lines after unfenced Pickle that wait to see whether more Pickle follows
+* Lines after unfenced Jigs that wait to see whether more Jigs follows
 * (a heading or a blank line inside a document), before they show as prose.
 */
 const MAX_HELD_LINES = 6;
 /**
 * Tags Markdown and HTML also use, so a prose line may start with one, as in
-* "<code>npm i</code> installs it." Such a line is Pickle only when it is all
+* "<code>npm i</code> installs it." Such a line is Jigs only when it is all
 * markup, ending in a tag.
 */
 const PROSE_TAGS = /* @__PURE__ */ new Set([
@@ -51,12 +51,12 @@ const PROSE_TAGS = /* @__PURE__ */ new Set([
 	"table",
 	"u"
 ]);
-/** A line that opens a pickle block: ```pickle, then an optional id. */
-const PICKLE_OPEN = /^( {0,3})`{3}[ \t]*pickle(?:[ \t]+([^`]*?))?[ \t]*$/i;
-/** A line that closes a pickle block. */
+/** A line that opens a jig block: ```jigs, then an optional id. */
+const JIGS_OPEN = /^( {0,3})`{3}[ \t]*jigs(?:[ \t]+([^`]*?))?[ \t]*$/i;
+/** A line that closes a jig block. */
 const BLOCK_CLOSE = /^ {0,3}`{3,}[ \t]*$/;
 /**
-* A fence with text after it, inside a block. Pickle never holds a fence, so
+* A fence with text after it, inside a block. Jigs never holds a fence, so
 * the model closed the block and ran its prose onto the same line.
 */
 const BLOCK_CLOSE_RUN_ON = /^ {0,3}`{3,}(.+)$/;
@@ -83,21 +83,21 @@ const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 const MAYBE_FENCE = /^ {0,3}(?:`{0,2}|~{0,2})$/;
 /** A partial line that is a fence line, whose end decides what it opens. */
 const FENCE_START = /^ {0,3}(?:`{3}|~{3})/;
-const AUTO_ID = /^pickle-(\d+)$/;
+const AUTO_ID = /^jigs-(\d+)$/;
 const VALID_ID = /^[a-z][a-z0-9-]*$/;
 /**
-* A block as the model wrote it, for the model's history: a fenced `pickle`
+* A block as the model wrote it, for the model's history: a fenced `jigs`
 * block with its id, and its source without the pragma line.
 */
 function chatBlockText(block) {
 	const body = splitPragma(block.source).body.replace(/\n+$/, "");
-	return `\`\`\`pickle ${block.id}\n${body}\n\`\`\``;
+	return `\`\`\`jigs ${block.id}\n${body}\n\`\`\``;
 }
 /** The block's id from the fence's info string, made kebab-case. */
 function slug(info) {
 	const joined = info.toLowerCase().split(/[^a-z0-9]+/).filter((word) => word !== "").join("-");
 	if (joined === "") return "";
-	return /^[a-z]/.test(joined) ? joined : `pickle-${joined}`;
+	return /^[a-z]/.test(joined) ? joined : `jigs-${joined}`;
 }
 /** Whether `line` closes a code fence opened with `fence`. */
 function closesFence(line, fence) {
@@ -126,7 +126,7 @@ function depthChange(line) {
 	return trimmed.endsWith("/>") || trimmed.includes(`</${name}>`) ? 0 : 1;
 }
 /**
-* Splits a chat reply into prose and pickle blocks as it streams. Pure and
+* Splits a chat reply into prose and jig blocks as it streams. Pure and
 * synchronous: `push` takes any slice of the reply and returns what it
 * completed. Prose comes out as soon as a partial line can no longer be a
 * fence; a block compiles at each committed line and is sent again whenever
@@ -169,15 +169,15 @@ function createReplyParser(deps, history) {
 	/** Whether the current prose line is already known to be text. */
 	let lineIsText = false;
 	let out = [];
-	/** Whether a complete prose line is Pickle the model forgot to fence. */
+	/** Whether a complete prose line is Jigs the model forgot to fence. */
 	const strayLine = (value) => {
 		if (BODY_LINE.test(value)) return true;
 		const name = TAG_LINE.exec(value)?.[1] ?? "";
 		if (!deps.tags.has(name)) return false;
 		return !PROSE_TAGS.has(name) || value.trimEnd().endsWith(">");
 	};
-	/** Whether a line keeps unfenced Pickle going: a stray line or a closing tag. */
-	const pickleLine = (value) => value.trim() !== "" && (strayLine(value) || /^\s*<\//.test(value));
+	/** Whether a line keeps unfenced Jigs going: a stray line or a closing tag. */
+	const jigsLine = (value) => value.trim() !== "" && (strayLine(value) || /^\s*<\//.test(value));
 	/** Whether a partial prose line may still become a stray line. */
 	const mayBeStray = (partial) => {
 		const trimmed = partial.trimStart();
@@ -249,7 +249,7 @@ function createReplyParser(deps, history) {
 	};
 	const open = (info, indent, implicit = false) => {
 		const named = slug(info ?? "");
-		const id = named === "" ? `pickle-${++autoId}` : named;
+		const id = named === "" ? `jigs-${++autoId}` : named;
 		const version = (versions.get(id) ?? 0) + 1;
 		versions.set(id, version);
 		opened++;
@@ -319,7 +319,7 @@ function createReplyParser(deps, history) {
 		if (block.over) {
 			settle(block, blockOf(block, "", empty, "done", {
 				code: "RATE_LIMITED",
-				message: `A reply shows at most ${MAX_BLOCKS} pickles, so this one was left out.`
+				message: `A reply shows at most ${MAX_BLOCKS} jigs, so this one was left out.`
 			}));
 			return;
 		}
@@ -332,7 +332,7 @@ function createReplyParser(deps, history) {
 			if (base === void 0) {
 				settle(block, blockOf(block, "", empty, "done", {
 					code: "NOT_FOUND",
-					message: `There is no earlier pickle "${block.id}" to change.`
+					message: `There is no earlier jig "${block.id}" to change.`
 				}), {
 					applied: false,
 					blocks: parsed.length
@@ -391,7 +391,7 @@ function createReplyParser(deps, history) {
 		if (mode.kind === "block") {
 			const { block } = mode;
 			if (block.implicit) {
-				if (block.depth > 0 || pickleLine(value)) {
+				if (block.depth > 0 || jigsLine(value)) {
 					block.lines.push(...block.waiting);
 					block.waiting = [];
 					block.depth = Math.max(0, block.depth + depthChange(value));
@@ -414,7 +414,7 @@ function createReplyParser(deps, history) {
 			const runOn = BLOCK_CLOSE_RUN_ON.exec(value);
 			if (runOn !== null) {
 				close(block);
-				line(PICKLE_OPEN.test(value) ? value : (runOn[1] ?? "").trimStart());
+				line(JIGS_OPEN.test(value) ? value : (runOn[1] ?? "").trimStart());
 				return;
 			}
 			let cut = 0;
@@ -432,9 +432,9 @@ function createReplyParser(deps, history) {
 			text(`${raw}\n`);
 			return;
 		}
-		const pickle = PICKLE_OPEN.exec(value);
-		if (pickle !== null) {
-			open(pickle[2], pickle[1]?.length ?? 0);
+		const jigs = JIGS_OPEN.exec(value);
+		if (jigs !== null) {
+			open(jigs[2], jigs[1]?.length ?? 0);
 			return;
 		}
 		if (TOOL_MARKUP.test(value)) return;
@@ -452,7 +452,7 @@ function createReplyParser(deps, history) {
 	};
 	/**
 	* Closes a block; for one with no fence, the lines still waiting after
-	* its Pickle are prose again.
+	* its Jigs lines are prose again.
 	*/
 	function finishImplicit(block) {
 		const waiting = block.waiting;
@@ -515,12 +515,12 @@ function createReplyParser(deps, history) {
 			if (!block.implicit) {
 				if (last !== "") line(last);
 				closeOpen();
-			} else if (last !== "" && (block.depth > 0 || pickleLine(last))) {
+			} else if (last !== "" && (block.depth > 0 || jigsLine(last))) {
 				line(last);
 				closeOpen();
 			} else {
 				finishImplicit(block);
-				if (PICKLE_OPEN.exec(last) === null) text(last);
+				if (JIGS_OPEN.exec(last) === null) text(last);
 			}
 		} else if (lineIsText) lineIsText = false;
 		else if (held !== "") {
@@ -529,7 +529,7 @@ function createReplyParser(deps, history) {
 			if (mode.kind !== "code" && strayLine(last)) {
 				line(last);
 				closeOpen();
-			} else if (mode.kind === "code" || PICKLE_OPEN.exec(last) === null) text(last);
+			} else if (mode.kind === "code" || JIGS_OPEN.exec(last) === null) text(last);
 		}
 		const events = out;
 		out = [];

package/dist/compile.js

@@ -1,8 +1,8 @@
 import { designChecks } from "./design.js";
-import { PickleCompileError, fatalDiagnostics } from "./errors.js";
+import { JigsCompileError, fatalDiagnostics } from "./errors.js";
 import { inputDiagnostics } from "./inputs.js";
 import { outputDiagnostics } from "./outputs.js";
-import { columnAt, compileLibrary, compilePickle, lineAt } from "@jigs.design/compiler";
+import { columnAt, compileJigs, compileLibrary, lineAt } from "@jigs.design/compiler";
 import { componentSchema } from "@jigs.design/host";
 import { PROGRAM_FORMAT } from "@jigs.design/runtime";
 //#region src/compile.ts
@@ -129,7 +129,7 @@ function tagsIn(source) {
 * or calls a procedure the host does not have, so a bad recipe stops the
 * server at startup instead of reaching the model. Throws too when a
 * situation's example has a diagnostic worse than info, so the prompt never
-* shows the model Pickle the checker refuses.
+* shows the model Jigs the checker refuses.
 */
 function createChecker(host) {
 	const catalog = compileCatalog(host.components);
@@ -167,7 +167,7 @@ function createChecker(host) {
 		};
 	};
 	const compile = (body) => {
-		const result = compilePickle(body, {
+		const result = compileJigs(body, {
 			catalog,
 			library
 		});
@@ -213,7 +213,7 @@ function createChecker(host) {
 	for (const entry of host.situations) {
 		if (entry.example === void 0) continue;
 		const fatal = fatalDiagnostics(compile(entry.example).diagnostics);
-		if (fatal.length > 0) throw new PickleCompileError(`Situation "${entry.name}" example`, fatal);
+		if (fatal.length > 0) throw new JigsCompileError(`Situation "${entry.name}" example`, fatal);
 	}
 	return { compile };
 }

package/dist/confirm.js

@@ -68,7 +68,7 @@ function createConfirmer(secret, store, now) {
 		name: "HMAC"
 	}, false, ["sign", "verify"]);
 	const signed = (binding, expiresAt, id) => encoder.encode(JSON.stringify([
-		"pickle-confirm-1",
+		"jigs-confirm-1",
 		binding.name,
 		binding.subject,
 		expiresAt,

package/dist/errors.d.ts

@@ -1,10 +1,10 @@
-import { Diagnostic, PickleErrorCode, PickleErrorData } from "@jigs.design/runtime";
+import { Diagnostic, JigsErrorCode, JigsErrorData } from "@jigs.design/runtime";
 //#region src/errors.d.ts
 /** Codes a product may throw from `context` or `run`. */
-export type ThrownCode = Exclude<PickleErrorCode, "DECLINED" | "NETWORK" | "UNAVAILABLE" | "UNKNOWN_PROCEDURE">;
+export type ThrownCode = Exclude<JigsErrorCode, "DECLINED" | "NETWORK" | "UNAVAILABLE" | "UNKNOWN_PROCEDURE">;
 declare const BRAND: unique symbol;
 /** An error whose code and message reach the browser. */
-export declare class PickleError extends Error {
+export declare class JigsError extends Error {
   readonly [BRAND] = true;
   readonly code: ThrownCode;
   constructor(code: ThrownCode, message: string);
@@ -14,7 +14,7 @@ export declare class PickleError extends Error {
  * startup. `diagnostics` holds the error and warning diagnostics; the message
  * lists them with their lines.
  */
-export declare class PickleCompileError extends Error {
+export declare class JigsCompileError extends Error {
   readonly diagnostics: ReadonlyArray<Diagnostic>;
   constructor(subject: string, diagnostics: ReadonlyArray<Diagnostic>);
 }

package/dist/errors.js

@@ -1,16 +1,16 @@
 //#region src/errors.ts
-const BRAND = Symbol.for("@jigs.design/server.PickleError");
+const BRAND = Symbol.for("@jigs.design/server.JigsError");
 /** An error whose code and message reach the browser. */
-var PickleError = class extends Error {
+var JigsError = class extends Error {
 	[BRAND] = true;
 	code;
 	constructor(code, message) {
 		super(message);
 		this.code = code;
-		this.name = "PickleError";
+		this.name = "JigsError";
 	}
 };
-function isPickleError(cause) {
+function isJigsError(cause) {
 	return typeof cause === "object" && cause !== null && BRAND in cause;
 }
 /** Diagnostics that make a stored spec or a strict compile fail. */
@@ -22,13 +22,13 @@ function fatalDiagnostics(diagnostics) {
 * startup. `diagnostics` holds the error and warning diagnostics; the message
 * lists them with their lines.
 */
-var PickleCompileError = class extends Error {
+var JigsCompileError = class extends Error {
 	diagnostics;
 	constructor(subject, diagnostics) {
 		const lines = diagnostics.map((diagnostic) => `line ${diagnostic.span.line}: ${diagnostic.message}`);
 		super(`${subject} failed to compile:\n${lines.join("\n")}`);
 		this.diagnostics = diagnostics;
-		this.name = "PickleCompileError";
+		this.name = "JigsCompileError";
 	}
 };
 const STATUS = {
@@ -48,7 +48,7 @@ function statusOf(code) {
 	return STATUS[code];
 }
 const INTERNAL_MESSAGE = "Something went wrong.";
-/** The browser's view of a thrown value: a `PickleError` keeps its message, anything else does not. */
+/** The browser's view of a thrown value: a `JigsError` keeps its message, anything else does not. */
 function errorData(error) {
 	return error === null ? {
 		code: "INTERNAL",
@@ -59,4 +59,4 @@ function errorData(error) {
 	};
 }
 //#endregion
-export { INTERNAL_MESSAGE, PickleCompileError, PickleError, errorData, fatalDiagnostics, isPickleError, statusOf };
+export { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError, statusOf };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { Advice, DesignCheckCode, Placement } from "./design.js";
 import { ConfirmationStore, memoryConfirmations } from "./confirm.js";
-import { CallContext, CallOutcome, CallReport, CallReportOutcome, CallRequest, ChatBlockResult, ChatBlockSource, ChatEvent, ChatOptions, ChatTurn, CompileOptions, ContextFunction, EditFailureReason, ErrorInfo, ModelFunction, ModelRequest, ModelRequestKind, PickleServer, PickleServerOptions, PolicyCall, RequiresAction, RunFunctions, SessionRequest, Turn, TurnEdits, TurnRewrite, TurnRound, Usage } from "./types.js";
+import { CallContext, CallOutcome, CallReport, CallReportOutcome, CallRequest, ChatBlockResult, ChatBlockSource, ChatEvent, ChatOptions, ChatTurn, CompileOptions, ContextFunction, EditFailureReason, ErrorInfo, JigsServer, JigsServerOptions, ModelFunction, ModelRequest, ModelRequestKind, PolicyCall, RequiresAction, RunFunctions, SessionRequest, Turn, TurnEdits, TurnRewrite, TurnRound, Usage } from "./types.js";
 import { chatBlockText } from "./chat.js";
-import { PickleCompileError, PickleError, ThrownCode } from "./errors.js";
-import { createPickleServer, defineRun } from "./server.js";
+import { JigsCompileError, JigsError, ThrownCode } from "./errors.js";
+import { createJigsServer, defineRun } from "./server.js";
 import { addUsage } from "./usage.js";
 import { PromptMode } from "@jigs.design/prompt";
-import { ChatBlock, ChatBlockStatus, Diagnostic, Message, PickleErrorCode, PickleErrorData, Program, SessionEvent, Span } from "@jigs.design/runtime";
-export { type Advice, type CallContext, type CallOutcome, type CallReport, type CallReportOutcome, type CallRequest, type ChatBlock, type ChatBlockResult, type ChatBlockSource, type ChatBlockStatus, type ChatEvent, type ChatOptions, type ChatTurn, type CompileOptions, type ConfirmationStore, type ContextFunction, type DesignCheckCode, type Diagnostic, type EditFailureReason, type ErrorInfo, type Message, type ModelFunction, type ModelRequest, type ModelRequestKind, PickleCompileError, PickleError, type PickleErrorCode, type PickleErrorData, type PickleServer, type PickleServerOptions, type Placement, type PolicyCall, type Program, type PromptMode, type RequiresAction, type RunFunctions, type SessionEvent, type SessionRequest, type Span, type ThrownCode, type Turn, type TurnEdits, type TurnRewrite, type TurnRound, type Usage, addUsage, chatBlockText, createPickleServer, defineRun, memoryConfirmations };
+import { ChatBlock, ChatBlockStatus, Diagnostic, JigsErrorCode, JigsErrorData, Message, Program, SessionEvent, Span } from "@jigs.design/runtime";
+export { type Advice, type CallContext, type CallOutcome, type CallReport, type CallReportOutcome, type CallRequest, type ChatBlock, type ChatBlockResult, type ChatBlockSource, type ChatBlockStatus, type ChatEvent, type ChatOptions, type ChatTurn, type CompileOptions, type ConfirmationStore, type ContextFunction, type DesignCheckCode, type Diagnostic, type EditFailureReason, type ErrorInfo, JigsCompileError, JigsError, type JigsErrorCode, type JigsErrorData, type JigsServer, type JigsServerOptions, type Message, type ModelFunction, type ModelRequest, type ModelRequestKind, type Placement, type PolicyCall, type Program, type PromptMode, type RequiresAction, type RunFunctions, type SessionEvent, type SessionRequest, type Span, type ThrownCode, type Turn, type TurnEdits, type TurnRewrite, type TurnRound, type Usage, addUsage, chatBlockText, createJigsServer, defineRun, memoryConfirmations };

package/dist/index.js

@@ -1,6 +1,6 @@
-import { PickleCompileError, PickleError } from "./errors.js";
+import { JigsCompileError, JigsError } from "./errors.js";
 import { addUsage } from "./usage.js";
 import { chatBlockText } from "./chat.js";
 import { memoryConfirmations } from "./confirm.js";
-import { createPickleServer, defineRun } from "./server.js";
-export { PickleCompileError, PickleError, addUsage, chatBlockText, createPickleServer, defineRun, memoryConfirmations };
+import { createJigsServer, defineRun } from "./server.js";
+export { JigsCompileError, JigsError, addUsage, chatBlockText, createJigsServer, defineRun, memoryConfirmations };

package/dist/node.d.ts

@@ -10,10 +10,10 @@ interface HandlerOwner {
   maxBodyBytes: number;
 }
 /**
- * Mounts `pickle.handler` on Express or plain Node. It builds a standard
+ * Mounts `jigs.handler` on Express or plain Node. It builds a standard
  * `Request`, so `context` is the same function on every platform, and aborts
  * the request's signal when the connection closes early.
  */
-export declare function nodeHandler(pickle: HandlerOwner): (request: NodeRequest, response: ServerResponse) => void;
+export declare function nodeHandler(jigs: HandlerOwner): (request: NodeRequest, response: ServerResponse) => void;
 //#endregion
 export {};

package/dist/node.js

@@ -40,11 +40,11 @@ function toHeaders(request) {
 	return headers;
 }
 /**
-* Mounts `pickle.handler` on Express or plain Node. It builds a standard
+* Mounts `jigs.handler` on Express or plain Node. It builds a standard
 * `Request`, so `context` is the same function on every platform, and aborts
 * the request's signal when the connection closes early.
 */
-function nodeHandler(pickle) {
+function nodeHandler(jigs) {
 	return (request, response) => {
 		const abort = new AbortController();
 		response.on("close", () => {
@@ -54,14 +54,14 @@ function nodeHandler(pickle) {
 			try {
 				const encrypted = "encrypted" in request.socket;
 				const url = new URL(request.originalUrl ?? request.url ?? "/", `${encrypted ? "https" : "http"}://${request.headers.host ?? "localhost"}`);
-				const body = await readBody(request, pickle.maxBodyBytes);
+				const body = await readBody(request, jigs.maxBodyBytes);
 				const init = {
 					headers: toHeaders(request),
 					method: request.method ?? "GET",
 					signal: abort.signal
 				};
 				if (body !== null) init.body = body;
-				const reply = await pickle.handler(new Request(url, init));
+				const reply = await jigs.handler(new Request(url, init));
 				response.statusCode = reply.status;
 				reply.headers.forEach((value, name) => {
 					response.setHeader(name, value);

package/dist/pragma.js

@@ -1,5 +1,5 @@
-const PRAGMA = /^\{@pickle\s+(\d+)(?:\s+catalog=(\d+))?\}[ \t]*(?:\r?\n|$)/;
-/** Splits a leading `{@pickle 0 catalog=1}` line from the body. */
+const PRAGMA = /^\{@jigs\s+(\d+)(?:\s+catalog=(\d+))?\}[ \t]*(?:\r?\n|$)/;
+/** Splits a leading `{@jigs 0 catalog=1}` line from the body. */
 function splitPragma(source) {
 	const match = PRAGMA.exec(source);
 	if (match === null) return {
@@ -39,7 +39,7 @@ function versionDiagnostics(versions, catalogVersion) {
 }
 /** The pragma line `withPragma` puts above a body, with its line break. */
 function pragmaLine(catalogVersion) {
-	return `{@pickle 0 catalog=${catalogVersion}}\n`;
+	return `{@jigs 0 catalog=${catalogVersion}}\n`;
 }
 /** `body` with a pragma naming the versions it was checked against. */
 function withPragma(body, catalogVersion) {

package/dist/server.d.ts

@@ -1,10 +1,10 @@
-import { ContextFunction, PickleServer, PickleServerOptions, RunFunctions } from "./types.js";
+import { ContextFunction, JigsServer, JigsServerOptions, RunFunctions } from "./types.js";
 import { Catalog, Procedures } from "@jigs.design/host";
 //#region src/server.d.ts
 /**
- * Types a `context` and `run` pair outside `createPickleServer`, so two
+ * Types a `context` and `run` pair outside `createJigsServer`, so two
  * servers (one per platform) can share them. `TContext` comes from `context`
- * alone, as in `createPickleServer`.
+ * alone, as in `createJigsServer`.
  */
 export declare function defineRun<const TProcedures extends Procedures, TContext = any>(procedures: TProcedures, handlers: {
   context: ContextFunction<TContext>;
@@ -13,5 +13,5 @@ export declare function defineRun<const TProcedures extends Procedures, TContext
   context: ContextFunction<TContext>;
   run: RunFunctions<TProcedures, TContext>;
 };
-export declare function createPickleServer<const TProcedures extends Procedures, const TCatalog extends Catalog, TContext = any, TOptions = undefined, const TSpecName extends string = never>(options: PickleServerOptions<TProcedures, TCatalog, TContext, TOptions, TSpecName>): PickleServer<TContext, TSpecName>;
+export declare function createJigsServer<const TProcedures extends Procedures, const TCatalog extends Catalog, TContext = any, TOptions = undefined, const TSpecName extends string = never>(options: JigsServerOptions<TProcedures, TCatalog, TContext, TOptions, TSpecName>): JigsServer<TContext, TSpecName>;
 //#endregion

package/dist/server.js

@@ -1,4 +1,4 @@
-import { INTERNAL_MESSAGE, PickleCompileError, PickleError, errorData, fatalDiagnostics, isPickleError, statusOf } from "./errors.js";
+import { INTERNAL_MESSAGE, JigsCompileError, JigsError, errorData, fatalDiagnostics, isJigsError, statusOf } from "./errors.js";
 import { checkMarkdownElements, createChecker } from "./compile.js";
 import { belowPrefix, splitPragma, versionDiagnostics } from "./pragma.js";
 import { MAX_CONTENT, messagesSchema, runSession } from "./session.js";
@@ -11,7 +11,7 @@ import { PROGRAM_FORMAT } from "@jigs.design/runtime";
 import { z } from "zod";
 import { frameDocument, frameSecurityPolicy } from "@jigs.design/runtime/frame";
 //#region src/server.ts
-const VERSION_HEADER = "pickle-version";
+const VERSION_HEADER = "jigs-version";
 const DEFAULT_MAX_BODY_BYTES = 1e6;
 const HEARTBEAT_MS = 15e3;
 /** A small document whose compiled code changes when the compiler's output does. */
@@ -96,12 +96,12 @@ const TOKEN_REFUSALS = {
 function confirmerFor(options) {
 	if (options.secret === void 0) {
 		const confirming = Object.entries(options.host.procedures).find(([, procedure]) => procedure.kind === "mutation" && procedure.policy === "confirm");
-		if (confirming !== void 0) throw new Error(`createPickleServer needs a secret and confirmSubject: "${confirming[0]}" asks for confirmation, and its tokens are signed with the secret`);
-		if (options.confirmSubject !== void 0) throw new Error("createPickleServer has confirmSubject but no secret");
+		if (confirming !== void 0) throw new Error(`createJigsServer needs a secret and confirmSubject: "${confirming[0]}" asks for confirmation, and its tokens are signed with the secret`);
+		if (options.confirmSubject !== void 0) throw new Error("createJigsServer has confirmSubject but no secret");
 		return null;
 	}
-	if (options.secret.length < 32) throw new Error(`createPickleServer's secret must be at least 32 characters`);
-	if (options.confirmSubject === void 0) throw new Error("createPickleServer has a secret but no confirmSubject: a confirmation token must be bound to who it was issued to");
+	if (options.secret.length < 32) throw new Error(`createJigsServer's secret must be at least 32 characters`);
+	if (options.confirmSubject === void 0) throw new Error("createJigsServer has a secret but no confirmSubject: a confirmation token must be bound to who it was issued to");
 	const now = options.now ?? Date.now;
 	return createConfirmer(options.secret, options.confirmations ?? memoryConfirmations(now), now);
 }
@@ -140,7 +140,7 @@ function hostFingerprint(host) {
 	});
 }
 /**
-* What `pickle.chat` reads from the route besides the request. `blocks` and
+* What `jigs.chat` reads from the route besides the request. `blocks` and
 * `prompt` come from the browser, so they are checked like a session's
 * messages.
 */
@@ -177,17 +177,17 @@ function issuesText(error) {
 	return error.issues.slice(0, 3).map((issue) => issue.path.length === 0 ? issue.message : `${issue.path.join(".")}: ${issue.message}`).join("; ");
 }
 /**
-* Types a `context` and `run` pair outside `createPickleServer`, so two
+* Types a `context` and `run` pair outside `createJigsServer`, so two
 * servers (one per platform) can share them. `TContext` comes from `context`
-* alone, as in `createPickleServer`.
+* alone, as in `createJigsServer`.
 */
 function defineRun(procedures, handlers) {
 	return handlers;
 }
-function createPickleServer(options) {
+function createJigsServer(options) {
 	const { host } = options;
 	checkMarkdownElements(host.components);
-	for (const [name, procedure] of Object.entries(host.procedures)) if (procedure.kind !== "action" && !Object.hasOwn(options.run, name)) throw new Error(`createPickleServer has no run function for "${name}"`);
+	for (const [name, procedure] of Object.entries(host.procedures)) if (procedure.kind !== "action" && !Object.hasOwn(options.run, name)) throw new Error(`createJigsServer has no run function for "${name}"`);
 	const confirmer = confirmerFor(options);
 	const checker = createChecker(host);
 	const promptOptions = (mode) => options.instructions === void 0 ? { mode } : {
@@ -198,7 +198,7 @@ function createPickleServer(options) {
 	const chatParts = systemPromptParts(host, promptOptions("chat"));
 	const system = `${documentParts.stable}\n\n${documentParts.variable}`;
 	const chatSystem = `${chatParts.stable}\n\n${chatParts.variable}`;
-	/** Tags that mark unfenced Pickle in a chat reply. */
+	/** Tags that mark unfenced Jigs in a chat reply. */
 	const chatTags = /* @__PURE__ */ new Set([...host.components.components.map((component) => component.name), ...host.recipes.map((entry) => entry.name)]);
 	const maxRepairs = options.maxRepairs ?? 1;
 	const programIntervalMs = options.programIntervalMs ?? 250;
@@ -256,7 +256,7 @@ function createPickleServer(options) {
 			});
 			return denial(name);
 		};
-		if (confirmer === null || options.confirmSubject === void 0) return refuse(/* @__PURE__ */ new Error(`The policy for "${name}" is "confirm", but createPickleServer has no secret and confirmSubject to sign a confirmation`));
+		if (confirmer === null || options.confirmSubject === void 0) return refuse(/* @__PURE__ */ new Error(`The policy for "${name}" is "confirm", but createJigsServer has no secret and confirmSubject to sign a confirmation`));
 		let binding;
 		try {
 			binding = {
@@ -333,7 +333,7 @@ function createPickleServer(options) {
 		try {
 			result = await run(input, context);
 		} catch (error) {
-			if (isPickleError(error)) return { error: errorData(error) };
+			if (isJigsError(error)) return { error: errorData(error) };
 			onError(error, {
 				name: request.name,
 				type: "call"
@@ -458,14 +458,14 @@ function createPickleServer(options) {
 	const compileStrict = (subject, source, placement) => {
 		const compiled = compileStored(source, placement);
 		const fatal = fatalDiagnostics(compiled.diagnostics);
-		if (fatal.length > 0) throw new PickleCompileError(subject, fatal);
+		if (fatal.length > 0) throw new JigsCompileError(subject, fatal);
 		return compiled;
 	};
 	const specs = /* @__PURE__ */ new Map();
 	for (const [name, source] of Object.entries(options.specs ?? {})) specs.set(name, compileStrict(`Spec "${name}"`, source).program);
 	const spec = (name) => {
 		const program = specs.get(name);
-		if (program === void 0) throw new Error(`createPickleServer has no spec named "${name}"`);
+		if (program === void 0) throw new Error(`createJigsServer has no spec named "${name}"`);
 		return program;
 	};
 	const compile = async (source, compileOptions) => compileOptions?.strict === false ? compileStored(source, compileOptions.placement) : compileStrict("The source", source, compileOptions?.placement);
@@ -502,26 +502,26 @@ function createPickleServer(options) {
 	};
 	const chat = async (request, chatOptions) => {
 		const refused = refusal(request);
-		if (refused !== null) throw new PickleError(refused.code, refused.message);
+		if (refused !== null) throw new JigsError(refused.code, refused.message);
 		let ctx;
 		try {
 			ctx = await options.context(request);
 		} catch (error) {
-			if (isPickleError(error)) throw error;
+			if (isJigsError(error)) throw error;
 			onError(error, { type: "chat" });
-			throw new PickleError("INTERNAL", INTERNAL_MESSAGE);
+			throw new JigsError("INTERNAL", INTERNAL_MESSAGE);
 		}
 		const input = parseBounded(() => chatInputSchema.safeParse({
 			blocks: chatOptions?.blocks,
 			prompt: chatOptions?.prompt
 		}));
-		if (!input.success) throw new PickleError("BAD_INPUT", input.message);
+		if (!input.success) throw new JigsError("BAD_INPUT", input.message);
 		let turnOptions;
 		if (options.options === void 0) turnOptions = void 0;
 		else {
 			const schema = options.options;
 			const parsed = parseBounded(() => schema.safeParse(chatOptions?.options ?? {}));
-			if (!parsed.success) throw new PickleError("BAD_INPUT", `options: ${parsed.message}`);
+			if (!parsed.success) throw new JigsError("BAD_INPUT", `options: ${parsed.message}`);
 			turnOptions = parsed.data;
 		}
 		const turnCall = {
@@ -623,7 +623,7 @@ function createPickleServer(options) {
 		try {
 			return { ctx: await options.context(request) };
 		} catch (error) {
-			if (isPickleError(error)) return { error: errorData(error) };
+			if (isJigsError(error)) return { error: errorData(error) };
 			onError(error, { type });
 			return { error: {
 				code: "INTERNAL",
@@ -783,4 +783,4 @@ function createPickleServer(options) {
 	};
 }
 //#endregion
-export { createPickleServer, defineRun };
+export { createJigsServer, defineRun };

package/dist/session.js

@@ -1,4 +1,4 @@
-import { errorData, isPickleError } from "./errors.js";
+import { errorData, isJigsError } from "./errors.js";
 import { belowPrefix, pragmaLine, splitPragma, versionDiagnostics, withPragma } from "./pragma.js";
 import { reorderDeclarations } from "./rewrite.js";
 import { addUsage } from "./usage.js";
@@ -313,7 +313,7 @@ async function* runSession(deps, messages, options, call) {
 			return;
 		}
 	} catch (error) {
-		if (isPickleError(error)) yield {
+		if (isJigsError(error)) yield {
 			error: errorData(error),
 			type: "error"
 		};

package/dist/types.d.ts

@@ -3,7 +3,7 @@ import { ConfirmationStore } from "./confirm.js";
 import { EditFailureReason } from "@jigs.design/compiler";
 import { PromptMode } from "@jigs.design/prompt";
 import { ActionDefinition, CallPolicy, Catalog, Host, InputOf, MutationDefinition, OutputOf, ProcedureDefinition, Procedures } from "@jigs.design/host";
-import { ChatBlock, ChatBlockStatus, Diagnostic, Invalidation, Message, PickleErrorData, Program, SessionEvent } from "@jigs.design/runtime";
+import { ChatBlock, ChatBlockStatus, Diagnostic, Invalidation, JigsErrorData, Message, Program, SessionEvent } from "@jigs.design/runtime";
 import { z } from "zod";
 //#region src/types.d.ts
 /**
@@ -175,7 +175,7 @@ export interface CallReport<TContext> {
   /** From the call's arrival to its outcome, in milliseconds. */
   durationMs: number;
   /** What the browser received, when `outcome` is not "success". */
-  error?: PickleErrorData;
+  error?: JigsErrorData;
   /**
    * The parsed input, or the input as the browser sent it when the call
    * failed before its input parsed.
@@ -200,7 +200,7 @@ export interface ErrorInfo {
  * `TContext` is inferred from `context`; `run` only reads it (`NoInfer`), so
  * a mistake in one `run` function is reported at that function.
  */
-export interface PickleServerOptions<TProcedures extends Procedures, TCatalog extends Catalog, TContext, TOptions, TSpecName extends string = never> {
+export interface JigsServerOptions<TProcedures extends Procedures, TCatalog extends Catalog, TContext, TOptions, TSpecName extends string = never> {
   /** Origins whose views may call this server and embed its frame. */
   allowedOrigins?: ReadonlyArray<string>;
   /**
@@ -286,7 +286,7 @@ export interface CompileOptions {
    */
   placement?: Placement;
   /**
-   * Throw a `PickleCompileError` when the source has an error or warning
+   * Throw a `JigsCompileError` when the source has an error or warning
    * diagnostic. Default true; pass false to get the program and the
    * diagnostics instead, as a session turn does.
    */
@@ -300,7 +300,7 @@ export type CallOutcome = {
   data: unknown;
   invalidate?: ReadonlyArray<Invalidation>;
 } | {
-  error: PickleErrorData;
+  error: JigsErrorData;
 } | {
   requiresAction: RequiresAction;
 };
@@ -364,8 +364,8 @@ export interface ChatBlockResult {
    * reply's limit (`RATE_LIMITED`), or an edit or repair that failed
    * (`INTERNAL`). The same error the block carries.
    */
-  error?: PickleErrorData;
-  /** False for Pickle the model wrote without a fence. */
+  error?: JigsErrorData;
+  /** False for Jigs the model wrote without a fence. */
   fenced: boolean;
   id: string;
   key: string;
@@ -437,13 +437,13 @@ export interface ChatTurn {
   /** The start of `system` that is the same on every turn, as on `ModelRequest`. */
   systemPrefix: string;
 }
-export interface PickleServer<TContext, TSpecName extends string = never> {
+export interface JigsServer<TContext, TSpecName extends string = never> {
   call: (request: CallRequest, context: CallContext<TContext>) => Promise<CallOutcome>;
   /**
    * Starts a chat reply for `request`. It refuses the request as `handler`
    * would (an `Origin` that may not call this server, or a body that is not
    * JSON), then runs `context` and parses `blocks` and `options`. Each
-   * failure rejects with a `PickleError`. See `ChatTurn`.
+   * failure rejects with a `JigsError`. See `ChatTurn`.
    */
   chat: (request: Request, options?: ChatOptions) => Promise<ChatTurn>;
   /** Checks and compiles a source with no model. Strict unless told otherwise. */
@@ -461,7 +461,7 @@ export interface PickleServer<TContext, TSpecName extends string = never> {
   /**
    * The system prompt for this host. "document" (default) is what sessions
    * use: every reply is one UI. "chat" is Markdown with UIs in fenced
-   * `pickle` blocks.
+   * `jigs` blocks.
    */
   prompt: (mode?: PromptMode) => string;
   /**

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@jigs.design/server",
-  "version": "0.1.1",
-  "description": "createPickleServer: checks and streams programs, runs procedures, and serves the sandbox frame.",
+  "version": "0.1.2",
+  "description": "createJigsServer: checks and streams programs, runs procedures, and serves the sandbox frame.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/yoamomonstruos/pickle.git",
+    "url": "git+https://github.com/yoamomonstruos/jigs.git",
     "directory": "packages/server"
   },
   "type": "module",
@@ -29,10 +29,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@jigs.design/prompt": "0.1.1",
-    "@jigs.design/runtime": "0.1.1",
-    "@jigs.design/host": "0.1.1",
-    "@jigs.design/compiler": "0.1.1"
+    "@jigs.design/host": "0.1.2",
+    "@jigs.design/prompt": "0.1.2",
+    "@jigs.design/compiler": "0.1.2",
+    "@jigs.design/runtime": "0.1.2"
   },
   "peerDependencies": {
     "zod": "^4.0.0"