@chelone/vue 0.1.0 → 0.1.1

package/dist/admin/admin-shell.vue.js

@@ -4,7 +4,7 @@ import { useRoute, useRouter, START_LOCATION } from "vue-router";
 import _sfc_main$6 from "../components/admin/layout/layout.vue.js";
 import _sfc_main$1 from "../components/admin/layout/theme-provider.vue.js";
 import _sfc_main$4 from "../components/admin/auth/login-page.vue.js";
-import _sfc_main$3 from "../components/ui/spinner2.vue.js";
+import _sfc_main$3 from "../components/ui/spinner.vue.js";
 import { useBasename } from "../router/adapter.js";
 import { useWatchDataErrors } from "../auth/permissions-hooks.js";
 import { useAuthGate } from "./auth-gate.js";

package/dist/components/admin/auth/auth-callback.vue.js

@@ -1,6 +1,6 @@
 import { defineComponent, computed, unref, openBlock, createBlock, createElementBlock, createVNode } from "vue";
 import { useHandleAuthCallback } from "../../../admin/auth-gate.js";
-import _sfc_main$2 from "../../ui/spinner2.vue.js";
+import _sfc_main$2 from "../../ui/spinner.vue.js";
 import _sfc_main$1 from "./auth-error.vue.js";
 const _hoisted_1 = {
   key: 1,

package/dist/components/admin/auth/login-form.vue.js

@@ -6,7 +6,7 @@ import { useTranslate } from "../../../i18n/use-translate.js";
 import { cn } from "../../../lib/utils.js";
 import { useLogin } from "../../../auth/auth-hooks.js";
 import _sfc_main$2 from "../../ui/button.vue.js";
-import _sfc_main$3 from "../../ui/spinner2.vue.js";
+import _sfc_main$3 from "../../ui/spinner.vue.js";
 import _sfc_main$1 from "../inputs/text-input.vue.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "login-form",

package/dist/components/admin/auth/login-with-email.vue.js

@@ -6,7 +6,7 @@ import { useForm } from "../../../form/use-form.js";
 import { useTranslate } from "../../../i18n/use-translate.js";
 import { cn } from "../../../lib/utils.js";
 import _sfc_main$3 from "../../ui/button.vue.js";
-import _sfc_main$4 from "../../ui/spinner2.vue.js";
+import _sfc_main$4 from "../../ui/spinner.vue.js";
 import _sfc_main$2 from "../inputs/password-input.vue.js";
 import _sfc_main$1 from "../inputs/text-input.vue.js";
 import { LogInIcon } from "./icons.js";

package/dist/components/admin/feedback/loading-indicator.vue.js

@@ -2,7 +2,7 @@ import { defineComponent, computed, openBlock, createElementBlock, normalizeClas
 import { useLoading, useRefresh } from "../../../data/use-refresh.js";
 import { useTranslate } from "../../../i18n/use-translate.js";
 import { cn } from "../../../lib/utils.js";
-import _sfc_main$2 from "../../ui/spinner2.vue.js";
+import _sfc_main$2 from "../../ui/spinner.vue.js";
 import { RotateCwIcon } from "../buttons/icons.js";
 import _sfc_main$1 from "../common/icon-button-with-tooltip.vue.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/dist/components/admin/feedback/spinner.vue.js

@@ -1,6 +1,6 @@
 import { defineComponent, computed, openBlock, createBlock, normalizeClass, createCommentVNode } from "vue";
 import { cn } from "../../../lib/utils.js";
-import _sfc_main$1 from "../../ui/spinner2.vue.js";
+import _sfc_main$1 from "../../ui/spinner.vue.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "spinner",
   props: {

package/dist/components/admin/list/calendar-list.vue.js

@@ -98,8 +98,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     );
     const rangeStartISO = computed(() => range.value.start.toISOString());
     const rangeEndISO = computed(() => range.value.end.toISOString());
-    const LIST_DEFAULT_PER_PAGE = 10;
-    const originalPerPage = list.perPage === props.perPage ? LIST_DEFAULT_PER_PAGE : list.perPage;
+    const originalPerPage = list.perPage === props.perPage ? list.defaultPerPage ?? 10 : list.perPage;
     let appliedKeys = [];
     const without = (filter, keys) => Object.fromEntries(
       Object.entries(filter).filter(([key]) => !keys.includes(key))

package/dist/components/admin/list/count-spinner.vue.js

@@ -1,5 +1,5 @@
 import { defineComponent, unref, openBlock, createBlock, normalizeClass, createCommentVNode } from "vue";
-import _sfc_main$1 from "../../ui/spinner2.vue.js";
+import _sfc_main$1 from "../../ui/spinner.vue.js";
 import { useTimeout } from "../feedback/use-timeout.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "count-spinner",

package/dist/components/admin/supabase/forgot-password-form.vue.js

@@ -6,7 +6,7 @@ import { useForm } from "../../../form/use-form.js";
 import { useTranslate } from "../../../i18n/use-translate.js";
 import { cn } from "../../../lib/utils.js";
 import _sfc_main$2 from "../../ui/button.vue.js";
-import _sfc_main$3 from "../../ui/spinner2.vue.js";
+import _sfc_main$3 from "../../ui/spinner.vue.js";
 import _sfc_main$1 from "../inputs/text-input.vue.js";
 import { useResetPassword } from "./use-password-recovery.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/dist/components/admin/supabase/set-password-form.vue.js

@@ -6,7 +6,7 @@ import { useForm } from "../../../form/use-form.js";
 import { useTranslate } from "../../../i18n/use-translate.js";
 import { cn } from "../../../lib/utils.js";
 import _sfc_main$2 from "../../ui/button.vue.js";
-import _sfc_main$3 from "../../ui/spinner2.vue.js";
+import _sfc_main$3 from "../../ui/spinner.vue.js";
 import _sfc_main$1 from "../inputs/password-input.vue.js";
 import { useSupabaseUrlTokens, useSetPassword } from "./use-password-recovery.js";
 const _hoisted_1 = {

package/dist/components/maps-osm/osm-feature-operator.vue.js

@@ -6,7 +6,7 @@ import { useTranslate } from "../../i18n/use-translate.js";
 import { useNotify } from "../../notification-hooks.js";
 import { useMapsConfig } from "../maps/use-map.js";
 import _sfc_main$1 from "../ui/button.vue.js";
-import _sfc_main$2 from "../ui/spinner2.vue.js";
+import _sfc_main$2 from "../ui/spinner.vue.js";
 import { fetchOsmFeatures } from "./osm-features.js";
 import { subtractMask, unionAll } from "./osm-geometry-ops.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({

package/dist/components/ui/spinner.vue.js

@@ -1,4 +1,32 @@
-import _sfc_main from "./spinner2.vue.js";
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createElementVNode } from "vue";
+import { cn } from "../../lib/utils.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "spinner",
+  props: {
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const classes = computed(() => cn("size-4 animate-spin", props.class));
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("svg", {
+        role: "status",
+        "aria-label": "Loading",
+        class: normalizeClass(classes.value),
+        "data-slot": "spinner",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        "stroke-width": "2",
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round",
+        "aria-hidden": "false"
+      }, [..._cache[0] || (_cache[0] = [
+        createElementVNode("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" }, null, -1)
+      ])], 2);
+    };
+  }
+});
 export {
   _sfc_main as default
 };

package/dist/components/ui/spinner2.vue.js

@@ -1,32 +1,4 @@
-import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createElementVNode } from "vue";
-import { cn } from "../../lib/utils.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "spinner",
-  props: {
-    class: {}
-  },
-  setup(__props) {
-    const props = __props;
-    const classes = computed(() => cn("size-4 animate-spin", props.class));
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("svg", {
-        role: "status",
-        "aria-label": "Loading",
-        class: normalizeClass(classes.value),
-        "data-slot": "spinner",
-        viewBox: "0 0 24 24",
-        fill: "none",
-        stroke: "currentColor",
-        "stroke-width": "2",
-        "stroke-linecap": "round",
-        "stroke-linejoin": "round",
-        "aria-hidden": "false"
-      }, [..._cache[0] || (_cache[0] = [
-        createElementVNode("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" }, null, -1)
-      ])], 2);
-    };
-  }
-});
+import _sfc_main from "./spinner.vue.js";
 export {
   _sfc_main as default
 };

package/dist/controllers/use-infinite-list-controller.js

@@ -1,4 +1,4 @@
-import { createInfiniteListController } from "@chelone/core";
+import { createInfiniteListController, listControllerActions } from "@chelone/core";
 import { reactive, computed } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useRequiredResource } from "../resource-context.js";
@@ -29,18 +29,7 @@ function useInfiniteListController(options = {}) {
     selectedIds: computed(() => state.value.selectedIds),
     hasNextPage: computed(() => state.value.hasNextPage),
     hasPreviousPage: computed(() => state.value.hasPreviousPage),
-    setPage: controller.setPage,
-    setPerPage: controller.setPerPage,
-    setSort: controller.setSort,
-    setFilters: controller.setFilters,
-    setParams: controller.setParams,
-    showFilter: controller.showFilter,
-    hideFilter: controller.hideFilter,
-    select: controller.select,
-    toggleItem: controller.toggleItem,
-    unselectAll: controller.unselectAll,
-    selectAll: controller.selectAll,
-    refetch: controller.refetch,
+    ...listControllerActions(controller),
     fetchNextPage: controller.fetchNextPage,
     fetchPreviousPage: controller.fetchPreviousPage
   });

package/dist/controllers/use-list-controller.js

@@ -1,4 +1,4 @@
-import { createListController, listPatchFromSearch, serializeListState } from "@chelone/core";
+import { createListController, listPatchFromSearch, serializeListState, listControllerActions } from "@chelone/core";
 import { onScopeDispose, watch, reactive, computed } from "vue";
 import { useCheloneContext } from "../context.js";
 import { useRequiredResource } from "../resource-context.js";
@@ -53,18 +53,8 @@ function useListController(options = {}) {
     selectedIds: computed(() => state.value.selectedIds),
     hasNextPage: computed(() => state.value.hasNextPage),
     hasPreviousPage: computed(() => state.value.hasPreviousPage),
-    setPage: controller.setPage,
-    setPerPage: controller.setPerPage,
-    setSort: controller.setSort,
-    setFilters: controller.setFilters,
-    setParams: controller.setParams,
-    showFilter: controller.showFilter,
-    hideFilter: controller.hideFilter,
-    select: controller.select,
-    toggleItem: controller.toggleItem,
-    unselectAll: controller.unselectAll,
-    selectAll: controller.selectAll,
-    refetch: controller.refetch
+    ...listControllerActions(controller),
+    defaultPerPage: controller.defaultPerPage
   });
 }
 export {

package/dist/data/create-chelone-hooks.d.ts

@@ -92,8 +92,165 @@ export declare function createCheloneHooks<TResources extends ResourceMap>(): {
             meta: {} | null;
         }];
         manySnapshot: [readonly unknown[], unknown][];
-    }>, "reset" | "mutate">>;
-    useUpdateMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>;
+    }>, "reset" | "mutate">> | (Omit<import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate">>, "mutate" | "mutateAsync"> & {
+        mutate: (params: import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").RecordOf<TResources, TName>, import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+    });
+    useUpdateMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | {
+        mutate: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"idle", "idle">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<undefined, undefined>;
+        isIdle: import("vue").Ref<true, true>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"pending", "pending">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<true, true>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<Error, Error>;
+        status: import("vue").Ref<"error", "error">;
+        isError: import("vue").Ref<true, true>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableUpdateManyCallbacks<import("@chelone/core").RecordOf<TResources, TName>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+        data: import("vue").Ref<import("@chelone/core").Identifier[], import("@chelone/core").Identifier[]>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"success", "success">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<true, true>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>, import("@chelone/core").UpdateManyParams<import("@chelone/core").RecordOf<TResources, TName>>>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    };
     useDelete: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
         previous?: undefined;
         key?: undefined;
@@ -164,7 +321,164 @@ export declare function createCheloneHooks<TResources extends ResourceMap>(): {
             meta: {} | null;
         }];
         manySnapshot: [readonly unknown[], unknown][];
-    }>, "reset" | "mutate">>;
-    useDeleteMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>;
+    }>, "reset" | "mutate">> | (Omit<import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").RecordOf<TResources, TName>, unknown, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, {
+        previous?: undefined;
+        key?: undefined;
+        manySnapshot?: undefined;
+    } | {
+        previous: import("@chelone/core").RecordOf<TResources, TName> | undefined;
+        key: readonly [string, "getOne", {
+            id: string;
+            meta?: undefined;
+        } | {
+            id: string;
+            meta: {} | null;
+        }];
+        manySnapshot: [readonly unknown[], unknown][];
+    }>, "reset" | "mutate">>, "mutate" | "mutateAsync"> & {
+        mutate: (params: import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").RecordOf<TResources, TName> | undefined, import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>> | undefined) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteParams<import("@chelone/core").RecordOf<TResources, TName>>) => Promise<void>;
+    });
+    useDeleteMany: <TName extends keyof TResources & string>(resource: TName, options?: MutationModeOptions) => (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+        mutate: (variables: import("@chelone/core").DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown> | undefined) => void;
+        mutateAsync: import("@tanstack/query-core").MutateFunction<import("@chelone/core").Identifier[], Error, import("@chelone/core").DeleteManyParams, unknown>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    }) | {
+        mutate: (params: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteManyParams) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"idle", "idle">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<undefined, undefined>;
+        isIdle: import("vue").Ref<true, true>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteManyParams) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"pending", "pending">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<true, true>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").DeleteManyParams, import("@chelone/core").DeleteManyParams>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteManyParams) => Promise<void>;
+        data: import("vue").Ref<undefined, undefined>;
+        error: import("vue").Ref<Error, Error>;
+        status: import("vue").Ref<"error", "error">;
+        isError: import("vue").Ref<true, true>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<false, false>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").DeleteManyParams, import("@chelone/core").DeleteManyParams>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    } | {
+        mutate: (params: import("@chelone/core").DeleteManyParams, callbacks?: import("@chelone/core").UndoableCallbacks<import("@chelone/core").Identifier[], import("@chelone/core").DeleteManyParams>) => void;
+        mutateAsync: (params: import("@chelone/core").DeleteManyParams) => Promise<void>;
+        data: import("vue").Ref<import("@chelone/core").Identifier[], import("@chelone/core").Identifier[]>;
+        error: import("vue").Ref<null, null>;
+        status: import("vue").Ref<"success", "success">;
+        isError: import("vue").Ref<false, false>;
+        isPending: import("vue").Ref<false, false>;
+        isSuccess: import("vue").Ref<true, true>;
+        failureCount: import("vue").Ref<number, number>;
+        failureReason: import("vue").Ref<Error | null, Error | null>;
+        isPaused: import("vue").Ref<boolean, boolean>;
+        variables: import("vue").Ref<import("@chelone/core").DeleteManyParams, import("@chelone/core").DeleteManyParams>;
+        isIdle: import("vue").Ref<false, false>;
+        context: import("vue").Ref<unknown, unknown>;
+        submittedAt: import("vue").Ref<number, number>;
+        reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+    };
 };
 export {};

package/dist/data/mutations.d.ts

@@ -14,7 +14,17 @@
  * vanilla `startUndoableMutation` engine + an Undo notification. The default
  * (`"pessimistic"`) path is unchanged.
  */
-import { type DeleteManyParams, type DeleteParams, type MutationModeOptions, type RecordOf, type ResourceMap, type UpdateManyParams, type UpdateParams } from "@chelone/core";
+import { type DeleteManyParams, type DeleteParams, type Identifier, type MutationModeOptions, type RecordOf, type ResourceMap, type UndoableCallbacks, type UndoableUpdateManyCallbacks, type UpdateManyParams, type UpdateParams } from "@chelone/core";
+/**
+ * A mutation whose `mutate` / `mutateAsync` are swapped for the undoable pair,
+ * the state refs untouched. Naming it keeps the hook's inferred type
+ * declaration-emittable: spreading vue-query's refs over a generic record type
+ * would expand to `@vue/shared` types a `.d.ts` cannot name.
+ */
+type Undoable<TMutation, TParams, TData> = Omit<TMutation, "mutate" | "mutateAsync"> & {
+    mutate: (params: TParams, callbacks?: UndoableCallbacks<TData, TParams>) => void;
+    mutateAsync: (params: TParams) => Promise<void>;
+};
 /**
  * Create mutation for `resource` — the Vue twin of `@chelone/react`'s
  * `useCreate(resource)`. Call `.mutateAsync({ data })` to dispatch; the
@@ -98,7 +108,77 @@ export declare function useUpdate<TResources extends ResourceMap = ResourceMap,
         meta: {} | null;
     }];
     manySnapshot: [readonly unknown[], unknown][];
-}>, "reset" | "mutate">>;
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, UpdateParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, UpdateParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName>>;
 /**
  * Delete-one mutation for `resource`. Returns vue-query's mutation object; call
  * `.mutateAsync({ id, previousData })` to dispatch. Mirrors the React delete
@@ -177,7 +257,77 @@ export declare function useDelete<TResources extends ResourceMap = ResourceMap,
         meta: {} | null;
     }];
     manySnapshot: [readonly unknown[], unknown][];
-}>, "reset" | "mutate">>;
+}>, "reset" | "mutate">> | Undoable<import("@tanstack/vue-query").UseMutationReturnType<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}, Omit<import("@tanstack/query-core").MutationObserverIdleResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<RecordOf<TResources, TName>, unknown, DeleteParams<RecordOf<TResources, TName>>, {
+    previous?: undefined;
+    key?: undefined;
+    manySnapshot?: undefined;
+} | {
+    previous: RecordOf<TResources, TName> | undefined;
+    key: readonly [string, "getOne", {
+        id: string;
+        meta?: undefined;
+    } | {
+        id: string;
+        meta: {} | null;
+    }];
+    manySnapshot: [readonly unknown[], unknown][];
+}>, "reset" | "mutate">>, DeleteParams<RecordOf<TResources, TName>>, RecordOf<TResources, TName> | undefined>;
 /**
  * Delete-many mutation for `resource` — the Vue twin of the bulk delete path
  * `@chelone/react`'s `<BulkDeleteButton>` fires against
@@ -190,7 +340,91 @@ export declare function useDelete<TResources extends ResourceMap = ResourceMap,
  * `mutateAsync` for the optimistic-with-Undo flow (remove the rows now, defer the
  * server call until the Undo window closes) via the core `startUndoableMutation`.
  */
-export declare function useDeleteMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>;
+export declare function useDeleteMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, DeleteManyParams, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: DeleteManyParams, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, DeleteManyParams, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, DeleteManyParams, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: DeleteManyParams, callbacks?: UndoableCallbacks<Identifier[], DeleteManyParams>) => void;
+    mutateAsync: (params: DeleteManyParams) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<DeleteManyParams, DeleteManyParams>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
 /**
  * Update-many mutation for `resource` — the Vue twin of the bulk update path
  * `@chelone/react`'s `<BulkUpdateButton>` fires against
@@ -199,4 +433,89 @@ export declare function useDeleteMany<TResources extends ResourceMap = ResourceM
  * invalidates the resource's caches on settle. Call `.mutateAsync({ ids, data })`
  * to dispatch; `<BulkUpdateButton>` then clears the selection + notifies.
  */
-export declare function useUpdateMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): import("@tanstack/vue-query").UseMutationReturnType<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown, Omit<import("@tanstack/query-core").MutationObserverIdleResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverLoadingResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverErrorResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate"> | Omit<import("@tanstack/query-core").MutationObserverSuccessResult<import("@chelone/core").Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>;
+export declare function useUpdateMany<TResources extends ResourceMap = ResourceMap, TName extends keyof TResources & string = keyof TResources & string>(resource: TName, options?: MutationModeOptions): (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverIdleResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverLoadingResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverErrorResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | (import("vue").ToRefs<Readonly<Omit<import("@tanstack/query-core").MutationObserverSuccessResult<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>, "reset" | "mutate">>> & {
+    mutate: (variables: UpdateManyParams<RecordOf<TResources, TName>>, options?: import("@tanstack/query-core").MutateOptions<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown> | undefined) => void;
+    mutateAsync: import("@tanstack/query-core").MutateFunction<Identifier[], Error, UpdateManyParams<RecordOf<TResources, TName>>, unknown>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+}) | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"idle", "idle">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<undefined, undefined>;
+    isIdle: import("vue").Ref<true, true>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"pending", "pending">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<true, true>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<undefined, undefined>;
+    error: import("vue").Ref<Error, Error>;
+    status: import("vue").Ref<"error", "error">;
+    isError: import("vue").Ref<true, true>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<false, false>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+} | {
+    mutate: (params: UpdateManyParams<RecordOf<TResources, TName>>, callbacks?: UndoableUpdateManyCallbacks<RecordOf<TResources, TName>>) => void;
+    mutateAsync: (params: UpdateManyParams<RecordOf<TResources, TName>>) => Promise<void>;
+    data: import("vue").Ref<Identifier[], Identifier[]>;
+    error: import("vue").Ref<null, null>;
+    status: import("vue").Ref<"success", "success">;
+    isError: import("vue").Ref<false, false>;
+    isPending: import("vue").Ref<false, false>;
+    isSuccess: import("vue").Ref<true, true>;
+    failureCount: import("vue").Ref<number, number>;
+    failureReason: import("vue").Ref<Error | null, Error | null>;
+    isPaused: import("vue").Ref<boolean, boolean>;
+    variables: import("vue").Ref<UpdateManyParams<RecordOf<TResources, TName>>, UpdateManyParams<RecordOf<TResources, TName>>>;
+    isIdle: import("vue").Ref<false, false>;
+    context: import("vue").Ref<unknown, unknown>;
+    submittedAt: import("vue").Ref<number, number>;
+    reset: import("@tanstack/query-core").MutationObserverResult<TData, TError, TVariables, TOnMutateResult>["reset"];
+};
+export {};

package/dist/data/mutations.js

@@ -1,4 +1,4 @@
-import { updateMutationOptions, resourceKey, createMutationOptions, deleteMutationOptions, updateRecordsInCache, removeRecordsFromCache } from "@chelone/core";
+import { updateMutationOptions, resourceKey, createMutationOptions, deleteMutationOptions, undoableCallbacks, undoableUpdateOptions, patchedRecord, undoableDeleteOptions } from "@chelone/core";
 import { useMutation } from "@tanstack/vue-query";
 import { useCheloneContext } from "../context.js";
 import { useUndoable } from "./undoable.js";
@@ -11,45 +11,49 @@ function useUpdate(resource, options = {}) {
   const runUndoable = useUndoable();
   const mutation = useMutation(updateMutationOptions(ctx, resource, options));
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => updateRecordsInCache(
+      ...undoableUpdateOptions(
         ctx.queryClient,
         resource,
         [params.id],
         params.data
       ),
-      commit: () => ctx.dataProvider.update(resource, params),
-      message: "chelone.notification.updated",
-      messageArgs: { smart_count: 1 }
+      commit: settle.commit(() => ctx.dataProvider.update(resource, params))
     });
+    settle.success(patchedRecord(params));
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
 }
 function useDelete(resource, options = {}) {
   const ctx = useCheloneContext();
   const runUndoable = useUndoable();
   const mutation = useMutation(deleteMutationOptions(ctx, resource, options));
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => removeRecordsFromCache(ctx.queryClient, resource, [params.id]),
-      commit: () => ctx.dataProvider.delete(resource, params),
-      message: "chelone.notification.deleted",
-      messageArgs: { smart_count: 1 }
+      ...undoableDeleteOptions(ctx.queryClient, resource, [params.id]),
+      commit: settle.commit(() => ctx.dataProvider.delete(resource, params))
     });
+    settle.success(params.previousData);
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
+  const undoable = {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
+  };
+  return undoable;
 }
 function useDeleteMany(resource, options = {}) {
   const ctx = useCheloneContext();
@@ -62,20 +66,23 @@ function useDeleteMany(resource, options = {}) {
     onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
   });
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => removeRecordsFromCache(ctx.queryClient, resource, params.ids),
-      commit: () => ctx.dataProvider.deleteMany(resource, params),
-      message: "chelone.notification.deleted",
-      messageArgs: { smart_count: params.ids.length }
+      ...undoableDeleteOptions(ctx.queryClient, resource, params.ids),
+      commit: settle.commit(
+        () => ctx.dataProvider.deleteMany(resource, params)
+      )
     });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
 }
 function useUpdateMany(resource, options = {}) {
   const ctx = useCheloneContext();
@@ -88,25 +95,28 @@ function useUpdateMany(resource, options = {}) {
     onSettled: () => ctx.queryClient.invalidateQueries({ queryKey: resourceKey(resource) })
   });
   if (options.mutationMode !== "undoable") return mutation;
-  const mutate = (params) => {
+  const mutate = (params, callbacks) => {
+    const settle = undoableCallbacks(params, callbacks);
     runUndoable({
-      queryKeys: [[resource]],
-      applyOptimistic: () => updateRecordsInCache(
+      ...undoableUpdateOptions(
         ctx.queryClient,
         resource,
         params.ids,
         params.data
       ),
-      commit: () => ctx.dataProvider.updateMany(resource, params),
-      message: "chelone.notification.updated",
-      messageArgs: { smart_count: params.ids.length }
+      commit: settle.commit(
+        () => ctx.dataProvider.updateMany(resource, params)
+      )
     });
+    settle.success(params.ids);
+  };
+  return {
+    ...mutation,
+    mutate,
+    mutateAsync: async (params) => {
+      mutate(params);
+    }
   };
-  mutation.mutate = mutate;
-  mutation.mutateAsync = (async (params) => {
-    mutate(params);
-  });
-  return mutation;
 }
 export {
   useCreate,

package/dist/list/use-list.js

@@ -1,4 +1,4 @@
-import { createClientListController } from "@chelone/core";
+import { createClientListController, listControllerActions } from "@chelone/core";
 import { toValue, watch, reactive, computed } from "vue";
 import { useMicroStore } from "../store/use-micro-store.js";
 function useList(options = {}) {
@@ -40,18 +40,7 @@ function useList(options = {}) {
     selectedIds: computed(() => state.value.selectedIds),
     hasNextPage: computed(() => state.value.hasNextPage),
     hasPreviousPage: computed(() => state.value.hasPreviousPage),
-    setPage: controller.setPage,
-    setPerPage: controller.setPerPage,
-    setSort: controller.setSort,
-    setFilters: controller.setFilters,
-    setParams: controller.setParams,
-    showFilter: controller.showFilter,
-    hideFilter: controller.hideFilter,
-    select: controller.select,
-    toggleItem: controller.toggleItem,
-    unselectAll: controller.unselectAll,
-    selectAll: controller.selectAll,
-    refetch: controller.refetch
+    ...listControllerActions(controller)
   });
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chelone/vue",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -57,7 +57,7 @@
   "dependencies": {
     "cronstrue": "^3.24.0",
     "libphonenumber-js": "^1.13.8",
-    "@chelone/core": "0.1.0"
+    "@chelone/core": "0.1.1"
   },
   "peerDependencies": {
     "@guolao/vue-monaco-editor": "^1.6.0",
@@ -76,7 +76,7 @@
     "terra-draw-maplibre-gl-adapter": "^1.5.0",
     "vue": "^3.4.0",
     "vue-router": "^4.0.0",
-    "@chelone/supabase": "0.1.0"
+    "@chelone/supabase": "0.1.1"
   },
   "peerDependenciesMeta": {
     "@chelone/supabase": {
@@ -150,7 +150,7 @@
     "vue-router": "^4.0.0",
     "vue-tsc": "^2.0.0",
     "zod": "^3.24.0",
-    "@chelone/supabase": "0.1.0"
+    "@chelone/supabase": "0.1.1"
   },
   "scripts": {
     "build": "vite build && vue-tsc -p tsconfig.build.json && node ../../scripts/strip-dts-css-imports.mjs dist && node ../../scripts/dts-extensions.mjs dist",