@babelize/engine 0.0.0-stage → 0.1.2

package/dist/utils/ui-copy.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATA_KEYS = exports.UI_COPY_KEYS = void 0;
+exports.isMultiWordCopy = isMultiWordCopy;
+exports.looksLikeCopy = looksLikeCopy;
+exports.isUiCopyForName = isUiCopyForName;
+exports.isUiCopyLiteral = isUiCopyLiteral;
+const t = __importStar(require("@babel/types"));
+/**
+ * UI copy vs program data in object / array / variable initializers.
+ *
+ * `const user = { name: "Ada" }` is data: translating it rewrites a user's
+ * name (`{ name: t("page.ada") }`). `[{ label: "Home", href: "/" }]` holds UI
+ * copy under `label` and data under `href`. A string in an initializer is
+ * only extracted when its key says it's copy, or (without a telling key) when
+ * it looks like copy: a sentence, a Title Case phrase or a capitalized word.
+ * Both lists match the key's last camelCase word (`buttonLabel` → label,
+ * `firstName` → name) or the whole key, case-insensitively, and can be
+ * extended by callers.
+ */
+exports.UI_COPY_KEYS = new Set([
+    'label', 'title', 'description', 'placeholder', 'text', 'message', 'heading', 'subheading', 'headline', 'subtitle',
+    'tooltip', 'cta', 'alt', 'arialabel', 'caption', 'hint', 'help', 'helptext', 'summary', 'body', 'question',
+    'answer', 'notice', 'error', 'success', 'warning', 'confirm', 'prompt', 'greeting', 'tagline', 'blurb', 'excerpt',
+]);
+exports.DATA_KEYS = new Set([
+    'name', 'id', 'key', 'email', 'username', 'slug', 'url', 'href', 'src', 'path', 'type', 'value', 'code', 'locale',
+    'lang', 'language', 'classname', 'class', 'variant', 'color', 'colour', 'icon', 'date', 'currency', 'size', 'status',
+    'role', 'method', 'format', 'mode', 'theme', 'target', 'rel', 'route', 'to', 'link', 'ref', 'uuid', 'token',
+    'phone', 'address', 'image', 'avatar', 'file', 'filename', 'extension', 'mime', 'kind', 'timezone', 'country',
+    'handle', 'domain', 'host', 'endpoint', 'version', 'sku', 'hash', 'secret', 'password', 'field', 'event', 'action',
+    'user', 'author', 'owner', 'customer', 'company', 'brand', 'city', 'state', 'zip', 'region',
+]);
+function words(name) {
+    return name.split(/(?=[A-Z])|[-_\s]/).filter(Boolean).map((w) => w.toLowerCase());
+}
+/** Two or more words with letters: reads like copy, not an identifier. */
+function isMultiWordCopy(text) {
+    return text.trim().split(/\s+/).filter((w) => /\p{L}/u.test(w)).length >= 2;
+}
+/**
+ * Copy without a key to say so: a sentence or Title Case phrase, or a single
+ * capitalized word ("Overview", "Settings"). Data looks different: lowercase
+ * tokens ("active"), kebab/snake/camelCase, ALLCAPS, or anything with digits,
+ * underscores, slashes or dots in a single token.
+ */
+function looksLikeCopy(text) {
+    const trimmed = text.trim();
+    if (isMultiWordCopy(trimmed))
+        return true;
+    return /^\p{Lu}\p{Ll}+[!?.:…]?$/u.test(trimmed);
+}
+/** Whether a string stored under `name` (a key or a variable) is UI copy. */
+function isUiCopyForName(name, text) {
+    if (name) {
+        const parts = words(name);
+        const last = parts[parts.length - 1] ?? '';
+        const full = name.toLowerCase().replace(/[-_]/g, '');
+        if (exports.UI_COPY_KEYS.has(last) || exports.UI_COPY_KEYS.has(full))
+            return true;
+        if (exports.DATA_KEYS.has(last) || exports.DATA_KEYS.has(full))
+            return false;
+    }
+    return looksLikeCopy(text);
+}
+function keyName(key) {
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    return null;
+}
+/**
+ * For a string literal in an object property value, array element or
+ * variable/assignment initializer: is it UI copy? Other positions (JSX,
+ * returns, conditionals, …) aren't initializers and are left as they are.
+ */
+function isUiCopyLiteral(node, parent, text) {
+    if (!parent)
+        return true;
+    if (t.isObjectProperty(parent) && parent.value === node)
+        return isUiCopyForName(parent.computed ? null : keyName(parent.key), text);
+    if (t.isVariableDeclarator(parent) && parent.init === node)
+        return isUiCopyForName(t.isIdentifier(parent.id) ? parent.id.name : null, text);
+    if (t.isAssignmentExpression(parent) && parent.right === node) {
+        const left = parent.left;
+        const name = t.isIdentifier(left) ? left.name : t.isMemberExpression(left) && !left.computed && t.isIdentifier(left.property) ? left.property.name : null;
+        return isUiCopyForName(name, text);
+    }
+    if (t.isArrayExpression(parent))
+        return looksLikeCopy(text);
+    return true;
+}

package/dist/utils/untranslated.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Detects source text that came back from translation unchanged.
+ *
+ * Into a Latin-script language an unchanged short string can be a real
+ * translation ("Hotel", "Email"). Into a non-Latin-script language, English
+ * letters returned verbatim were not translated. Such values must be rejected
+ * when the translator returns them AND when a cache or TM lookup does: once
+ * stored, a bad value would otherwise be replayed on every run and never retried.
+ */
+/** Is the locale written in Latin script (where an unchanged word can be a real translation)? */
+export declare function isLatinScript(locale: string): boolean;
+/** Letters left once placeholders, tags and entities are removed. */
+export declare function hasWords(text: string | undefined): boolean;
+/** `translated` is the untouched source, into a language where that cannot be a translation. */
+export declare function isUntranslatedInto(source: string, translated: string, targetLocale: string): boolean;

package/dist/utils/untranslated.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Detects source text that came back from translation unchanged.
+ *
+ * Into a Latin-script language an unchanged short string can be a real
+ * translation ("Hotel", "Email"). Into a non-Latin-script language, English
+ * letters returned verbatim were not translated. Such values must be rejected
+ * when the translator returns them AND when a cache or TM lookup does: once
+ * stored, a bad value would otherwise be replayed on every run and never retried.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLatinScript = isLatinScript;
+exports.hasWords = hasWords;
+exports.isUntranslatedInto = isUntranslatedInto;
+/** Is the locale written in Latin script (where an unchanged word can be a real translation)? */
+function isLatinScript(locale) {
+    try {
+        return new Intl.Locale(locale).maximize().script === 'Latn';
+    }
+    catch {
+        return true;
+    }
+}
+/** Letters left once placeholders, tags and entities are removed. */
+function hasWords(text) {
+    if (!text)
+        return false;
+    const stripped = text.replace(/%\(\w+\)[-#0 +]*\d*(?:\.\d+)?[a-zA-Z]|%[sdif%]|\{[^{}]*\}|<[^>]*>|&[#\w]+;|\[\s*#\s*VAR_\d+\s*#\s*\]/gi, ' ');
+    return /\p{L}{2,}/u.test(stripped);
+}
+/** `translated` is the untouched source, into a language where that cannot be a translation. */
+function isUntranslatedInto(source, translated, targetLocale) {
+    return !isLatinScript(targetLocale) && translated.trim() === source.trim() && hasWords(source);
+}

package/dist/utils/workspace.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Remove stale locale files from the workspace that are NOT in the target locale list.
+ *
+ * When a project is re-run with changed languages, old locale files from previous
+ * runs persist because `git reset --hard` only resets tracked files and generated
+ * locale files are untracked. This function cleans them up.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param targetLocales - Current list of target locale codes (e.g., ['fr', 'de'])
+ * @param sourceLocale - Source locale code (e.g., 'en') — always preserved
+ * @param localeFormat - Output format ('json' | 'po' | 'arb')
+ * @param publicDir - Public directory relative to workspace (e.g., 'public')
+ */
+export declare function removeStaleLocales(workspacePath: string, targetLocales: string[], sourceLocale: string, localeFormat?: string, publicDir?: string): Promise<void>;

package/dist/utils/workspace.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeStaleLocales = removeStaleLocales;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("./file-utils");
+const logger_1 = require("./logger");
+/**
+ * Remove stale locale files from the workspace that are NOT in the target locale list.
+ *
+ * When a project is re-run with changed languages, old locale files from previous
+ * runs persist because `git reset --hard` only resets tracked files and generated
+ * locale files are untracked. This function cleans them up.
+ *
+ * @param workspacePath - Path to the workspace directory
+ * @param targetLocales - Current list of target locale codes (e.g., ['fr', 'de'])
+ * @param sourceLocale - Source locale code (e.g., 'en') — always preserved
+ * @param localeFormat - Output format ('json' | 'po' | 'arb')
+ * @param publicDir - Public directory relative to workspace (e.g., 'public')
+ */
+async function removeStaleLocales(workspacePath, targetLocales, sourceLocale, localeFormat = 'json', publicDir = 'public') {
+    // Django uses locale/<lang>/LC_MESSAGES/ — skip stale locale removal for PO format
+    if (localeFormat === 'po')
+        return;
+    const localesDir = path.join(workspacePath, publicDir, 'locales');
+    if (!(await fs.pathExists(localesDir))) {
+        return;
+    }
+    const ext = (0, file_utils_1.localeExtension)(localeFormat);
+    const allowedLocales = new Set([sourceLocale, ...targetLocales]);
+    try {
+        const entries = await fs.readdir(localesDir);
+        let removedCount = 0;
+        for (const entry of entries) {
+            if (!entry.endsWith(ext))
+                continue;
+            const localeCode = entry.replace(ext, '');
+            if (!allowedLocales.has(localeCode)) {
+                const filePath = path.join(localesDir, entry);
+                await fs.remove(filePath);
+                removedCount++;
+                logger_1.engineLogger.debug('Removed stale locale file', { file: entry, localeCode });
+            }
+        }
+        if (removedCount > 0) {
+            logger_1.engineLogger.info('Cleaned up stale locale files', {
+                removedCount,
+                keptLocales: [...allowedLocales],
+                workspacePath,
+            });
+        }
+    }
+    catch (err) {
+        logger_1.engineLogger.warn('Failed to clean up stale locale files', { error: err, workspacePath });
+    }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@babelize/engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "Babelize translation pipeline (extract, keygen, translate, inject). Infrastructure is injected through provider/store interfaces.",
+  "keywords": [
+    "babelize",
+    "i18n",
+    "localization",
+    "translation",
+    "ast"
+  ],
+  "license": "Apache-2.0",
+  "homepage": "https://babelize.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/babelize/babelize-dashboard.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "schemas"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "jest",
+    "prepublishOnly": "npm run build && npm test && npm run typecheck"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.29.8",
+    "@babelize/types": "^0.1.2",
+    "@vue/compiler-dom": "^3.5",
+    "@vue/compiler-sfc": "^3.5",
+    "diff": "^8.0.4",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.3",
+    "gettext-parser": "^9.1.1",
+    "magic-string": "^0.30",
+    "node-html-parser": "^8.0.4",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@jest/globals": "^30.3.0",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "ajv": "^8.17.1",
+    "eslint": "^9.39.2",
+    "intl-messageformat": "^10.7.16",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.53.1"
+  }
+}

package/schemas/translate-report.schema.json

@@ -0,0 +1,297 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://babelize.co/schemas/translate-report.v1.json",
+  "title": "Babelize translate report",
+  "description": "What `babelize translate --json` prints and `.babelize/local/report.json` contains (TranslateReport in @babelize/engine). Every per-key list is complete.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "$schema", "schemaVersion", "ok", "startedAt", "finishedAt", "durationMs", "framework", "frameworkStatus",
+    "provider", "sourceLocale", "targetLocales", "keptLocales", "droppedLocales", "dryRun", "applied",
+    "filesChanged", "diffSummary", "stats", "summary", "locales", "failures", "qaWarnings", "missing",
+    "unchanged", "notInjected", "unusedKeys", "dynamicKeyFiles", "keys", "warnings", "notes", "engineLog",
+    "lockfile", "lockfileIgnored"
+  ],
+  "properties": {
+    "$schema": { "type": "string" },
+    "schemaVersion": { "const": 1 },
+    "ok": { "type": "boolean", "description": "False when any key failed (the run is partial; the CLI exits 6)." },
+    "startedAt": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$" },
+    "finishedAt": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$" },
+    "durationMs": { "type": "number", "minimum": 0 },
+    "framework": { "type": "string" },
+    "frameworkStatus": { "enum": ["supported", "beta"] },
+    "provider": {
+      "oneOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["provider", "name"],
+          "properties": {
+            "provider": { "type": "string" },
+            "name": { "type": "string" },
+            "model": { "type": "string" }
+          }
+        }
+      ]
+    },
+    "sourceLocale": { "type": "string" },
+    "targetLocales": { "$ref": "#/$defs/strings" },
+    "keptLocales": { "$ref": "#/$defs/strings" },
+    "droppedLocales": { "$ref": "#/$defs/strings" },
+    "dryRun": { "type": "boolean" },
+    "applied": { "type": "boolean" },
+    "filesChanged": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["added", "modified", "deleted"],
+      "properties": {
+        "added": { "$ref": "#/$defs/strings" },
+        "modified": { "$ref": "#/$defs/strings" },
+        "deleted": { "$ref": "#/$defs/strings" }
+      }
+    },
+    "diffSummary": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["file", "kind", "added", "removed"],
+        "properties": {
+          "file": { "type": "string" },
+          "kind": { "enum": ["added", "modified", "deleted"] },
+          "added": { "$ref": "#/$defs/count" },
+          "removed": { "$ref": "#/$defs/count" }
+        }
+      }
+    },
+    "diff": { "type": "string", "description": "Unified diff; dry runs only." },
+    "stats": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["filesScanned", "stringsExtracted", "keysExtracted", "injectionsApplied", "keysFromLockfile", "keysSentToTranslator"],
+      "properties": {
+        "filesScanned": { "$ref": "#/$defs/count" },
+        "stringsExtracted": { "$ref": "#/$defs/count" },
+        "keysExtracted": { "$ref": "#/$defs/count" },
+        "injectionsApplied": { "$ref": "#/$defs/count" },
+        "keysFromLockfile": { "$ref": "#/$defs/count" },
+        "keysSentToTranslator": { "$ref": "#/$defs/count" },
+        "translatedThisRun": { "$ref": "#/$defs/count" }
+      }
+    },
+    "summary": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["sourceKeys", "translations", "newTranslations", "reused", "failed", "qaWarnings", "missing", "unchanged", "notInjected"],
+      "properties": {
+        "sourceKeys": { "$ref": "#/$defs/count" },
+        "translations": { "$ref": "#/$defs/count" },
+        "newTranslations": { "$ref": "#/$defs/count" },
+        "reused": { "$ref": "#/$defs/count" },
+        "failed": { "$ref": "#/$defs/count" },
+        "qaWarnings": { "$ref": "#/$defs/count" },
+        "missing": { "$ref": "#/$defs/count" },
+        "unchanged": { "$ref": "#/$defs/count" },
+        "notInjected": { "$ref": "#/$defs/count" }
+      }
+    },
+    "locales": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["locale", "status", "total", "translated", "missing", "failed", "qaWarnings", "sameAsSource"],
+        "properties": {
+          "locale": { "type": "string" },
+          "status": { "enum": ["ok", "warning", "failed"] },
+          "total": { "$ref": "#/$defs/count" },
+          "translated": { "$ref": "#/$defs/count" },
+          "missing": { "$ref": "#/$defs/count" },
+          "failed": { "$ref": "#/$defs/count" },
+          "qaWarnings": { "$ref": "#/$defs/count" },
+          "sameAsSource": { "$ref": "#/$defs/count" }
+        }
+      }
+    },
+    "failures": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["locale", "key", "source", "reason", "retryable"],
+            "properties": {
+              "locale": { "type": "string" },
+              "key": { "type": "string" },
+              "source": { "type": "string" },
+              "reason": { "$ref": "#/$defs/failureReason" },
+              "retryable": { "type": "boolean" },
+              "message": { "type": "string" }
+            }
+          }
+        }
+      }
+    },
+    "qaWarnings": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["locale", "key", "warnings"],
+            "properties": {
+              "locale": { "type": "string" },
+              "key": { "type": "string" },
+              "warnings": { "$ref": "#/$defs/strings" }
+            }
+          }
+        }
+      }
+    },
+    "missing": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["locale", "key"],
+            "properties": { "locale": { "type": "string" }, "key": { "type": "string" } }
+          }
+        }
+      }
+    },
+    "unchanged": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["locale", "key", "value"],
+            "properties": { "locale": { "type": "string" }, "key": { "type": "string" }, "value": { "type": "string" } }
+          }
+        }
+      }
+    },
+    "notInjected": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": {
+        "items": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["file", "key", "text", "reason"],
+            "properties": {
+              "file": { "type": "string" },
+              "key": { "type": "string" },
+              "text": { "type": "string" },
+              "reason": { "type": "string" }
+            }
+          }
+        }
+      }
+    },
+    "unusedKeys": {
+      "$ref": "#/$defs/list",
+      "type": "object",
+      "properties": { "items": { "$ref": "#/$defs/strings" } }
+    },
+    "dynamicKeyFiles": { "$ref": "#/$defs/strings" },
+    "keys": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["key", "source", "locales"],
+        "properties": {
+          "key": { "type": "string" },
+          "source": { "type": "string" },
+          "locales": {
+            "type": "object",
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["status"],
+              "properties": {
+                "status": { "enum": ["translated", "warning", "unchanged", "failed", "missing"] },
+                "value": { "type": "string" },
+                "reason": { "$ref": "#/$defs/failureReason" },
+                "message": { "type": "string" },
+                "retryable": { "type": "boolean" },
+                "warnings": { "$ref": "#/$defs/strings" }
+              }
+            }
+          }
+        }
+      }
+    },
+    "warnings": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["type", "file", "message"],
+        "properties": {
+          "type": { "type": "string" },
+          "file": { "type": "string" },
+          "line": { "type": "number" },
+          "message": { "type": "string" }
+        }
+      }
+    },
+    "notes": { "$ref": "#/$defs/strings" },
+    "engineLog": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["level", "message"],
+        "properties": { "level": { "enum": ["warn", "error"] }, "message": { "type": "string" } }
+      }
+    },
+    "formatter": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["tool", "files", "ok"],
+      "properties": {
+        "tool": { "enum": ["prettier", "biome"] },
+        "files": { "$ref": "#/$defs/strings" },
+        "ok": { "type": "boolean" },
+        "message": { "type": "string" }
+      }
+    },
+    "lockfile": { "type": "string" },
+    "lockfileIgnored": { "type": "boolean" }
+  },
+  "$defs": {
+    "count": { "type": "integer", "minimum": 0 },
+    "strings": { "type": "array", "items": { "type": "string" } },
+    "list": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["total", "items"],
+      "properties": { "total": { "type": "integer", "minimum": 0 }, "items": { "type": "array" } }
+    },
+    "failureReason": {
+      "enum": [
+        "missing_from_response", "empty_value", "placeholder_lost", "untranslated", "icu_invalid",
+        "markup_mismatch", "unsupported_by_provider", "provider_error"
+      ]
+    }
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.