gesso-vite-plugin 0.6.30 → 0.8.0

package/dist/contracts-Dwn5pg-0.js

@@ -0,0 +1,1299 @@
+//#region src/catalog.ts
+/** What tells an agent, when it connects, that the catalog is here and to use it. */
+const CATALOG_INSTRUCTIONS = "This project has its own components. Before building anything, read them: library_overview lists every one, library_search finds the ones that fit, and library_get gives one in full with the inputs it takes. Use them, and write the theme's names from tokens_view rather than raw colours and sizes.";
+const READ_ONLY = {
+	readOnlyHint: true,
+	openWorldHint: false
+};
+const CATALOG_TOOLS = [
+	{
+		name: "library_overview",
+		title: "List the project's components",
+		description: "Every component this project has, one line each: its name, what it is for, where to import it from and how many files use it. Read it before building anything, and use what is here.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			additionalProperties: false
+		},
+		annotations: READ_ONLY
+	},
+	{
+		name: "library_search",
+		title: "Find components",
+		description: "The components whose name, purpose or inputs match a few words, such as \"date range\" or \"avatar\". Best matches first.",
+		inputSchema: {
+			type: "object",
+			properties: { query: {
+				type: "string",
+				description: "A few words for what the component should be or do."
+			} },
+			required: ["query"],
+			additionalProperties: false
+		},
+		annotations: READ_ONLY
+	},
+	{
+		name: "library_get",
+		title: "Read a component",
+		description: "One component in full: what it is for, every input it takes with its type, default and meaning, examples, and the files that already use it, which show how this project writes it.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					description: "The component, as library_overview names it."
+				},
+				from: {
+					type: "string",
+					description: "Where it is imported from, when two components share the name."
+				}
+			},
+			required: ["name"],
+			additionalProperties: false
+		},
+		annotations: READ_ONLY
+	}
+];
+var ComponentCatalog = class {
+	cached = null;
+	reader;
+	root;
+	options;
+	constructor(reader, root, options) {
+		this.reader = reader;
+		this.root = root.replace(/\/+$/, "");
+		this.options = options;
+	}
+	/**
+	* Something in the project changed. The whole catalog is read again
+	* on the next call: a project's components read in a tenth of a
+	* second, and a save can move a component between files, rename it,
+	* or start using it somewhere else.
+	*/
+	invalidate() {
+		this.cached = null;
+	}
+	/**
+	* The components, read once until something changes. A read that
+	* fails (TypeScript refusing a project mid-change) is a warning and an
+	* empty catalog, tried again on the next call, never a rejection left
+	* for nobody to catch, which ends the dev server.
+	*/
+	entries() {
+		return this.cached ??= this.read().catch((error) => {
+			this.cached = null;
+			console.warn(`[gesso] The component catalog could not be read: ${String(error.message ?? error)}`);
+			return [];
+		});
+	}
+	async call(name, args = {}) {
+		if (await this.reader() === null) return failure("The catalog needs TypeScript 7, which reads the components. Add `typescript` (7 or later).");
+		const entries = await this.entries();
+		switch (name) {
+			case "library_overview": return success(formatOverview(entries), { components: entries.map(summaryOf) });
+			case "library_search": {
+				if (typeof args.query !== "string" || args.query.trim() === "") return failure("library_search needs query: a few words for what the component should be or do.");
+				const found = search(entries, args.query);
+				if (found.length === 0) return success(`Nothing matches "${args.query}". library_overview lists every component.`, { components: [] });
+				return success(formatLines(found), { components: found.map(summaryOf) });
+			}
+			case "library_get": {
+				if (typeof args.name !== "string") return failure("library_get needs name: the component, as library_overview names it.");
+				const named = entries.filter((entry) => entry.name === args.name);
+				const matches = typeof args.from === "string" ? named.filter((entry) => entry.from === args.from) : named;
+				if (matches.length === 0) {
+					const near = search(entries, args.name).slice(0, 3);
+					return failure(`There is no component called ${args.name}` + (near.length === 0 ? "." : `. Did you mean ${near.map((entry) => entry.name).join(", ")}?`));
+				}
+				if (matches.length > 1) return failure(`${matches.length} components are called ${args.name}; say which with from: ` + matches.map((entry) => JSON.stringify(entry.from)).join(", "));
+				const entry = matches[0];
+				return success(formatEntry(entry), {
+					...entry,
+					schema: entry.schema
+				});
+			}
+			default: return failure(`There is no tool called ${name}.`);
+		}
+	}
+	async read() {
+		const reader = await this.reader();
+		if (reader === null) return [];
+		const excluded = (this.options.exclude ?? []).map((folder) => `${this.root}/${folder.replace(/^\.?\/+|\/+$/g, "")}/`);
+		const sources = reader.sources(this.options.tsconfig).filter((source) => source.file.startsWith(`${this.root}/`) && !/\.(?:spec|test)\.[cm]?[jt]sx?$/.test(source.file) && !excluded.some((folder) => source.file.startsWith(folder)));
+		const found = [];
+		for (const source of sources) {
+			if (!mayDeclareComponent(source.text)) continue;
+			const from = source.file.slice(this.root.length + 1).replace(/\.[cm]?[jt]sx?$/, "");
+			for (const [name, schema] of reader.readComponents(source.file, this.options.tsconfig).components) found.push({
+				name,
+				from,
+				file: source.file,
+				schema
+			});
+		}
+		for (const library of await this.options.libraries?.() ?? []) for (const [name, schema] of reader.readComponents(library.file).components) found.push({
+			name,
+			from: library.name,
+			library: library.name,
+			schema
+		});
+		return found.map((component) => {
+			const tag = new RegExp(`<${component.name}[\\s/>]`);
+			const usedIn = sources.filter((source) => source.file !== component.file && tag.test(source.text)).map((source) => source.file.slice(this.root.length + 1));
+			return {
+				name: component.name,
+				from: component.from,
+				...component.library === void 0 ? {} : { library: component.library },
+				schema: component.schema,
+				usedIn
+			};
+		});
+	}
+};
+/**
+* Whether a module could declare a component, without asking the
+* checker: it imports from `gesso-framework` and names `Inputs` or
+* `Component`. Most of a project's files are neither, and each one the
+* checker is spared is a round trip to its process.
+*/
+function mayDeclareComponent(text) {
+	return text.includes("gesso-framework") && /\b(?:Inputs|Component)\b/.test(text);
+}
+function summaryOf(entry) {
+	return {
+		name: entry.name,
+		from: entry.from,
+		...entry.library === void 0 ? {} : { library: entry.library },
+		...entry.schema.summary === void 0 ? {} : { summary: entry.schema.summary },
+		...entry.schema.deprecated === void 0 ? {} : { deprecated: entry.schema.deprecated },
+		usedIn: entry.usedIn.length
+	};
+}
+function formatOverview(entries) {
+	if (entries.length === 0) return "This project has no components yet: no module exports a function taking Inputs<P>, or a class extending Component. Build the first ones, and they will be listed here.";
+	const own = entries.filter((entry) => entry.library === void 0);
+	return [...[`${own.length} component${own.length === 1 ? "" : "s"} in this project` + (own.length === entries.length ? "" : `, and ${entries.length - own.length} from libraries it names`) + ". library_get gives one in full.", ""], formatLines(entries)].join("\n");
+}
+/** One line per component, grouped under where each is imported from. */
+function formatLines(entries) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const group = groups.get(entry.from) ?? [];
+		group.push(entry);
+		groups.set(entry.from, group);
+	}
+	const lines = [];
+	for (const [from, group] of groups) {
+		lines.push(group[0].library === void 0 ? from : `${from} (library)`);
+		for (const entry of group) {
+			const summary = firstSentence(entry.schema.summary);
+			const deprecated = entry.schema.deprecated === void 0 ? "" : " [deprecated]";
+			const used = entry.usedIn.length === 0 ? "" : ` (used in ${entry.usedIn.length})`;
+			lines.push(`  ${entry.name}${deprecated}${summary === "" ? "" : `: ${summary}`}${used}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* One component as an agent writing TSX wants it: the import, each
+* input as `name type = default` with its meaning under it, the shared
+* inputs folded into a line, and the files to copy its use from. The schema itself
+* goes with it as structured content, for a client that validates.
+*/
+function formatEntry(entry) {
+	const schema = entry.schema;
+	const lines = [`${entry.name}, from ${entry.from}${entry.library === void 0 ? "" : " (library)"}`];
+	if (schema.deprecated !== void 0) lines.push(`Deprecated${schema.deprecated === true ? "." : `: ${schema.deprecated}`}`);
+	if (schema.summary !== void 0) lines.push(schema.summary);
+	const inputs = schema.inputs;
+	const required = new Set(inputs.required ?? []);
+	const own = [];
+	const shared = /* @__PURE__ */ new Map();
+	for (const [name, input] of Object.entries(inputs.properties ?? {})) {
+		const from = input["x-gesso-from"];
+		if (typeof from === "string") {
+			shared.set(from, [...shared.get(from) ?? [], name]);
+			continue;
+		}
+		own.push(`  ${name}${required.has(name) ? "*" : ""} ${describeInput(input)}`);
+	}
+	lines.push("", own.length === 0 ? "Inputs: none of its own." : "Inputs (* required):", ...own);
+	for (const [from, names] of shared) lines.push(`Also takes the inputs of ${from}: ${names.join(", ")}.`);
+	if (entry.usedIn.length > 0) lines.push("", `Used in: ${entry.usedIn.join(", ")}`);
+	if (schema.examples !== void 0) lines.push("", "Examples:", ...schema.examples.map((example) => indent(example)));
+	if (schema.description !== void 0 && schema.description.replace(/\s+/g, " ").trim() !== schema.summary) lines.push("", "About it:", indent(schema.description));
+	return lines.join("\n");
+}
+function describeInput(input) {
+	const type = Array.isArray(input.enum) && input.enum.length > 0 ? input.enum.map((value) => JSON.stringify(value)).join(" | ") : String(input["x-gesso-type"] ?? "unknown");
+	const kind = input["x-gesso-callback"] === true ? " (callback)" : input["x-gesso-child"] === true ? " (child)" : "";
+	const fallback = input.default === void 0 ? "" : ` = ${JSON.stringify(input.default)}`;
+	const meaning = firstParagraph(typeof input.description === "string" ? input.description : void 0);
+	return `${type}${kind}${fallback}${meaning === "" ? "" : `\n      ${meaning}`}`;
+}
+/**
+* The components a few words find, best first: a word in the name
+* counts most, then in the summary, then in the rest of the description
+* and the input names. A component every word misses is left out.
+*/
+function search(entries, query) {
+	const words = query.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+	return entries.map((entry) => {
+		const name = spaced(entry.name);
+		const summary = (entry.schema.summary ?? "").toLowerCase();
+		const rest = `${entry.schema.description ?? ""} ${Object.keys(entry.schema.inputs.properties ?? {}).join(" ")}`.toLowerCase();
+		let score = 0;
+		for (const word of words) score += name.includes(word) ? 6 : summary.includes(word) ? 3 : rest.includes(word) ? 1 : 0;
+		return {
+			entry,
+			score
+		};
+	}).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).map(({ entry }) => entry);
+}
+/** `DateRangePicker` as `date range picker datarangepicker`, so both spellings find it. */
+function spaced(name) {
+	return `${name.replace(/([a-z0-9])([A-Z])/g, "$1 $2")} ${name}`.toLowerCase();
+}
+function firstSentence(text) {
+	if (text === void 0) return "";
+	const flat = text.replace(/\s+/g, " ").trim();
+	const end = flat.search(/[.!?](\s|$)/);
+	const sentence = end === -1 ? flat : flat.slice(0, end + 1);
+	return sentence.length > 140 ? `${sentence.slice(0, 139)}…` : sentence;
+}
+function firstParagraph(text) {
+	if (text === void 0) return "";
+	const paragraph = text.split(/\n\s*\n/)[0].replace(/\s+/g, " ").trim();
+	return paragraph.length > 240 ? `${paragraph.slice(0, 239)}…` : paragraph;
+}
+function indent(text) {
+	return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function success(text, structured) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		structuredContent: structured,
+		isError: false
+	};
+}
+function failure(text) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		isError: true
+	};
+}
+//#endregion
+//#region src/source.ts
+const IDENTIFIER = /[A-Za-z0-9_$]/;
+/**
+* A copy of `code` in which every string, template literal, regular
+* expression body and comment is spaces, and everything else is
+* untouched.
+*
+* Same length as the input, and newlines are kept, so an index into
+* the result is an index into the original and a line number is still
+* a line number. String and template delimiters are kept as well, so a
+* specifier can be found by its quotes here and read from there.
+*/
+function blankLiterals(code) {
+	const out = code.split("");
+	let index = 0;
+	let regexAllowed = true;
+	const blank = (from, to) => {
+		for (let i = from; i < to; i++) if (out[i] !== "\n") out[i] = " ";
+	};
+	while (index < code.length) {
+		const char = code[index];
+		if (char === "/" && code[index + 1] === "/") {
+			const end = code.indexOf("\n", index);
+			blank(index, end === -1 ? code.length : end);
+			index = end === -1 ? code.length : end;
+			continue;
+		}
+		if (char === "/" && code[index + 1] === "*") {
+			const end = code.indexOf("*/", index + 2);
+			const stop = end === -1 ? code.length : end + 2;
+			blank(index, stop);
+			index = stop;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			const end = closingQuote(code, index, char);
+			blank(index + 1, end);
+			index = end + 1;
+			regexAllowed = false;
+			continue;
+		}
+		if (char === "`") {
+			const end = closingQuote(code, index, "`");
+			blank(index + 1, end);
+			index = end + 1;
+			regexAllowed = false;
+			continue;
+		}
+		if (char === "/" && regexAllowed) {
+			const end = closingRegex(code, index);
+			if (end !== -1) {
+				blank(index + 1, end);
+				index = end + 1;
+				regexAllowed = false;
+				continue;
+			}
+		}
+		if (!/\s/.test(char)) regexAllowed = !IDENTIFIER.test(char) && char !== ")" && char !== "]";
+		index++;
+	}
+	return out.join("");
+}
+/** The index of the quote that closes the one at `open`, or the end. */
+function closingQuote(code, open, quote) {
+	for (let i = open + 1; i < code.length; i++) {
+		if (code[i] === "\\") {
+			i++;
+			continue;
+		}
+		if (code[i] === quote) return i;
+	}
+	return code.length;
+}
+/**
+* The index of the slash closing a regular expression, or -1 when the
+* slash was division after all.
+*
+* A newline inside means it was not a regular expression, which is the
+* cheap test that keeps `a / b` and `c / d` on one line from swallowing
+* everything between them.
+*/
+function closingRegex(code, open) {
+	let inClass = false;
+	for (let i = open + 1; i < code.length; i++) {
+		const char = code[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\n") return -1;
+		if (char === "[") {
+			inClass = true;
+			continue;
+		}
+		if (char === "]") {
+			inClass = false;
+			continue;
+		}
+		if (char === "/" && !inClass) return i;
+	}
+	return -1;
+}
+/**
+* Every call of `name` in the module, in source order.
+*
+* A bare name has to stand alone: `renderRoot(` matches, `myRenderRoot(`
+* and `thing.renderRoot(` do not, because a method of that name on some
+* other object is not the framework's function. A name written with a
+* leading dot is the opposite and matches only the method call:
+* `.useService(` is how a builder chain reads and the only way it is
+* ever written.
+*/
+function findCalls(code, name, blank = blankLiterals(code)) {
+	const member = name.startsWith(".");
+	const bare = member ? name.slice(1) : name;
+	const sites = [];
+	let from = 0;
+	for (;;) {
+		const at = blank.indexOf(bare, from);
+		if (at === -1) return sites;
+		from = at + bare.length;
+		const before = at === 0 ? "" : blank[at - 1];
+		if (member ? before !== "." : before !== "" && (IDENTIFIER.test(before) || before === ".")) continue;
+		let cursor = from;
+		while (cursor < blank.length && /\s/.test(blank[cursor])) cursor++;
+		if (blank[cursor] !== "(") continue;
+		const argsEnd = matchingBracket(blank, cursor);
+		if (argsEnd === -1) continue;
+		sites.push({
+			start: at,
+			argsStart: cursor + 1,
+			argsEnd,
+			end: argsEnd + 1
+		});
+		from = argsEnd + 1;
+	}
+}
+/** The first call of `name`, or null. */
+function findCall(code, name, blank = blankLiterals(code)) {
+	return findCalls(code, name, blank)[0] ?? null;
+}
+/** The index of the bracket closing the one at `open`, or -1. */
+function matchingBracket(blank, open) {
+	const stack = [];
+	for (let i = open; i < blank.length; i++) {
+		const char = blank[i];
+		if (char === "(" || char === "[" || char === "{") {
+			stack.push(char);
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") {
+			stack.pop();
+			if (stack.length === 0) return i;
+		}
+	}
+	return -1;
+}
+/**
+* The identifier a call's first argument is, or null when the argument
+* is anything more complicated than a name.
+*
+* `renderRoot(SegueApp)` is the shape every entry in this repository
+* writes and the only one that can be hot-replaced, because a
+* replacement has to be looked up by name in the module that changed.
+* `renderRoot(<App x={1} />)` is legal and gets no HMR wiring, which
+* the plugin says rather than guessing.
+*/
+function firstArgumentName(code, call, blank = blankLiterals(code)) {
+	const first = (splitTopLevel(blank.slice(call.argsStart, call.argsEnd))[0] ?? "").trim();
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(first) ? first : null;
+}
+/** Splits an argument list on its top-level commas. */
+function splitTopLevel(text) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		if (char === "(" || char === "[" || char === "{") depth++;
+		else if (char === ")" || char === "]" || char === "}") depth--;
+		else if (char === "," && depth === 0) {
+			parts.push(text.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(text.slice(start));
+	return parts;
+}
+/**
+* Which module each imported name came from: local name to specifier,
+* exactly as the import wrote it.
+*
+* Default and namespace imports are recorded under their local names
+* too, so `import App from './App'` and `import * as app from './App'`
+* both answer. What the map does not carry is whether the binding is a
+* type, because `import type` is stripped before this runs in every
+* configuration that matters and a type never reaches a call.
+*/
+function importSources(code, blank = blankLiterals(code)) {
+	const sources = /* @__PURE__ */ new Map();
+	const statement = /\bimport\b([\s\S]*?)\bfrom\b\s*(['"])/g;
+	for (;;) {
+		const match = statement.exec(blank);
+		if (match === null) return sources;
+		const quote = match[2];
+		const open = match.index + match[0].length;
+		const close = code.indexOf(quote, open);
+		if (close === -1) continue;
+		const specifier = code.slice(open, close);
+		for (const local of importedNames(match[1])) sources.set(local, specifier);
+		statement.lastIndex = close + 1;
+	}
+}
+/** The local names an import clause binds. */
+function importedNames(clause) {
+	const names = [];
+	const braces = clause.indexOf("{");
+	const head = (braces === -1 ? clause : clause.slice(0, braces)).replace(/\btype\b/g, "");
+	for (const part of head.split(",")) {
+		const named = /^\s*(?:\*\s*as\s*)?([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+		if (named !== null) names.push(named[1]);
+	}
+	if (braces !== -1) {
+		const close = clause.lastIndexOf("}");
+		const list = clause.slice(braces + 1, close === -1 ? clause.length : close);
+		for (const part of list.split(",")) {
+			const aliased = /^\s*(?:type\s+)?[A-Za-z_$][A-Za-z0-9_$]*\s+as\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+			const plain = /^\s*(?:type\s+)?([A-Za-z_$][A-Za-z0-9_$]*)\s*$/.exec(part);
+			const name = aliased?.[1] ?? plain?.[1];
+			if (name !== void 0) names.push(name);
+		}
+	}
+	return names;
+}
+//#endregion
+//#region src/contracts.ts
+/** The functions that declare a channel. */
+const DECLARATIONS = ["channel", "defineChannel"];
+/**
+* Whether a module declares a channel, without asking the checker.
+*
+* The checker is a process round trip per question, and every module
+* the application has passes through `transform`, so this is the gate:
+* a call to `channel` or `defineChannel` imported from
+* `gesso-framework`. A module that re-exports a token someone else
+* declared is not a contract, and the module that declared it is the
+* one described.
+*/
+function declaresChannel(code) {
+	if (!code.includes("gesso-framework")) return false;
+	const blank = blankLiterals(code);
+	const imports = importSources(code, blank);
+	return DECLARATIONS.some((name) => imports.get(name) === "gesso-framework" && (findCalls(code, name, blank).length > 0 || new RegExp(`(?<![\\w$.])${name}\\s*<`).test(blank)));
+}
+/**
+* The code appended to a contract module.
+*
+* An import at the bottom is still hoisted, and appending rather than
+* rewriting leaves every line the author wrote where they wrote it, so
+* the module's source map needs nothing.
+*/
+function describeCalls(channels) {
+	const lines = ["import { describeChannel as __gessoDescribeChannel } from 'gesso-framework';"];
+	for (const [name, schema] of channels) lines.push(`__gessoDescribeChannel(${name}, ${JSON.stringify(schema)});`);
+	return `\n${lines.join("\n")}\n`;
+}
+/**
+* A module that describes channels when it is imported, for a bundle
+* this plugin never sees.
+*
+* The plugin describes a contract by appending to it as Vite bundles
+* it. An Electrobun main process is bundled by Electrobun's own build,
+* which takes no plugins, so there the description is written ahead of
+* time instead: `gesso-channels` reads the contracts with the same
+* checker and writes this module, and the main process imports it once.
+* A token is imported from its contract, so the schema lands on the
+* same object the application serves.
+*
+* `outFile` and every `file` are absolute POSIX paths.
+*/
+function describedModule(contracts, outFile) {
+	const lines = [
+		"// Written by gesso-channels from the channel contracts it names below.",
+		"// Run it again after changing a contract rather than editing this file.",
+		"import { describeChannel } from 'gesso-framework';"
+	];
+	const from = outFile.slice(0, outFile.lastIndexOf("/"));
+	for (const contract of contracts) if (contract.channels.size > 0) {
+		const names = [...contract.channels.keys()].join(", ");
+		lines.push(`import { ${names} } from '${importPath(from, contract.file)}';`);
+	}
+	for (const contract of contracts) for (const [name, schema] of contract.channels) lines.push("", `describeChannel(${name}, ${JSON.stringify(schema, null, 2)});`);
+	return `${lines.join("\n")}\n`;
+}
+/** `./Counter` from `/app/src/shared` to `/app/src/shared/Counter.ts`, without the extension. */
+function importPath(fromDir, file) {
+	const from = fromDir.split("/").filter(Boolean);
+	const to = file.replace(/\.[cm]?[jt]sx?$/, "").split("/").filter(Boolean);
+	let shared = 0;
+	while (shared < from.length && shared < to.length - 1 && from[shared] === to[shared]) shared++;
+	const up = from.length - shared;
+	const rest = to.slice(shared).join("/");
+	return up === 0 ? `./${rest}` : `${"../".repeat(up)}${rest}`;
+}
+/**
+* The checker, held open across reads.
+*
+* Spawning it and loading a project costs about a hundred
+* milliseconds; a question after that costs well under one. So one
+* reader lives as long as the dev server or the build, is told which
+* files changed between reads, and is closed at the end, because the
+* process it holds would otherwise keep the build from exiting.
+*/
+var ContractReader = class {
+	api = null;
+	changed = /* @__PURE__ */ new Set();
+	created = /* @__PURE__ */ new Set();
+	deleted = /* @__PURE__ */ new Set();
+	/** Each contract's tsconfig, found once. */
+	configs = /* @__PURE__ */ new Map();
+	/**
+	* @param fs Callbacks the checker reads through before the disk, for
+	*   a spec that keeps its project in memory.
+	*/
+	ts;
+	cwd;
+	fs;
+	constructor(ts, cwd, fs) {
+		this.ts = ts;
+		this.cwd = cwd;
+		this.fs = fs;
+	}
+	/**
+	* A file changed on disk since the last read. A new or deleted one is
+	* said so, because a program's list of files only changes for those:
+	* a component in a new file is otherwise not in the catalog.
+	*/
+	invalidate(file, event = "update") {
+		(event === "create" ? this.created : event === "delete" ? this.deleted : this.changed).add(file);
+	}
+	/**
+	* A snapshot of the projects, with what changed since the last one.
+	*
+	* The checker keeps every project it has opened, and asked to update
+	* one whose tsconfig has since been deleted it refuses the whole
+	* update ("project not found for update"). That was a dev server gone
+	* with it: a project's tsconfig removed while the server ran threw out
+	* of the catalog's read and took the process down. A refused update is
+	* a checker started afresh, which reads the disk as it now is and
+	* opens only what is asked of it again.
+	*/
+	snapshot(request) {
+		const api = this.api ??= new this.ts.API({
+			cwd: this.cwd,
+			...this.fs === void 0 ? {} : { fs: this.fs }
+		});
+		try {
+			return api.updateSnapshot({
+				...request,
+				fileChanges: this.takeChanges()
+			});
+		} catch {
+			this.close();
+			this.configs.clear();
+			const fresh = this.api = new this.ts.API({
+				cwd: this.cwd,
+				...this.fs === void 0 ? {} : { fs: this.fs }
+			});
+			const { fileChanges: _changes, ...rest } = request;
+			return fresh.updateSnapshot(rest);
+		}
+	}
+	/** What changed since the last snapshot, emptied for the next. */
+	takeChanges() {
+		const changes = {
+			changed: [...this.changed],
+			created: [...this.created],
+			deleted: [...this.deleted]
+		};
+		this.changed.clear();
+		this.created.clear();
+		this.deleted.clear();
+		return changes;
+	}
+	/** Every channel `file` exports, described. */
+	read(file) {
+		const opened = this.open(file);
+		if (typeof opened === "string") return {
+			channels: /* @__PURE__ */ new Map(),
+			warnings: [opened]
+		};
+		const { checker, exports } = opened;
+		const describer = new Describer(this.ts, checker);
+		const channels = /* @__PURE__ */ new Map();
+		for (const exported of exports) {
+			const type = checker.getTypeOfSymbol(exported);
+			if (type === void 0 || type.getSymbol()?.name !== "ChannelToken") continue;
+			const [view, commands] = checker.getTypeArguments(type);
+			channels.set(exported.name, describer.channel(exported, view, commands));
+		}
+		return {
+			channels,
+			warnings: describer.warnings
+		};
+	}
+	/**
+	* Every component `file` exports, described: a function whose first
+	* parameter is `Inputs<P>`, or a class extending `Component`, whose
+	* inputs are its `InputCell` fields. A library's index re-exports its
+	* components, and reading it reads all of them.
+	*/
+	readComponents(file, config) {
+		const opened = this.open(file, config);
+		if (typeof opened === "string") return {
+			components: /* @__PURE__ */ new Map(),
+			warnings: [opened]
+		};
+		const { checker, exports } = opened;
+		const describer = new Describer(this.ts, checker, "component");
+		const components = /* @__PURE__ */ new Map();
+		for (const exported of exports) {
+			const symbol = exported.flags & this.ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+			const type = checker.getTypeOfSymbol(symbol);
+			const inputs = type === void 0 ? void 0 : this.inputsOf(checker, type);
+			if (inputs !== void 0) components.set(exported.name, describer.component(symbol, inputs));
+		}
+		return {
+			components,
+			warnings: describer.warnings
+		};
+	}
+	/**
+	* The source files of the project `config` describes, with their
+	* text: what the project itself wrote, so neither its dependencies
+	* nor declaration files. The project's own tsconfig decides what that
+	* is, which is the answer the person already gave their editor.
+	*/
+	sources(config) {
+		const program = this.snapshot({ openProjects: [config] }).getProject(config)?.program;
+		if (program === void 0) return [];
+		const out = [];
+		for (const file of program.getSourceFileNames()) {
+			if (file.includes("/node_modules/") || /\.d\.[cm]?ts$/.test(file)) continue;
+			const text = program.getSourceFile(file)?.text;
+			if (text !== void 0) out.push({
+				file,
+				text
+			});
+		}
+		return out;
+	}
+	/** The inputs a component's type declares, or undefined when it is not a component. */
+	inputsOf(checker, type) {
+		const { Call, Construct } = this.ts.SignatureKind;
+		const [call] = checker.getSignaturesOfType(type, Call);
+		const first = call?.getParameters()[0];
+		if (first !== void 0) {
+			const parameter = checker.getTypeOfSymbol(first);
+			const returns = checker.getReturnTypeOfSignature(call);
+			if (parameter?.getAliasSymbol()?.name === "Inputs" && returns !== void 0 && this.drawable(returns)) {
+				const [props] = parameter.getAliasTypeArguments();
+				return props === void 0 ? void 0 : {
+					kind: "props",
+					type: props
+				};
+			}
+			return;
+		}
+		const [construct] = checker.getSignaturesOfType(type, Construct);
+		const instance = construct === void 0 ? void 0 : checker.getReturnTypeOfSignature(construct);
+		if (instance === void 0 || !this.extendsComponent(instance)) return;
+		const cells = [];
+		for (const property of checker.getPropertiesOfType(instance)) {
+			const propertyType = checker.getTypeOfSymbol(property);
+			if (propertyType?.getSymbol()?.name === "InputCell") {
+				const [value] = checker.getTypeArguments(propertyType);
+				if (value !== void 0) cells.push({
+					symbol: property,
+					type: value
+				});
+			}
+		}
+		return {
+			kind: "cells",
+			cells
+		};
+	}
+	/** Whether a function returning `type` returns a child: `UiChild`, an element, or a union of them. */
+	drawable(type) {
+		if (type.getAliasSymbol()?.name === "UiChild") return true;
+		return (type.isUnionType() ? type.getTypes() ?? [] : [type]).some((member) => CHILD.has(member.getSymbol()?.name ?? ""));
+	}
+	extendsComponent(type) {
+		for (let depth = 0, current = type; current !== void 0 && depth < 16; depth++) {
+			if (current.getSymbol()?.name === "Component") return true;
+			current = current.isClassOrInterface() ? current.getBaseTypes()?.[0] : void 0;
+		}
+		return false;
+	}
+	/**
+	* The checker and the module's exports, or why there are none: read
+	* in the project `preferred` names when it includes the file (the
+	* catalog's own tsconfig, which may resolve its imports differently
+	* from any beside it), else the project TypeScript finds for it.
+	*/
+	open(file, preferred) {
+		this.changed.add(file);
+		let snapshot = this.snapshot(preferred === void 0 ? {} : { openProjects: [preferred] });
+		let config = preferred !== void 0 && snapshot.getProject(preferred)?.program.getSourceFile(file) !== void 0 ? preferred : this.configs.get(file);
+		if (config === void 0) {
+			config = this.snapshot({ openFiles: [file] }).getDefaultProjectForFile(file)?.configFileName;
+			snapshot = this.snapshot({
+				...config === void 0 ? {} : { openProjects: [config] },
+				closeFiles: [file]
+			});
+			if (config !== void 0) this.configs.set(file, config);
+		}
+		const project = config === void 0 ? void 0 : snapshot.getProject(config);
+		const source = project?.program.getSourceFile(file);
+		if (project === void 0 || source === void 0) return `TypeScript has no project that includes ${file}.`;
+		const checker = project.checker;
+		const module = checker.getSymbolAtLocation(source);
+		return {
+			checker,
+			exports: module === void 0 ? [] : checker.getExportsOfModule(module)
+		};
+	}
+	close() {
+		this.api?.close();
+		this.api = null;
+	}
+};
+/**
+* Library types that are objects to the checker and not plain data to
+* a channel. They compare by reference, so `provide` rejects them on
+* their first value; describing their methods as properties would be
+* describing something that never arrives.
+*/
+const NOT_PLAIN = /* @__PURE__ */ new Set([
+	"Date",
+	"Map",
+	"ReadonlyMap",
+	"Set",
+	"ReadonlySet",
+	"WeakMap",
+	"WeakSet",
+	"Promise",
+	"RegExp",
+	"Error",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Blob",
+	"File",
+	"URL",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+]);
+/**
+* Bytes, which a command may carry and a view key may not.
+*
+* A command's argument is structured-cloned onto the owning thread, and
+* a typed array or an `ArrayBuffer` clones as itself: a file a person
+* dropped crosses as its bytes, with no encoding pass on the render
+* thread. A view key is diffed, and a differ that compares bytes by
+* reference reports a change on every emission, so there they stay
+* unplain. In a command's schema they are a base64 string, which is
+* what an agent can write, tagged with the type the command expects so
+* the agent surface can turn the string back into it.
+*/
+const BINARY = /* @__PURE__ */ new Set([
+	"ArrayBuffer",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+]);
+/**
+* The types a component takes as a child. `UiChild` is a union of
+* these and an Observable of them, and describing its members would
+* describe the element records a tag compiles to, which nobody writes.
+*/
+const CHILD = /* @__PURE__ */ new Set([
+	"UiElement",
+	"ComponentLikeElement",
+	"ComponentElement"
+]);
+/**
+* Turns checker types into JSON Schema for one module's channels or
+* components.
+*
+* The two differ in what is allowed. A channel's values cross a thread
+* as plain data, so a function or a class instance in one is a mistake,
+* and is reported. A component's inputs stay on the render thread, where
+* a callback is how a component talks back and a child is how it is
+* composed, so there they are described for what they are and nothing
+* is reported.
+*/
+var Describer = class {
+	warnings = [];
+	flags;
+	/** Describing a command's parameters, where bytes are allowed; see `BINARY`. */
+	inCommand = false;
+	/** Types being described right now, to notice a type that contains itself. */
+	inProgress = /* @__PURE__ */ new Set();
+	/** Types found to contain themselves, which are described once in `$defs`. */
+	recursive = /* @__PURE__ */ new Set();
+	/** `$defs` for the schema being built. Reset per root, so each schema stands alone. */
+	defs = /* @__PURE__ */ new Map();
+	defNames = /* @__PURE__ */ new Map();
+	/** In a component, each named type's `$defs` entry, or null when it is small enough to repeat. */
+	shared = /* @__PURE__ */ new Map();
+	ts;
+	checker;
+	mode;
+	constructor(ts, checker, mode = "channel") {
+		this.ts = ts;
+		this.checker = checker;
+		this.flags = ts.TypeFlags;
+		this.mode = mode;
+	}
+	component(symbol, inputs) {
+		this.defs = /* @__PURE__ */ new Map();
+		this.shared = /* @__PURE__ */ new Map();
+		const checker = this.checker;
+		const properties = {};
+		const required = [];
+		const entries = inputs.kind === "cells" ? inputs.cells : checker.getPropertiesOfType(inputs.type).map((property) => ({
+			symbol: property,
+			type: checker.getTypeOfSymbol(property)
+		}));
+		const own = inputs.kind === "props" ? (inputs.type.getAliasSymbol() ?? inputs.type.getSymbol())?.name : void 0;
+		for (const { symbol: property, type: given } of entries) {
+			const path = `${symbol.name}.${property.name}`;
+			const type = given !== void 0 && this.includesUndefined(given) && !this.includesNull(given) ? checker.getNonNullableType(given) ?? given : given;
+			let schema = type === void 0 ? {} : this.describe(type, path);
+			if (type !== void 0) schema = {
+				...schema,
+				"x-gesso-type": this.typeText(type)
+			};
+			const description = checker.getDocumentationCommentOfSymbol(property);
+			if (description !== "") schema.description = description;
+			const fallback = checker.getJsDocTagsOfSymbol(property).find((tag) => tag.name === "default");
+			if (fallback?.text !== void 0) schema.default = parseDefault(fallback.text);
+			const from = property.getParent()?.name;
+			if (own !== void 0 && from !== void 0 && from !== own && !from.startsWith("__")) schema["x-gesso-from"] = from;
+			properties[property.name] = schema;
+			if (!(inputs.kind === "cells" || (property.flags & this.ts.SymbolFlags.Optional) !== 0 || given !== void 0 && this.includesUndefined(given))) required.push(property.name);
+		}
+		const schema = {
+			type: "object",
+			properties,
+			additionalProperties: false
+		};
+		if (required.length > 0) schema.required = required;
+		if (this.defs.size > 0) schema.$defs = Object.fromEntries(this.defs);
+		const out = { inputs: schema };
+		const description = this.componentDocumentation(symbol, inputs);
+		if (description !== "") {
+			out.summary = description.split(/\n\s*\n/)[0].replace(/\s+/g, " ").trim();
+			out.description = description;
+		}
+		const tags = checker.getJsDocTagsOfSymbol(symbol);
+		const examples = tags.filter((tag) => tag.name === "example" && tag.text !== void 0).map((tag) => tag.text);
+		if (examples.length > 0) out.examples = examples;
+		const deprecated = tags.find((tag) => tag.name === "deprecated");
+		if (deprecated !== void 0) out.deprecated = deprecated.text === void 0 || deprecated.text.trim() === "" ? true : deprecated.text.trim();
+		return out;
+	}
+	/**
+	* What a component is for: its own JSDoc, else its props type's. A
+	* comment elsewhere in its file is not read: no rule about which one
+	* describes the component holds across files, and a summary that is
+	* sometimes about something else is worse to an agent than none.
+	*/
+	componentDocumentation(symbol, inputs) {
+		const own = this.checker.getDocumentationCommentOfSymbol(symbol);
+		if (own !== "") return own;
+		const props = inputs.kind === "props" ? inputs.type.getAliasSymbol() ?? inputs.type.getSymbol() : void 0;
+		return props === void 0 ? "" : this.checker.getDocumentationCommentOfSymbol(props);
+	}
+	/** The type as TypeScript writes it, without the `undefined` an optional input carries. */
+	typeText(type) {
+		const defined = this.includesUndefined(type) ? this.checker.getNonNullableType(type) : type;
+		const text = this.checker.typeToString(defined ?? type);
+		return this.includesNull(type) && !/\bnull\b/.test(text) ? `${text} | null` : text;
+	}
+	includesNull(type) {
+		const isNull = (member) => (member.flags & this.flags.Null) !== 0;
+		return type.isUnionType() ? (type.getTypes() ?? []).some(isNull) : isNull(type);
+	}
+	channel(token, view, commands) {
+		const out = {
+			view: this.root(view, `${token.name}.view`),
+			commands: {}
+		};
+		const description = this.checker.getDocumentationCommentOfSymbol(token);
+		if (description !== "") out.description = description;
+		if (this.checker.getJsDocTagsOfSymbol(token).some((tag) => tag.name === "hidden")) out.internal = true;
+		const hidden = this.checker.getPropertiesOfType(view).filter((key) => this.checker.getJsDocTagsOfSymbol(key).some((tag) => tag.name === "hidden")).map((key) => key.name);
+		if (hidden.length > 0) out.hidden = hidden;
+		if (commands !== void 0) for (const command of this.checker.getPropertiesOfType(commands)) {
+			const described = this.command(command, `${token.name}.commands.${command.name}`);
+			if (described !== null) out.commands[command.name] = described;
+		}
+		return out;
+	}
+	/** A schema that stands alone: its own `$defs`, if anything in it recurs. */
+	root(type, path) {
+		this.defs = /* @__PURE__ */ new Map();
+		const schema = this.describe(type, path);
+		if (this.defs.size > 0) return {
+			...schema,
+			$defs: Object.fromEntries(this.defs)
+		};
+		return schema;
+	}
+	command(symbol, path) {
+		const type = this.checker.getTypeOfSymbol(symbol);
+		const signatures = type === void 0 ? [] : this.checker.getSignaturesOfType(type, this.ts.SignatureKind.Call);
+		if (signatures.length === 0) {
+			this.warnings.push(`${path} is not a function, so it is not a command an agent can send.`);
+			return null;
+		}
+		if (signatures.length > 1) this.warnings.push(`${path} is overloaded; only its first signature is described.`);
+		const signature = signatures[0];
+		const tags = this.checker.getJsDocTagsOfSymbol(symbol);
+		const parameters = signature.getParameters();
+		this.defs = /* @__PURE__ */ new Map();
+		const properties = {};
+		const required = [];
+		this.inCommand = true;
+		parameters.forEach((parameter, index) => {
+			const parameterType = this.checker.getTypeOfSymbol(parameter);
+			const optional = parameterType !== void 0 && this.includesUndefined(parameterType);
+			const schema = parameterType === void 0 ? {} : this.describe(parameterType, `${path}(${parameter.name})`);
+			const description = this.parameterDescription(parameter, tags);
+			properties[parameter.name] = description === "" ? schema : {
+				...schema,
+				description
+			};
+			const rest = signature.hasRestParameter && index === parameters.length - 1;
+			if (!optional && !rest) required.push(parameter.name);
+		});
+		this.inCommand = false;
+		const input = {
+			type: "object",
+			properties,
+			additionalProperties: false
+		};
+		if (required.length > 0) input.required = required;
+		if (this.defs.size > 0) input.$defs = Object.fromEntries(this.defs);
+		const out = {
+			parameters: parameters.map((parameter) => parameter.name),
+			input
+		};
+		const description = this.checker.getDocumentationCommentOfSymbol(symbol);
+		if (description !== "") out.description = description;
+		if (signature.hasRestParameter) out.rest = true;
+		for (const annotation of [
+			"destructive",
+			"idempotent",
+			"confirm",
+			"hidden"
+		]) if (tags.some((tag) => tag.name === annotation)) out[annotation] = true;
+		return out;
+	}
+	/**
+	* A parameter's own comment, or failing that its `@param` line.
+	*
+	* The checker attaches `@param` text to the parameter of a method
+	* signature. A command written as a property, `move: (from: number)
+	* => void`, keeps its comment on the property, so the tag is read
+	* from there instead.
+	*/
+	parameterDescription(parameter, tags) {
+		const own = this.checker.getDocumentationCommentOfSymbol(parameter);
+		if (own !== "") return own;
+		for (const tag of tags) {
+			const match = tag.name === "param" ? /^\s*(\S+)\s*(?:-\s*)?([\s\S]*)$/.exec(tag.text ?? "") : null;
+			if (match !== null && match[1] === parameter.name) return match[2].trim();
+		}
+		return "";
+	}
+	includesUndefined(type) {
+		const { Undefined, Void } = this.flags;
+		if (type.isUnionType()) return (type.getTypes() ?? []).some((member) => (member.flags & (Undefined | Void)) !== 0);
+		return (type.flags & (Undefined | Void)) !== 0;
+	}
+	/**
+	* In a component, a named type an input uses (`UiLength`, a props
+	* interface) is described once, in `$defs`, and referred to after.
+	* Every control takes the same layout inputs, and spelled out at each
+	* use they were most of each component's description: an agent reads
+	* these, and pays for every repetition.
+	*/
+	describe(type, path) {
+		if (this.mode !== "component") return this.describeType(type, path);
+		const known = this.shared.get(type.id);
+		if (known !== void 0) return known === null ? this.describeType(type, path) : { $ref: `#/$defs/${known}` };
+		const name = (type.getAliasSymbol() ?? type.getSymbol())?.name;
+		if (name === void 0 || name.startsWith("__") || name === "Array" || name === "ReadonlyArray") return this.describeType(type, path);
+		const schema = this.describeType(type, path);
+		if (schema.$ref !== void 0 || isSmall(schema)) {
+			this.shared.set(type.id, null);
+			return schema;
+		}
+		const defName = this.defName(type);
+		this.defs.set(defName, schema);
+		this.shared.set(type.id, defName);
+		return { $ref: `#/$defs/${defName}` };
+	}
+	describeType(type, path) {
+		const f = this.flags;
+		const flags = type.flags;
+		if (flags & (f.Any | f.Unknown)) return {};
+		if (flags & f.Never) {
+			this.warnings.push(`${path} is never, which describes no value. An empty array literal is never[] unless it says what it holds: write \`[] as Row[]\`.`);
+			return { not: {} };
+		}
+		if (flags & (f.String | f.TemplateLiteral | f.StringMapping)) return { type: "string" };
+		if (flags & f.Number) return { type: "number" };
+		if (flags & f.Boolean) return { type: "boolean" };
+		if (flags & f.Null) return { type: "null" };
+		if (flags & (f.Undefined | f.Void)) return {};
+		if (flags & f.BooleanLiteral) return { const: type.intrinsicName === "true" };
+		if (flags & (f.StringLiteral | f.NumberLiteral)) return { const: type.value };
+		if (flags & (f.BigInt | f.BigIntLiteral | f.ESSymbol | f.UniqueESSymbol)) return this.unplain(path, flags & f.BigIntLike ? "a bigint" : "a symbol");
+		if (type.isUnionType()) return this.union(type, path);
+		if (flags & f.TypeParameter) return {};
+		if (flags & (f.Object | f.Intersection)) {
+			if (this.checker.isArrayType(type)) {
+				const [element] = this.checker.getTypeArguments(type);
+				return {
+					type: "array",
+					items: element === void 0 ? {} : this.describe(element, `${path}[]`)
+				};
+			}
+			if (this.checker.isTupleType(type)) return this.tuple(type, path);
+			return this.named(type, path);
+		}
+		this.warnings.push(`${path} has a type this reader does not describe, so it is left open.`);
+		return {};
+	}
+	/**
+	* A union, with `undefined` taken out (optionality is said by
+	* `required`), `true | false` folded back into `boolean`, and a union
+	* of nothing but literals written as an `enum`.
+	*/
+	union(type, path) {
+		const f = this.flags;
+		let members = (type.getTypes() ?? []).filter((member) => (member.flags & (f.Undefined | f.Void)) === 0);
+		if (this.mode === "component" && members.some((member) => CHILD.has(member.getSymbol()?.name ?? ""))) return { "x-gesso-child": true };
+		const booleans = members.filter((member) => member.flags & f.BooleanLiteral);
+		const schemas = [];
+		if (booleans.length === 2) {
+			members = members.filter((member) => !(member.flags & f.BooleanLiteral));
+			schemas.push({ type: "boolean" });
+		}
+		if (members.length > 0 && schemas.length === 0 && members.every((member) => member.flags & (f.StringLiteral | f.NumberLiteral))) return { enum: members.map((member) => member.value) };
+		members.sort((a, b) => Number((a.flags & f.Null) !== 0) - Number((b.flags & f.Null) !== 0));
+		schemas.push(...members.map((member) => this.describe(member, path)));
+		return schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+	}
+	/**
+	* An object type, described once however often it appears, and by
+	* reference when it contains itself.
+	*/
+	named(type, path) {
+		const id = type.id;
+		if (this.inProgress.has(id)) {
+			this.recursive.add(id);
+			return { $ref: `#/$defs/${this.defName(type)}` };
+		}
+		this.inProgress.add(id);
+		const schema = this.object(type, path);
+		this.inProgress.delete(id);
+		if (this.recursive.has(id)) {
+			const name = this.defName(type);
+			this.defs.set(name, schema);
+			return { $ref: `#/$defs/${name}` };
+		}
+		return schema;
+	}
+	defName(type) {
+		let name = this.defNames.get(type.id);
+		if (name === void 0) {
+			const base = (type.getAliasSymbol() ?? type.getSymbol())?.name ?? "Type";
+			name = new Set(this.defNames.values()).has(base) ? `${base}${type.id}` : base;
+			this.defNames.set(type.id, name);
+		}
+		return name;
+	}
+	object(type, path) {
+		const checker = this.checker;
+		const symbolName = type.getSymbol()?.name;
+		if (this.mode === "component") {
+			if (symbolName !== void 0 && CHILD.has(symbolName)) return { "x-gesso-child": true };
+			if (checker.getSignaturesOfType(type, this.ts.SignatureKind.Call).length > 0) return { "x-gesso-callback": true };
+			if (symbolName !== void 0 && NOT_PLAIN.has(symbolName) || ((type.getSymbol()?.flags ?? 0) & this.ts.SymbolFlags.Class) !== 0) return { "x-gesso-type": checker.typeToString(type) };
+		}
+		if (symbolName !== void 0 && this.inCommand && BINARY.has(symbolName)) return {
+			type: "string",
+			contentEncoding: "base64",
+			"x-gesso-binary": symbolName
+		};
+		if (symbolName === "SharedArrayBuffer" && !this.inCommand) return {
+			type: "string",
+			description: "Shared memory, shown as its size.",
+			"x-gesso-shared": true
+		};
+		if (symbolName !== void 0 && NOT_PLAIN.has(symbolName)) return this.unplain(path, `a ${symbolName}`);
+		if (type.objectFlags & this.ts.ObjectFlags.Class) return this.unplain(path, `an instance of ${symbolName ?? "a class"}`);
+		if (checker.getSignaturesOfType(type, this.ts.SignatureKind.Call).length > 0) return this.unplain(path, "a function");
+		const properties = {};
+		const required = [];
+		for (const property of checker.getPropertiesOfType(type)) {
+			const propertyType = checker.getTypeOfSymbol(property);
+			const at = `${path}.${property.name}`;
+			if (propertyType === void 0) {
+				properties[property.name] = {};
+				continue;
+			}
+			const schema = this.describe(propertyType, at);
+			const description = checker.getDocumentationCommentOfSymbol(property);
+			properties[property.name] = description === "" ? schema : {
+				...schema,
+				description
+			};
+			if (!((property.flags & this.ts.SymbolFlags.Optional) !== 0 || this.includesUndefined(propertyType))) required.push(property.name);
+		}
+		const schema = {
+			type: "object",
+			properties
+		};
+		if (required.length > 0) schema.required = required;
+		const index = checker.getIndexInfosOfType(type).find((info) => info.keyType.flags & this.flags.String);
+		if (index !== void 0) schema.additionalProperties = this.describe(index.valueType, `${path}[key]`);
+		return schema;
+	}
+	tuple(type, path) {
+		const elements = this.checker.getTypeArguments(type);
+		const elementFlags = type.getTarget().elementFlags ?? [];
+		const { Required, Rest } = this.ts.ElementFlags;
+		const prefixItems = [];
+		let items = false;
+		let minItems = 0;
+		elements.forEach((element, index) => {
+			const schema = this.describe(element, `${path}[${index}]`);
+			if (elementFlags[index] & Rest) items = schema;
+			else {
+				prefixItems.push(schema);
+				if (elementFlags[index] & Required) minItems = index + 1;
+			}
+		});
+		return {
+			type: "array",
+			prefixItems,
+			items,
+			minItems
+		};
+	}
+	unplain(path, what) {
+		if (this.mode === "component") return {};
+		this.warnings.push(`${path} is ${what}, which is not plain data and cannot cross a channel.`);
+		return {};
+	}
+};
+/**
+* A `@default` tag's value: JSON when it is JSON (`99`, `'neutral'`
+* written with double quotes, `true`), a single-quoted string unquoted,
+* and otherwise the text as written.
+*/
+function parseDefault(text) {
+	const trimmed = text.trim();
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		const quoted = /^'(.*)'$/.exec(trimmed) ?? /^`(.*)`$/.exec(trimmed);
+		return quoted === null ? trimmed : quoted[1];
+	}
+}
+/** Whether a schema is as short as a reference to it would be. */
+function isSmall(schema) {
+	if (schema.enum !== void 0 || schema.const !== void 0) return true;
+	const keys = Object.keys(schema);
+	return keys.length === 0 || keys.length === 1 && (typeof schema.type === "string" || keys[0].startsWith("x-gesso-"));
+}
+//#endregion
+export { blankLiterals as a, firstArgumentName as c, CATALOG_TOOLS as d, ComponentCatalog as f, describedModule as i, importSources as l, declaresChannel as n, findCall as o, mayDeclareComponent as p, describeCalls as r, findCalls as s, ContractReader as t, CATALOG_INSTRUCTIONS as u };
+
+//# sourceMappingURL=contracts-Dwn5pg-0.js.map