@effect-app/vue-components 4.0.0-beta.31 → 4.0.0-beta.311

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.
@@ -190,7 +190,7 @@ In [tsconfig.json](tsconfig.js), set the following to address [Issue #32](https:
 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'
+import "@effect-app/vue-components/reset.css"
 ```
 
 ### 2. Nested union `_tag` handling
@@ -208,22 +208,26 @@ import '@effect-app/vue-components/reset.css'
 - **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

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

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

@@ -1,23 +1,42 @@
-import type { CommandBase } from "@effect-app/vue";
+import type { CommandBase, Progress } from "@effect-app/vue/makeClient";
+import * as Option from "effect-app/Option";
+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 {
 }
-/** Command Button is an easy way to connect commands and have it execute on click, while keeping track of disabled/loading states automatically */
+/**
+ * CommandButton connects a command to a button and tracks disabled / loading state.
+ *
+ * Input variants:
+ * - `input`: pass a validated value; button enabled when command + disabled allow it.
+ * - `optionalInput`: pass an `Option<I>`. `Some` → enabled, click fires with the value.
+ *   `None` → disabled. Use this when the input is gated by a `computed` instead of
+ *   a `v-if` on the button itself.
+ * - neither: command takes no input.
+ */
 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>;
+        optionalInput?: undefined;
+        command: CommandBase<I, any, RA, RE>;
         empty?: boolean;
     } | {
-        command: CommandBase;
+        optionalInput: Option.Option<NoInfer<I>>;
         input?: undefined;
+        command: CommandBase<I, any, RA, RE>;
+        empty?: boolean;
+    } | {
+        command: CommandBase<any, any, RA, RE>;
+        input?: undefined;
+        optionalInput?: 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/Dialog.vue.d.ts

@@ -9,8 +9,10 @@ declare var __VLS_11: {
     open: boolean;
     cancel: () => void;
     isActive: any;
-};
+}, __VLS_15: string, __VLS_16: any;
 type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_15>]?: (props: typeof __VLS_16) => any;
+} & {
     default?: (props: typeof __VLS_11) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

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

@@ -0,0 +1,39 @@
+type __VLS_Props = {
+    captureException: (err: Error, hint?: {
+        extra?: Record<string, unknown>;
+    }) => void;
+    toastError: (message: string) => void;
+    debug: boolean;
+    /** register the boundary only when true (backend passes import.meta.client; frontend omits → true) */
+    enabled?: boolean;
+    /** defer handling until app ready (backend: onNuxtReady while hydrating; frontend: omit → run now) */
+    scheduleAfterReady?: (fn: () => void) => void;
+    /** extra side-effect after emit, before error.value is set (backend: nuxtApp vue:error hook) */
+    onHandled?: (err: Error, instance: unknown, info: string) => void;
+};
+type __VLS_Slots = {
+    error(props: {
+        error: Error;
+        clearError: () => void;
+    }): any;
+    default(): any;
+};
+declare function clearError(): void;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    error: import("vue").ShallowRef<Error | null, Error | null>;
+    clearError: typeof clearError;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    error: (error: Error) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((error: Error) => any) | undefined;
+}>, {
+    enabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -16,7 +16,7 @@ export type InputProps<From extends Record<PropertyKey, any>, TName extends Deep
         inputClass: string | undefined | null;
     };
     field: OmegaFieldInternalApi<From, TName>;
-    /** be sure to use this state and not `field.state` as it is not reactive */
+    /** reactive field state, sourced from `field.state` (the Field slot's own `state` prop is a stale snapshot since @tanstack/vue-form 1.32) */
     state: OmegaFieldInternalApi<From, TName>["state"];
 };
 export type MergedInputProps<From extends Record<PropertyKey, any>, TName extends DeepKeys<From>> = InputProps<From, TName>["inputProps"] & Pick<InputProps<From, TName>, "field" | "state">;

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 * as Order from "effect/Order";
+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/OmegaInputVuetify.vue.d.ts

@@ -51,6 +51,12 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
             id: string;
             label: string;
         }) => any;
+    } & {
+        label?: (props: {
+            required: boolean | undefined;
+            id: string;
+            label: string;
+        }) => any;
     };
     emit: {
         (e: "focus", event: Event): void;

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 Component, 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 { 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>;
@@ -9,7 +10,6 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
         meta: MetaRecord<From>[NestedKeyOf<From>];
         label: string;
         type?: TypeOverride;
-        validators?: FieldValidators<From>;
         required?: boolean;
         inputClass?: string | null;
         register: (field: ComputedRef<{
@@ -19,8 +19,9 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
         }>) => void;
         options?: {
             title: string;
-            value: string;
+            value: unknown;
         }[];
+        inputs?: Record<string, Component>;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -43,11 +44,7 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, Name extends
             inputClass: string | undefined | null;
         }) => any;
     } & {
-        label?: (props: {
-            required: boolean | undefined;
-            id: string;
-            label: string;
-        }) => any;
+        label?: (props: any) => any;
     };
     emit: {};
 }>) => import("vue").VNode & {

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

@@ -15,8 +15,8 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends R
     attrs: any;
     slots: {
         [x: string]: ((props: {
-            field: import("./InputProps").OmegaFieldInternalApi<From, "_tag" | `${NonNullable<Name>}._tag`>;
-            state: NonNullable<import("@tanstack/vue-form").DeepValue<From, "_tag" | `${NonNullable<Name>}._tag`>>;
+            field: import("./InputProps").OmegaFieldInternalApi<From, DeepKeys<From>>;
+            tag: string;
         }) => any) | undefined;
     } & {
         OmegaCustomInput?: (props: {

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

@@ -1,9 +1,9 @@
-import { type DeepKeys, type DeepValue } from "@tanstack/vue-form";
+import { type DeepKeys } from "@tanstack/vue-form";
 import { type OmegaFieldInternalApi } from "./InputProps";
 import { type useOmegaForm } from "./useOmegaForm";
 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<{
-        state: DeepValue<From, Name>;
+        tag: string | null;
         field: OmegaFieldInternalApi<From, Name>;
         name?: DeepKeys<From>;
         form: ReturnType<typeof useOmegaForm<From, To>>;
@@ -15,7 +15,7 @@ declare const __VLS_export: <From extends Record<PropertyKey, any>, To extends R
     slots: {
         [x: string]: ((props: {
             field: OmegaFieldInternalApi<From, Name>;
-            state: NonNullable<DeepValue<From, Name>>;
+            tag: string;
         }) => any) | undefined;
     };
     emit: {};

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,6 @@
 import { type Component } from "vue";
-import { type DefaultTypeProps } from "./OmegaFormStuff";
+import type { OmegaConfig } 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: (CustomInputComponent: Component) => <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, const Cfg extends OmegaConfig<To> = OmegaConfig<To>>(schema: Parameters<typeof useOmegaForm<From, To>>[0], tanstackFormOptions?: Parameters<typeof useOmegaForm<From, To>>[1], omegaConfig?: Cfg) => import("./types").OmegaFormReturn<From, To, import("./types").TypePropsFor<Cfg extends {
+    inputs?: infer I;
+} ? I : {}>>;

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,21 @@
-export * from "./OmegaFormStuff";
-export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm";
+import type * as S from "effect-app/Schema";
+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 type { VuetifyInputProps, VuetifyInputProps as OmegaRendererProps } 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 * as S from "effect-app/Schema";
+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,33 @@
+import type * as Effect from "effect-app/Effect";
+import * as S from "effect-app/Schema";
+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,21 @@
+import * as S from "effect-app/Schema";
+export declare const defaultsValueFromSchema: (schema: S.Schema<any>, record?: Record<string, any>) => any;
+/**
+ * Deep-fills a partial form value with schema defaults for any nullable
+ * struct that has **materialised**.
+ *
+ * A nullable struct (`S.NullOr(S.Struct(...))`) left `null` stays `null`, but
+ * once it materialises — e.g. the user filled a single child — its untouched
+ * children are filled with their schema default (or `null` when nullable).
+ * Without this, strict `S.NullOr(...)` children reject the leftover
+ * `undefined` with a spurious "field must not be empty" error.
+ *
+ * Only children of a struct reached *through a nullable union* are filled;
+ * the always-present root struct keeps whatever fields it already has, so the
+ * form's own default-value priority is left untouched.
+ *
+ * Reference-preserving: returns `value` unchanged (same reference) when there
+ * is nothing to fill, so callers can detect a no-op with `===` and the result
+ * is idempotent (`fill(fill(v)) === fill(v)`).
+ */
+export declare const fillNestedDefaults: (ast: S.AST.AST, value: unknown, fillMissing?: boolean) => unknown;

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

@@ -0,0 +1,2 @@
+import * as S from "effect-app/Schema";
+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 * as S from "effect-app/Schema";
+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 {};