@mccaskie-labs/workbench-strings 0.0.0-stage → 0.1.1

package/dist/strings.js

@@ -0,0 +1,238 @@
+// defineStrings: an app's catalogue, its locales and its fallback chain, set
+// up once and checked at start. Server only (internationalization standard
+// §7.5): the catalogue holds every language, so it never goes to a browser.
+// Look words up here and pass the finished words to the page.
+import { GLOSS, isMeta, readReview, REVIEW_STATUS } from "./catalogue.js";
+import { localeCookie, readLocaleCookie, resolveLocale, } from "./detect.js";
+import { WorkbenchStringsError } from "./errors.js";
+import { formatMessage, parseMessage, placeholdersOf } from "./format.js";
+import { WORKBENCH_LANGUAGES } from "./languages.js";
+/** The name groups a key must start with (§5.3). A new class of string adds a group here, by PR. */
+export const NAMESPACES = ["ui", "enum", "question", "validation", "email", "notification", "page", "error", "meta"];
+function invalid(why) {
+    throw new WorkbenchStringsError("invalid_options", why);
+}
+function defaultOnMissing() {
+    const seen = new Set();
+    return (m) => {
+        const id = `${m.requested}\u0000${m.key}`;
+        if (seen.has(id))
+            return;
+        if (seen.size >= 1000)
+            seen.clear();
+        seen.add(id);
+        const line = { level: m.resolved === null ? "error" : "warn", event: "strings.missing", ...m };
+        console.warn(JSON.stringify(line));
+    };
+}
+/** Sets up an app's strings. Throws WorkbenchStringsError at start when a rule is broken. */
+export function defineStrings(options) {
+    const base = options.base.locale;
+    const locales = [...options.locales];
+    const planned = [...(options.planned ?? [])];
+    const translations = options.translations ?? {};
+    const onMissing = options.onMissing ?? defaultOnMissing();
+    // The locale set (§4).
+    if (locales.length === 0)
+        invalid("locales is empty");
+    if (new Set(locales).size !== locales.length)
+        invalid("locales names a locale twice");
+    if (!locales.includes(base))
+        invalid(`locales must include the base, ${base}`);
+    for (const l of locales) {
+        if (!WORKBENCH_LANGUAGES.includes(l)) {
+            invalid(`${l} is not a Workbench language (${WORKBENCH_LANGUAGES.join(", ")}). A new language is added to the shared list first`);
+        }
+    }
+    for (const p of planned) {
+        if (locales.includes(p))
+            invalid(`${p} is both live and planned. A planned locale is absent from locales`);
+        if (p in translations)
+            invalid(`${p} is planned but has a catalogue. Add it to locales when it has words`);
+    }
+    for (const l of locales)
+        if (l !== base && !(l in translations))
+            invalid(`${l} has no catalogue in translations`);
+    for (const l of Object.keys(translations)) {
+        if (l === base)
+            invalid(`the base, ${base}, goes in base, not translations`);
+        if (!locales.includes(l))
+            invalid(`translations has ${l}, which is not in locales`);
+    }
+    const defaultLocale = options.defaultLocale ?? base;
+    if (!locales.includes(defaultLocale))
+        invalid(`defaultLocale ${defaultLocale} is not in locales`);
+    // The fallback chain, written once (§6).
+    const parents = options.parents ?? {};
+    for (const [child, parent] of Object.entries(parents)) {
+        if (!locales.includes(child) || !locales.includes(parent))
+            invalid(`parents ${child} -> ${parent}: both must be live locales`);
+        if (child === base)
+            invalid("the base has no parent: every chain ends there");
+    }
+    const chains = new Map();
+    for (const l of locales) {
+        const chain = [l];
+        let at = l;
+        while (at !== base) {
+            at = parents[at] ?? base;
+            if (chain.includes(at))
+                invalid(`parents loop at ${at}`);
+            chain.push(at);
+        }
+        chains.set(l, Object.freeze(chain));
+    }
+    // Catalogues: parsed once, so a broken string fails at start.
+    const catalogues = new Map([[base, options.base.strings], ...Object.entries(translations)]);
+    const messages = new Map();
+    const reviews = new Map();
+    for (const [l, cat] of catalogues) {
+        const parsed = new Map();
+        for (const [key, text] of Object.entries(cat)) {
+            if (typeof text !== "string") {
+                throw new WorkbenchStringsError("invalid_catalogue", `${l}: ${key} is not a string (the file must be flat)`);
+            }
+            if (key.startsWith(GLOSS)) {
+                throw new WorkbenchStringsError("invalid_catalogue", l === base
+                    ? `${l}: the base catalogue has a gloss (${key}). Glosses belong only to translations`
+                    : `${l}: has glosses, so it is the authored file. Pass the generated file from strings/runtime/`);
+            }
+            if (isMeta(key))
+                continue;
+            try {
+                parsed.set(key, parseMessage(text));
+            }
+            catch (e) {
+                throw new WorkbenchStringsError("invalid_string", `${l} ${key}: ${e.message}`);
+            }
+        }
+        messages.set(l, parsed);
+        const review = readReview(cat, l);
+        reviews.set(l, review);
+        if (l === base)
+            continue;
+        if (cat[REVIEW_STATUS] === undefined) {
+            throw new WorkbenchStringsError("invalid_catalogue", `${l}: has no ${REVIEW_STATUS}. Every translated catalogue says how it was made and reviewed`);
+        }
+        // The review gate's hard edge: nothing translated goes public with no named reviewer.
+        if (options.env === "production" && !review.reviewer) {
+            throw new WorkbenchStringsError("no_reviewer", `${l} is live in production with no named native-speaker reviewer. Add "_review.reviewer": "Name, cadence" to its catalogue, or take it out of locales`);
+        }
+    }
+    const keys = Object.keys(options.base.strings).filter((k) => !isMeta(k));
+    // Detection: countries, aliases and prefixes.
+    const countries = {};
+    const regions = new Map();
+    for (const l of locales) {
+        const region = l.split("-")[1];
+        if (region && /^[A-Z]{2}$/.test(region))
+            regions.set(region, [...(regions.get(region) ?? []), l]);
+    }
+    for (const [region, ls] of regions)
+        if (ls.length === 1)
+            countries[region] = ls[0];
+    for (const [country, l] of Object.entries(options.countries ?? {})) {
+        if (!/^[A-Z]{2}$/.test(country))
+            invalid(`countries: ${country} is not a two-letter country code`);
+        if (!locales.includes(l))
+            invalid(`countries: ${country} -> ${l}, which is not a live locale`);
+        countries[country] = l;
+    }
+    const aliases = { ...(options.aliases ?? {}) };
+    for (const [tag, l] of Object.entries(aliases))
+        if (!locales.includes(l))
+            invalid(`aliases: ${tag} -> ${l}, which is not a live locale`);
+    const prefixes = {};
+    for (const l of locales) {
+        const p = options.prefixes?.[l] ?? l.toLowerCase();
+        if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(p))
+            invalid(`prefixes: "${p}" for ${l} must be lower-case letters, digits and hyphens`);
+        if (Object.values(prefixes).includes(p))
+            invalid(`prefixes: "${p}" is used twice`);
+        prefixes[l] = p;
+    }
+    for (const l of Object.keys(options.prefixes ?? {}))
+        if (!locales.includes(l))
+            invalid(`prefixes: ${l} is not a live locale`);
+    const byPrefix = new Map(Object.entries(prefixes).map(([l, p]) => [p, l]));
+    // A signed-off locale whose parent is not would serve the parent's unreviewed words.
+    const reviewed = (l) => (chains.get(l) ?? [l]).every((x) => x === base || reviews.get(x)?.signedOff !== undefined);
+    const rules = Object.freeze({ locales, base, defaultLocale, countries, aliases, reviewed });
+    const liveOrBase = (l) => (chains.has(l) ? l : base);
+    function lookup(locale, key) {
+        for (const l of chains.get(liveOrBase(locale))) {
+            const m = messages.get(l).get(key);
+            if (m)
+                return { message: m, from: l };
+        }
+        return undefined;
+    }
+    function t(locale, key, values) {
+        const requested = liveOrBase(locale);
+        const found = lookup(requested, key);
+        if (!found) {
+            // The test kit makes the base complete, so this is a bug: show the key,
+            // as a visible bug report, and log it.
+            onMissing({ key, requested, resolved: null });
+            return key;
+        }
+        if (found.from !== requested)
+            onMissing({ key, requested, resolved: found.from });
+        return formatMessage(found.message, requested, values);
+    }
+    const strings = {
+        base,
+        locales: Object.freeze(locales),
+        defaultLocale,
+        planned: Object.freeze(planned),
+        keys: Object.freeze(keys),
+        rules,
+        prefixes: Object.freeze(prefixes),
+        parents: Object.freeze({ ...parents }),
+        catalogue: (l) => catalogues.get(l) ?? invalid(`${l} is not a live locale`),
+        chain: (l) => chains.get(l) ?? invalid(`${l} is not a live locale`),
+        review: (l) => reviews.get(l) ?? invalid(`${l} is not a live locale`),
+        reviewed,
+        has: (key) => !isMeta(key) && messages.get(base).has(key),
+        t,
+        pick(locale, ks) {
+            return Object.fromEntries(ks.map((k) => [k, t(locale, k)]));
+        },
+        email(locale, name, part, values) {
+            const requested = liveOrBase(locale);
+            const key = `email.${name}.${part}`;
+            const found = lookup(requested, key);
+            if (!found) {
+                onMissing({ key, requested, resolved: null });
+                throw new WorkbenchStringsError("missing_string", `${key} is missing in ${requested} and in the base, ${base}`);
+            }
+            if (found.from !== requested)
+                onMissing({ key, requested, resolved: found.from });
+            for (const ph of placeholdersOf(found.message)) {
+                const name = ph.replace(/#plural$/, "");
+                if (values?.[name] == null)
+                    throw new WorkbenchStringsError("missing_value", `${key} needs {${name}}`);
+            }
+            return formatMessage(found.message, requested, values);
+        },
+        recipientLocale: (saved) => (saved != null && chains.has(saved) ? saved : base),
+        detect(request, opts = {}) {
+            const url = new URL(request.url);
+            const cf = request.cf;
+            return resolveLocale({
+                prefix: strings.localeFromPath(url.pathname)?.locale,
+                cookie: readLocaleCookie(request.headers.get("cookie")),
+                account: opts.account,
+                country: typeof cf?.country === "string" ? cf.country : undefined,
+                acceptLanguage: request.headers.get("accept-language"),
+            }, rules);
+        },
+        localeFromPath(pathname) {
+            const m = /^\/([^/]+)(\/.*)?$/.exec(pathname);
+            const locale = m ? byPrefix.get(m[1].toLowerCase()) : undefined;
+            return locale ? { locale, rest: m[2] ?? "/" } : null;
+        },
+        cookie: (l) => (chains.has(l) ? localeCookie(l) : invalid(`${l} is not a live locale`)),
+    };
+    return Object.freeze(strings);
+}

package/dist/testing.d.ts

@@ -0,0 +1,25 @@
+import { type StringsCheck } from "./checks.ts";
+import { type Strings } from "./strings.ts";
+export type { StringsCheck } from "./checks.ts";
+export interface StringsKitOptions {
+    /** The app's defineStrings result. */
+    strings: Strings<string>;
+    /** Raw text of every authored file, strings/strings.<locale>.json, by locale. */
+    authored: Readonly<Record<string, string>>;
+    /** Raw text of every generated file, strings/runtime/strings.<locale>.json, by locale (no base). */
+    runtime: Readonly<Record<string, string>>;
+    /** The app's source files' text, for the dead-key sweep. */
+    sources: readonly string[] | Readonly<Record<string, string>>;
+    /** The app's emails and their parts, from its email catalogue (`[]` for none). Their `email.<name>.<part>` keys are checked against this, not the sources. */
+    emails: readonly {
+        name: string;
+        parts: readonly string[];
+    }[];
+    /** Other key prefixes built at run time, e.g. "validation." for workbench-forms or "enum.status.". Never swept as dead. */
+    composed?: readonly string[];
+    /** Each locale's expected fallback chain, pinned by the app. Required when it sets `parents`. */
+    chains?: Readonly<Record<string, readonly string[]>>;
+    /** Words the brand voice forbids, per locale, matched on word boundaries. */
+    forbidden?: Readonly<Record<string, readonly string[]>>;
+}
+export declare function checkStrings(options: StringsKitOptions): StringsCheck[];

package/dist/testing.js

@@ -0,0 +1,252 @@
+// The test kit (internationalization standard §11): the standard's tests, run
+// against an app's own catalogue, configuration and code. It needs no test
+// framework; an app runs it from its own tests:
+//
+//   import { checkStrings } from '@mccaskie-labs/workbench-strings/testing'
+//   for (const check of checkStrings({ strings, authored, runtime, sources, emails }))
+//     it(check.name, () => expect(check.problems).toEqual([]))
+//
+// It takes file text rather than paths so it runs in the Workers test runtime
+// too (load the files with Vite's import.meta.glob and `?raw`).
+import { isMeta, readCatalogue } from "./catalogue.js";
+import { checkFiles } from "./checks.js";
+import { resolveLocale } from "./detect.js";
+import { formatMessage, parseMessage, placeholdersOf } from "./format.js";
+import { NAMESPACES } from "./strings.js";
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export function checkStrings(options) {
+    const { strings } = options;
+    const checks = checkFiles({ base: strings.base, authored: options.authored, runtime: options.runtime });
+    const add = (name) => {
+        const c = { name, problems: [] };
+        checks.push(c);
+        return c;
+    };
+    // The files must be the ones the app runs with.
+    const files = add("Every live locale has an authored file, and no other locale does");
+    for (const l of strings.locales)
+        if (!(l in options.authored))
+            files.problems.push(`no strings.${l}.json`);
+    for (const l of Object.keys(options.authored)) {
+        if (!strings.locales.includes(l)) {
+            files.problems.push(strings.planned.includes(l) ? `${l} is planned: a planned locale has no file until it goes live` : `strings.${l}.json is not a live locale`);
+        }
+    }
+    let baseCat = {};
+    try {
+        baseCat = readCatalogue(options.authored[strings.base] ?? "{}", strings.base);
+    }
+    catch {
+        // Reported by the file checks.
+    }
+    const baseKeys = Object.keys(baseCat).filter((k) => !isMeta(k));
+    // The strings under test must be built from these files.
+    const tied = add("defineStrings was given these files: the base and every generated catalogue");
+    if (JSON.stringify(Object.entries(strings.catalogue(strings.base))) !== JSON.stringify(Object.entries(baseCat))) {
+        tied.problems.push(`the base passed to defineStrings is not strings.${strings.base}.json`);
+    }
+    for (const l of strings.locales.filter((x) => x !== strings.base)) {
+        try {
+            const rc = readCatalogue(options.runtime[l] ?? "{}", l);
+            if (JSON.stringify(Object.entries(strings.catalogue(l))) !== JSON.stringify(Object.entries(rc))) {
+                tied.problems.push(`the ${l} catalogue passed to defineStrings is not runtime/strings.${l}.json`);
+            }
+        }
+        catch {
+            // Reported by the file checks.
+        }
+    }
+    const ns = add(`Every key starts with a declared name group (${NAMESPACES.join(", ")})`);
+    for (const k of baseKeys) {
+        const group = k.split(".")[0];
+        if (!NAMESPACES.includes(group) || k.split(".").length < 2)
+            ns.problems.push(k);
+    }
+    // Email keys: checked against the declared emails, the only thing that can.
+    const emails = add("Email words: every declared email part exists, and no email key is undeclared");
+    const declared = new Set(options.emails.flatMap((e) => e.parts.map((p) => `email.${e.name}.${p}`)));
+    for (const k of declared)
+        if (!(k in baseCat))
+            emails.problems.push(`${k} is missing from the base`);
+    for (const k of baseKeys)
+        if (k.startsWith("email.") && !declared.has(k))
+            emails.problems.push(`${k} belongs to no declared email`);
+    // Dead keys and unknown keys, matched exactly on quotes, never by substring.
+    const sources = Array.isArray(options.sources) ? options.sources : Object.values(options.sources);
+    const text = sources.join("\n");
+    const notCatalogue = add("The sources hold no catalogue file (its keys would vouch for themselves)");
+    sources.forEach((src, i) => {
+        if (/"_review\.status"\s*:/.test(src) || baseKeys.some((k) => src.includes(`"${k}":`))) {
+            notCatalogue.problems.push(`source ${Array.isArray(options.sources) ? i : Object.keys(options.sources)[i]} looks like a catalogue file`);
+        }
+    });
+    const composed = ["email.", ...(options.composed ?? [])];
+    const dead = add("Dead-key sweep: every base key is used by the app's code");
+    for (const k of baseKeys) {
+        if (composed.some((p) => k.startsWith(p)))
+            continue;
+        if (!new RegExp(`(["'\`])${escape(k)}\\1`).test(text))
+            dead.problems.push(`${k} is used nowhere`);
+    }
+    const unknown = add("Every key the code names exists in the base");
+    const groups = NAMESPACES.join("|");
+    const keyLiteral = new RegExp(`(["'\`])((?:${groups})\\.[A-Za-z0-9_.-]+)\\1`, "g");
+    const known = new Set(baseKeys);
+    for (const m of text.matchAll(keyLiteral)) {
+        const k = m[2];
+        const fileName = /\.(ts|tsx|js|mjs|json|css|html|astro|md)$/.test(k);
+        if (!known.has(k) && !fileName && !composed.some((p) => k.startsWith(p)) && !k.endsWith(".")) {
+            unknown.problems.push(`${k} is not in the base`);
+        }
+    }
+    unknown.problems = [...new Set(unknown.problems)];
+    // The voice: forbidden words on word boundaries, so a short particle inside a longer word passes.
+    const voice = add("Voice: no locale uses a word the brand voice forbids");
+    for (const [l, banned] of Object.entries(options.forbidden ?? {})) {
+        if (!(l in options.authored)) {
+            voice.problems.push(`forbidden names ${l}, which has no authored file`);
+            continue;
+        }
+        let cat;
+        try {
+            cat = readCatalogue(options.authored[l], l);
+        }
+        catch {
+            continue;
+        }
+        for (const w of banned) {
+            const re = new RegExp(`(?<![\\p{L}\\p{N}])${escape(w)}(?![\\p{L}\\p{N}])`, "iu");
+            for (const [k, v] of Object.entries(cat)) {
+                // Placeholder names are not words the reader sees.
+                const words = v.replace(/\{\s*[A-Za-z_][A-Za-z0-9_]*\s*(?=[,}])/g, "{");
+                if (!isMeta(k) && re.test(words))
+                    voice.problems.push(`${l} ${k} uses "${w}"`);
+            }
+        }
+    }
+    // The chain, as the app pinned it: a register must go through its parent.
+    const chain = add("Chain shape: each locale falls back as the app pinned it, ending at the base");
+    if (Object.keys(strings.parents).length && !options.chains)
+        chain.problems.push("the app sets parents, so pin each locale's chain in chains");
+    for (const [l, want] of Object.entries(options.chains ?? {})) {
+        if (!strings.locales.includes(l)) {
+            chain.problems.push(`chains names ${l}, which is not live`);
+            continue;
+        }
+        const got = strings.chain(l);
+        if (got.join(" -> ") !== want.join(" -> "))
+            chain.problems.push(`${l}: ${got.join(" -> ")}, pinned ${want.join(" -> ")}`);
+    }
+    // Detection, with this app's rules.
+    const det = detectionChecks(strings);
+    checks.push(...det);
+    const plurals = add("Plural by CLDR category: every plural string renders in every locale for 0, 1, 2 and 5");
+    for (const l of strings.locales) {
+        for (const k of baseKeys) {
+            let message;
+            try {
+                message = parseMessage(baseCat[k]);
+            }
+            catch {
+                continue;
+            }
+            const names = placeholdersOf(message);
+            if (!names.some((n) => n.endsWith("#plural")))
+                continue;
+            for (const n of [0, 1, 2, 5]) {
+                const values = Object.fromEntries(names.map((x) => [x.replace(/#plural$/, ""), x.endsWith("#plural") ? n : "x"]));
+                const out = strings.t(l, k, values);
+                if (/\{[A-Za-z_]/.test(out))
+                    plurals.problems.push(`${l} ${k} with ${n}: "${out}"`);
+            }
+        }
+    }
+    const intl = add("Unknown locale survives: formatting in every locale, planned ones too, does not throw");
+    const sample = parseMessage("{n, plural, =0 {none} one {# one} other {# other}} {x}");
+    for (const l of [...strings.locales, ...strings.planned]) {
+        try {
+            formatMessage(sample, l, { n: 2, x: "y" });
+        }
+        catch (e) {
+            intl.problems.push(`${l}: ${e.message}`);
+        }
+    }
+    return checks;
+}
+function detectionChecks(strings) {
+    const rules = strings.rules;
+    const all = { ...rules, reviewed: () => true };
+    const out = [];
+    const check = (name, fn) => {
+        const problems = [];
+        fn(problems);
+        out.push({ name, problems });
+    };
+    const expectLocale = (p, what, signals, r, want) => {
+        const got = resolveLocale(signals, r).locale;
+        if (got !== want)
+            p.push(`${what}: got ${got}, expected ${want}`);
+    };
+    const [a, b] = [strings.locales[0], strings.locales.find((l) => l !== strings.locales[0]) ?? strings.locales[0]];
+    const countryFor = (l) => Object.entries(rules.countries).find(([, v]) => v === l)?.[0];
+    check("Resolution precedence: prefix > cookie > account > country > header > default", (p) => {
+        const ladder = ["prefix", "cookie", "account", "country", "acceptLanguage"];
+        for (let i = 0; i < ladder.length - 1; i++) {
+            for (const [hi, lo] of [[a, b], [b, a]]) {
+                if (hi === lo)
+                    continue;
+                const signals = { [ladder[i]]: hi, [ladder[i + 1]]: lo };
+                if (ladder[i] === "country")
+                    signals.country = countryFor(hi);
+                if (ladder[i + 1] === "country")
+                    signals.country = countryFor(lo);
+                if (signals.country === undefined && (ladder[i] === "country" || ladder[i + 1] === "country"))
+                    continue;
+                expectLocale(p, `${ladder[i]} ${hi} over ${ladder[i + 1]} ${lo}`, signals, all, hi);
+            }
+        }
+        expectLocale(p, "no signal at all", {}, all, rules.defaultLocale);
+    });
+    check("Geo beats header: a local visitor whose phone reports another language gets the local locale", (p) => {
+        for (const [country, l] of Object.entries(rules.countries)) {
+            const other = strings.locales.find((x) => x !== l);
+            if (other)
+                expectLocale(p, `country ${country}, header ${other}`, { country, acceptLanguage: other }, all, l);
+        }
+    });
+    check("Unknown country falls through to the header, never to the base", (p) => {
+        for (const l of strings.locales) {
+            for (const country of ["XX", "T1", undefined]) {
+                expectLocale(p, `country ${country ?? "absent"}, header ${l}`, { country, acceptLanguage: l }, all, l);
+            }
+        }
+        expectLocale(p, "country XX, no header", { country: "XX" }, all, rules.defaultLocale);
+    });
+    check("A known country with no locale and no usable header gets the base", (p) => {
+        const elsewhere = ["AQ", "QM", "GL"].find((c) => !(c in rules.countries));
+        if (elsewhere)
+            expectLocale(p, `country ${elsewhere}`, { country: elsewhere }, all, strings.base);
+    });
+    check("Quality weights honoured: Accept-Language sorted by q, not first tag wins", (p) => {
+        if (a !== b)
+            expectLocale(p, `${b};q=0.4, ${a};q=0.9`, { acceptLanguage: `${b};q=0.4, ${a};q=0.9` }, all, a);
+    });
+    check("Old and other tags accepted (aliases)", (p) => {
+        for (const [tag, l] of Object.entries(rules.aliases))
+            expectLocale(p, `header ${tag}`, { acceptLanguage: tag }, all, l);
+    });
+    check("Gate armed: an unreviewed locale is never inferred, and a chosen one is still served", (p) => {
+        for (const l of strings.locales.filter((x) => !strings.reviewed(x))) {
+            const country = countryFor(l);
+            if (country)
+                expectLocale(p, `country ${country}`, { country }, rules, strings.base);
+            expectLocale(p, `header ${l}`, { acceptLanguage: l }, rules, strings.base);
+            if (rules.defaultLocale === l)
+                expectLocale(p, "default", {}, rules, strings.base);
+            expectLocale(p, `prefix ${l}`, { prefix: l }, rules, l);
+            expectLocale(p, `cookie ${l}`, { cookie: l }, rules, l);
+            expectLocale(p, `account ${l}`, { account: l }, rules, l);
+        }
+    });
+    return out;
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@mccaskie-labs/workbench-strings",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "The words an app's own screens and emails say: one file per language, named placeholders and plurals, one fallback chain, language detection, the translation review gate and a test kit. Server only.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mccaskie-labs/workbench.git",
+    "directory": "packages/strings"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "sideEffects": [
+    "./dist/browser.js"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "workerd": "./dist/index.js",
+      "worker": "./dist/index.js",
+      "node": "./dist/index.js",
+      "browser": "./dist/browser.js",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "workbench-strings": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.check.json && tsc -p test/tsconfig.json",
+    "test": "vitest run",
+    "build": "node scripts/build.mjs",
+    "prepack": "node scripts/build.mjs"
+  },
+  "dependencies": {
+    "@mccaskie-labs/workbench-config": "^0.1.14"
+  },
+  "peerDependencies": {
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "vitest": "^5.1.0",
+    "zod": "4.6.7"
+  }
+}