llmz 0.9.0 → 1.0.2

package/dist/compiler-CW1VjQsn.js

@@ -1,473 +0,0 @@
-import { parse } from "acorn";
-import MagicString from "magic-string";
-//#region src/compiler/ast.ts
-const TS_SMELL = /(^|[^:]):\s*(string|number|boolean|any|unknown|void)\b|\bas\s+(const\b|[A-Z])|\binterface\s+[A-Z]|^\s*type\s+[A-Z]|[a-zA-Z)\]]!\.|<(string|number|boolean)[,>]/m;
-function parseScript(code, opts) {
-	try {
-		return parse(code, {
-			ecmaVersion: "latest",
-			sourceType: "script",
-			locations: true,
-			allowReturnOutsideFunction: true,
-			allowAwaitOutsideFunction: true,
-			...opts,
-			onComment: opts === null || opts === void 0 ? void 0 : opts.comments
-		});
-	} catch (err) {
-		if (err instanceof SyntaxError && TS_SMELL.test(code)) err.message += ". The code must be plain JavaScript: do not use TypeScript syntax (type annotations, \"as\" casts, generics, interfaces or type aliases).";
-		throw err;
-	}
-}
-/**
-* Depth-first pre-order walk. `ancestors` is ordered outermost → innermost and
-* excludes `node` itself; `parent` is `ancestors[ancestors.length - 1]`.
-*/
-function walk(root, enter) {
-	const ancestors = [];
-	const visit = (node) => {
-		enter(node, ancestors[ancestors.length - 1] ?? null, ancestors);
-		ancestors.push(node);
-		for (const key of Object.keys(node)) {
-			if (key === "loc") continue;
-			const value = node[key];
-			if (Array.isArray(value)) {
-				for (const child of value) if (isNode(child)) visit(child);
-			} else if (isNode(value)) visit(value);
-		}
-		ancestors.pop();
-	};
-	visit(root);
-}
-const isNode = (value) => !!value && typeof value === "object" && typeof value.type === "string";
-const isStatementContainer = (node) => !!node && (node.type === "Program" || node.type === "BlockStatement" || node.type === "StaticBlock");
-/**
-* The statement that contains `node`: the outermost ancestor (or the node
-* itself) whose parent is a statement container.
-*/
-function enclosingStatement(node, ancestors) {
-	const chain = [...ancestors, node];
-	for (let i = chain.length - 1; i > 0; i--) if (isStatementContainer(chain[i - 1])) return chain[i];
-	return null;
-}
-/** The innermost node whose range contains [start, end] */
-function innermostContaining(ast, start, end) {
-	let best = null;
-	walk(ast, (node) => {
-		if (node.start <= start && node.end >= end) {
-			if (!best || node.start >= best.start && node.end <= best.end) best = node;
-		}
-	});
-	return best;
-}
-//#endregion
-//#region src/compiler/plugins/async-wrapper.ts
-const Open = "async function __fn__() {";
-const Close = "}";
-const USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
-const USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
-/**
-* Wraps user code in an async function so top-level `await` and `return` parse,
-* and so plugins can target the `__fn__` declaration. The wrapper is removed
-* after transformation — drivers re-wrap the bare statements themselves.
-*/
-const AsyncWrapper = {
-	preProcessing: (code) => {
-		return `"use strict";
-${Open}
-${USER_CODE_START_MARKER}
-${code}
-${USER_CODE_END_MARKER}
-${Close}
-`.trim();
-	},
-	postProcessing: (code) => {
-		code = code.slice(code.indexOf(Open) + 25);
-		code = code.slice(0, code.lastIndexOf(Close));
-		code = code.replace(USER_CODE_START_MARKER, "").replace(USER_CODE_END_MARKER, "");
-		return code.trimEnd();
-	}
-};
-//#endregion
-//#region src/compiler/plugins/line-tracking.ts
-const LineTrackingFnIdentifier = "__track__";
-const TRACKED_TYPES = /* @__PURE__ */ new Set([
-	"FunctionDeclaration",
-	"MethodDefinition",
-	"ReturnStatement",
-	"AwaitExpression",
-	"ForOfStatement",
-	"CallExpression",
-	"UnaryExpression",
-	"VariableDeclaration",
-	"AssignmentExpression"
-]);
-const SKIPPED_PARENT_TYPES = /* @__PURE__ */ new Set([
-	"ArrowFunctionExpression",
-	"Property",
-	"AwaitExpression",
-	"UnaryExpression",
-	"ReturnStatement",
-	"ForOfStatement",
-	"ForStatement",
-	"ForInStatement",
-	"VariableDeclaration",
-	"BinaryExpression",
-	"LogicalExpression"
-]);
-/**
-* Inserts a `__track__(<line>)` call before the statement containing each
-* tracked node — at most one per source line.
-*/
-function applyLineTracking(ctx) {
-	const trackedLines = /* @__PURE__ */ new Set();
-	walk(ctx.ast, (node, parent, ancestors) => {
-		if (!parent || !node.loc) return;
-		if (!TRACKED_TYPES.has(node.type) && parent.type !== "BlockStatement") return;
-		const line = node.loc.start.line;
-		if (trackedLines.has(line) || SKIPPED_PARENT_TYPES.has(parent.type)) return;
-		const statement = enclosingStatement(node, ancestors);
-		if (!statement) return;
-		trackedLines.add(line);
-		ctx.ms.appendLeft(statement.start, `${LineTrackingFnIdentifier}(${line});`);
-	});
-}
-//#endregion
-//#region src/compiler/plugins/replace-comment.ts
-const CommentFnIdentifier = "__comment__";
-const MARKER_TAGS = [USER_CODE_START_MARKER, USER_CODE_END_MARKER].map((m) => m.replace(/\/\*|\*\/|\s/g, ""));
-/** Blanks a range, keeping newlines so line numbers are preserved */
-const blank = (ctx, start, end) => {
-	ctx.ms.update(start, end, ctx.code.slice(start, end).replace(/[^\n]/g, " "));
-};
-/**
-* Replaces comments at statement position with `__comment__("<text>", <line>)`
-* calls so the agent's inline "thinking" comments show up as traces at runtime.
-* Comments inside expressions and the user-code markers are blanked; comments
-* inside instrumented tool-call ranges are left verbatim.
-*/
-function applyCommentReplacement(ctx, skipRanges) {
-	for (const comment of ctx.comments) {
-		const text = comment.value.trim();
-		if (MARKER_TAGS.some((tag) => text.includes(tag))) {
-			blank(ctx, comment.start, comment.end);
-			continue;
-		}
-		if (skipRanges.some(([start, end]) => comment.start >= start && comment.end <= end)) continue;
-		const container = innermostContaining(ctx.ast, comment.start, comment.end);
-		if (isStatementContainer(container)) {
-			const newlines = ctx.code.slice(comment.start, comment.end).replace(/[^\n]/g, "");
-			ctx.ms.update(comment.start, comment.end, `;${CommentFnIdentifier}(${JSON.stringify(text)}, ${comment.loc.start.line});${newlines}`);
-		} else blank(ctx, comment.start, comment.end);
-	}
-}
-//#endregion
-//#region src/compiler/plugins/return-async.ts
-/**
-* Plans the instrumentation of the last statement of the `__fn__` wrapper so
-* the generated code always returns an awaited value (the isolated VM cannot
-* return a pending Promise):
-* - `return expr` → `return await (expr)`
-* - a trailing `call()` / `await call()` statement → `return await (…)`
-*
-* The prefix must be applied before, and the suffix after, all other edits so
-* they wrap around the tool-call instrumentation.
-*/
-function planLastLineInstrumentation(ast) {
-	const fn = ast.body.find((node) => {
-		var _id;
-		return node.type === "FunctionDeclaration" && ((_id = node.id) === null || _id === void 0 ? void 0 : _id.name) === "__fn__";
-	});
-	if (!fn) return null;
-	const statements = fn.body.body;
-	const last = statements[statements.length - 1];
-	if (!last) return null;
-	if (last.type === "ReturnStatement") {
-		if (!last.argument) return null;
-		return {
-			prefixPos: last.argument.start,
-			prefix: "await (",
-			suffixPos: last.argument.end,
-			suffix: ")"
-		};
-	}
-	if (last.type === "ExpressionStatement" && (last.expression.type === "CallExpression" || last.expression.type === "AwaitExpression")) return {
-		prefixPos: last.expression.start,
-		prefix: "return await (",
-		suffixPos: last.expression.end,
-		suffix: ")"
-	};
-	return null;
-}
-//#endregion
-//#region src/compiler/plugins/track-tool-calls.ts
-const ToolCallTrackerFnIdentifier = "__toolc__";
-const ToolTrackerRetIdentifier = "__ret__";
-/**
-* Wraps every outermost call expression in an IIFE that reports
-* `__toolc__(<id>, "start" | "end", …)` events around the call:
-*
-*     const x = (() => {
-*       try {
-*         __toolc__(0, "start");
-*         const __ret__ = tool();
-*         __toolc__(0, "end", __ret__);
-*         return __ret__;
-*       } catch (err) { __toolc__(1, "end", err); throw new Error(err.message); }
-*     })()
-*
-* Calls assigned to a variable are registered in `calls` (keyed by the id used
-* in the catch clause — the id the runtime sees when a tool throws a
-* SnapshotSignal). Awaited calls get an async IIFE that awaits the call.
-*
-* Returns the wrapped source ranges so later passes can avoid editing inside.
-*/
-function applyToolCallTracking(ctx, calls) {
-	let callId = 0;
-	const wrappedRanges = [];
-	const src = ctx.code;
-	const sliceOf = (node) => src.slice(node.start, node.end);
-	const extractAssignment = (lval) => {
-		const source = sliceOf(lval);
-		if (lval.type === "Identifier") return {
-			type: "single",
-			left: source,
-			evalFn: `let ${source} = arguments[0]; return { ${source} };`
-		};
-		if (lval.type === "ArrayPattern") {
-			const elements = lval.elements.map((el) => el ? sliceOf(el) : "").join(", ");
-			return {
-				type: "array",
-				left: elements,
-				evalFn: `let [${elements}] = arguments[0] ?? []; return { ${elements} };`
-			};
-		}
-		if (lval.type === "ObjectPattern") return {
-			type: "object",
-			left: source,
-			evalFn: `let ${source} = arguments[0] ?? {}; return ${source};`
-		};
-		return {
-			type: "unsupported",
-			left: "",
-			evalFn: ""
-		};
-	};
-	walk(ctx.ast, (node, parent, ancestors) => {
-		if (node.type !== "CallExpression") return;
-		if (wrappedRanges.some(([start, end]) => node.start >= start && node.end <= end)) return;
-		if ((parent === null || parent === void 0 ? void 0 : parent.type) === "YieldExpression") return;
-		if ((parent === null || parent === void 0 ? void 0 : parent.type) !== "AwaitExpression") {
-			let containsAwait = false;
-			walk(node, (child, _parent, ancestors) => {
-				if (child.type === "AwaitExpression" && !ancestors.some((ancestor) => [
-					"FunctionDeclaration",
-					"FunctionExpression",
-					"ArrowFunctionExpression"
-				].includes(ancestor.type))) containsAwait = true;
-			});
-			if (containsAwait) return;
-		}
-		const declaration = [...ancestors].reverse().find((n) => n.type === "VariableDeclaration");
-		const assignment = [...ancestors].reverse().find((n) => n.type === "AssignmentExpression");
-		let lval = null;
-		if (declaration) {
-			var _;
-			lval = ((_ = declaration.declarations[0]) === null || _ === void 0 ? void 0 : _.id) ?? null;
-		}
-		if (assignment) lval = assignment.left;
-		const isAsync = (parent === null || parent === void 0 ? void 0 : parent.type) === "AwaitExpression";
-		const start = (id) => `${ToolCallTrackerFnIdentifier}(${id}, "start");`;
-		const end = (id, value) => `${ToolCallTrackerFnIdentifier}(${id}, "end", ${value});`;
-		const prefix = (id) => `(${isAsync ? "async " : ""}() => {try {${start(id)}const ${ToolTrackerRetIdentifier} = ${isAsync ? "await " : ""}`;
-		const successSuffix = (id) => `;${end(id, ToolTrackerRetIdentifier)}return ${ToolTrackerRetIdentifier};}`;
-		if (!lval) {
-			if (!sliceOf(node).trim().length) return;
-			const catchClause = ` catch (err) {${end(callId, "err")}const __newError = new Error(err.message);__newError.stack = err.stack + ("\\n" + __newError.stack);throw __newError;}})()`;
-			ctx.ms.appendLeft(node.start, prefix(callId));
-			ctx.ms.appendRight(node.end, successSuffix(callId) + catchClause);
-			wrappedRanges.push([node.start, node.end]);
-			callId++;
-			return;
-		}
-		const assign = extractAssignment(lval);
-		if (assign.type === "unsupported") return;
-		const tryId = callId;
-		callId++;
-		const callee = node.callee;
-		let object = "global";
-		let tool = callee.type === "Identifier" ? callee.name : sliceOf(callee);
-		if (callee.type === "MemberExpression") {
-			object = sliceOf(callee.object);
-			const property = callee.property;
-			tool = property.type === "Identifier" ? property.name : property.type === "Literal" ? String(property.value) : sliceOf(property);
-		}
-		const catchClause = ` catch (err) {${end(callId, "err")}throw new Error(err.message);}})()`;
-		ctx.ms.appendLeft(node.start, prefix(tryId));
-		ctx.ms.appendRight(node.end, successSuffix(tryId) + catchClause);
-		wrappedRanges.push([node.start, node.end]);
-		calls.set(callId, {
-			object,
-			tool,
-			assignment: assign
-		});
-	});
-	return wrappedRanges;
-}
-//#endregion
-//#region src/compiler/plugins/variable-extraction.ts
-const VariableTrackingFnIdentifier = "__var__";
-/**
-* Tracks user variables so the VM can read their values between iterations:
-* - after each variable declaration: `__var__("a", () => eval("a"));`
-* - at the top of function bodies, for their parameters
-*
-* The `eval` indirection captures the variable lazily in its own scope.
-*/
-function applyVariableTracking(ctx, variables) {
-	const trackerFor = (name) => {
-		if (name.startsWith("__")) return null;
-		variables.add(name);
-		return `${VariableTrackingFnIdentifier}(${JSON.stringify(name)}, () => eval(${JSON.stringify(name)}));`;
-	};
-	const track = (names) => names.map(trackerFor).filter((t) => !!t).join("");
-	const declaredNames = (id) => {
-		if (id.type === "Identifier") return [id.name];
-		if (id.type === "ObjectPattern") {
-			const names = [];
-			for (const prop of id.properties) {
-				if (prop.type !== "Property") continue;
-				if (prop.value.type === "Identifier") names.push(prop.value.name);
-				else if (prop.value.type === "ObjectPattern") names.push(...declaredNames(prop.value));
-				else if (prop.value.type === "AssignmentPattern" && prop.value.left.type === "Identifier") names.push(prop.value.left.name);
-			}
-			return names;
-		}
-		if (id.type === "ArrayPattern") {
-			const names = [];
-			for (const element of id.elements) {
-				if (!element) continue;
-				if (element.type === "Identifier") names.push(element.name);
-				else if (element.type === "RestElement" && element.argument.type === "Identifier") names.push(element.argument.name);
-				else if (element.type === "AssignmentPattern" && element.left.type === "Identifier") names.push(element.left.name);
-			}
-			return names;
-		}
-		return [];
-	};
-	const paramNames = (params) => {
-		const names = [];
-		for (const param of params) if (param.type === "Identifier") names.push(param.name);
-		else if (param.type === "AssignmentPattern" && param.left.type === "Identifier") names.push(param.left.name);
-		else if (param.type === "ObjectPattern") {
-			for (const prop of param.properties) if (prop.type === "Property" && prop.value.type === "Identifier") names.push(prop.value.name);
-		} else if (param.type === "ArrayPattern") {
-			for (const element of param.elements) if ((element === null || element === void 0 ? void 0 : element.type) === "Identifier") names.push(element.name);
-		}
-		return names;
-	};
-	walk(ctx.ast, (node, parent) => {
-		if (node.type === "VariableDeclaration") {
-			if (parent && (parent.type === "ForStatement" || parent.type === "ForInStatement" || parent.type === "ForOfStatement")) return;
-			const trackers = track(node.declarations.flatMap((d) => declaredNames(d.id)));
-			if (trackers) {
-				const semi = ctx.code[node.end - 1] === ";" ? "" : ";";
-				ctx.ms.appendRight(node.end, `${semi}${trackers}`);
-			}
-			return;
-		}
-		if (node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") {
-			const trackers = track(paramNames(node.params));
-			if (!trackers) return;
-			const body = node.body;
-			if (body.type === "BlockStatement") ctx.ms.appendRight(body.start + 1, trackers);
-			else {
-				const expressions = trackers.slice(0, -1).replaceAll(";", ",");
-				ctx.ms.prependLeft(body.start, `(${expressions}, (`);
-				ctx.ms.appendRight(body.end, "))");
-			}
-		}
-	});
-}
-//#endregion
-//#region src/compiler/compiler.ts
-const Identifiers = {
-	ConsoleObjIdentifier: "console",
-	LineTrackingFnIdentifier,
-	VariableTrackingFnIdentifier,
-	ToolCallTrackerFnIdentifier,
-	ToolTrackerRetIdentifier,
-	CommentFnIdentifier
-};
-const FUNCTION_TYPES = /* @__PURE__ */ new Set([
-	"FunctionDeclaration",
-	"FunctionExpression",
-	"ArrowFunctionExpression"
-]);
-/**
-* Whether the code contains a top-level `return` statement (one that would
-* return from the generated code itself, not from a nested function). Unlike a
-* regex, this ignores `return` inside comments, strings and nested functions.
-* Falls back to a word-boundary match if the code cannot be parsed.
-*/
-function hasTopLevelReturn(code) {
-	try {
-		const ast = parseScript(code);
-		let found = false;
-		walk(ast, (node, _parent, ancestors) => {
-			if (node.type === "ReturnStatement" && !ancestors.some((a) => FUNCTION_TYPES.has(a.type))) found = true;
-		});
-		return found;
-	} catch {
-		return /\breturn\b/.test(code);
-	}
-}
-/**
-* Compiles the agent's generated JavaScript for VM execution:
-*
-* 1. wraps it in an async `__fn__` so top-level `await`/`return` parse
-* 2. instruments it in a single parse + text-edit pass:
-*    line tracking, last-line return, tool-call tracking, comment tracing
-*    and variable tracking
-* 3. unwraps it — the VM drivers re-wrap the bare statements themselves
-*
-* All edits preserve line numbers 1:1 with the wrapped source, so positions
-* reported at runtime map straight back to the user code.
-*/
-function compile(code) {
-	const wrapped = AsyncWrapper.preProcessing(code);
-	const comments = [];
-	const ast = parseScript(wrapped, { comments });
-	const variables = /* @__PURE__ */ new Set();
-	const toolCalls = /* @__PURE__ */ new Map();
-	const lastLine = planLastLineInstrumentation(ast);
-	const msMarkers = new MagicString(wrapped);
-	if (lastLine) {
-		msMarkers.appendLeft(lastLine.prefixPos, lastLine.prefix);
-		msMarkers.appendRight(lastLine.suffixPos, lastLine.suffix);
-	}
-	const codeWithMarkers = msMarkers.toString();
-	const ms = new MagicString(wrapped);
-	const ctx = {
-		code: wrapped,
-		ms,
-		ast,
-		comments
-	};
-	applyLineTracking(ctx);
-	if (lastLine) ms.appendLeft(lastLine.prefixPos, lastLine.prefix);
-	applyCommentReplacement(ctx, applyToolCallTracking(ctx, toolCalls));
-	applyVariableTracking(ctx, variables);
-	if (lastLine) ms.appendRight(lastLine.suffixPos, lastLine.suffix);
-	return {
-		code: AsyncWrapper.postProcessing(ms.toString()),
-		codeWithMarkers,
-		map: ms.generateMap({
-			hires: true,
-			source: "<anonymous>"
-		}),
-		variables,
-		toolCalls
-	};
-}
-//#endregion
-export { USER_CODE_START_MARKER as i, compile as n, hasTopLevelReturn as r, Identifiers as t };

package/dist/component-C6Agl2ns.cjs

@@ -1,73 +0,0 @@
-const require_compiler = require("./compiler-C-OI9sim.cjs");
-const require_jsx = require("./jsx-owqxrquU.cjs");
-//#region src/component.ts
-var component_exports = /* @__PURE__ */ require_compiler.__exportAll({
-	Component: () => Component,
-	assertValidComponent: () => assertValidComponent,
-	isAnyComponent: () => isAnyComponent,
-	isComponent: () => isComponent
-});
-function assertValidComponent(component) {
-	if (!component.name) throw new Error("Component must have a name");
-	const nameRegex = /^[A-Z]{3,50}$/i;
-	if (!nameRegex.test(component.name)) throw new Error(`Component name "${component.name}" must be 3-50 characters long and start with an uppercase letter`);
-	if (component.aliases) {
-		for (const alias of component.aliases) if (!nameRegex.test(alias)) throw new Error(`Alias "${alias}" must be 3-50 characters long and start with an uppercase letter`);
-	}
-	if (!component.description) throw new Error("Component must have a description");
-	if (component.type === "default" && !component.default) throw new Error("Default component must have default props and children");
-	if (component.type === "leaf" && !component.leaf) throw new Error("Leaf component must have leaf props");
-	if (component.type === "container" && !component.container) throw new Error("Container component must have container props and children");
-}
-var Component = class {
-	definition;
-	propsType;
-	constructor(definition) {
-		assertValidComponent(definition);
-		this.definition = definition;
-	}
-	render(props, children = []) {
-		return require_jsx.createJsxComponent({
-			type: this.definition.name,
-			props,
-			children
-		});
-	}
-};
-function isComponent(rendered, component) {
-	return require_jsx.isJsxComponent(component.definition.name, rendered);
-}
-function isAnyComponent(message) {
-	return require_jsx.isAnyJsxComponent(message);
-}
-//#endregion
-Object.defineProperty(exports, "Component", {
-	enumerable: true,
-	get: function() {
-		return Component;
-	}
-});
-Object.defineProperty(exports, "assertValidComponent", {
-	enumerable: true,
-	get: function() {
-		return assertValidComponent;
-	}
-});
-Object.defineProperty(exports, "component_exports", {
-	enumerable: true,
-	get: function() {
-		return component_exports;
-	}
-});
-Object.defineProperty(exports, "isAnyComponent", {
-	enumerable: true,
-	get: function() {
-		return isAnyComponent;
-	}
-});
-Object.defineProperty(exports, "isComponent", {
-	enumerable: true,
-	get: function() {
-		return isComponent;
-	}
-});

package/dist/component-DGG7d_Mz.js

@@ -1,44 +0,0 @@
-import { n as __exportAll } from "./rolldown-runtime-EAsCxrDo.js";
-import { n as isAnyJsxComponent, r as isJsxComponent, t as createJsxComponent } from "./jsx-CIgdGGVs.js";
-//#region src/component.ts
-var component_exports = /* @__PURE__ */ __exportAll({
-	Component: () => Component,
-	assertValidComponent: () => assertValidComponent,
-	isAnyComponent: () => isAnyComponent,
-	isComponent: () => isComponent
-});
-function assertValidComponent(component) {
-	if (!component.name) throw new Error("Component must have a name");
-	const nameRegex = /^[A-Z]{3,50}$/i;
-	if (!nameRegex.test(component.name)) throw new Error(`Component name "${component.name}" must be 3-50 characters long and start with an uppercase letter`);
-	if (component.aliases) {
-		for (const alias of component.aliases) if (!nameRegex.test(alias)) throw new Error(`Alias "${alias}" must be 3-50 characters long and start with an uppercase letter`);
-	}
-	if (!component.description) throw new Error("Component must have a description");
-	if (component.type === "default" && !component.default) throw new Error("Default component must have default props and children");
-	if (component.type === "leaf" && !component.leaf) throw new Error("Leaf component must have leaf props");
-	if (component.type === "container" && !component.container) throw new Error("Container component must have container props and children");
-}
-var Component = class {
-	definition;
-	propsType;
-	constructor(definition) {
-		assertValidComponent(definition);
-		this.definition = definition;
-	}
-	render(props, children = []) {
-		return createJsxComponent({
-			type: this.definition.name,
-			props,
-			children
-		});
-	}
-};
-function isComponent(rendered, component) {
-	return isJsxComponent(component.definition.name, rendered);
-}
-function isAnyComponent(message) {
-	return isAnyJsxComponent(message);
-}
-//#endregion
-export { isComponent as a, isAnyComponent as i, assertValidComponent as n, component_exports as r, Component as t };

package/dist/component.d.ts

@@ -1,88 +0,0 @@
-import { z } from '@bpinternal/zui';
-import { JsxComponent } from './jsx.js';
-import type { BodyFormat, GenerativeComponentMetadata } from './message-stream/types.js';
-/**
- * @deprecated TSX-era examples are no longer shown to the model — llmz
- * generates ■-protocol blocks, not TSX. Use `generation.examples`
- * ({ props?, body? }) instead.
- */
-export type ExampleUsage = {
-    name: string;
-    description: string;
-    code: string;
-};
-/**
- * Optional body configuration for components that accept a message body
- * (`default` and `container` types). Controls how the body is documented to
- * the model in the ■ protocol reference.
- */
-export type ComponentBodyOptions = {
-    /** How the body should be written: 'markdown' (default), 'text' (plain prose) or 'code'. */
-    format?: BodyFormat;
-    /** Model-facing description of what the body must contain. */
-    description?: string;
-    /** Whether a body is required. Defaults to true. */
-    required?: boolean;
-};
-export type ComponentChild = {
-    description: string;
-    component: ComponentDefinition;
-};
-export declare function assertValidComponent(component: ComponentDefinition): asserts component is ComponentDefinition;
-export type DefaultComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
-    type: 'default';
-    name: string;
-    aliases: string[];
-    description: string;
-    /** @deprecated Not shown to the model. Use `generation.examples` instead. */
-    examples?: ExampleUsage[];
-    /** Body configuration for the ■ protocol reference, or false to disallow a body. */
-    body?: ComponentBodyOptions | false;
-    /** Model-facing generation metadata: usage guidance and ■-protocol examples ({ props?, body? }). */
-    generation?: GenerativeComponentMetadata;
-    default: {
-        props: T;
-        children: Array<ComponentChild>;
-    };
-};
-export type LeafComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
-    type: 'leaf';
-    name: string;
-    description: string;
-    aliases?: string[];
-    /** @deprecated Not shown to the model. Use `generation.examples` instead. */
-    examples?: ExampleUsage[];
-    /** Model-facing generation metadata: usage guidance and ■-protocol examples ({ props? }). */
-    generation?: GenerativeComponentMetadata;
-    leaf: {
-        props: T;
-    };
-};
-export type ContainerComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
-    type: 'container';
-    name: string;
-    description: string;
-    aliases?: string[];
-    /** @deprecated Not shown to the model. Use `generation.examples` instead. */
-    examples?: ExampleUsage[];
-    /** Body configuration for the ■ protocol reference, or false to disallow a body. */
-    body?: ComponentBodyOptions | false;
-    /** Model-facing generation metadata: usage guidance and ■-protocol examples ({ props?, body? }). */
-    generation?: GenerativeComponentMetadata;
-    container: {
-        props: T;
-        children: Array<ComponentChild>;
-    };
-};
-export type ComponentDefinition = DefaultComponentDefinition | LeafComponentDefinition | ContainerComponentDefinition;
-type ExtractComponentProps<T extends ComponentDefinition> = T extends LeafComponentDefinition<infer P> ? z.infer<P> : T extends ContainerComponentDefinition<infer P> ? z.infer<P> : T extends DefaultComponentDefinition<infer P> ? z.infer<P> : never;
-export type RenderedComponent<TProps extends {} = {}> = JsxComponent<string, TProps>;
-export declare class Component<T extends ComponentDefinition = ComponentDefinition> {
-    readonly definition: T;
-    readonly propsType: ExtractComponentProps<T>;
-    constructor(definition: T);
-    render<TChildren extends any = any>(props: Component['propsType'], children?: Array<TChildren>): RenderedComponent;
-}
-export declare function isComponent<T extends ComponentDefinition>(rendered: RenderedComponent<any>, component: Component<T>): rendered is RenderedComponent<ExtractComponentProps<T>>;
-export declare function isAnyComponent(message: unknown): message is RenderedComponent;
-export {};