@chelone/vue 0.0.0-stage → 0.1.0

package/LICENSE

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

package/README.md

@@ -1,3 +1,31 @@
-# Temporary Holding Version
+# @chelone/vue
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Vue 3 adapter for Chelone, a headless admin engine, and the source of its shadcn-vue component registry.
+
+```bash
+pnpm add @chelone/vue vue vue-router @tanstack/vue-query
+```
+
+## Optional entry points
+
+Each entry below needs the peer dependencies listed beside it, and only that entry loads them. The main entry needs none of them.
+
+| Entry | Optional peers |
+| --- | --- |
+| `@chelone/vue/monaco` | `monaco-editor`, `@guolao/vue-monaco-editor` |
+| `@chelone/vue/mdx-editor` | `@milkdown/crepe`, `@milkdown/kit` |
+| `@chelone/vue/csv-import` | `papaparse` |
+| `@chelone/vue/maps` | `maplibre-gl` |
+| `@chelone/vue/maps/draw` | `maplibre-gl`, `terra-draw`, `terra-draw-maplibre-gl-adapter`, `@turf/difference`, `@turf/simplify` |
+| `@chelone/vue/maps/osm` | `maplibre-gl`, `osm2geojson-lite`, `@turf/buffer`, `@turf/difference`, `@turf/union` |
+| `@chelone/vue/supabase` | `@chelone/supabase` |
+
+## shadcn-vue registry
+
+Add components to your project from the Vue registry. The React registry at `https://chelone.dev/r/` shares item names such as `admin`, so use the `/r/vue/` path:
+
+```bash
+npx shadcn-vue@latest add https://chelone.dev/r/vue/<item>.json
+```
+
+Docs: https://chelone.dev

package/dist/admin/admin-shell.vue.d.ts

@@ -0,0 +1,27 @@
+import type { ErrorFallbackProps } from "./default-error-fallback.vue.js";
+type __VLS_Props = {
+    requireAuth: boolean;
+    hasCustomRoutes: boolean;
+};
+type __VLS_Slots = {
+    /** Override the default shell chrome (wins over the route view). */
+    layout?: () => unknown;
+    /** The index/dashboard content (rendered before the route view at the index path only). */
+    dashboard?: () => unknown;
+    /** The unauthenticated login screen (default `<LoginPage>`). */
+    login?: () => unknown;
+    /** Replaces the spinner shown while the `requireAuth` check is pending. */
+    loading?: () => unknown;
+    /** Rendered alone when no resource is registered and no custom route is given. */
+    ready?: () => unknown;
+    /** Replaces the default fallback shown when the layout branch throws. */
+    error?: (props: ErrorFallbackProps) => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,113 @@
+import { defineComponent, useSlots, computed, resolveComponent, openBlock, createBlock, withCtx, renderSlot, createSlots, createVNode, unref, normalizeProps, guardReactiveProps, createElementVNode, createElementBlock, Fragment, createCommentVNode } from "vue";
+import { joinBasename } from "@chelone/core";
+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 { useBasename } from "../router/adapter.js";
+import { useWatchDataErrors } from "../auth/permissions-hooks.js";
+import { useAuthGate } from "./auth-gate.js";
+import { NO_LAYOUT_META } from "./custom-routes.js";
+import _sfc_main$5 from "./navigate-to-first-resource.vue.js";
+import { useResourceDefinitions } from "./resource-registry.js";
+import _sfc_main$2 from "./shell-error-boundary.vue.js";
+const _hoisted_1 = { class: "flex min-h-screen flex-col justify-center items-center" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "admin-shell",
+  props: {
+    requireAuth: { type: Boolean },
+    hasCustomRoutes: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const gate = useAuthGate(props.requireAuth);
+    const slots = useSlots();
+    const route = useRoute();
+    const router = useRouter();
+    const isNoLayout = computed(() => route.meta[NO_LAYOUT_META] === true);
+    const definitions = useResourceDefinitions();
+    const showReady = () => slots.ready != null && !props.hasCustomRoutes && Object.keys(definitions).length === 0;
+    const indexPath = joinBasename("/", useBasename()).toLowerCase();
+    const isIndex = computed(() => {
+      const path = route.path.toLowerCase();
+      return router.currentRoute.value !== START_LOCATION && (path === indexPath || path === `${indexPath}/`);
+    });
+    useWatchDataErrors();
+    return (_ctx, _cache) => {
+      const _component_router_view = resolveComponent("router-view");
+      return showReady() ? (openBlock(), createBlock(_sfc_main$1, { key: 0 }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "ready")
+        ]),
+        _: 3
+      })) : isNoLayout.value ? (openBlock(), createBlock(_sfc_main$2, { key: 1 }, createSlots({
+        default: withCtx(() => [
+          createVNode(_sfc_main$1, null, {
+            default: withCtx(() => [
+              createVNode(_component_router_view)
+            ]),
+            _: 1
+          })
+        ]),
+        _: 2
+      }, [
+        unref(slots).error ? {
+          name: "error",
+          fn: withCtx((errorProps) => [
+            renderSlot(_ctx.$slots, "error", normalizeProps(guardReactiveProps(errorProps)))
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1024)) : __props.requireAuth && unref(gate).isPending.value ? (openBlock(), createBlock(_sfc_main$1, { key: 2 }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "loading", {}, () => [
+            createElementVNode("div", _hoisted_1, [
+              createVNode(_sfc_main$3, { class: "size-9" })
+            ])
+          ])
+        ]),
+        _: 3
+      })) : __props.requireAuth && !unref(gate).authenticated.value ? renderSlot(_ctx.$slots, "login", { key: 3 }, () => [
+        createVNode(_sfc_main$1, null, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$4)
+          ]),
+          _: 1
+        })
+      ]) : (openBlock(), createElementBlock(Fragment, { key: 4 }, [
+        isIndex.value && !unref(slots).dashboard ? (openBlock(), createBlock(_sfc_main$5, { key: 0 })) : createCommentVNode("", true),
+        createVNode(_sfc_main$2, null, createSlots({
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "layout", {}, () => [
+              createVNode(_sfc_main$1, null, {
+                default: withCtx(() => [
+                  createVNode(_sfc_main$6, null, {
+                    default: withCtx(() => [
+                      isIndex.value ? renderSlot(_ctx.$slots, "dashboard", { key: 0 }) : createCommentVNode("", true),
+                      createVNode(_component_router_view)
+                    ]),
+                    _: 3
+                  })
+                ]),
+                _: 3
+              })
+            ])
+          ]),
+          _: 2
+        }, [
+          unref(slots).error ? {
+            name: "error",
+            fn: withCtx((errorProps) => [
+              renderSlot(_ctx.$slots, "error", normalizeProps(guardReactiveProps(errorProps)))
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1024)
+      ], 64));
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

@@ -0,0 +1,4 @@
+import _sfc_main from "./admin-shell.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/admin/admin.vue.d.ts

@@ -0,0 +1,126 @@
+/**
+ * `<Admin>` — the children-composable façade (D3), the Vue twin of
+ * `@chelone/react`'s `<Admin>` (`packages/react/src/admin/admin.tsx` +
+ * `admin-context.tsx`). Provider config = props; page overrides = named slots;
+ * resources = composed `<Resource>` children (or the `:resources` escape hatch).
+ *
+ * It owns four seams, each the Vue idiom of a React provider:
+ * 1. **The reactive registry.** Creates one `ResourceRegistry` and `provide`s it
+ *    so child `<Resource>`s self-register (the Vue mirror of React's
+ *    `<ResourceRegistryProvider>` + register-on-mount effect).
+ * 2. **The Chelone context.** `provide`s the same value React's `CheloneProvider`
+ *    builds (dataProvider / queryClient / store / i18n / auth / notifications) so
+ *    every data/i18n composable below reads it — "reuse core's context
+ *    construction, same as React's `<Admin>`".
+ * 3. **The query client.** Resolves (or creates) a vue-query `QueryClient`,
+ *    `mount`s it, and `provide`s it under vue-query's own key — the analog of
+ *    React's `<QueryClientProvider>`.
+ * 4. **The router adapter + reactive route build.** Installs the vue-router
+ *    adapter and, via a `watchEffect` over the registry, adds/removes vue-router
+ *    route records (`/{name}`, `/{name}/create/:pathMatch(.*)*`,
+ *    `/{name}/:id/:pathMatch(.*)*`, `/{name}/:id/show/:pathMatch(.*)*`) as resources register/unregister — the reactive analog
+ *    of React's declarative `<AdminRoutes>` resource route table. vue-router
+ *    ranks by specificity, so a static `create` or `show` route naturally beats
+ *    the `:id` edit route without a hand-maintained declaration order. The
+ *    edit, create and show routes take a trailing catch-all so a `<TabbedForm>`
+ *    or `<TabbedShowLayout>` tab can live in the URL.
+ *
+ * Named slots `#layout` / `#dashboard` override the default shell; `#login` is
+ * reserved for the auth gate (a later V1 wave). The `#layout` slot, when given,
+ * WINS over the default chrome (its fallback is the route view). The default
+ * slot always renders — that is where `<Resource>` markers live and register.
+ */
+import { type AnyCheloneI18n, type AuthProvider, type CheloneStore, type DataProvider, type NotificationStore, type ResourceMap } from "@chelone/core";
+import { QueryClient } from "@tanstack/vue-query";
+import type { ErrorFallbackProps } from "./default-error-fallback.vue.js";
+import { type CustomRoute } from "./custom-routes.js";
+import { type ResourceDefinition } from "./resource-registry.js";
+/** Props for {@link Admin}. */
+export interface AdminProps<TResources extends ResourceMap = ResourceMap> {
+    /** The data provider (required — the P2 data seam). */
+    dataProvider: DataProvider<TResources>;
+    /** An existing vue-query client. Omit to have `<Admin>` create one. */
+    queryClient?: QueryClient;
+    /**
+     * The path the host mounts `<Admin>` at, relative to the host router's own
+     * history base (default `''`). Starts with a slash when non-empty. Chelone
+     * prepends it to links and resource routes; vue-router applies its history
+     * base separately. Trailing slashes are removed. Remount `<Admin>` to change it.
+     */
+    basename?: string;
+    /** The optional auth provider. */
+    authProvider?: AuthProvider;
+    /** The optional i18n instance. */
+    i18n?: AnyCheloneI18n;
+    /** The optional KV store. */
+    store?: CheloneStore;
+    /** The optional notification store. */
+    notifications?: NotificationStore;
+    /**
+     * The zod resource registry (P5), the output of `defineResources(...)`. Named
+     * `registry` to avoid colliding with the `resources` view-component escape
+     * hatch below. When present, a resource's schema becomes the DEFAULT form
+     * validator for `useForm({ resource })` (D6): the core save-pipeline and
+     * `useForm` already READ `ctx.resources` — `<Admin>` is what PUTS it there,
+     * the exact seam React's `<Admin resources>` threads through `<CheloneProvider>`.
+     */
+    registry?: TResources;
+    /**
+     * The escape hatch (D3): resource definitions to merge into the registry
+     * WITHOUT a `<Resource>` child — the config path mirroring React's array form.
+     * NOTE: this is the runtime VIEW registry (list/edit/create components), NOT
+     * the zod schema registry — that is `registry` above.
+     */
+    resources?: ResourceDefinition[];
+    /**
+     * Extra routes mounted under `basename`, ahead of any resource route, so one at
+     * a resource's path wins. A `noLayout` route renders outside the layout and the
+     * auth gate; the rest render inside the layout, behind the gate. Read once at setup.
+     */
+    customRoutes?: CustomRoute[];
+    /**
+     * Gate the shell behind authentication (the no-flash auth gate). When `true`
+     * (and an `authProvider` is configured), the shell renders a loading spinner
+     * while the auth check is pending and the `#login` slot (default
+     * `<LoginPage>`) when unauthenticated — the protected layout never mounts
+     * during that window. Defaults `false`: the shell renders immediately, exactly
+     * as before (parity with React's `<Admin requireAuth>`).
+     */
+    requireAuth?: boolean;
+}
+declare const _default: <TResources extends ResourceMap = ResourceMap>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & AdminProps<TResources> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /** The resource markers (`<Resource>`) — always rendered so they register. */
+        default?: () => unknown;
+        /** Override the default shell chrome (wins over the route view). */
+        layout?: () => unknown;
+        /** The index/dashboard content (rendered before the route view by default). */
+        dashboard?: () => unknown;
+        /** The unauthenticated login screen (`requireAuth`) — default `<LoginPage>`. */
+        login?: () => unknown;
+        /** Replaces the spinner shown while the `requireAuth` check is pending. */
+        loading?: () => unknown;
+        /** Rendered alone when no resource is registered and no `customRoutes` are given. */
+        ready?: () => unknown;
+        /** Replaces the default fallback shown when a route view throws. */
+        error?: (props: ErrorFallbackProps) => unknown;
+        /** Mounted at `/auth-callback`, outside the layout and the auth gate. */
+        authCallback?: () => unknown;
+        /** Mounted at `/authentication-error`, inside the layout. */
+        authenticationError?: () => unknown;
+        /** Mounted at `/access-denied`, inside the layout. */
+        accessDenied?: () => unknown;
+        /** Mounted for any path no other route owns, inside the layout. */
+        catchAll?: () => unknown;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/admin/admin.vue.js

@@ -0,0 +1,214 @@
+import { defineComponent, provide, useSlots, onScopeDispose, onBeforeUpdate, watchEffect, openBlock, createElementBlock, Fragment, renderSlot, createVNode, createSlots, withCtx, normalizeProps, guardReactiveProps } from "vue";
+import { joinBasename } from "@chelone/core";
+import { BasenameKey } from "../router/adapter.js";
+import { QueryClient, VUE_QUERY_CLIENT } from "@tanstack/vue-query";
+import { useRouter, START_LOCATION } from "vue-router";
+import _sfc_main$1 from "./admin-shell.vue.js";
+import { provideCheloneContext } from "../context.js";
+import { toRouteRecord } from "./custom-routes.js";
+import { CATCH_ALL_META, createSlotRoutes } from "./slot-routes.js";
+import { provideVueRouterAdapter } from "../router/vue-router-adapter.js";
+import { provideHasDashboard } from "./has-dashboard.js";
+import { createResourceRegistry, ResourceRegistryKey } from "./resource-registry.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "admin",
+  props: {
+    dataProvider: {},
+    queryClient: {},
+    basename: {},
+    authProvider: {},
+    i18n: {},
+    store: {},
+    notifications: {},
+    registry: {},
+    resources: {},
+    customRoutes: {},
+    requireAuth: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const basename = (props.basename ?? "").replace(/\/+$/, "");
+    provide(BasenameKey, basename);
+    const slots = useSlots();
+    const registry = createResourceRegistry();
+    provide(ResourceRegistryKey, registry);
+    if (props.resources) {
+      for (const definition of props.resources) registry.register(definition);
+    }
+    provideHasDashboard(slots.dashboard != null);
+    const queryClient = props.queryClient ?? new QueryClient();
+    queryClient.mount();
+    provide(VUE_QUERY_CLIENT, queryClient);
+    onScopeDispose(() => queryClient.unmount());
+    provideCheloneContext({
+      dataProvider: props.dataProvider,
+      queryClient,
+      authProvider: props.authProvider,
+      i18n: props.i18n,
+      store: props.store,
+      notifications: props.notifications,
+      // Thread the zod registry so `useForm({ resource })` auto-resolves the
+      // resource schema as its default validator (the V1-b wiring gap this closes).
+      resources: props.registry
+    });
+    provideVueRouterAdapter();
+    const router = useRouter();
+    const routeRemovers = /* @__PURE__ */ new Map();
+    function addResourceRoutes(name, definition) {
+      const removers = [];
+      if (definition.create) {
+        removers.push(
+          router.addRoute({
+            path: joinBasename(`/${name}/create/:pathMatch(.*)*`, basename),
+            name: `chelone-${name}-create`,
+            component: definition.create
+          })
+        );
+      }
+      if (definition.show) {
+        removers.push(
+          router.addRoute({
+            path: joinBasename(`/${name}/:id/show/:pathMatch(.*)*`, basename),
+            name: `chelone-${name}-show`,
+            component: definition.show
+          })
+        );
+      }
+      if (definition.edit) {
+        removers.push(
+          router.addRoute({
+            path: joinBasename(`/${name}/:id/:pathMatch(.*)*`, basename),
+            name: `chelone-${name}-edit`,
+            component: definition.edit
+          })
+        );
+      }
+      if (definition.list) {
+        removers.push(
+          router.addRoute({
+            path: joinBasename(`/${name}`, basename),
+            name: `chelone-${name}-list`,
+            component: definition.list
+          })
+        );
+      }
+      return removers;
+    }
+    let resolving = false;
+    async function resolveWaitingLocation() {
+      if (resolving) return;
+      resolving = true;
+      try {
+        await router.isReady();
+      } catch {
+        return;
+      } finally {
+        resolving = false;
+      }
+      const current = router.currentRoute.value;
+      const indexPath = joinBasename("/", basename).toLowerCase();
+      const currentPath = current.path.toLowerCase();
+      if (current.matched.every((record) => record.meta[CATCH_ALL_META] === true) && currentPath !== indexPath && currentPath !== `${indexPath}/`) {
+        void router.replace(current.fullPath);
+      }
+    }
+    function resolveCurrentLocationAgain() {
+      const current = router.currentRoute.value;
+      if (current === START_LOCATION) return;
+      const next = router.resolve(current.fullPath);
+      if (next.matched.at(-1) !== current.matched.at(-1)) {
+        void router.replace(current.fullPath);
+      }
+    }
+    for (const route of props.customRoutes ?? []) {
+      onScopeDispose(router.addRoute(toRouteRecord(route, basename)));
+    }
+    const slotRoutes = createSlotRoutes(router, slots, basename);
+    onScopeDispose(slotRoutes.dispose);
+    const hasSlotRoutes = slotRoutes.sync();
+    onBeforeUpdate(() => {
+      if (slotRoutes.sync()) resolveCurrentLocationAgain();
+    });
+    if (props.customRoutes?.length || hasSlotRoutes) void resolveWaitingLocation();
+    watchEffect(() => {
+      const { definitions } = registry;
+      const names = new Set(Object.keys(definitions));
+      for (const [name, removers] of routeRemovers) {
+        if (!names.has(name)) {
+          for (const remove of removers) remove();
+          routeRemovers.delete(name);
+        }
+      }
+      let added = false;
+      for (const name of names) {
+        if (routeRemovers.has(name)) continue;
+        const definition = definitions[name];
+        if (!definition) continue;
+        routeRemovers.set(name, addResourceRoutes(name, definition));
+        added = true;
+      }
+      if (added) void resolveWaitingLocation();
+    });
+    onScopeDispose(() => {
+      for (const removers of routeRemovers.values()) {
+        for (const remove of removers) remove();
+      }
+      routeRemovers.clear();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        renderSlot(_ctx.$slots, "default"),
+        createVNode(_sfc_main$1, {
+          "require-auth": props.requireAuth ?? false,
+          "has-custom-routes": !!props.customRoutes?.length
+        }, createSlots({ _: 2 }, [
+          _ctx.$slots.layout ? {
+            name: "layout",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "layout")
+            ]),
+            key: "0"
+          } : void 0,
+          _ctx.$slots.dashboard ? {
+            name: "dashboard",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "dashboard")
+            ]),
+            key: "1"
+          } : void 0,
+          _ctx.$slots.login ? {
+            name: "login",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "login")
+            ]),
+            key: "2"
+          } : void 0,
+          _ctx.$slots.loading ? {
+            name: "loading",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "loading")
+            ]),
+            key: "3"
+          } : void 0,
+          _ctx.$slots.ready ? {
+            name: "ready",
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, "ready")
+            ]),
+            key: "4"
+          } : void 0,
+          _ctx.$slots.error ? {
+            name: "error",
+            fn: withCtx((errorProps) => [
+              renderSlot(_ctx.$slots, "error", normalizeProps(guardReactiveProps(errorProps)))
+            ]),
+            key: "5"
+          } : void 0
+        ]), 1032, ["require-auth", "has-custom-routes"])
+      ], 64);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/admin/admin2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./admin.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/admin/auth-gate.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The headless auth pieces the routing engine gates on — the Vue twin of
+ * `@chelone/react`'s `admin/auth-gate.tsx`:
+ *
+ * - `useAuthGate(requireAuth)` — the no-flash gate state. Reuses the P3 auth
+ *   query (`authStateQueryOptions` via `useCheloneAuthProvider`) but adds the two
+ *   shell-specific concerns the raw `useAuthState()` does not: the `enabled`
+ *   gating (`requireAuth` — no query when the shell doesn't gate) and the
+ *   NO-AUTHPROVIDER shortcut (`authProvider == null` → frozen authenticated, so
+ *   appless demos never gate). `<Admin requireAuth>` renders the login page WHILE
+ *   `isPending`, so protected content NEVER mounts during the pending-auth
+ *   window — that is the no-flash guarantee (not render-then-hide).
+ *
+ * - `useAuthenticated` — a per-page gate. Fires the auth check for a subtree and,
+ *   on failure, logs out (default) or renders nothing; `logoutOnFailure`
+ *   defaults `true`.
+ *
+ * - `useHandleAuthCallback` — the OAuth redirect resolver: call the provider's
+ *   `handleCallback`, then redirect to `data.redirectTo` ELSE the stored
+ *   `nextPathname` ELSE `location.state.nextPathname` ELSE `'/'`.
+ *
+ * Idiom translation from the React twin: React re-derives the gate values each
+ * render; Vue returns `ComputedRef`s off the vue-query result refs so the shell
+ * template re-renders reactively as the auth check settles. The one-shot
+ * side-effects (logout / callback redirect) run in `watch(..., { immediate })`
+ * instead of `useEffect`.
+ */
+import { type ComputedRef, type Ref } from "vue";
+/** The no-flash gate state the routing engine branches on (reactive). */
+export interface AuthGateState {
+    /** The auth check is in flight — render the loading page, NOT the layout. */
+    isPending: ComputedRef<boolean>;
+    /** Whether the user is authenticated (meaningful once `!isPending`). */
+    authenticated: ComputedRef<boolean>;
+}
+/**
+ * The no-flash gate state. Composition over the P3 auth query, adding the two
+ * shell concerns:
+ *
+ * 1. `enabled: requireAuth` — when the shell does not gate (`requireAuth` false)
+ *    the query never fires and the gate is instantly "authenticated, not
+ *    pending" (an ungated shell shows its content immediately).
+ * 2. the no-authProvider shortcut — with no `authProvider` the gate is frozen
+ *    `{ isPending: false, authenticated: true }` (appless demos never gate),
+ *    regardless of `requireAuth`.
+ *
+ * `requireAuth` is read once at setup (a mount-stable `<Admin>` prop), mirroring
+ * how the React twin reads a stable prop per render.
+ */
+export declare function useAuthGate(requireAuth: boolean): AuthGateState;
+export interface UseAuthenticatedOptions {
+    /** Whether to enforce the check (default true). `false` → a no-op pass. */
+    enabled?: boolean;
+    /** On a failed check, log the user out (default true) vs. render nothing. */
+    logoutOnFailure?: boolean;
+}
+/**
+ * A per-page auth gate. Fires the auth check for the current subtree; on failure
+ * it logs out (default `logoutOnFailure: true`) so the shell returns to the
+ * login flow. Returns the same reactive `{ isPending, authenticated }` gate
+ * state, so a caller can hold rendering until resolved.
+ */
+export declare function useAuthenticated(options?: UseAuthenticatedOptions): AuthGateState;
+export interface HandleAuthCallbackResult {
+    /** True once the callback has resolved and the redirect has been issued. */
+    settled: Ref<boolean>;
+    /** The error, if `handleCallback` rejected. */
+    error: Ref<unknown>;
+}
+/**
+ * Resolve an OAuth auth-callback redirect. On mount, call the provider's
+ * `handleCallback`; on success, redirect to the FIRST available of:
+ * `data.redirectTo` → the stored `nextPathname` (Store) → `location.state
+ * .nextPathname` → `'/'`. Rejections surface via the returned `error`.
+ *
+ * The redirect fires once (a `watch` on the settled query, guarded by a latch),
+ * so a re-render does not re-navigate. Uses `useRedirect` (absolute-http targets
+ * are honored, so a provider may redirect off-site).
+ */
+export declare function useHandleAuthCallback(): HandleAuthCallbackResult;