@kontsedal/olas-zod 0.0.1-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bohdan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,83 @@
+# @kontsedal/olas-zod
+
+Zod ↔ Olas forms adapter. Two helpers — `zodValidator` (single field) and `formFromZod` (whole form, inferred from schema).
+
+Olas core stays Zod-free. This package has a peer dep on `zod ^3`.
+
+## Install
+
+```bash
+pnpm add @kontsedal/olas-zod @kontsedal/olas-core zod
+```
+
+## 30-second example
+
+### Single-field validator
+
+```ts
+import { defineController } from '@kontsedal/olas-core'
+import { zodValidator } from '@kontsedal/olas-zod'
+import { z } from 'zod'
+
+const signup = defineController((ctx) => ({
+  email: ctx.field('', [zodValidator(z.string().email())]),
+}))
+```
+
+### Whole form inferred from schema
+
+```ts
+import { formFromZod } from '@kontsedal/olas-zod'
+import { z } from 'zod'
+
+const schema = z.object({
+  name: z.string().min(1),
+  age: z.number().int().min(0),
+  address: z.object({
+    street: z.string().min(1),
+    city: z.string().min(1),
+  }),
+  tags: z.array(z.string().min(1)),
+})
+
+const profileForm = defineController((ctx) => ({
+  form: formFromZod(ctx, schema),
+}))
+
+// form.value.value: { name: string; age: number; address: { street, city }; tags: string[] }
+```
+
+`formFromZod` walks the schema:
+
+- `z.object(...)` → `Form<...>` (recurses).
+- `z.array(...)` → `FieldArray<...>` (recurses on element type).
+- Anything else → `Field<...>` with `zodValidator(...)` attached.
+
+Each leaf's initial value comes from the Zod schema's `.default(...)` if present, otherwise the empty value for the type (`''` for string, `0` for number, etc.). Override per-field with the `initials` option.
+
+## API
+
+```ts
+function zodValidator<T>(schema: z.ZodType<T>): Validator<T>
+function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T>
+
+function formFromZod<S extends z.ZodObject<z.ZodRawShape>>(
+  ctx: Ctx,
+  schema: S,
+  options?: FormOptions<...>,
+): Form<...>
+```
+
+`zodValidator` runs `schema.safeParse(value)` and reports the first `ZodIssue`'s `message`. `zodValidatorAsync` awaits `.safeParseAsync(...)` for schemas with async `.refine` / `.transform`.
+
+Form-level `.refine(...)` on the root `z.object(...)` is attached as a top-level form validator (surfaces via `form.topLevelErrors`).
+
+## Limitation
+
+Array-level `.min(N)` rules from the outer Zod schema are *not* promoted to a `FieldArray`-level validator today — leaf and nested-object rules walk correctly. Workaround: write a manual `FieldArrayValidator` for that case, or assert on `form.isValid` (driven by leaf rules). Tracked in [`../../BACKLOG.md`](../../BACKLOG.md).
+
+## Further reading
+
+- [`../../API.md`](../../API.md#olaszod) — full reference.
+- [`../../.wiki/modules/zod.md`](../../.wiki/modules/zod.md)
+- SPEC §8.7 (Zod integration), §20.7 (form types).

package/dist/index.cjs

@@ -0,0 +1,96 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/index.ts
+/**
+* Wrap a Zod schema as an Olas validator. Returns a sync or async Validator
+* depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).
+*/
+function zodValidator(schema) {
+	return (value, signal) => {
+		const result = schema.safeParse(value);
+		if (result.success) return null;
+		return result.error.issues[0]?.message ?? "Invalid";
+	};
+}
+/**
+* Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.
+* Returns a Promise<string | null>.
+*/
+function zodValidatorAsync(schema) {
+	return async (value, signal) => {
+		const result = await schema.safeParseAsync(value);
+		if (result.success) return null;
+		return result.error.issues[0]?.message ?? "Invalid";
+	};
+}
+function unwrap(schema) {
+	let s = schema;
+	for (let i = 0; i < 5; i++) if (s instanceof zod.z.ZodDefault) s = s.def.innerType;
+	else if (s instanceof zod.z.ZodOptional) s = s.unwrap();
+	else if (s instanceof zod.z.ZodNullable) s = s.unwrap();
+	else return s;
+	return s;
+}
+function defaultInitial(schema) {
+	if (schema instanceof zod.z.ZodDefault) {
+		const raw = schema.def.defaultValue;
+		return typeof raw === "function" ? raw() : raw;
+	}
+	const inner = unwrap(schema);
+	if (inner instanceof zod.z.ZodString) return "";
+	if (inner instanceof zod.z.ZodNumber) return 0;
+	if (inner instanceof zod.z.ZodBoolean) return false;
+	if (inner instanceof zod.z.ZodArray) return [];
+	if (inner instanceof zod.z.ZodEnum) {
+		const first = inner.options[0];
+		return typeof first === "string" ? first : "";
+	}
+}
+/**
+* Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field
+* tree, with validators auto-attached.
+*
+* - `z.object(...)` → `Form`
+* - `z.array(...)`  → `FieldArray` (recurses on the element)
+* - leaf schemas    → `Field` with `zodValidator(...)` attached
+*
+* Each leaf's initial value is the Zod default if present, otherwise an empty
+* value for that type (`''` for strings, `0` for numbers, etc.).
+*
+* The return type is structurally precise — `form.fields.title.value` is
+* `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`
+* accepts the exact item shape, etc. Consumers do not need to hand-write
+* a `CardForm = Form<{...}>` matching the schema.
+*/
+function formFromZod(ctx, schema, options) {
+	return buildForm(ctx, schema, options?.initials);
+}
+function buildForm(ctx, schema, initials) {
+	const shape = schema.shape;
+	const fields = {};
+	for (const key of Object.keys(shape)) {
+		const propSchema = shape[key];
+		const initial = initials?.[key];
+		fields[key] = buildLeaf(ctx, propSchema, initial);
+	}
+	const formOpts = {};
+	const topLevelValidators = [];
+	if (topLevelValidators.length > 0) formOpts.validators = topLevelValidators;
+	return ctx.form(fields, formOpts);
+}
+function buildLeaf(ctx, schema, initial) {
+	const inner = unwrap(schema);
+	if (inner instanceof zod.z.ZodObject) return buildForm(ctx, inner, initial);
+	if (inner instanceof zod.z.ZodArray) {
+		const elementSchema = inner.element;
+		return ctx.fieldArray((itemInitial) => buildLeaf(ctx, elementSchema, itemInitial), initial !== void 0 ? { initial } : void 0);
+	}
+	const ini = initial !== void 0 ? initial : defaultInitial(schema);
+	return ctx.field(ini, [zodValidator(schema)]);
+}
+//#endregion
+exports.formFromZod = formFromZod;
+exports.zodValidator = zodValidator;
+exports.zodValidatorAsync = zodValidatorAsync;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["z"],"sources":["../src/index.ts"],"sourcesContent":["import type { Ctx, Field, FieldArray, Form, FormOptions, Validator } from '@kontsedal/olas-core'\nimport { z } from 'zod'\n\n/**\n * Wrap a Zod schema as an Olas validator. Returns a sync or async Validator\n * depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).\n */\nexport function zodValidator<T>(schema: z.ZodType<T>): Validator<T> {\n  return (value, signal) => {\n    // signal isn't used by Zod (parsing is sync) — kept for interface parity.\n    void signal\n    const result = schema.safeParse(value)\n    if (result.success) return null\n    return result.error.issues[0]?.message ?? 'Invalid'\n  }\n}\n\n/**\n * Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.\n * Returns a Promise<string | null>.\n */\nexport function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T> {\n  return async (value, signal) => {\n    void signal\n    const result = await schema.safeParseAsync(value)\n    if (result.success) return null\n    return result.error.issues[0]?.message ?? 'Invalid'\n  }\n}\n\n// Zod 4 typed every wrapper as `z.ZodType`-compatible; the public unwrap path\n// is `.unwrap()` for optional/nullable and `.def.innerType` for default.\ntype AnyZodType = z.ZodType\n\n// Strip the outer optional/nullable/default wrappers to find the inner schema.\nfunction unwrap(schema: AnyZodType): AnyZodType {\n  let s: AnyZodType = schema\n  // Unwrap default + optional + nullable, in any combination.\n  for (let i = 0; i < 5; i++) {\n    if (s instanceof z.ZodDefault) {\n      // ZodDefault stores the inner schema on `def.innerType`. The runtime\n      // shape is stable across 3.x and 4.x; the public type just shifts.\n      s = (s as unknown as { def: { innerType: AnyZodType } }).def.innerType\n    } else if (s instanceof z.ZodOptional) {\n      s = (s as z.ZodOptional<AnyZodType>).unwrap() as AnyZodType\n    } else if (s instanceof z.ZodNullable) {\n      s = (s as z.ZodNullable<AnyZodType>).unwrap() as AnyZodType\n    } else {\n      return s\n    }\n  }\n  return s\n}\n\nfunction defaultInitial(schema: AnyZodType): unknown {\n  // Honor Zod default if present.\n  if (schema instanceof z.ZodDefault) {\n    const raw = (schema as unknown as { def: { defaultValue: unknown } }).def.defaultValue\n    return typeof raw === 'function' ? (raw as () => unknown)() : raw\n  }\n  const inner = unwrap(schema)\n  if (inner instanceof z.ZodString) return ''\n  if (inner instanceof z.ZodNumber) return 0\n  if (inner instanceof z.ZodBoolean) return false\n  if (inner instanceof z.ZodArray) return []\n  if (inner instanceof z.ZodEnum) {\n    // Zod 4 widened ZodEnum's options to support record-style enums. The\n    // runtime values are still iterable; pick the first.\n    const opts = (inner as unknown as { options: readonly unknown[] }).options\n    const first = opts[0]\n    return typeof first === 'string' ? first : ''\n  }\n  // For unknown/any/dates etc., undefined is the safest starting point.\n  return undefined\n}\n\ntype AnyForm = Form<Record<string, Field<any> | Form<any> | FieldArray<any>>>\n\n// Strip the same wrappers as the runtime `unwrap` helper, at the type level.\ntype UnwrapZod<S> =\n  S extends z.ZodDefault<infer Inner>\n    ? UnwrapZod<Inner>\n    : S extends z.ZodOptional<infer Inner>\n      ? UnwrapZod<Inner>\n      : S extends z.ZodNullable<infer Inner>\n        ? UnwrapZod<Inner>\n        : S\n\n/**\n * Recursively map a Zod schema to its Olas form leaf:\n *  - `ZodObject<S>` → `Form<{ [K]: ZodToLeaf<S[K]> }>`\n *  - `ZodArray<E>`  → `FieldArray<ZodToLeaf<E>>` (when E is object/array)\n *                     or `FieldArray<Field<infer<E>>>` for primitive elements.\n *  - everything else → `Field<infer<S>>`.\n *\n * `ZodToLeaf<S>` matches what `buildLeaf(ctx, s, ...)` returns at runtime,\n * so the public `formFromZod<T>` can publish a precise structural type\n * without the consumer needing a hand-written `CardForm = Form<{...}>` cast.\n */\nexport type ZodToLeaf<S> =\n  UnwrapZod<S> extends z.ZodObject<infer RawShape>\n    ? Form<{ [K in keyof RawShape]: ZodToLeaf<RawShape[K]> }>\n    : UnwrapZod<S> extends z.ZodArray<infer Element>\n      ? FieldArray<ZodToLeaf<Element> extends Form<any> | Field<any> ? ZodToLeaf<Element> : never>\n      : Field<z.infer<UnwrapZod<S> & z.ZodType>>\n\n/**\n * Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field\n * tree, with validators auto-attached.\n *\n * - `z.object(...)` → `Form`\n * - `z.array(...)`  → `FieldArray` (recurses on the element)\n * - leaf schemas    → `Field` with `zodValidator(...)` attached\n *\n * Each leaf's initial value is the Zod default if present, otherwise an empty\n * value for that type (`''` for strings, `0` for numbers, etc.).\n *\n * The return type is structurally precise — `form.fields.title.value` is\n * `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`\n * accepts the exact item shape, etc. Consumers do not need to hand-write\n * a `CardForm = Form<{...}>` matching the schema.\n */\nexport function formFromZod<T extends z.ZodObject<z.ZodRawShape>>(\n  ctx: Ctx,\n  schema: T,\n  options?: { initials?: Partial<z.infer<T>> },\n): Form<{ [K in keyof T['shape']]: ZodToLeaf<T['shape'][K]> }> {\n  return buildForm(ctx, schema, options?.initials) as never\n}\n\nfunction buildForm(\n  ctx: Ctx,\n  schema: z.ZodObject<z.ZodRawShape>,\n  initials?: Record<string, unknown>,\n): AnyForm {\n  const shape = schema.shape\n  const fields: Record<string, Field<unknown> | Form<any> | FieldArray<any>> = {}\n  for (const key of Object.keys(shape)) {\n    const propSchema = shape[key] as AnyZodType\n    const initial = initials?.[key]\n    fields[key] = buildLeaf(ctx, propSchema, initial)\n  }\n  const formOpts: FormOptions<typeof fields> = {}\n  // If the schema has top-level refinements (z.object().refine(...)), Zod\n  // wraps it in ZodEffects. We expose those as form-level validators.\n  const topLevelValidators: Validator<unknown>[] = []\n  // Note: we received an unwrapped ZodObject here, so there's nothing extra.\n  if (topLevelValidators.length > 0) {\n    ;(formOpts as { validators: Validator<unknown>[] }).validators = topLevelValidators\n  }\n  return ctx.form(fields, formOpts) as AnyForm\n}\n\nfunction buildLeaf(\n  ctx: Ctx,\n  schema: AnyZodType,\n  initial: unknown,\n): Field<unknown> | Form<any> | FieldArray<any> {\n  const inner = unwrap(schema)\n\n  if (inner instanceof z.ZodObject) {\n    return buildForm(\n      ctx,\n      inner as z.ZodObject<z.ZodRawShape>,\n      initial as Record<string, unknown> | undefined,\n    )\n  }\n\n  if (inner instanceof z.ZodArray) {\n    const elementSchema = (inner as z.ZodArray<AnyZodType>).element as AnyZodType\n    return ctx.fieldArray(\n      (itemInitial) => buildLeaf(ctx, elementSchema, itemInitial) as Field<unknown> | Form<any>,\n      initial !== undefined ? { initial: initial as Array<unknown> } : undefined,\n    )\n  }\n\n  const ini = initial !== undefined ? initial : defaultInitial(schema)\n  return ctx.field(ini, [zodValidator(schema as z.ZodType<unknown>)])\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,aAAgB,QAAoC;CAClE,QAAQ,OAAO,WAAW;EAGxB,MAAM,SAAS,OAAO,UAAU,KAAK;EACrC,IAAI,OAAO,SAAS,OAAO;EAC3B,OAAO,OAAO,MAAM,OAAO,IAAI,WAAW;CAC5C;AACF;;;;;AAMA,SAAgB,kBAAqB,QAAoC;CACvE,OAAO,OAAO,OAAO,WAAW;EAE9B,MAAM,SAAS,MAAM,OAAO,eAAe,KAAK;EAChD,IAAI,OAAO,SAAS,OAAO;EAC3B,OAAO,OAAO,MAAM,OAAO,IAAI,WAAW;CAC5C;AACF;AAOA,SAAS,OAAO,QAAgC;CAC9C,IAAI,IAAgB;CAEpB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,IAAI,aAAaA,IAAAA,EAAE,YAGjB,IAAK,EAAoD,IAAI;MACxD,IAAI,aAAaA,IAAAA,EAAE,aACxB,IAAK,EAAgC,OAAO;MACvC,IAAI,aAAaA,IAAAA,EAAE,aACxB,IAAK,EAAgC,OAAO;MAE5C,OAAO;CAGX,OAAO;AACT;AAEA,SAAS,eAAe,QAA6B;CAEnD,IAAI,kBAAkBA,IAAAA,EAAE,YAAY;EAClC,MAAM,MAAO,OAAyD,IAAI;EAC1E,OAAO,OAAO,QAAQ,aAAc,IAAsB,IAAI;CAChE;CACA,MAAM,QAAQ,OAAO,MAAM;CAC3B,IAAI,iBAAiBA,IAAAA,EAAE,WAAW,OAAO;CACzC,IAAI,iBAAiBA,IAAAA,EAAE,WAAW,OAAO;CACzC,IAAI,iBAAiBA,IAAAA,EAAE,YAAY,OAAO;CAC1C,IAAI,iBAAiBA,IAAAA,EAAE,UAAU,OAAO,CAAC;CACzC,IAAI,iBAAiBA,IAAAA,EAAE,SAAS;EAI9B,MAAM,QADQ,MAAqD,QAChD;EACnB,OAAO,OAAO,UAAU,WAAW,QAAQ;CAC7C;AAGF;;;;;;;;;;;;;;;;;AAgDA,SAAgB,YACd,KACA,QACA,SAC6D;CAC7D,OAAO,UAAU,KAAK,QAAQ,SAAS,QAAQ;AACjD;AAEA,SAAS,UACP,KACA,QACA,UACS;CACT,MAAM,QAAQ,OAAO;CACrB,MAAM,SAAuE,CAAC;CAC9E,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GAAG;EACpC,MAAM,aAAa,MAAM;EACzB,MAAM,UAAU,WAAW;EAC3B,OAAO,OAAO,UAAU,KAAK,YAAY,OAAO;CAClD;CACA,MAAM,WAAuC,CAAC;CAG9C,MAAM,qBAA2C,CAAC;CAElD,IAAI,mBAAmB,SAAS,GAC7B,SAAmD,aAAa;CAEnE,OAAO,IAAI,KAAK,QAAQ,QAAQ;AAClC;AAEA,SAAS,UACP,KACA,QACA,SAC8C;CAC9C,MAAM,QAAQ,OAAO,MAAM;CAE3B,IAAI,iBAAiBA,IAAAA,EAAE,WACrB,OAAO,UACL,KACA,OACA,OACF;CAGF,IAAI,iBAAiBA,IAAAA,EAAE,UAAU;EAC/B,MAAM,gBAAiB,MAAiC;EACxD,OAAO,IAAI,YACR,gBAAgB,UAAU,KAAK,eAAe,WAAW,GAC1D,YAAY,KAAA,IAAY,EAAW,QAA0B,IAAI,KAAA,CACnE;CACF;CAEA,MAAM,MAAM,YAAY,KAAA,IAAY,UAAU,eAAe,MAAM;CACnE,OAAO,IAAI,MAAM,KAAK,CAAC,aAAa,MAA4B,CAAC,CAAC;AACpE"}

package/dist/index.d.cts

@@ -0,0 +1,49 @@
+import { Ctx, Field, FieldArray, Form, Validator } from "@kontsedal/olas-core";
+import { z } from "zod";
+
+//#region src/index.d.ts
+/**
+ * Wrap a Zod schema as an Olas validator. Returns a sync or async Validator
+ * depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).
+ */
+declare function zodValidator<T>(schema: z.ZodType<T>): Validator<T>;
+/**
+ * Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.
+ * Returns a Promise<string | null>.
+ */
+declare function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T>;
+type UnwrapZod<S> = S extends z.ZodDefault<infer Inner> ? UnwrapZod<Inner> : S extends z.ZodOptional<infer Inner> ? UnwrapZod<Inner> : S extends z.ZodNullable<infer Inner> ? UnwrapZod<Inner> : S;
+/**
+ * Recursively map a Zod schema to its Olas form leaf:
+ *  - `ZodObject<S>` → `Form<{ [K]: ZodToLeaf<S[K]> }>`
+ *  - `ZodArray<E>`  → `FieldArray<ZodToLeaf<E>>` (when E is object/array)
+ *                     or `FieldArray<Field<infer<E>>>` for primitive elements.
+ *  - everything else → `Field<infer<S>>`.
+ *
+ * `ZodToLeaf<S>` matches what `buildLeaf(ctx, s, ...)` returns at runtime,
+ * so the public `formFromZod<T>` can publish a precise structural type
+ * without the consumer needing a hand-written `CardForm = Form<{...}>` cast.
+ */
+type ZodToLeaf<S> = UnwrapZod<S> extends z.ZodObject<infer RawShape> ? Form<{ [K in keyof RawShape]: ZodToLeaf<RawShape[K]> }> : UnwrapZod<S> extends z.ZodArray<infer Element> ? FieldArray<ZodToLeaf<Element> extends Form<any> | Field<any> ? ZodToLeaf<Element> : never> : Field<z.infer<UnwrapZod<S> & z.ZodType>>;
+/**
+ * Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field
+ * tree, with validators auto-attached.
+ *
+ * - `z.object(...)` → `Form`
+ * - `z.array(...)`  → `FieldArray` (recurses on the element)
+ * - leaf schemas    → `Field` with `zodValidator(...)` attached
+ *
+ * Each leaf's initial value is the Zod default if present, otherwise an empty
+ * value for that type (`''` for strings, `0` for numbers, etc.).
+ *
+ * The return type is structurally precise — `form.fields.title.value` is
+ * `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`
+ * accepts the exact item shape, etc. Consumers do not need to hand-write
+ * a `CardForm = Form<{...}>` matching the schema.
+ */
+declare function formFromZod<T extends z.ZodObject<z.ZodRawShape>>(ctx: Ctx, schema: T, options?: {
+  initials?: Partial<z.infer<T>>;
+}): Form<{ [K in keyof T['shape']]: ZodToLeaf<T['shape'][K]> }>;
+//#endregion
+export { ZodToLeaf, formFromZod, zodValidator, zodValidatorAsync };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;AAOA;;iBAAgB,YAAA,GAAA,CAAgB,MAAA,EAAQ,CAAA,CAAE,OAAA,CAAQ,CAAA,IAAK,SAAA,CAAU,CAAA;;;;;iBAcjD,iBAAA,GAAA,CAAqB,MAAA,EAAQ,CAAA,CAAE,OAAA,CAAQ,CAAA,IAAK,SAAA,CAAU,CAAA;AAAA,KA0DjE,SAAA,MACH,CAAA,SAAU,CAAA,CAAE,UAAA,gBACR,SAAA,CAAU,KAAA,IACV,CAAA,SAAU,CAAA,CAAE,WAAA,gBACV,SAAA,CAAU,KAAA,IACV,CAAA,SAAU,CAAA,CAAE,WAAA,gBACV,SAAA,CAAU,KAAA,IACV,CAAA;;;;;;;;;AA/EwD;AAclE;;KA8EY,SAAA,MACV,SAAA,CAAU,CAAA,UAAW,CAAA,CAAE,SAAA,mBACnB,IAAA,eAAmB,QAAA,GAAW,SAAA,CAAU,QAAA,CAAS,CAAA,QACjD,SAAA,CAAU,CAAA,UAAW,CAAA,CAAE,QAAA,kBACrB,UAAA,CAAW,SAAA,CAAU,OAAA,UAAiB,IAAA,QAAY,KAAA,QAAa,SAAA,CAAU,OAAA,aACzE,KAAA,CAAM,CAAA,CAAE,KAAA,CAAM,SAAA,CAAU,CAAA,IAAK,CAAA,CAAE,OAAA;;;;;;;;;;;;;AAnFgC;AAOtE;;;iBA8Fe,WAAA,WAAsB,CAAA,CAAE,SAAA,CAAU,CAAA,CAAE,WAAA,EAAA,CAClD,GAAA,EAAK,GAAA,EACL,MAAA,EAAQ,CAAA,EACR,OAAA;EAAY,QAAA,GAAW,OAAA,CAAQ,CAAA,CAAE,KAAA,CAAM,CAAA;AAAA,IACtC,IAAA,eAAmB,CAAA,YAAa,SAAA,CAAU,CAAA,UAAW,CAAA"}

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { Ctx, Field, FieldArray, Form, Validator } from "@kontsedal/olas-core";
+
+//#region src/index.d.ts
+/**
+ * Wrap a Zod schema as an Olas validator. Returns a sync or async Validator
+ * depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).
+ */
+declare function zodValidator<T>(schema: z.ZodType<T>): Validator<T>;
+/**
+ * Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.
+ * Returns a Promise<string | null>.
+ */
+declare function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T>;
+type UnwrapZod<S> = S extends z.ZodDefault<infer Inner> ? UnwrapZod<Inner> : S extends z.ZodOptional<infer Inner> ? UnwrapZod<Inner> : S extends z.ZodNullable<infer Inner> ? UnwrapZod<Inner> : S;
+/**
+ * Recursively map a Zod schema to its Olas form leaf:
+ *  - `ZodObject<S>` → `Form<{ [K]: ZodToLeaf<S[K]> }>`
+ *  - `ZodArray<E>`  → `FieldArray<ZodToLeaf<E>>` (when E is object/array)
+ *                     or `FieldArray<Field<infer<E>>>` for primitive elements.
+ *  - everything else → `Field<infer<S>>`.
+ *
+ * `ZodToLeaf<S>` matches what `buildLeaf(ctx, s, ...)` returns at runtime,
+ * so the public `formFromZod<T>` can publish a precise structural type
+ * without the consumer needing a hand-written `CardForm = Form<{...}>` cast.
+ */
+type ZodToLeaf<S> = UnwrapZod<S> extends z.ZodObject<infer RawShape> ? Form<{ [K in keyof RawShape]: ZodToLeaf<RawShape[K]> }> : UnwrapZod<S> extends z.ZodArray<infer Element> ? FieldArray<ZodToLeaf<Element> extends Form<any> | Field<any> ? ZodToLeaf<Element> : never> : Field<z.infer<UnwrapZod<S> & z.ZodType>>;
+/**
+ * Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field
+ * tree, with validators auto-attached.
+ *
+ * - `z.object(...)` → `Form`
+ * - `z.array(...)`  → `FieldArray` (recurses on the element)
+ * - leaf schemas    → `Field` with `zodValidator(...)` attached
+ *
+ * Each leaf's initial value is the Zod default if present, otherwise an empty
+ * value for that type (`''` for strings, `0` for numbers, etc.).
+ *
+ * The return type is structurally precise — `form.fields.title.value` is
+ * `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`
+ * accepts the exact item shape, etc. Consumers do not need to hand-write
+ * a `CardForm = Form<{...}>` matching the schema.
+ */
+declare function formFromZod<T extends z.ZodObject<z.ZodRawShape>>(ctx: Ctx, schema: T, options?: {
+  initials?: Partial<z.infer<T>>;
+}): Form<{ [K in keyof T['shape']]: ZodToLeaf<T['shape'][K]> }>;
+//#endregion
+export { ZodToLeaf, formFromZod, zodValidator, zodValidatorAsync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;AAOA;;iBAAgB,YAAA,GAAA,CAAgB,MAAA,EAAQ,CAAA,CAAE,OAAA,CAAQ,CAAA,IAAK,SAAA,CAAU,CAAA;;;;;iBAcjD,iBAAA,GAAA,CAAqB,MAAA,EAAQ,CAAA,CAAE,OAAA,CAAQ,CAAA,IAAK,SAAA,CAAU,CAAA;AAAA,KA0DjE,SAAA,MACH,CAAA,SAAU,CAAA,CAAE,UAAA,gBACR,SAAA,CAAU,KAAA,IACV,CAAA,SAAU,CAAA,CAAE,WAAA,gBACV,SAAA,CAAU,KAAA,IACV,CAAA,SAAU,CAAA,CAAE,WAAA,gBACV,SAAA,CAAU,KAAA,IACV,CAAA;;;;;;;;;AA/EwD;AAclE;;KA8EY,SAAA,MACV,SAAA,CAAU,CAAA,UAAW,CAAA,CAAE,SAAA,mBACnB,IAAA,eAAmB,QAAA,GAAW,SAAA,CAAU,QAAA,CAAS,CAAA,QACjD,SAAA,CAAU,CAAA,UAAW,CAAA,CAAE,QAAA,kBACrB,UAAA,CAAW,SAAA,CAAU,OAAA,UAAiB,IAAA,QAAY,KAAA,QAAa,SAAA,CAAU,OAAA,aACzE,KAAA,CAAM,CAAA,CAAE,KAAA,CAAM,SAAA,CAAU,CAAA,IAAK,CAAA,CAAE,OAAA;;;;;;;;;;;;;AAnFgC;AAOtE;;;iBA8Fe,WAAA,WAAsB,CAAA,CAAE,SAAA,CAAU,CAAA,CAAE,WAAA,EAAA,CAClD,GAAA,EAAK,GAAA,EACL,MAAA,EAAQ,CAAA,EACR,OAAA;EAAY,QAAA,GAAW,OAAA,CAAQ,CAAA,CAAE,KAAA,CAAM,CAAA;AAAA,IACtC,IAAA,eAAmB,CAAA,YAAa,SAAA,CAAU,CAAA,UAAW,CAAA"}

package/dist/index.mjs

@@ -0,0 +1,93 @@
+import { z } from "zod";
+//#region src/index.ts
+/**
+* Wrap a Zod schema as an Olas validator. Returns a sync or async Validator
+* depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).
+*/
+function zodValidator(schema) {
+	return (value, signal) => {
+		const result = schema.safeParse(value);
+		if (result.success) return null;
+		return result.error.issues[0]?.message ?? "Invalid";
+	};
+}
+/**
+* Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.
+* Returns a Promise<string | null>.
+*/
+function zodValidatorAsync(schema) {
+	return async (value, signal) => {
+		const result = await schema.safeParseAsync(value);
+		if (result.success) return null;
+		return result.error.issues[0]?.message ?? "Invalid";
+	};
+}
+function unwrap(schema) {
+	let s = schema;
+	for (let i = 0; i < 5; i++) if (s instanceof z.ZodDefault) s = s.def.innerType;
+	else if (s instanceof z.ZodOptional) s = s.unwrap();
+	else if (s instanceof z.ZodNullable) s = s.unwrap();
+	else return s;
+	return s;
+}
+function defaultInitial(schema) {
+	if (schema instanceof z.ZodDefault) {
+		const raw = schema.def.defaultValue;
+		return typeof raw === "function" ? raw() : raw;
+	}
+	const inner = unwrap(schema);
+	if (inner instanceof z.ZodString) return "";
+	if (inner instanceof z.ZodNumber) return 0;
+	if (inner instanceof z.ZodBoolean) return false;
+	if (inner instanceof z.ZodArray) return [];
+	if (inner instanceof z.ZodEnum) {
+		const first = inner.options[0];
+		return typeof first === "string" ? first : "";
+	}
+}
+/**
+* Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field
+* tree, with validators auto-attached.
+*
+* - `z.object(...)` → `Form`
+* - `z.array(...)`  → `FieldArray` (recurses on the element)
+* - leaf schemas    → `Field` with `zodValidator(...)` attached
+*
+* Each leaf's initial value is the Zod default if present, otherwise an empty
+* value for that type (`''` for strings, `0` for numbers, etc.).
+*
+* The return type is structurally precise — `form.fields.title.value` is
+* `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`
+* accepts the exact item shape, etc. Consumers do not need to hand-write
+* a `CardForm = Form<{...}>` matching the schema.
+*/
+function formFromZod(ctx, schema, options) {
+	return buildForm(ctx, schema, options?.initials);
+}
+function buildForm(ctx, schema, initials) {
+	const shape = schema.shape;
+	const fields = {};
+	for (const key of Object.keys(shape)) {
+		const propSchema = shape[key];
+		const initial = initials?.[key];
+		fields[key] = buildLeaf(ctx, propSchema, initial);
+	}
+	const formOpts = {};
+	const topLevelValidators = [];
+	if (topLevelValidators.length > 0) formOpts.validators = topLevelValidators;
+	return ctx.form(fields, formOpts);
+}
+function buildLeaf(ctx, schema, initial) {
+	const inner = unwrap(schema);
+	if (inner instanceof z.ZodObject) return buildForm(ctx, inner, initial);
+	if (inner instanceof z.ZodArray) {
+		const elementSchema = inner.element;
+		return ctx.fieldArray((itemInitial) => buildLeaf(ctx, elementSchema, itemInitial), initial !== void 0 ? { initial } : void 0);
+	}
+	const ini = initial !== void 0 ? initial : defaultInitial(schema);
+	return ctx.field(ini, [zodValidator(schema)]);
+}
+//#endregion
+export { formFromZod, zodValidator, zodValidatorAsync };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Ctx, Field, FieldArray, Form, FormOptions, Validator } from '@kontsedal/olas-core'\nimport { z } from 'zod'\n\n/**\n * Wrap a Zod schema as an Olas validator. Returns a sync or async Validator\n * depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).\n */\nexport function zodValidator<T>(schema: z.ZodType<T>): Validator<T> {\n  return (value, signal) => {\n    // signal isn't used by Zod (parsing is sync) — kept for interface parity.\n    void signal\n    const result = schema.safeParse(value)\n    if (result.success) return null\n    return result.error.issues[0]?.message ?? 'Invalid'\n  }\n}\n\n/**\n * Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.\n * Returns a Promise<string | null>.\n */\nexport function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T> {\n  return async (value, signal) => {\n    void signal\n    const result = await schema.safeParseAsync(value)\n    if (result.success) return null\n    return result.error.issues[0]?.message ?? 'Invalid'\n  }\n}\n\n// Zod 4 typed every wrapper as `z.ZodType`-compatible; the public unwrap path\n// is `.unwrap()` for optional/nullable and `.def.innerType` for default.\ntype AnyZodType = z.ZodType\n\n// Strip the outer optional/nullable/default wrappers to find the inner schema.\nfunction unwrap(schema: AnyZodType): AnyZodType {\n  let s: AnyZodType = schema\n  // Unwrap default + optional + nullable, in any combination.\n  for (let i = 0; i < 5; i++) {\n    if (s instanceof z.ZodDefault) {\n      // ZodDefault stores the inner schema on `def.innerType`. The runtime\n      // shape is stable across 3.x and 4.x; the public type just shifts.\n      s = (s as unknown as { def: { innerType: AnyZodType } }).def.innerType\n    } else if (s instanceof z.ZodOptional) {\n      s = (s as z.ZodOptional<AnyZodType>).unwrap() as AnyZodType\n    } else if (s instanceof z.ZodNullable) {\n      s = (s as z.ZodNullable<AnyZodType>).unwrap() as AnyZodType\n    } else {\n      return s\n    }\n  }\n  return s\n}\n\nfunction defaultInitial(schema: AnyZodType): unknown {\n  // Honor Zod default if present.\n  if (schema instanceof z.ZodDefault) {\n    const raw = (schema as unknown as { def: { defaultValue: unknown } }).def.defaultValue\n    return typeof raw === 'function' ? (raw as () => unknown)() : raw\n  }\n  const inner = unwrap(schema)\n  if (inner instanceof z.ZodString) return ''\n  if (inner instanceof z.ZodNumber) return 0\n  if (inner instanceof z.ZodBoolean) return false\n  if (inner instanceof z.ZodArray) return []\n  if (inner instanceof z.ZodEnum) {\n    // Zod 4 widened ZodEnum's options to support record-style enums. The\n    // runtime values are still iterable; pick the first.\n    const opts = (inner as unknown as { options: readonly unknown[] }).options\n    const first = opts[0]\n    return typeof first === 'string' ? first : ''\n  }\n  // For unknown/any/dates etc., undefined is the safest starting point.\n  return undefined\n}\n\ntype AnyForm = Form<Record<string, Field<any> | Form<any> | FieldArray<any>>>\n\n// Strip the same wrappers as the runtime `unwrap` helper, at the type level.\ntype UnwrapZod<S> =\n  S extends z.ZodDefault<infer Inner>\n    ? UnwrapZod<Inner>\n    : S extends z.ZodOptional<infer Inner>\n      ? UnwrapZod<Inner>\n      : S extends z.ZodNullable<infer Inner>\n        ? UnwrapZod<Inner>\n        : S\n\n/**\n * Recursively map a Zod schema to its Olas form leaf:\n *  - `ZodObject<S>` → `Form<{ [K]: ZodToLeaf<S[K]> }>`\n *  - `ZodArray<E>`  → `FieldArray<ZodToLeaf<E>>` (when E is object/array)\n *                     or `FieldArray<Field<infer<E>>>` for primitive elements.\n *  - everything else → `Field<infer<S>>`.\n *\n * `ZodToLeaf<S>` matches what `buildLeaf(ctx, s, ...)` returns at runtime,\n * so the public `formFromZod<T>` can publish a precise structural type\n * without the consumer needing a hand-written `CardForm = Form<{...}>` cast.\n */\nexport type ZodToLeaf<S> =\n  UnwrapZod<S> extends z.ZodObject<infer RawShape>\n    ? Form<{ [K in keyof RawShape]: ZodToLeaf<RawShape[K]> }>\n    : UnwrapZod<S> extends z.ZodArray<infer Element>\n      ? FieldArray<ZodToLeaf<Element> extends Form<any> | Field<any> ? ZodToLeaf<Element> : never>\n      : Field<z.infer<UnwrapZod<S> & z.ZodType>>\n\n/**\n * Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field\n * tree, with validators auto-attached.\n *\n * - `z.object(...)` → `Form`\n * - `z.array(...)`  → `FieldArray` (recurses on the element)\n * - leaf schemas    → `Field` with `zodValidator(...)` attached\n *\n * Each leaf's initial value is the Zod default if present, otherwise an empty\n * value for that type (`''` for strings, `0` for numbers, etc.).\n *\n * The return type is structurally precise — `form.fields.title.value` is\n * `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`\n * accepts the exact item shape, etc. Consumers do not need to hand-write\n * a `CardForm = Form<{...}>` matching the schema.\n */\nexport function formFromZod<T extends z.ZodObject<z.ZodRawShape>>(\n  ctx: Ctx,\n  schema: T,\n  options?: { initials?: Partial<z.infer<T>> },\n): Form<{ [K in keyof T['shape']]: ZodToLeaf<T['shape'][K]> }> {\n  return buildForm(ctx, schema, options?.initials) as never\n}\n\nfunction buildForm(\n  ctx: Ctx,\n  schema: z.ZodObject<z.ZodRawShape>,\n  initials?: Record<string, unknown>,\n): AnyForm {\n  const shape = schema.shape\n  const fields: Record<string, Field<unknown> | Form<any> | FieldArray<any>> = {}\n  for (const key of Object.keys(shape)) {\n    const propSchema = shape[key] as AnyZodType\n    const initial = initials?.[key]\n    fields[key] = buildLeaf(ctx, propSchema, initial)\n  }\n  const formOpts: FormOptions<typeof fields> = {}\n  // If the schema has top-level refinements (z.object().refine(...)), Zod\n  // wraps it in ZodEffects. We expose those as form-level validators.\n  const topLevelValidators: Validator<unknown>[] = []\n  // Note: we received an unwrapped ZodObject here, so there's nothing extra.\n  if (topLevelValidators.length > 0) {\n    ;(formOpts as { validators: Validator<unknown>[] }).validators = topLevelValidators\n  }\n  return ctx.form(fields, formOpts) as AnyForm\n}\n\nfunction buildLeaf(\n  ctx: Ctx,\n  schema: AnyZodType,\n  initial: unknown,\n): Field<unknown> | Form<any> | FieldArray<any> {\n  const inner = unwrap(schema)\n\n  if (inner instanceof z.ZodObject) {\n    return buildForm(\n      ctx,\n      inner as z.ZodObject<z.ZodRawShape>,\n      initial as Record<string, unknown> | undefined,\n    )\n  }\n\n  if (inner instanceof z.ZodArray) {\n    const elementSchema = (inner as z.ZodArray<AnyZodType>).element as AnyZodType\n    return ctx.fieldArray(\n      (itemInitial) => buildLeaf(ctx, elementSchema, itemInitial) as Field<unknown> | Form<any>,\n      initial !== undefined ? { initial: initial as Array<unknown> } : undefined,\n    )\n  }\n\n  const ini = initial !== undefined ? initial : defaultInitial(schema)\n  return ctx.field(ini, [zodValidator(schema as z.ZodType<unknown>)])\n}\n"],"mappings":";;;;;;AAOA,SAAgB,aAAgB,QAAoC;CAClE,QAAQ,OAAO,WAAW;EAGxB,MAAM,SAAS,OAAO,UAAU,KAAK;EACrC,IAAI,OAAO,SAAS,OAAO;EAC3B,OAAO,OAAO,MAAM,OAAO,IAAI,WAAW;CAC5C;AACF;;;;;AAMA,SAAgB,kBAAqB,QAAoC;CACvE,OAAO,OAAO,OAAO,WAAW;EAE9B,MAAM,SAAS,MAAM,OAAO,eAAe,KAAK;EAChD,IAAI,OAAO,SAAS,OAAO;EAC3B,OAAO,OAAO,MAAM,OAAO,IAAI,WAAW;CAC5C;AACF;AAOA,SAAS,OAAO,QAAgC;CAC9C,IAAI,IAAgB;CAEpB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,IAAI,aAAa,EAAE,YAGjB,IAAK,EAAoD,IAAI;MACxD,IAAI,aAAa,EAAE,aACxB,IAAK,EAAgC,OAAO;MACvC,IAAI,aAAa,EAAE,aACxB,IAAK,EAAgC,OAAO;MAE5C,OAAO;CAGX,OAAO;AACT;AAEA,SAAS,eAAe,QAA6B;CAEnD,IAAI,kBAAkB,EAAE,YAAY;EAClC,MAAM,MAAO,OAAyD,IAAI;EAC1E,OAAO,OAAO,QAAQ,aAAc,IAAsB,IAAI;CAChE;CACA,MAAM,QAAQ,OAAO,MAAM;CAC3B,IAAI,iBAAiB,EAAE,WAAW,OAAO;CACzC,IAAI,iBAAiB,EAAE,WAAW,OAAO;CACzC,IAAI,iBAAiB,EAAE,YAAY,OAAO;CAC1C,IAAI,iBAAiB,EAAE,UAAU,OAAO,CAAC;CACzC,IAAI,iBAAiB,EAAE,SAAS;EAI9B,MAAM,QADQ,MAAqD,QAChD;EACnB,OAAO,OAAO,UAAU,WAAW,QAAQ;CAC7C;AAGF;;;;;;;;;;;;;;;;;AAgDA,SAAgB,YACd,KACA,QACA,SAC6D;CAC7D,OAAO,UAAU,KAAK,QAAQ,SAAS,QAAQ;AACjD;AAEA,SAAS,UACP,KACA,QACA,UACS;CACT,MAAM,QAAQ,OAAO;CACrB,MAAM,SAAuE,CAAC;CAC9E,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GAAG;EACpC,MAAM,aAAa,MAAM;EACzB,MAAM,UAAU,WAAW;EAC3B,OAAO,OAAO,UAAU,KAAK,YAAY,OAAO;CAClD;CACA,MAAM,WAAuC,CAAC;CAG9C,MAAM,qBAA2C,CAAC;CAElD,IAAI,mBAAmB,SAAS,GAC7B,SAAmD,aAAa;CAEnE,OAAO,IAAI,KAAK,QAAQ,QAAQ;AAClC;AAEA,SAAS,UACP,KACA,QACA,SAC8C;CAC9C,MAAM,QAAQ,OAAO,MAAM;CAE3B,IAAI,iBAAiB,EAAE,WACrB,OAAO,UACL,KACA,OACA,OACF;CAGF,IAAI,iBAAiB,EAAE,UAAU;EAC/B,MAAM,gBAAiB,MAAiC;EACxD,OAAO,IAAI,YACR,gBAAgB,UAAU,KAAK,eAAe,WAAW,GAC1D,YAAY,KAAA,IAAY,EAAW,QAA0B,IAAI,KAAA,CACnE;CACF;CAEA,MAAM,MAAM,YAAY,KAAA,IAAY,UAAU,eAAe,MAAM;CACnE,OAAO,IAAI,MAAM,KAAK,CAAC,aAAa,MAA4B,CAAC,CAAC;AACpE"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@kontsedal/olas-zod",
+  "version": "0.0.1-rc.0",
+  "description": "Olas Zod adapter — zodValidator + formFromZod",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "zod": "^4.0.0",
+    "@kontsedal/olas-core": "^0.0.1-rc.0"
+  },
+  "devDependencies": {
+    "zod": "^4.4.3",
+    "@kontsedal/olas-core": "^0.0.1-rc.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,179 @@
+import type { Ctx, Field, FieldArray, Form, FormOptions, Validator } from '@kontsedal/olas-core'
+import { z } from 'zod'
+
+/**
+ * Wrap a Zod schema as an Olas validator. Returns a sync or async Validator
+ * depending on whether the schema requires async parsing (e.g. `.refine(async ...)`).
+ */
+export function zodValidator<T>(schema: z.ZodType<T>): Validator<T> {
+  return (value, signal) => {
+    // signal isn't used by Zod (parsing is sync) — kept for interface parity.
+    void signal
+    const result = schema.safeParse(value)
+    if (result.success) return null
+    return result.error.issues[0]?.message ?? 'Invalid'
+  }
+}
+
+/**
+ * Async variant for schemas with `.refine(async ...)` or `.transform(async ...)`.
+ * Returns a Promise<string | null>.
+ */
+export function zodValidatorAsync<T>(schema: z.ZodType<T>): Validator<T> {
+  return async (value, signal) => {
+    void signal
+    const result = await schema.safeParseAsync(value)
+    if (result.success) return null
+    return result.error.issues[0]?.message ?? 'Invalid'
+  }
+}
+
+// Zod 4 typed every wrapper as `z.ZodType`-compatible; the public unwrap path
+// is `.unwrap()` for optional/nullable and `.def.innerType` for default.
+type AnyZodType = z.ZodType
+
+// Strip the outer optional/nullable/default wrappers to find the inner schema.
+function unwrap(schema: AnyZodType): AnyZodType {
+  let s: AnyZodType = schema
+  // Unwrap default + optional + nullable, in any combination.
+  for (let i = 0; i < 5; i++) {
+    if (s instanceof z.ZodDefault) {
+      // ZodDefault stores the inner schema on `def.innerType`. The runtime
+      // shape is stable across 3.x and 4.x; the public type just shifts.
+      s = (s as unknown as { def: { innerType: AnyZodType } }).def.innerType
+    } else if (s instanceof z.ZodOptional) {
+      s = (s as z.ZodOptional<AnyZodType>).unwrap() as AnyZodType
+    } else if (s instanceof z.ZodNullable) {
+      s = (s as z.ZodNullable<AnyZodType>).unwrap() as AnyZodType
+    } else {
+      return s
+    }
+  }
+  return s
+}
+
+function defaultInitial(schema: AnyZodType): unknown {
+  // Honor Zod default if present.
+  if (schema instanceof z.ZodDefault) {
+    const raw = (schema as unknown as { def: { defaultValue: unknown } }).def.defaultValue
+    return typeof raw === 'function' ? (raw as () => unknown)() : raw
+  }
+  const inner = unwrap(schema)
+  if (inner instanceof z.ZodString) return ''
+  if (inner instanceof z.ZodNumber) return 0
+  if (inner instanceof z.ZodBoolean) return false
+  if (inner instanceof z.ZodArray) return []
+  if (inner instanceof z.ZodEnum) {
+    // Zod 4 widened ZodEnum's options to support record-style enums. The
+    // runtime values are still iterable; pick the first.
+    const opts = (inner as unknown as { options: readonly unknown[] }).options
+    const first = opts[0]
+    return typeof first === 'string' ? first : ''
+  }
+  // For unknown/any/dates etc., undefined is the safest starting point.
+  return undefined
+}
+
+type AnyForm = Form<Record<string, Field<any> | Form<any> | FieldArray<any>>>
+
+// Strip the same wrappers as the runtime `unwrap` helper, at the type level.
+type UnwrapZod<S> =
+  S extends z.ZodDefault<infer Inner>
+    ? UnwrapZod<Inner>
+    : S extends z.ZodOptional<infer Inner>
+      ? UnwrapZod<Inner>
+      : S extends z.ZodNullable<infer Inner>
+        ? UnwrapZod<Inner>
+        : S
+
+/**
+ * Recursively map a Zod schema to its Olas form leaf:
+ *  - `ZodObject<S>` → `Form<{ [K]: ZodToLeaf<S[K]> }>`
+ *  - `ZodArray<E>`  → `FieldArray<ZodToLeaf<E>>` (when E is object/array)
+ *                     or `FieldArray<Field<infer<E>>>` for primitive elements.
+ *  - everything else → `Field<infer<S>>`.
+ *
+ * `ZodToLeaf<S>` matches what `buildLeaf(ctx, s, ...)` returns at runtime,
+ * so the public `formFromZod<T>` can publish a precise structural type
+ * without the consumer needing a hand-written `CardForm = Form<{...}>` cast.
+ */
+export type ZodToLeaf<S> =
+  UnwrapZod<S> extends z.ZodObject<infer RawShape>
+    ? Form<{ [K in keyof RawShape]: ZodToLeaf<RawShape[K]> }>
+    : UnwrapZod<S> extends z.ZodArray<infer Element>
+      ? FieldArray<ZodToLeaf<Element> extends Form<any> | Field<any> ? ZodToLeaf<Element> : never>
+      : Field<z.infer<UnwrapZod<S> & z.ZodType>>
+
+/**
+ * Walk a Zod schema and emit the equivalent Olas Form / FieldArray / Field
+ * tree, with validators auto-attached.
+ *
+ * - `z.object(...)` → `Form`
+ * - `z.array(...)`  → `FieldArray` (recurses on the element)
+ * - leaf schemas    → `Field` with `zodValidator(...)` attached
+ *
+ * Each leaf's initial value is the Zod default if present, otherwise an empty
+ * value for that type (`''` for strings, `0` for numbers, etc.).
+ *
+ * The return type is structurally precise — `form.fields.title.value` is
+ * `string` (not `string | boolean | …`), `form.fields.subtasks.add(...)`
+ * accepts the exact item shape, etc. Consumers do not need to hand-write
+ * a `CardForm = Form<{...}>` matching the schema.
+ */
+export function formFromZod<T extends z.ZodObject<z.ZodRawShape>>(
+  ctx: Ctx,
+  schema: T,
+  options?: { initials?: Partial<z.infer<T>> },
+): Form<{ [K in keyof T['shape']]: ZodToLeaf<T['shape'][K]> }> {
+  return buildForm(ctx, schema, options?.initials) as never
+}
+
+function buildForm(
+  ctx: Ctx,
+  schema: z.ZodObject<z.ZodRawShape>,
+  initials?: Record<string, unknown>,
+): AnyForm {
+  const shape = schema.shape
+  const fields: Record<string, Field<unknown> | Form<any> | FieldArray<any>> = {}
+  for (const key of Object.keys(shape)) {
+    const propSchema = shape[key] as AnyZodType
+    const initial = initials?.[key]
+    fields[key] = buildLeaf(ctx, propSchema, initial)
+  }
+  const formOpts: FormOptions<typeof fields> = {}
+  // If the schema has top-level refinements (z.object().refine(...)), Zod
+  // wraps it in ZodEffects. We expose those as form-level validators.
+  const topLevelValidators: Validator<unknown>[] = []
+  // Note: we received an unwrapped ZodObject here, so there's nothing extra.
+  if (topLevelValidators.length > 0) {
+    ;(formOpts as { validators: Validator<unknown>[] }).validators = topLevelValidators
+  }
+  return ctx.form(fields, formOpts) as AnyForm
+}
+
+function buildLeaf(
+  ctx: Ctx,
+  schema: AnyZodType,
+  initial: unknown,
+): Field<unknown> | Form<any> | FieldArray<any> {
+  const inner = unwrap(schema)
+
+  if (inner instanceof z.ZodObject) {
+    return buildForm(
+      ctx,
+      inner as z.ZodObject<z.ZodRawShape>,
+      initial as Record<string, unknown> | undefined,
+    )
+  }
+
+  if (inner instanceof z.ZodArray) {
+    const elementSchema = (inner as z.ZodArray<AnyZodType>).element as AnyZodType
+    return ctx.fieldArray(
+      (itemInitial) => buildLeaf(ctx, elementSchema, itemInitial) as Field<unknown> | Form<any>,
+      initial !== undefined ? { initial: initial as Array<unknown> } : undefined,
+    )
+  }
+
+  const ini = initial !== undefined ? initial : defaultInitial(schema)
+  return ctx.field(ini, [zodValidator(schema as z.ZodType<unknown>)])
+}