@podosoft/podokit 0.11.2 → 0.12.0

package/README.md

@@ -11,11 +11,13 @@ npx @podosoft/podokit create my-app
 cd my-app
 npm install
 cp .env.example .env
-npm run dev
+npx @podosoft/podokit dev watch
 ```
 
-- API: http://localhost:5002 (health at `/health`)
-- Web: http://localhost:5001
+Open **http://my-app.localhost**. The first project starts one user-level
+Traefik gateway on loopback port 80; later projects reuse it and route by
+hostname. Stop this project with `npx @podosoft/podokit dev down`. The traditional
+`npm run dev` loop remains available on web port 5001 and API port 5002.
 
 When run in a terminal, `podo create` lists the templates with descriptions and asks which one (and which package manager) to use. Pass flags (or `--yes`) to skip the prompts.
 
@@ -32,8 +34,10 @@ The `todo` template (`--template todo`) generates a working todo app (SvelteKit
 | `podo status` | Show the PodoKit version, modules, file tiers, and local edits |
 | `podo diff` | List the PodoKit-managed files you've edited since generation |
 | `podo doctor` | Check framework versions against the supported ranges |
+| `podo locale <command>` | Add, validate, activate, deactivate, or list JSON locales |
 | `podo update [--apply]` | Preview (or apply) what a version update would change |
 | `podo eject <path…>` | Take ownership of a managed file so updates skip it |
+| `podo dev <action>` | Watch, inspect, execute in, or stop a container stack behind the shared `*.localhost` gateway |
 
 ## Usage
 

package/dist/dev.d.ts

@@ -0,0 +1,26 @@
+export interface DevConfig {
+    schemaVersion: 1;
+    hostname: string;
+    publicUrl?: string;
+}
+export interface DevRuntime {
+    alias: string;
+    config: DevConfig;
+    projectRoot: string;
+    routeId: string;
+    runtimeComposePath: string;
+}
+interface CommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+export type CommandRunner = (command: string, args: string[], options: {
+    capture: boolean;
+}) => CommandResult;
+export declare function readDevConfig(projectRoot: string): DevConfig;
+export declare function resolveDevRuntime(projectRoot: string): DevRuntime;
+export declare function renderRuntimeCompose(runtime: DevRuntime): string;
+export declare function renderRoute(runtime: DevRuntime): string;
+export declare function runDevCommand(projectRoot: string, action: string | undefined, args: string[], runner?: CommandRunner): void;
+export {};

package/dist/dev.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDevConfig = readDevConfig;
+exports.resolveDevRuntime = resolveDevRuntime;
+exports.renderRuntimeCompose = renderRuntimeCompose;
+exports.renderRoute = renderRoute;
+exports.runDevCommand = runDevCommand;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const lockfile_1 = require("./lockfile");
+const GATEWAY_CONTAINER = "podokit-dev-gateway";
+const GATEWAY_IMAGE = "traefik:v3.5";
+const GATEWAY_LABEL = "io.podosoft.podokit.dev-gateway";
+const GATEWAY_NETWORK = "podokit-dev-gateway";
+const RUNTIME_COMPOSE = ".podokit/runtime/dev.compose.yaml";
+const DEV_CONFIG = ".podokit/dev.json";
+function defaultRunner(command, args, options) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        encoding: "utf8",
+        stdio: options.capture ? "pipe" : "inherit",
+    });
+    if (result.error)
+        throw result.error;
+    return {
+        status: result.status,
+        stdout: options.capture ? (result.stdout ?? "") : "",
+        stderr: options.capture ? (result.stderr ?? "") : "",
+    };
+}
+function parseJson(path) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Cannot read ${path}: ${error.message}`);
+    }
+}
+function validateHostname(hostname) {
+    if (hostname.length > 253 ||
+        !hostname.endsWith(".localhost") ||
+        !/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?\.localhost$/.test(hostname)) {
+        throw new Error(`Invalid development hostname "${hostname}". Use a lowercase *.localhost hostname without a scheme or port.`);
+    }
+}
+function validatePublicUrl(publicUrl) {
+    let parsed;
+    try {
+        parsed = new URL(publicUrl);
+    }
+    catch {
+        throw new Error(`Invalid publicUrl "${publicUrl}". Use an absolute HTTPS URL.`);
+    }
+    if (parsed.protocol !== "https:" || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+        throw new Error(`Invalid publicUrl "${publicUrl}". Use an HTTPS origin without a path.`);
+    }
+}
+function readDevConfig(projectRoot) {
+    const path = (0, node_path_1.join)(projectRoot, DEV_CONFIG);
+    const manifest = (0, lockfile_1.readManifest)(projectRoot);
+    if (!manifest)
+        throw new Error("Not a PodoKit project: .podokit/manifest.json is missing.");
+    const fallbackName = manifest.answers.projectName;
+    if (!fallbackName)
+        throw new Error("PodoKit manifest is missing answers.projectName.");
+    const config = (0, node_fs_1.existsSync)(path)
+        ? parseJson(path)
+        : { schemaVersion: 1, hostname: `${fallbackName}.localhost` };
+    if (config.schemaVersion !== 1) {
+        throw new Error(`Unsupported ${DEV_CONFIG} schemaVersion: ${String(config.schemaVersion)}`);
+    }
+    validateHostname(config.hostname);
+    if (config.publicUrl)
+        validatePublicUrl(config.publicUrl);
+    return config;
+}
+function stableId(projectRoot) {
+    return (0, node_crypto_1.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 10);
+}
+function slug(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+    return normalized.slice(0, 36) || "app";
+}
+function resolveDevRuntime(projectRoot) {
+    const root = (0, node_path_1.resolve)(projectRoot);
+    const config = readDevConfig(root);
+    const id = stableId(root);
+    const projectSlug = slug(config.hostname.replace(/\.localhost$/, ""));
+    return {
+        alias: `podokit-${projectSlug}-${id}`,
+        config,
+        projectRoot: root,
+        routeId: `route-${projectSlug}-${id}`,
+        runtimeComposePath: (0, node_path_1.join)(root, RUNTIME_COMPOSE),
+    };
+}
+function renderRuntimeCompose(runtime) {
+    return `# Generated by podo dev. Do not edit.\nservices:\n  traefik:\n    profiles: [podokit-legacy-proxy]\n  web:\n    networks:\n      ${GATEWAY_NETWORK}:\n        aliases: [${runtime.alias}]\nnetworks:\n  ${GATEWAY_NETWORK}:\n    external: true\n    name: ${GATEWAY_NETWORK}\n`;
+}
+function renderRoute(runtime) {
+    const { alias, config, routeId } = runtime;
+    return `http:\n  routers:\n    ${routeId}:\n      entryPoints: [web]\n      rule: Host(\`${config.hostname}\`)\n      service: ${routeId}\n      middlewares: [${routeId}-compression]\n  services:\n    ${routeId}:\n      loadBalancer:\n        servers:\n          - url: http://${alias}:5001\n  middlewares:\n    ${routeId}-compression:\n      compress: {}\n`;
+}
+function devHome() {
+    return process.env.PODOKIT_DEV_HOME ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".podokit", "dev-gateway");
+}
+function registryDirectory() {
+    return (0, node_path_1.join)(devHome(), "projects");
+}
+function routesDirectory() {
+    return (0, node_path_1.join)(devHome(), "routes");
+}
+function registryPath(runtime) {
+    return (0, node_path_1.join)(registryDirectory(), `${runtime.routeId}.json`);
+}
+function routePath(runtime) {
+    return (0, node_path_1.join)(routesDirectory(), `${runtime.routeId}.yml`);
+}
+function activeEntries() {
+    const dir = registryDirectory();
+    if (!(0, node_fs_1.existsSync)(dir))
+        return [];
+    const entries = [];
+    for (const name of (0, node_fs_1.readdirSync)(dir).filter((entry) => entry.endsWith(".json"))) {
+        const path = (0, node_path_1.join)(dir, name);
+        const entry = parseJson(path);
+        if (!(0, node_fs_1.existsSync)(entry.projectRoot)) {
+            (0, node_fs_1.rmSync)(path, { force: true });
+            (0, node_fs_1.rmSync)((0, node_path_1.join)(routesDirectory(), `${entry.routeId}.yml`), { force: true });
+            continue;
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+function writeRuntimeFiles(runtime) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(runtime.projectRoot, ".podokit", "runtime"), { recursive: true });
+    (0, node_fs_1.writeFileSync)(runtime.runtimeComposePath, renderRuntimeCompose(runtime));
+}
+function registerRoute(runtime) {
+    const collision = activeEntries().find((entry) => entry.hostname === runtime.config.hostname && entry.projectRoot !== runtime.projectRoot);
+    if (collision) {
+        throw new Error(`Development hostname ${runtime.config.hostname} is already registered by ${collision.projectRoot}. Change .podokit/dev.json or run podo dev down there.`);
+    }
+    (0, node_fs_1.mkdirSync)(registryDirectory(), { recursive: true });
+    (0, node_fs_1.mkdirSync)(routesDirectory(), { recursive: true });
+    (0, node_fs_1.writeFileSync)(routePath(runtime), renderRoute(runtime));
+    const entry = {
+        hostname: runtime.config.hostname,
+        projectRoot: runtime.projectRoot,
+        routeId: runtime.routeId,
+    };
+    (0, node_fs_1.writeFileSync)(registryPath(runtime), `${JSON.stringify(entry, null, 2)}\n`);
+}
+function unregisterRoute(runtime) {
+    (0, node_fs_1.rmSync)(registryPath(runtime), { force: true });
+    (0, node_fs_1.rmSync)(routePath(runtime), { force: true });
+}
+function commandSucceeded(result) {
+    return result.status === 0;
+}
+function ensureDocker(runner) {
+    const result = runner("docker", ["info", "--format", "{{.ServerVersion}}"], { capture: true });
+    if (!commandSucceeded(result)) {
+        throw new Error(`Docker is not available. ${result.stderr.trim()}`.trim());
+    }
+}
+function ensureNetwork(runner) {
+    const inspect = runner("docker", ["network", "inspect", GATEWAY_NETWORK], { capture: true });
+    if (commandSucceeded(inspect))
+        return;
+    const create = runner("docker", ["network", "create", GATEWAY_NETWORK], { capture: true });
+    if (!commandSucceeded(create)) {
+        throw new Error(`Cannot create Docker network ${GATEWAY_NETWORK}: ${create.stderr.trim()}`);
+    }
+}
+function ensureGateway(runner) {
+    const inspect = runner("docker", ["inspect", "--format", `{{ index .Config.Labels \"${GATEWAY_LABEL}\" }} {{.State.Running}}`, GATEWAY_CONTAINER], { capture: true });
+    if (commandSucceeded(inspect)) {
+        const [label, running] = inspect.stdout.trim().split(/\s+/);
+        if (label !== "1") {
+            throw new Error(`Container ${GATEWAY_CONTAINER} exists but is not managed by PodoKit.`);
+        }
+        if (running !== "true") {
+            const start = runner("docker", ["start", GATEWAY_CONTAINER], { capture: true });
+            if (!commandSucceeded(start)) {
+                throw new Error(`Cannot start ${GATEWAY_CONTAINER}: ${start.stderr.trim()}`);
+            }
+        }
+        return;
+    }
+    (0, node_fs_1.mkdirSync)(routesDirectory(), { recursive: true });
+    const run = runner("docker", [
+        "run",
+        "--detach",
+        "--name",
+        GATEWAY_CONTAINER,
+        "--label",
+        `${GATEWAY_LABEL}=1`,
+        "--restart",
+        "unless-stopped",
+        "--network",
+        GATEWAY_NETWORK,
+        "--publish",
+        "127.0.0.1:80:80",
+        "--volume",
+        `${routesDirectory()}:/etc/traefik/dynamic:ro`,
+        GATEWAY_IMAGE,
+        "--providers.file.directory=/etc/traefik/dynamic",
+        "--providers.file.watch=true",
+        "--entrypoints.web.address=:80",
+        "--api.dashboard=false",
+    ], { capture: true });
+    if (!commandSucceeded(run)) {
+        throw new Error(`Cannot start the shared PodoKit gateway on 127.0.0.1:80. Stop the current port owner, then retry. ${run.stderr.trim()}`.trim());
+    }
+}
+function composeArgs(runtime, args) {
+    return ["compose", "-f", "compose.dev.yaml", "-f", runtime.runtimeComposePath, ...args];
+}
+function runCompose(runtime, args, runner) {
+    const result = runner("docker", composeArgs(runtime, args), { capture: false });
+    if (!commandSucceeded(result)) {
+        throw new Error(`docker compose ${args.join(" ")} exited with status ${String(result.status)}.`);
+    }
+}
+function composeCommand(action, args) {
+    const global = [];
+    const command = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === undefined)
+            continue;
+        if (value === "--profile") {
+            const profile = args[index + 1];
+            if (!profile)
+                throw new Error("--profile requires a value.");
+            global.push(value, profile);
+            index += 1;
+        }
+        else if (value.startsWith("--profile=")) {
+            global.push(value);
+        }
+        else {
+            command.push(value);
+        }
+    }
+    const activeProfiles = action === "down" ? ["--profile", "*"] : [];
+    return [...activeProfiles, ...global, action, ...command];
+}
+function stopGatewayWhenUnused(runner) {
+    if (activeEntries().length > 0)
+        return;
+    runner("docker", ["rm", "--force", GATEWAY_CONTAINER], { capture: true });
+    runner("docker", ["network", "rm", GATEWAY_NETWORK], { capture: true });
+}
+function runDevCommand(projectRoot, action, args, runner = defaultRunner) {
+    const runtime = resolveDevRuntime(projectRoot);
+    writeRuntimeFiles(runtime);
+    if (action === "url") {
+        process.stdout.write(`http://${runtime.config.hostname}\n`);
+        if (runtime.config.publicUrl)
+            process.stdout.write(`${runtime.config.publicUrl}\n`);
+        return;
+    }
+    ensureDocker(runner);
+    if (action === "watch") {
+        ensureNetwork(runner);
+        registerRoute(runtime);
+        try {
+            ensureGateway(runner);
+            process.stdout.write(`Development URL: http://${runtime.config.hostname}\n`);
+            if (runtime.config.publicUrl)
+                process.stdout.write(`Public OAuth URL: ${runtime.config.publicUrl}\n`);
+            runCompose(runtime, composeCommand("watch", args), runner);
+        }
+        catch (error) {
+            unregisterRoute(runtime);
+            stopGatewayWhenUnused(runner);
+            throw error;
+        }
+        return;
+    }
+    if (action === "down") {
+        runCompose(runtime, composeCommand("down", args), runner);
+        unregisterRoute(runtime);
+        stopGatewayWhenUnused(runner);
+        return;
+    }
+    if (action === "exec" || action === "logs" || action === "ps") {
+        runCompose(runtime, composeCommand(action, args), runner);
+        return;
+    }
+    throw new Error("Usage: podo dev <watch|exec|logs|ps|down|url> [docker compose options]");
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { type PackageManager } from "./create";
+import { type LocaleDirection } from "./locale";
 interface ParsedArgs {
     command?: string;
     name?: string;
@@ -12,6 +13,9 @@ interface ParsedArgs {
     yes: boolean;
     help: boolean;
     ai: boolean;
+    positionals: string[];
+    localeName?: string;
+    localeDirection?: LocaleDirection;
 }
 export declare function parseArgs(argv: string[]): ParsedArgs;
 export {};

package/dist/index.js

@@ -12,6 +12,8 @@ const remove_1 = require("./remove");
 const inspect_1 = require("./inspect");
 const update_1 = require("./update");
 const eject_1 = require("./eject");
+const dev_1 = require("./dev");
+const locale_1 = require("./locale");
 const HELP = `podo — PodoKit project generator
 
 Usage:
@@ -21,6 +23,8 @@ Usage:
   podo status              Show version, modules, file tiers, and local edits
   podo diff                List PodoKit-managed files you have edited
   podo doctor              Check framework versions against supported ranges
+  podo dev <action> [...]  Run the shared, portless container development gateway
+  podo locale <command>    Add, validate, activate, or list JSON locales
   podo update [--apply]    Preview (or apply) what a version update would change
   podo eject <path...>     Take ownership of managed files (update skips them)
 
@@ -28,6 +32,8 @@ Options:
   --template <t> Template to scaffold (see below)
   --dir <path>   Target directory (default: ./<name>)
   --pm <name>    Package manager: npm | pnpm | yarn (default: npm)
+  --name <label> Display name for a locale
+  --direction <direction>  Text direction: ltr | rtl (default: ltr)
   --adopt        Adopt colliding paths explicitly declared managed by a module
   --no-ai        Skip AI agent guidance (AGENTS.md, CLAUDE.md, editor rules)
   -y, --yes      Skip prompts and accept defaults
@@ -42,7 +48,14 @@ Example:
   cd my-app && npx @podosoft/podokit add auth
 `;
 function parseArgs(argv) {
-    const parsed = { help: false, yes: false, apply: false, adopt: false, ai: true };
+    const parsed = {
+        help: false,
+        yes: false,
+        apply: false,
+        adopt: false,
+        ai: true,
+        positionals: [],
+    };
     const positionals = [];
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
@@ -73,12 +86,23 @@ function parseArgs(argv) {
         else if (arg === "--pm") {
             parsed.pm = argv[++i];
         }
+        else if (arg === "--name") {
+            parsed.localeName = argv[++i];
+        }
+        else if (arg === "--direction") {
+            const direction = argv[++i];
+            if (direction !== "ltr" && direction !== "rtl") {
+                throw new Error('--direction must be either "ltr" or "rtl".');
+            }
+            parsed.localeDirection = direction;
+        }
         else if (arg !== undefined && !arg.startsWith("-")) {
             positionals.push(arg);
         }
     }
     parsed.command = positionals[0];
     parsed.name = positionals[1];
+    parsed.positionals = positionals;
     return parsed;
 }
 function fail(message) {
@@ -203,6 +227,62 @@ async function main(argv) {
         }
         return;
     }
+    if (args.command === "dev") {
+        try {
+            (0, dev_1.runDevCommand)(process.cwd(), args.name, argv.slice(2));
+        }
+        catch (err) {
+            fail(err.message);
+        }
+        return;
+    }
+    if (args.command === "locale") {
+        const action = args.positionals[1] ?? "list";
+        const code = args.positionals[2];
+        try {
+            if (action === "add") {
+                if (!code)
+                    fail("Usage: podo locale add <code> [--name <label>] [--direction ltr|rtl]");
+                const definition = (0, locale_1.addLocale)(process.cwd(), code, {
+                    name: args.localeName,
+                    direction: args.localeDirection,
+                });
+                process.stdout.write(`Added ${definition.code} (${definition.name}) as inactive. Translate catalogs, run ` +
+                    `"podo locale validate ${definition.code}", then activate it.\n`);
+                return;
+            }
+            if (action === "validate") {
+                const locales = code ? [code] : (0, locale_1.listLocales)(process.cwd()).map((locale) => locale.code);
+                for (const locale of locales) {
+                    const coverage = (0, locale_1.validateLocale)(process.cwd(), locale);
+                    process.stdout.write(`${coverage.definition.code.padEnd(10)} ${String(coverage.percent).padStart(3)}% ` +
+                        `(${coverage.translated}/${coverage.total})` +
+                        `${coverage.missing.length ? `  missing ${coverage.missing.length}` : ""}\n`);
+                }
+                return;
+            }
+            if (action === "activate" || action === "deactivate") {
+                if (!code)
+                    fail(`Usage: podo locale ${action} <code>`);
+                const coverage = (0, locale_1.setLocaleEnabled)(process.cwd(), code, action === "activate");
+                process.stdout.write(`${action === "activate" ? "Activated" : "Deactivated"} ${coverage.definition.code} ` +
+                    `(${coverage.percent}% translated; missing keys use the configured fallback).\n`);
+                return;
+            }
+            if (action === "list") {
+                for (const locale of (0, locale_1.listLocales)(process.cwd())) {
+                    const coverage = (0, locale_1.validateLocale)(process.cwd(), locale.code);
+                    process.stdout.write(`${locale.enabled ? "active  " : "inactive"} ${locale.code.padEnd(10)} ` +
+                        `${locale.name}  ${coverage.percent}%\n`);
+                }
+                return;
+            }
+            fail(`Unknown locale command "${action}". Use add, validate, activate, deactivate, or list.`);
+        }
+        catch (err) {
+            fail(err.message);
+        }
+    }
     if (args.command === "update") {
         const templatesDir = (0, node_path_1.join)(__dirname, "templates");
         try {
@@ -238,7 +318,7 @@ async function main(argv) {
         return;
     }
     if (args.command === "eject") {
-        const targets = argv.filter((a) => !a.startsWith("-")).slice(1);
+        const targets = args.positionals.slice(1);
         if (!targets.length) {
             fail("Usage: podo eject <path...>");
         }

package/dist/lib.d.ts

@@ -8,6 +8,8 @@ export { status, diff, doctor, SUPPORTED_FRAMEWORKS } from "./inspect";
 export type { StatusReport, DoctorFinding } from "./inspect";
 export { planUpdate, summarize } from "./update";
 export type { UpdatePlan, FileChange } from "./update";
+export { readDevConfig, renderRoute, renderRuntimeCompose, resolveDevRuntime, runDevCommand } from "./dev";
+export type { CommandRunner, DevConfig, DevRuntime } from "./dev";
 /** Absolute path to the templates bundled in this installed package. */
 export declare function builtinTemplatesDir(): string;
 /** Absolute path to the modules bundled in this installed package. */

package/dist/lib.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.summarize = exports.planUpdate = exports.SUPPORTED_FRAMEWORKS = exports.doctor = exports.diff = exports.status = exports.addModule = exports.listModules = exports.isKnownTemplate = exports.TEMPLATE_NAMES = exports.DEFAULT_TEMPLATE = exports.TEMPLATES = exports.create = void 0;
+exports.runDevCommand = exports.resolveDevRuntime = exports.renderRuntimeCompose = exports.renderRoute = exports.readDevConfig = exports.summarize = exports.planUpdate = exports.SUPPORTED_FRAMEWORKS = exports.doctor = exports.diff = exports.status = exports.addModule = exports.listModules = exports.isKnownTemplate = exports.TEMPLATE_NAMES = exports.DEFAULT_TEMPLATE = exports.TEMPLATES = exports.create = void 0;
 exports.builtinTemplatesDir = builtinTemplatesDir;
 exports.builtinModulesDir = builtinModulesDir;
 // Library entry point: the reusable functions behind the `podo` CLI, for other
@@ -24,6 +24,12 @@ Object.defineProperty(exports, "SUPPORTED_FRAMEWORKS", { enumerable: true, get:
 var update_1 = require("./update");
 Object.defineProperty(exports, "planUpdate", { enumerable: true, get: function () { return update_1.planUpdate; } });
 Object.defineProperty(exports, "summarize", { enumerable: true, get: function () { return update_1.summarize; } });
+var dev_1 = require("./dev");
+Object.defineProperty(exports, "readDevConfig", { enumerable: true, get: function () { return dev_1.readDevConfig; } });
+Object.defineProperty(exports, "renderRoute", { enumerable: true, get: function () { return dev_1.renderRoute; } });
+Object.defineProperty(exports, "renderRuntimeCompose", { enumerable: true, get: function () { return dev_1.renderRuntimeCompose; } });
+Object.defineProperty(exports, "resolveDevRuntime", { enumerable: true, get: function () { return dev_1.resolveDevRuntime; } });
+Object.defineProperty(exports, "runDevCommand", { enumerable: true, get: function () { return dev_1.runDevCommand; } });
 /** Absolute path to the templates bundled in this installed package. */
 function builtinTemplatesDir() {
     return (0, node_path_1.join)(__dirname, "templates");

package/dist/locale.d.ts

@@ -0,0 +1,22 @@
+export type LocaleDirection = "ltr" | "rtl";
+export interface LocaleDefinition {
+    code: string;
+    name: string;
+    direction: LocaleDirection;
+    enabled: boolean;
+}
+export interface LocaleCoverage {
+    definition: LocaleDefinition;
+    translated: number;
+    total: number;
+    percent: number;
+    missing: string[];
+}
+export declare function normalizeLocaleCode(value: string): string;
+export declare function listLocales(projectRoot: string): LocaleDefinition[];
+export declare function validateLocale(projectRoot: string, rawCode: string): LocaleCoverage;
+export declare function addLocale(projectRoot: string, rawCode: string, options?: {
+    name?: string;
+    direction?: LocaleDirection;
+}): LocaleDefinition;
+export declare function setLocaleEnabled(projectRoot: string, rawCode: string, enabled: boolean): LocaleCoverage;