@octabits-io/nuxt-ui-kit 0.2.0

package/dist/index.js

@@ -0,0 +1,526 @@
+import { UserManager, WebStorageStateStore } from "oidc-client-ts";
+import { computed, ref, watch } from "vue";
+import { treaty } from "@elysiajs/eden";
+//#region src/auth/oidc.ts
+/**
+* Lazily-created `UserManager` singleton bound to `window.localStorage`.
+* Call the returned getter from plugins/stores/composables — the manager is
+* constructed on first call (client-side only; requires `window`).
+*/
+function createUserManagerFactory(options) {
+	let userManager = null;
+	return function getUserManager() {
+		if (userManager) return userManager;
+		const { issuerUrl, clientId } = options.getConfig();
+		if (!issuerUrl || !clientId) (options.onMissingConfig ?? console.error)("Missing OIDC issuer URL or client id in runtime config");
+		userManager = new UserManager({
+			authority: issuerUrl,
+			client_id: clientId,
+			redirect_uri: `${window.location.origin}${options.redirectPath ?? "/auth/callback"}`,
+			post_logout_redirect_uri: `${window.location.origin}${options.postLogoutRedirectPath ?? "/login"}`,
+			response_type: "code",
+			scope: options.scope,
+			automaticSilentRenew: options.automaticSilentRenew ?? true,
+			...options.refreshTokenAllowedScope ? { refreshTokenAllowedScope: options.refreshTokenAllowedScope } : {},
+			userStore: new WebStorageStateStore({ store: window.localStorage }),
+			...options.settings
+		});
+		return userManager;
+	};
+}
+/**
+* Remove any `oidc.user:` storage keys that don't belong to the current
+* authority+clientId — leftovers from environment switches would otherwise
+* shadow or bloat the session storage.
+*/
+function removeStaleOidcKeys(authority, clientId, storage = globalThis.localStorage) {
+	const currentKey = `oidc.user:${authority}:${clientId}`;
+	for (let i = storage.length - 1; i >= 0; i--) {
+		const key = storage.key(i);
+		if (key && key.startsWith("oidc.user:") && key !== currentKey) storage.removeItem(key);
+	}
+}
+/** Refresh tokens fail unrecoverably with these OIDC error codes — user must re-auth. */
+function isUnrecoverableRenewError(message) {
+	return message.includes("login_required") || message.includes("invalid_grant") || message.includes("interaction_required") || message.includes("consent_required");
+}
+/**
+* Build a `redirectToLogin()` that starts an OIDC signin redirect carrying the
+* current path as returnUrl state, with a plain `/login?redirect=` navigation
+* fallback when the IdP redirect cannot even be started. No-ops on auth routes.
+*/
+function createLoginRedirector(options) {
+	const loginPath = options.loginPath ?? "/login";
+	const isAuthRoute = options.isAuthRoute ?? ((path) => path === loginPath || path.startsWith("/auth/"));
+	return async function redirectToLogin() {
+		const path = window.location.pathname;
+		if (isAuthRoute(path)) return;
+		const returnUrl = path + window.location.search;
+		try {
+			await options.getUserManager().signinRedirect({ state: returnUrl });
+		} catch (err) {
+			(options.log ?? console.error)("[oidc] signinRedirect failed, falling back to login navigation", err);
+			window.location.href = `${loginPath}?redirect=${encodeURIComponent(returnUrl)}`;
+		}
+	};
+}
+/**
+* Wire oidc-client-ts session events to app callbacks:
+*
+* - silent-renew error → `notify` (`renew-failed`, or `session-expired` when the
+*   error is unrecoverable — see {@link isUnrecoverableRenewError}); an
+*   unrecoverable error also triggers the login redirect
+* - access token expired without renewal → `notify(session-expired)` +
+*   `onSessionLost` + login redirect
+* - back-channel signout at the IdP → `onSessionLost` + login redirect (no notice
+*   — the user initiated it elsewhere)
+*
+* Returns a detach function.
+*/
+function attachSessionLifecycleHandlers(userManager, handlers) {
+	const log = handlers.log ?? console.warn;
+	const onSilentRenewError = (error) => {
+		log("[oidc] silent token renew failed:", error);
+		const unrecoverable = isUnrecoverableRenewError(error.message);
+		handlers.notify?.(unrecoverable ? {
+			kind: "session-expired",
+			error
+		} : {
+			kind: "renew-failed",
+			error
+		});
+		if (unrecoverable) handlers.redirectToLogin();
+	};
+	const onAccessTokenExpired = () => {
+		log("[oidc] access token expired without silent renewal");
+		handlers.notify?.({ kind: "session-expired" });
+		handlers.onSessionLost?.();
+		handlers.redirectToLogin();
+	};
+	const onUserSignedOut = () => {
+		log("[oidc] user signed out at IdP (back-channel)");
+		handlers.onSessionLost?.();
+		handlers.redirectToLogin();
+	};
+	userManager.events.addSilentRenewError(onSilentRenewError);
+	userManager.events.addAccessTokenExpired(onAccessTokenExpired);
+	userManager.events.addUserSignedOut(onUserSignedOut);
+	return () => {
+		userManager.events.removeSilentRenewError(onSilentRenewError);
+		userManager.events.removeAccessTokenExpired(onAccessTokenExpired);
+		userManager.events.removeUserSignedOut(onUserSignedOut);
+	};
+}
+//#endregion
+//#region src/auth/zitadel.ts
+/**
+* Zitadel scope presets for {@link createUserManagerFactory}.
+*
+* The URN scopes request the resource-owner (organization) claim and the
+* project role grants; `offline_access` requests a refresh token.
+*/
+const ZITADEL_ORG_PROJECT_SCOPE = "openid profile email urn:zitadel:iam:user:resourceowner urn:zitadel:iam:org:project:roles offline_access";
+/**
+* Zitadel only accepts standard OIDC scopes on the refresh-token grant —
+* sending `offline_access` or the `urn:zitadel:*` scopes returns
+* `invalid_scope` even though they were granted at the initial auth. The
+* URN-based claims still need to land in the refreshed access token; that
+* depends on "Assert Roles on Authentication" being enabled at the Zitadel
+* project level.
+*/
+const ZITADEL_REFRESH_TOKEN_ALLOWED_SCOPE = "openid profile email";
+//#endregion
+//#region src/auth/bypass.ts
+/**
+* Dev/E2E auth bypass: seed storage with a fake oidc-client-ts user whose
+* `access_token` is the bypass secret, so the app considers the session
+* authenticated and the API client sends the secret as Bearer.
+*
+* Call from a plugin that runs before the OIDC plugin. Skips seeding when a
+* valid (non-expired) session already exists; overwrites corrupt entries.
+* Returns whether a session was seeded.
+*/
+function seedAuthBypassSession(options) {
+	if (options.isProductionBuild) return false;
+	if (!options.bypassSecret) return false;
+	const storage = options.storage ?? globalThis.localStorage;
+	const storageKey = `oidc.user:${options.issuerUrl}:${options.clientId}`;
+	const existing = storage.getItem(storageKey);
+	if (existing) try {
+		if ((JSON.parse(existing).expires_at ?? 0) > Date.now() / 1e3) return false;
+	} catch {}
+	(options.warn ?? console.warn)("[auth-bypass] Seeding storage with bypass token for dev/E2E testing");
+	storage.setItem(storageKey, JSON.stringify({
+		access_token: options.bypassSecret,
+		token_type: "Bearer",
+		expires_at: Math.floor(Date.now() / 1e3) + (options.sessionTtlSeconds ?? 86400),
+		profile: options.profile ?? {
+			sub: "e2e-test-user",
+			email: "e2e@example.test",
+			name: "E2E Test User"
+		},
+		scope: "openid profile email"
+	}));
+	return true;
+}
+//#endregion
+//#region src/auth/session.ts
+function defaultAuthUserMapper(profile) {
+	return {
+		id: profile.sub,
+		email: profile.email ?? "",
+		name: profile.name ?? null,
+		picture: profile.picture ?? null
+	};
+}
+/**
+* Reactive OIDC session state + actions — the setup body of an auth store.
+* Wrap it in the app's own store so naming and registration stay app-owned:
+*
+* ```ts
+* export const useAuthStore = defineStore('auth', () =>
+*   createAuthSessionCore({ getUserManager, mapUser: defaultAuthUserMapper }),
+* )
+* ```
+*/
+function createAuthSessionCore(options) {
+	const log = options.log ?? console.warn;
+	const user = ref(null);
+	const initialized = ref(false);
+	const loading = ref(false);
+	const isAuthenticated = computed(() => !!user.value);
+	async function checkAuth() {
+		loading.value = true;
+		try {
+			const um = options.getUserManager();
+			let oidcUser = await um.getUser();
+			if (oidcUser && oidcUser.expired && oidcUser.refresh_token) try {
+				oidcUser = await um.signinSilent();
+			} catch (err) {
+				log("[auth] signinSilent failed during checkAuth", err);
+				oidcUser = null;
+			}
+			if (oidcUser && !oidcUser.expired) user.value = options.mapUser(oidcUser.profile);
+			else user.value = null;
+		} catch {
+			user.value = null;
+		} finally {
+			initialized.value = true;
+			loading.value = false;
+		}
+	}
+	async function login(returnUrl) {
+		await options.getUserManager().signinRedirect({ state: returnUrl ?? "/" });
+	}
+	async function handleCallback() {
+		loading.value = true;
+		try {
+			const oidcUser = await options.getUserManager().signinRedirectCallback();
+			user.value = options.mapUser(oidcUser.profile);
+			return oidcUser.state || "/";
+		} finally {
+			initialized.value = true;
+			loading.value = false;
+		}
+	}
+	async function logout() {
+		loading.value = true;
+		try {
+			const manager = options.getUserManager();
+			const idTokenHint = (await manager.getUser())?.id_token;
+			await manager.removeUser();
+			user.value = null;
+			await manager.signoutRedirect(idTokenHint ? { id_token_hint: idTokenHint } : void 0);
+		} finally {
+			loading.value = false;
+		}
+	}
+	return {
+		user,
+		initialized,
+		loading,
+		isAuthenticated,
+		checkAuth,
+		login,
+		handleCallback,
+		logout
+	};
+}
+//#endregion
+//#region src/auth/guard.ts
+/**
+* Build the body of a global auth route-middleware. The returned handler
+* yields a redirect target path or `undefined` to allow navigation; the app's
+* middleware maps that onto its router:
+*
+* ```ts
+* export default defineNuxtRouteMiddleware(async (to) => {
+*   const target = await guard(to)
+*   if (target) return navigateTo(target)
+* })
+* ```
+*/
+function createAuthGuard(options) {
+	const isPublicRoute = options.isPublicRoute ?? ((to) => to.path === "/login" || to.path.startsWith("/auth/"));
+	const loginRedirect = options.loginRedirect ?? ((returnTo) => `/login?redirect=${encodeURIComponent(returnTo)}`);
+	return async function guard(to) {
+		if (isPublicRoute(to)) return void 0;
+		if (!await options.ensureAuthenticated()) return loginRedirect(to.fullPath);
+		const target = await options.afterAuthenticated?.(to);
+		return typeof target === "string" ? target : void 0;
+	};
+}
+//#endregion
+//#region src/api/client.ts
+/**
+* Resolve the API base URL: configured value, else the page origin in
+* production builds (same-host ingress), else a localhost dev port.
+*/
+function resolveApiBaseUrl(options) {
+	if (options.configuredUrl) return options.configuredUrl;
+	return options.isProductionBuild ? options.origin ?? window.location.origin : `http://localhost:${options.devFallbackPort}`;
+}
+/**
+* Bearer-token provider backed by the OIDC session: resolves to the current
+* access token, or `null` when there is no non-expired session.
+*/
+function createAccessTokenProvider(getUserManager) {
+	return async function getAccessToken() {
+		const user = await getUserManager().getUser();
+		if (!user || user.expired) return null;
+		return user.access_token;
+	};
+}
+/**
+* Lazily-created Eden Treaty client singleton with OIDC bearer injection.
+*
+* ```ts
+* const getClient = createTreatyClientFactory<App>({ getBaseUrl, getAccessToken })
+* export function useApi() {
+*   const client = getClient()
+*   return { api: client.api, client }
+* }
+* ```
+*/
+function createTreatyClientFactory(options) {
+	let client = null;
+	return function getClient() {
+		if (client) return client;
+		client = treaty(options.getBaseUrl(), {
+			parseDate: options.parseDate ?? false,
+			headers: async () => {
+				const token = await options.getAccessToken();
+				if (token) return { authorization: `Bearer ${token}` };
+			},
+			...options.treatyConfig
+		});
+		return client;
+	};
+}
+//#endregion
+//#region src/org/orgStore.ts
+/**
+* Reactive granted-organizations state + switching — the setup body of an
+* org/tenant store. Wrap it in the app's own store (and alias names there):
+*
+* ```ts
+* export const useTenantStore = defineStore('tenant', () => {
+*   const core = createOrgStoreCore<Tenant>({ fetchOrganizations, getSlug: t => t.slug })
+*   return { ...core, fetchTenants: core.fetchOrganizations }
+* })
+* ```
+*/
+function createOrgStoreCore(options) {
+	const persistenceKey = options.persistenceKey ?? "currentOrgSlug";
+	const getStorage = () => options.storage ?? globalThis.localStorage;
+	const organizations = ref([]);
+	const currentSlug = ref(null);
+	const loading = ref(false);
+	const fetchError = ref(null);
+	const currentOrganization = computed(() => {
+		if (!currentSlug.value) return null;
+		return organizations.value.find((org) => options.getSlug(org) === currentSlug.value) ?? null;
+	});
+	async function fetchOrganizations() {
+		loading.value = true;
+		fetchError.value = null;
+		try {
+			const result = await options.fetchOrganizations();
+			if (result.items === void 0) {
+				fetchError.value = result.error;
+				return;
+			}
+			organizations.value = result.items;
+			if (currentSlug.value) {
+				if (!organizations.value.some((org) => options.getSlug(org) === currentSlug.value)) setCurrent(null);
+			}
+		} finally {
+			loading.value = false;
+		}
+	}
+	function setCurrent(slug) {
+		currentSlug.value = slug;
+		if (slug) getStorage().setItem(persistenceKey, slug);
+		else getStorage().removeItem(persistenceKey);
+	}
+	function loadPersisted() {
+		const stored = getStorage().getItem(persistenceKey);
+		if (stored) currentSlug.value = stored;
+	}
+	return {
+		organizations,
+		currentSlug,
+		currentOrganization,
+		loading,
+		fetchError,
+		fetchOrganizations,
+		setCurrent,
+		loadPersisted
+	};
+}
+//#endregion
+//#region src/composables/useConfirm.ts
+const isOpen = ref(false);
+const currentOptions = ref({ title: "" });
+let resolvePromise = null;
+/** Promise-based confirmation: `if (await confirm({ title, dangerous: true })) …` */
+function useConfirm() {
+	function confirm(options) {
+		currentOptions.value = options;
+		isOpen.value = true;
+		return new Promise((resolve) => {
+			resolvePromise = resolve;
+		});
+	}
+	return { confirm };
+}
+/** State + handlers for the dialog renderer component. */
+function useConfirmState() {
+	function handleConfirm() {
+		isOpen.value = false;
+		resolvePromise?.(true);
+		resolvePromise = null;
+	}
+	function handleCancel() {
+		isOpen.value = false;
+		resolvePromise?.(false);
+		resolvePromise = null;
+	}
+	return {
+		isOpen,
+		options: currentOptions,
+		handleConfirm,
+		handleCancel
+	};
+}
+//#endregion
+//#region src/composables/apiErrorMessenger.ts
+/**
+* Map API error bodies to user-facing i18n strings using a fixed key
+* convention the consumer's locale files fulfil:
+*
+* - `errors.<key>` — one entry per API error key (fallback: the raw
+*   server `message`, and `errors.internal_server_error` for non-API errors)
+* - `validation.fields.<path>` — display names for validated fields
+* - `validation.messages.<snake_cased_message>` — validation message texts
+*
+* Framework-free: pass `t`/`te` from your i18n instance (the app-side
+* composable is typically `const { t, te } = useI18n()` + this factory).
+* Eden Treaty error envelopes (`{ value }`) are unwrapped automatically.
+*/
+function createApiErrorMessenger(options) {
+	const { t, te } = options;
+	const log = options.log ?? ((message, error) => console.error(message, error));
+	function isApiError(error) {
+		return typeof error === "object" && error !== null && "key" in error && "message" in error;
+	}
+	function isValidationError(error) {
+		return isApiError(error) && error.key === "validation_error";
+	}
+	function getErrorMessage(error) {
+		log("API Error:", error);
+		let actualError = error;
+		if (typeof error === "object" && error !== null && "value" in error) actualError = error.value;
+		if (isValidationError(actualError)) return actualError.fields.map((f) => {
+			const fieldKey = `validation.fields.${f.path}`;
+			const fieldName = te(fieldKey) ? t(fieldKey) : f.path;
+			const messageKey = `validation.messages.${f.message.toLowerCase().replace(/\s+/g, "_")}`;
+			return `${fieldName}: ${te(messageKey) ? t(messageKey) : f.message}`;
+		}).join(", ") || t("errors.validation_error");
+		if (!isApiError(actualError)) return t("errors.internal_server_error");
+		const errorKey = `errors.${actualError.key}`;
+		if (te(errorKey)) return t(errorKey);
+		return actualError.message;
+	}
+	return {
+		getErrorMessage,
+		isValidationError
+	};
+}
+//#endregion
+//#region src/composables/useDirtyTracking.ts
+function deepClone(obj) {
+	return JSON.parse(JSON.stringify(obj));
+}
+/**
+* Form change-detection over a reactive state object via JSON deep-compare:
+* `isDirty` flips when any field differs from the snapshot; `resetInitial()`
+* re-snapshots after load/save (optionally assigning new values first);
+* `getDirtyFields()` yields a minimal PATCH payload.
+*/
+function useDirtyTracking(state) {
+	const initial = ref(deepClone(state));
+	const isDirty = computed(() => JSON.stringify(state) !== JSON.stringify(initial.value));
+	function getDirtyFields() {
+		const dirty = {};
+		for (const key of Object.keys(state)) if (JSON.stringify(state[key]) !== JSON.stringify(initial.value[key])) dirty[key] = state[key];
+		return dirty;
+	}
+	function resetInitial(values) {
+		if (values) Object.assign(state, values);
+		initial.value = deepClone(state);
+	}
+	return {
+		isDirty,
+		getDirtyFields,
+		resetInitial
+	};
+}
+//#endregion
+//#region src/composables/usePagination.ts
+/**
+* Offset-based table pagination: `page`/`itemsPerPage`/`total` state with a
+* derived `offset` and ready-to-spread `queryParams { limit, offset }`.
+* `onPaginationChange` fires whenever page or page size changes (refetch hook).
+*/
+function usePagination(options = {}) {
+	const { defaultLimit = 50, onPaginationChange } = options;
+	const page = ref(1);
+	const itemsPerPage = ref(defaultLimit);
+	const total = ref(0);
+	const offset = computed(() => (page.value - 1) * itemsPerPage.value);
+	const queryParams = computed(() => ({
+		limit: itemsPerPage.value,
+		offset: offset.value
+	}));
+	function setTotal(value) {
+		total.value = value;
+	}
+	function resetPagination() {
+		page.value = 1;
+	}
+	watch([page, itemsPerPage], () => {
+		onPaginationChange?.();
+	});
+	return {
+		page,
+		itemsPerPage,
+		total,
+		offset,
+		queryParams,
+		setTotal,
+		resetPagination
+	};
+}
+//#endregion
+export { ZITADEL_ORG_PROJECT_SCOPE, ZITADEL_REFRESH_TOKEN_ALLOWED_SCOPE, attachSessionLifecycleHandlers, createAccessTokenProvider, createApiErrorMessenger, createAuthGuard, createAuthSessionCore, createLoginRedirector, createOrgStoreCore, createTreatyClientFactory, createUserManagerFactory, defaultAuthUserMapper, isUnrecoverableRenewError, removeStaleOidcKeys, resolveApiBaseUrl, seedAuthBypassSession, useConfirm, useConfirmState, useDirtyTracking, usePagination };

package/dist/zod/index.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod";
+//#region src/zod/index.d.ts
+type ZodLocaleFactory = () => Parameters<typeof z.config>[0];
+interface ZodLocaleSyncOptions {
+  /** Locale code → zod locale factory (from `zod/locales`), e.g. `{ de, en }`. */
+  locales: Record<string, ZodLocaleFactory>;
+  /** Applied when the active locale has no entry in `locales`. */
+  defaultLocale: string;
+  /** Read the active UI locale code. */
+  getLocale: () => string;
+  /**
+   * Wire locale-change reactivity — call `apply` with the new code whenever
+   * the UI locale changes (e.g. `apply => watch(() => i18n.locale.value, apply)`).
+   */
+  onLocaleChange: (apply: (code: string) => void) => void;
+}
+/**
+ * Keep Zod's built-in error messages in the user's language: applies the
+ * matching `zod/locales` config immediately and re-applies on every locale
+ * change. Call once from an app plugin.
+ */
+declare function setupZodLocaleSync(options: ZodLocaleSyncOptions): void;
+//#endregion
+export { ZodLocaleSyncOptions, setupZodLocaleSync };

package/dist/zod/index.js

@@ -0,0 +1,17 @@
+import * as z from "zod";
+//#region src/zod/index.ts
+/**
+* Keep Zod's built-in error messages in the user's language: applies the
+* matching `zod/locales` config immediately and re-applies on every locale
+* change. Call once from an app plugin.
+*/
+function setupZodLocaleSync(options) {
+	const apply = (code) => {
+		const factory = options.locales[code] ?? options.locales[options.defaultLocale];
+		if (factory) z.config(factory());
+	};
+	apply(options.getLocale());
+	options.onLocaleChange(apply);
+}
+//#endregion
+export { setupZodLocaleSync };

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@octabits-io/nuxt-ui-kit",
+  "version": "0.2.0",
+  "description": "Frontend kit for Nuxt/Vue admin SPAs: OIDC session harness (oidc-client-ts), Eden Treaty client factory, auth/org store cores, and a route-guard builder — factory-style seams the app wires into its own plugins, stores, and middleware",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./zod": {
+      "types": "./dist/zod/index.d.ts",
+      "import": "./dist/zod/index.js",
+      "default": "./dist/zod/index.js"
+    },
+    "./dates": {
+      "types": "./dist/dates/index.d.ts",
+      "import": "./dist/dates/index.js",
+      "default": "./dist/dates/index.js"
+    },
+    "./ai": {
+      "types": "./dist/ai/index.d.ts",
+      "import": "./dist/ai/index.js",
+      "default": "./dist/ai/index.js"
+    },
+    "./components/*": "./src/components/*"
+  },
+  "files": [
+    "dist",
+    "src/components",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/octabits-io/platform.git",
+    "directory": "packages/nuxt-ui-kit"
+  },
+  "homepage": "https://github.com/octabits-io/platform/tree/main/packages/nuxt-ui-kit",
+  "bugs": {
+    "url": "https://github.com/octabits-io/platform/issues"
+  },
+  "devDependencies": {
+    "@elysiajs/eden": "^1.4.9",
+    "date-fns": "^4.4.0",
+    "elysia": "^1.4.29",
+    "oidc-client-ts": "^3.5.0",
+    "vitest": "^4.1.10",
+    "vue": "^3.5.39",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@elysiajs/eden": "^1.4.0",
+    "@internationalized/date": "^3",
+    "@nuxt/ui": "^4",
+    "date-fns": "^3 || ^4",
+    "elysia": ">=1.4 <3",
+    "oidc-client-ts": "^3.3.0",
+    "typescript": "^5 || ^6 || ^7",
+    "vue": "^3.5.0",
+    "vue-i18n": "^11",
+    "vue-router": "^4",
+    "zod": "^4"
+  },
+  "peerDependenciesMeta": {
+    "@internationalized/date": {
+      "optional": true
+    },
+    "@nuxt/ui": {
+      "optional": true
+    },
+    "date-fns": {
+      "optional": true
+    },
+    "elysia": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    },
+    "vue-i18n": {
+      "optional": true
+    },
+    "vue-router": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}