@contractspec/lib.contracts 1.44.0

package/dist/capabilities/openbanking.d.ts

@@ -0,0 +1,10 @@
+import { CapabilityRegistry, CapabilitySpec } from "./capabilities.js";
+import "./index.js";
+
+//#region src/capabilities/openbanking.d.ts
+declare const openBankingAccountsReadCapability: CapabilitySpec;
+declare const openBankingTransactionsReadCapability: CapabilitySpec;
+declare const openBankingBalancesReadCapability: CapabilitySpec;
+declare function registerOpenBankingCapabilities(registry: CapabilityRegistry): CapabilityRegistry;
+//#endregion
+export { openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities };

package/dist/capabilities/openbanking.js

@@ -0,0 +1,92 @@
+import { StabilityEnum } from "../ownership.js";
+
+//#region src/capabilities/openbanking.ts
+const OWNERS = ["platform.finance"];
+const TAGS = ["open-banking", "finance"];
+const openBankingAccountsReadCapability = {
+	meta: {
+		key: "openbanking.accounts.read",
+		version: 1,
+		kind: "integration",
+		title: "Open Banking Accounts (Read)",
+		description: "Provides read-only access to linked bank accounts, including account summaries and metadata.",
+		domain: "finance",
+		owners: [...OWNERS],
+		tags: [...TAGS],
+		stability: StabilityEnum.Experimental
+	},
+	provides: [
+		{
+			surface: "operation",
+			key: "openbanking.accounts.list",
+			version: 1,
+			description: "List bank accounts linked to a Powens open banking connection."
+		},
+		{
+			surface: "operation",
+			key: "openbanking.accounts.get",
+			version: 1,
+			description: "Retrieve the canonical bank account record for a specific account."
+		},
+		{
+			surface: "operation",
+			key: "openbanking.accounts.sync",
+			version: 1,
+			description: "Trigger a refresh of bank account metadata from the open banking provider."
+		}
+	]
+};
+const openBankingTransactionsReadCapability = {
+	meta: {
+		key: "openbanking.transactions.read",
+		version: 1,
+		kind: "integration",
+		title: "Open Banking Transactions (Read)",
+		description: "Enables retrieval of transaction history for linked bank accounts via open banking providers.",
+		domain: "finance",
+		owners: [...OWNERS],
+		tags: [...TAGS, "transactions"],
+		stability: StabilityEnum.Experimental
+	},
+	provides: [{
+		surface: "operation",
+		key: "openbanking.transactions.list",
+		version: 1,
+		description: "List transactions for a given bank account with optional date filtering."
+	}, {
+		surface: "operation",
+		key: "openbanking.transactions.sync",
+		version: 1,
+		description: "Synchronise transactions from the open banking provider into the canonical ledger."
+	}]
+};
+const openBankingBalancesReadCapability = {
+	meta: {
+		key: "openbanking.balances.read",
+		version: 1,
+		kind: "integration",
+		title: "Open Banking Balances (Read)",
+		description: "Allows querying of current and available balances for linked bank accounts via open banking providers.",
+		domain: "finance",
+		owners: [...OWNERS],
+		tags: [...TAGS, "balances"],
+		stability: StabilityEnum.Experimental
+	},
+	provides: [{
+		surface: "operation",
+		key: "openbanking.balances.get",
+		version: 1,
+		description: "Retrieve the latest known balances for a specified bank account."
+	}, {
+		surface: "operation",
+		key: "openbanking.balances.refresh",
+		version: 1,
+		description: "Force a balance refresh from the open banking provider."
+	}]
+};
+function registerOpenBankingCapabilities(registry) {
+	return registry.register(openBankingAccountsReadCapability).register(openBankingTransactionsReadCapability).register(openBankingBalancesReadCapability);
+}
+
+//#endregion
+export { openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities };

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./react/feature-render.js";
+import { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer } from "./react/form-render.js";
+import { ShadcnDriver, shadcnDriver } from "./react/drivers/shadcn.js";
+import { RnReusablesDriver, rnReusablesDriver } from "./react/drivers/rn-reusables.js";
+import "./react/index.js";
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, RnReusablesDriver, ShadcnDriver, createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/client/index.js

@@ -0,0 +1,9 @@
+'use client';
+
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./react/feature-render.js";
+import { createFormRenderer } from "./react/form-render.js";
+import { shadcnDriver } from "./react/drivers/shadcn.js";
+import { rnReusablesDriver } from "./react/drivers/rn-reusables.js";
+import "./react/index.js";
+
+export { createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/client/react/drivers/rn-reusables.d.ts

@@ -0,0 +1,22 @@
+import { DriverSlots } from "../form-render.js";
+
+//#region src/client/react/drivers/rn-reusables.d.ts
+
+/**
+ * Create a React Native UI-kit driver by mapping required slots to components.
+ * Host apps should import their UI-kit primitives and pass them here.
+ *
+ * Example usage:
+ * ```tsx
+ * import { rnReusablesDriver } from '@contractspec/lib.contracts/client/react/drivers/rn-reusables';
+ * import { Input, Textarea, Button } from '@contractspec/lib.ui-kit/ui';
+ *
+ * const driver = rnReusablesDriver({
+ *   Input, Textarea, Button, // ... other components
+ * });
+ * ```
+ */
+declare function rnReusablesDriver(slots: DriverSlots): DriverSlots;
+type RnReusablesDriver = ReturnType<typeof rnReusablesDriver>;
+//#endregion
+export { RnReusablesDriver, rnReusablesDriver };

package/dist/client/react/drivers/rn-reusables.js

@@ -0,0 +1,21 @@
+//#region src/client/react/drivers/rn-reusables.ts
+/**
+* Create a React Native UI-kit driver by mapping required slots to components.
+* Host apps should import their UI-kit primitives and pass them here.
+*
+* Example usage:
+* ```tsx
+* import { rnReusablesDriver } from '@contractspec/lib.contracts/client/react/drivers/rn-reusables';
+* import { Input, Textarea, Button } from '@contractspec/lib.ui-kit/ui';
+*
+* const driver = rnReusablesDriver({
+*   Input, Textarea, Button, // ... other components
+* });
+* ```
+*/
+function rnReusablesDriver(slots) {
+	return slots;
+}
+
+//#endregion
+export { rnReusablesDriver };

package/dist/client/react/drivers/shadcn.d.ts

@@ -0,0 +1,12 @@
+import { DriverSlots } from "../form-render.js";
+
+//#region src/client/react/drivers/shadcn.d.ts
+
+/**
+ * Create a shadcn/ui driver by mapping required slots to components.
+ * Host apps should import their shadcn primitives and pass them here.
+ */
+declare function shadcnDriver(slots: DriverSlots): DriverSlots;
+type ShadcnDriver = ReturnType<typeof shadcnDriver>;
+//#endregion
+export { ShadcnDriver, shadcnDriver };

package/dist/client/react/drivers/shadcn.js

@@ -0,0 +1,11 @@
+//#region src/client/react/drivers/shadcn.ts
+/**
+* Create a shadcn/ui driver by mapping required slots to components.
+* Host apps should import their shadcn primitives and pass them here.
+*/
+function shadcnDriver(slots) {
+	return slots;
+}
+
+//#endregion
+export { shadcnDriver };

package/dist/client/react/feature-render.d.ts

@@ -0,0 +1,23 @@
+import { PresentationSpec, PresentationTarget } from "../../presentations/presentations.js";
+import { FeatureModuleSpec } from "../../features/types.js";
+import { FeatureRegistry } from "../../features/registry.js";
+import { ComponentMap, TransformEngine } from "../../presentations/transform-engine.js";
+import "../../presentations/index.js";
+import "../../features/index.js";
+import React from "react";
+import { BlockConfig } from "@blocknote/core";
+
+//#region src/client/react/feature-render.d.ts
+declare function createEngineWithDefaults(): TransformEngine;
+declare function renderFeaturePresentation(engine: TransformEngine, target: PresentationTarget, desc: PresentationSpec, options?: {
+  componentMap?: ComponentMap;
+  reactProps?: Record<string, unknown>;
+  renderBlockNote?: (docJson: unknown, blockConfig?: BlockConfig) => React.ReactElement;
+}): Promise<React.ReactElement | {
+  mimeType: string;
+  body: string;
+} | null>;
+declare function createFeatureModule(meta: FeatureModuleSpec['meta'], refs: Partial<Pick<FeatureModuleSpec, 'operations' | 'events' | 'presentations' | 'presentationsTargets'>>): FeatureModuleSpec;
+declare function registerFeature(registry: FeatureRegistry, feature: FeatureModuleSpec): FeatureRegistry;
+//#endregion
+export { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation };

package/dist/client/react/feature-render.js

@@ -0,0 +1,44 @@
+import { createDefaultTransformEngine, registerBasicValidation, registerDefaultReactRenderer } from "../../presentations/transform-engine.js";
+import "../../presentations/index.js";
+import React from "react";
+
+//#region src/client/react/feature-render.ts
+function createEngineWithDefaults() {
+	return registerBasicValidation(registerDefaultReactRenderer(createDefaultTransformEngine()));
+}
+async function renderFeaturePresentation(engine, target, desc, options) {
+	if (target === "react") {
+		const rd = await engine.render("react", desc);
+		if (rd.kind === "react_component") {
+			const C = (options?.componentMap ?? {})[rd.componentKey];
+			if (!C) return null;
+			const merged = {
+				...rd.props ?? {},
+				...options?.reactProps ?? {}
+			};
+			return React.createElement(C, merged);
+		}
+		if (rd.kind === "blocknotejs") {
+			if (options?.renderBlockNote) return options.renderBlockNote(rd.docJson, rd.blockConfig);
+			return React.createElement("div", {}, "[BlockNote renderer not configured]");
+		}
+		return null;
+	}
+	if (target === "markdown") return engine.render(target, desc);
+	if (target === "application/json") return engine.render(target, desc);
+	if (target === "application/xml") return engine.render(target, desc);
+	return null;
+}
+function createFeatureModule(meta, refs) {
+	return {
+		meta,
+		...refs
+	};
+}
+function registerFeature(registry, feature) {
+	registry.register(feature);
+	return registry;
+}
+
+//#endregion
+export { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation };

package/dist/client/react/form-render.d.ts

@@ -0,0 +1,92 @@
+import { FormOption, FormSpec, FormValuesFor } from "../../forms/forms.js";
+import "../../forms/index.js";
+import { AnySchemaModel } from "@contractspec/lib.schema";
+import React from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/client/react/form-render.d.ts
+interface DriverSlots {
+  Field: React.ComponentType<React.PropsWithChildren<{
+    'data-invalid'?: boolean;
+    hidden?: boolean;
+    disabled?: boolean;
+  }>>;
+  FieldLabel: React.ComponentType<React.PropsWithChildren<{
+    htmlFor?: string;
+  }>>;
+  FieldDescription: React.ComponentType<React.PropsWithChildren<{}>>;
+  FieldError: React.ComponentType<{
+    errors: {
+      message?: string;
+    }[];
+  }>;
+  FieldGroup?: React.ComponentType<React.PropsWithChildren<{
+    className?: string;
+  }>>;
+  FieldSet?: React.ComponentType<React.PropsWithChildren<{
+    className?: string;
+  }>>;
+  FieldLegend?: React.ComponentType<React.PropsWithChildren<{
+    variant?: 'label' | 'default';
+  }>>;
+  Input: React.ComponentType<React.InputHTMLAttributes<HTMLInputElement>>;
+  Textarea: React.ComponentType<React.TextareaHTMLAttributes<HTMLTextAreaElement>>;
+  Select: React.ComponentType<{
+    id?: string;
+    name?: string;
+    value?: unknown;
+    onChange?: (v: unknown) => void;
+    disabled?: boolean;
+    'aria-invalid'?: boolean;
+    options: FormOption[];
+  } & Record<string, unknown>>;
+  Checkbox: React.ComponentType<{
+    id?: string;
+    name?: string;
+    checked?: boolean;
+    onCheckedChange?: (v: boolean) => void;
+    disabled?: boolean;
+  } & Record<string, unknown>>;
+  RadioGroup: React.ComponentType<{
+    id?: string;
+    name?: string;
+    value?: unknown;
+    onValueChange?: (v: unknown) => void;
+    disabled?: boolean;
+    options: FormOption[];
+  } & Record<string, unknown>>;
+  Switch: React.ComponentType<{
+    id?: string;
+    name?: string;
+    checked?: boolean;
+    onCheckedChange?: (v: boolean) => void;
+    disabled?: boolean;
+  } & Record<string, unknown>>;
+  Button: React.ComponentType<React.PropsWithChildren<{
+    type?: 'button' | 'submit' | 'reset';
+    variant?: string;
+    size?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+  }>>;
+}
+type ResolverMap<TValues> = Record<string, (values: TValues, args?: unknown) => Promise<FormOption[]> | FormOption[]>;
+type ComputationMap<TValues> = Record<string, (values: TValues) => unknown>;
+interface CreateRendererOptions<TValues = Record<string, unknown>> {
+  driver: DriverSlots;
+  formOptions?: Record<string, unknown>;
+  onSubmitOverride?: (values: TValues, actionKey: string) => Promise<void> | void;
+  activeFlags?: string[];
+  resolvers?: ResolverMap<TValues>;
+  computations?: ComputationMap<TValues>;
+  unmountStrategy?: 'keep' | 'clear';
+}
+interface RenderOptions<TValues = Record<string, unknown>> {
+  defaultValues?: Partial<TValues>;
+  overrides?: Partial<CreateRendererOptions<TValues>>;
+}
+declare function createFormRenderer<M extends AnySchemaModel = AnySchemaModel>(base: CreateRendererOptions<FormValuesFor<M>>): {
+  render: (spec: FormSpec<M>, options?: RenderOptions<FormValuesFor<M>>) => react_jsx_runtime0.JSX.Element;
+};
+//#endregion
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer };

package/dist/client/react/form-render.js

@@ -0,0 +1,298 @@
+import { buildZodWithRelations, evalPredicate } from "../../forms/forms.js";
+import React, { useEffect, useMemo, useState } from "react";
+import { Controller, useFieldArray, useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/client/react/form-render.tsx
+function toOptionsArray(src) {
+	if (!src) return void 0;
+	if (Array.isArray(src)) return {
+		kind: "static",
+		options: src
+	};
+	return src;
+}
+function getAtPath(values, path) {
+	if (!path) return void 0;
+	const segs = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+	let cur = values;
+	for (const s of segs) {
+		if (cur == null) return void 0;
+		cur = cur[s];
+	}
+	return cur;
+}
+function makeDepsKey(values, deps) {
+	if (!deps || deps.length === 0) return "[]";
+	try {
+		return JSON.stringify(deps.map((d) => getAtPath(values, d)));
+	} catch {
+		return "[]";
+	}
+}
+function useResolvedOptions(values, source, resolvers) {
+	const [opts, setOpts] = useState([]);
+	useEffect(() => {
+		let mounted = true;
+		const run = async () => {
+			if (!source) return setOpts([]);
+			if (source.kind === "static") return setOpts([...source.options ?? []]);
+			const fn = resolvers?.[source.resolverKey];
+			if (!fn) return setOpts([]);
+			const res = await fn(values, source.args);
+			if (mounted) setOpts([...res ?? []]);
+		};
+		run();
+		return () => {
+			mounted = false;
+		};
+	}, [useMemo(() => {
+		if (!source) return "nil";
+		if (source.kind === "static") return JSON.stringify(source.options ?? []);
+		return makeDepsKey(values, source.deps);
+	}, [source, values]), source && source.kind === "resolver" ? source.resolverKey : void 0]);
+	return opts;
+}
+function fieldPath(parent, name, arrayIndex) {
+	if (!name) return parent ?? "";
+	const child = typeof arrayIndex === "number" ? `${name.replace(/^\$index$/, String(arrayIndex))}` : name;
+	return parent ? `${parent}${typeof arrayIndex === "number" ? `.${arrayIndex}` : ""}.${child}`.replace(/\.+/g, ".") : child;
+}
+function createFormRenderer(base) {
+	const conf = base;
+	const { driver } = conf;
+	function InternalForm(props) {
+		const { spec, options, merged } = props;
+		const baseZod = useMemo(() => buildZodWithRelations(spec), [spec]);
+		const form = useForm({
+			...merged.formOptions,
+			resolver: zodResolver(baseZod),
+			defaultValues: options?.defaultValues
+		});
+		const values = form.watch();
+		const renderOne = (f, parent, arrayIndex) => {
+			const DriverField = driver.Field;
+			const DriverLabel = driver.FieldLabel;
+			const DriverDesc = driver.FieldDescription;
+			const DriverError = driver.FieldError;
+			const name = fieldPath(parent, f.name, arrayIndex);
+			const visible = evalPredicate(values, f.visibleWhen);
+			const enabled = evalPredicate(values, f.enabledWhen);
+			const invalid = Boolean(form.getFieldState(name)?.invalid);
+			if (!visible) return null;
+			const id = name?.replace(/\./g, "-");
+			const commonWrapProps = {
+				"data-invalid": invalid,
+				hidden: !visible,
+				disabled: !enabled
+			};
+			const labelNode = f.labelI18n ? /* @__PURE__ */ jsx(DriverLabel, {
+				htmlFor: id,
+				children: f.labelI18n
+			}) : null;
+			const descNode = f.descriptionI18n ? /* @__PURE__ */ jsx(DriverDesc, { children: f.descriptionI18n }) : null;
+			if (f.kind === "group") {
+				const children = f.fields.map((c, i) => /* @__PURE__ */ jsx(React.Fragment, { children: renderOne(c, name, arrayIndex) }, `${name}-${i}`));
+				return /* @__PURE__ */ jsxs(DriverField, {
+					...commonWrapProps,
+					children: [
+						labelNode,
+						children,
+						descNode
+					]
+				});
+			}
+			if (f.kind === "array") return renderArray(f, parent);
+			return /* @__PURE__ */ jsx(Controller, {
+				name,
+				control: form.control,
+				render: ({ field, fieldState }) => {
+					const err = fieldState.error ? [fieldState.error] : [];
+					const ariaInvalid = fieldState.invalid || void 0;
+					if (f.kind === "text") {
+						const textField = f;
+						const Input = driver.Input;
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(Input, {
+									id,
+									"aria-invalid": ariaInvalid,
+									placeholder: f.placeholderI18n,
+									autoComplete: textField.autoComplete,
+									inputMode: textField.inputMode,
+									maxLength: textField.maxLength,
+									minLength: textField.minLength,
+									disabled: !enabled,
+									...field,
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					if (f.kind === "textarea") {
+						const textareaField = f;
+						const Textarea = driver.Textarea;
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(Textarea, {
+									id,
+									"aria-invalid": ariaInvalid,
+									placeholder: f.placeholderI18n,
+									rows: textareaField.rows,
+									maxLength: textareaField.maxLength,
+									disabled: !enabled,
+									...field,
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					if (f.kind === "select") {
+						const selectField = f;
+						const Select = driver.Select;
+						const opts = useResolvedOptions(values, toOptionsArray(selectField.options), merged.resolvers);
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(Select, {
+									id,
+									name,
+									"aria-invalid": ariaInvalid,
+									disabled: !enabled,
+									value: field.value,
+									onChange: (v) => field.onChange(v),
+									options: opts,
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					if (f.kind === "checkbox") {
+						const Checkbox = driver.Checkbox;
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(Checkbox, {
+									id,
+									name,
+									disabled: !enabled,
+									checked: !!field.value,
+									onCheckedChange: (v) => field.onChange(v),
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					if (f.kind === "radio") {
+						const radioField = f;
+						const RadioGroup = driver.RadioGroup;
+						const opts = useResolvedOptions(values, toOptionsArray(radioField.options), merged.resolvers);
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(RadioGroup, {
+									id,
+									name,
+									disabled: !enabled,
+									value: field.value,
+									onValueChange: (v) => field.onChange(v),
+									options: opts,
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					if (f.kind === "switch") {
+						const Switch = driver.Switch;
+						return /* @__PURE__ */ jsxs(DriverField, {
+							...commonWrapProps,
+							children: [
+								labelNode,
+								/* @__PURE__ */ jsx(Switch, {
+									id,
+									name,
+									disabled: !enabled,
+									checked: !!field.value,
+									onCheckedChange: (v) => field.onChange(v),
+									...f.uiProps
+								}),
+								descNode,
+								fieldState.invalid ? /* @__PURE__ */ jsx(DriverError, { errors: err }) : null
+							]
+						});
+					}
+					return /* @__PURE__ */ jsx(Fragment, {});
+				}
+			}, name);
+		};
+		const renderArray = (f, parent) => {
+			const name = fieldPath(parent, f.name);
+			const { fields, append, remove } = useFieldArray({
+				control: form.control,
+				name
+			});
+			const canAdd = f.max == null || fields.length < f.max;
+			const canRemove = (idx) => (f.min == null ? fields.length > 0 : fields.length > f.min) && idx >= 0;
+			const Button$1 = driver.Button;
+			const Label = driver.FieldLabel;
+			return /* @__PURE__ */ jsxs("div", { children: [
+				f.labelI18n ? /* @__PURE__ */ jsx(Label, { children: f.labelI18n }) : null,
+				fields.map((row, idx) => /* @__PURE__ */ jsxs("div", { children: [renderOne(f.of, name, idx), canRemove(idx) ? /* @__PURE__ */ jsx(Button$1, {
+					type: "button",
+					variant: "ghost",
+					size: "sm",
+					onClick: () => remove(idx),
+					children: "Remove"
+				}) : null] }, row.id ?? idx)),
+				canAdd ? /* @__PURE__ */ jsx(Button$1, {
+					type: "button",
+					variant: "outline",
+					size: "sm",
+					onClick: () => append({}),
+					children: "Add"
+				}) : null
+			] }, name);
+		};
+		const onSubmit = async (data) => {
+			const actionKey = spec.actions?.[0]?.key ?? "submit";
+			if (merged.onSubmitOverride) return merged.onSubmitOverride(data, actionKey);
+		};
+		const Button = driver.Button;
+		return /* @__PURE__ */ jsxs("form", {
+			onSubmit: form.handleSubmit(onSubmit),
+			children: [(spec.fields || []).map((f, i) => /* @__PURE__ */ jsx(React.Fragment, { children: renderOne(f) }, i)), spec.actions && spec.actions.length ? /* @__PURE__ */ jsx("div", { children: spec.actions.map((a) => /* @__PURE__ */ jsx(Button, {
+				type: "submit",
+				children: a.labelI18n
+			}, a.key)) }) : null]
+		});
+	}
+	return { render: (spec, options) => /* @__PURE__ */ jsx(InternalForm, {
+		spec,
+		options,
+		merged: {
+			...conf,
+			...options?.overrides ?? {}
+		}
+	}) };
+}
+
+//#endregion
+export { createFormRenderer };

package/dist/client/react/index.d.ts

@@ -0,0 +1,5 @@
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./feature-render.js";
+import { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer } from "./form-render.js";
+import { ShadcnDriver, shadcnDriver } from "./drivers/shadcn.js";
+import { RnReusablesDriver, rnReusablesDriver } from "./drivers/rn-reusables.js";
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, RnReusablesDriver, ShadcnDriver, createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/client/react/index.js

@@ -0,0 +1,8 @@
+'use client';
+
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./feature-render.js";
+import { createFormRenderer } from "./form-render.js";
+import { shadcnDriver } from "./drivers/shadcn.js";
+import { rnReusablesDriver } from "./drivers/rn-reusables.js";
+
+export { createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/contract-registry/index.d.ts

@@ -0,0 +1,3 @@
+import { ContractRegistryFile, ContractRegistryItem, ContractRegistryItemType, ContractRegistryManifest, JsonSchema } from "./types.js";
+import { ContractRegistryFileSchema, ContractRegistryItemParsed, ContractRegistryItemSchema, ContractRegistryItemTypeSchema, ContractRegistryManifestParsed, ContractRegistryManifestSchema } from "./schemas.js";
+export { type ContractRegistryFile, ContractRegistryFileSchema, type ContractRegistryItem, type ContractRegistryItemParsed, ContractRegistryItemSchema, type ContractRegistryItemType, ContractRegistryItemTypeSchema, type ContractRegistryManifest, type ContractRegistryManifestParsed, ContractRegistryManifestSchema, type JsonSchema };

package/dist/contract-registry/index.js

@@ -0,0 +1,3 @@
+import { ContractRegistryFileSchema, ContractRegistryItemSchema, ContractRegistryItemTypeSchema, ContractRegistryManifestSchema } from "./schemas.js";
+
+export { ContractRegistryFileSchema, ContractRegistryItemSchema, ContractRegistryItemTypeSchema, ContractRegistryManifestSchema };