@lotics/cli 0.88.0 → 0.89.1

package/dist/generate_package_fields.test.js

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generatePackageAppFields } from "./generate_package_fields.js";
-// A live installation binding — fully-qualified alias → concrete id. The
-// generator sources the alias SET here (never a contract file); the emitted
-// module resolves the SAME keys through `getAppBinding()` at runtime.
-const binding = {
-    fields: {
-        "tasks.title": "fld_title",
-        "tasks.status": "fld_status",
-        "projects.name": "fld_name",
-    },
-    options: {
-        "tasks.status:to_do": "opt_todo",
-        "tasks.status:doing": "opt_doing",
-        "tasks.status:done": "opt_done",
-    },
-    roles: { approver: "grp_approver" },
-};
-describe("generatePackageAppFields", () => {
-    it("emits runtime-resolved F/OPT/ROLE keyed by the binding's aliases", () => {
-        const src = generatePackageAppFields(binding);
-        // Resolves through the SDK binding at module load (top-level await).
-        expect(src).toContain('import { getAppBinding } from "@lotics/app-sdk";');
-        expect(src).toContain("const binding = await getAppBinding();");
-        // F: uppercased entity alias, fully-qualified binding keys.
-        expect(src).toContain('title: bound(binding.fields, "tasks.title", "field")');
-        expect(src).toContain('name: bound(binding.fields, "projects.name", "field")');
-        expect(src).toMatch(/TASKS: \{/);
-        expect(src).toMatch(/PROJECTS: \{/);
-        // OPT: qualified entity.field:opt keys; option-less fields absent.
-        expect(src).toContain('to_do: bound(binding.options, "tasks.status:to_do", "option")');
-        expect(src).toContain('done: bound(binding.options, "tasks.status:done", "option")');
-        expect(src).not.toContain('"tasks.title:');
-        // ROLE map from the binding's roles.
-        expect(src).toContain('approver: bound(binding.roles, "approver", "role")');
-        // No concrete id in any VALUE position — the module is workspace-agnostic.
-        // (Doc comments legitimately name the id prefixes, so match quoted ids.)
-        expect(src).not.toMatch(/"(fld|opt|tbl|grp)_/);
-    });
-    it("emits valid empty maps for an empty binding", () => {
-        const src = generatePackageAppFields({ fields: {}, options: {}, roles: {} });
-        expect(src).toContain("export const F = {} as const;");
-        expect(src).toContain("export const OPT = {} as const;");
-        expect(src).toContain("export const ROLE = {} as const;");
-        // Still imports the SDK so the module shape is uniform.
-        expect(src).toContain("const binding = await getAppBinding();");
-    });
-    it("quotes an alias that is not a valid identifier", () => {
-        const src = generatePackageAppFields({
-            fields: { "tasks.2nd_field": "fld_x" },
-            options: {},
-            roles: {},
-        });
-        expect(src).toContain('"2nd_field": bound(binding.fields, "tasks.2nd_field", "field")');
-    });
-    it("is deterministic — same binding, same bytes", () => {
-        expect(generatePackageAppFields(binding)).toBe(generatePackageAppFields(binding));
-    });
-});

package/dist/inputs.d.ts

@@ -1,38 +0,0 @@
-/**
- * Shared JSON-args ingestion for `lotics run` and `lotics app workflow`.
- *
- * A tool/workflow payload can arrive three ways, all of which bypass the OS
- * `ARG_MAX` limit so bulk inputs (a knowledge-doc `content`, a batch update)
- * don't overflow the inline arg:
- *   - inline:  `… '<json>'`
- *   - `@file`: `… @args.json`   (a leading `@` is unambiguous — JSON starts `{`)
- *   - stdin:   `… < args.json`  or  `cat args.json | …`
- *
- * Kept apart from `cli.ts` (which runs `main()` on import) so the file/JSON
- * branches are unit-testable; `readStdin` is injected so the tests don't touch
- * the real process stdin.
- */
-export type IngestResult = {
-    kind: "ok";
-    args: Record<string, unknown>;
-} | {
-    kind: "error";
-    message: string;
-};
-export interface IngestOptions {
-    /** The positional arg as parsed (`'<json>'`, `@file`, or undefined). */
-    rawArg: string | undefined;
-    /** Whether stdin is a TTY — when false and no rawArg, read piped stdin. */
-    stdinIsTTY: boolean;
-    /** Reads a UTF-8 file. Injected for testability. */
-    readFile: (path: string) => string;
-    /** Reads all of stdin. Injected for testability. */
-    readStdin: () => Promise<string>;
-}
-/**
- * Resolve the raw payload string, then JSON.parse it. An absent payload (no
- * arg, no piped stdin) is a valid empty `{}` — some tools/workflows take no
- * inputs. A `@file` read failure or invalid JSON is a typed error the caller
- * surfaces; this function never throws or exits.
- */
-export declare function ingestJsonArgs(opts: IngestOptions): Promise<IngestResult>;

package/dist/inputs.js

@@ -1,50 +0,0 @@
-/**
- * Shared JSON-args ingestion for `lotics run` and `lotics app workflow`.
- *
- * A tool/workflow payload can arrive three ways, all of which bypass the OS
- * `ARG_MAX` limit so bulk inputs (a knowledge-doc `content`, a batch update)
- * don't overflow the inline arg:
- *   - inline:  `… '<json>'`
- *   - `@file`: `… @args.json`   (a leading `@` is unambiguous — JSON starts `{`)
- *   - stdin:   `… < args.json`  or  `cat args.json | …`
- *
- * Kept apart from `cli.ts` (which runs `main()` on import) so the file/JSON
- * branches are unit-testable; `readStdin` is injected so the tests don't touch
- * the real process stdin.
- */
-/**
- * Resolve the raw payload string, then JSON.parse it. An absent payload (no
- * arg, no piped stdin) is a valid empty `{}` — some tools/workflows take no
- * inputs. A `@file` read failure or invalid JSON is a typed error the caller
- * surfaces; this function never throws or exits.
- */
-export async function ingestJsonArgs(opts) {
-    let raw = opts.rawArg;
-    if (raw && raw.startsWith("@")) {
-        const argsPath = raw.slice(1);
-        try {
-            raw = opts.readFile(argsPath);
-        }
-        catch (err) {
-            return {
-                kind: "error",
-                message: `Cannot read args file "${argsPath}": ${err instanceof Error ? err.message : String(err)}`,
-            };
-        }
-    }
-    else if (!raw && !opts.stdinIsTTY) {
-        raw = await opts.readStdin();
-    }
-    if (!raw)
-        return { kind: "ok", args: {} };
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-            return { kind: "error", message: `JSON args must be an object, got: ${raw}` };
-        }
-        return { kind: "ok", args: parsed };
-    }
-    catch {
-        return { kind: "error", message: `Invalid JSON: ${raw}` };
-    }
-}

package/dist/inputs.test.d.ts

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

package/dist/inputs.test.js

@@ -1,89 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ingestJsonArgs } from "./inputs.js";
-const neverFile = () => {
-    throw new Error("readFile should not be called");
-};
-const neverStdin = async () => {
-    throw new Error("readStdin should not be called");
-};
-describe("ingestJsonArgs", () => {
-    it("parses an inline JSON object arg without touching file/stdin", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: '{"table_id":"tbl_1"}',
-            stdinIsTTY: true,
-            readFile: neverFile,
-            readStdin: neverStdin,
-        });
-        expect(r).toEqual({ kind: "ok", args: { table_id: "tbl_1" } });
-    });
-    it("reads @file args (bypassing ARG_MAX)", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: "@args.json",
-            stdinIsTTY: true,
-            readFile: (p) => {
-                expect(p).toBe("args.json");
-                return '{"big":"payload"}';
-            },
-            readStdin: neverStdin,
-        });
-        expect(r).toEqual({ kind: "ok", args: { big: "payload" } });
-    });
-    it("surfaces a typed error when the @file can't be read", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: "@missing.json",
-            stdinIsTTY: true,
-            readFile: () => {
-                throw new Error("ENOENT");
-            },
-            readStdin: neverStdin,
-        });
-        expect(r.kind).toBe("error");
-        if (r.kind === "error")
-            expect(r.message).toContain("missing.json");
-    });
-    it("reads piped stdin when there's no arg and stdin is not a TTY", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: undefined,
-            stdinIsTTY: false,
-            readFile: neverFile,
-            readStdin: async () => '{"from":"stdin"}',
-        });
-        expect(r).toEqual({ kind: "ok", args: { from: "stdin" } });
-    });
-    it("treats an absent payload (no arg, TTY stdin) as empty {}", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: undefined,
-            stdinIsTTY: true,
-            readFile: neverFile,
-            readStdin: neverStdin,
-        });
-        expect(r).toEqual({ kind: "ok", args: {} });
-    });
-    it("errors on invalid JSON", async () => {
-        const r = await ingestJsonArgs({
-            rawArg: "{not json",
-            stdinIsTTY: true,
-            readFile: neverFile,
-            readStdin: neverStdin,
-        });
-        expect(r.kind).toBe("error");
-        if (r.kind === "error")
-            expect(r.message).toContain("Invalid JSON");
-    });
-    it("rejects a non-object top-level JSON (array / scalar)", async () => {
-        const arr = await ingestJsonArgs({
-            rawArg: "[1,2,3]",
-            stdinIsTTY: true,
-            readFile: neverFile,
-            readStdin: neverStdin,
-        });
-        expect(arr.kind).toBe("error");
-        const scalar = await ingestJsonArgs({
-            rawArg: "42",
-            stdinIsTTY: true,
-            readFile: neverFile,
-            readStdin: neverStdin,
-        });
-        expect(scalar.kind).toBe("error");
-    });
-});

package/dist/preview.d.ts

@@ -1,3 +0,0 @@
-export declare function runPreviewCommand(filePath: string | undefined, flags: {
-    output?: string;
-}): Promise<void>;

package/dist/preview.js

@@ -1,233 +0,0 @@
-// `lotics preview <file.docx|.xlsx> [--out x.png]` — render a generated document to
-// a PNG using the SAME engines the frontend FilePreview uses. No npm deps: drives a
-// headless Chrome over CDP with Node built-ins (WebSocket/fetch/http/child_process),
-// keeping the CLI a single bundled binary. The render logic lives in the esbuild
-// browser bundle dist/render_page.js (built by build_cli.mjs); this file orchestrates
-// Chrome. Chrome itself is external (system Chrome / Playwright chromium / CHROME_PATH)
-// — inherent to rendering docx/xlsx, which are browser-rendered formats.
-import { spawn } from "node:child_process";
-import { createServer } from "node:http";
-import { readFileSync, writeFileSync, existsSync, mkdtempSync, rmSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname, resolve, extname, basename } from "node:path";
-import { fileURLToPath } from "node:url";
-import { setTimeout as sleep } from "node:timers/promises";
-const HERE = dirname(fileURLToPath(import.meta.url));
-function fail(msg) {
-    console.error(msg);
-    process.exit(1);
-}
-/** Locate a Chrome/Chromium binary: explicit env → Playwright's install → system. */
-function findChrome() {
-    const env = process.env.LOTICS_CHROME || process.env.CHROME_PATH;
-    if (env && existsSync(env))
-        return env;
-    const home = process.env.HOME || "";
-    // Playwright installs under ms-playwright/chromium-<rev>/…  Enumerate with readdirSync
-    // (Node 10+) — NOT node:fs globSync, which is Node 22+; a globSync import would fail to
-    // load the whole bundled CLI on the Node 18+ it supports.
-    const pwDir = process.platform === "darwin"
-        ? `${home}/Library/Caches/ms-playwright`
-        : `${home}/.cache/ms-playwright`;
-    if (existsSync(pwDir)) {
-        const rel = process.platform === "darwin"
-            ? ["chrome-mac/Chromium.app/Contents/MacOS/Chromium"]
-            : ["chrome-linux/chrome", "chrome-linux/headless_shell"];
-        const revs = readdirSync(pwDir)
-            .filter((n) => n.startsWith("chromium-") || n.startsWith("chromium_headless_shell-"))
-            .sort()
-            .reverse();
-        for (const rev of revs) {
-            for (const r of rel) {
-                const bin = join(pwDir, rev, r);
-                if (existsSync(bin))
-                    return bin;
-            }
-        }
-    }
-    const systemPaths = [
-        "/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium",
-        "/usr/bin/chromium-browser", "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-        "/Applications/Chromium.app/Contents/MacOS/Chromium",
-    ];
-    return systemPaths.find((p) => existsSync(p)) ?? null;
-}
-/** Minimal CDP client over the built-in WebSocket. */
-async function cdpConnect(wsUrl) {
-    const ws = new WebSocket(wsUrl);
-    await new Promise((res, rej) => {
-        ws.onopen = () => res();
-        ws.onerror = () => rej(new Error("CDP websocket failed to open"));
-    });
-    let id = 0;
-    const pending = new Map();
-    // If Chrome exits mid-render the socket closes with no reply — settle every in-flight
-    // request so `send()` rejects instead of hanging forever (the finally then cleans up).
-    ws.onclose = () => {
-        for (const done of pending.values())
-            done(Promise.reject(new Error("CDP connection closed (Chrome exited?)")));
-        pending.clear();
-    };
-    ws.onmessage = (e) => {
-        const m = JSON.parse(String(e.data));
-        if (m.id != null && pending.has(m.id)) {
-            const done = pending.get(m.id);
-            pending.delete(m.id);
-            done(m.error ? Promise.reject(new Error(m.error.message)) : m.result);
-        }
-    };
-    const send = (method, params = {}) => new Promise((res) => {
-        const i = ++id;
-        pending.set(i, (r) => res(r));
-        ws.send(JSON.stringify({ id: i, method, params }));
-    });
-    return { send, close: () => ws.close() };
-}
-export async function runPreviewCommand(filePath, flags) {
-    if (!filePath)
-        fail("Usage: lotics preview <file.docx|.xlsx> [--out <file.png>]");
-    const abs = resolve(filePath);
-    if (!existsSync(abs))
-        fail(`File not found: ${abs}`);
-    const ext = extname(abs).toLowerCase();
-    const type = ext === ".docx" ? "docx" : (ext === ".xlsx" || ext === ".xls" || ext === ".csv") ? "xlsx" : null;
-    if (!type)
-        fail(`Unsupported file type "${ext}" — preview supports .docx and .xlsx/.csv. (PDFs open directly — no preview needed.)`);
-    // preview drives Chrome over CDP via the built-in WebSocket (Node 22+). The rest of the
-    // CLI supports Node 18, so fail this one command clearly rather than with "WebSocket is
-    // not defined" — and before launching Chrome.
-    if (typeof WebSocket === "undefined") {
-        fail("lotics preview needs Node 22+ (it drives Chrome over CDP via the built-in WebSocket). Upgrade Node and retry.");
-    }
-    const bundlePath = join(HERE, "..", "render_page.js");
-    if (!existsSync(bundlePath))
-        fail(`Render bundle missing at ${bundlePath} — reinstall @lotics/cli (build step failed).`);
-    const chrome = findChrome();
-    if (!chrome) {
-        fail("No Chrome/Chromium found. Set CHROME_PATH to a Chrome binary, or install one:\n" +
-            "  npx playwright install chromium   (then it's auto-detected)\n" +
-            "  or install Google Chrome / Chromium via your package manager.");
-    }
-    const b64 = readFileSync(abs).toString("base64");
-    const bundle = readFileSync(bundlePath, "utf8");
-    const html = `<!doctype html><html><head><meta charset="utf-8"><style>body{margin:0;background:#fff;font-family:sans-serif}` +
-        `#root{padding:20px;max-width:1240px;margin:0 auto}</style></head><body><div id="root"></div>` +
-        `<script>window.__LOTICS_RENDER=${JSON.stringify({ type, b64 })}</script>` +
-        `<script src="/render_page.js"></script></body></html>`;
-    const server = createServer((req, res) => {
-        if (req.url === "/render_page.js") {
-            res.writeHead(200, { "content-type": "application/javascript" });
-            res.end(bundle);
-        }
-        else {
-            res.writeHead(200, { "content-type": "text/html" });
-            res.end(html);
-        }
-    });
-    await new Promise((r) => server.listen(0, "127.0.0.1", () => r()));
-    const httpPort = server.address().port;
-    const udd = mkdtempSync(join(tmpdir(), "lotics-render-"));
-    const child = spawn(chrome, [
-        "--headless=new", "--disable-gpu", "--no-sandbox", "--hide-scrollbars",
-        // Large multi-sheet renders exhaust the (often tiny) /dev/shm in containers/WSL2 and
-        // crash the tab; back shared memory with /tmp instead.
-        "--disable-dev-shm-usage",
-        "--force-device-scale-factor=2", "--remote-debugging-port=0", `--user-data-dir=${udd}`,
-        "about:blank",
-    ], { stdio: "ignore" });
-    const cleanup = () => {
-        try {
-            child.kill();
-        }
-        catch { /* ignore */ }
-        try {
-            server.close();
-        }
-        catch { /* ignore */ }
-        try {
-            rmSync(udd, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-    };
-    try {
-        // Chrome writes the chosen debug port to DevToolsActivePort (first line).
-        let cdpPort = 0;
-        const portFile = join(udd, "DevToolsActivePort");
-        for (let i = 0; i < 100 && !cdpPort; i++) {
-            if (existsSync(portFile)) {
-                const p = parseInt(readFileSync(portFile, "utf8").split("\n")[0], 10);
-                if (p)
-                    cdpPort = p;
-            }
-            if (!cdpPort)
-                await sleep(100);
-        }
-        if (!cdpPort)
-            throw new Error("Chrome did not expose a debugging port (launch failed?).");
-        let target;
-        for (let i = 0; i < 60 && !target?.webSocketDebuggerUrl; i++) {
-            try {
-                const list = await (await fetch(`http://127.0.0.1:${cdpPort}/json/list`)).json();
-                target = list.find((t) => t.type === "page");
-            }
-            catch { /* not ready */ }
-            if (!target?.webSocketDebuggerUrl)
-                await sleep(100);
-        }
-        if (!target?.webSocketDebuggerUrl)
-            throw new Error("No Chrome page target available.");
-        const cdp = await cdpConnect(target.webSocketDebuggerUrl);
-        await cdp.send("Page.enable");
-        await cdp.send("Runtime.enable");
-        await cdp.send("Page.navigate", { url: `http://127.0.0.1:${httpPort}/` });
-        // Poll for the render-done flag the page sets.
-        let err;
-        let done = false;
-        const warnings = [];
-        for (let i = 0; i < 200; i++) {
-            const r = await cdp.send("Runtime.evaluate", {
-                expression: "({done: !!window.__loticsDone, err: window.__loticsError || '', warnings: window.__loticsWarnings || []})",
-                returnByValue: true,
-            });
-            const v = r.result?.value;
-            if (v?.done) {
-                done = true;
-                err = v.err || undefined;
-                if (v.warnings?.length)
-                    warnings.push(...v.warnings);
-                break;
-            }
-            await sleep(75);
-        }
-        if (!done)
-            throw new Error("Render timed out (page never signaled completion).");
-        if (err)
-            throw new Error(`Render engine error: ${err}`);
-        // Size the capture to the full rendered content, then screenshot beyond viewport.
-        // Clamp to Chrome's ceiling: the PNG is 2× (device scale) the CSS clip, so a CSS side
-        // over ~15000px would blow past the ~32767px canvas limit. A very long docx or several
-        // huge sheets hit this — clamp explicitly and WARN, never clip in silence.
-        const metrics = await cdp.send("Page.getLayoutMetrics");
-        const size = metrics.cssContentSize ?? metrics.contentSize ?? { width: 1240, height: 1600 };
-        const MAX_CAPTURE = 15000; // CSS px; ×2 device scale → ≤30000px PNG
-        const w = Math.ceil(size.width);
-        const h = Math.ceil(size.height);
-        if (w > MAX_CAPTURE || h > MAX_CAPTURE) {
-            warnings.push(`content ${w}×${h}px clipped to ${Math.min(w, MAX_CAPTURE)}×${Math.min(h, MAX_CAPTURE)}px (exceeds the ${MAX_CAPTURE}px capture limit)`);
-        }
-        const shot = await cdp.send("Page.captureScreenshot", {
-            format: "png",
-            captureBeyondViewport: true,
-            clip: { x: 0, y: 0, width: Math.min(w, MAX_CAPTURE), height: Math.min(h, MAX_CAPTURE), scale: 1 },
-        });
-        cdp.close();
-        const outPath = flags.output ? resolve(flags.output) : join(dirname(abs), basename(abs, ext) + ".png");
-        writeFileSync(outPath, Buffer.from(shot.data, "base64"));
-        console.log(`Rendered ${basename(abs)} → ${outPath}  (${Math.min(w, MAX_CAPTURE)}×${Math.min(h, MAX_CAPTURE)}, via ${basename(chrome)})`);
-        for (const warn of warnings)
-            console.error(`  ⚠ ${warn}`);
-    }
-    finally {
-        cleanup();
-    }
-}

package/dist/starter_template.d.ts

@@ -1,64 +0,0 @@
-/**
- * Starter template for `lotics app create`.
- *
- * The CLI scaffolds these files into the user's target directory, then runs
- * `npm install` + `npm run build` + `lotics app deploy` to populate v1.
- *
- * Embedded as string literals here (rather than packaged as files alongside
- * the CLI) so the CLI binary is self-contained and the starter survives
- * `npm publish` cleanly. Updates to the starter ship in CLI releases.
- *
- * Conventions (locked decisions):
- *   - Vite + React + TypeScript (strict mode).
- *   - Entry: src/App.tsx with `export default`. main.tsx wires
- *     `mount(<LoticsLocaleProvider locale={vi}><PortalHost><App/></PortalHost></LoticsLocaleProvider>)` —
- *     LoticsLocaleProvider sets the kit's strings to Vietnamese (Lotics apps are
- *     Vietnamese; swap to `en` for English); PortalHost is the render target
- *     @lotics/ui overlays (Popover/Tooltip/Dialog) need — and imports
- *     @lotics/ui/index.css (base style reset) + @lotics/ui/fonts.css
- *     (path-independent Inter @font-face bundle — Text renders unstyled without it).
- *   - Vite default `base: "/"` so emitted asset URLs are absolute; the render
- *     endpoint rewrites root-relative paths to `/v1/apps/{id}/asset/...`.
- *     Don't switch to `base: "./"` without updating `rewriteAssetPaths`.
- *   - react-native aliased to react-native-web so @lotics/ui's RN primitives
- *     render in a pure-web environment. `.web.tsx` is prioritized in the
- *     resolve.extensions list.
- *   - @lotics/app-sdk + @lotics/ui peer-supplied; user installs both via npm.
- *   - oxlint + vitest + tsc out of the box, plus a GitHub Actions CI
- *     workflow that runs all three on every PR.
- */
-export interface StarterFile {
-    path: string;
-    content: string;
-}
-/**
- * Pin defaults for `@lotics/ui` and `@lotics/app-sdk` in the scaffolded
- * package.json. Used when `lotics app create` can't resolve the latest
- * versions from npm (no network, registry blip) — keeps `app create`
- * working offline at the cost of a stale starter pin.
- *
- * Bump these in tandem with new releases of either package. Production
- * scaffolds resolve the live version via `fetchLatestNpmVersion` and only
- * fall back here when the lookup fails.
- */
-export declare const STARTER_FALLBACK_UI_VERSION = "6.1.0";
-export declare const STARTER_FALLBACK_SDK_VERSION = "0.51.0";
-/**
- * react-native pin for scaffolded apps. Matches the monorepo frontend's pin so
- * an app deep-typechecks `@lotics/ui`'s `.tsx` source against the SAME RN types
- * the package is developed and CI'd against. A mismatch surfaces RN-version-
- * sensitive type errors (e.g. `StyleSheet.absoluteFill`, which `frontend/` CI
- * never sees because `packages/ui` is only typechecked through `frontend/`).
- * RN is aliased to react-native-web at runtime, so this pin is effectively
- * types-only.
- */
-export declare const STARTER_REACT_NATIVE_VERSION = "0.85.3";
-export declare function buildStarterTemplate(args: {
-    app_name: string;
-    app_id: string;
-    workspace_id: string;
-    /** @lotics/ui version range, e.g. "^1.8.0". Defaults to the fallback pin. */
-    ui_version?: string;
-    /** @lotics/app-sdk version range, e.g. "^0.7.0". Defaults to the fallback pin. */
-    sdk_version?: string;
-}): StarterFile[];