@jigs.design/server 0.0.0-stage → 0.1.0

package/dist/chat.js

@@ -0,0 +1,711 @@
+import { MARKDOWN_ELEMENTS } from "./compile.js";
+import { belowPrefix, pragmaLine, splitPragma, withPragma } from "./pragma.js";
+import { reorderDeclarations } from "./rewrite.js";
+import { applyChecked, editResult, runSession } from "./session.js";
+import { applyEdits, isEditReply, parseEdits } from "@jigs.design/compiler";
+import { editRepairText, needsRepair, repairText } from "@jigs.design/prompt";
+//#region src/chat.ts
+/**
+* The most blocks one reply shows. Each is a sandboxed program in the
+* browser, so a reply asked for dozens of UIs stops here; later blocks are
+* done with an error and no program.
+*/
+const MAX_BLOCKS = 8;
+/**
+* The most blocks of one reply that get a repair, each a model call (or
+* `maxRepairs` of them). Later blocks with errors are done as they are.
+*/
+const MAX_BLOCK_REPAIRS = 3;
+/**
+* Lines after unfenced Pickle that wait to see whether more Pickle 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
+* markup, ending in a tag.
+*/
+const PROSE_TAGS = /* @__PURE__ */ new Set([
+	...MARKDOWN_ELEMENTS,
+	"a",
+	"abbr",
+	"b",
+	"br",
+	"button",
+	"del",
+	"details",
+	"em",
+	"i",
+	"img",
+	"input",
+	"kbd",
+	"label",
+	"mark",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"summary",
+	"sup",
+	"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. */
+const BLOCK_CLOSE = /^ {0,3}`{3,}[ \t]*$/;
+/**
+* A fence with text after it, inside a block. Pickle 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,}(.+)$/;
+/** Tag names of tool-call markup, held back until the line shows what it is. */
+const TOOL_TAGS = [
+	"function_calls",
+	"invoke",
+	"parameter",
+	"tool_call",
+	"tool_use"
+];
+const TOOL_NAME = String.raw`(?:${TOOL_TAGS.join("|")})\b`;
+/** One tool tag, or an opening and a closing tag with only text between them. */
+const TOOL_PIECE = String.raw`(?:<\/?${TOOL_NAME}[^>]*>|<${TOOL_NAME}[^>]*>[^<]*<\/${TOOL_NAME}[^>]*>)`;
+/**
+* A prose line that is only tool-call markup, which some models leak into
+* their text instead of calling a tool. It would show as text. Text outside
+* a tag pair makes it prose: "`<invoke>` wraps each call."
+*/
+const TOOL_MARKUP = new RegExp(String.raw`^\s*${TOOL_PIECE}(?:\s*${TOOL_PIECE})*\s*$`);
+/** A line that opens any other fenced code block. */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+/** A partial line that may still turn into a fence line. */
+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 VALID_ID = /^[a-z][a-z0-9-]*$/;
+/**
+* A block as the model wrote it, for the model's history: a fenced `pickle`
+* 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\`\`\``;
+}
+/** 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}`;
+}
+/** Whether `line` closes a code fence opened with `fence`. */
+function closesFence(line, fence) {
+	const trimmed = line.trimStart();
+	if (line.length - trimmed.length > 3) return false;
+	let run = 0;
+	while (run < trimmed.length && trimmed[run] === fence[0]) run++;
+	return run >= fence.length && trimmed.slice(run).trim() === "";
+}
+/** `lines` without trailing blank lines, joined. */
+function bodyOf(lines) {
+	let end = lines.length;
+	while (end > 0 && (lines[end - 1] ?? "").trim() === "") end--;
+	return lines.slice(0, end).join("\n");
+}
+const TAG_LINE = /^ {0,3}<\/?([A-Za-z][\w-]*)/;
+const BODY_LINE = /^ {0,3}\{@body\b/;
+const BODY_PREFIX = "{@body";
+/** How a complete line changes the open-tag depth of a block with no fence. */
+function depthChange(line) {
+	const trimmed = line.trim();
+	const tag = TAG_LINE.exec(trimmed);
+	if (tag === null) return 0;
+	if (trimmed.startsWith("</")) return -1;
+	const name = tag[1] ?? "";
+	return trimmed.endsWith("/>") || trimmed.includes(`</${name}>`) ? 0 : 1;
+}
+/**
+* Splits a chat reply into prose and pickle 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
+* its program changes.
+*/
+function createReplyParser(deps, history) {
+	/** Latest body (no pragma) by id. */
+	const latest = /* @__PURE__ */ new Map();
+	/**
+	* The body as this reply wrote it, by id, for a block whose `{@body}`
+	* lines the server moved: an edit later in the same reply was written
+	* against it, not against the moved source.
+	*/
+	const asWritten = /* @__PURE__ */ new Map();
+	/** The version `edits` apply to: the latest, or the one the reply wrote. */
+	const baseFor = (id, edits) => {
+		const base = latest.get(id);
+		const written = asWritten.get(id);
+		return base !== void 0 && written !== void 0 && !applyEdits(base, edits).ok && applyEdits(written, edits).ok ? written : base;
+	};
+	const versions = /* @__PURE__ */ new Map();
+	/** By block key, so a copy of the block (spread, cloned, serialized) finds its plan. */
+	const plans = /* @__PURE__ */ new Map();
+	/** By block key, in the order the blocks closed. */
+	const results = /* @__PURE__ */ new Map();
+	let autoId = 0;
+	let opened = 0;
+	let repairsLeft = MAX_BLOCK_REPAIRS;
+	for (const entry of history) {
+		if (!VALID_ID.test(entry.id)) continue;
+		latest.set(entry.id, splitPragma(entry.source).body);
+		versions.set(entry.id, (versions.get(entry.id) ?? 0) + 1);
+		const auto = AUTO_ID.exec(entry.id);
+		if (auto !== null) autoId = Math.max(autoId, Number(auto[1]));
+	}
+	const empty = deps.compile("");
+	let mode = { kind: "prose" };
+	/** The current prose line, while it may still be a fence line. */
+	let held = "";
+	/** 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. */
+	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 partial prose line may still become a stray line. */
+	const mayBeStray = (partial) => {
+		const trimmed = partial.trimStart();
+		if (partial.length - trimmed.length > 3) return false;
+		if (trimmed === "") return false;
+		if (trimmed === "<" || trimmed === "</") return true;
+		if (trimmed.startsWith("{")) return BODY_PREFIX.startsWith(trimmed) || BODY_LINE.test(trimmed);
+		const tag = TAG_LINE.exec(trimmed);
+		if (tag === null) return false;
+		const name = tag[1] ?? "";
+		if (tag[0].length === trimmed.length) {
+			for (const known of [...deps.tags, ...TOOL_TAGS]) if (known.startsWith(name)) return true;
+			return false;
+		}
+		return deps.tags.has(name) || TOOL_TAGS.includes(name);
+	};
+	const text = (value) => {
+		if (value === "") return;
+		const last = out.at(-1);
+		if (last?.type === "text") out[out.length - 1] = {
+			text: last.text + value,
+			type: "text"
+		};
+		else out.push({
+			text: value,
+			type: "text"
+		});
+	};
+	const blockOf = (open, body, compiled, status, error) => {
+		const block = {
+			diagnostics: belowPrefix(compiled.diagnostics, pragmaLine(deps.catalogVersion)),
+			id: open.id,
+			key: `${open.id}@${open.version}`,
+			program: compiled.program,
+			source: withPragma(body, deps.catalogVersion),
+			status,
+			version: open.version
+		};
+		if (error !== void 0) block.error = error;
+		return block;
+	};
+	const emit = (block) => {
+		out.push({
+			block,
+			type: "block"
+		});
+	};
+	/**
+	* Emits a block that closed, and records what it came to. A block whose
+	* edit did not apply shows the previous version, whose diagnostics are
+	* not the reply's, so its result has none. `advice` is numbered by the
+	* body's lines, as the compile reported it.
+	*/
+	const settle = (open, block, edits, advice = [], rewrite) => {
+		const result = {
+			advice: belowPrefix(advice, pragmaLine(deps.catalogVersion)),
+			diagnostics: edits?.applied === false ? [] : block.diagnostics,
+			fenced: !open.implicit,
+			id: block.id,
+			key: block.key,
+			repairs: [],
+			status: block.status === "repairing" ? "repairing" : "done"
+		};
+		if (edits !== void 0) result.edits = edits;
+		if (block.error !== void 0) result.error = block.error;
+		if (rewrite !== void 0) result.rewrites = [rewrite];
+		results.set(block.key, result);
+		emit(block);
+	};
+	const open = (info, indent, implicit = false) => {
+		const named = slug(info ?? "");
+		const id = named === "" ? `pickle-${++autoId}` : named;
+		const version = (versions.get(id) ?? 0) + 1;
+		versions.set(id, version);
+		opened++;
+		const block = {
+			baseShown: false,
+			depth: 0,
+			dirty: false,
+			editsShown: 0,
+			id,
+			implicit,
+			indent,
+			lastKey: JSON.stringify(empty.program),
+			lastSentAt: Number.NEGATIVE_INFINITY,
+			lines: [],
+			over: opened > MAX_BLOCKS,
+			partial: "",
+			version,
+			waiting: []
+		};
+		mode = {
+			block,
+			kind: "block"
+		};
+		if (!block.over) emit(blockOf(block, "", empty, "streaming"));
+	};
+	/**
+	* Compiles the committed lines. An edit block shows its base version,
+	* then each finished edit over it; edits that do not apply wait for the
+	* block to close, which reports them.
+	*/
+	const refresh = (block) => {
+		if (block.over) return;
+		let body = bodyOf(block.lines);
+		const editing = isEditReply(body);
+		if (editing === true) {
+			const edits = parseEdits(body);
+			const base = baseFor(block.id, edits);
+			if (base === void 0) return;
+			if (!block.baseShown) {
+				block.baseShown = true;
+				const compiled = deps.compile(base);
+				block.lastKey = JSON.stringify(compiled.program);
+				emit(blockOf(block, base, compiled, "streaming"));
+			}
+			const applied = applyEdits(base, edits);
+			if (edits.length === block.editsShown || !applied.ok) return;
+			block.editsShown = edits.length;
+			body = applied.text;
+		} else if (editing === null) return;
+		const compiled = deps.compile(body);
+		const key = JSON.stringify(compiled.program);
+		const now = deps.now();
+		if (key !== block.lastKey && now - block.lastSentAt >= deps.programIntervalMs) {
+			block.lastKey = key;
+			block.lastSentAt = now;
+			emit(blockOf(block, body, compiled, "streaming"));
+		}
+	};
+	/** Whether a block that closed with a problem gets a repair round. */
+	const repairable = () => {
+		if (!deps.repairs || repairsLeft === 0) return false;
+		repairsLeft--;
+		return true;
+	};
+	const close = (block) => {
+		mode = { kind: "prose" };
+		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.`
+			}));
+			return;
+		}
+		const written = bodyOf(block.lines);
+		let body = written;
+		let edits;
+		if (isEditReply(written) === true) {
+			const parsed = parseEdits(written);
+			const base = baseFor(block.id, parsed);
+			if (base === void 0) {
+				settle(block, blockOf(block, "", empty, "done", {
+					code: "NOT_FOUND",
+					message: `There is no earlier pickle "${block.id}" to change.`
+				}), {
+					applied: false,
+					blocks: parsed.length
+				});
+				return;
+			}
+			const applied = applyChecked(base, parsed, deps.compile);
+			edits = editResult(parsed.length, applied);
+			if (!applied.ok) {
+				const previous = deps.compile(base);
+				if (!repairable()) {
+					settle(block, blockOf(block, base, previous, "done", {
+						code: "INTERNAL",
+						message: "The model's edit could not be applied."
+					}), edits);
+					return;
+				}
+				const pending = blockOf(block, base, previous, "repairing");
+				const { ok: _ok, ...failure } = applied;
+				plans.set(pending.key, {
+					base,
+					failure,
+					kind: "edit"
+				});
+				settle(block, pending, edits);
+				return;
+			}
+			body = applied.text;
+		}
+		let compiled = deps.compile(body);
+		const reordered = reorderDeclarations(body, compiled, deps.compile);
+		if (reordered === null) asWritten.delete(block.id);
+		else {
+			asWritten.set(block.id, body);
+			({body, compiled} = reordered);
+		}
+		latest.set(block.id, body);
+		const advice = compiled.advise("chat");
+		const chosen = advice.filter((entry) => deps.designRepair.has(entry.code));
+		if ((needsRepair(compiled.diagnostics) || chosen.length > 0) && repairable()) {
+			const pending = blockOf(block, body, compiled, "repairing");
+			plans.set(pending.key, {
+				advice: chosen,
+				body,
+				diagnostics: compiled.diagnostics,
+				kind: "errors"
+			});
+			settle(block, pending, edits, advice, reordered?.rewrite);
+			return;
+		}
+		settle(block, blockOf(block, body, compiled, "done"), edits, advice, reordered?.rewrite);
+	};
+	/** One complete line, without its newline. */
+	const line = (raw) => {
+		const value = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+		if (mode.kind === "block") {
+			const { block } = mode;
+			if (block.implicit) {
+				if (block.depth > 0 || pickleLine(value)) {
+					block.lines.push(...block.waiting);
+					block.waiting = [];
+					block.depth = Math.max(0, block.depth + depthChange(value));
+					block.lines.push(value);
+					block.dirty = true;
+					return;
+				}
+				if (FENCE_OPEN.exec(value) === null && block.waiting.length < MAX_HELD_LINES) {
+					block.waiting.push(value);
+					return;
+				}
+				finishImplicit(block);
+				line(raw);
+				return;
+			}
+			if (BLOCK_CLOSE.test(value)) {
+				close(block);
+				return;
+			}
+			const runOn = BLOCK_CLOSE_RUN_ON.exec(value);
+			if (runOn !== null) {
+				close(block);
+				line(PICKLE_OPEN.test(value) ? value : (runOn[1] ?? "").trimStart());
+				return;
+			}
+			let cut = 0;
+			while (cut < block.indent && value[cut] === " ") cut++;
+			block.lines.push(value.slice(cut));
+			block.dirty = true;
+			return;
+		}
+		if (lineIsText) {
+			text("\n");
+			return;
+		}
+		if (mode.kind === "code") {
+			if (closesFence(value, mode.fence)) mode = { kind: "prose" };
+			text(`${raw}\n`);
+			return;
+		}
+		const pickle = PICKLE_OPEN.exec(value);
+		if (pickle !== null) {
+			open(pickle[2], pickle[1]?.length ?? 0);
+			return;
+		}
+		if (TOOL_MARKUP.test(value)) return;
+		if (strayLine(value)) {
+			open(void 0, 0, true);
+			line(raw);
+			return;
+		}
+		const fence = FENCE_OPEN.exec(value);
+		if (fence !== null && !(fence[1]?.startsWith("`") && fence[2]?.includes("`"))) mode = {
+			fence: fence[1] ?? "```",
+			kind: "code"
+		};
+		text(`${raw}\n`);
+	};
+	/**
+	* Closes a block; for one with no fence, the lines still waiting after
+	* its Pickle are prose again.
+	*/
+	function finishImplicit(block) {
+		const waiting = block.waiting;
+		block.waiting = [];
+		close(block);
+		for (const value of waiting) line(value);
+	}
+	const push = (delta) => {
+		out = [];
+		let rest = delta;
+		while (rest !== "") {
+			const newline = rest.indexOf("\n");
+			const piece = newline === -1 ? rest : rest.slice(0, newline);
+			rest = newline === -1 ? "" : rest.slice(newline + 1);
+			if (mode.kind === "block") {
+				const { block } = mode;
+				block.partial += piece;
+				if (newline !== -1) {
+					const whole = block.partial;
+					block.partial = "";
+					line(whole);
+				}
+			} else if (lineIsText) {
+				text(piece);
+				if (newline !== -1) {
+					line("");
+					lineIsText = false;
+				}
+			} else {
+				held += piece;
+				if (newline !== -1) {
+					const whole = held;
+					held = "";
+					line(whole);
+				} else if (!MAYBE_FENCE.test(held) && !FENCE_START.test(held) && !mayBeStray(held)) {
+					lineIsText = true;
+					text(held);
+					held = "";
+				}
+			}
+		}
+		if (mode.kind === "block" && mode.block.dirty) {
+			mode.block.dirty = false;
+			refresh(mode.block);
+		}
+		const events = out;
+		out = [];
+		return events;
+	};
+	/** Closes the block `line` may have opened; a function, so `mode` is read fresh. */
+	const closeOpen = () => {
+		if (mode.kind === "block") finishImplicit(mode.block);
+	};
+	const end = () => {
+		out = [];
+		if (mode.kind === "block") {
+			const { block } = mode;
+			const last = block.partial;
+			block.partial = "";
+			if (!block.implicit) {
+				if (last !== "") line(last);
+				closeOpen();
+			} else if (last !== "" && (block.depth > 0 || pickleLine(last))) {
+				line(last);
+				closeOpen();
+			} else {
+				finishImplicit(block);
+				if (PICKLE_OPEN.exec(last) === null) text(last);
+			}
+		} else if (lineIsText) lineIsText = false;
+		else if (held !== "") {
+			const last = held;
+			held = "";
+			if (mode.kind !== "code" && strayLine(last)) {
+				line(last);
+				closeOpen();
+			} else if (mode.kind === "code" || PICKLE_OPEN.exec(last) === null) text(last);
+		}
+		const events = out;
+		out = [];
+		return events;
+	};
+	return {
+		claim: (block) => {
+			const plan = plans.get(block.key);
+			plans.delete(block.key);
+			return plan;
+		},
+		end,
+		plan: (block) => plans.get(block.key),
+		push,
+		remember: (id, body) => {
+			asWritten.delete(id);
+			latest.set(id, body);
+		},
+		result: (key) => results.get(key),
+		results: () => [...results.values()].map((result) => ({ ...result }))
+	};
+}
+/**
+* Repairs one block with a document-mode session turn: the user's message,
+* the block's source as the assistant's answer, and the follow-up that asks
+* for the fix.
+*/
+async function* repairBlock(deps, block) {
+	if (block.status !== "repairing") {
+		yield block;
+		return;
+	}
+	const plan = deps.parser.claim(block);
+	if (plan === void 0) {
+		yield {
+			...block,
+			error: {
+				code: "NOT_FOUND",
+				message: `No repair is waiting for "${block.key}": it was repaired already, or comes from another turn.`
+			},
+			status: "done"
+		};
+		return;
+	}
+	const result = deps.parser.result(block.key);
+	const base = plan.kind === "edit" ? plan.base : plan.body;
+	const ask = `Write the "${block.id}" UI.`;
+	const messages = [
+		{
+			content: deps.prompt === void 0 ? ask : `${deps.prompt}\n\n${ask}`,
+			role: "user"
+		},
+		{
+			content: base,
+			role: "assistant"
+		},
+		{
+			content: plan.kind === "edit" ? editRepairText(plan.failure, plan.base) : repairText(plan.diagnostics, plan.advice),
+			role: "user"
+		}
+	];
+	let program = null;
+	let failure = {
+		code: "INTERNAL",
+		message: "The repair stopped before it finished."
+	};
+	const forward = deps.session.onTurn;
+	const session = {
+		...deps.session,
+		designRepair: plan.kind === "errors" && plan.advice.length > 0 ? /* @__PURE__ */ new Set() : deps.session.designRepair,
+		editFailures: plan.kind === "edit" ? 1 : 0,
+		onTurn: async (turn) => {
+			if (result !== void 0) result.repairs = turn.rounds;
+			await forward?.(turn);
+		}
+	};
+	for await (const event of runSession(session, messages, deps.options, deps.call)) if (event.type === "program") program = event.program;
+	else if (event.type === "done") {
+		deps.parser.remember(block.id, splitPragma(event.source).body);
+		if (result !== void 0) result.status = "done";
+		yield {
+			...block,
+			diagnostics: event.diagnostics,
+			program: program ?? block.program,
+			source: event.source,
+			status: "done"
+		};
+		return;
+	} else failure = event.error;
+	if (result !== void 0) {
+		result.error = failure;
+		result.status = "done";
+	}
+	yield {
+		...block,
+		error: failure,
+		status: "done"
+	};
+}
+/**
+* Runs `push`, `end` and `repair` over a reply's text. Repairs start as
+* their block closes and run while the rest of the reply streams; the
+* iterable ends once the text has ended and every repair has settled.
+*/
+async function* streamChat(turn, reply, signal) {
+	const ready = [];
+	let wake = null;
+	let running = 0;
+	const outcome = {};
+	const stop = new AbortController();
+	const stopped = () => stop.signal.aborted || signal?.aborted === true;
+	const notify = () => {
+		const resume = wake;
+		wake = null;
+		resume?.();
+	};
+	const repair = async (block) => {
+		try {
+			for await (const next of turn.repair(block)) {
+				ready.push({
+					block: next,
+					type: "block"
+				});
+				notify();
+			}
+		} finally {
+			running--;
+			notify();
+		}
+	};
+	const take = (events) => {
+		for (const event of events) {
+			ready.push(event);
+			if (event.type === "block" && event.block.status === "repairing") {
+				running++;
+				repair(event.block);
+			}
+		}
+		notify();
+	};
+	const pump = async () => {
+		const iterator = reply[Symbol.asyncIterator]();
+		try {
+			for (;;) {
+				if (stopped()) return;
+				const step = await iterator.next();
+				if (step.done === true) break;
+				take(turn.push(step.value));
+			}
+			take(turn.end());
+		} catch (error) {
+			outcome.failure = { error };
+		} finally {
+			if (stopped()) iterator.return?.();
+			running--;
+			notify();
+		}
+	};
+	running++;
+	pump();
+	try {
+		for (;;) {
+			const next = ready.shift();
+			if (next !== void 0) {
+				yield next;
+				continue;
+			}
+			if (running === 0) break;
+			await new Promise((resolve) => {
+				wake = resolve;
+			});
+		}
+		if (outcome.failure !== void 0) throw outcome.failure.error;
+	} finally {
+		stop.abort();
+	}
+}
+//#endregion
+export { chatBlockText, createReplyParser, repairBlock, streamChat };

package/dist/compile.d.ts

@@ -0,0 +1,3 @@
+import "./design.js";
+import { Catalog, Host } from "@jigs.design/host";
+import { Diagnostic, Program } from "@jigs.design/runtime";