@chelone/vue 0.5.0 → 0.7.0

package/dist/data/use-refresh.js

@@ -1,17 +1,33 @@
-import { useQueryClient, useIsFetching, useIsMutating } from "@tanstack/vue-query";
 import { computed } from "vue";
+import { useIsFetching, useIsMutating, useQueryClient } from "@tanstack/vue-query";
+// src/data/use-refresh.ts
+/**
+* `useRefresh` / `useLoading` — the Vue twins of `@chelone/react`'s
+* `compat-hooks.ts` (`useRefresh` / `useLoading`). Both wrap
+* `@tanstack/vue-query` against the SAME `queryClient` `<Admin>` provides.
+* `<RefreshButton>` is the consumer: it invalidates every query on click and
+* disables while any request is in flight.
+*/
+/**
+* Trigger a full refresh (ra `useRefresh` parity). The returned callback
+* invalidates EVERY query (no filter) so the active ones refetch. Stable — the
+* `queryClient` identity never changes within an `<Admin>`.
+*/
 function useRefresh() {
-  const queryClient = useQueryClient();
-  return () => {
-    queryClient.invalidateQueries();
-  };
+	const queryClient = useQueryClient();
+	return () => {
+		queryClient.invalidateQueries();
+	};
 }
+/**
+* Global data-connection state (ra `useLoading` parity): `true` while ANY query
+* or mutation is pending. The Vue twin needs no manual cache subscription — the
+* `useIsFetching` / `useIsMutating` composables already return reactive refs
+* over the two caches; this just ORs their counts into a boolean.
+*/
 function useLoading() {
-  const isFetching = useIsFetching();
-  const isMutating = useIsMutating();
-  return computed(() => isFetching.value > 0 || isMutating.value > 0);
+	const isFetching = useIsFetching();
+	const isMutating = useIsMutating();
+	return computed(() => isFetching.value > 0 || isMutating.value > 0);
 }
-export {
-  useLoading,
-  useRefresh
-};
+export { useLoading, useRefresh };

package/dist/form/field-error.d.ts

@@ -1,11 +1 @@
-/**
- * Field error normalization — the Vue twin of `@chelone/react`'s
- * `field-error.ts`. form-core stores errors as `unknown` under an error-map
- * keyed by validation cause; this projects the FIRST displayable error to a
- * `string | TranslatableMessage` (ra's translatable-error contract) using core's
- * `normalizeFormError` boundary. Inputs render that payload through i18n — never
- * a raw `error.root.message` or a `@@react-admin@@` string.
- */
-import { type TranslatableMessage } from "@chelone/core";
-/** The first displayable error across a field's error-map causes, normalized. */
-export declare function firstFieldError(errorMap: object): string | TranslatableMessage | undefined;
+export { firstFieldError } from "@chelone/core";

package/dist/form/field-error.js

@@ -1,20 +1 @@
-import { normalizeFormError } from "@chelone/core";
-const ERROR_MAP_PRIORITY = [
-  "onSubmit",
-  "onDynamic",
-  "onChange",
-  "onBlur",
-  "onMount",
-  "onServer"
-];
-function firstFieldError(errorMap) {
-  const map = errorMap;
-  for (const cause of ERROR_MAP_PRIORITY) {
-    const normalized = normalizeFormError(map[cause]);
-    if (normalized !== void 0) return normalized;
-  }
-  return void 0;
-}
-export {
-  firstFieldError
-};
+export { firstFieldError } from "@chelone/core";

package/dist/form/form-context.d.ts

@@ -7,23 +7,21 @@
  * Idiom translation from the React twin: React threads the form through a
  * `createContext` provider read with `useContext`. Vue `provide`s it once (by
  * `useForm`, in `setup`) under a typed `InjectionKey` and reads it with `inject`,
- * so the inject site is fully typed with no cast. A React context cannot be
- * generic, so — exactly as the React twin does — providers widen their
- * `CheloneFormApi<TFormData>` to the erased `Record<string, unknown>` shape;
- * field paths are runtime strings and values `unknown`, so nothing downstream
- * needs the precise type back.
+ * so the inject site is fully typed with no cast. A context spans every record
+ * below it, so it carries a {@link FormContextHandle}: a union of record-typed
+ * handles tagged by resource, plus the unbound handle of a form with no
+ * resource. A library input reads `form.ambient`, which every member has; app
+ * code narrows with {@link useFormHandle}.
  */
-import type { CheloneFormApi, SourceScope } from "@chelone/core";
+import type { AnyFormHandle, CheloneFormApi, FormContextHandle, HandleName, RegisteredResourceName, ResourceFormHandle, SourceScope } from "@chelone/core";
 import { type InjectionKey } from "vue";
-/** The erased form-data shape ambient (context-provided) forms carry. */
-type UnknownFormValues = Record<string, unknown>;
 /**
- * What input consumers need from an ambient form: the FormApi (field bindings
- * hang off it) and the controller's submit pipeline (submit-on-enter, toolbar
- * buttons). Provided by `useForm`.
+ * What input consumers need from an ambient form: the handle (field bindings
+ * hang off its `ambient`) and the controller's submit pipeline (submit-on-enter,
+ * toolbar buttons). Provided by `useForm`.
  */
 export interface CheloneFormContextValue {
-    form: CheloneFormApi<UnknownFormValues>;
+    form: FormContextHandle;
     submit: (() => Promise<void>) | undefined;
 }
 /**
@@ -31,15 +29,45 @@ export interface CheloneFormContextValue {
  * reads it via {@link useCheloneFormContext}.
  */
 export declare const CheloneFormContextKey: InjectionKey<CheloneFormContextValue>;
-/** Provide the ambient form to the subtree (called by `useForm` in `setup`). */
+/**
+ * Provide the ambient form to the subtree (called by `useForm` in `setup`).
+ * `resource` tags the handle; a form with none provides the unbound handle.
+ */
 export declare function provideCheloneForm<TFormData>(value: {
     form: CheloneFormApi<TFormData>;
     submit?: () => Promise<void>;
+    resource?: string;
 }): void;
 /** The ambient form context; throws without a `useForm` provider above. */
 export declare function useCheloneFormContext(): CheloneFormContextValue;
 /** The ambient form context, or `null` when no `useForm` provider is above. */
 export declare function useOptionalCheloneFormContext(): CheloneFormContextValue | null;
+/**
+ * The member of the handle union `THandle` that edits `TName`. A union that
+ * names no such member (nothing registered) falls back to a bare
+ * {@link ResourceFormHandle}, whose values are unchecked.
+ */
+export type NamedFormHandle<THandle extends AnyFormHandle, TName extends string> = [Extract<THandle, {
+    resource: TName;
+}>] extends [never] ? ResourceFormHandle<TName> : Extract<THandle, {
+    resource: TName;
+}>;
+/**
+ * The ambient form handle: the whole {@link FormContextHandle} union without a
+ * name, or the member that edits `name`, narrowed to its record, with one. The
+ * named form is `undefined` when the ambient form edits another resource or
+ * none. Throws without a `useForm` provider above.
+ */
+export declare function useFormHandle(): FormContextHandle;
+export declare function useFormHandle<TName extends RegisteredResourceName>(name: TName): NamedFormHandle<FormContextHandle, TName> | undefined;
+/**
+ * What {@link useFormHandle} does with the handle it injects, over any handle
+ * union: the union itself without a name, or the member that edits `name`.
+ * Split out so a type test can run it over an explicit resource map, since
+ * registering resources is global to a type-check run.
+ */
+export declare function readFormHandle<THandle extends AnyFormHandle>(handle: THandle): THandle;
+export declare function readFormHandle<THandle extends AnyFormHandle, TName extends HandleName<THandle>>(handle: THandle, name: TName): NamedFormHandle<THandle, TName> | undefined;
 /**
  * The provide/inject key for the ambient source scope (ra's SourceContext).
  * Composed inputs (iterator rows, grouped inputs — a later wave) prefix their
@@ -55,4 +83,3 @@ export declare function provideSourceScope(scope: SourceScope): void;
 export declare function useSourceScope(): SourceScope;
 /** The FINAL field path for `source` under the ambient scope (ra parity). */
 export declare function useWrappedSource(source: string): string;
-export {};

package/dist/form/form-context.js

@@ -1,44 +1,58 @@
-import { rootSourceScope } from "@chelone/core";
 import { inject, provide } from "vue";
-const CheloneFormContextKey = /* @__PURE__ */ Symbol("chelone-form-context");
+import { createFormHandle, isResourceHandle, rootSourceScope, toFormContextHandle } from "@chelone/core";
+// src/form/form-context.ts
+/**
+* The provide/inject key for the ambient form. `useForm` provides it; `useInput`
+* reads it via {@link useCheloneFormContext}.
+*/
+var CheloneFormContextKey = Symbol("chelone-form-context");
+/**
+* Provide the ambient form to the subtree (called by `useForm` in `setup`).
+* `resource` tags the handle; a form with none provides the unbound handle.
+*/
 function provideCheloneForm(value) {
-  provide(CheloneFormContextKey, {
-    // Erasure cast only — the runtime object is untouched.
-    form: value.form,
-    submit: value.submit
-  });
+	provide(CheloneFormContextKey, {
+		form: toFormContextHandle(createFormHandle(value.form), value.resource),
+		submit: value.submit
+	});
 }
+/** The ambient form context; throws without a `useForm` provider above. */
 function useCheloneFormContext() {
-  const ctx = inject(CheloneFormContextKey, null);
-  if (!ctx) {
-    throw new Error(
-      "useCheloneFormContext: no ambient form found. Call useForm() in an ancestor setup() (e.g. an <Edit>/<Create> view) above this input."
-    );
-  }
-  return ctx;
+	const ctx = inject(CheloneFormContextKey, null);
+	if (!ctx) throw new Error("useCheloneFormContext: no ambient form found. Call useForm() in an ancestor setup() (e.g. an <Edit>/<Create> view) above this input.");
+	return ctx;
 }
+/** The ambient form context, or `null` when no `useForm` provider is above. */
 function useOptionalCheloneFormContext() {
-  return inject(CheloneFormContextKey, null);
+	return inject(CheloneFormContextKey, null);
 }
-const SourceScopeKey = /* @__PURE__ */ Symbol(
-  "chelone-source-scope"
-);
+function useFormHandle(name) {
+	const { form } = useCheloneFormContext();
+	return name === void 0 ? readFormHandle(form) : readFormHandle(form, name);
+}
+function readFormHandle(handle, name) {
+	if (name === void 0) return handle;
+	return isResourceHandle(handle, name) ? handle : void 0;
+}
+/**
+* The provide/inject key for the ambient source scope (ra's SourceContext).
+* Composed inputs (iterator rows, grouped inputs — a later wave) prefix their
+* children's `source`; the default is the identity scope, so top-level inputs
+* need no provider. The scope OBJECT comes from core
+* (`createRowSourceScope`/`createArraySourceScope`) — this file only transports
+* it.
+*/
+var SourceScopeKey = Symbol("chelone-source-scope");
+/** Scopes every `useInput`/`useWrappedSource` below to `scope`. */
 function provideSourceScope(scope) {
-  provide(SourceScopeKey, scope);
+	provide(SourceScopeKey, scope);
 }
+/** The ambient source scope — the identity scope when no provider is above. */
 function useSourceScope() {
-  return inject(SourceScopeKey, rootSourceScope);
+	return inject(SourceScopeKey, rootSourceScope);
 }
+/** The FINAL field path for `source` under the ambient scope (ra parity). */
 function useWrappedSource(source) {
-  return useSourceScope().getSource(source);
-}
-export {
-  CheloneFormContextKey,
-  SourceScopeKey,
-  provideCheloneForm,
-  provideSourceScope,
-  useCheloneFormContext,
-  useOptionalCheloneFormContext,
-  useSourceScope,
-  useWrappedSource
-};
+	return useSourceScope().getSource(source);
+}
+export { CheloneFormContextKey, SourceScopeKey, provideCheloneForm, provideSourceScope, readFormHandle, useCheloneFormContext, useFormHandle, useOptionalCheloneFormContext, useSourceScope, useWrappedSource };

package/dist/form/form-group-provider.js

@@ -0,0 +1,4 @@
+import form_group_provider_vue_vue_type_script_setup_true_lang_default from "./form-group-provider.vue_vue_type_script_setup_true_lang.js";
+// src/form/form-group-provider.vue
+var form_group_provider_default = form_group_provider_vue_vue_type_script_setup_true_lang_default;
+export { form_group_provider_default as default };

package/dist/form/form-group-provider.vue.d.ts

@@ -3,10 +3,11 @@ export interface FormGroupProviderProps {
     /** The group name inputs below auto-register into (tab/step name). */
     name: string;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormGroupProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FormGroupProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;
-export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/form/form-group-provider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,19 @@
+import { provideFormGroup } from "./form-groups.js";
+import { defineComponent, renderSlot } from "vue";
+// src/form/form-group-provider.vue?vue&type=script&setup=true&lang.ts
+var form_group_provider_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "form-group-provider",
+	props: { name: {} },
+	setup(__props) {
+		/**
+		* `<FormGroupProvider>` — scopes every `useInput` below into the named group.
+		* Nest under `<FormGroupsProvider>`. Renders its default slot only.
+		*/
+		const props = __props;
+		provideFormGroup(() => props.name);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+export { form_group_provider_vue_vue_type_script_setup_true_lang_default as default };

package/dist/form/form-groups-provider.js

@@ -0,0 +1,4 @@
+import form_groups_provider_vue_vue_type_script_setup_true_lang_default from "./form-groups-provider.vue_vue_type_script_setup_true_lang.js";
+// src/form/form-groups-provider.vue
+var form_groups_provider_default = form_groups_provider_vue_vue_type_script_setup_true_lang_default;
+export { form_groups_provider_default as default };

package/dist/form/form-groups-provider.vue.d.ts

@@ -4,10 +4,11 @@ export interface FormGroupsProviderProps {
     /** An externally created registry (advanced/testing). Omit to create one. */
     groups?: FormGroups;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<FormGroupsProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<FormGroupsProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FormGroupsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 }>;
-export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/form/form-groups-provider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,19 @@
+import { provideFormGroups } from "./form-groups.js";
+import { defineComponent, renderSlot } from "vue";
+// src/form/form-groups-provider.vue?vue&type=script&setup=true&lang.ts
+var form_groups_provider_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "form-groups-provider",
+	props: { groups: {} },
+	setup(__props) {
+		/**
+		* `<FormGroupsProvider>` — provides one `FormGroups` registry to the form
+		* subtree. Renders its default slot only; place it below the form's `useForm`.
+		*/
+		const props = __props;
+		provideFormGroups(() => props.groups);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
+	}
+});
+export { form_groups_provider_vue_vue_type_script_setup_true_lang_default as default };

package/dist/form/form-groups.d.ts

@@ -1,7 +1,7 @@
 /**
  * FormGroups Vue layer — the twin of `@chelone/react`'s `group-hooks.tsx`. Wires
  * core's string-membership `createFormGroups` registry to the ambient form's
- * `form.store.state.fieldMeta` so a tab/step badge reads just its own members'
+ * `form.ambient.store.state.fieldMeta` so a tab/step badge reads just its own members'
  * validity.
  *
  * `useFormGroup` runs the reducer inside the consuming badge and swaps its ref

package/dist/form/form-groups.js

@@ -1,128 +1,141 @@
-import { createFormGroups, reduceGroupState } from "@chelone/core";
-import { inject, provide, computed, toValue, shallowRef, watch, onScopeDispose, watchEffect } from "vue";
 import { useCheloneFormContext } from "./form-context.js";
 import { subscribeStore } from "./subscribe-ref.js";
-const FormGroupsKey = /* @__PURE__ */ Symbol(
-  "chelone-form-groups"
-);
-const FormGroupNameKey = /* @__PURE__ */ Symbol(
-  "chelone-form-group-name"
-);
+import { computed, inject, onScopeDispose, provide, shallowRef, toValue, watch, watchEffect } from "vue";
+import { createFormGroups, reduceGroupState } from "@chelone/core";
+// src/form/form-groups.ts
+/**
+* FormGroups Vue layer — the twin of `@chelone/react`'s `group-hooks.tsx`. Wires
+* core's string-membership `createFormGroups` registry to the ambient form's
+* `form.ambient.store.state.fieldMeta` so a tab/step badge reads just its own members'
+* validity.
+*
+* `useFormGroup` runs the reducer inside the consuming badge and swaps its ref
+* only when the aggregate differs by value, so a keystroke in a field outside
+* the group never wakes the badge.
+*/
+var FormGroupsKey = Symbol("chelone-form-groups");
+var FormGroupNameKey = Symbol("chelone-form-group-name");
+/**
+* Provides one {@link FormGroups} registry to the subtree and returns the one
+* in effect now. Made with `createFormGroups()` unless an external registry is
+* passed. Pass a ref or getter to follow a changing prop: consumers switch to
+* the new registry.
+*/
 function provideFormGroups(groups) {
-  let created;
-  const registry = computed(() => {
-    const given = toValue(groups);
-    if (given) return given;
-    created ??= createFormGroups();
-    return created;
-  });
-  provide(FormGroupsKey, registry);
-  return registry.value;
+	let created;
+	const registry = computed(() => {
+		const given = toValue(groups);
+		if (given) return given;
+		created ??= createFormGroups();
+		return created;
+	});
+	provide(FormGroupsKey, registry);
+	return registry.value;
 }
+/** The ambient registry as a ref, so consumers can follow a swapped registry. */
 function useFormGroupsRef() {
-  return inject(FormGroupsKey, null) ?? void 0;
+	return inject(FormGroupsKey, null) ?? void 0;
+}
+/** The ambient registry as a ref; throws without a provider. */
+function requireFormGroupsRef() {
+	const registry = useFormGroupsRef();
+	if (!registry) throw new Error("useFormGroups: no <FormGroupsProvider> found above this component.");
+	return registry;
 }
+/** The ambient {@link FormGroups} registry; throws without a provider. */
 function useFormGroups() {
-  const registry = useFormGroupsRef();
-  if (!registry) {
-    throw new Error(
-      "useFormGroups: no <FormGroupsProvider> found above this component."
-    );
-  }
-  return registry.value;
+	return requireFormGroupsRef().value;
 }
+/** The ambient registry, or `undefined` so `useInput` never throws outside a grouped form. */
 function useOptionalFormGroups() {
-  return useFormGroupsRef()?.value;
+	return useFormGroupsRef()?.value;
 }
+/**
+* Scopes every `useInput` below into the group `name`. Pass a ref or getter to
+* follow a changing prop: inputs move to the new group. A nested scope adds to
+* the groups above it rather than replacing them, so an input joins every
+* enclosing group.
+*/
 function provideFormGroup(name) {
-  const parent = inject(FormGroupNameKey, void 0);
-  provide(
-    FormGroupNameKey,
-    computed(() => {
-      const own = toValue(name);
-      const above = parent?.value.names ?? [];
-      return {
-        name: own,
-        names: above.includes(own) ? above : [...above, own]
-      };
-    })
-  );
+	const parent = inject(FormGroupNameKey, void 0);
+	provide(FormGroupNameKey, computed(() => {
+		const own = toValue(name);
+		const above = parent?.value.names ?? [];
+		return {
+			name: own,
+			names: above.includes(own) ? above : [...above, own]
+		};
+	}));
 }
+/** The innermost ambient group name as a ref, `undefined` outside a `<FormGroupProvider>`. */
 function useFormGroupName() {
-  const scope = inject(FormGroupNameKey, void 0);
-  return computed(() => scope?.value.name);
+	const scope = inject(FormGroupNameKey, void 0);
+	return computed(() => scope?.value.name);
 }
+/**
+* Registers `source` into every enclosing group in setup, re-registers when the
+* groups or registry change, and unregisters on scope disposal. Does nothing
+* without a registry or a group name.
+*/
 function useRegisterFieldGroup(source) {
-  const registry = useFormGroupsRef();
-  const scope = inject(FormGroupNameKey, void 0);
-  if (!registry || !scope) return;
-  watchEffect(
-    (onCleanup) => {
-      const target = registry.value;
-      const names = scope.value.names;
-      for (const name of names) target.register(name, source);
-      onCleanup(() => {
-        for (const name of names) target.unregister(name, source);
-      });
-    },
-    { flush: "sync" }
-  );
+	const registry = useFormGroupsRef();
+	const scope = inject(FormGroupNameKey, void 0);
+	if (!registry || !scope) return;
+	watchEffect((onCleanup) => {
+		const target = registry.value;
+		const names = scope.value.names;
+		for (const name of names) target.register(name, source);
+		onCleanup(() => {
+			for (const name of names) target.unregister(name, source);
+		});
+	}, { flush: "sync" });
 }
 function sameDisplayError(a, b) {
-  if (a === b) return true;
-  if (typeof a === "string" || typeof b === "string") return false;
-  if (a.message !== b.message) return false;
-  const aArgs = a.args ?? {};
-  const bArgs = b.args ?? {};
-  const aKeys = Object.keys(aArgs);
-  if (aKeys.length !== Object.keys(bArgs).length) return false;
-  return aKeys.every((key) => aArgs[key] === bArgs[key]);
+	if (a === b) return true;
+	if (typeof a === "string" || typeof b === "string") return false;
+	if (a.message !== b.message) return false;
+	const aArgs = a.args ?? {};
+	const bArgs = b.args ?? {};
+	const aKeys = Object.keys(aArgs);
+	if (aKeys.length !== Object.keys(bArgs).length) return false;
+	return aKeys.every((key) => aArgs[key] === bArgs[key]);
 }
 function sameGroupState(a, b) {
-  if (a.isValid !== b.isValid || a.isDirty !== b.isDirty || a.isTouched !== b.isTouched || a.isValidating !== b.isValidating) {
-    return false;
-  }
-  const aKeys = Object.keys(a.errors);
-  if (aKeys.length !== Object.keys(b.errors).length) return false;
-  return aKeys.every((key) => {
-    const other = b.errors[key];
-    return other !== void 0 && sameDisplayError(a.errors[key], other);
-  });
+	if (a.isValid !== b.isValid || a.isDirty !== b.isDirty || a.isTouched !== b.isTouched || a.isValidating !== b.isValidating) return false;
+	const aKeys = Object.keys(a.errors);
+	if (aKeys.length !== Object.keys(b.errors).length) return false;
+	return aKeys.every((key) => {
+		const mine = a.errors[key];
+		const other = b.errors[key];
+		return mine !== void 0 && other !== void 0 && sameDisplayError(mine, other);
+	});
 }
+/**
+* The reactive aggregated state of the named group (tab/step badge), reduced
+* over the ambient form's `fieldMeta` for the group's current members. Pass a
+* ref or getter for `name` to follow a changing prop.
+*/
 function useFormGroup(name) {
-  useFormGroups();
-  const registry = useFormGroupsRef();
-  const { form } = useCheloneFormContext();
-  const reduce = () => reduceGroupState(
-    form.store.state.fieldMeta,
-    registry.value.getMembers(toValue(name))
-  );
-  const state = shallowRef(reduce());
-  const refresh = () => {
-    const next = reduce();
-    if (!sameGroupState(state.value, next)) state.value = next;
-  };
-  const stopStore = subscribeStore(form.store, refresh);
-  const stopWatch = watch(
-    [registry, () => toValue(name)],
-    (_, __, onCleanup) => {
-      onCleanup(registry.value.subscribe(refresh));
-      refresh();
-    },
-    { immediate: true, flush: "sync" }
-  );
-  onScopeDispose(() => {
-    stopStore();
-    stopWatch();
-  });
-  return state;
+	const registry = requireFormGroupsRef();
+	const { form } = useCheloneFormContext();
+	const reduce = () => reduceGroupState(form.ambient.store.state.fieldMeta, registry.value.getMembers(toValue(name)));
+	const state = shallowRef(reduce());
+	const refresh = () => {
+		const next = reduce();
+		if (!sameGroupState(state.value, next)) state.value = next;
+	};
+	const stopStore = subscribeStore(form.ambient.store, refresh);
+	const stopWatch = watch([registry, () => toValue(name)], (_, __, onCleanup) => {
+		onCleanup(registry.value.subscribe(refresh));
+		refresh();
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	onScopeDispose(() => {
+		stopStore();
+		stopWatch();
+	});
+	return state;
 }
-export {
-  provideFormGroup,
-  provideFormGroups,
-  useFormGroup,
-  useFormGroupName,
-  useFormGroups,
-  useOptionalFormGroups,
-  useRegisterFieldGroup
-};
+export { provideFormGroup, provideFormGroups, useFormGroup, useFormGroupName, useFormGroups, useOptionalFormGroups, useRegisterFieldGroup };

package/dist/form/form-scope.d.ts

@@ -16,8 +16,9 @@ import { type FormSubmit, type UseFormOptions } from "./use-form.js";
  *
  * The without-`save` member spells its keys out so `defineProps` can resolve
  * it; `form-scope.test-d.ts` pins the list against `UseFormOptions`.
+ * `recordForm` is not a prop: a form built from props edits the record.
  */
-export type OptionalSaveFormProps<TFormData> = (Omit<UseFormOptions<TFormData>, "onSubmit"> & {
+export type OptionalSaveFormProps<TFormData> = (Omit<UseFormOptions<TFormData>, "onSubmit" | "recordForm"> & {
     save: FormSubmit<TFormData>;
 }) | {
     save?: undefined;