@jigs.design/server 0.0.0-stage → 0.1.0

package/dist/compile.js

@@ -0,0 +1,249 @@
+import { designChecks } from "./design.js";
+import { PickleCompileError, fatalDiagnostics } from "./errors.js";
+import { inputDiagnostics } from "./inputs.js";
+import { outputDiagnostics } from "./outputs.js";
+import { columnAt, compileLibrary, compilePickle, lineAt } from "@jigs.design/compiler";
+import { componentSchema } from "@jigs.design/host";
+import { PROGRAM_FORMAT } from "@jigs.design/runtime";
+//#region src/compile.ts
+/** Elements the parser makes from Markdown; every catalog must be able to draw them. */
+const MARKDOWN_ELEMENTS = [
+	"bold",
+	"code",
+	"divider",
+	"item",
+	"italic",
+	"list",
+	"text",
+	"title"
+];
+function propSpec(definition) {
+	const { schema } = definition;
+	switch (schema.kind) {
+		case "boolean":
+		case "handler":
+		case "string": return { kind: schema.kind };
+		case "enum": return definition.default === void 0 ? {
+			kind: "enum",
+			values: schema.values
+		} : {
+			default: String(definition.default),
+			kind: "enum",
+			values: schema.values
+		};
+		case "image":
+		case "link": return { kind: "string" };
+		case "list": return { kind: "rows" };
+		case "number": {
+			const spec = { kind: "number" };
+			if (schema.min !== void 0) spec.min = schema.min;
+			if (schema.max !== void 0) spec.max = schema.max;
+			return spec;
+		}
+	}
+}
+/** The host catalog in the form today's compiler checks against. */
+function compileCatalog(catalog) {
+	const out = {};
+	for (const component of catalog.components) {
+		const props = {};
+		for (const [name, definition] of Object.entries(component.props)) props[name] = propSpec(definition);
+		out[component.name] = {
+			children: component.children,
+			props
+		};
+	}
+	return out;
+}
+const TAG = /<([a-z][A-Za-z0-9]*)/g;
+/** The span of `[start, end)` in `source`. */
+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);
+}
+function procedureDiagnostics(host, source, uses) {
+	const diagnostics = [];
+	const report = (use, code, message) => {
+		diagnostics.push({
+			code,
+			message,
+			severity: "error",
+			span: spanIn(source, use)
+		});
+	};
+	const queries = Object.entries(host.procedures).filter(([, procedure]) => procedure.kind === "query").map(([name]) => name);
+	for (const use of uses) {
+		if (use.hook === "useAction") {
+			report(use, "procedure_kind", `There is no \`useAction\`: an action is called like a mutation. Write \`useMutation("${use.name ?? "name"}")\` and call \`mutate\` from a handler`);
+			continue;
+		}
+		if (use.tanstack) {
+			report(use, "tanstack_form", `\`${use.hook}({ queryKey, queryFn })\` is TanStack Query's form. Write \`${use.hook}("${use.hook === "useQuery" ? queries[0] ?? "name" : "name"}"${use.hook === "useQuery" ? ", input" : ""})\` with a name from the host`);
+			continue;
+		}
+		if (use.name === null) {
+			report(use, "procedure_name", `\`${use.hook}\` needs the procedure name as a string literal, such as \`${use.hook}("${use.hook === "useQuery" ? queries[0] ?? "name" : "name"}")\``);
+			continue;
+		}
+		const procedure = Object.hasOwn(host.procedures, use.name) ? host.procedures[use.name] : void 0;
+		if (procedure === void 0) {
+			report(use, "unknown_procedure", `"${use.name}" is not a query, mutation or action on this host; its handle reports UNKNOWN_PROCEDURE`);
+			continue;
+		}
+		const expected = procedure.kind === "query" ? "useQuery" : "useMutation";
+		if (expected !== use.hook) report(use, "procedure_kind", `\`${use.hook}("${use.name}")\` names ${procedure.kind === "action" ? "an" : "a"} ${procedure.kind}. Write \`${expected}("${use.name}")\`${procedure.kind === "query" ? "" : " and call `mutate` from a handler"}`);
+	}
+	return diagnostics;
+}
+function procedureTable(host, uses) {
+	const table = /* @__PURE__ */ new Map();
+	for (const use of uses) {
+		if (use.name === null || use.tanstack) continue;
+		const procedure = Object.hasOwn(host.procedures, use.name) ? host.procedures[use.name] : void 0;
+		const expected = procedure?.kind === "query" ? "useQuery" : "useMutation";
+		if (procedure === void 0 || expected !== use.hook) continue;
+		table.set(use.name, {
+			invalidates: procedure.kind === "mutation" ? procedure.invalidates : [],
+			kind: procedure.kind
+		});
+	}
+	return Object.fromEntries(table);
+}
+/** Tag names written in a source. */
+function tagsIn(source) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(TAG)) if (match[1] !== void 0) tags.add(match[1]);
+	return tags;
+}
+/**
+* The host, ready to check sources: its catalog in the compiler's form and
+* its recipes compiled into a library. Throws when a recipe does not compile
+* 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.
+*/
+function createChecker(host) {
+	const catalog = compileCatalog(host.components);
+	const library = compileLibrary(host.recipes.map((entry) => ({
+		name: entry.name,
+		source: entry.source
+	})), catalog);
+	const recipes = /* @__PURE__ */ new Map();
+	for (const entry of host.recipes) {
+		const uses = [...library.get(entry.name)?.procedures ?? []];
+		const problem = [...procedureDiagnostics(host, entry.source, uses), ...inputDiagnostics(host, entry.source)][0];
+		if (problem !== void 0) throw new Error(`Recipe "${entry.name}" failed to compile: line ${problem.span.line}: ${problem.message}`);
+		recipes.set(entry.name, {
+			tags: tagsIn(entry.source),
+			uses
+		});
+	}
+	/** The tags a source draws, through every recipe it uses, and the procedures those recipes call. */
+	const reach = (body) => {
+		const tags = new Set(MARKDOWN_ELEMENTS);
+		const uses = [];
+		const pending = [...tagsIn(body)];
+		for (let tag = pending.pop(); tag !== void 0; tag = pending.pop()) {
+			if (tags.has(tag)) continue;
+			tags.add(tag);
+			const facts = recipes.get(tag);
+			if (facts !== void 0) {
+				uses.push(...facts.uses);
+				pending.push(...facts.tags);
+			}
+		}
+		return {
+			tags,
+			uses
+		};
+	};
+	const compile = (body) => {
+		const result = compilePickle(body, {
+			catalog,
+			library
+		});
+		const own = result.procedures;
+		const reached = reach(result.source);
+		return {
+			advise: (placement) => designChecks({
+				catalog: host.components,
+				compiled: result,
+				placement
+			}),
+			diagnostics: [
+				...result.diagnostics.map((diagnostic) => {
+					const sent = {
+						code: diagnostic.code,
+						message: diagnostic.message,
+						severity: diagnostic.severity === "warning" ? "error" : "info",
+						span: spanIn(body, diagnostic)
+					};
+					if (diagnostic.fix !== void 0) sent.fix = {
+						edits: diagnostic.fix.edits.map((edit) => ({
+							span: rangeIn(body, edit.start, edit.end),
+							text: edit.text
+						})),
+						title: diagnostic.fix.title
+					};
+					return sent;
+				}),
+				...procedureDiagnostics(host, body, own),
+				...outputDiagnostics(host, body, result.reads),
+				...inputDiagnostics(host, body)
+			].toSorted((a, b) => a.span.line - b.span.line),
+			program: {
+				code: result.output.code,
+				components: Object.fromEntries(host.components.components.filter((component) => reached.tags.has(component.name)).map((component) => [component.name, componentSchema(component)])),
+				format: PROGRAM_FORMAT,
+				imageHosts: host.imageHosts,
+				procedures: procedureTable(host, [...own, ...reached.uses]),
+				prose: result.output.constants
+			}
+		};
+	};
+	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);
+	}
+	return { compile };
+}
+/** Props the parser sets on Markdown elements, with the values it uses. */
+const MARKDOWN_PROPS = [{
+	component: "title",
+	prop: "size",
+	values: [
+		"xl",
+		"lg",
+		"md"
+	]
+}, {
+	component: "list",
+	prop: "ordered",
+	values: [true]
+}];
+/**
+* Throws when the catalog cannot draw what Markdown produces: the elements,
+* and the props the parser sets on them. Without them every heading or list
+* would be a diagnostic, and every turn a repair round.
+*/
+function checkMarkdownElements(catalog) {
+	const byName = new Map(catalog.components.map((component) => [component.name, component]));
+	const missing = MARKDOWN_ELEMENTS.filter((name) => !byName.has(name));
+	if (missing.length > 0) throw new Error(`The catalog has no ${missing.map((name) => `<${name}>`).join(", ")}, which Markdown prose compiles to`);
+	for (const need of MARKDOWN_PROPS) {
+		const schema = (byName.get(need.component)?.props[need.prop])?.schema;
+		if (!(schema !== void 0 && need.values.every((value) => schema.kind === "enum" ? schema.values.includes(String(value)) : schema.kind === "boolean" && value === true))) throw new Error(`<${need.component}> needs a \`${need.prop}\` prop that accepts ${need.values.map((value) => JSON.stringify(value)).join(", ")}, which Markdown sets`);
+	}
+}
+//#endregion
+export { MARKDOWN_ELEMENTS, checkMarkdownElements, createChecker };

package/dist/confirm.d.ts

@@ -0,0 +1,16 @@
+//#region src/confirm.d.ts
+/**
+ * Where the server records which tokens were used. `claim` returns true the
+ * first time it sees `id` and false after; `expiresAt` (ms since the epoch)
+ * is when it may forget the id. A store that throws refuses the call.
+ */
+export interface ConfirmationStore {
+  claim(id: string, expiresAt: number): Promise<boolean> | boolean;
+}
+/**
+ * The default store: a map in this process's memory, pruned of expired ids.
+ * Only valid for a single server process; behind a load balancer, pass a
+ * shared store, such as Redis `SET id 1 NX PXAT expiresAt`.
+ */
+export declare function memoryConfirmations(now: () => number): ConfirmationStore;
+//#endregion

package/dist/confirm.js

@@ -0,0 +1,97 @@
+//#region src/confirm.ts
+/**
+* Single-use confirmation tokens: HMAC-SHA-256 through Web Crypto, so they
+* work on every server target. A token binds one call (procedure, input and
+* subject), expires, and is claimed once through a `ConfirmationStore`.
+*/
+/** How long a token stays valid: five minutes. */
+const CONFIRM_TTL_MS = 3e5;
+/**
+* The host's confirmation text, made fit for one dialog. The host writes
+* the message, but the input it reads came from the program, which a prompt
+* injection may have written, so an unbounded value could fill the dialog
+* or push the question out of view. Control characters and line breaks
+* become spaces, runs of spaces collapse, and text past
+* `MAX_CONFIRM_MESSAGE` characters ends in an ellipsis.
+*/
+function confirmMessage(text) {
+	const flat = text.replaceAll(/[\p{Cc}\p{Cf}\s]+/gu, " ").trim();
+	if (flat.length <= 200) return flat;
+	return `${flat.slice(0, 199).trimEnd()}…`;
+}
+/**
+* The default store: a map in this process's memory, pruned of expired ids.
+* Only valid for a single server process; behind a load balancer, pass a
+* shared store, such as Redis `SET id 1 NX PXAT expiresAt`.
+*/
+function memoryConfirmations(now) {
+	const claimed = /* @__PURE__ */ new Map();
+	return { claim(id, expiresAt) {
+		const time = now();
+		for (const [key, expiry] of claimed) if (expiry <= time) claimed.delete(key);
+		if (claimed.has(id)) return false;
+		claimed.set(id, expiresAt);
+		return true;
+	} };
+}
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** JSON with every object's keys sorted, so equal inputs give equal text. */
+function canonicalJson(value) {
+	return JSON.stringify(value ?? null, (_key, entry) => isObject(entry) ? Object.fromEntries(Object.keys(entry).toSorted().map((key) => [key, entry[key]])) : entry);
+}
+const UUID = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/;
+function base64url(bytes) {
+	let text = "";
+	for (const byte of new Uint8Array(bytes)) text += String.fromCharCode(byte);
+	return btoa(text).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+/** The bytes of a base64url string, or null when it is not one. */
+function fromBase64url(text) {
+	if (!/^[\w-]*$/.test(text)) return null;
+	let binary;
+	try {
+		binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+	} catch {
+		return null;
+	}
+	return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+/**
+* Issues and checks tokens of the form `expiresAt.id.mac`. The MAC covers
+* the binding as well, so the binding never travels and a token for another
+* call fails as "invalid".
+*/
+function createConfirmer(secret, store, now) {
+	const encoder = new TextEncoder();
+	const key = crypto.subtle.importKey("raw", encoder.encode(secret), {
+		hash: "SHA-256",
+		name: "HMAC"
+	}, false, ["sign", "verify"]);
+	const signed = (binding, expiresAt, id) => encoder.encode(JSON.stringify([
+		"pickle-confirm-1",
+		binding.name,
+		binding.subject,
+		expiresAt,
+		id,
+		canonicalJson(binding.input)
+	]));
+	return {
+		async check(token, binding) {
+			const [expires = "", id = "", mac = "", ...rest] = token.split(".");
+			const expiresAt = Number(expires);
+			const signature = fromBase64url(mac);
+			if (rest.length > 0 || !Number.isSafeInteger(expiresAt) || !UUID.test(id) || signature === null) return "invalid";
+			if (String(expiresAt) !== expires || base64url(signature.buffer) !== mac) return "invalid";
+			if (!await crypto.subtle.verify("HMAC", await key, signature, signed(binding, expiresAt, id))) return "invalid";
+			if (expiresAt <= now()) return "expired";
+			return await store.claim(id, expiresAt) ? "ok" : "used";
+		},
+		async issue(binding) {
+			const expiresAt = now() + CONFIRM_TTL_MS;
+			const id = crypto.randomUUID();
+			return `${expiresAt}.${id}.${base64url(await crypto.subtle.sign("HMAC", await key, signed(binding, expiresAt, id)))}`;
+		}
+	};
+}
+//#endregion
+export { CONFIRM_TTL_MS, canonicalJson, confirmMessage, createConfirmer, memoryConfirmations };

package/dist/design.d.ts

@@ -0,0 +1,17 @@
+import "@jigs.design/compiler";
+import { Catalog } from "@jigs.design/host";
+import { Span } from "@jigs.design/runtime";
+//#region src/design.d.ts
+/** The design checks, by code. */
+export type DesignCheckCode = "design/literal-braces" | "design/many-actions" | "design/many-primary" | "design/nested-card" | "design/trailing-divider" | "design/unlabelled-button" | "design/unlabelled-chart" | "design/unlabelled-field";
+/** A design check's finding: advice, never an error. */
+export interface Advice {
+  code: DesignCheckCode;
+  message: string;
+  severity: "advice";
+  /** The line the advice is about, numbered like the diagnostics beside it. */
+  span: Span;
+}
+/** Where the UI sits: a whole document, or one block of a chat reply. */
+export type Placement = "chat" | "document";
+//#endregion

package/dist/design.js

@@ -0,0 +1,145 @@
+//#region src/design.ts
+/** A chat block holds at most this many actions. */
+const MAX_BLOCK_ACTIONS = 2;
+const meaningful = (node) => node.type !== "text" || node.value.trim() !== "";
+/** A prop's literal value, its default when unset, or `undefined` when an expression decides it. */
+function literalProp(node, component, name) {
+	const value = node.props[name];
+	if (value === void 0) return component.props[name]?.default;
+	return value.kind === "literal" ? value.value : void 0;
+}
+/** A prop that is unset, or set to a blank string. */
+function missing(node, name) {
+	const value = node.props[name];
+	return value === void 0 || value.kind === "literal" && String(value.value).trim() === "";
+}
+const INTERPOLATION = /\{([A-Za-z_$][\w$]*)\}/;
+/** Every design check's findings on one compiled source. */
+function designChecks(options) {
+	const { compiled } = options;
+	const components = new Map(options.catalog.components.map((component) => [component.name, component]));
+	const defines = new Map([...compiled.library, ...compiled.defines.map((entry) => [entry.name, entry])]);
+	const advice = [];
+	const seen = /* @__PURE__ */ new Set();
+	const report = (code, line, message) => {
+		const key = `${code}:${line}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			advice.push({
+				code,
+				message,
+				severity: "advice",
+				span: { line }
+			});
+		}
+	};
+	const actions = [];
+	let primaryProps = [];
+	const element = (node, frame, line) => {
+		const component = components.get(node.component);
+		const design = component?.design;
+		if (component === void 0 || design === void 0) return;
+		const tag = `<${node.component}>`;
+		const labelled = (prop) => Object.hasOwn(component.props, prop) && !missing(node, prop);
+		switch (design.role) {
+			case "action": {
+				const primary = design.primary !== void 0 && Object.entries(design.primary).every(([name, value]) => literalProp(node, component, name) === value);
+				if (primary && design.primary !== void 0) primaryProps = Object.keys(design.primary);
+				actions.push({
+					line,
+					primary,
+					repeated: frame.repeated
+				});
+				if (!node.children.some((child) => meaningful(child)) && Object.hasOwn(component.props, "ariaLabel") && !labelled("ariaLabel")) report("design/unlabelled-button", line, `This ${tag} has no label, so a screen reader cannot say what it does. Give it an \`ariaLabel\`, such as \`ariaLabel="Delete"\`.`);
+				break;
+			}
+			case "chart":
+				if (Object.hasOwn(component.props, "ariaLabel") && !labelled("ariaLabel")) report("design/unlabelled-chart", line, `This ${tag} has no \`ariaLabel\`. Give it one that states its takeaway, such as \`ariaLabel="Sales rose 12% in March"\`.`);
+				break;
+			case "field": {
+				const names = ["label", "ariaLabel"].filter((prop) => Object.hasOwn(component.props, prop));
+				if (names.length > 0 && !names.some((prop) => labelled(prop))) report("design/unlabelled-field", line, `This ${tag} has no ${names.map((prop) => `\`${prop}\``).join(" or ")}, so nothing names what it is for. Give it a \`${names[0] ?? "label"}\`.`);
+				break;
+			}
+			case "surface": if (frame.inCard) report("design/nested-card", line, `This ${tag} is inside another one. Keep one card and group what is inside it with a layout tag and \`gap\`, or put the cards one after the other.`);
+		}
+	};
+	const literalBraces = (props, line) => {
+		for (const [name, value] of Object.entries(props)) {
+			if (value.kind !== "literal") continue;
+			const found = INTERPOLATION.exec(String(value.value));
+			if (found !== null) report("design/literal-braces", line, `\`${name}="…{${found[1] ?? ""}}…"\` is plain text, so it shows the braces. Write the value as an expression: \`${name}={\`…\${${found[1] ?? ""}}…\`}\`.`);
+		}
+	};
+	const trailingDivider = (each, siblings, frame) => {
+		if (siblings.findLast((node) => meaningful(node)) !== each) return;
+		const last = each.children.findLast((node) => meaningful(node));
+		if (last?.type === "element" && last.component === "divider") report("design/trailing-divider", frame.line ?? last.line, `This <divider> ends every row, so one hangs under the last. Give the <each> \`index="i"\` and put the divider first, inside \`<if test={i > 0}>\`.`);
+	};
+	const walk = (nodes, frame) => {
+		for (const node of nodes) switch (node.type) {
+			case "element": {
+				const line = frame.line ?? node.line;
+				element(node, frame, line);
+				literalBraces(node.props, line);
+				const surface = components.get(node.component)?.design?.role === "surface";
+				walk(node.children, {
+					...frame,
+					inCard: frame.inCard || surface
+				});
+				break;
+			}
+			case "each":
+				trailingDivider(node, nodes, frame);
+				walk(node.children, {
+					...frame,
+					repeated: true
+				});
+				break;
+			case "if":
+				walk(node.children, frame);
+				break;
+			case "call": {
+				const define = defines.get(node.name);
+				if (define === void 0 || frame.within.has(node.name)) break;
+				walk(define.body, {
+					inCard: frame.inCard,
+					line: frame.line ?? (define.origin === "library" ? node.line : null),
+					repeated: frame.repeated,
+					slot: {
+						children: node.children,
+						frame
+					},
+					within: /* @__PURE__ */ new Set([...frame.within, node.name])
+				});
+				break;
+			}
+			case "slot": if (frame.slot !== null) walk(frame.slot.children, {
+				...frame.slot.frame,
+				inCard: frame.inCard,
+				repeated: frame.repeated
+			});
+		}
+	};
+	walk(compiled.program.tree, {
+		inCard: false,
+		line: null,
+		repeated: false,
+		slot: null,
+		within: /* @__PURE__ */ new Set()
+	});
+	const primaries = actions.filter((action) => action.primary);
+	const second = primaries.find((action) => action.repeated) ?? primaries[1];
+	if (second !== void 0) {
+		const others = primaryProps.map((prop) => `\`${prop}\``).join(" or ");
+		report("design/many-primary", second.line, second.repeated ? `This primary button repeats with every row, so the view has many. Keep one primary button for the view's main action, and give the row buttons another ${others}.` : `This is a second primary button. Keep one for the view's main action, and give the others another ${others}.`);
+	}
+	if (options.placement === "chat") {
+		const repeated = actions.find((action) => action.repeated);
+		const over = repeated ?? actions[MAX_BLOCK_ACTIONS];
+		if (over !== void 0) report("design/many-actions", over.line, repeated === void 0 ? `This block has ${actions.length} buttons; a block in a chat reply has at most ${MAX_BLOCK_ACTIONS}. Keep the ones that matter most: the reader can ask for the rest.` : `This button repeats with every row, so the block has more than ${MAX_BLOCK_ACTIONS}. A block in a chat reply has at most ${MAX_BLOCK_ACTIONS} buttons: move the row's action to one button for the whole block, or leave it to the reader to ask.`);
+	}
+	return advice.toSorted((a, b) => a.span.line - b.span.line);
+}
+//#endregion
+export { designChecks };

package/dist/errors.d.ts

@@ -0,0 +1,22 @@
+import { Diagnostic, PickleErrorCode, PickleErrorData } 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">;
+declare const BRAND: unique symbol;
+/** An error whose code and message reach the browser. */
+export declare class PickleError extends Error {
+  readonly [BRAND] = true;
+  readonly code: ThrownCode;
+  constructor(code: ThrownCode, message: string);
+}
+/**
+ * A source that failed a strict compile, or a spec in `specs` that failed at
+ * startup. `diagnostics` holds the error and warning diagnostics; the message
+ * lists them with their lines.
+ */
+export declare class PickleCompileError extends Error {
+  readonly diagnostics: ReadonlyArray<Diagnostic>;
+  constructor(subject: string, diagnostics: ReadonlyArray<Diagnostic>);
+}
+//#endregion
+export {};

package/dist/errors.js

@@ -0,0 +1,62 @@
+//#region src/errors.ts
+const BRAND = Symbol.for("@jigs.design/server.PickleError");
+/** An error whose code and message reach the browser. */
+var PickleError = class extends Error {
+	[BRAND] = true;
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "PickleError";
+	}
+};
+function isPickleError(cause) {
+	return typeof cause === "object" && cause !== null && BRAND in cause;
+}
+/** Diagnostics that make a stored spec or a strict compile fail. */
+function fatalDiagnostics(diagnostics) {
+	return diagnostics.filter((diagnostic) => diagnostic.severity === "error" || diagnostic.severity === "warning");
+}
+/**
+* A source that failed a strict compile, or a spec in `specs` that failed at
+* startup. `diagnostics` holds the error and warning diagnostics; the message
+* lists them with their lines.
+*/
+var PickleCompileError = 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";
+	}
+};
+const STATUS = {
+	BAD_INPUT: 400,
+	CONFLICT: 409,
+	DECLINED: 403,
+	FORBIDDEN: 403,
+	INTERNAL: 500,
+	NETWORK: 502,
+	NOT_FOUND: 404,
+	RATE_LIMITED: 429,
+	UNAUTHORIZED: 401,
+	UNAVAILABLE: 503,
+	UNKNOWN_PROCEDURE: 404
+};
+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. */
+function errorData(error) {
+	return error === null ? {
+		code: "INTERNAL",
+		message: INTERNAL_MESSAGE
+	} : {
+		code: error.code,
+		message: error.message
+	};
+}
+//#endregion
+export { INTERNAL_MESSAGE, PickleCompileError, PickleError, errorData, fatalDiagnostics, isPickleError, statusOf };

package/dist/index.d.ts

@@ -0,0 +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 { chatBlockText } from "./chat.js";
+import { PickleCompileError, PickleError, ThrownCode } from "./errors.js";
+import { createPickleServer, 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 };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { PickleCompileError, PickleError } 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 };