@pocket-trash/localizations 0.0.3 → 0.0.8

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pocket Trash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,18 @@
 # @pocket-trash/localizations
 
-Shared localization utilities and message catalogs for Pocket Trash.
+[![npm version](https://img.shields.io/npm/v/@pocket-trash/localizations.svg)](https://www.npmjs.com/package/@pocket-trash/localizations)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./package.json)
+[![CI](https://github.com/Pocket-Trash/pocket-trash-localizations/actions/workflows/ci.yml/badge.svg)](https://github.com/Pocket-Trash/pocket-trash-localizations/actions/workflows/ci.yml)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](docs/contributing.md)
+
+Shared localization utilities and translation catalogs for Pocket Trash.
+
+## Documentation
+
+| File | Description |
+| --- | --- |
+| [contributing.md](docs/contributing.md) | Explains how to edit translations, run checks, commit changes, and open a pull request. |
+| [publishing.md](docs/publishing.md) | Explains how changesets become package versions and npm releases. |
 
 ## Install
 
@@ -8,20 +20,234 @@ Shared localization utilities and message catalogs for Pocket Trash.
 npm install @pocket-trash/localizations
 ```
 
-## Use
+## Quick Start
 
 ```ts
-import { formatMessage, resolveLocale } from '@pocket-trash/localizations';
+import { formatTranslation, resolveLocale } from '@pocket-trash/localizations';
 
 const locale = resolveLocale('es-MX');
-const label = formatMessage('action.save', {}, locale);
+const label = formatTranslation('action.save', {}, locale);
+```
+
+`label` is `"Guardar"`.
+
+## Formatting Translations
+
+Use `formatTranslation(key, values, locale)` when you need one translated
+string.
+
+```ts
+import { formatTranslation } from '@pocket-trash/localizations';
+
+formatTranslation('action.save');
+formatTranslation('locale.current', { locale: 'es-MX' }, 'es-MX');
+```
+
+The second argument is the placeholder values object. Pass `{}` when the
+translation does not need any values.
+
+```ts
+formatTranslation('action.save', {}, 'es-MX');
+```
+
+For translations with placeholders, pass the placeholder names and values:
+
+```ts
+formatTranslation('locale.current', { locale: 'es-MX' }, 'es-MX');
+```
+
+That fills `{locale}` in this translation:
+
+```ts
+export const esMX = {
+  locale: {
+    current: 'Idioma actual: {locale}',
+  },
+};
+```
+
+If a placeholder value is missing, the placeholder stays in the string. That
+makes missing data visible instead of silently deleting text.
+
+## Resolving Locales
+
+Use `resolveLocale()` before formatting when locale input comes from a browser,
+request header, user setting, or other string source.
+
+```ts
+import { resolveLocale } from '@pocket-trash/localizations';
+
+const locale = resolveLocale('fr-CA', 'es-MX');
+// locale is "es-MX"
+```
+
+`resolveLocale()` returns a TypeScript-safe `SupportedLocale`.
+
+```ts
+import type { SupportedLocale } from '@pocket-trash/localizations';
+
+const locale: SupportedLocale = resolveLocale('nl-BE');
+// locale is "en-US" because nl-BE is not supported
+```
+
+Passing an unsupported locale to `resolveLocale()` does not throw. It falls
+back to `en-US`.
+
+```ts
+const locale = resolveLocale('nl-BE');
+formatTranslation('action.save', {}, locale);
+// "Save"
+```
+
+The `locale` parameter on `formatTranslation()` is TypeScript-safe. Passing an
+unsupported literal like `'nl-BE'` directly is a type error.
+
+```ts
+formatTranslation('action.save', {}, 'nl-BE');
+// TypeScript error: "nl-BE" is not assignable to SupportedLocale
+```
+
+Use `resolveLocale()` for raw external input. It returns a supported locale that
+can be passed to `formatTranslation()`.
+
+## TypeScript Safety
+
+Translation keys are type-safe when you use a known key.
+
+```ts
+import type { TranslationKey } from '@pocket-trash/localizations';
+
+const key: TranslationKey = 'action.save';
 ```
 
+The current translation keys are:
+
+```ts
+type TranslationKey =
+  | 'app.name'
+  | 'action.cancel'
+  | 'action.save'
+  | 'error.generic'
+  | 'locale.current';
+```
+
+`formatTranslation()` only accepts known `TranslationKey` values. Unknown keys
+are TypeScript errors.
+
+```ts
+formatTranslation('unknown.key');
+// TypeScript error: "unknown.key" is not assignable to TranslationKey
+```
+
+## Getting a Whole Catalog
+
+Use `getTranslations()` when you need all translations for a locale.
+
+```ts
+import { getTranslations } from '@pocket-trash/localizations';
+
+const translations = getTranslations('es-MX');
+const save = translations['action.save'];
+```
+
+Returned catalogs are complete. If a non-English locale omits a translation,
+or has a blank string, that key falls back to the `en-US` value.
+
+## Clerk Localizations
+
+Use `getClerkLocalization()` when configuring Clerk UI components.
+
+```ts
+import { getClerkLocalization, resolveLocale } from '@pocket-trash/localizations';
+
+const locale = resolveLocale('es-MX');
+const localization = getClerkLocalization(locale);
+```
+
+English returns `undefined`, so Clerk uses its default English strings. Spanish
+returns Clerk's `esMX` localization.
+
+## Adding Translations
+
+Source locale files use nested objects:
+
+```ts
+export const enUS = {
+  app: {
+    name: 'Pocket Trash',
+  },
+  action: {
+    cancel: 'Cancel',
+    save: 'Save',
+  },
+};
+```
+
+Callers still use dot keys:
+
+```ts
+formatTranslation('action.save');
+```
+
+Add new translation keys in two places:
+
+1. Add the nested field to `CompleteLocalizationResource` in `src/types/localization.ts`.
+2. Add the required English value to `src/localizations/en-US.ts`.
+3. Run `pnpm localization:sync`.
+4. Fill in translated values when available.
+5. Run `pnpm test`.
+
+Non-English locale files can omit new keys until translations are ready. Missing
+or blank keys fall back to `en-US` at runtime.
+
+## Scaffolding a Locale
+
+Create and wire a new locale:
+
+```sh
+pnpm localization:create nl-BE
+```
+
+That command:
+
+1. Creates `src/localizations/nl-BE.ts`.
+2. Copies the nested `en-US` shape with every value set to `''`.
+3. Adds the locale to `SupportedLocale`, `SUPPORTED_LOCALES`, `localizations`,
+   and `translations`.
+4. Adds a Clerk localization mapping if `@clerk/localizations` exports one.
+
+Sync missing keys into existing non-English locales:
+
+```sh
+pnpm localization:sync
+```
+
+`en-US` is the source of truth. Sync adds missing nested keys with blank values
+and preserves existing translations.
+
 ## Develop
+Common commands:
+
+| Command | Description |
+| --- | --- |
+| `pnpm install` | Install dependencies. |
+| `pnpm build` | Build the package with TypeScript. |
+| `pnpm format` | Format files with Biome. |
+| `pnpm lint` | Check formatting and lint rules with Biome. |
+| `pnpm check` | Run Biome checks and apply safe fixes. |
+| `pnpm test` | Build the package and run the test suite. |
+| `pnpm localization:create nl-BE` | Create and wire a new locale from the `en-US` source shape. |
+| `pnpm localization:sync` | Add missing source keys to existing non-English locale files. |
+| `pnpm changeset` | Create a release changeset for a pull request. |
+| `pnpm release` | Publish pending package changes from the release workflow. |
 
 ```sh
 pnpm install
+pnpm format
+pnpm lint
 pnpm test
+pnpm localization:create nl-BE
+pnpm localization:sync
 ```
 
 Publishing notes live in [docs/publishing.md](docs/publishing.md).

package/dist/index.d.ts

@@ -1,31 +1,62 @@
-import { esMX } from '@clerk/localizations';
-export type SupportedLocale = 'en' | 'es-MX';
-export type MessageKey = 'app.name' | 'action.cancel' | 'action.save' | 'error.generic' | 'locale.current';
-export type Messages = Readonly<Record<MessageKey, string>>;
+import { esMX as clerkEsMX } from "@clerk/localizations";
+import type { TranslationKey, Translations } from "./types/localization.js";
+export { enUS } from "./localizations/en-US.js";
+export { esMX } from "./localizations/es-MX.js";
+export type { CompleteLocalizationResource, LocalizationResource, TranslationKey, Translations, } from "./types/localization.js";
+export type SupportedLocale = "en-US" | "es-MX";
+export type MessageKey = TranslationKey;
+export type Messages = Translations;
 export type LocalePreference = string | readonly string[] | null | undefined;
-export type ClerkLocalizationResource = typeof esMX;
-export declare const DEFAULT_LOCALE = "en";
-export declare const SUPPORTED_LOCALES: readonly ["en", "es-MX"];
+export type ClerkLocalizationResource = typeof clerkEsMX;
+export declare const DEFAULT_LOCALE = "en-US";
+export declare const SUPPORTED_LOCALES: readonly ["en-US", "es-MX"];
+export declare const localizations: Readonly<{
+    "en-US": {
+        app: {
+            name: string;
+        };
+        action: {
+            cancel: string;
+            save: string;
+        };
+        error: {
+            generic: string;
+        };
+        locale: {
+            current: string;
+        };
+    };
+    "es-MX": {
+        app: {
+            name: string;
+        };
+        action: {
+            cancel: string;
+            save: string;
+        };
+        error: {
+            generic: string;
+        };
+        locale: {
+            current: string;
+        };
+    };
+}>;
+export declare const translationKeys: readonly TranslationKey[];
+export declare const translations: Readonly<{
+    "en-US": Readonly<Readonly<Record<TranslationKey, string>>>;
+    "es-MX": Readonly<Readonly<Record<TranslationKey, string>>>;
+}>;
 export declare const messages: Readonly<{
-    en: Readonly<{
-        'app.name': "Pocket Trash";
-        'action.cancel': "Cancel";
-        'action.save': "Save";
-        'error.generic': "Something went wrong.";
-        'locale.current': "Current language: {locale}";
-    }>;
-    'es-MX': Readonly<{
-        'app.name': "Pocket Trash";
-        'action.cancel': "Cancelar";
-        'action.save': "Guardar";
-        'error.generic': "Algo salio mal.";
-        'locale.current': "Idioma actual: {locale}";
-    }>;
+    "en-US": Readonly<Readonly<Record<TranslationKey, string>>>;
+    "es-MX": Readonly<Readonly<Record<TranslationKey, string>>>;
 }>;
-export declare const messageKeys: readonly MessageKey[];
+export declare const messageKeys: readonly TranslationKey[];
 export declare const clerkLocalizations: Readonly<Record<SupportedLocale, ClerkLocalizationResource | undefined>>;
 export declare function resolveLocale(...preferences: readonly LocalePreference[]): SupportedLocale;
-export declare function getMessages(locale?: string | null): Messages;
-export declare function getClerkLocalization(locale?: string | null): ClerkLocalizationResource | undefined;
-export declare function formatMessage(key: MessageKey | string, values?: Readonly<Record<string, unknown>>, locale?: string | null): string;
+export declare function getTranslations(locale?: SupportedLocale | null): Translations;
+export declare const getMessages: typeof getTranslations;
+export declare function getClerkLocalization(locale?: SupportedLocale | null): ClerkLocalizationResource | undefined;
+export declare function formatTranslation(key: TranslationKey, values?: Readonly<Record<string, unknown>>, locale?: SupportedLocale | null): string;
+export declare const formatMessage: typeof formatTranslation;
 export declare function assertCompleteCatalogs(): true;

package/dist/index.js

@@ -1,34 +1,31 @@
-import { esMX } from '@clerk/localizations';
-export const DEFAULT_LOCALE = 'en';
-export const SUPPORTED_LOCALES = Object.freeze(['en', 'es-MX']);
+import { esMX as clerkEsMX } from "@clerk/localizations";
+import { enUS } from "./localizations/en-US.js";
+import { esMX } from "./localizations/es-MX.js";
+export { enUS } from "./localizations/en-US.js";
+export { esMX } from "./localizations/es-MX.js";
+export const DEFAULT_LOCALE = "en-US";
+export const SUPPORTED_LOCALES = Object.freeze(["en-US", "es-MX"]);
 const localeAliases = new Map([
-    ['en', 'en'],
-    ['en-us', 'en'],
-    ['en-ca', 'en'],
-    ['es', 'es-MX'],
-    ['es-mx', 'es-MX'],
-    ['es-us', 'es-MX'],
+    ["es", "es-MX"],
+    ["es-mx", "es-MX"],
+    ["es-us", "es-MX"],
+    ["en-us", "en-US"],
 ]);
-export const messages = Object.freeze({
-    en: Object.freeze({
-        'app.name': 'Pocket Trash',
-        'action.cancel': 'Cancel',
-        'action.save': 'Save',
-        'error.generic': 'Something went wrong.',
-        'locale.current': 'Current language: {locale}',
-    }),
-    'es-MX': Object.freeze({
-        'app.name': 'Pocket Trash',
-        'action.cancel': 'Cancelar',
-        'action.save': 'Guardar',
-        'error.generic': 'Algo salio mal.',
-        'locale.current': 'Idioma actual: {locale}',
-    }),
+export const localizations = Object.freeze({
+    "en-US": enUS,
+    "es-MX": esMX,
 });
-export const messageKeys = Object.freeze(Object.keys(messages[DEFAULT_LOCALE]));
+const defaultTranslations = flattenLocalization(enUS);
+export const translationKeys = Object.freeze(Object.keys(defaultTranslations));
+export const translations = Object.freeze({
+    "en-US": Object.freeze(defaultTranslations),
+    "es-MX": Object.freeze(mergeTranslations(defaultTranslations, flattenLocalization(esMX))),
+});
+export const messages = translations;
+export const messageKeys = translationKeys;
 export const clerkLocalizations = Object.freeze({
-    en: undefined,
-    'es-MX': esMX,
+    "en-US": undefined,
+    "es-MX": clerkEsMX,
 });
 export function resolveLocale(...preferences) {
     for (const preference of preferences.flat()) {
@@ -40,39 +37,47 @@ export function resolveLocale(...preferences) {
     }
     return DEFAULT_LOCALE;
 }
-export function getMessages(locale) {
-    return messages[resolveLocale(locale)];
+export function getTranslations(locale) {
+    return translations[resolveLocale(locale)];
 }
+export const getMessages = getTranslations;
 export function getClerkLocalization(locale) {
     return clerkLocalizations[resolveLocale(locale)];
 }
-export function formatMessage(key, values = {}, locale = DEFAULT_LOCALE) {
-    const template = getMessages(locale)[key] ?? messages[DEFAULT_LOCALE][key];
+export function formatTranslation(key, values = {}, locale = DEFAULT_LOCALE) {
+    const template = getTranslations(locale)[key] ?? translations[DEFAULT_LOCALE][key];
     if (!template)
         return key;
     return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, name) => values[name] == null ? `{${name}}` : String(values[name]));
 }
+export const formatMessage = formatTranslation;
 export function assertCompleteCatalogs() {
-    const expected = new Set(messageKeys);
-    for (const [locale, catalog] of Object.entries(messages)) {
-        const keys = Object.keys(catalog);
-        const missing = messageKeys.filter((key) => !(key in catalog));
+    const expected = new Set(translationKeys);
+    for (const [locale, catalog] of Object.entries(localizations)) {
+        const flatCatalog = flattenLocalization(catalog);
+        const keys = Object.keys(flatCatalog);
+        const missing = locale === DEFAULT_LOCALE
+            ? translationKeys.filter((key) => !(key in flatCatalog))
+            : [];
+        const empty = locale === DEFAULT_LOCALE
+            ? translationKeys.filter((key) => flatCatalog[key] === "")
+            : [];
         const extra = keys.filter((key) => !expected.has(key));
-        if (missing.length || extra.length) {
-            throw new Error(`${locale} catalog mismatch: missing ${missing.join(', ') || 'none'}; extra ${extra.join(', ') || 'none'}`);
+        if (missing.length || empty.length || extra.length) {
+            throw new Error(`${locale} catalog mismatch: missing ${missing.join(", ") || "none"}; empty ${empty.join(", ") || "none"}; extra ${extra.join(", ") || "none"}`);
         }
     }
     return true;
 }
 function parseLocalePreference(preference) {
-    if (typeof preference !== 'string' || !preference.trim())
+    if (typeof preference !== "string" || !preference.trim())
         return [];
-    if (!preference.includes(',') && !preference.includes(';'))
+    if (!preference.includes(",") && !preference.includes(";"))
         return [preference];
     return preference
-        .split(',')
+        .split(",")
         .map((part, index) => {
-        const [tag, ...params] = part.trim().split(';');
+        const [tag, ...params] = part.trim().split(";");
         const q = params
             .map((param) => param.trim().match(/^q=([0-9.]+)$/i)?.[1])
             .find(Boolean);
@@ -83,9 +88,34 @@ function parseLocalePreference(preference) {
         .map(({ tag }) => tag);
 }
 function matchLocale(tag) {
-    const normalized = tag.trim().replace('_', '-').toLowerCase();
-    if (normalized === '*')
+    const normalized = tag.trim().replace("_", "-").toLowerCase();
+    if (normalized === "*")
         return DEFAULT_LOCALE;
-    return localeAliases.get(normalized) ?? localeAliases.get(normalized.split('-')[0] ?? '') ?? null;
+    return localeAliases.get(normalized) ?? null;
+}
+function flattenLocalization(resource) {
+    const entries = {};
+    for (const [key, value] of flattenEntries(resource)) {
+        entries[key] = value;
+    }
+    return entries;
+}
+function flattenEntries(resource, prefix = "") {
+    return Object.entries(resource).flatMap(([key, value]) => {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === "string")
+            return [[path, value]];
+        if (value && typeof value === "object")
+            return flattenEntries(value, path);
+        return [];
+    });
+}
+function mergeTranslations(defaults, overrides) {
+    return Object.fromEntries(translationKeys.map((key) => [
+        key,
+        overrides[key] === "" || overrides[key] == null
+            ? defaults[key]
+            : overrides[key],
+    ]));
 }
 assertCompleteCatalogs();

package/dist/localizations/en-US.d.ts

@@ -0,0 +1,24 @@
+/**
+ * English (United States) translations for Pocket Trash.
+ *
+ * This catalog is checked against `CompleteLocalizationResource` from
+ * `src/types/localization.ts`. When adding a translation key, update that type
+ * first, then add the required English string here. Other locale catalogs can
+ * omit most new keys until a translation is available; omitted keys fall back to
+ * this `en-US` catalog at runtime.
+ */
+export declare const enUS: {
+    app: {
+        name: string;
+    };
+    action: {
+        cancel: string;
+        save: string;
+    };
+    error: {
+        generic: string;
+    };
+    locale: {
+        current: string;
+    };
+};

package/dist/localizations/en-US.js

@@ -0,0 +1,24 @@
+/**
+ * English (United States) translations for Pocket Trash.
+ *
+ * This catalog is checked against `CompleteLocalizationResource` from
+ * `src/types/localization.ts`. When adding a translation key, update that type
+ * first, then add the required English string here. Other locale catalogs can
+ * omit most new keys until a translation is available; omitted keys fall back to
+ * this `en-US` catalog at runtime.
+ */
+export const enUS = {
+    app: {
+        name: "Pocket Trash",
+    },
+    action: {
+        cancel: "Cancel",
+        save: "Save",
+    },
+    error: {
+        generic: "Something went wrong.",
+    },
+    locale: {
+        current: "Current language: {locale}",
+    },
+};

package/dist/localizations/es-MX.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Spanish (Mexico) translations for Pocket Trash.
+ *
+ * This catalog is checked against `LocalizationResource` from
+ * `src/types/localization.ts`. When adding a translation key, update that type
+ * first, add the required English string in `src/localizations/en-US.ts`, then
+ * add this locale's translation when available. Most new keys should remain
+ * optional in the type so this catalog can omit untranslated strings and fall
+ * back to `en-US` at runtime.
+ */
+export declare const esMX: {
+    app: {
+        name: string;
+    };
+    action: {
+        cancel: string;
+        save: string;
+    };
+    error: {
+        generic: string;
+    };
+    locale: {
+        current: string;
+    };
+};

package/dist/localizations/es-MX.js

@@ -0,0 +1,25 @@
+/**
+ * Spanish (Mexico) translations for Pocket Trash.
+ *
+ * This catalog is checked against `LocalizationResource` from
+ * `src/types/localization.ts`. When adding a translation key, update that type
+ * first, add the required English string in `src/localizations/en-US.ts`, then
+ * add this locale's translation when available. Most new keys should remain
+ * optional in the type so this catalog can omit untranslated strings and fall
+ * back to `en-US` at runtime.
+ */
+export const esMX = {
+    app: {
+        name: "Pocket Trash",
+    },
+    action: {
+        cancel: "Cancelar",
+        save: "Guardar",
+    },
+    error: {
+        generic: "Algo salio mal.",
+    },
+    locale: {
+        current: "Idioma actual: {locale}",
+    },
+};

package/dist/types/localization.d.ts

@@ -0,0 +1,25 @@
+type DotPaths<T> = {
+    [K in keyof T & string]: T[K] extends string ? K : T[K] extends object ? `${K}.${DotPaths<T[K]>}` : never;
+}[keyof T & string];
+type DeepPartial<T> = {
+    readonly [K in keyof T]?: T[K] extends string ? string : DeepPartial<T[K]>;
+};
+export type CompleteLocalizationResource = Readonly<{
+    app: {
+        name: string;
+    };
+    action: {
+        cancel: string;
+        save: string;
+    };
+    error: {
+        generic: string;
+    };
+    locale: {
+        current: string;
+    };
+}>;
+export type TranslationKey = DotPaths<CompleteLocalizationResource>;
+export type Translations = Readonly<Record<TranslationKey, string>>;
+export type LocalizationResource = DeepPartial<CompleteLocalizationResource>;
+export {};

package/dist/types/localization.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pocket-trash/localizations",
-  "version": "0.0.3",
+  "version": "0.0.8",
   "description": "Shared localization utilities and message catalogs for Pocket Trash.",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,23 +31,32 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "changeset": "changeset",
-    "changeset:version": "changeset version",
-    "release": "changeset publish",
-    "test": "pnpm run build && node --test"
-  },
   "engines": {
     "node": ">=20"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.8",
     "@changesets/cli": "^2.31.1",
+    "@commitlint/cli": "^21.2.2",
+    "@commitlint/config-conventional": "^21.2.2",
+    "husky": "^9.1.7",
     "typescript": "^5.9.2"
   },
   "dependencies": {
     "@clerk/localizations": "^4.14.2",
     "lts": "^2.0.0"
   },
-  "packageManager": "pnpm@11.10.0"
-}
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "biome check --write .",
+    "changeset": "changeset",
+    "changeset:version": "changeset version && node scripts/stamp-changelog-release-date.mjs",
+    "dev": "tsc -p tsconfig.json --watch",
+    "format": "biome format --write .",
+    "lint": "biome ci .",
+    "localization:create": "node scripts/localizations.mjs create",
+    "localization:sync": "node scripts/localizations.mjs sync",
+    "release": "pnpm run changeset:version && pnpm install --lockfile-only && changeset publish",
+    "test": "pnpm run build && node --test"
+  }
+}