@jigs.design/runtime 0.0.0-stage → 0.1.1

package/dist/tree-store.d.ts

@@ -0,0 +1,56 @@
+import { ComponentSchema } from "./types.js";
+import { Op, WireValue } from "./protocol.js";
+//#region src/tree-store.d.ts
+export interface TreeNode {
+  children: ReadonlyArray<number>;
+  id: number;
+  props: Readonly<Record<string, WireValue>>;
+  text: string;
+  type: string;
+}
+interface TreeSchemas {
+  components: Readonly<Record<string, ComponentSchema>>;
+  imageHosts: ReadonlyArray<string>;
+}
+export interface TreeStore {
+  apply: (ops: ReadonlyArray<Op>) => void;
+  get: (id: number) => TreeNode | undefined;
+  /** What the store dropped since the last program change, newest last. */
+  getIssues: () => ReadonlyArray<string>;
+  reset: () => void;
+  /** The schemas the next ops are checked against. Clears the issues. */
+  setSchemas: (schemas: TreeSchemas) => void;
+  subscribe: (listener: () => void) => () => void;
+}
+/**
+ * Most nodes a tree may hold, the root aside. The runtime refuses to render
+ * more (it keeps its own copy of the number), so only a worker that broke out
+ * of the runtime gets past it here, and the store drops the creates over it.
+ * The count is what a whole message leaves: the runtime may create a row's
+ * new nodes before it removes the old ones further on, so mid-message the
+ * store may hold up to twice this (`MAX_DRAFT_NODES`).
+ */
+export declare const MAX_NODES = 10000;
+/**
+ * Most ops one message may carry. A render of `MAX_NODES` nodes needs at most
+ * three per node (remove the old one, create and place the new one), so the
+ * runtime stays under it; a message over it is dropped whole.
+ */
+export declare const MAX_OPS: number;
+/** Longest text a text node may hold, in UTF-16 code units, as for a string prop. */
+export declare const MAX_TEXT = 10000;
+/**
+ * The page's copy of the sandboxed UI, built from worker ops. Ops are
+ * untrusted: components the program did not declare and props that fail
+ * their schema are dropped, and each drop is recorded as an issue. The tree
+ * holds at most `MAX_NODES` nodes once a message is applied, a message at
+ * most `MAX_OPS` ops, and a text node at most `MAX_TEXT` characters.
+ * `apply` takes time linear in its ops for what the runtime sends, and
+ * stops a message that splices or walks the tree for longer than that.
+ *
+ * Nodes are replaced, never mutated, so `get(id)` works as a
+ * `useSyncExternalStore` snapshot.
+ */
+export declare function createTreeStore(): TreeStore;
+//#endregion
+export {};

package/dist/tree-store.js

@@ -0,0 +1,340 @@
+import "./protocol.js";
+import { acceptsProp } from "./validate.js";
+//#region src/tree-store.ts
+const ROOT_TYPE = "#root";
+const TEXT_TYPE = "#text";
+const MAX_ISSUES = 20;
+/**
+* Most nodes a tree may hold, the root aside. The runtime refuses to render
+* more (it keeps its own copy of the number), so only a worker that broke out
+* of the runtime gets past it here, and the store drops the creates over it.
+* The count is what a whole message leaves: the runtime may create a row's
+* new nodes before it removes the old ones further on, so mid-message the
+* store may hold up to twice this (`MAX_DRAFT_NODES`).
+*/
+const MAX_NODES = 1e4;
+/**
+* Most nodes the store holds while one message is applied: the old tree and
+* a new one, each up to `MAX_NODES`. Creates past it are dropped at once.
+*/
+const MAX_DRAFT_NODES = 2 * MAX_NODES;
+/**
+* Most ops one message may carry. A render of `MAX_NODES` nodes needs at most
+* three per node (remove the old one, create and place the new one), so the
+* runtime stays under it; a message over it is dropped whole.
+*/
+const MAX_OPS = 3 * MAX_NODES;
+/** Longest text a text node may hold, in UTF-16 code units, as for a string prop. */
+const MAX_TEXT = 1e4;
+/** A removed child's slot in a draft, until the draft is compacted. */
+const HOLE = -1;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isId = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+/** Whether an op from the frame has the fields its kind needs; anything else is dropped. */
+function isWellFormed(op) {
+	const fields = op;
+	if (!isRecord(fields) || !isId(fields.id)) return false;
+	switch (op.op) {
+		case "create": return typeof fields.type === "string" && isRecord(fields.props);
+		case "createText":
+		case "text": return typeof fields.text === "string" && fields.text.length <= 1e4;
+		case "place": return isId(fields.parent) && isId(fields.index);
+		case "remove": return true;
+		case "set": return isRecord(fields.props);
+		default: return false;
+	}
+}
+const rootNode = () => ({
+	children: [],
+	id: 0,
+	props: {},
+	text: "",
+	type: ROOT_TYPE
+});
+const compact = (draft) => {
+	if (draft.holes > 0) {
+		draft.items = draft.items.filter((child) => child !== HOLE);
+		draft.holes = 0;
+		draft.at = null;
+	}
+};
+/**
+* Puts `id` at `index` among a draft's live children, and says whether that
+* took constant time. The runtime either appends or fills the slot of the
+* child it just removed at that index, which do. Any other order compacts
+* and splices, which is linear in the parent's children.
+*/
+function insert(draft, id, index) {
+	if (index >= draft.items.length - draft.holes) {
+		draft.at?.set(id, draft.items.length);
+		draft.items.push(id);
+		return true;
+	}
+	if (draft.holes === 1 && draft.items[index] === HOLE) {
+		draft.items[index] = id;
+		draft.holes = 0;
+		draft.at?.set(id, index);
+		return true;
+	}
+	compact(draft);
+	draft.items.splice(index, 0, id);
+	draft.at = null;
+	return false;
+}
+/**
+* Most ops in one message that take time linear in a parent's children (see
+* `insert`). The runtime sends none, so this only stops a worker that broke
+* out of it from spending `MAX_OPS * MAX_NODES` steps of the page's time.
+*/
+const MAX_SLOW_OPS = 1e3;
+/**
+* Most ancestors one message may walk to rule out cycles, 64 per op on
+* average. The runtime places a subtree before its parent, so its walks stop
+* at once or climb a shallow tree; a worker that broke out of it could
+* otherwise re-place a leaf under a chain `MAX_NODES` deep, over and over.
+*/
+const MAX_WALK_STEPS = 64 * MAX_OPS;
+/**
+* The page's copy of the sandboxed UI, built from worker ops. Ops are
+* untrusted: components the program did not declare and props that fail
+* their schema are dropped, and each drop is recorded as an issue. The tree
+* holds at most `MAX_NODES` nodes once a message is applied, a message at
+* most `MAX_OPS` ops, and a text node at most `MAX_TEXT` characters.
+* `apply` takes time linear in its ops for what the runtime sends, and
+* stops a message that splices or walks the tree for longer than that.
+*
+* Nodes are replaced, never mutated, so `get(id)` works as a
+* `useSyncExternalStore` snapshot.
+*/
+function createTreeStore() {
+	const nodes = /* @__PURE__ */ new Map([[0, rootNode()]]);
+	const parents = /* @__PURE__ */ new Map();
+	/** Children being rebuilt by the current `apply`, by parent. */
+	const drafts = /* @__PURE__ */ new Map();
+	/** Ops of the current `apply` that took linear time; see `MAX_SLOW_OPS`. */
+	let slow = 0;
+	/** Ancestors the current `apply` walked; see `MAX_WALK_STEPS`. */
+	let walked = 0;
+	/** Nodes the current `apply` created, oldest first. */
+	let created = [];
+	const listeners = /* @__PURE__ */ new Set();
+	let schemas = {
+		components: {},
+		imageHosts: []
+	};
+	let issues = [];
+	const report = (issue) => {
+		if (issues.length < MAX_ISSUES && !issues.includes(issue)) issues = [...issues, issue];
+	};
+	const reportTooMany = () => {
+		report(`The program drew more than ${MAX_NODES} nodes; the rest were dropped`);
+	};
+	const schemaFor = (type) => Object.hasOwn(schemas.components, type) ? schemas.components[type] : void 0;
+	const checkedProps = (type, incoming, base) => {
+		const schema = schemaFor(type);
+		const props = { ...base };
+		if (schema === void 0) return props;
+		for (const [name, value] of Object.entries(incoming)) if (value === null) delete props[name];
+		else if (acceptsProp(schema, name, value, schemas.imageHosts)) props[name] = value;
+		else {
+			delete props[name];
+			report(`<${type}> dropped an invalid \`${name}\``);
+		}
+		return props;
+	};
+	const update = (id, change) => {
+		const node = nodes.get(id);
+		if (node !== void 0) nodes.set(id, change(node));
+	};
+	const draftOf = (parent) => {
+		let draft = drafts.get(parent);
+		if (draft === void 0) {
+			const items = [...nodes.get(parent)?.children ?? []];
+			draft = {
+				at: new Map(items.map((child, index) => [child, index])),
+				holes: 0,
+				items
+			};
+			drafts.set(parent, draft);
+		}
+		return draft;
+	};
+	const detach = (id) => {
+		const parent = parents.get(id);
+		if (parent === void 0) return;
+		const draft = draftOf(parent);
+		if (draft.at === null) slow++;
+		const slot = draft.at === null ? draft.items.indexOf(id) : draft.at.get(id) ?? -1;
+		if (slot !== -1) {
+			draft.items[slot] = HOLE;
+			draft.holes++;
+			draft.at?.delete(id);
+		}
+		parents.delete(id);
+	};
+	/**
+	* Writes each draft back as its parent's `children`. With `pruned`, some
+	* nodes were removed without leaving a hole, so children are kept only
+	* while they exist.
+	*/
+	const commitDrafts = (pruned) => {
+		for (const [parent, draft] of drafts) {
+			compact(draft);
+			const children = pruned ? draft.items.filter((child) => nodes.has(child)) : draft.items;
+			update(parent, (node) => ({
+				...node,
+				children
+			}));
+		}
+		drafts.clear();
+	};
+	/** Whether `id` is `ancestor` or sits below it; placing there would create a cycle. */
+	const isWithin = (id, ancestor) => {
+		let current = id;
+		while (current !== void 0) {
+			if (current === ancestor) return true;
+			walked++;
+			current = parents.get(current);
+		}
+		return false;
+	};
+	const removeSubtree = (id) => {
+		const children = drafts.get(id)?.items ?? nodes.get(id)?.children ?? [];
+		drafts.delete(id);
+		for (const child of children) if (child !== HOLE) {
+			parents.delete(child);
+			removeSubtree(child);
+		}
+		nodes.delete(id);
+	};
+	/**
+	* Drops this message's newest creates, with what they hold, until the
+	* tree is back under `MAX_NODES`. Says whether it dropped any.
+	*/
+	const trimToCap = () => {
+		if (nodes.size <= 10001) return false;
+		reportTooMany();
+		for (let index = created.length - 1; index >= 0; index--) {
+			if (nodes.size <= 10001) break;
+			const id = created[index] ?? 0;
+			if (nodes.has(id)) {
+				parents.delete(id);
+				removeSubtree(id);
+			}
+		}
+		return true;
+	};
+	const applyOne = (op) => {
+		if (!isWellFormed(op)) {
+			report("The sandbox sent a malformed operation; it was dropped");
+			return;
+		}
+		if (op.op === "create" || op.op === "createText") {
+			if (op.id === 0 || nodes.has(op.id)) {
+				report("The sandbox reused a node id; the operation was dropped");
+				return;
+			}
+			if (nodes.size > MAX_DRAFT_NODES) {
+				reportTooMany();
+				return;
+			}
+			created.push(op.id);
+		}
+		switch (op.op) {
+			case "createText":
+				nodes.set(op.id, {
+					children: [],
+					id: op.id,
+					props: {},
+					text: String(op.text),
+					type: TEXT_TYPE
+				});
+				return;
+			case "create":
+				if (schemaFor(op.type) === void 0) {
+					report(`<${op.type}> is not a component this program may draw`);
+					return;
+				}
+				nodes.set(op.id, {
+					children: [],
+					id: op.id,
+					props: checkedProps(op.type, op.props, {}),
+					text: "",
+					type: op.type
+				});
+				return;
+			case "set":
+				update(op.id, (node) => node.type === ROOT_TYPE || node.type === TEXT_TYPE ? node : {
+					...node,
+					props: checkedProps(node.type, op.props, node.props)
+				});
+				return;
+			case "text":
+				update(op.id, (node) => node.type === TEXT_TYPE ? {
+					...node,
+					text: String(op.text)
+				} : node);
+				return;
+			case "place":
+				if (!nodes.has(op.id) || !nodes.has(op.parent) || op.id === 0 || isWithin(op.parent, op.id)) return;
+				detach(op.id);
+				if (!insert(draftOf(op.parent), op.id, op.index)) slow++;
+				parents.set(op.id, op.parent);
+				return;
+			case "remove":
+				if (op.id === 0) return;
+				detach(op.id);
+				removeSubtree(op.id);
+				return;
+		}
+	};
+	const notify = () => {
+		for (const listener of listeners) listener();
+	};
+	return {
+		apply: (ops) => {
+			if (!Array.isArray(ops)) return;
+			if (ops.length > 3e4) {
+				report(`The sandbox sent ${ops.length} operations at once, over the limit of ${MAX_OPS}; the update was dropped`);
+				notify();
+				return;
+			}
+			slow = 0;
+			walked = 0;
+			created = [];
+			for (const op of ops) {
+				if (slow > MAX_SLOW_OPS || walked > MAX_WALK_STEPS) {
+					report("The sandbox reordered too many nodes at once; the rest of the update was dropped");
+					break;
+				}
+				applyOne(op);
+			}
+			const pruned = trimToCap();
+			created = [];
+			commitDrafts(pruned);
+			notify();
+		},
+		get: (id) => nodes.get(id),
+		getIssues: () => issues,
+		reset: () => {
+			nodes.clear();
+			parents.clear();
+			drafts.clear();
+			nodes.set(0, rootNode());
+			issues = [];
+			notify();
+		},
+		setSchemas: (next) => {
+			schemas = next;
+			issues = [];
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+export { MAX_NODES, MAX_OPS, MAX_TEXT, createTreeStore };

package/dist/types.d.ts

@@ -0,0 +1,168 @@
+//#region src/types.d.ts
+/**
+ * Types the server and the browser share. The server builds these values;
+ * the browser receives them as JSON and checks them with `parse.ts`.
+ */
+/** The version of the program format. The runtime refuses any other. */
+export declare const PROGRAM_FORMAT = 1;
+export declare const pickleErrorCodes: readonly ["BAD_INPUT", "UNAUTHORIZED", "FORBIDDEN", "NOT_FOUND", "CONFLICT", "RATE_LIMITED", "INTERNAL", "UNKNOWN_PROCEDURE", "UNAVAILABLE", "NETWORK", "DECLINED"];
+export type PickleErrorCode = (typeof pickleErrorCodes)[number];
+/** A failure as the spec and the browser see it. */
+export interface PickleErrorData {
+  code: PickleErrorCode;
+  message: string;
+}
+/**
+ * Where a diagnostic points. Every span has a line; one about something the
+ * compiler can place in the source also has its range, as offsets into the
+ * source the line counts (JavaScript string indices), and the column of its
+ * start.
+ */
+export interface Span {
+  /** 1-based, on `line`. */
+  column?: number;
+  /** Just past the range. */
+  end?: number;
+  line: number;
+  /** The range's first character. */
+  start?: number;
+}
+/**
+ * A rewrite that makes a diagnostic's problem go away: replace each edit's
+ * span with its text. The server attaches one only when there is a single
+ * way to write it, and applies it itself, so its diagnostic is `info`.
+ */
+export interface DiagnosticFix {
+  edits: Array<{
+    span: Span;
+    text: string;
+  }>;
+  title: string;
+}
+export interface Diagnostic {
+  code: string;
+  fix?: DiagnosticFix;
+  message: string;
+  /** `error` marks something the compiler had to change; the program still runs. */
+  severity: "error" | "hint" | "info" | "warning";
+  span: Span;
+}
+export interface NumberPropSchema {
+  kind: "number";
+  max?: number;
+  min?: number;
+}
+/** How the view checks one prop before a registry component sees it. */
+export type PropSchema = {
+  kind: "boolean";
+} | {
+  kind: "enum";
+  values: ReadonlyArray<string>;
+} | {
+  kind: "handler";
+} | {
+  kind: "image";
+} | {
+  kind: "link";
+} | {
+  kind: "list";
+} | NumberPropSchema | {
+  kind: "string";
+};
+export type ChildrenKind = "block" | "inline" | "none";
+export interface ComponentSchema {
+  children: ChildrenKind;
+  props: Readonly<Record<string, PropSchema>>;
+}
+/** `action` is a mutation the embedding page handles instead of the server. */
+export type ProcedureKind = "action" | "mutation" | "query";
+export interface ProcedureEntry {
+  invalidates: ReadonlyArray<string>;
+  kind: ProcedureKind;
+}
+/**
+ * One query a mutation refreshed, as the server sends it with the mutation's
+ * data. Without `input`, every input of the query refetches. With it, only
+ * the queries whose input contains those values.
+ */
+export interface Invalidation {
+  input?: JsonValue;
+  name: string;
+}
+/**
+ * A compiled spec. Opaque to apps: pass it from the server to the view and
+ * nowhere else. The view trusts its schemas and image hosts.
+ */
+export interface Program {
+  code: string;
+  /** Prop schemas of the components the program draws. */
+  components: Readonly<Record<string, ComponentSchema>>;
+  format: typeof PROGRAM_FORMAT;
+  imageHosts: ReadonlyArray<string>;
+  /** Procedures the program calls, with their kind and `invalidates` list. */
+  procedures: Readonly<Record<string, ProcedureEntry>>;
+  /** Text nodes pulled out of the code, so a prose edit swaps a table. */
+  prose: Readonly<Record<string, string>>;
+}
+export interface Message {
+  content: string;
+  role: "assistant" | "user";
+}
+export type SessionEvent = {
+  diagnostics: ReadonlyArray<Diagnostic>;
+  /**
+   * True on the first program of a new UI: the model wrote a whole
+   * document rather than editing the last one, or a stored one was
+   * restored. The view starts it from fresh state.
+   */
+  fresh: boolean;
+  program: Program;
+  revision: number;
+  type: "program";
+} | {
+  diagnostics: ReadonlyArray<Diagnostic>;
+  revision: number;
+  source: string;
+  type: "done";
+} | {
+  error: PickleErrorData;
+  type: "error";
+};
+/**
+ * Where a chat block is: still arriving, being repaired after it closed with
+ * errors, or final.
+ */
+export type ChatBlockStatus = "done" | "repairing" | "streaming";
+/**
+ * A pickle in a chat reply: one fenced `pickle` block, compiled on its own.
+ * The server sends it again whenever its program changes, under the same
+ * `key`.
+ */
+export interface ChatBlock {
+  /** Lines refer to `source`, which starts with its pragma line. */
+  diagnostics: ReadonlyArray<Diagnostic>;
+  /** Set when the block could not be built, e.g. an edit to a missing UI. */
+  error?: PickleErrorData;
+  /** The id the model gave the block, e.g. "monthly-spending". */
+  id: string;
+  /** `${id}@${version}`: unique in a conversation. */
+  key: string;
+  program: Program;
+  /** The checked source, with its pragma. Store this, not the program. */
+  source: string;
+  status: ChatBlockStatus;
+  /** 1 for the first block with this id in the conversation, then 2, 3… */
+  version: number;
+}
+/** A value that travels as JSON. */
+export type JsonValue = boolean | null | number | string | ReadonlyArray<JsonValue> | {
+  readonly [key: string]: JsonValue;
+};
+/** App options sent with a turn; the server parses them with its `options` schema. */
+export type SessionOptions = Readonly<Record<string, JsonValue>>;
+/** What a session request carries. */
+export interface SessionBody {
+  messages: ReadonlyArray<Message>;
+  options?: SessionOptions;
+}
+//#endregion

package/dist/types.js

@@ -0,0 +1,22 @@
+//#region src/types.ts
+/**
+* Types the server and the browser share. The server builds these values;
+* the browser receives them as JSON and checks them with `parse.ts`.
+*/
+/** The version of the program format. The runtime refuses any other. */
+const PROGRAM_FORMAT = 1;
+const pickleErrorCodes = [
+	"BAD_INPUT",
+	"UNAUTHORIZED",
+	"FORBIDDEN",
+	"NOT_FOUND",
+	"CONFLICT",
+	"RATE_LIMITED",
+	"INTERNAL",
+	"UNKNOWN_PROCEDURE",
+	"UNAVAILABLE",
+	"NETWORK",
+	"DECLINED"
+];
+//#endregion
+export { PROGRAM_FORMAT, pickleErrorCodes };

package/dist/urls.d.ts

@@ -0,0 +1,14 @@
+//#region src/urls.d.ts
+/**
+ * A hostname, or `*.example.com` for its subdomains (not the apex),
+ * optionally followed by a path prefix that ends in `/`, such as
+ * `images.example.com/products/`.
+ */
+export declare function isImageHostEntry(entry: string): boolean;
+/** The entry with its host lowercased; the path keeps its case. */
+export declare function normalizeImageHost(entry: string): string;
+/** An `https` URL with no credentials or port, on one of `hosts`. */
+export declare function isAllowedImage(src: string, hosts: ReadonlyArray<string>): boolean;
+/** An absolute `http` or `https` URL. Anything else, such as `javascript:`, is refused. */
+export declare function isAllowedLink(href: string): boolean;
+//#endregion

package/dist/urls.js

@@ -0,0 +1,59 @@
+//#region src/urls.ts
+const HOST = /^(\*\.)?[a-z0-9-]+(\.[a-z0-9-]+)*$/;
+const PATH_PREFIX = /^\/(?:[A-Za-z0-9._~!$&'()*+,;=:@%/-]*\/)?$/;
+/** An image host entry split into its host and optional path prefix. */
+function splitEntry(entry) {
+	const slash = entry.indexOf("/");
+	return slash === -1 ? {
+		host: entry.toLowerCase(),
+		path: "/"
+	} : {
+		host: entry.slice(0, slash).toLowerCase(),
+		path: entry.slice(slash)
+	};
+}
+/**
+* A hostname, or `*.example.com` for its subdomains (not the apex),
+* optionally followed by a path prefix that ends in `/`, such as
+* `images.example.com/products/`.
+*/
+function isImageHostEntry(entry) {
+	const parts = splitEntry(entry);
+	return HOST.test(parts.host) && PATH_PREFIX.test(parts.path);
+}
+/** The entry with its host lowercased; the path keeps its case. */
+function normalizeImageHost(entry) {
+	const parts = splitEntry(entry);
+	return entry.includes("/") ? `${parts.host}${parts.path}` : parts.host;
+}
+/**
+* An encoded `/`, `\`, `.` or `%`: a server that decodes it after matching can
+* be walked out of the prefix with `..%2F`, or with `..%252F` if it decodes
+* twice, and the URL parser leaves it alone. So a prefix can't serve object
+* keys that hold an encoded `/`, such as Firebase Storage's `o/a%2Fb.jpg`.
+*/
+const ENCODED_SEPARATOR = /%(?:2f|5c|2e|25)/i;
+function matchesHost(url, entry) {
+	if (!isImageHostEntry(entry)) return false;
+	const parts = splitEntry(entry);
+	return (parts.host.startsWith("*.") ? url.hostname.endsWith(parts.host.slice(1)) : url.hostname === parts.host) && url.pathname.startsWith(parts.path) && (parts.path === "/" || !ENCODED_SEPARATOR.test(url.pathname));
+}
+function parseUrl(text) {
+	try {
+		return new URL(text);
+	} catch {
+		return null;
+	}
+}
+/** An `https` URL with no credentials or port, on one of `hosts`. */
+function isAllowedImage(src, hosts) {
+	const url = parseUrl(src);
+	return url !== null && url.protocol === "https:" && url.username === "" && url.password === "" && url.port === "" && hosts.some((entry) => matchesHost(url, entry));
+}
+/** An absolute `http` or `https` URL. Anything else, such as `javascript:`, is refused. */
+function isAllowedLink(href) {
+	const url = parseUrl(href);
+	return url !== null && (url.protocol === "https:" || url.protocol === "http:") && url.username === "" && url.password === "";
+}
+//#endregion
+export { isAllowedImage, isAllowedLink, isImageHostEntry, normalizeImageHost };

package/dist/validate.js

@@ -0,0 +1,33 @@
+import { isAllowedImage, isAllowedLink } from "./urls.js";
+//#region src/validate.ts
+const MAX_ROWS = 500;
+const MAX_ROW_KEYS = 20;
+const MAX_CELL = 500;
+const MAX_STRING = 1e4;
+const isCell = (value) => value === null || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.length <= MAX_CELL;
+function isRows(value) {
+	return Array.isArray(value) && value.length <= MAX_ROWS && value.every((row) => typeof row === "object" && row !== null && !Array.isArray(row) && Object.getPrototypeOf(row) === Object.prototype && Object.keys(row).length <= MAX_ROW_KEYS && Object.values(row).every((cell) => isCell(cell)));
+}
+function isFnRef(value) {
+	return typeof value === "object" && value !== null && "fn" in value && typeof value.fn === "string";
+}
+/** Whether one wire value passes its prop schema. */
+function acceptsValue(schema, value, imageHosts) {
+	switch (schema.kind) {
+		case "boolean": return typeof value === "boolean";
+		case "enum": return typeof value === "string" && schema.values.includes(value);
+		case "handler": return isFnRef(value);
+		case "image": return typeof value === "string" && isAllowedImage(value, imageHosts);
+		case "link": return typeof value === "string" && isAllowedLink(value);
+		case "list": return typeof value === "object" && value !== null && "rows" in value && isRows(value.rows);
+		case "number": return typeof value === "number" && Number.isFinite(value) && (schema.min === void 0 || value >= schema.min) && (schema.max === void 0 || value <= schema.max);
+		case "string": return typeof value === "string" && value.length <= MAX_STRING;
+	}
+}
+/** Whether a prop named `name` with `value` may reach a component drawn with `schema`. */
+function acceptsProp(schema, name, value, imageHosts) {
+	const prop = Object.hasOwn(schema.props, name) ? schema.props[name] : void 0;
+	return prop !== void 0 && acceptsValue(prop, value, imageHosts);
+}
+//#endregion
+export { acceptsProp };