@frigear-nu/events 0.0.7 → 0.0.9

package/dist/runtime/server/utils/admin.js

@@ -1,5 +1,8 @@
 import { db, schema } from "@nuxthub/db";
 import { newId } from "../../utils/index.js";
+import { asc, eq } from "drizzle-orm";
+import { loadCatalog } from "./catalog.js";
+import { eventInput, ticketTypeInput } from "./admin-schemas.js";
 export async function insertAddonGroup(ticketTypeId, input) {
   const { addons, ...group } = input;
   const [row] = await db.insert(schema.eventAddonGroups).values({ id: newId("agr"), ticketTypeId, ...group }).returning();
@@ -17,8 +20,55 @@ export async function insertTicketType(eventId, input) {
     capacity: type.capacity ?? null,
     saleStartsAt: type.saleStartsAt ?? null,
     saleEndsAt: type.saleEndsAt ?? null,
-    requiresMembership: type.requiresMembership ?? null
+    saleSchedule: type.saleSchedule ?? null,
+    requiresMembership: type.requiresMembership ?? null,
+    excludesMembership: type.excludesMembership ?? null
   }).returning();
   for (const group of addonGroups ?? []) await insertAddonGroup(row.id, group);
   return row;
 }
+export async function assertMembershipAvailable(...inputs) {
+  if (!inputs.some((input) => input?.requiresMembership || input?.excludesMembership)) return;
+  if ((await getMembershipOptions()).available) return;
+  throw createError({ statusCode: 400, statusMessage: "Membership rules need a membership provider such as @frigear-nu/subscriptions." });
+}
+export async function createEventWithCatalog(raw) {
+  const { ticketTypes, ...input } = raw;
+  await assertMembershipAvailable(input, ...ticketTypes ?? []);
+  const [taken] = await db.select({ id: schema.events.id }).from(schema.events).where(eq(schema.events.slug, input.slug)).limit(1);
+  if (taken) throw createError({ statusCode: 409, statusMessage: "An event with this slug already exists." });
+  const [row] = await db.insert(schema.events).values({
+    id: newId("evn"),
+    ...input,
+    requiresMembership: input.requiresMembership ?? null
+  }).returning();
+  for (const type of ticketTypes ?? []) await insertTicketType(row.id, type);
+  return row;
+}
+export const eventPatchSchema = eventInput.omit({ ticketTypes: true }).partial();
+export async function patchEventRow(id, patch) {
+  await assertMembershipAvailable(patch);
+  const [row] = await db.update(schema.events).set(patch).where(eq(schema.events.id, id)).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  return row;
+}
+export const ticketTypePatchSchema = ticketTypeInput.omit({ addonGroups: true }).partial();
+export async function patchTicketTypeRow(id, patch) {
+  await assertMembershipAvailable(patch);
+  const [row] = await db.update(schema.eventTicketTypes).set(patch).where(eq(schema.eventTicketTypes.id, id)).returning();
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Ticket type not found." });
+  return row;
+}
+export async function getEventWithTicketTypes(id) {
+  const [row] = await db.select().from(schema.events).where(eq(schema.events.id, id)).limit(1);
+  if (!row) throw createError({ statusCode: 404, statusMessage: "Event not found." });
+  const ticketTypes = await db.select().from(schema.eventTicketTypes).where(eq(schema.eventTicketTypes.eventId, id)).orderBy(asc(schema.eventTicketTypes.sortOrder));
+  const { groups, addons } = await loadCatalog(id);
+  return {
+    ...row,
+    ticketTypes: ticketTypes.map((type) => ({
+      ...type,
+      addonGroups: groups.filter((group) => group.ticketTypeId === type.id).map((group) => ({ ...group, addons: addons.filter((addon) => addon.groupId === group.id) }))
+    }))
+  };
+}

package/dist/runtime/server/utils/auth.d.ts

@@ -1,10 +1,11 @@
 import type { H3Event } from 'h3';
-/**
- * Gate for staff routes (event/ticket management, check-in). This repo has no shared permission
- * system, so the host app decides through the `events:authorize` Nitro hook. Denied by default:
- *
- *     nitroApp.hooks.hook('events:authorize', (ctx) => { ctx.allowed = isStaff(ctx.userId) })
- */
+/** Gate for staff routes (event/ticket management, check-in). */
 export declare function requireEventsManager(event: H3Event): Promise<{
     userId: number;
 }>;
+/** Non-throwing form of the `events:authorize` policy for the caller of an already-authenticated request (MCP). */
+export declare const canManageEvents: (event: H3Event, principal: {
+    user: {
+        id: number;
+    };
+}) => any;

package/dist/runtime/server/utils/auth.js

@@ -1,7 +1,7 @@
+const gate = definePolicyGate("events:authorize");
 export async function requireEventsManager(event) {
-  const { user } = await requireUserSession(event);
-  const ctx = { event, userId: user.id, allowed: false };
-  await useNitroApp().hooks.callHook("events:authorize", ctx);
-  if (!ctx.allowed) throw createError({ statusCode: 403, statusMessage: "You are not allowed to manage events." });
+  const user = await requireUser(event, { scopes: ["events:manage"] });
+  await gate.assert(event, user.id, "You are not allowed to manage events.");
   return { userId: user.id };
 }
+export const canManageEvents = (event, principal) => gate.isAllowed(event, principal.user.id);

package/dist/runtime/server/utils/catalog.d.ts

@@ -1,5 +1,6 @@
 import { schema } from '@nuxthub/db';
 import type { EventDetailDto, EventSummaryDto, TicketDto } from '../../../types.js';
+import type { Schedule } from '@frigear-nu/module-kit/schedule';
 type EventRow = typeof schema.events.$inferSelect;
 type TicketRow = typeof schema.eventTickets.$inferSelect;
 /** Tickets that currently occupy a seat: paid ones, and unpaid ones still inside their reservation window. */
@@ -15,6 +16,19 @@ export declare function loadCatalog(eventId: string): Promise<{
     groups: any;
     addons: any;
 }>;
+type SaleWindowType = {
+    saleStartsAt: Date | null;
+    saleEndsAt: Date | null;
+    saleSchedule: Schedule | null;
+};
+/**
+ * Whether a ticket type can be bought at `now`: its fixed window (`saleStartsAt`/`saleEndsAt`) and its optional
+ * recurring `saleSchedule` must both be open. `opensAt` is when sales (re)open, if they will.
+ */
+export declare function saleWindow(type: SaleWindowType, now?: Date): {
+    state: 'open' | 'not_started' | 'ended';
+    opensAt: Date | null;
+};
 /**
  * The public event detail. For a signed-in user (`userId`) each ticket type also says whether they
  * may buy it (`blocked`), so the UI can disable it with the right badge.

package/dist/runtime/server/utils/catalog.js

@@ -1,7 +1,8 @@
 import { db, schema } from "@nuxthub/db";
 import { and, asc, eq, gt, inArray, like, or, sql } from "drizzle-orm";
+import { isScheduleOpen, nextScheduleOpening } from "@frigear-nu/module-kit/schedule";
 import { normalizeMembership } from "../../utils/index.js";
-import { meetsMembership } from "./membership.js";
+import { meetsMembership, passesExclusion } from "./membership.js";
 export function holdsSeat() {
   const cutoff = new Date(Date.now() - useRuntimeConfig().events.reservationMinutes * 6e4);
   return or(
@@ -46,6 +47,16 @@ export async function loadCatalog(eventId) {
   const addons = groupIds.length ? await db.select().from(schema.eventAddons).where(inArray(schema.eventAddons.groupId, groupIds)).orderBy(asc(schema.eventAddons.sortOrder)) : [];
   return { types, groups, addons };
 }
+export function saleWindow(type, now = /* @__PURE__ */ new Date()) {
+  const time = now.getTime();
+  if (type.saleStartsAt && type.saleStartsAt.getTime() > time) return { state: "not_started", opensAt: type.saleStartsAt };
+  if (type.saleEndsAt && type.saleEndsAt.getTime() < time) return { state: "ended", opensAt: null };
+  if (!isScheduleOpen(type.saleSchedule ?? void 0, now)) {
+    const opensAt = nextScheduleOpening(type.saleSchedule ?? void 0, now);
+    return opensAt && (!type.saleEndsAt || opensAt < type.saleEndsAt) ? { state: "not_started", opensAt } : { state: "ended", opensAt: null };
+  }
+  return { state: "open", opensAt: null };
+}
 export async function getEventDetail(row, userId) {
   const { types, groups, addons } = await loadCatalog(row.id);
   const eventRequirement = normalizeMembership(row.requiresMembership);
@@ -53,11 +64,14 @@ export async function getEventDetail(row, userId) {
   const ticketTypes = await Promise.all(types.map(async (type) => {
     const seats = type.capacity === null ? null : await countSeats(type.id);
     const remaining = type.capacity === null ? null : Math.max(type.capacity - (seats ?? 0), 0);
-    const saleState = type.saleStartsAt && type.saleStartsAt.getTime() > now ? "not_started" : type.saleEndsAt && type.saleEndsAt.getTime() < now ? "ended" : remaining === 0 ? "sold_out" : "open";
+    const window = saleWindow(type, new Date(now));
+    const saleState = window.state === "open" && remaining === 0 ? "sold_out" : window.state;
     const typeRequirement = normalizeMembership(type.requiresMembership);
+    const typeExclusion = normalizeMembership(type.excludesMembership);
     let blocked = null;
     if (userId !== void 0) {
       if (!await meetsMembership(userId, eventRequirement) || !await meetsMembership(userId, typeRequirement)) blocked = "membership_required";
+      else if (!await passesExclusion(userId, typeExclusion)) blocked = "membership_excluded";
       else {
         const [owned] = await db.select({ count: sql`count(*)` }).from(schema.eventTickets).where(and(
           eq(schema.eventTickets.userId, userId),
@@ -90,8 +104,9 @@ export async function getEventDetail(row, userId) {
       hidePrice: type.hidePrice,
       isDefault: type.isDefault,
       requiresMembership: typeRequirement,
+      excludesMembership: typeExclusion,
       remaining,
-      saleStartsAt: type.saleStartsAt?.toISOString() ?? null,
+      saleStartsAt: (window.state === "not_started" ? window.opensAt : type.saleStartsAt)?.toISOString() ?? null,
       saleEndsAt: type.saleEndsAt?.toISOString() ?? null,
       saleState,
       blocked,
@@ -123,7 +138,8 @@ export async function toTicketDtos(rows) {
       paymentId: row.paymentId,
       code: row.status === "paid" ? row.code : null,
       checkedInAt: row.checkedInAt?.toISOString() ?? null,
-      createdAt: row.createdAt.toISOString()
+      createdAt: row.createdAt.toISOString(),
+      locale: row.locale ?? null
     };
   });
 }

package/dist/runtime/server/utils/membership.d.ts

@@ -1,3 +1,7 @@
-import type { MembershipRequirement } from '../../types.js';
-/** True when `requirement` is null, or the user holds a matching active subscription. */
+import type { MembershipOptionsContext, MembershipRequirement } from '../../types.js';
+/** True when `requirement` is null, or a membership provider confirms the user holds a matching membership. */
 export declare function meetsMembership(userId: number, requirement: MembershipRequirement | undefined): Promise<boolean>;
+/** True when `exclusion` is null, or the user holds none of the excluded memberships (`'any'` = no membership at all). */
+export declare function passesExclusion(userId: number, exclusion: MembershipRequirement | undefined): Promise<boolean>;
+/** What the installed membership provider(s) offer; `available` is false when there is none. */
+export declare function getMembershipOptions(): Promise<MembershipOptionsContext>;

package/dist/runtime/server/utils/membership.js

@@ -1,5 +1,18 @@
-import { hasActiveSubscription } from "#events/membership";
+async function holds(userId, requirement) {
+  const ctx = { userId, requirement, satisfied: false };
+  await useNitroApp().hooks.callHook("events:membership:check", ctx);
+  return ctx.satisfied;
+}
 export async function meetsMembership(userId, requirement) {
   if (!requirement) return true;
-  return hasActiveSubscription(userId, requirement === "any" ? {} : { plans: requirement });
+  return holds(userId, requirement);
+}
+export async function passesExclusion(userId, exclusion) {
+  if (!exclusion) return true;
+  return !await holds(userId, exclusion);
+}
+export async function getMembershipOptions() {
+  const ctx = { available: false, options: [] };
+  await useNitroApp().hooks.callHook("events:membership:options", ctx);
+  return ctx;
 }

package/dist/runtime/server/utils/tickets.js

@@ -1,8 +1,9 @@
 import { db, schema } from "@nuxthub/db";
 import { and, eq, sql } from "drizzle-orm";
-import { newId, newTicketCode, normalizeMembership, resolveSameOriginUrl, translate } from "../../utils/index.js";
+import { resolveSameOriginUrl } from "@frigear-nu/stripe/utils";
+import { newId, newTicketCode, normalizeMembership, translate } from "../../utils/index.js";
 import { countAddonSeats, countSeats, getPublishedEventRow, holdsSeat, loadCatalog, toTicketDtos } from "./catalog.js";
-import { meetsMembership } from "./membership.js";
+import { meetsMembership, passesExclusion } from "./membership.js";
 const fail = (statusCode, statusMessage) => createError({ statusCode, statusMessage });
 function returnUrls(event, slug, ticketId, body) {
   const origin = getRequestURL(event).origin;
@@ -30,13 +31,14 @@ export async function purchaseTicket(event, userId, slug, body) {
   const { types, groups, addons } = await loadCatalog(eventRow.id);
   const type = types.find((item) => item.id === body.ticketTypeId);
   if (!type) throw fail(404, "Ticket type not found.");
-  const now = Date.now();
-  if (type.saleStartsAt && type.saleStartsAt.getTime() > now) throw fail(409, "Ticket sales have not started yet.");
-  if (type.saleEndsAt && type.saleEndsAt.getTime() < now) throw fail(409, "Ticket sales have ended.");
+  const window = saleWindow(type);
+  if (window.state === "not_started") throw fail(409, "Ticket sales have not started yet.");
+  if (window.state === "ended") throw fail(409, "Ticket sales have ended.");
   const requirements = [normalizeMembership(eventRow.requiresMembership), normalizeMembership(type.requiresMembership)];
   for (const requirement of requirements) {
     if (!await meetsMembership(userId, requirement)) throw fail(403, "An active membership is required for this ticket.");
   }
+  if (!await passesExclusion(userId, normalizeMembership(type.excludesMembership))) throw fail(403, "This ticket is not available for your membership.");
   const typeGroups = groups.filter((group) => group.ticketTypeId === type.id);
   const typeAddons = addons.filter((addon) => typeGroups.some((group) => group.id === addon.groupId));
   const addonIds = [...new Set(body.addonIds ?? [])];
@@ -47,11 +49,11 @@ export async function purchaseTicket(event, userId, slug, body) {
   });
   for (const group of typeGroups) {
     const inGroup = chosen.filter((addon) => addon.groupId === group.id);
-    if (group.required && inGroup.length === 0) throw fail(400, `Choose an option for "${translate(group.title)}".`);
-    if (!group.multiple && inGroup.length > 1) throw fail(400, `Only one option can be chosen for "${translate(group.title)}".`);
+    if (group.required && inGroup.length === 0) throw fail(400, `Choose an option for "${translate(group.title, body.locale)}".`);
+    if (!group.multiple && inGroup.length > 1) throw fail(400, `Only one option can be chosen for "${translate(group.title, body.locale)}".`);
   }
   for (const addon of chosen) {
-    if (addon.capacity !== null && await countAddonSeats(addon.id) >= addon.capacity) throw fail(409, `"${translate(addon.label)}" is sold out.`);
+    if (addon.capacity !== null && await countAddonSeats(addon.id) >= addon.capacity) throw fail(409, `"${translate(addon.label, body.locale)}" is sold out.`);
   }
   if (type.capacity !== null && await countSeats(type.id) >= type.capacity) throw fail(409, "This ticket type is sold out.");
   await useNitroApp().hooks.callHook("events:purchase:before", { event, userId, eventId: eventRow.id, ticketTypeId: type.id, addonIds });
@@ -64,6 +66,7 @@ export async function purchaseTicket(event, userId, slug, body) {
     eventId: eventRow.id,
     ticketTypeId: type.id,
     userId,
+    locale: body.locale ?? null,
     status: amount === 0 ? "paid" : "pending",
     addons: chosen.map((addon) => ({ id: addon.id, label: addon.label, price: addon.price })),
     amount,
@@ -81,7 +84,7 @@ export async function purchaseTicket(event, userId, slug, body) {
     const winners = await db.select({ id: schema.eventTickets.id }).from(schema.eventTickets).where(and(sql`${schema.eventTickets.addons} like ${`%"id":"${addon.id}"%`}`, holdsSeat())).orderBy(sql`rowid`).limit(addon.capacity);
     if (!winners.some((winner) => winner.id === id)) {
       await release(id);
-      throw fail(409, `"${translate(addon.label)}" is sold out.`);
+      throw fail(409, `"${translate(addon.label, body.locale)}" is sold out.`);
     }
   }
   const [dto] = await toTicketDtos([inserted]);
@@ -93,10 +96,10 @@ export async function purchaseTicket(event, userId, slug, body) {
     const urls = returnUrls(event, eventRow.slug, id, body);
     const { payment, url } = await createPayment({
       userId,
-      description: `${translate(eventRow.name)} - ${translate(type.name)}`,
+      description: `${translate(eventRow.name, body.locale)} - ${translate(type.name, body.locale)}`,
       items: [
-        ...type.price > 0 ? [{ name: `${translate(eventRow.name)} - ${translate(type.name)}`, amount: type.price, currency: type.currency }] : [],
-        ...chosen.filter((addon) => addon.price > 0).map((addon) => ({ name: translate(addon.label), amount: addon.price, currency: type.currency }))
+        ...type.price > 0 ? [{ name: `${translate(eventRow.name, body.locale)} - ${translate(type.name, body.locale)}`, amount: type.price, currency: type.currency }] : [],
+        ...chosen.filter((addon) => addon.price > 0).map((addon) => ({ name: translate(addon.label, body.locale), amount: addon.price, currency: type.currency }))
       ],
       reference: { type: "event_ticket", id },
       expiresInMinutes: useRuntimeConfig().events.reservationMinutes,

package/dist/runtime/utils/index.d.ts

@@ -1,14 +1,24 @@
-import type { MembershipRequirement, Translated } from '../types.js';
+import { translate } from '@frigear-nu/ui/translated';
+import type { MembershipRequirement } from '../types.js';
+export { translate };
 export type { AddonDto, AddonGroupDto, AuthorizeContext, CheckInResponse, EventDetailDto, EventStatus, EventSummaryDto, MembershipRequirement, ModuleOptions, PurchaseBeforeContext, PurchaseBody, PurchaseResponse, TicketDto, TicketHookContext, TicketStatus, TicketTypeDto, Translated, } from '../types.js';
-/** Picks the text for a locale, falling back to `en`, then to the first available entry. */
-export declare function translate(value: Translated | null | undefined, locale?: string): string;
-/** Formats minor units, e.g. `formatPrice(15000, 'DKK', 'da')` -> `150,00 kr.`. */
-export declare function formatPrice(amount: number, currency: string, locale?: string): string;
+/** The currency tickets and add-ons are sold in unless they say otherwise (the column default). */
+export declare const DEFAULT_CURRENCY = "DKK";
 /** Normalises a stored requirement: empty plan lists mean "any active subscription". */
 export declare function normalizeMembership(value: MembershipRequirement | undefined): MembershipRequirement;
-/** Resolves a relative path against `origin`, and only accepts absolute URLs on the same origin. */
-export declare function resolveSameOriginUrl(input: string, origin: string): string | null;
 /** Random, prefixed id (`tkt_...`), Web Crypto only so it works on Workers. */
 export declare function newId(prefix: string): string;
 /** A longer random token for ticket QR codes. */
 export declare function newTicketCode(): string;
+/**
+ * Variables a ticket type's description can use in MDC (`{{ticket}}`, `{{price}}`, ...).
+ * `ticket` is the ticket's name; the rest describe the same ticket.
+ */
+export declare function ticketMdcData(type: {
+    name: unknown;
+    price: number;
+    currency: string;
+    hidePrice?: boolean;
+    remaining?: number | null;
+    key?: string;
+}, name: string, locale?: string): Record<string, unknown>;

package/dist/runtime/utils/index.js

@@ -1,30 +1,27 @@
-export function translate(value, locale = "en") {
-  if (!value) return "";
-  if (typeof value === "string") return value;
-  return value[locale] ?? value.en ?? Object.values(value)[0] ?? "";
-}
-export function formatPrice(amount, currency, locale = "en") {
-  return new Intl.NumberFormat(locale, { style: "currency", currency }).format(amount / 100);
-}
+import { translate } from "@frigear-nu/ui/translated";
+import { formatMoney as formatPrice } from "@frigear-nu/ui/money";
+export { translate };
+export const DEFAULT_CURRENCY = "DKK";
 export function normalizeMembership(value) {
   if (value === "any") return "any";
   if (Array.isArray(value)) return value.length ? value : "any";
   return null;
 }
-export function resolveSameOriginUrl(input, origin) {
-  if (input.startsWith("/")) {
-    if (input.startsWith("//") || input.startsWith("/\\")) return null;
-    return `${origin}${input}`;
-  }
-  try {
-    return new URL(input).origin === new URL(origin).origin ? input : null;
-  } catch {
-    return null;
-  }
-}
 export function newId(prefix) {
   return `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
 }
 export function newTicketCode() {
   return `${crypto.randomUUID().replaceAll("-", "")}${crypto.randomUUID().replaceAll("-", "")}`;
 }
+export function ticketMdcData(type, name, locale = "en") {
+  return {
+    ticket: name,
+    name,
+    key: type.key,
+    price: type.price === 0 ? "Free" : formatPrice(type.price, type.currency, locale),
+    amount: type.price,
+    currency: type.currency,
+    hidePrice: !!type.hidePrice,
+    remaining: type.remaining ?? null
+  };
+}

package/dist/types.d.mts

@@ -1,3 +1,5 @@
+export { type Translated } from '@frigear-nu/ui/translated'
+
 export { default } from './module.mjs'
 
-export { type AddonDto, type AddonGroupDto, type AuthorizeContext, type CheckInResponse, type EventDetailDto, type EventStatus, type EventSummaryDto, type EventsRuntimeConfig, type MembershipRequirement, type ModuleOptions, type PublicModuleOptions, type PurchaseBeforeContext, type PurchaseBody, type PurchaseResponse, type TicketDto, type TicketHookContext, type TicketStatus, type TicketTypeDto, type Translated } from './module.mjs'
+export { type AddonDto, type AddonGroupDto, type AuthorizeContext, type CheckInResponse, type EventDetailDto, type EventStatus, type EventSummaryDto, type EventsRuntimeConfig, type MembershipCheckContext, type MembershipOption, type MembershipOptionsContext, type MembershipRequirement, type ModuleOptions, type PublicModuleOptions, type PurchaseBeforeContext, type PurchaseBody, type PurchaseResponse, type TicketDto, type TicketHookContext, type TicketStatus, type TicketTypeDto } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frigear-nu/events",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Events with ticket types, addons, capacity, membership requirements, Stripe payments and QR check-in for the frigear ecosystem, built on @frigear-nu/payments.",
   "homepage": "https://docs.frigear.dev/modules/events",
   "repository": {
@@ -30,12 +30,15 @@
     "playground"
   ],
   "dependencies": {
-    "@frigear-nu/menu": "0.0.8",
-    "@frigear-nu/module-kit": "0.1.6",
-    "@frigear-nu/payments": "0.0.7",
-    "@frigear-nu/stripe": "0.0.7",
-    "@frigear-nu/subscriptions": "0.0.7",
-    "@frigear-nu/users": "1.0.8",
+    "@frigear-nu/admin": "0.0.3",
+    "@frigear-nu/module-kit": "1.0.0",
+    "@frigear-nu/payments": "0.0.9",
+    "@frigear-nu/stripe": "0.0.9",
+    "@frigear-nu/subscriptions": "0.0.9",
+    "@frigear-nu/ui": "0.0.8",
+    "@frigear-nu/auth": "0.0.4",
+    "@frigear-nu/mcp": "0.0.4",
+    "@frigear-nu/users": "1.0.10",
     "@libsql/client": "^0.18.0",
     "@nuxt/kit": "^4.6.0",
     "@vueuse/core": "^15.0.0",
@@ -48,15 +51,25 @@
     "zod": "^4.6.5"
   },
   "peerDependencies": {
+    "@frigear-nu/menu": "0.0.10",
+    "@frigear-nu/widget": "0.0.3",
     "@nuxt/ui": "^4.10.0",
     "@nuxthub/core": "^0.10.8"
   },
   "peerDependenciesMeta": {
+    "@frigear-nu/menu": {
+      "optional": true
+    },
+    "@frigear-nu/widget": {
+      "optional": true
+    },
     "@nuxt/ui": {
       "optional": true
     }
   },
   "devDependencies": {
+    "@frigear-nu/menu": "0.0.10",
+    "@frigear-nu/widget": "0.0.3",
     "@nuxt/devtools": "^3.4.2",
     "@nuxt/eslint-config": "^1.17.0",
     "@nuxt/module-builder": "^1.0.3",