@abraca/nuxt 1.8.2 → 2.0.0

package/dist/runtime/composables/useAAFollowAnchor.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from 'vue';
+import type { AAFocusPayload } from './useAAFocus.js';
+/**
+ * Smart anchor-based scroll-follow.
+ *
+ * Given a leader's `clientId` (or `publicKey`), this composable:
+ *   1. Watches the leader's `peer:aa:focus` payload
+ *   2. If the leader is on a different route, navigates the local browser
+ *      to match (via vue-router push)
+ *   3. Once on the same route, finds the leader's anchor element in the
+ *      LOCAL DOM and scrolls it to the same vertical position the leader
+ *      had it at — i.e. preserves the leader's `anchorRatio` rather than
+ *      copying raw scroll px. This keeps the experience consistent across
+ *      different viewport heights and zoom levels.
+ *
+ * Selection-kind payloads use the selection's start element as the anchor
+ * (the user is presumably reading where they're highlighting).
+ *
+ * Pass `null` (or `undefined`) for `leaderId` to disable the follow.
+ */
+export declare function useAAFollowAnchor(leaderId: Ref<number | null | undefined>): {
+    leader: import("vue").ComputedRef<import("../types.js").AwarenessPeer | null>;
+    leaderPayload: import("vue").ComputedRef<AAFocusPayload | null>;
+    scrollToLeader: () => void;
+};

package/dist/runtime/composables/useAAFollowAnchor.js

@@ -0,0 +1,69 @@
+import { computed, watch } from "vue";
+import { useRoute, useRouter } from "#imports";
+import { useAAEphemeral } from "./useAAEphemeral.js";
+import { useAwarenessPeers } from "./useAwarenessPeers.js";
+import { elementFromPath } from "../utils/domPath.js";
+export function useAAFollowAnchor(leaderId) {
+  const { peers } = useAAEphemeral("aa:focus");
+  const { peers: allPeers } = useAwarenessPeers();
+  const route = useRoute();
+  const router = useRouter();
+  let scrollRaf = 0;
+  let lastTargetKey = "";
+  const leaderPayload = computed(() => {
+    const id = leaderId.value;
+    if (id == null) return null;
+    const found = peers.value.find((p) => p.clientId === id);
+    return found?.value ?? null;
+  });
+  watch(leaderPayload, (payload) => {
+    if (!payload) return;
+    if (payload.route && payload.route !== route.path) {
+      router.push(payload.route).catch(() => {
+      });
+    }
+  }, { immediate: true });
+  function scrollToLeader() {
+    cancelAnimationFrame(scrollRaf);
+    scrollRaf = requestAnimationFrame(() => {
+      const payload = leaderPayload.value;
+      if (!payload) return;
+      if (payload.route !== route.path) return;
+      const instructions = [];
+      if (payload.scrollers && payload.scrollers.length) {
+        for (const s of payload.scrollers) {
+          instructions.push({ container: s.containerPath, element: s.elementPath, ratio: s.ratio });
+        }
+      } else if (payload.kind === "anchor" && payload.anchor) {
+        instructions.push({ element: payload.anchor.elementPath, ratio: payload.anchorRatio ?? 0.05 });
+      } else if (payload.kind === "selection" && payload.start) {
+        instructions.push({ element: payload.start.elementPath, ratio: 0.2 });
+      }
+      const fingerprint = [];
+      for (const ins of instructions) {
+        const target = elementFromPath(ins.element);
+        if (!target || !target.isConnected) continue;
+        const scroller = ins.container ? elementFromPath(ins.container) ?? window : window;
+        const isWindow = scroller === window;
+        const scrollerRect = isWindow ? { top: 0, height: window.innerHeight || document.documentElement.clientHeight } : scroller.getBoundingClientRect();
+        const desiredTop = scrollerRect.top + scrollerRect.height * Math.max(0, Math.min(0.9, ins.ratio));
+        const rect = target.getBoundingClientRect();
+        const delta = rect.top - desiredTop;
+        fingerprint.push(`${isWindow ? "w" : ins.container?.join(",")}-${Math.round(rect.top)}-${ins.ratio.toFixed(3)}`);
+        if (Math.abs(delta) < 8) continue;
+        if (isWindow) window.scrollBy({ top: delta, behavior: "smooth" });
+        else scroller.scrollBy({ top: delta, behavior: "smooth" });
+      }
+      const key = fingerprint.join("|");
+      if (key === lastTargetKey) return;
+      lastTargetKey = key;
+    });
+  }
+  watch(leaderPayload, scrollToLeader, { deep: true, flush: "post" });
+  const leader = computed(() => {
+    const id = leaderId.value;
+    if (id == null) return null;
+    return allPeers.value.find((p) => p.clientId === id) ?? null;
+  });
+  return { leader, leaderPayload, scrollToLeader };
+}

package/dist/runtime/composables/useAAFollowPeer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Follow another peer's `aware-ui` keys live. Reads the target peer's most
+ * recent writes to the shared `aware-ui` Y.Map and re-applies them locally
+ * by writing the same `{value, by, ts}` shape under our own clientId, so any
+ * `live`-bound aware component snaps to the leader's UI state (active tab,
+ * expanded accordion, current page, modal open, etc.).
+ *
+ * Activation is explicit — call `follow(clientId)` from `<AFollowBar>`. Local
+ * interaction (any keystroke, click, or scroll) calls `unfollow()` so the
+ * follower can break out at any time.
+ *
+ * Optional `keyPrefix` scopes the follow to a subset of UI keys; default
+ * follows everything the leader writes.
+ */
+export interface UseAAFollowPeerOptions {
+    /** Only mirror keys that start with this prefix. */
+    keyPrefix?: string;
+    /** Hook fired when the user breaks follow via local interaction. */
+    onBreak?: () => void;
+}
+export declare function useAAFollowPeer(options?: UseAAFollowPeerOptions): {
+    follow: (clientId: number) => void;
+    unfollow: () => void;
+    followingClientId: import("vue").Ref<number | null, number | null>;
+    followingUser: import("vue").ComputedRef<{
+        name?: string;
+        color?: string;
+    } | null>;
+};

package/dist/runtime/composables/useAAFollowPeer.js

@@ -0,0 +1,75 @@
+import { computed, onScopeDispose, ref, watch } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useSyncedMap } from "./useYDoc.js";
+import { useAwareness } from "./useAwareness.js";
+const _followingClientId = ref(null);
+export function useAAFollowPeer(options = {}) {
+  const { doc, provider } = useAbracadabra();
+  const { data, set } = useSyncedMap(doc, "aware-ui");
+  const { states } = useAwareness();
+  const followingClientId = _followingClientId;
+  let unsubInteraction = null;
+  const followingUser = computed(() => {
+    if (followingClientId.value == null) return null;
+    const state = states.value.get(followingClientId.value);
+    return state?.user ?? null;
+  });
+  function detachInteraction() {
+    unsubInteraction?.();
+    unsubInteraction = null;
+  }
+  function attachInteractionBreaker() {
+    detachInteraction();
+    if (typeof window === "undefined") return;
+    const onBreak = () => unfollow();
+    window.addEventListener("keydown", onBreak);
+    window.addEventListener("pointerdown", onBreak);
+    window.addEventListener("wheel", onBreak, { passive: true });
+    unsubInteraction = () => {
+      window.removeEventListener("keydown", onBreak);
+      window.removeEventListener("pointerdown", onBreak);
+      window.removeEventListener("wheel", onBreak);
+    };
+  }
+  function follow(clientId) {
+    if (followingClientId.value === clientId) return;
+    followingClientId.value = clientId;
+    attachInteractionBreaker();
+  }
+  function unfollow() {
+    if (followingClientId.value == null) return;
+    followingClientId.value = null;
+    detachInteraction();
+    options.onBreak?.();
+  }
+  const myClientId = computed(() => provider.value?.awareness?.clientID);
+  watch(
+    () => Object.entries(data),
+    (entries) => {
+      const target = followingClientId.value;
+      if (target == null) return;
+      const me = myClientId.value;
+      const prefix = options.keyPrefix;
+      for (const [key, entry] of entries) {
+        if (!entry || typeof entry !== "object") continue;
+        if (entry.by !== target) continue;
+        if (prefix && !key.startsWith(prefix)) continue;
+        set(key, { value: entry.value, by: me, ts: Date.now() });
+      }
+    },
+    { deep: true }
+  );
+  watch(followingClientId, (target) => {
+    if (target == null) return;
+    const me = myClientId.value;
+    const prefix = options.keyPrefix;
+    for (const [key, entry] of Object.entries(data)) {
+      if (!entry || typeof entry !== "object") continue;
+      if (entry.by !== target) continue;
+      if (prefix && !key.startsWith(prefix)) continue;
+      set(key, { value: entry.value, by: me, ts: Date.now() });
+    }
+  });
+  onScopeDispose(detachInteraction);
+  return { follow, unfollow, followingClientId, followingUser };
+}

package/dist/runtime/composables/useAAKey.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Broadcast the local user's most recent shortcut press as a short-lived
+ * ephemeral field. Receivers (`<AKeyHint>`, presence overlays) flash a brief
+ * "Janis just pressed ⌘K" indicator on the avatar.
+ *
+ * Each `pressKey(label)` call publishes `{ label, ts }` for ~1s, then auto-
+ * clears so peers don't see stale shortcuts.
+ */
+export interface PeerKeyHint {
+    clientId: number;
+    label: string;
+    ts: number;
+    user?: {
+        name?: string;
+        color?: string;
+        publicKey?: string;
+    };
+}
+export declare function useAAKey(): {
+    pressKey: (label: string) => void;
+    hints: import("vue").ComputedRef<PeerKeyHint[]>;
+};

package/dist/runtime/composables/useAAKey.js

@@ -0,0 +1,24 @@
+import { computed, onScopeDispose } from "vue";
+import { useAAEphemeral } from "./useAAEphemeral.js";
+const HOLD_MS = 1e3;
+export function useAAKey() {
+  const { peers, setLocal } = useAAEphemeral(() => "key:last");
+  let timer = null;
+  function pressKey(label) {
+    if (timer) clearTimeout(timer);
+    setLocal({ label, ts: Date.now() });
+    timer = setTimeout(() => {
+      setLocal(null);
+      timer = null;
+    }, HOLD_MS);
+  }
+  onScopeDispose(() => {
+    if (timer) clearTimeout(timer);
+    setLocal(null);
+  });
+  const hints = computed(() => {
+    const now = Date.now();
+    return peers.value.filter((p) => p.value && now - p.value.ts < HOLD_MS).map((p) => ({ clientId: p.clientId, label: p.value.label, ts: p.value.ts, user: p.user }));
+  });
+  return { pressKey, hints };
+}

package/dist/runtime/composables/useAAPointer.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Per-peer free-floating mouse pointer position over a scoped element.
+ *
+ * The local pointer position (relative to the scoped element's bounding box)
+ * is broadcast as `peer:pointer:<scope>` ephemeral state, RAF-throttled to
+ * the display refresh rate. Reads return every other peer's `{ x, y, vis }`
+ * with their user info attached, ready for rendering by `<APresenceCursors>`.
+ *
+ * Coordinates are normalised in [0, 1] so receivers can render at their own
+ * element size without sender-side knowledge of viewport dimensions.
+ */
+export interface PeerPointer {
+    clientId: number;
+    /** Normalised x within the scope element (0..1). */
+    x: number;
+    /** Normalised y within the scope element (0..1). */
+    y: number;
+    /** Whether the peer's pointer is inside the scope right now. */
+    vis: boolean;
+    user?: {
+        name?: string;
+        color?: string;
+        publicKey?: string;
+    };
+}
+export declare function useAAPointer(scope: MaybeRefOrGetter<string>, elementRef: Ref<HTMLElement | null | undefined>): {
+    pointers: import("vue").ComputedRef<PeerPointer[]>;
+};

package/dist/runtime/composables/useAAPointer.js

@@ -0,0 +1,53 @@
+import { computed, onScopeDispose, watch } from "vue";
+import { useAAEphemeral } from "./useAAEphemeral.js";
+export function useAAPointer(scope, elementRef) {
+  const slot = computed(() => `pointer:${typeof scope === "function" ? scope() : scope?.value ?? scope}`);
+  const { peers, setLocal } = useAAEphemeral(slot);
+  let raf = 0;
+  let pending = null;
+  function flush() {
+    raf = 0;
+    if (pending) setLocal(pending);
+  }
+  function onMove(e) {
+    const el = elementRef.value;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return;
+    const x = (e.clientX - rect.left) / rect.width;
+    const y = (e.clientY - rect.top) / rect.height;
+    pending = { x, y, vis: x >= 0 && x <= 1 && y >= 0 && y <= 1 };
+    if (!raf) raf = requestAnimationFrame(flush);
+  }
+  function onLeave() {
+    pending = { x: 0, y: 0, vis: false };
+    if (!raf) raf = requestAnimationFrame(flush);
+  }
+  let attached = null;
+  function attach(el) {
+    if (attached === el) return;
+    detach();
+    attached = el;
+    el.addEventListener("pointermove", onMove);
+    el.addEventListener("pointerleave", onLeave);
+  }
+  function detach() {
+    if (!attached) return;
+    attached.removeEventListener("pointermove", onMove);
+    attached.removeEventListener("pointerleave", onLeave);
+    attached = null;
+    setLocal(null);
+  }
+  watch(elementRef, (el) => {
+    if (el) attach(el);
+    else detach();
+  }, { immediate: true, flush: "post" });
+  onScopeDispose(() => {
+    if (raf) cancelAnimationFrame(raf);
+    detach();
+  });
+  const pointers = computed(
+    () => peers.value.filter((p) => p.value.vis).map((p) => ({ clientId: p.clientId, x: p.value.x, y: p.value.y, vis: p.value.vis, user: p.user }))
+  );
+  return { pointers };
+}

package/dist/runtime/composables/useAAUIState.d.ts

@@ -0,0 +1,29 @@
+import { type WritableComputedRef } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Shared UI state across every connected tab — the building block under the
+ * `live` prop on every aware component.
+ *
+ * Stores a single value keyed by `fieldKey` on a shared Y.Map called
+ * `aware-ui` on the root Y.Doc. All connected peers read and write the same
+ * record, so opening a dropdown / expanding an accordion / switching a tab
+ * happens *live* on every screen.
+ *
+ * Distinct from `useAAFieldValue`:
+ *   - `useAAFieldValue` stores the *bound primitive value* (input text, switch on/off)
+ *   - `useAAUIState` stores *UI chrome state* (open, expanded, sort col, current page)
+ *   - Different Y.Map names so reset / introspection / TTL logic stay separate.
+ *
+ * Each entry carries `{ value, by, ts }` so receivers can attribute the
+ * change ("opened by Janis") and apply last-write-wins on conflict.
+ */
+export interface UseAAUIStateOptions<T> {
+    /** Returned when no entry exists yet. */
+    defaultValue?: T;
+}
+export declare function useAAUIState<T = unknown>(fieldKey: MaybeRefOrGetter<string>, options?: UseAAUIStateOptions<T>): WritableComputedRef<T | undefined>;
+/**
+ * Read who last wrote a given live UI field — used to render attribution
+ * labels ("opened by Janis") in `live` components.
+ */
+export declare function useAAUIStateAuthor(fieldKey: MaybeRefOrGetter<string>): import("vue").ComputedRef<number | undefined>;

package/dist/runtime/composables/useAAUIState.js

@@ -0,0 +1,28 @@
+import { computed } from "vue";
+import { useAbracadabra } from "./useAbracadabra.js";
+import { useSyncedMap } from "./useYDoc.js";
+function resolveKey(fieldKey) {
+  if (typeof fieldKey === "function") return fieldKey();
+  if (fieldKey && typeof fieldKey === "object" && "value" in fieldKey) return fieldKey.value;
+  return fieldKey;
+}
+export function useAAUIState(fieldKey, options = {}) {
+  const { doc, provider } = useAbracadabra();
+  const { data, set } = useSyncedMap(doc, "aware-ui");
+  return computed({
+    get() {
+      const entry = data[resolveKey(fieldKey)];
+      if (!entry) return options.defaultValue;
+      return entry.value;
+    },
+    set(value) {
+      const by = provider.value?.awareness?.clientID;
+      set(resolveKey(fieldKey), { value, by, ts: Date.now() });
+    }
+  });
+}
+export function useAAUIStateAuthor(fieldKey) {
+  const { doc } = useAbracadabra();
+  const { data } = useSyncedMap(doc, "aware-ui");
+  return computed(() => data[resolveKey(fieldKey)]?.by);
+}

package/dist/runtime/composables/useAAViewport.d.ts

@@ -0,0 +1,22 @@
+import { type Ref } from 'vue';
+import type { MaybeRefOrGetter } from 'vue';
+/**
+ * IntersectionObserver-based "what section is this peer currently looking at"
+ * — broadcasts the data-section attribute of the most-visible region under a
+ * scoped container as `peer:viewport:<scope>` ephemeral state.
+ *
+ * Use case: render "Janis is reading the API section" overlays in long docs.
+ * Pair with `<APresenceCursors>` for a complete spatial-presence layer.
+ */
+export interface PeerViewport {
+    clientId: number;
+    section: string;
+    user?: {
+        name?: string;
+        color?: string;
+        publicKey?: string;
+    };
+}
+export declare function useAAViewport(scope: MaybeRefOrGetter<string>, elementRef: Ref<HTMLElement | null | undefined>): {
+    viewports: import("vue").ComputedRef<PeerViewport[]>;
+};

package/dist/runtime/composables/useAAViewport.js

@@ -0,0 +1,50 @@
+import { computed, onScopeDispose, watch } from "vue";
+import { useAAEphemeral } from "./useAAEphemeral.js";
+export function useAAViewport(scope, elementRef) {
+  const slot = computed(() => `viewport:${typeof scope === "function" ? scope() : scope?.value ?? scope}`);
+  const { peers, setLocal } = useAAEphemeral(slot);
+  let io = null;
+  let attached = null;
+  let mostVisible = null;
+  function publish() {
+    setLocal(mostVisible?.id ?? null);
+  }
+  function attach(el) {
+    if (attached === el) return;
+    detach();
+    attached = el;
+    io = new IntersectionObserver((entries) => {
+      let best = mostVisible;
+      for (const e of entries) {
+        const id = e.target.dataset.section;
+        if (!id) continue;
+        if (!e.isIntersecting) {
+          if (best?.id === id) best = null;
+          continue;
+        }
+        if (!best || e.intersectionRatio > best.ratio) {
+          best = { id, ratio: e.intersectionRatio };
+        }
+      }
+      mostVisible = best;
+      publish();
+    }, { threshold: [0, 0.25, 0.5, 0.75, 1] });
+    el.querySelectorAll("[data-section]").forEach((s) => io.observe(s));
+  }
+  function detach() {
+    io?.disconnect();
+    io = null;
+    attached = null;
+    mostVisible = null;
+    setLocal(null);
+  }
+  watch(elementRef, (el) => {
+    if (el) attach(el);
+    else detach();
+  }, { immediate: true, flush: "post" });
+  onScopeDispose(detach);
+  const viewports = computed(
+    () => peers.value.filter((p) => !!p.value).map((p) => ({ clientId: p.clientId, section: p.value, user: p.user }))
+  );
+  return { viewports };
+}

package/dist/runtime/composables/useAbraAdmin.d.ts

@@ -0,0 +1,54 @@
+/**
+ * useAbraAdmin
+ *
+ * Admin-only composable. Wraps the `/admin/*` REST endpoints (audit log,
+ * backup dump, user lockout). All methods reject with `Error('not admin')`
+ * when `isAdmin` is false — UI should gate route entry on the same flag.
+ *
+ * Usage:
+ *   const admin = useAbraAdmin()
+ *   if (admin.isAdmin.value) {
+ *     const rows = await admin.auditList({ event_type: 'auth.login_failed' })
+ *   }
+ */
+import type { AuditLogEntry, AuditQueryOpts, AuditVerifyResult } from '@abraca/dabra';
+declare function auditList(opts?: AuditQueryOpts): Promise<AuditLogEntry[]>;
+declare function auditExport(opts?: Omit<AuditQueryOpts, 'limit' | 'offset'>): Promise<string>;
+declare function auditVerify(): Promise<AuditVerifyResult>;
+declare function unlockUser(userId: string): Promise<void>;
+declare function backupDump(opts?: {
+    includeAudit?: boolean;
+}): Promise<Blob>;
+/**
+ * Convenience: download a backup tar to the user's machine. Computes a
+ * filename like `abracadabra-backup-<server>-<isoDate>.tar`.
+ */
+declare function downloadBackup(opts?: {
+    includeAudit?: boolean;
+    filename?: string;
+}): Promise<void>;
+export declare function useAbraAdmin(): {
+    /** True when the current effective role is admin/owner/service. */
+    isAdmin: import("vue").ComputedRef<boolean>;
+    /** Last-fetched audit log rows (best-first). */
+    auditEntries: import("vue").ShallowRef<AuditLogEntry[], AuditLogEntry[]>;
+    /** Last `auditVerify()` result, or null. */
+    auditVerifyResult: import("vue").ShallowRef<AuditVerifyResult | null, AuditVerifyResult | null>;
+    /** Whether an admin call is in flight. */
+    isLoading: import("vue").Ref<boolean, boolean>;
+    /** Last error message, or null. */
+    error: import("vue").Ref<string | null, string | null>;
+    /** GET /admin/audit. */
+    auditList: typeof auditList;
+    /** GET /admin/audit/export — returns NDJSON as a string. */
+    auditExport: typeof auditExport;
+    /** GET /admin/audit/verify — returns the result whether ok or broken. */
+    auditVerify: typeof auditVerify;
+    /** POST /admin/users/:id/unlock. */
+    unlockUser: typeof unlockUser;
+    /** GET /admin/backup/dump — returns the tar Blob. */
+    backupDump: typeof backupDump;
+    /** Convenience: backupDump + browser download. */
+    downloadBackup: typeof downloadBackup;
+};
+export {};

package/dist/runtime/composables/useAbraAdmin.js

@@ -0,0 +1,115 @@
+import { computed, ref, shallowRef } from "vue";
+import { useAbracadabra } from "#imports";
+const auditEntries = shallowRef([]);
+const auditVerifyResult = shallowRef(null);
+const isLoading = ref(false);
+const error = ref(null);
+function _client() {
+  const abra = useAbracadabra();
+  const c = abra.client.value;
+  if (!c) throw new Error("Not connected");
+  return { abra, client: c };
+}
+function _isAdminRole(role) {
+  return role === "admin" || role === "service" || role === "owner";
+}
+async function auditList(opts) {
+  const { client } = _client();
+  isLoading.value = true;
+  error.value = null;
+  try {
+    const rows = await client.adminAuditList(opts);
+    auditEntries.value = rows;
+    return rows;
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to load audit log";
+    throw e;
+  } finally {
+    isLoading.value = false;
+  }
+}
+async function auditExport(opts) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    return await client.adminAuditExport(opts);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to export audit log";
+    throw e;
+  }
+}
+async function auditVerify() {
+  const { client } = _client();
+  error.value = null;
+  try {
+    const result = await client.adminAuditVerify();
+    auditVerifyResult.value = result;
+    return result;
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Audit verification failed";
+    throw e;
+  }
+}
+async function unlockUser(userId) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    await client.adminUnlockUser(userId);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Failed to unlock user";
+    throw e;
+  }
+}
+async function backupDump(opts) {
+  const { client } = _client();
+  error.value = null;
+  try {
+    return await client.adminBackupDump(opts);
+  } catch (e) {
+    error.value = e instanceof Error ? e.message : "Backup dump failed";
+    throw e;
+  }
+}
+async function downloadBackup(opts) {
+  const { abra } = _client();
+  const blob = await backupDump(opts);
+  if (typeof window === "undefined") return;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const host = abra.currentServerUrl.value.replace(/^https?:\/\//, "").replace(/[^a-z0-9.-]/gi, "_");
+  a.download = opts?.filename ?? `abracadabra-backup-${host}-${date}.tar`;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+}
+export function useAbraAdmin() {
+  const abra = useAbracadabra();
+  const isAdmin = computed(() => _isAdminRole(abra.effectiveRole.value));
+  return {
+    /** True when the current effective role is admin/owner/service. */
+    isAdmin,
+    /** Last-fetched audit log rows (best-first). */
+    auditEntries,
+    /** Last `auditVerify()` result, or null. */
+    auditVerifyResult,
+    /** Whether an admin call is in flight. */
+    isLoading,
+    /** Last error message, or null. */
+    error,
+    /** GET /admin/audit. */
+    auditList,
+    /** GET /admin/audit/export — returns NDJSON as a string. */
+    auditExport,
+    /** GET /admin/audit/verify — returns the result whether ok or broken. */
+    auditVerify,
+    /** POST /admin/users/:id/unlock. */
+    unlockUser,
+    /** GET /admin/backup/dump — returns the tar Blob. */
+    backupDump,
+    /** Convenience: backupDump + browser download. */
+    downloadBackup
+  };
+}

package/dist/runtime/composables/useAbracadabraAuth.d.ts

@@ -12,7 +12,15 @@ export declare function useAbracadabraAuth(): {
     userNeutralColorName: any;
     claimAccount: any;
     loginWithHardware: any;
+    loginWithPassword: any;
+    registerWithPassword: any;
     logout: any;
+    logoutServer: any;
+    logoutAll: any;
+    requestPasswordReset: any;
+    confirmPasswordReset: any;
+    changePassword: any;
+    setPassword: any;
     recoverIdentity: any;
     unblockConnection: any;
     setUserName: any;

package/dist/runtime/composables/useAbracadabraAuth.js

@@ -15,7 +15,15 @@ export function useAbracadabraAuth() {
     userNeutralColorName: abra.userNeutralColorName,
     claimAccount: abra.claimAccount,
     loginWithHardware: abra.loginWithHardware,
+    loginWithPassword: abra.loginWithPassword,
+    registerWithPassword: abra.registerWithPassword,
     logout: abra.logout,
+    logoutServer: abra.logoutServer,
+    logoutAll: abra.logoutAll,
+    requestPasswordReset: abra.requestPasswordReset,
+    confirmPasswordReset: abra.confirmPasswordReset,
+    changePassword: abra.changePassword,
+    setPassword: abra.setPassword,
     recoverIdentity: abra.recoverIdentity,
     unblockConnection: abra.unblockConnection,
     setUserName: abra.setUserName,