schema-components 2.0.1 → 2.1.0

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/uri.d.mts

@@ -33,8 +33,8 @@ declare function isSafeHyperlink(value: string): boolean;
  * the resulting `mailto:` URI. Refuse any value containing `%` to close
  * that header-injection vector. The plain email-format regex stays a
  * pure email-syntax check; the additional `%` filter lives here so other
- * callers of the format pattern (form validators, JSON Schema `format:
- * email` checks) are not affected.
+ * callers of the format pattern (form validators, JSON Schema
+ * `format: email` checks) are not affected.
  */
 declare function isSafeMailtoAddress(value: string): boolean;
 /**

package/dist/core/uri.mjs

@@ -70,8 +70,8 @@ function isSafeHyperlink(value) {
 * the resulting `mailto:` URI. Refuse any value containing `%` to close
 * that header-injection vector. The plain email-format regex stays a
 * pure email-syntax check; the additional `%` filter lives here so other
-* callers of the format pattern (form validators, JSON Schema `format:
-* email` checks) are not affected.
+* callers of the format pattern (form validators, JSON Schema
+* `format: email` checks) are not affected.
 */
 function isSafeMailtoAddress(value) {
 	if (value.includes("%")) return false;

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. */
@@ -115,7 +115,7 @@ declare function buildFileField(schema: Record<string, unknown>, ctx: WalkContex
  * cannot represent a JSON Schema and have no walk-time meaning.
  */
 declare function walkSubSchemaMap<T>(map: Record<string, unknown>, walkSubSchema: (schema: unknown, ctx: WalkContext) => T, ctx: WalkContext): Record<string, T>;
-/** Walk a dependentRequired map (Record<string, string[]>). */
+/** Walk a dependentRequired map (`Record<string, string[]>`). */
 declare function walkDependentRequiredMap(map: Record<string, unknown>): Record<string, string[]>;
 /**
  * Return a copy of the schema without the specified keys.

package/dist/core/walkBuilders.mjs

@@ -161,7 +161,7 @@ function walkSubSchemaMap(map, walkSubSchema, ctx) {
 	for (const [key, value] of Object.entries(map)) if (isObject(value) || typeof value === "boolean") result[key] = walkSubSchema(value, ctx);
 	return result;
 }
-/** Walk a dependentRequired map (Record<string, string[]>). */
+/** Walk a dependentRequired map (`Record<string, string[]>`). */
 function walkDependentRequiredMap(map) {
 	const result = {};
 	for (const [key, value] of Object.entries(map)) if (Array.isArray(value)) result[key] = value.filter((x) => typeof x === "string");

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/core/walker.mjs

@@ -47,9 +47,9 @@ function walkSubSchema(value, ctx) {
 * JSON Schema 2020-12 §11.2/§11.3 semantics:
 *
 *   false (forbid all extras)
-*     > schema-object (extras must match the schema)
-*     > true (extras explicitly permitted)
-*     > absent (extras implicitly permitted)
+*     \> schema-object (extras must match the schema)
+*     \> true (extras explicitly permitted)
+*     \> absent (extras implicitly permitted)
 *
 * Unknown shapes (numbers, arrays, strings) sort below absent — we
 * cannot reason about them, so do not let them override anything.

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/html.d.mts

@@ -12,16 +12,18 @@
  *
  * Usage:
  *
- *     import { h, serialize } from "./html.ts";
+ * ```ts
+ * import { h, serialize } from "./html.ts";
  *
- *     const el = h("input", { type: "text", id: "name", "aria-required": true });
- *     serialize(el); // → '<input type="text" id="name" aria-required>'
+ * const el = h("input", { type: "text", id: "name", "aria-required": true });
+ * serialize(el); // → '<input type="text" id="name" aria-required>'
  *
- *     const form = h("form", {},
- *         h("label", { for: "name" }, "Name"),
- *         h("input", { type: "text", id: "name" }),
- *     );
- *     serialize(form); // → '<form><label for="name">Name</label><input type="text" id="name"></form>'
+ * const form = h("form", {},
+ *     h("label", { for: "name" }, "Name"),
+ *     h("input", { type: "text", id: "name" }),
+ * );
+ * serialize(form); // → '<form><label for="name">Name</label><input type="text" id="name"></form>'
+ * ```
  */
 /**
  * An HTML element node. Void elements (input, br, etc.) have no children

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-PPXWJpbN.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";
@@ -18,14 +18,20 @@ import { defaultHtmlResolver } from "./renderers.mjs";
 * compile-time tag/attribute checking and automatic escaping.
 *
 * Usage:
-*   import { renderToHtml } from "schema-components/html/renderToHtml";
-*   const html = renderToHtml(userSchema, { value: userData });
+*
+* ```ts
+* import { renderToHtml } from "schema-components/html/renderToHtml";
+* const html = renderToHtml(userSchema, { value: userData });
+* ```
 *
 * Custom resolver:
-*   const html = renderToHtml(schema, {
-*     value,
-*     resolver: { string: (props) => h("b", {}, String(props.value)) },
-*   });
+*
+* ```ts
+* const html = renderToHtml(schema, {
+*   value,
+*   resolver: { string: (props) => h("b", {}, String(props.value)) },
+* });
+* ```
 */
 /**
 * Build the recursion-cap sentinel element used when the renderer
@@ -72,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-PPXWJpbN.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

package/dist/{inferValue-PPXWJpbN.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
@@ -46,9 +46,9 @@ type NarrowAtPath<V, P extends string | undefined> = P extends string ? TypeAtPa
  * Public alias mapping a schema input to the rendered value type.
  *
  * Picks the OUTPUT side (server → client) of every transform / pipe /
- * codec. For an `<SchemaComponent io="output">` or `<SchemaView
- * io="output">` (both defaults), this is the inferred shape of
- * `value` and the parameter of `onChange`.
+ * codec. For a `<SchemaComponent io="output">` or `<SchemaView io="output">`
+ * (both defaults), this is the inferred shape of `value` and the
+ * parameter of `onChange`.
  */
 type InferredOutputValue<T, Ref extends string | undefined = undefined, P extends string | undefined = undefined> = NarrowAtPath<InferSchemaValue<T, Ref, "output">, P>;
 /**

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 };