@effect-app/vue-components 4.0.0-beta.20 → 4.0.0-beta.201

package/README.md

@@ -61,9 +61,9 @@ The doc app itself is a client app of the libary, therefore PrimeVue is imported
 module.exports = {
   vite: {
     resolve: {
-      dedupe: ['vue', /primevue\/.+/],
-    },
-  },
+      dedupe: ["vue", /primevue\/.+/]
+    }
+  }
 }
 ```
 
@@ -103,7 +103,7 @@ If you have your own special set of SVG icons, you may create a font file (`.wof
 The client app shall import `style.css`, usually in the entry file:
 
 ```js
-import 'my-lib/dist/style.css'
+import "my-lib/dist/style.css"
 ```
 
 ### Third-party dependencies
@@ -132,7 +132,7 @@ The dependency to be externalized may be declared as peer dependency in your lib
 If you don't expect the client app of your library also needing the same dependency, you may embed cherry-picked functions. For example, to embed the `fill` function of popular library [lodash](https://lodash.com), import the `fill` function like the following:
 
 ```js
-import fill from 'lodash/fill'
+import fill from "lodash/fill"
 ```
 
 Even with tree-shaking, the codes being brought into your library may still be large, as the function may have its own dependencies.
@@ -183,23 +183,51 @@ In [tsconfig.json](tsconfig.js), set the following to address [Issue #32](https:
 }
 ```
 
+## v4 Breaking Changes (from v3)
+
+### 1. Vuetify 4 CSS Reset Removed
+
+Vuetify 4 removed the aggressive global CSS reset that v3 included (universal `margin: 0; padding: 0`, list/heading/input resets, etc.). If your app relied on these defaults, opt in to the supplemental reset:
+
+```ts
+import "@effect-app/vue-components/reset.css"
+```
+
+### 2. Nested union `_tag` handling
+
+`S.TaggedStruct` produces a bare `Literal` AST node, while legacy `S.Struct({ _tag: S.Literal("X") })` produces `Union([Literal("X")])` after `AST.toType`. Both patterns now correctly produce `"select"` metadata thanks to the `unwrapSingleLiteralUnion` helper. A `console.warn` is emitted for the legacy pattern to encourage migration to `TaggedStruct`.
+
+### 3. `UndefinedOr` defaults include the key with explicit `undefined`
+
+- **v3**: `defaultsValueFromSchema` skipped keys where the recursive call returned `undefined`, so `UndefinedOr` fields were omitted from the result object entirely.
+- **v4**: The key is present in the result with an explicit `undefined` value.
+
+### 4. `S.optionalKey(X).pipe(S.withDecodingDefault(...))` support
+
+- **v3**: Not supported. The v3 equivalent `S.optionalWith` encoded defaults inside a `PropertySignatureTransformation`, opaque to AST inspection.
+- **v4**: `defaultsValueFromSchema` detects `PropertySignatureTransformation` and extracts defaults, enabling `withDecodingDefault` as a new pattern for declaring field defaults directly on the schema.
+
 ### On Submit event
-The :on-submit event could be tricky in `<OmegaForm />` component. 
+
+The :on-submit event could be tricky in `<OmegaForm />` component.
 This is a prop that is basically a map of Tanstack Form `onSubmit` option and accept a function that return a Promise. If you want to use it as an event, you have to manage the state of loading yourself with `@submit` with a function returning `void`
 
 E.g.
 
 to use it as a Promise based Tanstack way:
+
 ```html
-  <OmegaForm :schema="schema" :on-submit="onSubmit" :subscribe="['values']">
+<OmegaForm :schema="schema" :on-submit="onSubmit" :subscribe="['values']">
 ```
 
 to use it as an event:
+
 ```html
 <OmegaForm :schema="schema" @submit="onSubmit" :is-loading="false" :subscribe="['values']">
 ```
 
 this will give you a type error instead, because `:is-loading` is only accepted in event mode
+
 ```html
-  <OmegaForm :schema="schema" :on-submit="onSubmit" :is-loading="false" :subscribe="['values']">
+<OmegaForm :schema="schema" :on-submit="onSubmit" :is-loading="false" :subscribe="['values']">
 ```

package/dist/reset.css

@@ -0,0 +1,52 @@
+/*
+ * Supplemental CSS reset for Vuetify 4.
+ * Vuetify 4 removed the aggressive global reset that v3 included.
+ * Import this file to restore equivalent behavior:
+ *   import '@effect-app/vue-components/reset.css'
+ */
+@layer vuetify-reset {
+  body {
+    margin: 0;
+  }
+
+  ul,
+  ol {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    margin: 0;
+    font-size: inherit;
+    font-weight: inherit;
+  }
+
+  p {
+    margin: 0;
+  }
+
+  input,
+  textarea,
+  select {
+    border: 0;
+    background: transparent;
+  }
+
+  a {
+    text-decoration: none;
+    color: inherit;
+  }
+
+  figure,
+  details,
+  summary {
+    margin: 0;
+    padding: 0;
+  }
+}

package/dist/types/components/CommandButton.vue.d.ts

@@ -1,4 +1,5 @@
-import type { CommandBase } from "@effect-app/vue";
+import type { CommandBase, Progress } from "@effect-app/vue";
+import type * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
 import type { VBtn } from "vuetify/components";
 export type VBtnProps = VBtn["$props"];
 export interface ButtonProps extends /* @vue-ignore */ VBtnProps {
@@ -6,18 +7,19 @@ export interface ButtonProps extends /* @vue-ignore */ VBtnProps {
 /** Command Button is an easy way to connect commands and have it execute on click, while keeping track of disabled/loading states automatically */
 declare const _default: typeof __VLS_export;
 export default _default;
-declare const __VLS_export: <I = never>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const __VLS_export: <I = never, RA = unknown, RE = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<({
         input: NoInfer<I>;
-        command: CommandBase<I>;
+        command: CommandBase<I, any, RA, RE>;
         empty?: boolean;
     } | {
-        command: CommandBase;
+        command: CommandBase<any, any, RA, RE>;
         input?: undefined;
         empty?: boolean;
     }) & {
         disabled?: ButtonProps["disabled"];
         title?: string;
+        mapProgress?: (result: AsyncResult.AsyncResult<RA, RE>) => Progress | undefined;
     } & ButtonProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});

package/dist/types/components/OmegaForm/OmegaArray.vue.d.ts

@@ -1,5 +1,5 @@
 import { type DeepKeys } from "@tanstack/vue-form";
-import { type OmegaArrayProps } from "./OmegaFormStuff";
+import { type OmegaArrayProps } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<OmegaArrayProps<From, To, Name>> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

package/dist/types/components/OmegaForm/OmegaAutoGen.vue.d.ts

@@ -1,6 +1,6 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import { Order } from "effect-app";
-import { type OmegaAutoGenMeta, type OmegaInputProps } from "./OmegaFormStuff";
+import { type OmegaAutoGenMeta, type OmegaInputProps } from "./types";
 declare const __VLS_export: <// dprint-ignore
 From extends Record<PropertyKey, string>, To extends Record<PropertyKey, string>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{

package/dist/types/components/OmegaForm/OmegaErrorsInternal.vue.d.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1Issue } from "@tanstack/vue-form";
-import { type OmegaError } from "./OmegaFormStuff";
+import { type OmegaError } from "./types";
 type __VLS_Props = {
     generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[];
     errors: OmegaError[];

package/dist/types/components/OmegaForm/OmegaFormInput.vue.d.ts

@@ -1,6 +1,6 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import type { MergedInputProps } from "./InputProps";
-import type { BaseProps, DefaultTypeProps } from "./OmegaFormStuff";
+import type { BaseProps, DefaultTypeProps } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<BaseProps<From, Name> & DefaultTypeProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

package/dist/types/components/OmegaForm/OmegaInput.vue.d.ts

@@ -1,5 +1,5 @@
 import { type DeepKeys } from "@tanstack/vue-form";
-import { type OmegaInputPropsBase } from "./OmegaFormStuff";
+import { type OmegaInputPropsBase } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<OmegaInputPropsBase<From, To, Name>> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

package/dist/types/components/OmegaForm/OmegaInternalInput.vue.d.ts

@@ -1,7 +1,8 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import { type ComputedRef } from "vue";
 import type { OmegaFieldInternalApi } from "./InputProps";
-import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff";
+import type { MetaRecord, NestedKeyOf } from "./meta/types";
+import type { FieldValidators, TypeOverride } from "./types";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         field: OmegaFieldInternalApi<From, Name>;

package/dist/types/components/OmegaForm/OmegaWrapper.vue.d.ts

@@ -1,4 +1,4 @@
-import { type DefaultTypeProps, type OmegaFormState } from "./OmegaFormStuff";
+import { type DefaultTypeProps, type OmegaFormState } from "./types";
 import { type OmegaFormReturn } from "./useOmegaForm";
 declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, K extends keyof OmegaFormState<From, To> = keyof OmegaFormState<From, To>, Props = DefaultTypeProps>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{

package/dist/types/components/OmegaForm/createUseFormWithCustomInput.d.ts

@@ -1,4 +1,4 @@
 import { type Component } from "vue";
-import { type DefaultTypeProps } from "./OmegaFormStuff";
+import { type DefaultTypeProps } from "./types";
 import { useOmegaForm } from "./useOmegaForm";
-export declare const createUseFormWithCustomInput: <TypeProps = DefaultTypeProps>(CustomInputComponent: Component) => <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>>(...args: Parameters<typeof useOmegaForm<From, To>>) => import("./useOmegaForm").OmegaFormReturn<From, To, TypeProps>;
+export declare const createUseFormWithCustomInput: <TypeProps = DefaultTypeProps>(CustomInputComponent: Component) => <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>>(...args: Parameters<typeof useOmegaForm<From, To>>) => import("./types").OmegaFormReturn<From, To, TypeProps>;

package/dist/types/components/OmegaForm/errors.d.ts

@@ -0,0 +1,33 @@
+import { type Component, type ComputedRef, type ConcreteComponent, type Ref } from "vue";
+import type { OF } from "./useOmegaForm";
+export declare const useErrorLabel: (form: OF<any, any>) => (propsName: string) => string;
+export declare const eHoc: (errorProps: {
+    form: OF<any, any>;
+    fieldMap: Ref<Map<string, {
+        id: string;
+        label: string;
+    }>>;
+}) => <P>(WrappedComponent: Component<P>) => ConcreteComponent<P>;
+export declare const makeFieldMap: () => {
+    fieldMap: Ref<Map<string, {
+        label: string;
+        id: string;
+    }> & Omit<Map<string, {
+        label: string;
+        id: string;
+    }>, keyof Map<any, any>>, Map<string, {
+        label: string;
+        id: string;
+    }> | (Map<string, {
+        label: string;
+        id: string;
+    }> & Omit<Map<string, {
+        label: string;
+        id: string;
+    }>, keyof Map<any, any>>)>;
+    registerField: (field: ComputedRef<{
+        name: string;
+        label: string;
+        id: string;
+    }>) => void;
+};

package/dist/types/components/OmegaForm/getOmegaStore.d.ts

@@ -1,3 +1,3 @@
 import { type Ref } from "vue";
-import type { OmegaFormApi, OmegaFormState } from "./OmegaFormStuff";
+import type { OmegaFormApi, OmegaFormState } from "./types";
 export declare function getOmegaStore<To, From, K extends keyof OmegaFormState<To, From> = keyof OmegaFormState<To, From>>(form: OmegaFormApi<To, From>, subscribe?: K[]): Ref<K[] extends undefined[] ? Record<string, never> : Pick<OmegaFormState<To, From>, K>>;

package/dist/types/components/OmegaForm/hocs.d.ts

@@ -0,0 +1,3 @@
+import { type Component, type ConcreteComponent } from "vue";
+import type { OF } from "./useOmegaForm";
+export declare const fHoc: (form: OF<any, any>) => <P>(WrappedComponent: Component<P>) => ConcreteComponent<P>;

package/dist/types/components/OmegaForm/index.d.ts

@@ -1,10 +1,20 @@
-export * from "./OmegaFormStuff";
-export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm";
+import type { S } from "effect-app";
+export { getInputType, type SupportedInputs } from "./inputs";
+export { createMeta, generateMetaFromSchema, isNullableOrUndefined, metadataFromAst } from "./meta/createMeta";
+export type { CreateMeta, FilterItems } from "./meta/createMeta";
+export { defaultsValueFromSchema } from "./meta/defaults";
+export { toFormSchema } from "./meta/redacted";
+export type { BaseFieldMeta, BooleanFieldMeta, DateFieldMeta, FieldMeta, MetaRecord, MultipleFieldMeta, NestedKeyOf, NumberFieldMeta, SelectFieldMeta, StringFieldMeta, UnknownFieldMeta } from "./meta/types";
+export { deepMerge } from "./persistency";
+export type { BaseProps, DefaultTypeProps, FieldPath, FieldPath_, FieldValidators, FormComponent, FormProps, FormType, OmegaArrayProps, OmegaAutoGenMeta, OmegaError, OmegaFormApi, OmegaFormParams, OmegaFormState, OmegaInputProps, OmegaInputPropsBase, PrefixFromDepth, TypeOverride, TypesWithOptions } from "./types";
+export { makeStandardSchemaV1Hooks, toLocalizedStandardSchemaV1 } from "./validation/localized";
+export { FormErrors, OmegaFormKey, useErrorLabel, useOmegaForm } from "./useOmegaForm";
+export type { defaultValuesPriorityUnion, OF, OmegaConfig, OmegaFormReturn, Policies } from "./useOmegaForm";
 export { type ExtractTagValue, type ExtractUnionBranch, type InputProps, type MergedInputProps, type TaggedUnionOption, type TaggedUnionOptionsArray, type TaggedUnionProps } from "./InputProps";
 export { default as OmegaInput } from "./OmegaInput.vue";
 export { default as OmegaVuetifyInput } from "./OmegaInternalInput.vue";
 export { default as OmegaTaggedUnion } from "./OmegaTaggedUnion.vue";
 export { default as OmegaTaggedUnionInternal } from "./OmegaTaggedUnionInternal.vue";
 export { useOnClose, usePreventClose } from "./blockDialog";
-export { getInputType } from "./OmegaFormStuff";
 export { createUseFormWithCustomInput } from "./createUseFormWithCustomInput";
+export declare const duplicateSchema: <From, To>(schema: S.Codec<To, From>) => S.Codec<To, From, never, never>;

package/dist/types/components/OmegaForm/inputs.d.ts

@@ -0,0 +1,4 @@
+declare const supportedInputs: readonly ["button", "checkbox", "color", "date", "email", "number", "password", "radio", "range", "search", "submit", "tel", "text", "time", "url"];
+export type SupportedInputs = typeof supportedInputs[number];
+export declare const getInputType: (input: string) => SupportedInputs;
+export {};

package/dist/types/components/OmegaForm/meta/checks.d.ts

@@ -0,0 +1,4 @@
+import { S } from "effect-app";
+import type { FieldMeta } from "./types";
+export declare const getCheckMetas: (property: S.AST.AST) => Array<Record<string, any>>;
+export declare const getFieldMetadataFromAst: (property: S.AST.AST) => Partial<FieldMeta> & Record<string, unknown>;

package/dist/types/components/OmegaForm/meta/createMeta.d.ts

@@ -0,0 +1,32 @@
+import { type Effect, S } from "effect-app";
+import type { FieldMeta, MetaRecord } from "./types";
+export type FilterItems = {
+    items: readonly [string, ...string[]];
+    message: string | Effect.Effect<string> | {
+        readonly message: string | Effect.Effect<string>;
+    };
+};
+export type CreateMeta = {
+    parent?: string;
+    meta?: Record<string, any>;
+    nullableOrUndefined?: false | "undefined" | "null";
+} & ({
+    propertySignatures: readonly S.AST.PropertySignature[];
+    property?: never;
+} | {
+    propertySignatures?: never;
+    property: S.AST.AST;
+});
+export declare const unwrapDeclaration: (property: S.AST.AST) => S.AST.AST;
+export declare const isNullableOrUndefined: (property: false | S.AST.AST | undefined) => false | "undefined" | "null";
+export declare const createMeta: <T = any>({ meta, parent, property, propertySignatures }: CreateMeta, acc?: Partial<MetaRecord<T>>) => MetaRecord<T> | FieldMeta;
+export declare const metadataFromAst: <From, To>(schema: S.Codec<To, From>) => {
+    meta: MetaRecord<To>;
+    defaultValues: Record<string, any>;
+    unionMeta: Record<string, MetaRecord<To>>;
+};
+export declare const generateMetaFromSchema: <From, To>(schema: S.Codec<To, From>) => {
+    schema: S.Codec<To, From>;
+    meta: MetaRecord<To>;
+    unionMeta: Record<string, MetaRecord<To>>;
+};

package/dist/types/components/OmegaForm/meta/defaults.d.ts

@@ -0,0 +1,2 @@
+import { S } from "effect-app";
+export declare const defaultsValueFromSchema: (schema: S.Schema<any>, record?: Record<string, any>) => any;

package/dist/types/components/OmegaForm/meta/redacted.d.ts

@@ -0,0 +1,2 @@
+import { S } from "effect-app";
+export declare const toFormSchema: <From, To>(schema: S.Codec<To, From>) => S.Codec<To, From>;

package/dist/types/components/OmegaForm/meta/types.d.ts

@@ -0,0 +1,56 @@
+import type { DeepKeys } from "@tanstack/vue-form";
+import type { S } from "effect-app";
+import type { Redacted } from "effect/Redacted";
+type StripRedacted<T> = T extends Redacted<any> ? string : T extends ReadonlyArray<infer U> ? ReadonlyArray<StripRedacted<U>> : T extends Record<string, any> ? {
+    [K in keyof T]: StripRedacted<T[K]>;
+} : T;
+export type NestedKeyOf<T> = DeepKeys<StripRedacted<T>>;
+export type BaseFieldMeta = {
+    required: boolean;
+    nullableOrUndefined?: false | "undefined" | "null";
+    /**
+     * True when the schema property is `S.optionalKey` (AST
+     * `context.isOptional`) — i.e. the key should be ABSENT from the submitted
+     * object when empty, not present with `undefined`. Distinct from
+     * `required: false`, which may also mean "empty string is valid" for
+     * unconstrained `S.String` fields.
+     */
+    isOptionalKey?: boolean;
+};
+export type StringFieldMeta = BaseFieldMeta & {
+    type: "string";
+    maxLength?: number;
+    minLength?: number;
+    format?: string;
+};
+export type NumberFieldMeta = BaseFieldMeta & {
+    type: "number";
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    refinement?: "int";
+};
+export type SelectFieldMeta = BaseFieldMeta & {
+    type: "select";
+    members: any[];
+};
+export type MultipleFieldMeta = BaseFieldMeta & {
+    type: "multiple";
+    members: any[];
+    rest: readonly S.AST.AST[];
+};
+export type BooleanFieldMeta = BaseFieldMeta & {
+    type: "boolean";
+};
+export type DateFieldMeta = BaseFieldMeta & {
+    type: "date";
+};
+export type UnknownFieldMeta = BaseFieldMeta & {
+    type: "unknown";
+};
+export type FieldMeta = StringFieldMeta | NumberFieldMeta | SelectFieldMeta | MultipleFieldMeta | BooleanFieldMeta | DateFieldMeta | UnknownFieldMeta;
+export type MetaRecord<T = string> = {
+    [K in NestedKeyOf<T>]?: FieldMeta;
+};
+export {};

package/dist/types/components/OmegaForm/meta/walker.d.ts

@@ -0,0 +1,18 @@
+import { S } from "effect-app";
+import type { FieldMeta, MetaRecord } from "./types";
+export type WalkerContext<T> = {
+    acc: Partial<MetaRecord<T>>;
+    unionMeta: Record<string, MetaRecord<T>>;
+};
+export type ParentMeta = {
+    required: boolean;
+    nullableOrUndefined: false | "null" | "undefined";
+    /** Set when iterating the members of a nullable discriminated union */
+    isNullableDiscriminatedUnion?: boolean;
+    /** Set when this property was declared with S.optionalKey */
+    isOptionalKey?: boolean;
+};
+export declare const leafMetaForAst: (ast: S.AST.AST, parentMeta: ParentMeta) => FieldMeta;
+export declare const walkStruct: <T>(propertySignatures: readonly S.AST.PropertySignature[], parent: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;
+export declare const classifyAndWalkUnion: <T>(unionAst: S.AST.Union, key: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;
+export declare const walk: <T>(ast: S.AST.AST, key: string, parentMeta: ParentMeta, ctx: WalkerContext<T>) => void;

package/dist/types/components/OmegaForm/persistency.d.ts

@@ -0,0 +1,58 @@
+import { type ComputedRef } from "vue";
+import { type MetaRecord } from "./meta/types";
+export type Policies = "local" | "session" | "querystring";
+export type DefaultValuesPriorityUnion = "tanstack" | "persistency" | "schema";
+export type defaultValuesPriorityUnion = DefaultValuesPriorityUnion;
+export interface PersistencyConfig {
+    /** Order of importance:
+     * - "querystring": Highest priority when persisting
+     * - "local" and then "session": Lower priority storage options
+     */
+    policies?: ReadonlyArray<Policies>;
+    overrideDefaultValues?: "deprecated: use defaultValuesPriority";
+    id?: string;
+    keys?: ReadonlyArray<string> | "You should only use one of banKeys or keys, not both, moron";
+    banKeys?: ReadonlyArray<string> | "You should only use one of banKeys or keys, not both, moron";
+}
+export declare function deepMerge(target: any, source: any): any;
+export interface UsePersistencyOptions<From> {
+    meta: MetaRecord<From>;
+    persistency?: PersistencyConfig;
+    preventWindowExit?: "prevent" | "prevent-and-reset" | "nope";
+    defaultValuesPriority?: DefaultValuesPriorityUnion[] | readonly DefaultValuesPriorityUnion[];
+    /** Tanstack-provided default values (highest priority by default). */
+    tanstackDefaultValues?: any;
+    /** Lazy schema-derived defaults factory. */
+    schemaDefaultValues: () => any;
+    /**
+     * Lazy accessor for the form. Lazy because persistency is created BEFORE
+     * the form (its `defaultValues` are passed into `useForm`), but the
+     * persistence callbacks (`persistData`, `saveDataInUrl`, the
+     * `beforeunload` listener) only run later and need the live form.
+     */
+    getForm: () => {
+        store: {
+            state: {
+                values: any;
+                isDirty: boolean;
+            };
+        };
+        getFieldValue: (path: any) => any;
+    };
+}
+export interface UsePersistencyReturn {
+    defaultValues: ComputedRef;
+    persistencyKey: ComputedRef<string>;
+    persistData: () => void;
+    saveDataInUrl: () => void;
+    clearUrlParams: () => void;
+}
+/**
+ * Encapsulates form-data persistency: loading default values from
+ * localStorage / sessionStorage / querystring, persisting them on unmount
+ * or window blur, and the optional `preventWindowExit` warning listener.
+ *
+ * The `prevent-and-reset` reset-on-success behavior is intentionally NOT
+ * owned here — the consumer wires that to its own form submit lifecycle.
+ */
+export declare const usePersistency: <From>(opts: UsePersistencyOptions<From>) => UsePersistencyReturn;

package/dist/types/components/OmegaForm/submit.d.ts

@@ -0,0 +1,60 @@
+import * as api from "@opentelemetry/api";
+import type { DeepKeys, StandardSchemaV1Issue, ValidationError, ValidationErrorMap } from "@tanstack/vue-form";
+import { Effect } from "effect-app";
+import type { Fiber as EffectFiber } from "effect/Fiber";
+import type { OmegaFormApi, OmegaFormParams } from "./types";
+declare const FormErrors_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FormErrors";
+} & Readonly<A>;
+export declare class FormErrors<From> extends FormErrors_base<{
+    form: {
+        errors: (Record<string, StandardSchemaV1Issue[]> | undefined)[];
+        errorMap: ValidationErrorMap<undefined, undefined, Record<string, StandardSchemaV1Issue[]>, undefined, undefined, undefined, undefined, undefined, undefined, undefined>;
+    };
+    fields: Record<DeepKeys<From>, {
+        errors: ValidationError[];
+        errorMap: ValidationErrorMap;
+    }>;
+}> {
+}
+export declare const wrapWithSpan: (span: api.Span | undefined, toWrap: () => any) => any;
+export type UserOnSubmit<From, To> = (props: {
+    formApi: OmegaFormParams<From, To>;
+    meta: any;
+    value: To;
+}) => Promise<any> | EffectFiber<any, any> | Effect.Effect<unknown, any>;
+export type RunPromise = <A, E>(eff: Effect.Effect<A, E>) => Promise<A>;
+/**
+ * Wraps the user's `onSubmit` to:
+ * - run inside the OpenTelemetry span passed via `meta.currentSpan`
+ * - decode the raw form `value` (validators only validate, they don't transform)
+ * - normalize Promise / Effect / Fiber return values to a Promise
+ *
+ * Returns `undefined` when `userOnSubmit` is `undefined` (so callers can pass it
+ * directly to `useForm({ onSubmit })` without changing semantics).
+ */
+export declare const wrapOnSubmit: <From, To>(userOnSubmit: UserOnSubmit<From, To> | undefined, decode: (value: From) => Effect.Effect<To, any>, runPromise: RunPromise) => (({ formApi, meta, value }: {
+    formApi: OmegaFormParams<From, To>;
+    meta: any;
+    value: From;
+}) => any) | undefined;
+/**
+ * Builds the public submit handlers from a `useForm`-returned `form`:
+ * - `handleSubmit` injects the current OpenTelemetry span as `meta.currentSpan`.
+ * - `handleSubmitEffect` runs `handleSubmit` inside an Effect that picks up the
+ *   ambient `Effect.currentSpan`. With `checkErrors: true`, it fails with
+ *   `FormErrors<From>` when validation produced errors.
+ */
+export declare const makeSubmitHandlers: <From, To>(form: OmegaFormApi<From, To>) => {
+    handleSubmit: (meta?: Record<string, any>) => Promise<void>;
+    handleSubmitEffect: {
+        (options: {
+            checkErrors: true;
+            meta?: Record<string, any>;
+        }): Effect.Effect<void, FormErrors<From>>;
+        (options?: {
+            meta?: Record<string, any>;
+        }): Effect.Effect<void>;
+    };
+};
+export {};