schema-components 2.0.2 → 2.1.1

package/dist/core/types.d.mts

@@ -1,2 +1,2 @@
-import { A as UnknownField, B as isNeverField, C as RecordField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isNumberField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as ObjectField, T as SchemaType, U as isObjectField, V as isNullField, W as isRecordField, Y as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as SchemaMeta, x as ObjectConstraints, y as NumberConstraints, z as isNegationField } from "../types-BrYbjC7_.mjs";
+import { A as UnknownField, B as isNeverField, C as RecordField, D as StringField, E as StringConstraints, F as isDiscriminatedUnionField, G as isStringField, H as isNumberField, I as isEnumField, J as isUnknownField, K as isTupleField, L as isFileField, M as isArrayField, N as isBooleanField, O as TupleField, P as isConditionalField, R as isLiteralField, S as ObjectField, T as SchemaType, U as isObjectField, V as isNullField, W as isRecordField, Y as resolveEditability, _ as NeverField, a as DiscriminatedUnionField, b as NumberField, c as FieldBase, d as FieldOverrides, f as FileConstraints, g as NegationField, h as LiteralField, i as ConditionalField, j as WalkedField, k as UnionField, l as FieldConstraints, m as JsonObject, n as ArrayField, o as Editability, p as FileField, q as isUnionField, r as BooleanField, s as EnumField, t as ArrayConstraints, u as FieldOverride, v as NullField, w as SchemaMeta, x as ObjectConstraints, y as NumberConstraints, z as isNegationField } from "../types-BBQaEPfE.mjs";
 export { ArrayConstraints, ArrayField, BooleanField, ConditionalField, DiscriminatedUnionField, Editability, EnumField, FieldBase, FieldConstraints, FieldOverride, FieldOverrides, FileConstraints, FileField, JsonObject, LiteralField, NegationField, NeverField, NullField, NumberConstraints, NumberField, ObjectConstraints, ObjectField, RecordField, SchemaMeta, SchemaType, StringConstraints, StringField, TupleField, UnionField, UnknownField, WalkedField, isArrayField, isBooleanField, isConditionalField, isDiscriminatedUnionField, isEnumField, isFileField, isLiteralField, isNegationField, isNeverField, isNullField, isNumberField, isObjectField, isRecordField, isStringField, isTupleField, isUnionField, isUnknownField, resolveEditability };

package/dist/core/unionMatch.d.mts

@@ -1,4 +1,4 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
 
 //#region src/core/unionMatch.d.ts
 /**

package/dist/core/version.d.mts

@@ -1,2 +1,2 @@
-import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-DL8U5RuA.mjs";
+import { a as detectJsonSchemaDraft, c as inferJsonSchemaDraftWithReason, d as isSwagger2, f as matchJsonSchemaDraftUri, i as OpenApiVersionInfo, l as isOpenApi30, n as JsonSchemaDialectInfo, o as detectOpenApiVersion, p as readJsonSchemaDialect, r as JsonSchemaDraft, s as inferJsonSchemaDraft, t as InferredDraft, u as isOpenApi31 } from "../version-BEBx10ND.mjs";
 export { InferredDraft, JsonSchemaDialectInfo, JsonSchemaDraft, OpenApiVersionInfo, detectJsonSchemaDraft, detectOpenApiVersion, inferJsonSchemaDraft, inferJsonSchemaDraftWithReason, isOpenApi30, isOpenApi31, isSwagger2, matchJsonSchemaDraftUri, readJsonSchemaDialect };

package/dist/core/walkBuilders.d.mts

@@ -1,6 +1,6 @@
-import { A as UnknownField, D as StringField, b as NumberField, c as FieldBase, d as FieldOverrides, j as WalkedField, o as Editability, p as FileField, r as BooleanField, v as NullField, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
-import { t as ExternalResolver } from "../ref-DdsbekXX.mjs";
+import { A as UnknownField, D as StringField, b as NumberField, c as FieldBase, d as FieldOverrides, j as WalkedField, o as Editability, p as FileField, r as BooleanField, v as NullField, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
+import { t as ExternalResolver } from "../ref-DWrQG1Er.mjs";
 
 //#region src/core/walkBuilders.d.ts
 /** Read a key from a JSON object, returning the value when it is a string and `undefined` otherwise. */

package/dist/core/walker.d.mts

@@ -1,4 +1,4 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
 import { WalkOptions } from "./walkBuilders.mjs";
 
 //#region src/core/walker.d.ts

package/dist/{errors-Dki7tji4.d.mts → errors-DbaI04x2.d.mts}

@@ -1,4 +1,4 @@
-import { T as SchemaType } from "./types-BrYbjC7_.mjs";
+import { T as SchemaType } from "./types-BBQaEPfE.mjs";
 
 //#region src/core/errors.d.ts
 /**

package/dist/html/a11y.d.mts

@@ -1,5 +1,5 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
-import { AllConstraints } from "../core/renderer.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { t as AllConstraints } from "../renderer-ab9E52Bp.mjs";
 import { constraintHint } from "../core/constraintHint.mjs";
 import { HtmlAttributes, HtmlNode } from "./html.mjs";
 

package/dist/html/renderToHtml.d.mts

@@ -1,8 +1,8 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { SchemaIoSide } from "../core/adapter.mjs";
-import { HtmlResolver } from "../core/renderer.mjs";
-import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
+import { s as HtmlResolver } from "../renderer-ab9E52Bp.mjs";
+import { f as RejectUnrepresentableZod } from "../typeInference-Y8tNEQJk.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
 
 //#region src/html/renderToHtml.d.ts
 /**

package/dist/html/renderToHtml.mjs

@@ -1,6 +1,6 @@
 import { toRecordOrUndefined } from "../core/guards.mjs";
-import "../core/limits.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
+import { dispatchRenderField } from "../core/renderField.mjs";
 import { getHtmlRenderFn, mergeHtmlResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
 import { h, serialize } from "./html.mjs";
@@ -78,31 +78,46 @@ function renderToHtml(schema, options = {}) {
 	});
 	const resolver = options.resolver ?? defaultHtmlResolver;
 	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, pathSuffix) => {
-		if (currentDepth >= 10) return recursionSentinelHtml(typeof childTree.meta.description === "string" ? childTree.meta.description : "schema");
 		const childPath = joinPath(parentPath, pathSuffix);
-		return renderFieldHtml(childTree, childValue, resolver, childPath, makeRenderChild(currentDepth + 1, childPath));
+		return renderFieldHtml(childTree, childValue, resolver, childPath, makeRenderChild(currentDepth + 1, childPath), currentDepth + 1);
 	};
 	const renderChild = makeRenderChild(0, "");
-	return renderFieldHtml(tree, options.value ?? tree.defaultValue, resolver, "", renderChild);
+	return renderFieldHtml(tree, options.value ?? tree.defaultValue, resolver, "", renderChild, 0);
 }
-function renderFieldHtml(tree, value, resolver, path, renderChild) {
+function renderFieldHtml(tree, value, resolver, path, renderChild, depth = 0) {
 	if (tree.meta.visible === false) return "";
 	const effectiveValue = value ?? tree.defaultValue;
-	const mergedResolver = mergeHtmlResolvers(resolver, defaultHtmlResolver);
-	const renderFn = getHtmlRenderFn(tree.type, mergedResolver);
-	if (renderFn === void 0) throw new Error(`renderToHtml: no HTML renderer registered for type "${tree.type}"`);
-	const props = {
+	return dispatchRenderField({
+		tree,
 		value: effectiveValue,
-		readOnly: tree.editability === "presentation",
-		writeOnly: tree.editability === "input",
-		meta: tree.meta,
-		constraints: tree.constraints,
 		path,
-		tree,
-		renderChild
-	};
-	if (tree.examples !== void 0) props.examples = tree.examples;
-	return renderFn(props);
+		depth,
+		resolver: mergeHtmlResolvers(resolver, defaultHtmlResolver),
+		config: {
+			buildProps: (fieldTree, fieldPath) => {
+				const props = {
+					value: effectiveValue,
+					readOnly: fieldTree.editability === "presentation",
+					writeOnly: fieldTree.editability === "input",
+					meta: fieldTree.meta,
+					constraints: fieldTree.constraints,
+					path: fieldPath,
+					tree: fieldTree,
+					renderChild
+				};
+				if (fieldTree.examples !== void 0) props.examples = fieldTree.examples;
+				return props;
+			},
+			lookupRenderFn: (type, htmlResolver) => getHtmlRenderFn(type, htmlResolver),
+			recursionSentinel: (fieldTree) => {
+				return recursionSentinelHtml(typeof fieldTree.meta.description === "string" ? fieldTree.meta.description : "schema");
+			},
+			fallback: (fieldTree) => {
+				throw new Error(`renderToHtml: no HTML renderer registered for type "${fieldTree.type}"`);
+			},
+			coerceResult: (result) => typeof result === "string" ? result : void 0
+		}
+	});
 }
 //#endregion
 export { recursionSentinelHtml, renderToHtml };

package/dist/html/renderToHtmlStream.d.mts

@@ -1,8 +1,8 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { SchemaIoSide } from "../core/adapter.mjs";
-import { HtmlResolver } from "../core/renderer.mjs";
-import { RejectUnrepresentableZod } from "../core/typeInference.mjs";
-import { a as InferredValue, t as InferFields } from "../inferValue-Ce-PviSD.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
+import { s as HtmlResolver } from "../renderer-ab9E52Bp.mjs";
+import { f as RejectUnrepresentableZod } from "../typeInference-Y8tNEQJk.mjs";
+import { a as InferredValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 /**

package/dist/html/renderers.d.mts

@@ -1,4 +1,4 @@
-import { HtmlResolver } from "../core/renderer.mjs";
+import { s as HtmlResolver } from "../renderer-ab9E52Bp.mjs";
 import { dateInputType } from "../core/formats.mjs";
 import { matchUnionOption } from "../core/unionMatch.mjs";
 

package/dist/html/streamRenderers.d.mts

@@ -1,6 +1,6 @@
-import { j as WalkedField } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
-import { HtmlResolver } from "../core/renderer.mjs";
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
+import { s as HtmlResolver } from "../renderer-ab9E52Bp.mjs";
 import { HtmlElement } from "./html.mjs";
 
 //#region src/html/streamRenderers.d.ts
@@ -19,10 +19,19 @@ declare function yieldClose(el: HtmlElement): string;
 /**
  * Render a leaf {@link WalkedField} entirely as a single HTML chunk.
  * Used inside the streaming generators when descent into containers is
- * complete. Falls back to a `<span>`-wrapped value when no renderer is
- * registered for the field type.
+ * complete.
+ *
+ * Delegates to the framework-agnostic {@link dispatchRenderField}
+ * dispatcher so resolver lookup, the (unused) widget step, error
+ * wrapping, and the unresolved-type fallback share one implementation
+ * with the sync HTML renderer and the React adapter.
+ *
+ * @param depth - Current recursion depth — defaults to `0` so the
+ *   public signature stays additive. Callers inside the streaming
+ *   pipeline thread the live `currentDepth` so the dispatcher's
+ *   internal depth check is consistent with the streamField gate.
  */
-declare function renderLeaf(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string): string;
+declare function renderLeaf(tree: WalkedField, value: unknown, mergedResolver: HtmlResolver, path: string, depth?: number): string;
 /**
  * Drain {@link streamField} into a single string. Used when a streamed
  * sub-tree needs to be embedded inside a non-streaming chunk (e.g. as

package/dist/html/streamRenderers.mjs

@@ -3,6 +3,7 @@ import "../core/limits.mjs";
 import { emitDiagnostic } from "../core/diagnostics.mjs";
 import { SC_CLASSES } from "../core/cssClasses.mjs";
 import { panelIdFor, tabIdFor } from "../core/idPath.mjs";
+import { dispatchRenderField } from "../core/renderField.mjs";
 import { getHtmlRenderFn } from "../core/renderer.mjs";
 import { matchUnionOption, resolveDiscriminatedActive } from "../core/unionMatch.mjs";
 import { VOID_ELEMENTS, h, raw, serialize, serializeAttributes } from "./html.mjs";
@@ -29,14 +30,15 @@ function yieldClose(el) {
 	return `</${el.tag}>`;
 }
 /**
-* Render a leaf {@link WalkedField} entirely as a single HTML chunk.
-* Used inside the streaming generators when descent into containers is
-* complete. Falls back to a `<span>`-wrapped value when no renderer is
-* registered for the field type.
+* Build the per-leaf {@link HtmlRenderProps} bundle handed to resolver
+* render functions and (in future) to widget renderers. The streaming
+* pipeline never recurses through `renderChild` for leaves — container
+* recursion happens through the streamField generators — so the
+* supplied `renderChild` is the constant `() => ""` stub matching the
+* historic streaming-leaf shape.
 */
-function renderLeaf(tree, value, mergedResolver, path) {
-	const renderFn = getHtmlRenderFn(tree.type, mergedResolver);
-	if (renderFn !== void 0) return renderFn({
+function buildLeafProps(tree, value, path) {
+	const props = {
 		value,
 		readOnly: tree.editability === "presentation",
 		writeOnly: tree.editability === "input",
@@ -45,11 +47,55 @@ function renderLeaf(tree, value, mergedResolver, path) {
 		path,
 		tree,
 		renderChild: () => ""
-	});
+	};
+	if (tree.examples !== void 0) props.examples = tree.examples;
+	return props;
+}
+/**
+* Build the streaming-friendly placeholder a {@link dispatchRenderField}
+* fallback emits when no resolver handled the leaf type. The sync HTML
+* dispatcher throws in this position — streaming must keep producing
+* output, so the streaming adapter renders the same `<span>` shape
+* `renderLeaf` historically produced for unresolved types.
+*/
+function leafFallbackHtml(value) {
 	if (value === void 0 || value === null) return serialize(h("span", { class: SC_CLASSES.valueEmpty }, "—"));
 	return serialize(h("span", { class: SC_CLASSES.value }, typeof value === "string" ? value : JSON.stringify(value)));
 }
 /**
+* Render a leaf {@link WalkedField} entirely as a single HTML chunk.
+* Used inside the streaming generators when descent into containers is
+* complete.
+*
+* Delegates to the framework-agnostic {@link dispatchRenderField}
+* dispatcher so resolver lookup, the (unused) widget step, error
+* wrapping, and the unresolved-type fallback share one implementation
+* with the sync HTML renderer and the React adapter.
+*
+* @param depth - Current recursion depth — defaults to `0` so the
+*   public signature stays additive. Callers inside the streaming
+*   pipeline thread the live `currentDepth` so the dispatcher's
+*   internal depth check is consistent with the streamField gate.
+*/
+function renderLeaf(tree, value, mergedResolver, path, depth = 0) {
+	return dispatchRenderField({
+		tree,
+		value,
+		path,
+		depth,
+		resolver: mergedResolver,
+		config: {
+			buildProps: (fieldTree, fieldPath) => buildLeafProps(fieldTree, value, fieldPath),
+			lookupRenderFn: (type, htmlResolver) => getHtmlRenderFn(type, htmlResolver),
+			recursionSentinel: (fieldTree) => {
+				return recursionSentinelHtml(typeof fieldTree.meta.description === "string" ? fieldTree.meta.description : "schema");
+			},
+			fallback: (_fieldTree, fieldValue) => leafFallbackHtml(fieldValue),
+			coerceResult: (result) => typeof result === "string" ? result : void 0
+		}
+	});
+}
+/**
 * Drain {@link streamField} into a single string. Used when a streamed
 * sub-tree needs to be embedded inside a non-streaming chunk (e.g. as
 * children of a parent element).
@@ -87,7 +133,7 @@ function* streamField(tree, value, mergedResolver, path, rawResolver, currentDep
 	const effectiveValue = value ?? tree.defaultValue;
 	const type = tree.type;
 	if (type === "string" || type === "number" || type === "boolean" || type === "enum" || type === "literal" || type === "file" || type === "unknown") {
-		yield renderLeaf(tree, effectiveValue, mergedResolver, path);
+		yield renderLeaf(tree, effectiveValue, mergedResolver, path, currentDepth);
 		return;
 	}
 	if (type === "union") {
@@ -110,7 +156,7 @@ function* streamField(tree, value, mergedResolver, path, rawResolver, currentDep
 		yield* streamRecord(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
-	yield renderLeaf(tree, value, mergedResolver, path);
+	yield renderLeaf(tree, value, mergedResolver, path, currentDepth);
 }
 function* streamObject(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
 	if (tree.type !== "object") return;

package/dist/{inferValue-Ce-PviSD.d.mts → inferValue-eAnh50EM.d.mts}

@@ -1,6 +1,6 @@
-import { d as FieldOverrides, u as FieldOverride } from "./types-BrYbjC7_.mjs";
-import { SchemaIoSide } from "./core/adapter.mjs";
-import { FromJSONSchema, FromJSONSchemaMode, IsSwagger2Doc, ResolveOpenAPIRef, TypeAtPath, __SchemaInferenceFellBack } from "./core/typeInference.mjs";
+import { d as FieldOverrides, u as FieldOverride } from "./types-BBQaEPfE.mjs";
+import { r as SchemaIoSide } from "./adapter-ktQaheWB.mjs";
+import { c as IsSwagger2Doc, i as FromJSONSchemaMode, m as TypeAtPath, p as ResolveOpenAPIRef, r as FromJSONSchema, v as __SchemaInferenceFellBack } from "./typeInference-Y8tNEQJk.mjs";
 import { z } from "zod";
 
 //#region src/core/inferValue.d.ts

package/dist/lit/SchemaComponent.d.mts

@@ -0,0 +1,125 @@
+import { j as WalkedField, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { t as Diagnostic } from "../diagnostics-mftUZI7c.mjs";
+import { r as SchemaIoSide } from "../adapter-ktQaheWB.mjs";
+import { r as LitRenderProps, t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
+import { LitElement, TemplateResult } from "lit";
+
+//#region src/lit/SchemaComponent.d.ts
+/**
+ * Public change-event detail emitted on the top-level `<schema-component>`.
+ *
+ * The `value` payload carries the updated root value as returned by
+ * the user's most recent edit. Consumers wire this into their
+ * framework's binding system — React via `addEventListener` on the
+ * canonical `change` event, Vue via a `@change` directive, Svelte
+ * via `on:change`. The detail object always carries a single
+ * `value` field with the post-edit root value.
+ */
+interface SchemaChangeEventDetail {
+  value: unknown;
+}
+/**
+ * Lit Custom Element for editable schema-driven UI.
+ *
+ * Tag: `<schema-component>` (default) or `<{prefix}schema-component>`
+ * (when `registerSchemaComponents(prefix)` is called).
+ *
+ * **Required:** call {@link registerSchemaComponents} once at module
+ * setup before instantiating this element in HTML markup, otherwise
+ * none of the per-type `<sc-*>` children will upgrade and the tree
+ * will render as unknown elements.
+ */
+declare class SchemaComponent extends LitElement {
+  /**
+   * Element property declarations.
+   *
+   * All four "data" properties (`schema`, `value`, `resolver`,
+   * `widgets`) carry `attribute: false`: Custom Element attributes
+   * are strings, and these payloads (an arbitrary Zod schema, an
+   * arbitrary JS value, a resolver function map, a widget tag map)
+   * cannot round-trip through attribute serialisation. Set them via
+   * direct property assignment.
+   *
+   * `readOnly` is a boolean attribute (and reflects to DOM) so the
+   * common "render read-only view" case is reachable from plain
+   * HTML markup (`<schema-component readonly></schema-component>`).
+   * The capitalisation is `readOnly` on the property and `readonly`
+   * on the attribute — matching the HTML `readonly` attribute on
+   * `<input>` / `<textarea>`.
+   */
+  static readonly properties: {
+    schema: {
+      attribute: boolean;
+    };
+    value: {
+      attribute: boolean;
+    };
+    resolver: {
+      attribute: boolean;
+    };
+    widgets: {
+      attribute: boolean;
+    };
+    fields: {
+      attribute: boolean;
+    };
+    meta: {
+      attribute: boolean;
+    };
+    ref: {
+      attribute: boolean;
+    };
+    io: {
+      attribute: boolean;
+    };
+    idPrefix: {
+      attribute: boolean;
+    };
+    onDiagnostic: {
+      attribute: boolean;
+    };
+    readOnly: {
+      type: BooleanConstructor;
+      reflect: boolean;
+      attribute: string;
+    };
+    strict: {
+      type: BooleanConstructor;
+    };
+  };
+  /**
+   * Reactive property declarations. Each field is declared with
+   * `declare` (no runtime emit) so Lit's `static properties`
+   * accessors are not shadowed by class-field initialisers. Default
+   * values are seeded in the constructor.
+   */
+  schema: unknown;
+  ref: string | undefined;
+  io: SchemaIoSide | undefined;
+  value: unknown;
+  resolver: LitComponentResolver | undefined;
+  widgets: ReadonlyMap<string, string> | undefined;
+  fields: Record<string, unknown> | undefined;
+  meta: SchemaMeta | undefined;
+  idPrefix: string | undefined;
+  readOnly: boolean;
+  strict: boolean;
+  onDiagnostic: ((diagnostic: Diagnostic) => void) | undefined;
+  constructor();
+  render(): TemplateResult;
+  /**
+   * Build the recursive `renderChild` closure threaded through every
+   * container renderer.
+   */
+  protected makeRenderChild(currentDepth: number, parentPath: string, userResolver: LitComponentResolver): LitRenderProps["renderChild"];
+  /**
+   * Dispatch a single walked field through the resolver, widget
+   * registry, and recursion limit. Parallel to
+   * `renderField` in `react/SchemaComponent.tsx`.
+   */
+  protected renderField(tree: WalkedField, value: unknown, change: (next: unknown) => void, userResolver: LitComponentResolver, renderChild: LitRenderProps["renderChild"], path: string): TemplateResult;
+  private applyWidgetProperties;
+  private buildDiagnostics;
+}
+//#endregion
+export { SchemaChangeEventDetail, SchemaComponent };

package/dist/lit/SchemaComponent.mjs

@@ -0,0 +1,2 @@
+import { t as SchemaComponent } from "../SchemaComponent-BxzzsHsK.mjs";
+export { SchemaComponent };

package/dist/lit/SchemaField.d.mts

@@ -0,0 +1,65 @@
+import { SchemaComponent } from "./SchemaComponent.mjs";
+import { TemplateResult } from "lit";
+
+//#region src/lit/SchemaField.d.ts
+/**
+ * Lit Custom Element rendering a single sub-field of a schema.
+ *
+ * Tag: `<schema-field>` (registered by `registerSchemaComponents`).
+ */
+declare class SchemaField extends SchemaComponent {
+  /**
+   * Dot-separated path identifying the field to render
+   * (e.g. `"address.city"` or `"tags[0]"`). Declared via `declare`
+   * so Lit's accessor (installed by the static `properties` table)
+   * is not shadowed by a class-field initialiser.
+   */
+  path: string;
+  static readonly properties: {
+    path: {
+      attribute: boolean;
+    };
+    schema: {
+      attribute: boolean;
+    };
+    value: {
+      attribute: boolean;
+    };
+    resolver: {
+      attribute: boolean;
+    };
+    widgets: {
+      attribute: boolean;
+    };
+    fields: {
+      attribute: boolean;
+    };
+    meta: {
+      attribute: boolean;
+    };
+    ref: {
+      attribute: boolean;
+    };
+    io: {
+      attribute: boolean;
+    };
+    idPrefix: {
+      attribute: boolean;
+    };
+    onDiagnostic: {
+      attribute: boolean;
+    };
+    readOnly: {
+      type: BooleanConstructor;
+      reflect: boolean;
+      attribute: string;
+    };
+    strict: {
+      type: BooleanConstructor;
+    };
+  };
+  constructor();
+  render(): TemplateResult;
+}
+//#endregion
+export { SchemaField };

package/dist/lit/SchemaField.mjs

@@ -0,0 +1,2 @@
+import { o as SchemaField } from "../SchemaComponent-BxzzsHsK.mjs";
+export { SchemaField };

package/dist/lit/SchemaView.d.mts

@@ -0,0 +1,14 @@
+import { SchemaComponent } from "./SchemaComponent.mjs";
+
+//#region src/lit/SchemaView.d.ts
+/**
+ * Lit Custom Element rendering a schema in read-only mode.
+ *
+ * Tag: `<schema-view>` (registered by `registerSchemaComponents`).
+ */
+declare class SchemaView extends SchemaComponent {
+  constructor();
+  connectedCallback(): void;
+}
+//#endregion
+export { SchemaView };

package/dist/lit/SchemaView.mjs

@@ -0,0 +1,2 @@
+import { s as SchemaView } from "../SchemaComponent-BxzzsHsK.mjs";
+export { SchemaView };

package/dist/lit/constructorTypes.d.mts

@@ -0,0 +1,2 @@
+import { t as Constructor } from "../constructorTypes-BdCiMS6e.mjs";
+export { Constructor };

package/dist/lit/constructorTypes.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lit/contexts.d.mts

@@ -0,0 +1,78 @@
+import { ContextPort } from "../core/contexts.mjs";
+import { t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
+import { ReactiveControllerHost, ReactiveElement } from "lit";
+
+//#region src/lit/contexts.d.ts
+/**
+ * Context key identifying the {@link LitComponentResolver} provided at
+ * a host element. Re-used by every built-in `<sc-*>` Custom Element so
+ * a single `<schema-component>` provider seeds the whole subtree —
+ * matching the behaviour of `<SchemaProvider>` on the React side.
+ *
+ * The literal `"sc-resolver"` value is the runtime key carried in the
+ * Context Protocol's `context-request` event; consumers and providers
+ * must use the same `Context` object (not just the same string) to
+ * match, which is why this is exported rather than redeclared per
+ * element.
+ */
+declare const resolverContext: {
+  __context__: LitComponentResolver;
+};
+/**
+ * Lit binding wrapping `ContextProvider` / `ContextConsumer` from
+ * `@lit/context` for the {@link resolverContext}.
+ *
+ * The port is host-scoped — both `provide` and `consume` require a
+ * `ReactiveControllerHost` reference so `@lit/context` can register
+ * its controllers on the element's lifecycle. This is unavoidable
+ * given Lit's reactive update model and is the reason the Lit port
+ * does not match the canonical {@link ContextPort} signature in
+ * `core/contexts.ts` directly — see this module's docstring for the
+ * rationale.
+ */
+declare const resolverContextPort: {
+  provide(host: ReactiveControllerHost & ReactiveElement, value: LitComponentResolver): {
+    setValue: (value: LitComponentResolver) => void;
+  };
+  consume(host: ReactiveControllerHost & ReactiveElement): {
+    readonly value?: LitComponentResolver;
+  };
+};
+/**
+ * Widget map — name → custom element tag.
+ *
+ * Where the React adapter's `WidgetMap` is `ReadonlyMap<string, RenderFunction>`
+ * (a function value per hint name), the Lit adapter resolves widgets by
+ * Custom Element tag name. A schema field carrying
+ * `.meta({ component: "color-picker" })` looks up `widgets.get("color-picker")`
+ * and renders the matching tag — preserving the Web-Components-native
+ * pattern where every renderer override IS a Custom Element.
+ *
+ * Tags must be registered via `customElements.define` before they can
+ * be rendered. Unregistered tags surface as unknown elements with no
+ * upgrade — matching the browser's behaviour rather than throwing.
+ */
+type LitWidgetMap = ReadonlyMap<string, string>;
+/**
+ * Context key for {@link LitWidgetMap}.
+ */
+declare const widgetsContext: {
+  __context__: LitWidgetMap;
+};
+/**
+ * Lit binding wrapping `ContextProvider` / `ContextConsumer` from
+ * `@lit/context` for the {@link widgetsContext}. Parallel to
+ * {@link resolverContextPort}; see that export for the rationale on
+ * why the Lit port is host-scoped rather than matching the canonical
+ * {@link ContextPort} signature directly.
+ */
+declare const widgetsContextPort: {
+  provide(host: ReactiveControllerHost & ReactiveElement, value: LitWidgetMap): {
+    setValue: (value: LitWidgetMap) => void;
+  };
+  consume(host: ReactiveControllerHost & ReactiveElement): {
+    readonly value?: LitWidgetMap;
+  };
+};
+//#endregion
+export { type ContextPort, LitWidgetMap, resolverContext, resolverContextPort, widgetsContext, widgetsContextPort };