schema-components 2.0.2 → 2.1.0

package/dist/lit/contexts.mjs

@@ -0,0 +1,238 @@
+//#region ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/context-request-event.js
+/**
+* @license
+* Copyright 2021 Google LLC
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+var s$2 = class extends Event {
+	constructor(s, t, e, o) {
+		super("context-request", {
+			bubbles: !0,
+			composed: !0
+		}), this.context = s, this.contextTarget = t, this.callback = e, this.subscribe = o ?? !1;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/create-context.js
+/**
+* @license
+* Copyright 2021 Google LLC
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+function n(n) {
+	return n;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/controllers/context-consumer.js
+/**
+* @license
+* Copyright 2021 Google LLC
+* SPDX-License-Identifier: BSD-3-Clause
+*/ var s$1 = class {
+	constructor(t, s, i, h) {
+		if (this.subscribe = !1, this.provided = !1, this.value = void 0, this.t = (t, s) => {
+			this.unsubscribe && (this.unsubscribe !== s && (this.provided = !1, this.unsubscribe()), this.subscribe || this.unsubscribe()), this.value = t, this.host.requestUpdate(), this.provided && !this.subscribe || (this.provided = !0, this.callback && this.callback(t, s)), this.unsubscribe = s;
+		}, this.host = t, void 0 !== s.context) {
+			const t = s;
+			this.context = t.context, this.callback = t.callback, this.subscribe = t.subscribe ?? !1;
+		} else this.context = s, this.callback = i, this.subscribe = h ?? !1;
+		this.host.addController(this);
+	}
+	hostConnected() {
+		this.dispatchRequest();
+	}
+	hostDisconnected() {
+		this.unsubscribe && (this.unsubscribe(), this.unsubscribe = void 0);
+	}
+	dispatchRequest() {
+		this.host.dispatchEvent(new s$2(this.context, this.host, this.t, this.subscribe));
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/value-notifier.js
+/**
+* @license
+* Copyright 2021 Google LLC
+* SPDX-License-Identifier: BSD-3-Clause
+*/
+var s = class {
+	get value() {
+		return this.o;
+	}
+	set value(s) {
+		this.setValue(s);
+	}
+	setValue(s, t = !1) {
+		const i = t || !Object.is(s, this.o);
+		this.o = s, i && this.updateObservers();
+	}
+	constructor(s) {
+		this.subscriptions = /* @__PURE__ */ new Map(), this.updateObservers = () => {
+			for (const [s, { disposer: t }] of this.subscriptions) s(this.o, t);
+		}, void 0 !== s && (this.value = s);
+	}
+	addCallback(s, t, i) {
+		if (!i) return void s(this.value);
+		this.subscriptions.has(s) || this.subscriptions.set(s, {
+			disposer: () => {
+				this.subscriptions.delete(s);
+			},
+			consumerHost: t
+		});
+		const { disposer: h } = this.subscriptions.get(s);
+		s(this.value, h);
+	}
+	clearCallbacks() {
+		this.subscriptions.clear();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@lit+context@1.1.6/node_modules/@lit/context/lib/controllers/context-provider.js
+/**
+* @license
+* Copyright 2021 Google LLC
+* SPDX-License-Identifier: BSD-3-Clause
+*/ var e = class extends Event {
+	constructor(t, s) {
+		super("context-provider", {
+			bubbles: !0,
+			composed: !0
+		}), this.context = t, this.contextTarget = s;
+	}
+};
+var i = class extends s {
+	constructor(s, e, i) {
+		super(void 0 !== e.context ? e.initialValue : i), this.onContextRequest = (t) => {
+			if (t.context !== this.context) return;
+			const s = t.contextTarget ?? t.composedPath()[0];
+			s !== this.host && (t.stopPropagation(), this.addCallback(t.callback, s, t.subscribe));
+		}, this.onProviderRequest = (s) => {
+			if (s.context !== this.context) return;
+			if ((s.contextTarget ?? s.composedPath()[0]) === this.host) return;
+			const e = /* @__PURE__ */ new Set();
+			for (const [s, { consumerHost: i }] of this.subscriptions) e.has(s) || (e.add(s), i.dispatchEvent(new s$2(this.context, i, s, !0)));
+			s.stopPropagation();
+		}, this.host = s, void 0 !== e.context ? this.context = e.context : this.context = e, this.attachListeners(), this.host.addController?.(this);
+	}
+	attachListeners() {
+		this.host.addEventListener("context-request", this.onContextRequest), this.host.addEventListener("context-provider", this.onProviderRequest);
+	}
+	hostConnected() {
+		this.host.dispatchEvent(new e(this.context, this.host));
+	}
+};
+//#endregion
+//#region src/lit/contexts.ts
+/**
+* Context ports for the Lit adapter.
+*
+* Implements the `ContextPort<T>` abstraction described in the
+* multi-framework research note. The port is the framework-agnostic
+* contract for "provide a value at a parent and consume it at any
+* descendant" — every framework adapter (React `createContext`, Vue
+* `provide`/`inject`, Svelte `setContext`/`getContext`, Lit
+* `@lit/context`) wires the same shape into its native primitive so
+* the core renderer dispatch loop never reaches for a framework-
+* specific API.
+*
+* For Lit, the port is implemented on top of
+* [`@lit/context`](https://lit.dev/docs/data/context/), which uses the
+* proposed [Context Protocol](https://github.com/webcomponents/community-protocols/blob/main/proposals/context.md)
+* — DOM events bubble up from a consumer until a provider catches them
+* and seeds the consumer with the requested value. The protocol is
+* synchronous, DOM-scoped, and runs only in the browser.
+*
+* **SSR caveat.** `@lit/context` does NOT server-render. The Lit SSR
+* package (`@lit-labs/ssr`) emits Custom Element markup without firing
+* the consumer-side context request events, so any value provided via
+* a `ContextPort` is `undefined` on the server. Consumers must default
+* gracefully — the built-in Lit renderers fall back to the default
+* resolver when the resolver context is unset, matching their browser
+* behaviour when no consumer wraps the schema element.
+*
+* **Canonical {@link ContextPort} compatibility.** The canonical
+* {@link ContextPort} interface declared in `core/contexts.ts` is
+* deliberately host-agnostic: `provide(value, children): unknown` and
+* `consume(): T`. Lit's `@lit/context` requires a `ReactiveControllerHost`
+* at every call site to register provider / consumer controllers, so
+* the Lit ports below cannot match the canonical signature directly.
+* Rather than declaring a parallel local `ContextPort<T>` (which would
+* shadow the canonical type), the Lit adapter exports the port objects
+* with inferred local types and re-exports the canonical
+* {@link ContextPort} so consumers retain a single source of truth for
+* the type name.
+*
+* @packageDocumentation
+*/
+/**
+* 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.
+*/
+const resolverContext = n(Symbol.for("sc-resolver"));
+/**
+* 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.
+*/
+const resolverContextPort = {
+	provide(host, value) {
+		const controller = new i(host, {
+			context: resolverContext,
+			initialValue: value
+		});
+		return { setValue(next) {
+			controller.setValue(next);
+		} };
+	},
+	consume(host) {
+		return new s$1(host, {
+			context: resolverContext,
+			subscribe: true
+		});
+	}
+};
+/**
+* Context key for {@link LitWidgetMap}.
+*/
+const widgetsContext = n(Symbol.for("sc-widgets"));
+/**
+* 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.
+*/
+const widgetsContextPort = {
+	provide(host, value) {
+		const controller = new i(host, {
+			context: widgetsContext,
+			initialValue: value
+		});
+		return { setValue(next) {
+			controller.setValue(next);
+		} };
+	},
+	consume(host) {
+		return new s$1(host, {
+			context: widgetsContext,
+			subscribe: true
+		});
+	}
+};
+//#endregion
+export { resolverContext, resolverContextPort, widgetsContext, widgetsContextPort };

package/dist/lit/defaultResolver.d.mts

@@ -0,0 +1,33 @@
+import { j as WalkedField } from "../types-BBQaEPfE.mjs";
+import { t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
+import { RegistrationResult } from "./registry.mjs";
+
+//#region src/lit/defaultResolver.d.ts
+/**
+ * Map of every `WalkedField.type` to its matching canonical `<sc-*>`
+ * tag. Exhaustive over the discriminated union — adding a new variant
+ * to the walker forces a deliberate update here.
+ *
+ * Exported so theme adapters can introspect the mapping when building
+ * their own resolvers (e.g. a shadcn-flavoured Web Components theme
+ * that wraps `<sc-string>` in a `<sl-input>`-style shell).
+ */
+declare const TYPE_TO_CANONICAL_TAG: Readonly<Record<WalkedField["type"], string>>;
+/**
+ * Build the default Lit resolver for the supplied
+ * {@link RegistrationResult}.
+ *
+ * Each render function emits a Lit `html` template whose body is a
+ * dynamically-created `<sc-*>` element with every field prop assigned.
+ * The change callback is forwarded directly so user input on a leaf
+ * renderer reaches the orchestrator without going through a Custom
+ * Event boundary on the fast path.
+ *
+ * When no `registration` is supplied, the resolver emits the
+ * canonical `sc-*` tags. Useful in tests where `customElements.define`
+ * may have been called separately and the consumer doesn't need a
+ * prefixed registration object.
+ */
+declare function createDefaultLitResolver(registration?: RegistrationResult): LitComponentResolver;
+//#endregion
+export { TYPE_TO_CANONICAL_TAG, createDefaultLitResolver };

package/dist/lit/defaultResolver.mjs

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

package/dist/lit/registry.d.mts

@@ -0,0 +1,66 @@
+import { t as Constructor } from "../constructorTypes-BdCiMS6e.mjs";
+
+//#region src/lit/registry.d.ts
+/**
+ * Mapping from the canonical built-in tag (without prefix) to the
+ * `BaseScElement` subclass that backs it. Exported so consumers can
+ * introspect what {@link registerSchemaComponents} will register —
+ * useful for diagnostics and for building documentation surfaces.
+ *
+ * The top-level orchestrator elements (`schema-component`,
+ * `schema-view`, `schema-field`) are listed alongside the per-type
+ * `<sc-*>` elements; the structural type relaxes to `HTMLElement` so
+ * every constructor is assignable.
+ */
+declare const BUILT_IN_ELEMENTS: Readonly<Record<string, Constructor<HTMLElement>>>;
+/**
+ * Register every built-in `<sc-*>` Custom Element on the global
+ * `customElements` registry, optionally namespaced under `prefix`.
+ *
+ * Re-registering the same tag is a no-op — `customElements.get(tag)`
+ * is checked first so calling this function twice (or alongside
+ * another library that registered the same tag) does not throw.
+ *
+ * @param prefix - Optional prefix prepended to every built-in tag.
+ *   E.g. `registerSchemaComponents("myapp-")` registers
+ *   `<myapp-sc-string>`, `<myapp-sc-number>`, …, avoiding collisions
+ *   with another library that may have shipped its own `<sc-*>`
+ *   elements. Pass an empty string (the default) to use the
+ *   canonical names.
+ * @returns A {@link RegistrationResult} carrying the canonical-tag →
+ *   registered-tag map and the list of elements skipped because the
+ *   tag was already registered. The map is used by the default
+ *   resolver to look up the right tag when the consumer chose a
+ *   custom prefix.
+ *
+ * @example
+ * ```ts
+ * // Default registration — tags are <sc-string>, <sc-number>, ...
+ * import { registerSchemaComponents } from "schema-components/lit/registry";
+ * const tags = registerSchemaComponents();
+ *
+ * // Namespaced registration — tags are <myapp-sc-string>, ...
+ * const namespaced = registerSchemaComponents("myapp-");
+ * ```
+ */
+declare function registerSchemaComponents(prefix?: string): RegistrationResult;
+/**
+ * Return value of {@link registerSchemaComponents}.
+ *
+ * The `tags` map carries the canonical-tag → registered-tag mapping
+ * for every built-in element. The default Lit resolver reads this map
+ * to dispatch from a `WalkedField.type` to the matching Custom
+ * Element tag — see `lit/renderers/defaultResolver.ts`.
+ *
+ * The `skipped` array lists tags that were already registered (a
+ * second call to `registerSchemaComponents` with the same prefix, or
+ * a deliberate consumer-side registration that pre-empted the
+ * default). Skipped tags are NOT re-registered — the consumer's
+ * implementation wins.
+ */
+interface RegistrationResult {
+  tags: Readonly<Record<string, string>>;
+  skipped: readonly string[];
+}
+//#endregion
+export { BUILT_IN_ELEMENTS, RegistrationResult, registerSchemaComponents };

package/dist/lit/registry.mjs

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

package/dist/lit/renderers/baseElement.d.mts

@@ -0,0 +1,131 @@
+import { j as WalkedField, w as SchemaMeta } from "../../types-BBQaEPfE.mjs";
+import { t as AllConstraints } from "../../renderer-ab9E52Bp.mjs";
+import { r as LitRenderProps } from "../../types-BCy7K3nk.mjs";
+import { LitElement, TemplateResult } from "lit";
+
+//#region src/lit/renderers/baseElement.d.ts
+/**
+ * Detail payload emitted on the `sc-change` Custom Event.
+ *
+ * The event bubbles and is composed so cross-Shadow-DOM listeners
+ * (e.g. the orchestrating `<schema-component>` outside the child's
+ * shadow tree) receive it without breaking encapsulation.
+ */
+interface ScChangeEventDetail {
+  value: unknown;
+  /** Path of the field that produced the change. */
+  path: string;
+}
+/**
+ * Canonical Custom Event name emitted by every built-in `<sc-*>`
+ * element when its user-facing input changes.
+ *
+ * The orchestrating `<schema-component>` listens for this internal
+ * event, applies the resulting structural update to the root value,
+ * and re-emits a public `change` Custom Event on its own host so
+ * framework consumers observe a single, well-typed boundary event.
+ */
+declare const SC_CHANGE_EVENT = "sc-change";
+/**
+ * Base class for the built-in `<sc-*>` Custom Elements.
+ *
+ * Subclasses declare:
+ *
+ * 1. A `static properties` table extending `BaseScElement.properties`.
+ * 2. A `render()` method returning the per-type `TemplateResult`.
+ *
+ * The class deliberately does not implement `render()` itself — a
+ * `LitElement` without `render()` is still constructible, but its
+ * default behaviour is to render nothing. Subclasses are required to
+ * override.
+ */
+declare abstract class BaseScElement extends LitElement {
+  /**
+   * Property declarations shared by every built-in Custom Element.
+   *
+   * Subclasses spread this in:
+   *
+   * ```ts
+   * static override properties = {
+   *   ...BaseScElement.properties,
+   *   ...
+   * };
+   * ```
+   *
+   * Every shared property uses `attribute: false` — none of the
+   * payloads (`tree`, `value`, `meta`, `constraints`) round-trip
+   * safely through HTML attribute strings.
+   */
+  static readonly properties: {
+    tree: {
+      attribute: boolean;
+    };
+    value: {
+      attribute: boolean;
+    };
+    readOnly: {
+      attribute: boolean;
+    };
+    writeOnly: {
+      attribute: boolean;
+    };
+    path: {
+      attribute: boolean;
+    };
+    meta: {
+      attribute: boolean;
+    };
+    constraints: {
+      attribute: boolean;
+    };
+    examples: {
+      attribute: boolean;
+    };
+    change: {
+      attribute: boolean;
+    };
+    renderChild: {
+      attribute: boolean;
+    };
+  };
+  tree: WalkedField;
+  value: unknown;
+  readOnly: boolean;
+  writeOnly: boolean;
+  path: string;
+  meta: SchemaMeta;
+  constraints: AllConstraints;
+  examples?: unknown[];
+  change: (value: unknown) => void;
+  renderChild: LitRenderProps["renderChild"];
+  constructor();
+  /**
+   * Dispatch the canonical `sc-change` event. Renderers call this
+   * inside DOM event handlers (`@input`, `@change`, `@click` on
+   * add/remove controls) — the orchestrating ancestor catches the
+   * event, propagates the structural update to the root value, and
+   * re-emits a top-level `change` event on its own host.
+   */
+  protected emitChange(value: unknown): void;
+}
+/**
+ * Build a `renderChild` closure that delegates back to the
+ * orchestrating resolver dispatch. Container renderers (object, array,
+ * tuple, record, union, discriminatedUnion, conditional, negation)
+ * call this to recursively render their children without re-running
+ * the resolver dispatch loop themselves.
+ *
+ * The closure is stored on the parent's render props and forwarded to
+ * the resolver render function, mirroring the `renderChild` signatures
+ * on the React and HTML render-props (see `core/renderer.ts`).
+ */
+type LitRenderChild = LitRenderProps["renderChild"];
+/**
+ * Trivial pass-through helper used by renderers that need to emit a
+ * `nothing` placeholder rather than a full `TemplateResult`. Keeps the
+ * dispatch table strictly typed without forcing callers to import
+ * `nothing` from Lit.
+ */
+declare const emptyTemplate: () => TemplateResult;
+//#endregion
+export { BaseScElement, LitRenderChild, SC_CHANGE_EVENT, ScChangeEventDetail, emptyTemplate };

package/dist/lit/renderers/baseElement.mjs

@@ -0,0 +1,109 @@
+import { LitElement, html } from "lit";
+//#region src/lit/renderers/baseElement.ts
+/**
+* Shared base class for every built-in `<sc-*>` Custom Element.
+*
+* Centralises the per-field property declarations and a small helper
+* for dispatching the canonical `sc-change` Custom Event that wires
+* an internal change through to whichever ancestor element is
+* orchestrating value flow (typically `<schema-component>`).
+*
+* Every Custom Element on the Lit side reads the per-field data from
+* declarative properties — schemas, walked field trees, constraints,
+* and example arrays cannot be safely serialised through HTML
+* attributes, so the declarations use `attribute: false`. This is the
+* single largest difference from the React adapter, where the same
+* data flows through component props.
+*
+* @packageDocumentation
+*/
+/**
+* Canonical Custom Event name emitted by every built-in `<sc-*>`
+* element when its user-facing input changes.
+*
+* The orchestrating `<schema-component>` listens for this internal
+* event, applies the resulting structural update to the root value,
+* and re-emits a public `change` Custom Event on its own host so
+* framework consumers observe a single, well-typed boundary event.
+*/
+const SC_CHANGE_EVENT = "sc-change";
+/**
+* Base class for the built-in `<sc-*>` Custom Elements.
+*
+* Subclasses declare:
+*
+* 1. A `static properties` table extending `BaseScElement.properties`.
+* 2. A `render()` method returning the per-type `TemplateResult`.
+*
+* The class deliberately does not implement `render()` itself — a
+* `LitElement` without `render()` is still constructible, but its
+* default behaviour is to render nothing. Subclasses are required to
+* override.
+*/
+var BaseScElement = class extends LitElement {
+	/**
+	* Property declarations shared by every built-in Custom Element.
+	*
+	* Subclasses spread this in:
+	*
+	* ```ts
+	* static override properties = {
+	*   ...BaseScElement.properties,
+	*   ...
+	* };
+	* ```
+	*
+	* Every shared property uses `attribute: false` — none of the
+	* payloads (`tree`, `value`, `meta`, `constraints`) round-trip
+	* safely through HTML attribute strings.
+	*/
+	static properties = {
+		tree: { attribute: false },
+		value: { attribute: false },
+		readOnly: { attribute: false },
+		writeOnly: { attribute: false },
+		path: { attribute: false },
+		meta: { attribute: false },
+		constraints: { attribute: false },
+		examples: { attribute: false },
+		change: { attribute: false },
+		renderChild: { attribute: false }
+	};
+	constructor() {
+		super();
+		this.readOnly = false;
+		this.writeOnly = false;
+		this.path = "";
+		this.meta = {};
+		this.constraints = {};
+		this.change = () => {};
+		this.renderChild = () => html``;
+	}
+	/**
+	* Dispatch the canonical `sc-change` event. Renderers call this
+	* inside DOM event handlers (`@input`, `@change`, `@click` on
+	* add/remove controls) — the orchestrating ancestor catches the
+	* event, propagates the structural update to the root value, and
+	* re-emits a top-level `change` event on its own host.
+	*/
+	emitChange(value) {
+		this.change(value);
+		this.dispatchEvent(new CustomEvent(SC_CHANGE_EVENT, {
+			detail: {
+				value,
+				path: this.path
+			},
+			bubbles: true,
+			composed: true
+		}));
+	}
+};
+/**
+* Trivial pass-through helper used by renderers that need to emit a
+* `nothing` placeholder rather than a full `TemplateResult`. Keeps the
+* dispatch table strictly typed without forcing callers to import
+* `nothing` from Lit.
+*/
+const emptyTemplate = () => html``;
+//#endregion
+export { BaseScElement, SC_CHANGE_EVENT, emptyTemplate };

package/dist/lit/renderers/recordHelpers.d.mts

@@ -0,0 +1,25 @@
+import { j as WalkedField } from "../../types-BBQaEPfE.mjs";
+
+//#region src/lit/renderers/recordHelpers.d.ts
+/**
+ * Compute the default value for a freshly added array element or
+ * record entry based on its element / value schema. Mirrors
+ * `react/headlessRenderers.tsx::defaultRecordValue` so the same
+ * field type produces the same default across renderers.
+ */
+declare function defaultRecordValueLit(valueType: WalkedField): unknown;
+/**
+ * Generate a unique, currently-unused key for a new record entry.
+ * Picks the first of `key`, `key-1`, `key-2`, … that is not in
+ * `existing`. Mirrors `react/headlessRenderers.tsx::nextRecordKey`.
+ */
+declare function nextRecordKeyLit(existing: readonly string[], base?: string): string;
+/**
+ * Rename a key in an object while preserving insertion order. Returns
+ * the original reference when the rename is a no-op (same key) or
+ * when the new key collides with an existing entry. Mirrors
+ * `react/headlessRenderers.tsx::renameRecordKey`.
+ */
+declare function renameRecordKeyLit(obj: Record<string, unknown>, oldKey: string, newKey: string): Record<string, unknown>;
+//#endregion
+export { defaultRecordValueLit, nextRecordKeyLit, renameRecordKeyLit };

package/dist/lit/renderers/recordHelpers.mjs

@@ -0,0 +1,55 @@
+//#region src/lit/renderers/recordHelpers.ts
+/**
+* Compute the default value for a freshly added array element or
+* record entry based on its element / value schema. Mirrors
+* `react/headlessRenderers.tsx::defaultRecordValue` so the same
+* field type produces the same default across renderers.
+*/
+function defaultRecordValueLit(valueType) {
+	if (valueType.defaultValue !== void 0) return valueType.defaultValue;
+	switch (valueType.type) {
+		case "string": return "";
+		case "number": return 0;
+		case "boolean": return false;
+		case "array": return [];
+		case "object":
+		case "record": return {};
+		case "null": return null;
+		case "unknown":
+		case "enum":
+		case "literal":
+		case "tuple":
+		case "union":
+		case "discriminatedUnion":
+		case "conditional":
+		case "negation":
+		case "file":
+		case "never": return;
+	}
+}
+/**
+* Generate a unique, currently-unused key for a new record entry.
+* Picks the first of `key`, `key-1`, `key-2`, … that is not in
+* `existing`. Mirrors `react/headlessRenderers.tsx::nextRecordKey`.
+*/
+function nextRecordKeyLit(existing, base = "key") {
+	if (!existing.includes(base)) return base;
+	let i = 1;
+	while (existing.includes(`${base}-${String(i)}`)) i += 1;
+	return `${base}-${String(i)}`;
+}
+/**
+* Rename a key in an object while preserving insertion order. Returns
+* the original reference when the rename is a no-op (same key) or
+* when the new key collides with an existing entry. Mirrors
+* `react/headlessRenderers.tsx::renameRecordKey`.
+*/
+function renameRecordKeyLit(obj, oldKey, newKey) {
+	if (oldKey === newKey) return obj;
+	if (newKey in obj && newKey !== oldKey) return obj;
+	const renamed = {};
+	for (const [k, v] of Object.entries(obj)) renamed[k === oldKey ? newKey : k] = v;
+	return renamed;
+}
+//#endregion
+export { defaultRecordValueLit, nextRecordKeyLit, renameRecordKeyLit };

package/dist/lit/renderers/scArray.d.mts

@@ -0,0 +1,14 @@
+import { BaseScElement } from "./baseElement.mjs";
+import { TemplateResult } from "lit";
+
+//#region src/lit/renderers/scArray.d.ts
+/**
+ * Lit Custom Element rendering an array schema field.
+ *
+ * Tag: `<sc-array>` (registered by `registerSchemaComponents`).
+ */
+declare class ScArray extends BaseScElement {
+  render(): TemplateResult;
+}
+//#endregion
+export { ScArray };