@wervt/nuxt 0.3.8 → 0.3.10

package/dist/runtime/app/plugins/webmcp.client.js

@@ -1,49 +1,12 @@
 import { defineNuxtPlugin, onNuxtReady, useRuntimeConfig } from "#app";
+import { hasWebMcp, registerTools } from "@wervt/client";
 // src/runtime/app/plugins/webmcp.client.ts
-function pageModelContext() {
-	const context = document.modelContext ?? navigator.modelContext;
-	return typeof context?.registerTool === "function" ? context : void 0;
-}
 var webmcp_client_default = defineNuxtPlugin({
 	name: "wervt:webmcp",
 	setup() {
-		const context = pageModelContext();
-		if (!context) return;
-		const base = useRuntimeConfig().app.baseURL.replace(/\/$/, "");
-		async function execute(name, input) {
-			const res = await fetch(`${base}/_wervt/tools/${encodeURIComponent(name)}`, {
-				method: "POST",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify(input ?? {})
-			});
-			const body = await res.json().catch(() => void 0);
-			if (res.ok) return body?.result ?? null;
-			const issues = body?.issues ?? body?.data;
-			const message = (typeof body?.error === "string" ? body.error : body?.message) ?? `${res.status} ${res.statusText}`;
-			throw new Error(issues ? `${message} ${JSON.stringify(issues)}` : message);
-		}
-		onNuxtReady(async () => {
-			let tools;
-			try {
-				const res = await fetch(`${base}/_wervt/tools`);
-				if (!res.ok) return;
-				tools = await res.json();
-			} catch {
-				return;
-			}
-			for (const tool of tools) try {
-				const result = context.registerTool({
-					name: tool.name,
-					description: tool.description,
-					inputSchema: tool.inputSchema,
-					...tool.readOnly ? { annotations: { readOnlyHint: true } } : {},
-					execute: (input) => execute(tool.name, input)
-				});
-				if (result instanceof Promise) result.catch((e) => console.warn(`wervt: could not register tool ${tool.name}`, e));
-			} catch (e) {
-				console.warn(`wervt: could not register tool ${tool.name}`, e);
-			}
-		});
+		if (!hasWebMcp()) return;
+		const base = useRuntimeConfig().app.baseURL;
+		onNuxtReady(() => registerTools({ base }));
 	}
 });
 export { webmcp_client_default as default };

package/dist/runtime/app/snapshot.d.ts

@@ -1,15 +1,2 @@
-import { Message, Offset, Row } from "@electric-sql/client";
-export interface ShapeSnapshot<T> {
-  rows: [string, T][];
-  offset: Offset;
-  handle?: string;
-  /**
-   * The route answered 401: the shape needs a signed-in user and there is none, e.g. an anonymous
-   * visitor of a public app, or the deploy's page check. No rows, and nothing to stream.
-   */
-  unauthorized?: true;
-}
-/** The rows of the shape at `url` (absolute) as of now, without subscribing. */
-export declare function loadSnapshot<T extends Row<unknown>>(url: string, fetchClient?: typeof fetch): Promise<ShapeSnapshot<T>>;
-/** Applies Electric change messages to `rows`. Returns whether anything changed. */
-export declare function applyMessages<T extends Row<unknown>>(rows: Map<string, T>, messages: Message<T>[]): boolean;
+import { ShapeSnapshot, applyMessages, loadSnapshot } from "@wervt/client/shape";
+export { type ShapeSnapshot, applyMessages, loadSnapshot };

package/dist/runtime/app/snapshot.js

@@ -1,63 +1 @@
-import { shapeParser } from "../shared/shape.js";
-import { ShapeStream, isChangeMessage, isControlMessage } from "@electric-sql/client";
-// src/runtime/app/snapshot.ts
-/** The rows of the shape at `url` (absolute) as of now, without subscribing. */
-async function loadSnapshot(url, fetchClient) {
-	const rows = /* @__PURE__ */ new Map();
-	let fail = () => {};
-	const stream = new ShapeStream({
-		url,
-		subscribe: false,
-		fetchClient,
-		parser: shapeParser,
-		onError: (e) => fail(e)
-	});
-	try {
-		await new Promise((resolve, reject) => {
-			fail = reject;
-			stream.subscribe((messages) => {
-				applyMessages(rows, messages);
-				if (stream.isUpToDate) resolve();
-			}, (e) => reject(e));
-		});
-	} catch (e) {
-		if (e?.status === 401) return {
-			rows: [],
-			offset: "-1",
-			unauthorized: true
-		};
-		throw e;
-	} finally {
-		stream.unsubscribeAll();
-	}
-	return {
-		rows: [...rows],
-		offset: stream.lastOffset,
-		handle: stream.shapeHandle
-	};
-}
-/** Applies Electric change messages to `rows`. Returns whether anything changed. */
-function applyMessages(rows, messages) {
-	let changed = false;
-	for (const message of messages) if (isChangeMessage(message)) {
-		const { key, value } = message;
-		switch (message.headers.operation) {
-			case "insert":
-				rows.set(key, value);
-				break;
-			case "update":
-				rows.set(key, {
-					...rows.get(key),
-					...value
-				});
-				break;
-			case "delete": rows.delete(key);
-		}
-		changed = true;
-	} else if (isControlMessage(message) && message.headers.control === "must-refetch") {
-		rows.clear();
-		changed = true;
-	}
-	return changed;
-}
-export { applyMessages, loadSnapshot };
+export { applyMessages, loadSnapshot } from "@wervt/client/shape";

package/dist/runtime/app/useShape.js

@@ -1,5 +1,5 @@
-import { shapeParser } from "../shared/shape.js";
 import { applyMessages, loadSnapshot } from "./snapshot.js";
+import { shapeParser } from "../shared/shape.js";
 import { onNuxtReady, useAsyncData, useRequestEvent, useRequestFetch } from "#app";
 import { getCurrentScope, onScopeDispose, ref, shallowRef } from "vue";
 import { ShapeStream } from "@electric-sql/client";

package/dist/runtime/app/useWervtFeedback.d.ts

@@ -1,14 +1,3 @@
-interface KontorWidget {
-  open(): void;
-  close(): void;
-  setContext(values: Record<string, unknown>): void;
-}
-declare global {
-  interface Window {
-    kontor?: KontorWidget;
-  }
-}
-export declare const pendingFeedbackContext: Record<string, unknown>;
 /**
  * Controls the feedback widget (`wervt: { feedback: { key } }`): open it from your own button,
  * or add context to every report, e.g. what the user was looking at.
@@ -19,5 +8,4 @@ export declare function useWervtFeedback(): {
   open: () => void | undefined;
   close: () => void | undefined;
   setContext(values: Record<string, unknown>): void;
-};
-export {};
+};

package/dist/runtime/app/useWervtFeedback.js

@@ -1,5 +1,5 @@
+import { feedback } from "@wervt/client";
 // src/runtime/app/useWervtFeedback.ts
-const pendingFeedbackContext = {};
 /**
 * Controls the feedback widget (`wervt: { feedback: { key } }`): open it from your own button,
 * or add context to every report, e.g. what the user was looking at.
@@ -7,14 +7,6 @@ const pendingFeedbackContext = {};
 * @example useWervtFeedback().setContext({ room: room.id })
 */
 function useWervtFeedback() {
-	const widget = () => import.meta.client ? window.kontor : void 0;
-	return {
-		open: () => widget()?.open(),
-		close: () => widget()?.close(),
-		setContext(values) {
-			Object.assign(pendingFeedbackContext, values);
-			widget()?.setContext(values);
-		}
-	};
+	return feedback;
 }
-export { pendingFeedbackContext, useWervtFeedback };
+export { useWervtFeedback };

package/dist/runtime/app/useWervtTrack.js

@@ -1,4 +1,5 @@
 import { useRuntimeConfig } from "#app";
+import { track } from "@wervt/client";
 // src/runtime/app/useWervtTrack.ts
 /**
 * Custom events for wervt's analytics, e.g. `track('signup')` or `track('click', url)`. They
@@ -9,15 +10,10 @@ import { useRuntimeConfig } from "#app";
 function useWervtTrack() {
 	const config = useRuntimeConfig();
 	const enabled = config.public.wervt?.analytics;
-	const base = config.app.baseURL.replace(/\/$/, "");
+	const base = config.app.baseURL;
 	return (name, label) => {
-		if (!enabled || import.meta.server || typeof navigator === "undefined") return;
-		const body = JSON.stringify({
-			path: location.pathname,
-			name,
-			label
-		});
-		navigator.sendBeacon?.(`${base}/_wervt/view`, new Blob([body], { type: "application/json" }));
+		if (!enabled || import.meta.server) return;
+		track(name, label, { base });
 	};
 }
 export { useWervtTrack };

package/dist/runtime/app/useWervtUser.d.ts

@@ -1,4 +1,5 @@
 import { WervtUser } from "../shared/user.js";
+import { loginUrl, logoutUrl } from "@wervt/client";
 /**
  * The signed-in wervt user, or `null`. Read during SSR and kept in the payload; apps without
  * SSR load it from `/_wervt/user` before they render. Public apps get one when the visitor
@@ -6,6 +7,6 @@ import { WervtUser } from "../shared/user.js";
  */
 export declare function useWervtUser(): import("vue").Ref<WervtUser | null, WervtUser | null>;
 /** Sign in with wervt, then come back to `redirect` (a path in this app). */
-export declare const wervtLoginUrl: (redirect?: string) => string;
+export declare const wervtLoginUrl: typeof loginUrl;
 /** Sign out of wervt (all apps), then come back to `redirect`. */
-export declare const wervtLogoutUrl: (redirect?: string) => string;
+export declare const wervtLogoutUrl: typeof logoutUrl;

package/dist/runtime/app/useWervtUser.js

@@ -1,5 +1,6 @@
 import { DEV_LOGIN_COOKIE, devUser, parseWervtUser } from "../shared/user.js";
 import { useCookie, useRequestHeaders, useState } from "#app";
+import { loginUrl, logoutUrl } from "@wervt/client";
 // src/runtime/app/useWervtUser.ts
 /**
 * The signed-in wervt user, or `null`. Read during SSR and kept in the payload; apps without
@@ -11,7 +12,7 @@ function useWervtUser() {
 	return useState("wervt-user", () => import.meta.server ? parseWervtUser(useRequestHeaders(["x-wervt-user"])["x-wervt-user"]) ?? devUser(String(devLogin?.value) === "1") ?? null : null);
 }
 /** Sign in with wervt, then come back to `redirect` (a path in this app). */
-const wervtLoginUrl = (redirect = "/") => `/_wervt/login?redirect=${encodeURIComponent(redirect)}`;
+const wervtLoginUrl = loginUrl;
 /** Sign out of wervt (all apps), then come back to `redirect`. */
-const wervtLogoutUrl = (redirect = "/") => `/_wervt/logout?redirect=${encodeURIComponent(redirect)}`;
+const wervtLogoutUrl = logoutUrl;
 export { useWervtUser, wervtLoginUrl, wervtLogoutUrl };

package/dist/runtime/server/access.d.ts

@@ -1,25 +1,5 @@
+import { WervtAccess, WervtAccess as WervtAccess$1, WervtInvite } from "@wervt/core";
 import { RequestEvent } from "nuxt/server";
-export interface WervtInvite {
-  email: string;
-  /** Who invited them. */
-  by: string;
-  /** ISO time. */
-  at: string;
-}
-export interface WervtAccess {
-  /** Lets `email` into the app. `invited` is false when they could already get in. */
-  invite(email: string): Promise<{
-    email: string;
-    invited: boolean;
-  }>;
-  /** Takes back an invite (not the owner's allow list). */
-  revoke(email: string): Promise<{
-    email: string;
-    revoked: boolean;
-  }>;
-  /** Everyone the app invited, with who invited them and when. */
-  list(): Promise<WervtInvite[]>;
-}
 /**
  * Invites on an invite-only app (`wervt access <app> --invite`), as the user of this request: the
  * runtime vouches for them, and only someone with access can invite. Everyone with access may
@@ -30,4 +10,5 @@ export interface WervtAccess {
  * 409 when the app isn't invite-only, 429 past the limits (25 invites per person and day, 500 per
  * app).
  */
-export declare function useWervtAccess(event: RequestEvent): WervtAccess;
+export declare function useWervtAccess(event: RequestEvent): WervtAccess$1;
+export type { WervtAccess, WervtInvite };

package/dist/runtime/server/access.js

@@ -1,4 +1,6 @@
 import { DEV_LOGIN_COOKIE, devUser } from "../shared/user.js";
+import { withH3Errors } from "./errors.js";
+import { appAccess, runtimeUrl } from "@wervt/core";
 import { createError, getCookie } from "nuxt/server";
 // src/runtime/server/access.ts
 const devInvites = [];
@@ -13,31 +15,12 @@ const devInvites = [];
 * app).
 */
 function useWervtAccess(event) {
-	const runtime = process.env.WERVT_RUNTIME_URL;
-	if (!runtime) return devAccess(event);
-	async function call(method, body) {
-		const res = await fetch(new URL("/_wervt/access", runtime), {
-			method,
-			headers: {
-				"content-type": "application/json",
-				"x-wervt-app": process.env.WERVT_APP ?? "",
-				"x-wervt-token": process.env.WERVT_TOKEN ?? "",
-				"x-wervt-user": event.req.headers.get("x-wervt-user") ?? "",
-				"x-wervt-user-proof": event.req.headers.get("x-wervt-user-proof") ?? ""
-			},
-			body: body && JSON.stringify(body)
-		});
-		const data = await res.json().catch(() => ({}));
-		if (!res.ok) throw createError({
-			status: res.status,
-			message: data.error ?? `access ${res.status}`
-		});
-		return data;
-	}
+	if (!runtimeUrl()) return devAccess(event);
+	const access = appAccess(event.req);
 	return {
-		invite: (email) => call("POST", { email }),
-		revoke: (email) => call("DELETE", { email }),
-		list: async () => (await call("GET")).invited
+		invite: (email) => withH3Errors(access.invite(email)),
+		revoke: (email) => withH3Errors(access.revoke(email)),
+		list: () => withH3Errors(access.list())
 	};
 }
 function devAccess(event) {

package/dist/runtime/server/anthropic.d.ts

@@ -1,11 +1,6 @@
+import { AnthropicOptions } from "@wervt/core/anthropic";
 import Anthropic from "@anthropic-ai/sdk";
-export interface UseAnthropicOptions {
-  /**
-   * The key for `nuxt dev`, where there is no workload identity. Default: `ANTHROPIC_API_KEY`.
-   * Never used on wervt.
-   */
-  devApiKey?: string;
-}
+export type UseAnthropicOptions = AnthropicOptions;
 /**
  * An Anthropic client that authenticates as this app through its wervt identity: no API key, only
  * IDs from the Anthropic Console in the app's env (`ANTHROPIC_FEDERATION_RULE_ID`,

package/dist/runtime/server/anthropic.js

@@ -1,10 +1,6 @@
-import { useWorkloadIdentity } from "./identity.js";
-import { createError } from "nuxt/server";
-import Anthropic from "@anthropic-ai/sdk";
-import { oidcFederationProvider } from "@anthropic-ai/sdk/lib/credentials/oidc-federation";
+import { toH3Error } from "./errors.js";
+import { getAnthropic } from "@wervt/core/anthropic";
 // src/runtime/server/anthropic.ts
-const BASE_URL = "https://api.anthropic.com";
-let client;
 /**
 * An Anthropic client that authenticates as this app through its wervt identity: no API key, only
 * IDs from the Anthropic Console in the app's env (`ANTHROPIC_FEDERATION_RULE_ID`,
@@ -16,37 +12,10 @@ let client;
 * (`wervt identity status <app>`). In `nuxt dev` it uses `options.devApiKey` instead.
 */
 function useAnthropic(options = {}) {
-	return client ??= create(options);
-}
-function create(options) {
-	if (!process.env.WERVT_RUNTIME_URL) {
-		const apiKey = options.devApiKey ?? process.env.ANTHROPIC_API_KEY;
-		if (!apiKey) throw createError({
-			status: 503,
-			message: "useAnthropic() in `nuxt dev` needs an API key (ANTHROPIC_API_KEY or devApiKey)."
-		});
-		return new Anthropic({ apiKey });
+	try {
+		return getAnthropic(options);
+	} catch (e) {
+		throw toH3Error(e);
 	}
-	const federationRuleId = process.env.ANTHROPIC_FEDERATION_RULE_ID;
-	const organizationId = process.env.ANTHROPIC_ORGANIZATION_ID;
-	if (!federationRuleId || !organizationId) throw createError({
-		status: 503,
-		message: "useAnthropic() needs ANTHROPIC_FEDERATION_RULE_ID and ANTHROPIC_ORGANIZATION_ID (wervt env <app> --set …)."
-	});
-	const identity = useWorkloadIdentity();
-	return new Anthropic({
-		apiKey: null,
-		authToken: null,
-		baseURL: BASE_URL,
-		credentials: oidcFederationProvider({
-			identityTokenProvider: () => identity.token(BASE_URL),
-			federationRuleId,
-			organizationId,
-			serviceAccountId: process.env.ANTHROPIC_SERVICE_ACCOUNT_ID || void 0,
-			workspaceId: process.env.ANTHROPIC_WORKSPACE_ID || void 0,
-			baseURL: BASE_URL,
-			fetch: (...args) => fetch(...args)
-		})
-	});
 }
 export { useAnthropic };

package/dist/runtime/server/db.d.ts

@@ -1,17 +1,2 @@
-import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import { AnyRelations, EmptyRelations } from "drizzle-orm";
-/**
- * Drizzle client for the app's database. In production the wervt runtime injects
- * DATABASE_URL for the app's own role, whose search_path is its own schema, so
- * tables are declared without a schema.
- *
- * Pass the app's relations (from `defineRelations`) to use `db.query.*`. All clients
- * share one connection pool.
- *
- * @example
- * const db = useDb({ relations })
- * const room = await db.query.rooms.findFirst({ where: { id }, with: { players: true } })
- */
-export declare function useDb<TRelations extends AnyRelations = EmptyRelations>(options?: {
-  relations?: TRelations;
-}): PostgresJsDatabase<TRelations>;
+import { useDb } from "@wervt/core/db";
+export { useDb };

package/dist/runtime/server/db.js

@@ -1,35 +1 @@
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
-// src/runtime/server/db.ts
-let client;
-const clients = /* @__PURE__ */ new Map();
-/**
-* Drizzle client for the app's database. In production the wervt runtime injects
-* DATABASE_URL for the app's own role, whose search_path is its own schema, so
-* tables are declared without a schema.
-*
-* Pass the app's relations (from `defineRelations`) to use `db.query.*`. All clients
-* share one connection pool.
-*
-* @example
-* const db = useDb({ relations })
-* const room = await db.query.rooms.findFirst({ where: { id }, with: { players: true } })
-*/
-function useDb(options) {
-	if (!process.env.DATABASE_URL) throw new Error("DATABASE_URL is not set");
-	client ??= postgres(process.env.DATABASE_URL, {
-		max: 2,
-		idle_timeout: 20
-	});
-	const relations = options?.relations;
-	let db = clients.get(relations);
-	if (!db) {
-		db = drizzle({
-			client,
-			relations
-		});
-		clients.set(relations, db);
-	}
-	return db;
-}
-export { useDb };
+export { useDb } from "@wervt/core/db";

package/dist/runtime/server/errors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns @wervt/core's errors into h3's, which Nitro answers with their status. Any other error
+ * would become a 500 without its message.
+ */
+export declare function toH3Error(error: unknown): unknown;
+export declare function withH3Errors<T>(promise: Promise<T>): Promise<T>;

package/dist/runtime/server/errors.js

@@ -0,0 +1,21 @@
+import { WervtError } from "@wervt/core";
+import { createError } from "nuxt/server";
+// src/runtime/server/errors.ts
+/**
+* Turns @wervt/core's errors into h3's, which Nitro answers with their status. Any other error
+* would become a 500 without its message.
+*/
+function toH3Error(error) {
+	return error instanceof WervtError ? createError({
+		status: error.status,
+		message: error.message
+	}) : error;
+}
+async function withH3Errors(promise) {
+	try {
+		return await promise;
+	} catch (e) {
+		throw toH3Error(e);
+	}
+}
+export { toH3Error, withH3Errors };

package/dist/runtime/server/identity.d.ts

@@ -1,11 +1,4 @@
-export interface WorkloadIdentity {
-  /**
-   * A fresh JWT that says "I am this wervt app", for `audience` (a provider on wervt's list, e.g.
-   * `https://api.anthropic.com`). Valid for 5 minutes and single-use: trade it for a provider
-   * token right away. Each call signs a new one; providers' SDKs cache what they get for it.
-   */
-  token(audience: string): Promise<string>;
-}
+import { WorkloadIdentity, WorkloadIdentity as WorkloadIdentity$1 } from "@wervt/core";
 /**
  * The app's workload identity: tokens signed by wervt's issuer, so the app can authenticate to an
  * AI provider (Anthropic's Workload Identity Federation) without an API key. Its owner turns it
@@ -15,4 +8,5 @@ export interface WorkloadIdentity {
  * doesn't sign for, 429 past 10 tokens a minute, 503 when the issuer is off. In `nuxt dev` there
  * is no issuer, so it always throws.
  */
-export declare function useWorkloadIdentity(): WorkloadIdentity;
+export declare function useWorkloadIdentity(): WorkloadIdentity$1;
+export type { WorkloadIdentity };

package/dist/runtime/server/identity.js

@@ -1,4 +1,5 @@
-import { createError } from "nuxt/server";
+import { withH3Errors } from "./errors.js";
+import { workloadIdentity } from "@wervt/core";
 // src/runtime/server/identity.ts
 /**
 * The app's workload identity: tokens signed by wervt's issuer, so the app can authenticate to an
@@ -10,27 +11,7 @@ import { createError } from "nuxt/server";
 * is no issuer, so it always throws.
 */
 function useWorkloadIdentity() {
-	return { async token(audience) {
-		const runtime = process.env.WERVT_RUNTIME_URL;
-		if (!runtime) throw createError({
-			status: 503,
-			message: "Workload identity only exists on wervt, not in `nuxt dev`."
-		});
-		const res = await fetch(new URL("/_wervt/identity-token", runtime), {
-			method: "POST",
-			headers: {
-				"content-type": "application/json",
-				"x-wervt-app": process.env.WERVT_APP ?? "",
-				"x-wervt-token": process.env.WERVT_TOKEN ?? ""
-			},
-			body: JSON.stringify({ audience })
-		});
-		const body = await res.json().catch(() => ({}));
-		if (!res.ok || !body.token) throw createError({
-			status: res.status,
-			message: body.error ?? `identity token failed (${res.status})`
-		});
-		return body.token;
-	} };
+	const identity = workloadIdentity();
+	return { token: (audience) => withH3Errors(identity.token(audience)) };
 }
 export { useWorkloadIdentity };

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

@@ -8,8 +8,8 @@ import { createEvlogError, log, useLogger } from "./logger.js";
 import { SendMailOptions, sendMail } from "./mail.js";
 import { McpTokenContext } from "./mcp-auth.js";
 import { seedTable } from "./seed.js";
-import { ShapeResponse } from "../shared/shape.js";
 import { ShapeOptions, ShapeRow, proxyShape } from "./shape.js";
+import { ShapeResponse } from "../shared/shape.js";
 import { AccountMergedPayload, Task, TaskEvent, TaskResult, defineTask } from "./tasks.js";
 import { SafeResult, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
 import { Tool, ToolRoute, defineTool, defineToolRoute } from "./tools.js";

package/dist/runtime/server/index.js

@@ -1,8 +1,8 @@
 import { wervtInstance } from "../shared/instance.js";
 import { renderEmail } from "../email/render.js";
 import { useWervtAccess } from "./access.js";
-import { useWorkloadIdentity } from "./identity.js";
 import { useDb } from "./db.js";
+import { useWorkloadIdentity } from "./identity.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
 import { sendMail } from "./mail.js";
 import { seedTable } from "./seed.js";

package/dist/runtime/server/mail.js

@@ -1,5 +1,6 @@
 import { renderEmail } from "../email/render.js";
-import { createError } from "nuxt/server";
+import { withH3Errors } from "./errors.js";
+import { sendMail as sendMail$1 } from "@wervt/core";
 // src/runtime/server/mail.ts
 /**
 * Renders a template and sends it through wervt. Throws on failure, with the status the platform
@@ -11,33 +12,14 @@ import { createError } from "nuxt/server";
 async function sendMail(options) {
 	const { subject, html, text } = await renderEmail(options.template, options.props);
 	const template = options.template.__name;
-	const runtime = process.env.WERVT_RUNTIME_URL;
-	if (!runtime) {
-		console.info(`[mail] to ${options.to}: ${subject}\n${text}`);
-		return { id: "dev" };
-	}
-	const res = await fetch(new URL("/_wervt/mail", runtime), {
-		method: "POST",
-		headers: {
-			"content-type": "application/json",
-			"x-wervt-app": process.env.WERVT_APP ?? "",
-			"x-wervt-token": process.env.WERVT_TOKEN ?? ""
-		},
-		body: JSON.stringify({
-			to: options.to,
-			subject,
-			html,
-			text,
-			replyTo: options.replyTo,
-			fromName: options.fromName,
-			template
-		})
-	});
-	const body = await res.json().catch(() => ({}));
-	if (!res.ok) throw createError({
-		status: res.status,
-		message: body.error ?? `sending mail failed (${res.status})`
-	});
-	return { id: body.id ?? "" };
+	return withH3Errors(sendMail$1({
+		to: options.to,
+		subject,
+		html,
+		text,
+		replyTo: options.replyTo,
+		fromName: options.fromName,
+		template
+	}));
 }
 export { sendMail };

package/dist/runtime/server/mcp-claims.d.ts

@@ -1,3 +1,2 @@
-import { WervtUser } from "../shared/user.js";
-/** The wervt user an access token's claims name, or undefined when they're incomplete. */
-export declare function userFromClaims(claims: Record<string, unknown>): WervtUser | undefined;
+import { userFromClaims } from "@wervt/core";
+export { userFromClaims };

package/dist/runtime/server/mcp-claims.js

@@ -1,17 +1 @@
-// src/runtime/server/mcp-claims.ts
-/** The wervt user an access token's claims name, or undefined when they're incomplete. */
-function userFromClaims(claims) {
-	const { sub, email, name, picture, accounts } = claims;
-	if (typeof sub !== "string" || !sub || typeof email !== "string") return void 0;
-	return {
-		id: sub,
-		email: email.toLowerCase(),
-		name: typeof name === "string" ? name : void 0,
-		image: typeof picture === "string" ? picture : void 0,
-		accounts: isAccounts(accounts) ? accounts : void 0
-	};
-}
-function isAccounts(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((id) => typeof id === "string");
-}
-export { userFromClaims };
+export { userFromClaims } from "@wervt/core";