@wervt/nuxt 0.3.9 → 0.3.11

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";

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

@@ -1,16 +1,2 @@
-import { InferInsertModel } from "drizzle-orm";
-import { PgTable } from "drizzle-orm/pg-core";
-/**
- * Inserts `rows` into `table` only while it is empty, so a seed task can run again without
- * duplicating data or touching what users created. Returns how many rows it inserted.
- *
- * @example
- * // server/tasks/db/seed.ts
- * export default defineTask({
- *   meta: { description: 'Fill an empty database with example data' },
- *   async run() {
- *     return { result: { todos: await seedTable(todos, [{ title: 'Try wervt' }]) } }
- *   },
- * })
- */
-export declare function seedTable<T extends PgTable>(table: T, rows: InferInsertModel<T>[]): Promise<number>;
+import { seedTable } from "@wervt/core/db";
+export { seedTable };

package/dist/runtime/server/seed.js

@@ -1,26 +1 @@
-import { useDb } from "./db.js";
-import { sql } from "drizzle-orm";
-// src/runtime/server/seed.ts
-/**
-* Inserts `rows` into `table` only while it is empty, so a seed task can run again without
-* duplicating data or touching what users created. Returns how many rows it inserted.
-*
-* @example
-* // server/tasks/db/seed.ts
-* export default defineTask({
-*   meta: { description: 'Fill an empty database with example data' },
-*   async run() {
-*     return { result: { todos: await seedTable(todos, [{ title: 'Try wervt' }]) } }
-*   },
-* })
-*/
-async function seedTable(table, rows) {
-	if (rows.length === 0) return 0;
-	const db = useDb();
-	const target = table;
-	const [existing] = await db.select({ one: sql`1` }).from(target).limit(1);
-	if (existing) return 0;
-	await db.insert(target).values(rows);
-	return rows.length;
-}
-export { seedTable };
+export { seedTable } from "@wervt/core/db";

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

@@ -1,4 +1,4 @@
-import { ShapeResponse } from "../shared/shape.js";
+import { ShapeResponse } from "@wervt/core";
 import { RequestEvent } from "nuxt/server";
 import { InferSelectModel, Table } from "drizzle-orm";
 export interface ShapeOptions<T extends Table | string = Table | string> {
@@ -21,4 +21,4 @@ export type ShapeRow<T extends Table | string> = T extends Table ? InferSelectMo
  * In production the request goes through the wervt runtime gateway, which pins the
  * table to this app's schema. In dev it goes to Electric directly (ELECTRIC_URL).
  */
-export declare function proxyShape<T extends Table | string>(event: RequestEvent, { table: tableOrName, where, params, columns }: ShapeOptions<T>): Promise<ShapeResponse<ShapeRow<T>>>;
+export declare function proxyShape<T extends Table | string>(event: RequestEvent, { table, ...options }: ShapeOptions<T>): Promise<ShapeResponse<ShapeRow<T>>>;

package/dist/runtime/server/shape.js

@@ -1,56 +1,16 @@
+import { proxyShape as proxyShape$1 } from "@wervt/core";
 import { getTableName, isTable } from "drizzle-orm";
 // src/runtime/server/shape.ts
-const CLIENT_PARAMS = [
-	"offset",
-	"handle",
-	"live",
-	"live_sse",
-	"cursor",
-	"replica",
-	"log"
-];
 /**
 * Serves an Electric shape from a route. Do auth checks before calling it.
 *
 * In production the request goes through the wervt runtime gateway, which pins the
 * table to this app's schema. In dev it goes to Electric directly (ELECTRIC_URL).
 */
-async function proxyShape(event, { table: tableOrName, where, params, columns }) {
-	const table = isTable(tableOrName) ? getTableName(tableOrName) : tableOrName;
-	const runtime = process.env.WERVT_RUNTIME_URL;
-	const url = runtime ? new URL("/_wervt/electric/v1/shape", runtime) : new URL("/v1/shape", process.env.ELECTRIC_URL ?? "http://localhost:3000");
-	const query = new URL(event.req.url).searchParams;
-	for (const key of CLIENT_PARAMS) {
-		const value = query.get(key);
-		if (value !== null) url.searchParams.set(key, value);
-	}
-	url.searchParams.set("table", runtime ? table : devTable(table));
-	if (where) url.searchParams.set("where", where);
-	params?.forEach((value, i) => url.searchParams.set(`params[${i + 1}]`, String(value)));
-	if (columns) url.searchParams.set("columns", columns.map(quoteIdentifier).join(","));
-	if (!runtime && process.env.ELECTRIC_SECRET) url.searchParams.set("secret", process.env.ELECTRIC_SECRET);
-	const headers = {};
-	if (runtime) {
-		headers["x-wervt-app"] = process.env.WERVT_APP ?? "";
-		headers["x-wervt-token"] = process.env.WERVT_TOKEN ?? "";
-	}
-	const res = await fetch(url, {
-		headers,
-		signal: event.req.signal
+function proxyShape(event, { table, ...options }) {
+	return proxyShape$1(event.req, {
+		...options,
+		table: isTable(table) ? getTableName(table) : table
 	});
-	const out = new Headers(res.headers);
-	out.delete("content-encoding");
-	out.delete("content-length");
-	return new Response(res.body, {
-		status: res.status,
-		headers: out
-	});
-}
-function devTable(table) {
-	const schema = process.env.WERVT_DB_SCHEMA;
-	return schema ? `${schema}.${table}` : table;
-}
-function quoteIdentifier(name) {
-	return /^[a-z_][a-z0-9_]*$/.test(name) ? name : `"${name.replaceAll("\"", "\"\"")}"`;
 }
 export { proxyShape };

package/dist/runtime/server/task-handlers.d.ts

@@ -10,12 +10,8 @@ type Registry = Record<string, {
   resolve?: () => Promise<unknown>;
 }>;
 /** `POST /_wervt/tasks/:name`: runs a task when the control plane asks. */
-export declare function taskRunHandler(runTask: RunTask): import("nuxt/server").EventHandler<Promise<{
-  result?: undefined;
+export declare function taskRunHandler(runTask: RunTask): import("nuxt/server").EventHandler<Promise<Response | {
   error: string;
-} | {
-  error?: undefined;
-  result: {} | null;
 }>>;
 /** `GET /_wervt/tasks`: the tasks with the descriptions from `defineTask({ meta })`. */
 export declare function taskListHandler(tasks: Registry): import("nuxt/server").EventHandler<Promise<{

package/dist/runtime/server/task-handlers.js

@@ -1,7 +1,8 @@
+import { isTaskRequest, taskRunResponse } from "@wervt/core";
 import { defineEventHandler } from "nuxt/server";
 // src/runtime/server/task-handlers.ts
 function trusted(event) {
-	if (event.req.headers.get("x-wervt-task") === "1") return true;
+	if (isTaskRequest(event.req)) return true;
 	event.res.status = 404;
 	return false;
 }
@@ -11,14 +12,7 @@ function taskRunHandler(runTask) {
 		if (!trusted(event)) return { error: "not found" };
 		const name = decodeURIComponent(new URL(event.req.url).pathname.split("/").pop() ?? "");
 		const body = await event.req.json().catch(() => ({}));
-		event.res.headers.set("cache-control", "no-store");
-		try {
-			return { result: (await runTask(name, { payload: body.payload ?? {} })).result ?? null };
-		} catch (e) {
-			console.error(`Task ${name} failed:`, e);
-			event.res.status = e.status ?? 500;
-			return { error: e instanceof Error ? e.message : String(e) };
-		}
+		return taskRunResponse(name, () => runTask(name, { payload: body.payload ?? {} }));
 	});
 }
 /** `GET /_wervt/tasks`: the tasks with the descriptions from `defineTask({ meta })`. */

package/dist/runtime/server/task-run-nitro2.d.ts

@@ -1,8 +1,4 @@
-declare const _default: import("nuxt/server").EventHandler<Promise<{
+declare const _default: import("nuxt/server").EventHandler<Promise<Response | {
   error: string;
-  result?: undefined;
-} | {
-  error?: undefined;
-  result: {} | null;
 }>>;
 export { _default as default };

package/dist/runtime/server/task-run-nitro3.d.ts

@@ -1,8 +1,4 @@
-declare const _default: import("nuxt/server").EventHandler<Promise<{
+declare const _default: import("nuxt/server").EventHandler<Promise<Response | {
   error: string;
-  result?: undefined;
-} | {
-  error?: undefined;
-  result: {} | null;
 }>>;
 export { _default as default };

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

@@ -1,32 +1,2 @@
-export interface TaskEvent<P = Record<string, unknown>> {
-  name: string;
-  /** `{ scheduledTime }` for scheduled runs, or what was passed to a manual run. */
-  payload: P;
-  context: Record<string, unknown>;
-}
-/**
- * Payload of the `wervt:account-merged` task: one person had two wervt accounts and an admin
- * merged `from` into `into`. `from` no longer exists; move its rows over to `into`.
- */
-export interface AccountMergedPayload {
-  from: {
-    id: string;
-    email: string;
-  };
-  into: {
-    id: string;
-    email: string;
-  };
-}
-export interface TaskResult<R = unknown> {
-  result?: R;
-}
-export interface Task<R = unknown, P = Record<string, unknown>> {
-  meta?: {
-    name?: string;
-    description?: string;
-  };
-  run(event: TaskEvent<P>): TaskResult<R> | Promise<TaskResult<R>>;
-}
-/** A task in `server/tasks/` (`server/tasks/presence/sweep.ts` is `presence:sweep`). */
-export declare function defineTask<R = unknown, P = Record<string, unknown>>(task: Task<R, P>): Task<R, P>;
+import { AccountMergedPayload, Task, TaskEvent, TaskResult, defineTask } from "@wervt/core";
+export { type AccountMergedPayload, type Task, type TaskEvent, type TaskResult, defineTask };

package/dist/runtime/server/tasks.js

@@ -1,9 +1 @@
-// src/runtime/server/tasks.ts
-/** A task in `server/tasks/` (`server/tasks/presence/sweep.ts` is `presence:sweep`). */
-function defineTask(task) {
-	if (typeof task.run !== "function") task.run = () => {
-		throw new TypeError("Task must implement a `run` method!");
-	};
-	return task;
-}
-export { defineTask };
+export { defineTask } from "@wervt/core";

package/dist/runtime/server/user-route.d.ts

@@ -1,6 +1,4 @@
-import { WervtUser } from "../shared/user.js";
-import "./user.js";
 declare const _default: import("nuxt/server").EventHandler<{
-  user: WervtUser | null;
+  user: import("@wervt/core").WervtUser | null;
 }>;
 export { _default as default };

package/dist/runtime/server/user.js

@@ -1,5 +1,7 @@
 import { DEV_LOGIN_COOKIE, devUser, parseWervtUser } from "../shared/user.js";
-import { createError, getCookie } from "nuxt/server";
+import { toH3Error } from "./errors.js";
+import { checkRole } from "@wervt/core";
+import { getCookie } from "nuxt/server";
 // src/runtime/server/user.ts
 const MCP_USER = "wervtMcpUser";
 /**
@@ -23,15 +25,10 @@ function useWervtUser(event) {
 * Throws 401 without a signed-in user, 403 with another role.
 */
 function requireWervtRole(event, ...roles) {
-	const user = useWervtUser(event);
-	if (!user) throw createError({
-		status: 401,
-		message: "sign in at /_wervt/login first"
-	});
-	if (!user.role || !roles.includes(user.role)) throw createError({
-		status: 403,
-		message: `needs role ${roles.join(", ")}`
-	});
-	return user;
+	try {
+		return checkRole(useWervtUser(event), roles);
+	} catch (e) {
+		throw toH3Error(e);
+	}
 }
 export { DEV_LOGIN_COOKIE, parseWervtUser, requireWervtRole, useWervtUser };

package/dist/runtime/shared/agent-token.d.ts

@@ -1,7 +1,2 @@
-/** Who minted the agent token a request came with, and its id (the control plane's log). */
-export interface AgentToken {
-  id: string;
-  by: string;
-}
-/** Parses the `x-wervt-agent-token` header the runtime sets (and strips from client requests). */
-export declare function parseAgentToken(header: string | null | undefined): AgentToken | undefined;
+import { AgentToken, parseAgentToken } from "@wervt/core";
+export { type AgentToken, parseAgentToken };

package/dist/runtime/shared/agent-token.js

@@ -1,16 +1 @@
-// src/runtime/shared/agent-token.ts
-/** Parses the `x-wervt-agent-token` header the runtime sets (and strips from client requests). */
-function parseAgentToken(header) {
-	if (!header) return void 0;
-	try {
-		const value = JSON.parse(decodeURIComponent(header));
-		if (typeof value?.id !== "string" || typeof value.by !== "string") return void 0;
-		return {
-			id: value.id,
-			by: value.by
-		};
-	} catch {
-		return;
-	}
-}
-export { parseAgentToken };
+export { parseAgentToken } from "@wervt/core";

package/dist/runtime/shared/i18n.d.ts

@@ -0,0 +1,28 @@
+export declare const LOCALES: readonly ['en', 'de'];
+export type Locale = (typeof LOCALES)[number];
+export declare const DEFAULT_LOCALE: Locale;
+export declare const isLocale: (value: unknown) => value is Locale;
+/**
+ * The best supported language for an `Accept-Language` header: the highest-ranked one there is a
+ * catalog for, English when there's none.
+ */
+export declare function negotiateLocale(header: string | null | undefined): Locale;
+/** One locale's texts, with the keys of the English catalog. */
+export type Catalog<M> = { readonly [K in keyof M]: string; };
+/** Every locale's catalog; English is the source of keys and placeholders. */
+export type Messages<M> = {
+  en: M;
+} & { [L in Exclude<Locale, 'en'>]: Catalog<M>; };
+/** Checks the catalogs against English at compile time; returns them unchanged. */
+export declare const defineMessages: <const M extends Record<string, string>>(messages: Messages<M>) => Messages<M>;
+type Placeholders<S> = S extends `${string}{${infer K}}${infer Rest}` ? K | Placeholders<Rest> : never;
+type Params<S> = [Placeholders<S>] extends [never] ? [] : [params: Record<Placeholders<S>, string | number>];
+export type Translate<M> = <K extends keyof M & string>(key: K, ...params: Params<M[K]>) => string;
+/** `t(key, params)` for one locale. */
+export declare function translator<M extends Record<string, string>>(messages: Messages<M>, locale: Locale): Translate<M>;
+/**
+ * What's wrong with the catalogs, for tests: keys English has and another locale lacks (or the
+ * other way round), empty texts and placeholders that differ from English.
+ */
+export declare function catalogProblems(messages: Messages<Record<string, string>>): string[];
+export {};

package/dist/runtime/shared/i18n.js

@@ -0,0 +1,54 @@
+// src/runtime/shared/i18n.ts
+const LOCALES = ["en", "de"];
+const DEFAULT_LOCALE = "en";
+const isLocale = (value) => typeof value === "string" && LOCALES.includes(value);
+/**
+* The best supported language for an `Accept-Language` header: the highest-ranked one there is a
+* catalog for, English when there's none.
+*/
+function negotiateLocale(header) {
+	if (!header) return "en";
+	return header.split(",").map((part, index) => {
+		const [tag = "", ...params] = part.trim().split(";");
+		const q = params.map((p) => p.trim()).find((p) => p.startsWith("q="));
+		return {
+			lang: tag.trim().toLowerCase().split("-")[0],
+			q: q ? Number(q.slice(2)) : 1,
+			index
+		};
+	}).filter((entry) => entry.q > 0).sort((a, b) => b.q - a.q || a.index - b.index).map((entry) => entry.lang).find(isLocale) ?? "en";
+}
+/** Checks the catalogs against English at compile time; returns them unchanged. */
+const defineMessages = (messages) => messages;
+const fill = (text, params) => params ? text.replace(/\{(\w+)\}/g, (all, key) => String(params[key] ?? all)) : text;
+/** `t(key, params)` for one locale. */
+function translator(messages, locale) {
+	const catalog = messages[locale];
+	return (key, ...params) => fill(catalog[key] ?? messages.en[key], params[0]);
+}
+const placeholders = (text) => [...text.matchAll(/\{(\w+)\}/g)].map((m) => m[1]).sort();
+/**
+* What's wrong with the catalogs, for tests: keys English has and another locale lacks (or the
+* other way round), empty texts and placeholders that differ from English.
+*/
+function catalogProblems(messages) {
+	const problems = [];
+	const source = messages.en;
+	for (const locale of LOCALES) {
+		const catalog = messages[locale];
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(source), ...Object.keys(catalog)])) {
+			const text = catalog[key];
+			if (!(key in source)) problems.push(`${locale}.${key}: not in en`);
+			else if (text === void 0) problems.push(`${locale}.${key}: missing`);
+			else if (!text.trim()) problems.push(`${locale}.${key}: empty`);
+			else {
+				const own = placeholders(text).join(",");
+				const expected = placeholders(source[key]).join(",");
+				if (own !== expected) problems.push(`${locale}.${key}: placeholders ${fmt(own)} differ from en ${fmt(expected)}`);
+			}
+		}
+	}
+	return problems;
+}
+const fmt = (list) => list.split(",").filter(Boolean).map((p) => `{${p}}`).join(" ");
+export { DEFAULT_LOCALE, LOCALES, catalogProblems, defineMessages, isLocale, negotiateLocale, translator };

package/dist/runtime/shared/messages.d.ts

@@ -0,0 +1,15 @@
+import { Messages } from "./i18n.js";
+export declare const mailMessages: Messages<{
+  readonly sentBy: "Sent by {app}";
+  readonly sentByVia: "Sent by {app} via wervt";
+  readonly securedBy: "Secured by wervt";
+  readonly docs: "Docs";
+  readonly inviteSubject: "{by} invited you to {app}";
+  readonly invitePreview: "Join {app}";
+  readonly inviteReason: "You received this email because {by} invited this address.";
+  readonly inviteEyebrow: "Invitation";
+  readonly inviteHeading: "You're invited to {app}";
+  readonly inviteText: "{by} invited you to {app}.";
+  readonly inviteAction: "Open {app}";
+  readonly inviteNote: "Sign in with this email address to get in.";
+}>;

package/dist/runtime/shared/messages.js

@@ -0,0 +1,33 @@
+import { defineMessages } from "./i18n.js";
+// src/runtime/shared/messages.ts
+const mailMessages = defineMessages({
+	en: {
+		sentBy: "Sent by {app}",
+		sentByVia: "Sent by {app} via wervt",
+		securedBy: "Secured by wervt",
+		docs: "Docs",
+		inviteSubject: "{by} invited you to {app}",
+		invitePreview: "Join {app}",
+		inviteReason: "You received this email because {by} invited this address.",
+		inviteEyebrow: "Invitation",
+		inviteHeading: "You're invited to {app}",
+		inviteText: "{by} invited you to {app}.",
+		inviteAction: "Open {app}",
+		inviteNote: "Sign in with this email address to get in."
+	},
+	de: {
+		sentBy: "Gesendet von {app}",
+		sentByVia: "Gesendet von {app} über wervt",
+		securedBy: "Gesichert durch wervt",
+		docs: "Doku",
+		inviteSubject: "{by} hat dich zu {app} eingeladen",
+		invitePreview: "Mach mit bei {app}",
+		inviteReason: "Du bekommst diese E-Mail, weil {by} diese Adresse eingeladen hat.",
+		inviteEyebrow: "Einladung",
+		inviteHeading: "Du bist zu {app} eingeladen",
+		inviteText: "{by} hat dich zu {app} eingeladen.",
+		inviteAction: "{app} öffnen",
+		inviteNote: "Melde dich mit dieser E-Mail-Adresse an, um reinzukommen."
+	}
+});
+export { mailMessages };

package/dist/runtime/shared/shape.d.ts

@@ -1,17 +1,2 @@
-declare const shapeRow: unique symbol;
-export type ShapeResponse<Row> = Response & {
-  readonly [shapeRow]?: Row;
-};
-/** The row type of a shape route's handler, `never` if it doesn't serve a typed shape. */
-export type ShapeRowOf<Handler> = Handler extends ((...args: never[]) => infer Result) ? Awaited<Result> extends ShapeResponse<infer Row> ? Row : never : never;
-/**
- * Postgres text of a `timestamp`/`timestamptz` as a Date, like Drizzle's default `mode: 'date'`
- * reads it. Drizzle stores `timestamp` without time zone as UTC, so it's read as UTC too.
- */
-export declare function parseTimestamp(value: string): Date;
-/** Electric parsers for the types Drizzle reads differently from Electric's defaults. */
-export declare const shapeParser: {
-  timestamp: typeof parseTimestamp;
-  timestamptz: typeof parseTimestamp;
-};
-export {};
+import { ShapeResponse, ShapeRowOf, parseTimestamp, shapeParser } from "@wervt/core";
+export { type ShapeResponse, type ShapeRowOf, parseTimestamp, shapeParser };