@lotics/cli 0.88.0 → 0.88.1

package/dist/docx.test.js

@@ -1,145 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { parseDocx } from "@lotics/docx";
-import { runDocxCommand } from "./docx.js";
-import { CliError } from "./file_command_io.js";
-let tmpDir;
-let file;
-beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "docx-test-"));
-    file = path.join(tmpDir, "test.docx");
-    vi.spyOn(console, "error").mockImplementation(() => { });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-async function writeFresh(json) {
-    await runDocxCommand("write", file, [json]);
-}
-async function readBlocks() {
-    const stdout = vi.spyOn(console, "log").mockImplementation(() => { });
-    try {
-        await runDocxCommand("read", file, []);
-        const printed = stdout.mock.calls[0]?.[0];
-        const out = JSON.parse(printed);
-        return out.blocks
-            .filter((b) => b.kind === "paragraph")
-            .map((b) => ({ text: b.text ?? "", style: b.style }));
-    }
-    finally {
-        stdout.mockRestore();
-    }
-}
-describe("docx write + read", () => {
-    it("round-trips paragraphs with styles", async () => {
-        await writeFresh(JSON.stringify({
-            blocks: [
-                { kind: "paragraph", text: "Title", style: "Heading1" },
-                { kind: "paragraph", text: "Body" },
-            ],
-        }));
-        expect(await readBlocks()).toEqual([
-            { text: "Title", style: "Heading1" },
-            { text: "Body", style: undefined },
-        ]);
-    });
-    it("renders multi-line text as <w:br/> line breaks and round-trips through read", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "L1\nL2\nL3" }] }));
-        expect(await readBlocks()).toEqual([{ text: "L1\nL2\nL3", style: undefined }]);
-    });
-});
-describe("docx single-op mutations", () => {
-    beforeEach(async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "first" }] }));
-    });
-    it("append-paragraph adds at end", async () => {
-        await runDocxCommand("append-paragraph", file, ["second"]);
-        expect((await readBlocks()).map((b) => b.text)).toEqual(["first", "second"]);
-    });
-    it("append-paragraph carries a style flag", async () => {
-        await runDocxCommand("append-paragraph", file, ["heading", "--style=Heading2"]);
-        expect((await readBlocks())[1]).toEqual({ text: "heading", style: "Heading2" });
-    });
-    it("append-paragraph does NOT consume --style as positional text", async () => {
-        // Regression: an earlier draft picked rest[0] without filtering flags,
-        // so `--style=X` became the paragraph text.
-        await expect(runDocxCommand("append-paragraph", file, ["--style=Heading1"])).rejects.toBeInstanceOf(CliError);
-    });
-    it("insert-paragraph splices at index", async () => {
-        await runDocxCommand("insert-paragraph", file, ["front", "--at=0"]);
-        expect((await readBlocks()).map((b) => b.text)).toEqual(["front", "first"]);
-    });
-    it("delete-block removes by index", async () => {
-        await runDocxCommand("append-paragraph", file, ["second"]);
-        await runDocxCommand("delete-block", file, ["--at=0"]);
-        expect((await readBlocks()).map((b) => b.text)).toEqual(["second"]);
-    });
-    it("replace-text rewrites all paragraph runs", async () => {
-        await runDocxCommand("append-paragraph", file, ["the {{name}}"]);
-        await runDocxCommand("replace-text", file, ["{{name}}", "Acme"]);
-        expect((await readBlocks()).map((b) => b.text)).toEqual(["first", "the Acme"]);
-    });
-});
-describe("docx batch", () => {
-    it("applies many ops in one parse/serialize cycle", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "a" }] }));
-        const ops = [
-            { op: "append-paragraph", text: "b" },
-            { op: "insert-paragraph", text: "front", at: 0 },
-            { op: "replace-text", search: "b", replace: "B" },
-        ];
-        await runDocxCommand("batch", file, [JSON.stringify(ops)]);
-        expect((await readBlocks()).map((b) => b.text)).toEqual(["front", "a", "B"]);
-    });
-    it("rejects batch op without an 'op' string", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "x" }] }));
-        await expect(runDocxCommand("batch", file, [JSON.stringify([{ text: "y" }])])).rejects.toBeInstanceOf(CliError);
-    });
-});
-describe("docx round-trip preserves opaque blocks", () => {
-    it("a table (parsed as opaque_block) survives replace-text + write back", async () => {
-        // Build a docx by hand with a paragraph + a synthetic table cell.
-        // Use the live parse/serialize path to confirm opaque content survives.
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "before" }] }));
-        // We can't construct an opaque_block via write JSON, so just verify
-        // that the round-trip of a doc containing only paragraphs is stable
-        // and that error path for opaque_block is hit on write.
-        await expect(runDocxCommand("write", file, [JSON.stringify({
-                blocks: [{ kind: "opaque_block" }],
-            })])).rejects.toBeInstanceOf(CliError);
-    });
-});
-describe("docx error paths", () => {
-    it("fails on missing file", async () => {
-        await expect(runDocxCommand("append-paragraph", path.join(tmpDir, "no.docx"), ["x"])).rejects.toBeInstanceOf(CliError);
-    });
-    it("fails on invalid write JSON", async () => {
-        await expect(runDocxCommand("write", file, ["{not json"])).rejects.toBeInstanceOf(CliError);
-    });
-    it("fails on missing blocks array", async () => {
-        await expect(runDocxCommand("write", file, [JSON.stringify({})])).rejects.toBeInstanceOf(CliError);
-    });
-    it("fails on out-of-range --at on insert-paragraph", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "only" }] }));
-        await expect(runDocxCommand("insert-paragraph", file, ["x", "--at=99"])).rejects.toBeInstanceOf(CliError);
-    });
-    it("fails on out-of-range --at on delete-block", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "only" }] }));
-        await expect(runDocxCommand("delete-block", file, ["--at=5"])).rejects.toBeInstanceOf(CliError);
-    });
-});
-// Verify parseDocx is callable from this test (sanity that the barrel import
-// works under tsgo + vitest) — write a doc, parse with the library directly,
-// confirm at least one paragraph block.
-describe("docx barrel sanity", () => {
-    it("parseDocx is reachable from @lotics/docx", async () => {
-        await writeFresh(JSON.stringify({ blocks: [{ kind: "paragraph", text: "hi" }] }));
-        const bytes = fs.readFileSync(file);
-        const doc = await parseDocx(new Uint8Array(bytes));
-        const paragraphs = doc.body.children.filter((b) => b.kind === "paragraph");
-        expect(paragraphs.length).toBeGreaterThanOrEqual(1);
-    });
-});

package/dist/file_command_io.d.ts

@@ -1,12 +0,0 @@
-/**
- * Throw a tagged user-facing error from a CLI subcommand.
- *
- * The top-level CLI catch (`main().catch` in cli.ts) prints `message` to
- * stderr and exits 1, so callers get the same UX as `process.exit(1)` but
- * tests can catch the throw without killing the test runner.
- */
-export declare class CliError extends Error {
-    constructor(message: string);
-}
-export declare function fail(message: string): never;
-export declare function writeFileAtomic(filePath: string, bytes: Uint8Array): void;

package/dist/file_command_io.js

@@ -1,34 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-/**
- * Throw a tagged user-facing error from a CLI subcommand.
- *
- * The top-level CLI catch (`main().catch` in cli.ts) prints `message` to
- * stderr and exits 1, so callers get the same UX as `process.exit(1)` but
- * tests can catch the throw without killing the test runner.
- */
-export class CliError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "CliError";
-    }
-}
-export function fail(message) {
-    throw new CliError(message);
-}
-export function writeFileAtomic(filePath, bytes) {
-    const dir = path.dirname(path.resolve(filePath));
-    const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-    fs.writeFileSync(tmp, bytes);
-    try {
-        fs.renameSync(tmp, filePath);
-    }
-    catch (error) {
-        try {
-            fs.unlinkSync(tmp);
-        }
-        catch { /* best-effort cleanup */ }
-        throw error;
-    }
-    console.error(`Wrote ${filePath}`);
-}

package/dist/generate_app_agents_dts.d.ts

@@ -1,16 +0,0 @@
-/**
- * Codegen: emit `.lotics/app_agents.d.ts` from the app's manifest.
- *
- * Mirrors `generate_app_workflows_dts` — agents reuse the exact same typed
- * input/output vocabulary, so the `inputsToType` / `objectFieldsToType` mappers
- * are shared. The augmentation adds a typed entry to `AppAgents` for every alias
- * declared in `package.json#lotics.agents`:
- *
- *   - No declared `inputs` → `alias: Record<string, unknown>` (untyped payload)
- *   - Declared `inputs`    → `alias: { …declared shape… }`
- *   - Declared `outputs`   → an `AppAgentResults[alias]` entry → typed `output`
- *
- * Pure function. Same inputs → same output. Idempotent.
- */
-import type { AppAgentDeclaration } from "./app_commands.js";
-export declare function generateAppAgentsDts(agents: Record<string, AppAgentDeclaration> | undefined): string;

package/dist/generate_app_agents_dts.js

@@ -1,62 +0,0 @@
-/**
- * Codegen: emit `.lotics/app_agents.d.ts` from the app's manifest.
- *
- * Mirrors `generate_app_workflows_dts` — agents reuse the exact same typed
- * input/output vocabulary, so the `inputsToType` / `objectFieldsToType` mappers
- * are shared. The augmentation adds a typed entry to `AppAgents` for every alias
- * declared in `package.json#lotics.agents`:
- *
- *   - No declared `inputs` → `alias: Record<string, unknown>` (untyped payload)
- *   - Declared `inputs`    → `alias: { …declared shape… }`
- *   - Declared `outputs`   → an `AppAgentResults[alias]` entry → typed `output`
- *
- * Pure function. Same inputs → same output. Idempotent.
- */
-import { inputsToType, objectFieldsToType, isValidIdentifier } from "./generate_app_workflows_dts.js";
-const HEADER = `// Auto-generated by 'lotics app pull/dev/deploy'.
-// DO NOT EDIT — regenerated from package.json#lotics.agents.
-//
-// This file gives \`useAgentRun("alias")\` typed input + output at call sites by
-// augmenting the @lotics/app-sdk \`AppAgents\` / \`AppAgentResults\` interfaces.
-
-import "@lotics/app-sdk";
-`;
-export function generateAppAgentsDts(agents) {
-    const entries = Object.entries(agents ?? {});
-    if (entries.length === 0) {
-        return `${HEADER}
-// No agents declared in package.json#lotics.agents.
-// Add an entry to enable typed useAgentRun<"alias"> at call sites.
-declare module "@lotics/app-sdk" {
-  interface AppAgents {}
-}
-`;
-    }
-    // Sort alphabetically for deterministic output across regenerations.
-    entries.sort(([a], [b]) => a.localeCompare(b));
-    const inputLines = [];
-    const resultLines = [];
-    for (const [alias, declaration] of entries) {
-        const valueType = declaration.inputs
-            ? inputsToType(declaration.inputs)
-            : "Record<string, unknown>";
-        const aliasKey = isValidIdentifier(alias) ? alias : JSON.stringify(alias);
-        inputLines.push(`    ${aliasKey}: ${valueType};`);
-        if (declaration.outputs) {
-            resultLines.push(`    ${aliasKey}: ${objectFieldsToType(declaration.outputs)};`);
-        }
-    }
-    const resultsBlock = resultLines.length > 0
-        ? `
-  interface AppAgentResults {
-${resultLines.join("\n")}
-  }`
-        : "";
-    return `${HEADER}
-declare module "@lotics/app-sdk" {
-  interface AppAgents {
-${inputLines.join("\n")}
-  }${resultsBlock}
-}
-`;
-}

package/dist/generate_app_agents_dts.test.d.ts

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

package/dist/generate_app_agents_dts.test.js

@@ -1,45 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateAppAgentsDts } from "./generate_app_agents_dts.js";
-describe("generateAppAgentsDts", () => {
-    it("emits an empty AppAgents interface when no agents are declared", () => {
-        const out = generateAppAgentsDts(undefined);
-        expect(out).toContain("interface AppAgents {}");
-        expect(out).not.toContain("interface AppAgentResults");
-    });
-    it("types the input payload from declared inputs", () => {
-        const out = generateAppAgentsDts({
-            recognize: { inputs: { photo: { type: "file" }, prompt: { type: "text", required: false } } },
-        });
-        expect(out).toContain("recognize: {");
-        expect(out).toContain("photo: string;");
-        expect(out).toContain("prompt?: string;");
-    });
-    it("leaves an inputs-less agent as an untyped payload", () => {
-        const out = generateAppAgentsDts({ summarize: {} });
-        expect(out).toContain("summarize: Record<string, unknown>;");
-    });
-    it("emits AppAgentResults from declared outputs, including nested objects", () => {
-        const out = generateAppAgentsDts({
-            recognize: {
-                inputs: { photo: { type: "file" } },
-                outputs: {
-                    style: { type: "text" },
-                    dimensions: {
-                        type: "object",
-                        fields: { width_mm: { type: "number" }, height_mm: { type: "number" } },
-                    },
-                    confidence: { type: "number" },
-                },
-            },
-        });
-        expect(out).toContain("interface AppAgentResults {");
-        expect(out).toContain("style: string");
-        expect(out).toContain("width_mm: number");
-        expect(out).toContain("confidence: number");
-    });
-    it("is deterministic and sorts aliases", () => {
-        const a = generateAppAgentsDts({ zebra: {}, alpha: {} });
-        expect(a.indexOf("alpha:")).toBeLessThan(a.indexOf("zebra:"));
-        expect(generateAppAgentsDts({ zebra: {}, alpha: {} })).toBe(a);
-    });
-});

package/dist/generate_app_fields.d.ts

@@ -1,56 +0,0 @@
-/**
- * Codegen: emit a RUNTIME `.lotics/app_fields.ts` from a workspace schema.
- *
- * Unlike the `.d.ts` companions (which only augment types), this is a real
- * `.ts` module: apps import the string VALUES at runtime to address fields and
- * select options by a stable, human-readable alias instead of pasting opaque
- * `fld_…` / `opt_…` ids into their source:
- *
- *   import { F, OPT } from "../.lotics/app_fields";
- *   record.data[F.SHIPMENTS.status]            // "fld_…"
- *   if (status === OPT.SHIPMENTS.status.cleared) // "opt_…"
- *
- * Aliases are derived from display names (NFD-stripped, non-alnum → `_`, deduped
- * in stable order), so a rename on the platform re-runs codegen and the app's
- * call sites move with it. Pure function — same schema → same bytes. Idempotent.
- */
-/** One select option as it appears in a field's metadata. */
-export interface TableFieldOption {
-    /** Stable id (`opt_…`) — the value persisted in record data. */
-    id: string;
-    /** Display label the option alias is slugified from. */
-    label: string;
-}
-/** A single table field with the metadata codegen needs. */
-export interface TableFieldSchema {
-    /** Stable id (`fld_…`) — the value emitted under `F`. */
-    id: string;
-    /** Display name the field alias is slugified from. */
-    name: string;
-    /** Present only for select/multi-select fields — drives the `OPT` map. */
-    options?: TableFieldOption[];
-}
-/** The schema of one table, as returned by `client.getWorkspaceSchema`. */
-export interface TableSchema {
-    /** Stable id (`tbl_…`). Carried for fidelity; not emitted by name. */
-    id: string;
-    /** Display name the TABLE alias is slugified from. */
-    name: string;
-    fields: TableFieldSchema[];
-}
-/**
- * Slugify a display name to a valid TS identifier. NFD-normalize then strip
- * diacritics so "Lô hàng" and "Lo hang" don't collide on the accent, lowercase,
- * non-alnum → `_`, collapse runs, trim edge `_`. A leading digit (identifiers
- * can't start with one) and the empty result both get a `_` prefix/placeholder.
- * `upper` uppercases the result (TABLE aliases read as constants).
- */
-export declare function slugifyAlias(name: string, upper: boolean): string;
-/** A property key for an object literal — bare when a valid identifier, else quoted. */
-export declare function propKey(alias: string): string;
-/**
- * Generate the full `.lotics/app_fields.ts` source. `tables` is the resolved
- * workspace schema (the subset the app touches). An empty list yields valid,
- * empty `F`/`OPT` maps so the file always compiles and imports resolve.
- */
-export declare function generateAppFields(tables: TableSchema[]): string;

package/dist/generate_app_fields.js

@@ -1,148 +0,0 @@
-/**
- * Codegen: emit a RUNTIME `.lotics/app_fields.ts` from a workspace schema.
- *
- * Unlike the `.d.ts` companions (which only augment types), this is a real
- * `.ts` module: apps import the string VALUES at runtime to address fields and
- * select options by a stable, human-readable alias instead of pasting opaque
- * `fld_…` / `opt_…` ids into their source:
- *
- *   import { F, OPT } from "../.lotics/app_fields";
- *   record.data[F.SHIPMENTS.status]            // "fld_…"
- *   if (status === OPT.SHIPMENTS.status.cleared) // "opt_…"
- *
- * Aliases are derived from display names (NFD-stripped, non-alnum → `_`, deduped
- * in stable order), so a rename on the platform re-runs codegen and the app's
- * call sites move with it. Pure function — same schema → same bytes. Idempotent.
- */
-import { isValidIdentifier } from "./generate_app_workflows_dts.js";
-const HEADER = `// Auto-generated by 'lotics app codegen' (and app pull/dev/deploy).
-// DO NOT EDIT — regenerated from the workspace schema.
-//
-// Runtime field + option ids addressed by stable display-name aliases:
-//   record.data[F.<TABLE>.<field>]            → "fld_…"
-//   value === OPT.<TABLE>.<field>.<option>    → "opt_…"
-// A rename on the platform re-runs codegen and moves these in lockstep.
-`;
-/**
- * Slugify a display name to a valid TS identifier. NFD-normalize then strip
- * diacritics so "Lô hàng" and "Lo hang" don't collide on the accent, lowercase,
- * non-alnum → `_`, collapse runs, trim edge `_`. A leading digit (identifiers
- * can't start with one) and the empty result both get a `_` prefix/placeholder.
- * `upper` uppercases the result (TABLE aliases read as constants).
- */
-export function slugifyAlias(name, upper) {
-    const stripped = name
-        .normalize("NFD")
-        .replace(/[̀-ͯ]/g, "") // combining diacritical marks
-        .replace(/đ/g, "d")
-        .replace(/Đ/g, "D"); // not a combining mark — map explicitly
-    const cased = upper ? stripped.toUpperCase() : stripped.toLowerCase();
-    const slug = cased
-        .replace(/[^a-zA-Z0-9]+/g, "_")
-        .replace(/^_+|_+$/g, "");
-    if (slug === "")
-        return "_";
-    return /^[0-9]/.test(slug) ? `_${slug}` : slug;
-}
-/**
- * Assign each input a unique alias, preserving input order. The first claim on
- * a slug keeps it; later collisions get `_2`, `_3`, … so the mapping is stable
- * across regenerations (order is the schema's field/option order). Returns the
- * aliases positionally aligned with `names`.
- */
-function dedupeAliases(names, upper) {
-    const used = new Map();
-    return names.map((name) => {
-        const base = slugifyAlias(name, upper);
-        const seen = used.get(base);
-        if (seen === undefined) {
-            used.set(base, 1);
-            return base;
-        }
-        let n = seen + 1;
-        while (used.has(`${base}_${n}`))
-            n++;
-        used.set(base, n);
-        used.set(`${base}_${n}`, 1);
-        return `${base}_${n}`;
-    });
-}
-/** A property key for an object literal — bare when a valid identifier, else quoted. */
-export function propKey(alias) {
-    return isValidIdentifier(alias) ? alias : JSON.stringify(alias);
-}
-/** Resolve table + field aliases once, so the `F`/`OPT` maps and the union types agree. */
-function aliasTables(tables) {
-    const tableAliases = dedupeAliases(tables.map((t) => t.name), true);
-    return tables.map((table, i) => {
-        const fieldAliases = dedupeAliases(table.fields.map((f) => f.name), false);
-        return {
-            alias: tableAliases[i],
-            table,
-            fields: table.fields.map((field, j) => ({ alias: fieldAliases[j], field })),
-        };
-    });
-}
-/** Emit the `F` map: `{ TABLE: { field: "fld_…" } }` plus its literal-union type. */
-function emitFieldMap(aliased) {
-    const tableBlocks = aliased.map(({ alias, fields }) => {
-        const fieldLines = fields.map(({ alias: fieldAlias, field }) => `    ${propKey(fieldAlias)}: ${JSON.stringify(field.id)},`);
-        return `  ${propKey(alias)}: {\n${fieldLines.join("\n")}\n  },`;
-    });
-    return `export const F = {\n${tableBlocks.join("\n")}\n} as const;`;
-}
-/**
- * Emit the `OPT` map: `{ TABLE: { selectField: { option: "opt_…" } } }`. Only
- * fields that carry options appear. Tables and fields with no options are
- * omitted entirely (so `OPT.SHIPMENTS` may be absent — that's by design).
- */
-function emitOptionMap(aliased) {
-    const tableBlocks = [];
-    for (const { alias, fields } of aliased) {
-        const fieldBlocks = [];
-        for (const { alias: fieldAlias, field } of fields) {
-            const options = field.options ?? [];
-            if (options.length === 0)
-                continue;
-            const optionAliases = dedupeAliases(options.map((o) => o.label), false);
-            const optionLines = options.map((option, i) => `      ${propKey(optionAliases[i])}: ${JSON.stringify(option.id)},`);
-            fieldBlocks.push(`    ${propKey(fieldAlias)}: {\n${optionLines.join("\n")}\n    },`);
-        }
-        if (fieldBlocks.length === 0)
-            continue;
-        tableBlocks.push(`  ${propKey(alias)}: {\n${fieldBlocks.join("\n")}\n  },`);
-    }
-    if (tableBlocks.length === 0)
-        return `export const OPT = {} as const;`;
-    return `export const OPT = {\n${tableBlocks.join("\n")}\n} as const;`;
-}
-/**
- * Generate the full `.lotics/app_fields.ts` source. `tables` is the resolved
- * workspace schema (the subset the app touches). An empty list yields valid,
- * empty `F`/`OPT` maps so the file always compiles and imports resolve.
- */
-export function generateAppFields(tables) {
-    if (tables.length === 0) {
-        return `${HEADER}
-export const F = {} as const;
-
-export const OPT = {} as const;
-
-/** Field-id alias map (empty — no tables in scope). */
-export type AppFields = typeof F;
-/** Select-option alias map (empty — no tables in scope). */
-export type AppOptions = typeof OPT;
-`;
-    }
-    const aliased = aliasTables(tables);
-    return `${HEADER}
-${emitFieldMap(aliased)}
-
-${emitOptionMap(aliased)}
-
-/** Field-id alias map: \`F[<TABLE>][<field>]\` is the \`fld_…\` id (literal-typed). */
-export type AppFields = typeof F;
-/** Select-option alias map: \`OPT[<TABLE>][<field>][<option>]\` is the \`opt_…\` id. */
-export type AppOptions = typeof OPT;
-`;
-}

package/dist/generate_app_fields.test.d.ts

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

package/dist/generate_app_fields.test.js

@@ -1,108 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateAppFields, slugifyAlias } from "./generate_app_fields.js";
-describe("slugifyAlias", () => {
-    it("strips Vietnamese diacritics so accented + unaccented names don't collide on the accent", () => {
-        expect(slugifyAlias("Lô hàng", true)).toBe("LO_HANG");
-        expect(slugifyAlias("Đơn vị", true)).toBe("DON_VI");
-        expect(slugifyAlias("trạng thái", false)).toBe("trang_thai");
-    });
-    it("collapses non-alnum runs to a single underscore and trims edges", () => {
-        expect(slugifyAlias("  Báo giá / CTA  ", true)).toBe("BAO_GIA_CTA");
-        expect(slugifyAlias("a---b", false)).toBe("a_b");
-    });
-    it("prefixes a leading digit (identifiers can't start with one)", () => {
-        expect(slugifyAlias("40HC cont", false)).toBe("_40hc_cont");
-    });
-    it("falls back to '_' for an all-symbol or empty name", () => {
-        expect(slugifyAlias("***", false)).toBe("_");
-        expect(slugifyAlias("", true)).toBe("_");
-    });
-});
-describe("generateAppFields", () => {
-    it("emits empty F/OPT maps that still compile when no tables are in scope", () => {
-        const out = generateAppFields([]);
-        expect(out).toContain("export const F = {} as const;");
-        expect(out).toContain("export const OPT = {} as const;");
-    });
-    it("emits F entries keyed by slugified table + field names", () => {
-        const tables = [
-            {
-                id: "tbl_1",
-                name: "Lô hàng",
-                fields: [
-                    { id: "fld_status", name: "Trạng thái" },
-                    { id: "fld_eta", name: "ETA" },
-                ],
-            },
-        ];
-        const out = generateAppFields(tables);
-        expect(out).toContain("LO_HANG: {");
-        expect(out).toContain('trang_thai: "fld_status"');
-        expect(out).toContain('eta: "fld_eta"');
-    });
-    it("emits OPT only for fields that carry options, keyed by option label", () => {
-        const tables = [
-            {
-                id: "tbl_1",
-                name: "Shipments",
-                fields: [
-                    {
-                        id: "fld_status",
-                        name: "Status",
-                        options: [
-                            { id: "opt_open", label: "Open" },
-                            { id: "opt_cleared", label: "Cleared" },
-                        ],
-                    },
-                    { id: "fld_eta", name: "ETA" },
-                ],
-            },
-        ];
-        const out = generateAppFields(tables);
-        expect(out).toContain("SHIPMENTS: {");
-        expect(out).toContain('open: "opt_open"');
-        expect(out).toContain('cleared: "opt_cleared"');
-        // No options on ETA → it must not appear in the OPT block.
-        const optBlock = out.slice(out.indexOf("export const OPT"));
-        expect(optBlock).not.toContain("eta:");
-    });
-    it("omits a table from OPT entirely when none of its fields have options", () => {
-        const tables = [
-            { id: "tbl_1", name: "Plain", fields: [{ id: "fld_a", name: "A" }] },
-        ];
-        const out = generateAppFields(tables);
-        expect(out).toContain("export const OPT = {} as const;");
-    });
-    it("dedupes collided aliases with _2/_3 in stable field order", () => {
-        const tables = [
-            {
-                id: "tbl_1",
-                name: "T",
-                fields: [
-                    { id: "fld_a", name: "Ngày" },
-                    { id: "fld_b", name: "ngày" }, // slugifies to the same `ngay`
-                    { id: "fld_c", name: "Ngày!" }, // also `ngay`
-                ],
-            },
-        ];
-        const out = generateAppFields(tables);
-        expect(out).toContain('ngay: "fld_a"');
-        expect(out).toContain('ngay_2: "fld_b"');
-        expect(out).toContain('ngay_3: "fld_c"');
-    });
-    it("quotes a non-identifier alias only when slugify could not produce one", () => {
-        // An all-symbol name slugifies to "_", a valid identifier — so it's bare.
-        const tables = [
-            { id: "tbl_1", name: "***", fields: [{ id: "fld_a", name: "@@@" }] },
-        ];
-        const out = generateAppFields(tables);
-        expect(out).toContain("_: {");
-        expect(out).toContain('_: "fld_a"');
-    });
-    it("is deterministic — same schema → byte-identical output", () => {
-        const tables = [
-            { id: "tbl_1", name: "A", fields: [{ id: "fld_a", name: "X" }] },
-        ];
-        expect(generateAppFields(tables)).toBe(generateAppFields(tables));
-    });
-});

package/dist/generate_app_queries_dts.d.ts

@@ -1,21 +0,0 @@
-/**
- * Codegen: emit `.lotics/app_queries.d.ts` from the app's manifest.
- *
- * The starter tsconfig.json includes `.lotics/` in its `include` list, so this
- * file is auto-discovered by `tsc --noEmit` and the bundler. The augmentation
- * adds a typed entry to `AppQueries` for every alias declared in
- * `package.json#lotics.queries`, mapping each to its declared param shape:
- *
- *   - `params` declared → `alias: { …declared shape… }`
- *   - `params` omitted  → `alias: Record<string, never>` (no params)
- *
- * Result: `useQuery("alias", params)` is typed against the manifest, and an
- * undeclared alias is a compile-time error.
- *
- * The typed-input → TS-type mappers are shared with the workflow codegen —
- * both surfaces use the same `AppWorkflowInput` vocabulary.
- *
- * Pure function. Same inputs → same output. Idempotent.
- */
-import type { AppQueryDeclaration } from "./app_commands.js";
-export declare function generateAppQueriesDts(queries: Record<string, AppQueryDeclaration> | undefined): string;