@k8ordo/form 0.1.0

package/dist/parse/parse-form.d.mts

@@ -0,0 +1,26 @@
+import { FormState } from "../types.mjs";
+import { ObjectSchema } from "../schema/object-schema.mjs";
+import { FormDefinition } from "../rules/define-form.mjs";
+import { output } from "zod/v4/core";
+//#region src/parse/parse-form.d.ts
+type ParseResult<Output> = {
+  success: true;
+  data: Output;
+  state: FormState;
+} | {
+  success: false;
+  data?: undefined;
+  state: FormState;
+};
+/**
+ * Turn FormData into the shape the schema expects, then validate it.
+ *
+ * Only the structural part happens here — an unchecked checkbox arrives as a
+ * missing key, a repeated name arrives as several entries, names carry their
+ * nesting, and everything is a string. Converting `'42'` to `42` stays the
+ * schema's job via `z.coerce`, so the schema keeps describing what it
+ * actually validates.
+ */
+declare const parseForm: <Shape extends ObjectSchema>(input: FormDefinition<Shape> | Shape, formData: FormData) => ParseResult<output<Shape>>;
+//#endregion
+export { ParseResult, parseForm };

package/dist/parse/parse-form.mjs

@@ -0,0 +1,118 @@
+import { breachOf } from "../rules/rules.mjs";
+import { asDefinition } from "../rules/define-form.mjs";
+import { asProbe } from "../schema/object-schema.mjs";
+import { INDEX, schemaMap } from "../schema/walk.mjs";
+import { nameOf, setPath } from "./paths.mjs";
+//#region src/parse/parse-form.ts
+/**
+* The submitted names are the only source for row counts, and anyone can POST
+* anything: without a ceiling, one forged `items[99999999].name` key makes the
+* reconstruction allocate an array that long before the schema ever runs.
+* Arrays with a `.max()` are capped there; this bounds the rest.
+*/
+const MAX_ROWS = 1e3;
+let parseSeq = 0;
+/** How many rows each array actually received, read from the submitted names. */
+const rowCounts = (formData, arrays) => {
+	const counts = {};
+	for (const array of arrays) {
+		const cap = Math.min(array.maxItems ?? MAX_ROWS, MAX_ROWS);
+		let highest = -1;
+		for (const key of formData.keys()) {
+			if (!key.startsWith(`${array.path}[`)) continue;
+			const index = Number(key.slice(array.path.length + 1, key.indexOf("]", array.path.length)));
+			if (Number.isInteger(index) && index > highest) highest = index;
+		}
+		counts[array.path] = Math.min(highest + 1, cap);
+	}
+	return counts;
+};
+const describeMissing = (missing) => {
+	const shown = missing.slice(0, 5).join(", ");
+	return missing.length > 5 ? `${shown} … ほか${String(missing.length - 5)}件` : shown;
+};
+/**
+* Turn FormData into the shape the schema expects, then validate it.
+*
+* Only the structural part happens here — an unchecked checkbox arrives as a
+* missing key, a repeated name arrives as several entries, names carry their
+* nesting, and everything is a string. Converting `'42'` to `42` stays the
+* schema's job via `z.coerce`, so the schema keeps describing what it
+* actually validates.
+*/
+const parseForm = (input, formData) => {
+	const { schema, rules } = asDefinition(input);
+	const map = schemaMap(schema);
+	const raw = {};
+	const missing = [];
+	const secrets = /* @__PURE__ */ new Set();
+	const rows = rowCounts(formData, map.arrays);
+	for (const array of map.arrays) setPath(raw, array.path, Array.from({ length: rows[array.path] ?? 0 }));
+	const strings = (name) => formData.getAll(name).filter((value) => typeof value === "string");
+	for (const leaf of map.leaves) {
+		const names = leaf.arrayPath === null ? [leaf.name] : Array.from({ length: rows[leaf.arrayPath] ?? 0 }, (_, index) => leaf.name.replace(INDEX, String(index)));
+		for (const name of names) {
+			if (leaf.json.input === "password") secrets.add(name);
+			if (leaf.group !== void 0) {
+				setPath(raw, name, strings(name));
+				continue;
+			}
+			if (leaf.json.type === "boolean") {
+				setPath(raw, name, formData.has(name));
+				continue;
+			}
+			const entries = formData.getAll(name);
+			if (entries.length === 0) {
+				if (leaf.json.enum !== void 0) continue;
+				missing.push(name);
+				continue;
+			}
+			setPath(raw, name, entries.length === 1 ? entries[0] : entries);
+		}
+	}
+	if (missing.length > 0) throw new Error(`[@k8ordo/form] スキーマにあるフィールドが送信されていません: ${describeMissing(missing)}\ninput に name が付いていないか、その入力欄が描画されていない可能性があります。`);
+	const result = asProbe(schema).safeParse(raw);
+	const breaches = {};
+	for (const rule of rules) {
+		const message = breachOf(rule, strings);
+		if (message !== void 0) breaches[rule.field] = message;
+	}
+	const values = {};
+	for (const [name, value] of formData.entries()) {
+		if (typeof value !== "string" || secrets.has(name)) continue;
+		const existing = values[name];
+		if (existing === void 0) values[name] = value;
+		else if (typeof existing === "string") values[name] = [existing, value];
+		else existing.push(value);
+	}
+	parseSeq += 1;
+	const token = `${String(Date.now())}.${String(parseSeq)}`;
+	if (result.success && Object.keys(breaches).length === 0) return {
+		success: true,
+		data: result.data,
+		state: {
+			values,
+			rows,
+			token
+		}
+	};
+	const errors = { ...breaches };
+	let formError;
+	for (const issue of result.error?.issues ?? []) {
+		const name = nameOf(issue.path);
+		if (name === "") formError ??= issue.message;
+		else errors[name] ??= issue.message;
+	}
+	return {
+		success: false,
+		state: {
+			errors,
+			values,
+			rows,
+			formError,
+			token
+		}
+	};
+};
+//#endregion
+export { parseForm };

package/dist/parse/paths.d.mts

@@ -0,0 +1,20 @@
+//#region src/parse/paths.d.ts
+/** One step of a name: an object key, or an array index. */
+type Step = {
+  key: string;
+} | {
+  index: number;
+};
+/** Split `items[1].name` into its steps. */
+declare const stepsOf: (name: string) => Step[];
+/**
+ * Write a value at a dotted/indexed path, creating the objects and arrays the
+ * path implies. Gaps in an array stay holes rather than shifting later rows
+ * onto earlier indexes, so a row removed on the client cannot silently
+ * renumber the rows that follow.
+ */
+declare const setPath: (root: Record<string, unknown>, name: string, value: unknown) => void;
+/** Turn a zod issue path into the `name` of the input that produced it. */
+declare const nameOf: (path: readonly PropertyKey[]) => string;
+//#endregion
+export { nameOf, setPath, stepsOf };

package/dist/parse/paths.mjs

@@ -0,0 +1,52 @@
+//#region src/parse/paths.ts
+const STEP = /([^.[\]]+)|\[(\d+)\]/gu;
+/** Split `items[1].name` into its steps. */
+const stepsOf = (name) => {
+	const steps = [];
+	for (const match of name.matchAll(STEP)) {
+		const [, key, index] = match;
+		if (key !== void 0) steps.push({ key });
+		else if (index !== void 0) steps.push({ index: Number(index) });
+	}
+	return steps;
+};
+/**
+* Write a value at a dotted/indexed path, creating the objects and arrays the
+* path implies. Gaps in an array stay holes rather than shifting later rows
+* onto earlier indexes, so a row removed on the client cannot silently
+* renumber the rows that follow.
+*/
+const setPath = (root, name, value) => {
+	const steps = stepsOf(name);
+	if (steps.length === 0) return;
+	let cursor = root;
+	for (const [position, step] of steps.entries()) {
+		const last = position === steps.length - 1;
+		const next = steps[position + 1];
+		const container = next !== void 0 && "index" in next ? [] : {};
+		if ("index" in step) {
+			const list = cursor;
+			if (last) list[step.index] = value;
+			else {
+				list[step.index] ??= container;
+				cursor = list[step.index];
+			}
+			continue;
+		}
+		const record = cursor;
+		if (last) record[step.key] = value;
+		else {
+			record[step.key] ??= container;
+			cursor = record[step.key];
+		}
+	}
+};
+/** Turn a zod issue path into the `name` of the input that produced it. */
+const nameOf = (path) => {
+	let name = "";
+	for (const segment of path) if (typeof segment === "number") name += `[${String(segment)}]`;
+	else name += name === "" ? String(segment) : `.${String(segment)}`;
+	return name;
+};
+//#endregion
+export { nameOf, setPath, stepsOf };

package/dist/paths.d.mts

@@ -0,0 +1,56 @@
+//#region src/paths.d.ts
+/**
+ * Dotted paths derived from a zod object type, so `field('titel')` fails to
+ * compile rather than at runtime. Arrays of objects are reached through
+ * `array()`, so they are excluded from the field paths and listed separately —
+ * except an array of enums, which is a checkbox group: one shared name, so it
+ * is a field.
+ *
+ * Wrappers (`.optional()`, `.nullable()`, `.default()`, …) are peeled the same
+ * way the runtime walk peels them, so the two advertise the same paths.
+ */
+type Join<Prefix extends string, Key extends string> = Prefix extends '' ? Key : `${Prefix}.${Key}`;
+/**
+ * Wrappers keep their inner schema on the shared core definition; following it
+ * here mirrors what the runtime walk does with `_zod.def.innerType`.
+ */
+type Unwrap<Schema> = Schema extends {
+  _zod: {
+    def: {
+      innerType: infer Inner;
+    };
+  };
+} ? Unwrap<Inner> : Schema;
+/**
+ * `zod/mini` arrays carry the element only on the shared core definition, so
+ * this is the one shape that matches both entries. Objects expose `shape`
+ * publicly on both and are matched there.
+ */
+type ArrayElement<Schema> = Schema extends {
+  _zod: {
+    def: {
+      element: infer Element;
+    };
+  };
+} ? Element : never;
+type IsArray<Schema> = [ArrayElement<Schema>] extends [never] ? false : true;
+/** Enums carry `entries` on the core definition, in both zod entries. */
+type IsEnum<Schema> = Unwrap<Schema> extends {
+  _zod: {
+    def: {
+      entries: infer _Entries;
+    };
+  };
+} ? true : false;
+type FieldPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? Prefix extends '' ? never : Prefix : never : Bare extends {
+  shape: infer Shape;
+} ? { [Key in keyof Shape & string]: FieldPathsOf<Shape[Key], Join<Prefix, Key>>; }[keyof Shape & string] : Prefix extends '' ? never : Prefix : never;
+/**
+ * No recursion into an array's element: a repeat inside a repeat has no
+ * unambiguous name, and the runtime walk refuses it too.
+ */
+type ArrayPathsOf<Schema, Prefix extends string = ''> = Unwrap<Schema> extends (infer Bare) ? IsArray<Bare> extends true ? IsEnum<ArrayElement<Bare>> extends true ? never : Prefix extends '' ? never : Prefix : Bare extends {
+  shape: infer Shape;
+} ? { [Key in keyof Shape & string]: ArrayPathsOf<Shape[Key], Join<Prefix, Key>>; }[keyof Shape & string] : never : never;
+//#endregion
+export { ArrayPathsOf, FieldPathsOf };

package/dist/paths.mjs

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

package/dist/rules/define-form.d.mts

@@ -0,0 +1,21 @@
+import { Rule } from "./rules.mjs";
+import { FieldPathsOf } from "../paths.mjs";
+import { ObjectSchema } from "../schema/object-schema.mjs";
+//#region src/rules/define-form.d.ts
+/**
+ * A schema plus the checks HTML cannot express. Declaring them together is
+ * what keeps the client and the server working from one source: `formFields`
+ * serializes the rules for the browser, `parseForm` runs them on submit.
+ *
+ * The rules are typed against the schema's own paths, so
+ * `sameAs('confrim', …)` is a compile error, not a rule that never fires.
+ */
+type FormDefinition<Schema extends ObjectSchema = ObjectSchema> = {
+  schema: Schema;
+  rules: Array<Rule<FieldPathsOf<Schema>>>;
+};
+declare const defineForm: <Schema extends ObjectSchema>(schema: Schema, rules?: Array<Rule<FieldPathsOf<Schema>>>) => FormDefinition<Schema>;
+/** Accept either a bare schema or a definition, so rules stay optional. */
+declare const asDefinition: <Schema extends ObjectSchema>(input: FormDefinition<Schema> | Schema) => FormDefinition<Schema>;
+//#endregion
+export { FormDefinition, asDefinition, defineForm };

package/dist/rules/define-form.mjs

@@ -0,0 +1,12 @@
+//#region src/rules/define-form.ts
+const defineForm = (schema, rules = []) => ({
+	schema,
+	rules
+});
+/** Accept either a bare schema or a definition, so rules stay optional. */
+const asDefinition = (input) => "schema" in input ? input : {
+	schema: input,
+	rules: []
+};
+//#endregion
+export { asDefinition, defineForm };

package/dist/rules/rules.d.mts

@@ -0,0 +1,41 @@
+//#region src/rules/rules.d.ts
+/**
+ * Checks HTML has no attribute for. They are plain data so they cross to the
+ * client with everything else, and both sides run the same evaluator against
+ * the same values — the client reading the live form, the server reading the
+ * submission. One declaration, two consumers, no second implementation to
+ * drift from the first.
+ *
+ * `Field` is the set of paths the schema actually has: `defineForm` supplies
+ * it, so a typo in a field name fails to compile instead of producing a rule
+ * that never fires.
+ */
+type Rule<Field extends string = string> = {
+  kind: 'sameAs';
+  field: Field;
+  other: Field;
+  message: string;
+} | {
+  kind: 'minChecked';
+  field: Field;
+  min: number;
+  message: string;
+} | {
+  kind: 'requiredWhen';
+  field: Field;
+  when: Field;
+  equals: string;
+  message: string;
+};
+/** Reads the current values of a name, however many controls carry it. */
+type Values = (name: string) => string[];
+/** The value must equal another field's. Password confirmation, and the like. */
+declare const sameAs: <Field extends string>(field: Field, other: Field, message: string) => Rule<Field>;
+/** At least `min` boxes sharing this name must be checked. */
+declare const minChecked: <Field extends string>(field: Field, min: number, message: string) => Rule<Field>;
+/** Required only while another field holds a particular value. */
+declare const requiredWhen: <Field extends string>(field: Field, when: Field, equals: string, message: string) => Rule<Field>;
+/** The message when the rule is broken, or undefined when it holds. */
+declare const breachOf: (rule: Rule, values: Values) => string | undefined;
+//#endregion
+export { Rule, Values, breachOf, minChecked, requiredWhen, sameAs };

package/dist/rules/rules.mjs

@@ -0,0 +1,35 @@
+//#region src/rules/rules.ts
+/** The value must equal another field's. Password confirmation, and the like. */
+const sameAs = (field, other, message) => ({
+	kind: "sameAs",
+	field,
+	other,
+	message
+});
+/** At least `min` boxes sharing this name must be checked. */
+const minChecked = (field, min, message) => ({
+	kind: "minChecked",
+	field,
+	min,
+	message
+});
+/** Required only while another field holds a particular value. */
+const requiredWhen = (field, when, equals, message) => ({
+	kind: "requiredWhen",
+	field,
+	when,
+	equals,
+	message
+});
+const first = (values, name) => values(name)[0] ?? "";
+/** The message when the rule is broken, or undefined when it holds. */
+const breachOf = (rule, values) => {
+	switch (rule.kind) {
+		case "sameAs": return first(values, rule.field) === first(values, rule.other) ? void 0 : rule.message;
+		case "minChecked": return values(rule.field).length >= rule.min ? void 0 : rule.message;
+		case "requiredWhen": return first(values, rule.when) === rule.equals && first(values, rule.field) === "" ? rule.message : void 0;
+		default: return;
+	}
+};
+//#endregion
+export { breachOf, minChecked, requiredWhen, sameAs };

package/dist/schema/object-schema.d.mts

@@ -0,0 +1,33 @@
+import { $ZodObject, $ZodShape, $ZodType } from "zod/v4/core";
+//#region src/schema/object-schema.d.ts
+/**
+ * The common ground between `zod` and `zod/mini`: both build on the shared core
+ * object and both expose `shape`. Accepting this instead of the classic
+ * `ZodObject` is what lets a caller pick the seven-times-smaller entry without
+ * losing the types.
+ */
+type ObjectSchema<Shape extends $ZodShape = $ZodShape> = $ZodObject<Shape> & {
+  shape: Shape;
+};
+type ProbeIssue = {
+  code: string;
+  message: string;
+  path: readonly PropertyKey[];
+};
+/** What probing needs, present on both entries but not on the core type. */
+type ProbeSchema = $ZodType & {
+  safeParse: (value: unknown) => {
+    success: true;
+    data: unknown;
+    error?: undefined;
+  } | {
+    success: false;
+    data?: undefined;
+    error: {
+      issues: readonly ProbeIssue[];
+    };
+  };
+};
+declare const asProbe: (schema: $ZodType) => ProbeSchema;
+//#endregion
+export { ObjectSchema, ProbeIssue, ProbeSchema, asProbe };

package/dist/schema/object-schema.mjs

@@ -0,0 +1,4 @@
+//#region src/schema/object-schema.ts
+const asProbe = (schema) => schema;
+//#endregion
+export { asProbe };

package/dist/schema/walk.d.mts

@@ -0,0 +1,48 @@
+import { LeafSchema } from "../derive/attributes.mjs";
+import { ObjectSchema } from "./object-schema.mjs";
+import { $ZodType } from "zod/v4/core";
+//#region src/schema/walk.d.ts
+/** Placeholder an array item's name carries until a row index is known. */
+declare const INDEX = "{index}";
+type LeafNode = {
+  /** Dotted path within the parsed object, e.g. `user.email`. */
+  path: string;
+  /** The `name` attribute, with {@link INDEX} still in it for array items. */
+  name: string;
+  json: LeafSchema & {
+    input?: string;
+  };
+  zod: $ZodType;
+  required: boolean;
+  /** The array this leaf repeats inside, or null. */
+  arrayPath: string | null;
+  /** Key within the array item; '' when the array holds scalars. */
+  itemKey: string | null;
+  /**
+   * Present when several same-named controls submit together — a checkbox
+   * group, derived from an array of enums. Carries the bounds the group's
+   * array schema declared, which HTML has no attribute for.
+   */
+  group?: {
+    minItems?: number;
+    maxItems?: number;
+  };
+};
+type ArrayNode = {
+  path: string;
+  name: string;
+  minItems?: number;
+  maxItems?: number;
+};
+type SchemaMap = {
+  leaves: LeafNode[];
+  arrays: ArrayNode[];
+};
+/**
+ * Describe a schema once: every leaf that becomes an input, and every array
+ * that becomes a repeatable group. Both the derivation and the parse read this,
+ * so the two can never disagree about what the form contains.
+ */
+declare const schemaMap: (schema: ObjectSchema) => SchemaMap;
+//#endregion
+export { ArrayNode, INDEX, LeafNode, SchemaMap, schemaMap };

package/dist/schema/walk.mjs

@@ -0,0 +1,128 @@
+import { asProbe } from "./object-schema.mjs";
+import { toJSONSchema } from "zod/v4/core";
+//#region src/schema/walk.ts
+/** Placeholder an array item's name carries until a row index is known. */
+const INDEX = "{index}";
+/**
+* Peel wrapper schemas until the node that owns the structure is reached.
+* `toJSONSchema` flattens `.optional()` / `.default()` into the plain node, so
+* pairing the two trees requires flattening the zod side the same way.
+*/
+const unwrap = ($schema) => {
+	let current = $schema;
+	let inner = current._zod?.def?.innerType;
+	while (inner !== void 0) {
+		current = inner;
+		inner = current._zod?.def?.innerType;
+	}
+	return current;
+};
+const shapeOf = ($schema) => unwrap($schema).shape;
+const elementOf = ($schema) => {
+	const candidate = unwrap($schema);
+	return candidate.element ?? candidate._zod?.def?.element;
+};
+/**
+* `required` in JSON Schema means "the key is present", but a form always
+* submits something for every control. What it submits depends on the control:
+* a text field sends `''`, an unchecked checkbox maps to `false` in the parse.
+* Asking the schema what it does with that empty submission is what makes the
+* attribute mean the same on both sides.
+*/
+const rejectsEmptySubmission = (json, $schema) => {
+	const empty = json.type === "boolean" ? false : "";
+	return !asProbe($schema).safeParse(empty).success;
+};
+const fail = (path, reason) => {
+	throw new Error(`[@k8ordo/form] '${path === "" ? "(schema)" : path}': ${reason}`);
+};
+const walkNode = (json, zod, path, name, context, out) => {
+	if (json.type === "object") {
+		const shape = shapeOf(zod);
+		if (json.properties === void 0 || shape === void 0) fail(path, "オブジェクトのキー構成を列挙できないため、フォームに展開できません（z.record などは表現できません）");
+		for (const [key, child] of Object.entries(json.properties)) {
+			if (/[.[\]]/u.test(key)) fail(path === "" ? key : `${path}.${key}`, "キーに '.' や '[' ']' を含むスキーマは、入力の name と経路の区切りが衝突するため使えません");
+			const childZod = shape[key];
+			if (childZod === void 0) fail(path === "" ? key : `${path}.${key}`, "JSON Schema 側にだけ現れるキーです。zod 側と対応が取れないため、フォームに展開できません");
+			walkNode(child, childZod, path === "" ? key : `${path}.${key}`, name === "" ? key : `${name}.${key}`, {
+				arrayPath: context.arrayPath,
+				itemKey: context.arrayPath === null ? null : context.itemKey === null || context.itemKey === "" ? key : `${context.itemKey}.${key}`
+			}, out);
+		}
+		return;
+	}
+	if (json.type === "array") {
+		if (json.items === void 0) fail(path, "タプルなど要素型が一様でない配列は、繰り返し行として表現できません");
+		if (json.items.enum !== void 0) {
+			const element = elementOf(zod);
+			if (element === void 0) fail(path, "配列要素のスキーマを取り出せませんでした");
+			out.leaves.push({
+				path,
+				name,
+				json: json.items,
+				zod: element,
+				required: false,
+				arrayPath: context.arrayPath,
+				itemKey: context.itemKey,
+				group: {
+					minItems: json.minItems,
+					maxItems: json.maxItems
+				}
+			});
+			return;
+		}
+		if (context.arrayPath !== null) fail(path, "繰り返しの中の繰り返しは name の添字が一意に決まらないため表現できません");
+		const element = elementOf(zod);
+		if (element === void 0) fail(path, "配列要素のスキーマを取り出せませんでした");
+		out.arrays.push({
+			path,
+			name,
+			minItems: json.minItems,
+			maxItems: json.maxItems
+		});
+		walkNode(json.items, element, path, `${name}[${INDEX}]`, {
+			arrayPath: path,
+			itemKey: ""
+		}, out);
+		return;
+	}
+	if (json.anyOf !== void 0) {
+		for (const branch of json.anyOf) if (branch.type === "object" || branch.type === "array") fail(path, "nullable / union のオブジェクトや配列は、どちらの枝を描画すべきか決まらないため表現できません");
+	}
+	out.leaves.push({
+		path,
+		name,
+		json,
+		zod,
+		required: rejectsEmptySubmission(json, zod),
+		arrayPath: context.arrayPath,
+		itemKey: context.itemKey
+	});
+};
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* Describe a schema once: every leaf that becomes an input, and every array
+* that becomes a repeatable group. Both the derivation and the parse read this,
+* so the two can never disagree about what the form contains.
+*/
+const schemaMap = (schema) => {
+	const cached = cache.get(schema);
+	if (cached !== void 0) return cached;
+	const json = toJSONSchema(schema, {
+		io: "output",
+		reused: "inline",
+		unrepresentable: "any"
+	});
+	const out = {
+		leaves: [],
+		arrays: []
+	};
+	walkNode(json, schema, "", "", {
+		arrayPath: null,
+		itemKey: null
+	}, out);
+	cache.set(schema, out);
+	return out;
+};
+//#endregion
+export { INDEX, schemaMap };

package/dist/server.d.mts

@@ -0,0 +1,6 @@
+import { Rule, minChecked, requiredWhen, sameAs } from "./rules/rules.mjs";
+import { DerivedArray, DerivedField, DroppedCheck, FieldInput, FormFields, FormState, ValidityFlag } from "./types.mjs";
+import { FormDefinition, defineForm } from "./rules/define-form.mjs";
+import { formFields } from "./derive/form-fields.mjs";
+import { ParseResult, parseForm } from "./parse/parse-form.mjs";
+export { type DerivedArray, type DerivedField, type DroppedCheck, type FieldInput, type FormDefinition, type FormFields, type FormState, type ParseResult, type Rule, type ValidityFlag, defineForm, formFields, minChecked, parseForm, requiredWhen, sameAs };

package/dist/server.mjs

@@ -0,0 +1,5 @@
+import { minChecked, requiredWhen, sameAs } from "./rules/rules.mjs";
+import { defineForm } from "./rules/define-form.mjs";
+import { formFields } from "./derive/form-fields.mjs";
+import { parseForm } from "./parse/parse-form.mjs";
+export { defineForm, formFields, minChecked, parseForm, requiredWhen, sameAs };