@celestia-island/hikari 0.41.3 → 0.41.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celestia-island/hikari",
-  "version": "0.41.3",
+  "version": "0.41.6",
   "private": false,
   "type": "module",
   "description": "Hikari Vue 3 component library — production-grade UI components based on shittim-chest design system",

package/src/components/HkButton.scss

@@ -64,62 +64,6 @@
   min-height: 2.75rem;
 }
 
-/* ---- Prefix / suffix icon boxes ---- */
-/* Standard-part contract (2026-09-10 user direction): a button glyph
-   renders inside a FIXED SQUARE box — flex:none so host flex rows can
-   never squeeze it into a squat sliver, centered on both axes so the
-   icon rides the button's vertical midline at any button height, and
-   the box (not the bare svg) owns the rhythm so the glyph keeps a
-   consistent margin from the adjacent label via the button's own gap.
-   The 1rem box matches the 16px glyph HkButton renders for the
-   icon/suffix props. */
-.hk-btn-icon,
-.hk-btn-suffix {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  flex: none;
-  inline-size: 1rem;
-  block-size: 1rem;
-  line-height: 0;
-
-  svg {
-    display: block;
-  }
-}
-
-/* ---- Icon-only square ---- */
-/* An icon-only HkButton (glyph, no label) occupies a SQUARE footprint
-   by default: padding collapses fully and width locks to the size
-   variant's min-height, so it reads as the same standard square the
-   HIconButton family guarantees. box-sizing is self-declared (house
-   convention — geometry rules never rely on a host-side reset reaching
-   the component): with zero padding the min-height governs the height
-   on every size, an exact square under border-box AND content-box.
-   Hosts may still override with an explicit width when a design
-   genuinely calls for another shape. */
-.hk-btn-icon-only {
-  padding: 0;
-  box-sizing: border-box;
-}
-
-.hk-btn-sm.hk-btn-icon-only {
-  width: 1.75rem;
-}
-
-.hk-btn-md.hk-btn-icon-only {
-  width: 2.5rem;
-}
-
-.hk-btn-lg.hk-btn-icon-only {
-  width: 2.75rem;
-}
-
-/* The first-class block prop wins over the square width. */
-.hk-btn-block.hk-btn-icon-only {
-  width: 100%;
-}
-
 /* ---- Primary ---- */
 
 .hk-btn-primary {

package/src/components/HkButton.test.tsx

@@ -1,13 +1,8 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { createApp, h } from "vue";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import HkButton from "./HkButton";
 
-const here = dirname(fileURLToPath(import.meta.url));
-
 /**
  * HkButton contract tests:
  * - variant / size / block / loading class mapping on the root <button>
@@ -147,82 +142,6 @@ describe("HkButton content slots", () => {
   });
 });
 
-describe("HkButton icon-only square contract", () => {
-  it("flags the icon-only square class for a glyph with no label", () => {
-    const iconOnly = mount(h(HkButton, { icon: "close", ariaLabel: "Close" }));
-    const btn = button(iconOnly);
-    expect(btn.className).toContain("hk-btn-icon-only");
-    expect(iconOnly.querySelector(".hk-btn-icon")).not.toBeNull();
-
-    const suffixOnly = mount(h(HkButton, { suffix: "close", ariaLabel: "Next" }));
-    expect(button(suffixOnly).className).toContain("hk-btn-icon-only");
-
-    // Glyph + text stays a normal text button — no square collapse.
-    const withText = mount(h(HkButton, { icon: "close" }, () => "Close"));
-    expect(button(withText).className).not.toContain("hk-btn-icon-only");
-  });
-
-  it("keeps the square footprint while an icon-only button loads", () => {
-    const c = mount(h(HkButton, { icon: "close", loading: true, ariaLabel: "Busy" }));
-    // The spinner replaces the glyph, but the button still carries no
-    // label — the square footprint must hold through the swap.
-    expect(button(c).className).toContain("hk-btn-icon-only");
-  });
-
-  it("keeps the block class alongside the icon-only square class", () => {
-    // CSS precedence lives in the SCSS contract test below; this pins the
-    // class composition so both rules can actually apply.
-    const c = mount(h(HkButton, { icon: "close", block: true, ariaLabel: "Go" }));
-    const cls = button(c).className;
-    expect(cls).toContain("hk-btn-block");
-    expect(cls).toContain("hk-btn-icon-only");
-  });
-
-  it("does not square-collapse when a shortcut chip rides along", () => {
-    // The HKbd chip is an extra flex child — the fixed square width would
-    // visibly clip it, so icon + shortcut stays a padded button.
-    const c = mount(h(HkButton, { icon: "close", shortcut: "Ctrl+W", ariaLabel: "Close" }));
-    expect(button(c).className).not.toContain("hk-btn-icon-only");
-  });
-});
-
-// SCSS geometry contract (house pattern, cf. HkNumberInput.affix.test.ts):
-// the square is a CSS fact — padding fully collapsed + self-declared
-// border-box (survives hosts without a reset) + the block prop winning
-// over the square width. Textual assertions because happy-dom does not
-// lay out.
-describe("HkButton icon-only SCSS contract", () => {
-  const scss = readFileSync(join(here, "HkButton.scss"), "utf-8");
-
-  it("self-declares the collapsed square geometry", () => {
-    const rule = scss.match(/\.hk-btn-icon-only\s*{[^}]*}/)?.[0] ?? "";
-    expect(rule, "icon-only rule must exist").toBeTruthy();
-    expect(rule).toContain("padding: 0");
-    expect(rule).toContain("box-sizing: border-box");
-  });
-
-  it("lets the block prop win over the square width", () => {
-    const rule = scss.match(/\.hk-btn-block\.hk-btn-icon-only\s*{[^}]*}/)?.[0] ?? "";
-    expect(rule, "block override rule must exist").toBeTruthy();
-    expect(rule).toContain("width: 100%");
-  });
-
-  it("locks each size variant width to its min-height", () => {
-    const cases: Array<[string, string]> = [
-      ["sm", "1.75rem"],
-      ["md", "2.5rem"],
-      ["lg", "2.75rem"],
-    ];
-    for (const [size, width] of cases) {
-      const rule = scss.match(new RegExp(`\\.hk-btn-${size}\\.hk-btn-icon-only\\s*{[^}]*}`))?.[0] ?? "";
-      expect(rule, `${size} icon-only rule must exist`).toBeTruthy();
-      expect(rule).toContain(`width: ${width}`);
-      const minH = scss.match(new RegExp(`\\.hk-btn-${size}\\s*{[^}]*}`))?.[0] ?? "";
-      expect(minH).toContain(`min-height: ${width}`);
-    }
-  });
-});
-
 describe("HkButton attr fallthrough (inheritAttrs: false)", () => {
   it("spreads extra attrs and honors an explicit type", () => {
     const c = mount(h(HkButton, { type: "submit", "data-test": "probe" }, () => "Save"));

package/src/components/HkButton.tsx

@@ -42,47 +42,33 @@ export default defineComponent({
       props.shortcut ? "hk-btn-has-shortcut" : "",
     ]);
 
-    return () => {
-      // Icon-only contract (2026-09-10 user direction): a button carrying
-      // just a prefix/suffix glyph and no text collapses to the same
-      // square footprint the HIconButton family guarantees — a bare icon
-      // in a padded text button reads as a squat rectangle otherwise.
-      // Re-evaluated per render, NOT a computed: slots.default is not
-      // reactive, so a cached flag would go stale when a parent toggles
-      // the label slot without touching the icon props. A shortcut chip
-      // is excluded: it renders as an extra flex child the fixed square
-      // width would visibly clip.
-      const iconOnly =
-        !slots.default && Boolean(props.icon || props.suffix) && !props.shortcut;
-
-      return (
-        <button
-          {...attrs}
-          type={(attrs.type as "button" | "submit" | "reset") || "button"}
-          disabled={props.disabled || props.loading}
-          class={[buttonClass.value, iconOnly ? "hk-btn-icon-only" : "", attrs.class]}
-          style={attrs.style || undefined}
-          aria-label={props.ariaLabel}
-          aria-busy={props.loading || undefined}
-          onClick={(e) => emit("click", e)}
-        >
-          {props.loading ? <HSpinner size="xs" tone="current" /> : null}
-          {!props.loading && props.icon ? (
-            <span class="hk-btn-icon">
-              <HIcon name={props.icon} size={16} />
-            </span>
-          ) : null}
-          {slots.default?.()}
-          {props.suffix ? (
-            <span class="hk-btn-suffix">
-              <HIcon name={props.suffix} size={16} />
-            </span>
-          ) : null}
-          {props.shortcut ? (
-            <HKbd keys={props.shortcut!} size="sm" />
-          ) : null}
-        </button>
-      );
-    };
+    return () => (
+      <button
+        {...attrs}
+        type={(attrs.type as "button" | "submit" | "reset") || "button"}
+        disabled={props.disabled || props.loading}
+        class={[buttonClass.value, attrs.class]}
+        style={attrs.style || undefined}
+        aria-label={props.ariaLabel}
+        aria-busy={props.loading || undefined}
+        onClick={(e) => emit("click", e)}
+      >
+        {props.loading ? <HSpinner size="xs" tone="current" /> : null}
+        {!props.loading && props.icon ? (
+          <span class="hk-btn-icon">
+            <HIcon name={props.icon} size={16} />
+          </span>
+        ) : null}
+        {slots.default?.()}
+        {props.suffix ? (
+          <span class="hk-btn-suffix">
+            <HIcon name={props.suffix} size={16} />
+          </span>
+        ) : null}
+        {props.shortcut ? (
+          <HKbd keys={props.shortcut!} size="sm" />
+        ) : null}
+      </button>
+    );
   },
 });

package/src/components/HkIconButton.test.tsx

@@ -102,19 +102,4 @@ describe("HkIconButton", () => {
     const c = mountComp(() => h(HkIconButton, { "aria-label": "probe" }));
     expect(c.querySelector("circle")).not.toBeNull();
   });
-
-  // Named-icon contract (2026-09-10): the icon prop resolves through HIcon
-  // (functional keys ride the host material pack) — slot content still
-  // wins over it, and the placeholder circle only shows with neither.
-  it("renders the icon prop through HIcon, below slot precedence", () => {
-    const propOnly = mountComp(() => h(HkIconButton, { icon: "close", "aria-label": "close" }));
-    expect(propOnly.querySelector(".hk-icon")).not.toBeNull();
-    expect(propOnly.querySelector("circle")).toBeNull();
-
-    const propAndSlot = mountComp(() =>
-      h(HkIconButton, { icon: "close", "aria-label": "close" }, { icon: () => h("span", { class: "slot-probe" }) }),
-    );
-    expect(propAndSlot.querySelector(".slot-probe")).not.toBeNull();
-    expect(propAndSlot.querySelector(".hk-icon")).toBeNull();
-  });
 });

package/src/components/HkIconButton.tsx

@@ -1,7 +1,6 @@
 import { computed, defineComponent, type PropType } from "vue";
 import "./HkIconButton.scss";
 import "./HkIconButtonVars.scss";
-import HIcon from "./HkIcon";
 
 export default defineComponent({
   name: "HkIconButton",
@@ -22,14 +21,6 @@ export default defineComponent({
       `hk-icon-button-${props.variant}`,
     ]);
 
-    // Named-icon contract (2026-09-10 user direction): the icon prop is a
-    // first-class way to draw the glyph — it resolves through HIcon so
-    // functional keys ("close", "back") keep riding the host material-pack
-    // family exactly like the slot composition does. The rendered size is
-    // pinned by --hi-icon-button-icon-size; the HIcon size prop only picks
-    // the matching box class. Slot content still wins over the prop.
-    const glyphSize = computed(() => (props.size >= 32 ? 20 : 16));
-
     return () => (
       <button
         class={cls.value}
@@ -44,15 +35,11 @@ export default defineComponent({
               ? // Natural children usage: <HIconButton><HIcon .../></HIconButton>
                 // renders the child as the icon (unified window-close wave).
                 slots.default()
-              : props.icon
-                ? (
-                  <HIcon name={props.icon} size={glyphSize.value} />
-                )
-                : (
-                  <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-                    <circle cx="12" cy="12" r="10" />
-                  </svg>
-                )}
+              : (
+                <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                  <circle cx="12" cy="12" r="10" />
+                </svg>
+              )}
         </span>
       </button>
     );

package/src/components/HkSelectionGrid.scss

@@ -11,6 +11,15 @@
   margin: 0 0 0.5rem;
 }
 
+/* Foot note under the grid — same register as .hk-input-hint so the
+   helper line reads identically wherever it appears in a form. */
+.hk-selection-grid-hint {
+  margin: var(--space-4, 0.25rem) 0 0;
+  font-size: var(--text-xs, 0.75rem);
+  color: color-mix(in srgb, rgb(var(--color-muted)) 70%, rgb(var(--color-background)));
+  text-align: start;
+}
+
 .hk-selection-grid-grid {
   display: grid;
   gap: 0.5rem;

package/src/components/HkSelectionGrid.test.tsx

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { createApp, h } from "vue";
+
+import HkSelectionGrid, { type SelectionGridItem } from "./HkSelectionGrid";
+
+/**
+ * HkSelectionGrid contract tests:
+ * - single mode keys the lit state off `selectedId` and lights exactly one card
+ * - multi mode keys it off `selectedIds` membership and lights every listed id
+ * - multi mode never lets `selectedId` leak through (the two selectors stay
+ *   independent, so a stale single id cannot double-light a card)
+ * - `select` fires for already-selected cards too — the consumer owns the
+ *   toggle, the grid only reports the click
+ * - the optional `hint` renders under the grid and is absent when unset
+ *
+ * House style: raw createApp mounts on a shared container list torn down
+ * after each case; DOM assertions via document queries.
+ */
+
+const mounts: Array<{ app: ReturnType<typeof createApp>; container: HTMLElement }> = [];
+
+function mount(node: ReturnType<typeof h>) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const app = createApp({ render: () => node });
+  app.mount(container);
+  mounts.push({ app, container });
+  return container;
+}
+
+afterEach(() => {
+  for (const { app, container } of mounts.splice(0)) {
+    app.unmount();
+    container.remove();
+  }
+});
+
+const ITEMS: SelectionGridItem[] = [
+  { id: "text", title: "Text" },
+  { id: "vision", title: "Vision" },
+  { id: "gen", title: "Generation" },
+];
+
+function cards(container: HTMLElement) {
+  return Array.from(container.querySelectorAll<HTMLElement>(".hk-selection-grid-item"));
+}
+
+function litIds(container: HTMLElement) {
+  return cards(container)
+    .filter((el) => el.hasAttribute("data-selected"))
+    .map((el) => el.querySelector(".hk-selection-grid-name")?.textContent);
+}
+
+describe("HkSelectionGrid single mode", () => {
+  it("lights only the card matching selectedId", () => {
+    const container = mount(h(HkSelectionGrid, { items: ITEMS, selectedId: "vision" }));
+    expect(litIds(container)).toEqual(["Vision"]);
+  });
+
+  it("lights nothing when selectedId is undefined", () => {
+    const container = mount(h(HkSelectionGrid, { items: ITEMS }));
+    expect(litIds(container)).toEqual([]);
+  });
+
+  it("ignores selectedIds unless multi is on", () => {
+    const container = mount(
+      h(HkSelectionGrid, { items: ITEMS, selectedIds: ["text", "gen"], selectedId: "vision" }),
+    );
+    expect(litIds(container)).toEqual(["Vision"]);
+  });
+});
+
+describe("HkSelectionGrid multi mode", () => {
+  it("lights every id listed in selectedIds", () => {
+    const container = mount(
+      h(HkSelectionGrid, { items: ITEMS, multi: true, selectedIds: ["text", "gen"] }),
+    );
+    expect(litIds(container)).toEqual(["Text", "Generation"]);
+  });
+
+  it("lights nothing when selectedIds is empty", () => {
+    const container = mount(h(HkSelectionGrid, { items: ITEMS, multi: true }));
+    expect(litIds(container)).toEqual([]);
+  });
+
+  it("does not read selectedId while multi is on", () => {
+    const container = mount(
+      h(HkSelectionGrid, { items: ITEMS, multi: true, selectedIds: ["gen"], selectedId: "text" }),
+    );
+    expect(litIds(container)).toEqual(["Generation"]);
+  });
+
+  it("emits select for an already-selected card so the consumer can toggle it off", () => {
+    const seen: string[] = [];
+    const container = mount(
+      h(HkSelectionGrid, {
+        items: ITEMS,
+        multi: true,
+        selectedIds: ["vision"],
+        onSelect: (item: SelectionGridItem) => seen.push(item.id),
+      }),
+    );
+    cards(container)[1]!.click();
+    expect(seen).toEqual(["vision"]);
+  });
+});
+
+describe("HkSelectionGrid hint", () => {
+  it("renders the hint line under the grid when provided", () => {
+    const container = mount(h(HkSelectionGrid, { items: ITEMS, hint: "Pick one or more" }));
+    const hint = container.querySelector(".hk-selection-grid-hint");
+    expect(hint?.textContent).toBe("Pick one or more");
+  });
+
+  it("renders no hint node when the prop is unset", () => {
+    const container = mount(h(HkSelectionGrid, { items: ITEMS }));
+    expect(container.querySelector(".hk-selection-grid-hint")).toBeNull();
+  });
+});

package/src/components/HkSelectionGrid.tsx

@@ -19,8 +19,14 @@ export default defineComponent({
   props: {
     items: { type: Array as PropType<SelectionGridItem[]>, required: true },
     selectedId: { type: String, default: undefined },
+    selectedIds: {
+      type: Array as PropType<string[]>,
+      default: () => [],
+    },
+    multi: { type: Boolean, default: false },
     columns: { type: Number as PropType<SelectionGridCols>, default: 2 },
     groupTitle: { type: String, default: undefined },
+    hint: { type: String, default: undefined },
     dense: { type: Boolean, default: false },
   },
   emits: {
@@ -41,7 +47,9 @@ export default defineComponent({
             data-dense={props.dense || undefined}
           >
             {props.items.map((item) => {
-              const isSelected = props.selectedId === item.id;
+              const isSelected = props.multi
+                ? props.selectedIds.includes(item.id)
+                : props.selectedId === item.id;
               const ItemIcon = item.icon;
 
               return (
@@ -93,6 +101,9 @@ export default defineComponent({
               );
             })}
           </div>
+          {props.hint && (
+            <p class="hk-selection-grid-hint">{props.hint}</p>
+          )}
         </div>
       );
     };

package/src/runtime/createAuthGuard.permissions.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createAuthGuard } from "./createAuthGuard";
+
+/** Shape the guard's router parameter accepts (a slim slice of
+ *  vue-router's Router — the guard only calls beforeEach/onError). */
+interface SlimRouter {
+  beforeEach: (fn: (to: GuardTo) => unknown) => void;
+  onError: (fn: (error: unknown, to: GuardTo) => void) => void;
+}
+
+interface GuardTo {
+  name?: string | symbol | null;
+  fullPath?: string;
+  meta?: Record<string, unknown>;
+}
+
+/** Minimal router double: records guards, lets tests drive them. */
+function makeRouter() {
+  const guards: Array<(to: GuardTo) => unknown> = [];
+  const router: SlimRouter = {
+    beforeEach: (fn) => { guards.push(fn); },
+    onError: () => {},
+  };
+  return {
+    router,
+    run: (to: GuardTo) => {
+      expect(guards.length).toBeGreaterThan(0);
+      return guards[guards.length - 1](to);
+    },
+  };
+}
+
+function makeAuthStore(overrides: Partial<Record<string, unknown>> = {}) {
+  return {
+    isAuthenticated: false,
+    user: null,
+    tryRestoreSession: vi.fn().mockResolvedValue(undefined),
+    checkSetup: vi.fn().mockResolvedValue({ needs_setup: false }),
+    fetchUser: vi.fn().mockResolvedValue(undefined),
+    ...overrides,
+  };
+}
+
+/** Permissions-store double mirroring the real store's semantics:
+ *  `fetch()` resolves the set and flips loaded=true; a failing fetch
+ *  leaves loaded=false (fail-open). */
+function makePermStore(init: { loaded?: boolean; perms?: string[]; failFetch?: boolean } = {}) {
+  const state = { loaded: init.loaded ?? false, perms: init.perms ?? [] };
+  return {
+    get loaded() { return state.loaded; },
+    fetch: vi.fn().mockImplementation(async () => {
+      if (init.failFetch) return;
+      state.perms = init.perms ?? [];
+      state.loaded = true;
+    }),
+    has: (perm: string) => state.perms.includes(perm),
+    hasAny: (perms: string[]) => perms.some((p) => state.perms.includes(p)),
+  };
+}
+
+const baseOpts = {
+  loginRoute: "login",
+  homeRoute: "demiurge",
+  setupRoute: "setup-redirect",
+};
+
+describe("createAuthGuard requiresPermission enforcement", () => {
+  // Contract: routes declare `requiresPermission` (e.g. /backend with
+  // "system.read") and the guard is the enforcement point. The meta used
+  // to be declared but never consumed — any authenticated user could
+  // open the admin console route and only AdminLayout's own nav filtering
+  // hid the views (field report 2026-09).
+  it("bounces a user lacking the required permission to the home route", async () => {
+    const auth = makeAuthStore({ isAuthenticated: true, user: { username: "momoi" } });
+    const perms = makePermStore({ perms: [] });
+    const { router, run } = makeRouter();
+    createAuthGuard(router, { ...baseOpts, useAuthStore: () => auth, permissions: () => perms });
+
+    const verdict = await run({
+      name: "admin",
+      fullPath: "/backend",
+      meta: { requiresAuth: true, requiresPermission: "system.read" },
+    });
+    expect(verdict).toEqual({ name: "demiurge" });
+    expect(perms.fetch).toHaveBeenCalledOnce();
+  });
+
+  it("admits a user holding the required permission", async () => {
+    const auth = makeAuthStore({ isAuthenticated: true, user: { username: "demiurge" } });
+    const perms = makePermStore({ loaded: true, perms: ["system.read"] });
+    const { router, run } = makeRouter();
+    createAuthGuard(router, { ...baseOpts, useAuthStore: () => auth, permissions: () => perms });
+
+    const verdict = await run({
+      name: "admin",
+      fullPath: "/backend",
+      meta: { requiresAuth: true, requiresPermission: "system.read" },
+    });
+    expect(verdict).toBeUndefined();
+    // Already-loaded set must not be refetched on every navigation.
+    expect(perms.fetch).not.toHaveBeenCalled();
+  });
+
+  it("accepts any-of lists via hasAny", async () => {
+    const auth = makeAuthStore({ isAuthenticated: true, user: { username: "u" } });
+    const perms = makePermStore({ loaded: true, perms: ["industrial.write"] });
+    const { router, run } = makeRouter();
+    createAuthGuard(router, { ...baseOpts, useAuthStore: () => auth, permissions: () => perms });
+
+    const verdict = await run({
+      name: "writer",
+      fullPath: "/somewhere",
+      meta: { requiresPermission: ["system.read", "industrial.write"] },
+    });
+    expect(verdict).toBeUndefined();
+  });
+
+  it("fails open while the permission set is unloaded (store outage must not brick navigation)", async () => {
+    const auth = makeAuthStore({ isAuthenticated: true, user: { username: "u" } });
+    const perms = makePermStore({ failFetch: true });
+    const { router, run } = makeRouter();
+    createAuthGuard(router, { ...baseOpts, useAuthStore: () => auth, permissions: () => perms });
+
+    const verdict = await run({
+      name: "admin",
+      fullPath: "/backend",
+      meta: { requiresAuth: true, requiresPermission: "system.read" },
+    });
+    expect(verdict).toBeUndefined();
+  });
+
+  it("ignores routes without the meta and unwired permission stores", async () => {
+    const auth = makeAuthStore({ isAuthenticated: true, user: { username: "u" } });
+    const { router, run } = makeRouter();
+    createAuthGuard(router, { ...baseOpts, useAuthStore: () => auth });
+
+    const verdict = await run({ name: "demiurge", fullPath: "/@ws", meta: { requiresAuth: true } });
+    expect(verdict).toBeUndefined();
+  });
+});