@chelone/vue 0.6.0 → 0.7.0

package/dist/admin/custom-routes.js

@@ -1,14 +1,14 @@
 import { joinBasename } from "@chelone/core";
-const NO_LAYOUT_META = "chelone:noLayout";
+// src/admin/custom-routes.ts
+/** The route meta key `<AdminShell>` reads to render a match outside the layout. */
+var NO_LAYOUT_META = "chelone:noLayout";
+/** The vue-router record for a custom route, under `basename`. */
 function toRouteRecord(route, basename) {
-  return {
-    path: joinBasename(`/${route.path}`, basename),
-    name: route.name,
-    component: route.component,
-    meta: route.noLayout ? { [NO_LAYOUT_META]: true } : {}
-  };
+	return {
+		path: joinBasename(`/${route.path}`, basename),
+		name: route.name,
+		component: route.component,
+		meta: route.noLayout ? { [NO_LAYOUT_META]: true } : {}
+	};
 }
-export {
-  NO_LAYOUT_META,
-  toRouteRecord
-};
+export { NO_LAYOUT_META, toRouteRecord };

package/dist/admin/default-error-fallback.js

@@ -0,0 +1,4 @@
+import default_error_fallback_vue_vue_type_script_setup_true_lang_default from "./default-error-fallback.vue_vue_type_script_setup_true_lang.js";
+// src/admin/default-error-fallback.vue
+var default_error_fallback_default = default_error_fallback_vue_vue_type_script_setup_true_lang_default;
+export { default_error_fallback_default as default };

package/dist/admin/default-error-fallback.vue.d.ts

@@ -7,5 +7,6 @@ export interface ErrorFallbackProps {
     /** Clear the error and render the wrapped view again. */
     reset: () => void;
 }
-declare const _default: import("vue").DefineComponent<ErrorFallbackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ErrorFallbackProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ErrorFallbackProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ErrorFallbackProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/admin/default-error-fallback.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,32 @@
+import { createElementBlock, createElementVNode, defineComponent, openBlock, toDisplayString } from "vue";
+// src/admin/default-error-fallback.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	role: "alert",
+	"data-chelone": "error-boundary"
+};
+var default_error_fallback_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "default-error-fallback",
+	props: {
+		error: {},
+		info: {},
+		reset: { type: Function }
+	},
+	setup(__props) {
+		/**
+		* The built-in shell fallback, the Vue twin of React's `DefaultErrorFallback`:
+		* deliberately plain, so a throwing route degrades to something readable
+		* instead of a blank page. Replace it with the `#error` slot on `<Admin>`.
+		*/
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				_cache[1] || (_cache[1] = createElementVNode("h1", null, "Something went wrong.", -1)),
+				createElementVNode("p", null, toDisplayString(__props.error.message), 1),
+				createElementVNode("button", {
+					type: "button",
+					onClick: _cache[0] || (_cache[0] = ($event) => __props.reset())
+				}, "Try again")
+			]);
+		};
+	}
+});
+export { default_error_fallback_vue_vue_type_script_setup_true_lang_default as default };

package/dist/admin/has-dashboard.js

@@ -1,15 +1,23 @@
-import { provide, inject } from "vue";
-const HasDashboardKey = /* @__PURE__ */ Symbol(
-  "chelone-has-dashboard"
-);
+import { inject, provide } from "vue";
+// src/admin/has-dashboard.ts
+/**
+* The `HasDashboard` seam — the Vue twin of `@chelone/react`'s
+* `admin/has-dashboard.ts` (`HasDashboardContext` + `useHasDashboard`). `<Admin>`
+* provides whether a `#dashboard` slot was given so any descendant (the sidebar
+* `<Menu>`) can render a "Dashboard" entry ONLY when a dashboard exists.
+*
+* Vue idiom: React's `createContext`/`useContext` become a typed provide/inject
+* pair. The inject default is `false`, so a `<Menu>` mounted without an `<Admin>`
+* (or without a dashboard) simply omits the dashboard item — never throwing.
+*/
+/** The provide/inject key carrying whether the app registered a dashboard. */
+var HasDashboardKey = Symbol("chelone-has-dashboard");
+/** Provide the dashboard flag for the subtree. `<Admin>` calls this in `setup`. */
 function provideHasDashboard(value) {
-  provide(HasDashboardKey, value);
+	provide(HasDashboardKey, value);
 }
+/** Read whether the app has a dashboard (drives the conditional menu entry). */
 function useHasDashboard() {
-  return inject(HasDashboardKey, false);
+	return inject(HasDashboardKey, false);
 }
-export {
-  HasDashboardKey,
-  provideHasDashboard,
-  useHasDashboard
-};
+export { HasDashboardKey, provideHasDashboard, useHasDashboard };

package/dist/admin/navigate-to-first-resource.js

@@ -0,0 +1,4 @@
+import navigate_to_first_resource_vue_vue_type_script_setup_true_lang_default from "./navigate-to-first-resource.vue_vue_type_script_setup_true_lang.js";
+// src/admin/navigate-to-first-resource.vue
+var navigate_to_first_resource_default = navigate_to_first_resource_vue_vue_type_script_setup_true_lang_default;
+export { navigate_to_first_resource_default as default };

package/dist/admin/navigate-to-first-resource.vue.d.ts

@@ -1,2 +1,3 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/admin/navigate-to-first-resource.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,39 @@
+import { useMenuAccess } from "../components/admin/layout/use-menu-access.js";
+import { useCreatePath, useNavigate } from "../router/nav-composables.js";
+import { useResourceRegistry } from "./resource-registry.js";
+import { computed, defineComponent, watchEffect } from "vue";
+// src/admin/navigate-to-first-resource.vue?vue&type=script&setup=true&lang.ts
+var navigate_to_first_resource_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "navigate-to-first-resource",
+	setup(__props) {
+		/**
+		* `<NavigateToFirstResource>` — renders nothing; replaces the location with the
+		* list of the first resource (registration order) that has a list view, once the
+		* user may list it. The Vue twin of `NavigateToFirstResource` in
+		* `@chelone/react`'s `admin/admin-routes.tsx`.
+		*
+		* Like React, it checks only the FIRST listable resource: a denied or pending
+		* check leaves the index blank rather than falling through to the next one.
+		*/
+		const registry = useResourceRegistry();
+		const navigate = useNavigate();
+		const createPath = useCreatePath();
+		const firstListable = computed(() => Object.values(registry.definitions).find((d) => d.list != null));
+		const { canAccess, isPending } = useMenuAccess(() => ({
+			action: "list",
+			resource: firstListable.value?.name ?? ""
+		}), () => firstListable.value != null);
+		watchEffect(() => {
+			const first = firstListable.value;
+			if (first == null || isPending.value || !canAccess.value) return;
+			navigate(createPath({
+				resource: first.name,
+				type: "list"
+			}), { replace: true });
+		}, { flush: "post" });
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+export { navigate_to_first_resource_vue_vue_type_script_setup_true_lang_default as default };

package/dist/admin/resource-registry.d.ts

@@ -17,6 +17,7 @@
  * `<Resource>` also carries the view components as props.
  */
 import { type Component, type ComputedRef, type InjectionKey, type MaybeRefOrGetter } from "vue";
+import type { RecordRepresentation } from "../index.js";
 /**
  * A registered resource: its name (the registry key + route base) plus the view
  * components to mount under `/{name}` (list), `/{name}/create`, `/{name}/:id`
@@ -37,7 +38,7 @@ export interface ResourceDefinition {
     /** The menu / breadcrumb icon (a Vue component). */
     icon?: Component;
     /** How a record renders as a label (field name, function, or component). */
-    recordRepresentation?: unknown;
+    recordRepresentation?: RecordRepresentation;
 }
 /** The reactive resource registry contract `<Admin>` provides and `<Resource>` mutates. */
 export interface ResourceRegistry {
@@ -88,7 +89,7 @@ export interface UseResourceDefinitionOptions {
     hasCreate?: boolean;
     hasEdit?: boolean;
     hasShow?: boolean;
-    recordRepresentation?: unknown;
+    recordRepresentation?: RecordRepresentation;
 }
 /** A resource's definition with the four `has*` view flags resolved. */
 export type ResourceDefinitionView = Partial<ResourceDefinition> & {

package/dist/admin/resource-registry.js

@@ -1,55 +1,91 @@
-import { shallowReactive, inject, computed, toValue } from "vue";
 import { useResourceContext } from "../resource-context.js";
-const ResourceRegistryKey = /* @__PURE__ */ Symbol(
-  "chelone-resource-registry"
-);
+import { computed, inject, shallowReactive, toValue } from "vue";
+// src/admin/resource-registry.ts
+/**
+* The runtime resource registry for `@chelone/vue` — the Vue twin of the React
+* adapter's registry seam (`packages/react/src/resource/registry-hooks.tsx`).
+* Where React wraps core's vanilla `createResourceRegistry` in a
+* `useSyncExternalStore`, the Vue adapter models the registry as a *reactive
+* map* (D3): `<Resource>` children `register` themselves into it on `setup` and
+* `unregister` on scope disposal, and `<Admin>`'s `watchEffect` rebuilds the
+* vue-router route table whenever the map's key set changes. Vue's own
+* reactivity graph replaces the external-store subscription — no bridge needed
+* because the registry IS reactive.
+*
+* The stored `ResourceDefinition` deliberately holds the ACTUAL view components
+* (`list`/`edit`/`create`/`show`) rather than boolean `has*` route flags: the
+* Vue router needs the component to mount a route, so the registry doubles as
+* the source of route records. This differs from core's `ResourceDefinition`
+* (name + `has*` flags) — a Vue-adapter-local shape, matching how React's
+* `<Resource>` also carries the view components as props.
+*/
+/**
+* The provide/inject key for the reactive registry. `<Admin>` provides it in
+* `setup`; `<Resource>` reads it via {@link useResourceRegistry} to
+* self-register. A typed `InjectionKey` keeps both sites cast-free.
+*/
+var ResourceRegistryKey = Symbol("chelone-resource-registry");
+/**
+* Create a fresh reactive registry. `<Admin>` owns one per instance. The backing
+* store is a `shallowReactive` map: key add/remove is tracked (so the route
+* builder re-runs), but the stored definitions — which hold Vue components — are
+* NOT deep-proxied (proxying a component definition is both wasteful and a
+* documented Vue footgun).
+*/
 function createResourceRegistry() {
-  const definitions = shallowReactive({});
-  return {
-    definitions,
-    register(definition) {
-      definitions[definition.name] = definition;
-    },
-    unregister(name) {
-      delete definitions[name];
-    }
-  };
+	const definitions = shallowReactive({});
+	return {
+		definitions,
+		register(definition) {
+			definitions[definition.name] = definition;
+		},
+		unregister(name) {
+			delete definitions[name];
+		}
+	};
 }
+/**
+* Read the ambient resource registry. Throws when used outside `<Admin>` — a
+* `<Resource>` (or any registry consumer) rendered without a provider is a
+* misuse that must fail loudly (parity with the React twin's
+* `useResourceRegistry`).
+*/
 function useResourceRegistry() {
-  const registry = inject(ResourceRegistryKey, null);
-  if (!registry) {
-    throw new Error(
-      "useResourceRegistry: no registry found. Render <Resource> inside <Admin>."
-    );
-  }
-  return registry;
+	const registry = inject(ResourceRegistryKey, null);
+	if (!registry) throw new Error("useResourceRegistry: no registry found. Render <Resource> inside <Admin>.");
+	return registry;
 }
+/**
+* Read the whole reactive definition map (resource-name → definition). A
+* template or computed that reads it re-runs when a `<Resource>` registers or
+* unregisters.
+*/
 function useResourceDefinitions() {
-  return useResourceRegistry().definitions;
+	return useResourceRegistry().definitions;
 }
+/**
+* The definition of one resource — the `resource` option or else the ambient
+* one — with `hasList` / `hasCreate` / `hasEdit` / `hasShow` true when the
+* resource registered that view component (parity: ra-core's
+* `useResourceDefinition`, whose flags the Vue registry derives from the view
+* components it stores). An explicit option wins over the registry entry; an
+* unregistered resource yields all-false flags plus any override.
+*/
 function useResourceDefinition(options) {
-  const definitions = useResourceDefinitions();
-  const ambient = useResourceContext();
-  return computed(() => {
-    const opts = toValue(options);
-    const resource = opts?.resource ?? ambient;
-    const base = resource ? definitions[resource] : void 0;
-    return {
-      ...base,
-      hasList: opts?.hasList ?? base?.list != null,
-      hasCreate: opts?.hasCreate ?? base?.create != null,
-      hasEdit: opts?.hasEdit ?? base?.edit != null,
-      hasShow: opts?.hasShow ?? base?.show != null,
-      ...opts?.recordRepresentation !== void 0 && {
-        recordRepresentation: opts.recordRepresentation
-      }
-    };
-  });
+	const definitions = useResourceDefinitions();
+	const ambient = useResourceContext();
+	return computed(() => {
+		const opts = toValue(options);
+		const resource = opts?.resource ?? ambient;
+		const base = resource ? definitions[resource] : void 0;
+		return {
+			...base,
+			hasList: opts?.hasList ?? base?.list != null,
+			hasCreate: opts?.hasCreate ?? base?.create != null,
+			hasEdit: opts?.hasEdit ?? base?.edit != null,
+			hasShow: opts?.hasShow ?? base?.show != null,
+			...opts?.recordRepresentation !== void 0 && { recordRepresentation: opts.recordRepresentation }
+		};
+	});
 }
-export {
-  ResourceRegistryKey,
-  createResourceRegistry,
-  useResourceDefinition,
-  useResourceDefinitions,
-  useResourceRegistry
-};
+export { ResourceRegistryKey, createResourceRegistry, useResourceDefinition, useResourceDefinitions, useResourceRegistry };

package/dist/admin/resource.js

@@ -0,0 +1,4 @@
+import resource_vue_vue_type_script_setup_true_lang_default from "./resource.vue_vue_type_script_setup_true_lang.js";
+// src/admin/resource.vue
+var resource_default = resource_vue_vue_type_script_setup_true_lang_default;
+export { resource_default as default };

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

@@ -16,5 +16,6 @@ export interface ResourceProps {
     /** How a record renders as a label. */
     recordRepresentation?: ResourceDefinition["recordRepresentation"];
 }
-declare const _default: import("vue").DefineComponent<ResourceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResourceProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ResourceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ResourceProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/admin/resource.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,49 @@
+import { useResourceRegistry } from "./resource-registry.js";
+import { defineComponent, onScopeDispose } from "vue";
+// src/admin/resource.vue?vue&type=script&setup=true&lang.ts
+var resource_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "resource",
+	props: {
+		name: {},
+		list: {},
+		create: {},
+		edit: {},
+		show: {},
+		icon: {},
+		recordRepresentation: { type: [String, Function] }
+	},
+	setup(__props) {
+		/**
+		* `<Resource>` — the self-registration marker (D3), the Vue twin of
+		* `@chelone/react`'s `<Resource>` config-marker role
+		* (`packages/react/src/resource/resource.tsx`). Where React tags itself with a
+		* static `chelName` for the children partition to hoist, Vue's `<Resource>`
+		* simply `inject`s the reactive registry `<Admin>` provides and `register`s its
+		* own `ResourceDefinition` during `setup`, unregistering on scope disposal.
+		* `<Admin>`'s `watchEffect` reacts to the registry mutation and builds the
+		* vue-router routes — so composing `<Resource>` components IS the routing
+		* declaration, with no marker-partition walk needed (Vue's provide/inject +
+		* reactivity does natively what React's JSX-children partition does manually).
+		*
+		* It renders nothing: a registration marker only. The single comment node keeps
+		* the SFC's template valid without contributing DOM.
+		*/
+		const props = __props;
+		const registry = useResourceRegistry();
+		const { name } = props;
+		registry.register({
+			name,
+			list: props.list,
+			create: props.create,
+			edit: props.edit,
+			show: props.show,
+			icon: props.icon,
+			recordRepresentation: props.recordRepresentation
+		});
+		onScopeDispose(() => registry.unregister(name));
+		return (_ctx, _cache) => {
+			return null;
+		};
+	}
+});
+export { resource_vue_vue_type_script_setup_true_lang_default as default };

package/dist/admin/shell-error-boundary.js

@@ -0,0 +1,4 @@
+import shell_error_boundary_vue_vue_type_script_setup_true_lang_default from "./shell-error-boundary.vue_vue_type_script_setup_true_lang.js";
+// src/admin/shell-error-boundary.vue
+var shell_error_boundary_default = shell_error_boundary_vue_vue_type_script_setup_true_lang_default;
+export { shell_error_boundary_default as default };

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

@@ -1,12 +1,28 @@
+/**
+ * The shell error boundary, the Vue twin of React's `ShellErrorBoundary`.
+ * `onErrorCaptured` keeps the first error from the wrapped tree and swaps the
+ * default slot for a fallback.
+ *
+ * The error clears when `location.pathname` changes, not on a search or hash
+ * change, and the boundary has no `key`: the wrapped layout and its form state
+ * survive every navigation.
+ *
+ * Only errors from setup, render and the creation, mount and update hooks are
+ * captured, as in React: a failed event handler or watcher propagates and
+ * leaves the page usable. Returning `false` stops a captured error here, so
+ * `app.config.errorHandler` does not see it.
+ */
+import { type VNode } from "vue";
 import { type ErrorFallbackProps } from "./default-error-fallback.vue.js";
 type __VLS_Slots = {
     /** The wrapped tree. */
-    default?: () => unknown;
+    default?: () => VNode[];
     /** Replaces the default fallback. */
-    error?: (props: ErrorFallbackProps) => unknown;
+    error?: (props: ErrorFallbackProps) => VNode[];
 };
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

package/dist/admin/shell-error-boundary.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,70 @@
+import { useLocation } from "../router/nav-composables.js";
+import default_error_fallback_default from "./default-error-fallback.js";
+import { createVNode, defineComponent, onErrorCaptured, renderSlot, shallowRef, watch } from "vue";
+// src/admin/shell-error-boundary.vue?vue&type=script&setup=true&lang.ts
+var shell_error_boundary_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "shell-error-boundary",
+	setup(__props) {
+		/**
+		* The shell error boundary, the Vue twin of React's `ShellErrorBoundary`.
+		* `onErrorCaptured` keeps the first error from the wrapped tree and swaps the
+		* default slot for a fallback.
+		*
+		* The error clears when `location.pathname` changes, not on a search or hash
+		* change, and the boundary has no `key`: the wrapped layout and its form state
+		* survive every navigation.
+		*
+		* Only errors from setup, render and the creation, mount and update hooks are
+		* captured, as in React: a failed event handler or watcher propagates and
+		* leaves the page usable. Returning `false` stops a captured error here, so
+		* `app.config.errorHandler` does not see it.
+		*/
+		const captured = shallowRef(null);
+		const CAPTURED_SOURCES = /* @__PURE__ */ new Set([
+			"setup function",
+			"render function",
+			"beforeCreate hook",
+			"created hook",
+			"beforeMount hook",
+			"mounted hook",
+			"beforeUpdate hook",
+			"updated",
+			"0",
+			"1",
+			"bc",
+			"c",
+			"bm",
+			"m",
+			"bu",
+			"u"
+		]);
+		function isCapturedSource(info) {
+			return CAPTURED_SOURCES.has(info.split("#runtime-").pop() ?? info);
+		}
+		onErrorCaptured((error, _instance, info) => {
+			if (captured.value || !isCapturedSource(info)) return;
+			captured.value = {
+				error: error instanceof Error ? error : new Error(String(error)),
+				info
+			};
+			return false;
+		});
+		function reset() {
+			captured.value = null;
+		}
+		const location = useLocation();
+		watch(() => location.value.pathname, reset);
+		return (_ctx, _cache) => {
+			return captured.value ? renderSlot(_ctx.$slots, "error", {
+				error: captured.value.error,
+				info: captured.value.info,
+				reset
+			}, () => [createVNode(default_error_fallback_default, {
+				error: captured.value.error,
+				info: captured.value.info,
+				reset
+			}, null, 8, ["error", "info"])], void 0, 0) : renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 1);
+		};
+	}
+});
+export { shell_error_boundary_vue_vue_type_script_setup_true_lang_default as default };

package/dist/admin/slot-routes.js

@@ -1,68 +1,88 @@
+import { toRouteRecord } from "./custom-routes.js";
+import { defineComponent, markRaw } from "vue";
 import { joinBasename } from "@chelone/core";
-import { markRaw, defineComponent } from "vue";
 import { useRoute } from "vue-router";
-import { toRouteRecord } from "./custom-routes.js";
-const CATCH_ALL_META = "chelone:catchAll";
-const PAGE_SLOTS = [
-  { name: "authCallback", path: "/auth-callback", noLayout: true },
-  { name: "authenticationError", path: "/authentication-error" },
-  { name: "accessDenied", path: "/access-denied" },
-  { name: "catchAll", path: "/:pathMatch(.*)*" }
+// src/admin/slot-routes.ts
+/** The route meta key marking the `#catchAll` route, which matches any path. */
+var CATCH_ALL_META = "chelone:catchAll";
+var PAGE_SLOTS = [
+	{
+		name: "authCallback",
+		path: "/auth-callback",
+		noLayout: true
+	},
+	{
+		name: "authenticationError",
+		path: "/authentication-error"
+	},
+	{
+		name: "accessDenied",
+		path: "/access-denied"
+	},
+	{
+		name: "catchAll",
+		path: "/:pathMatch(.*)*"
+	}
 ];
+/** A route component that renders the slot as it is now, not as it was at setup. */
 function slotPage(slots, name) {
-  return markRaw(defineComponent({ setup: () => () => slots[name]?.() }));
+	return markRaw(defineComponent({ setup: () => () => slots[name]?.() }));
 }
+/**
+* The catch-all also matches the basename root, which the dashboard or the
+* first-resource redirect owns, so it renders nothing there.
+*/
 function catchAllPage(slots, basename) {
-  const indexPath = joinBasename("/", basename).toLowerCase();
-  return markRaw(
-    defineComponent({
-      setup() {
-        const route = useRoute();
-        return () => {
-          const path = route.path.toLowerCase();
-          return path === indexPath || path === `${indexPath}/` ? null : slots.catchAll?.();
-        };
-      }
-    })
-  );
+	const indexPath = joinBasename("/", basename).toLowerCase();
+	return markRaw(defineComponent({ setup() {
+		const route = useRoute();
+		return () => {
+			const path = route.path.toLowerCase();
+			return path === indexPath || path === `${indexPath}/` ? null : slots.catchAll?.();
+		};
+	} }));
 }
+/**
+* Routes for the page slots that are given, under `basename`. `sync` adds the
+* route of a slot that has appeared and removes that of one that has gone, so
+* call it on each update: `useSlots()` is not reactive.
+*/
 function createSlotRoutes(router, slots, basename) {
-  const removers = /* @__PURE__ */ new Map();
-  function sync() {
-    let changed = false;
-    for (const { name, path, noLayout } of PAGE_SLOTS) {
-      const given = slots[name] != null;
-      if (!given) {
-        if (removers.has(name)) {
-          removers.get(name)?.();
-          removers.delete(name);
-          changed = true;
-        }
-      } else if (!removers.has(name)) {
-        const route = {
-          path,
-          noLayout,
-          component: name === "catchAll" ? catchAllPage(slots, basename) : slotPage(slots, name)
-        };
-        const record = toRouteRecord(route, basename);
-        removers.set(
-          name,
-          router.addRoute(
-            name === "catchAll" ? { ...record, meta: { ...record.meta, [CATCH_ALL_META]: true } } : record
-          )
-        );
-        changed = true;
-      }
-    }
-    return changed;
-  }
-  function dispose() {
-    for (const remove of removers.values()) remove();
-    removers.clear();
-  }
-  return { sync, dispose };
+	const removers = /* @__PURE__ */ new Map();
+	/** Returns whether a route was added or removed. */
+	function sync() {
+		let changed = false;
+		for (const { name, path, noLayout } of PAGE_SLOTS) if (!(slots[name] != null)) {
+			if (removers.has(name)) {
+				removers.get(name)?.();
+				removers.delete(name);
+				changed = true;
+			}
+		} else if (!removers.has(name)) {
+			const route = {
+				path,
+				noLayout,
+				component: name === "catchAll" ? catchAllPage(slots, basename) : slotPage(slots, name)
+			};
+			const record = toRouteRecord(route, basename);
+			removers.set(name, router.addRoute(name === "catchAll" ? {
+				...record,
+				meta: {
+					...record.meta,
+					[CATCH_ALL_META]: true
+				}
+			} : record));
+			changed = true;
+		}
+		return changed;
+	}
+	function dispose() {
+		for (const remove of removers.values()) remove();
+		removers.clear();
+	}
+	return {
+		sync,
+		dispose
+	};
 }
-export {
-  CATCH_ALL_META,
-  createSlotRoutes
-};
+export { CATCH_ALL_META, createSlotRoutes };