@lotics/cli 0.88.0 → 0.88.1

package/dist/generate_app_queries_dts.js

@@ -1,57 +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 { inputsToType, 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.queries.
-//
-// This file gives \`useQuery("alias", params)\` typed params at call sites by
-// augmenting the @lotics/app-sdk \`AppQueries\` interface.
-
-import "@lotics/app-sdk";
-`;
-export function generateAppQueriesDts(queries) {
-    const entries = Object.entries(queries ?? {});
-    if (entries.length === 0) {
-        return `${HEADER}
-// No queries declared in package.json#lotics.queries.
-// Add an entry to enable typed useQuery("alias", params) at call sites.
-declare module "@lotics/app-sdk" {
-  interface AppQueries {}
-}
-`;
-    }
-    // Sort alphabetically for deterministic output across regenerations.
-    entries.sort(([a], [b]) => a.localeCompare(b));
-    const lines = [];
-    for (const [alias, declaration] of entries) {
-        // `inputsToType` returns `Record<string, never>` for an empty/absent
-        // param schema — exactly the no-params placeholder `useQuery` expects.
-        const valueType = inputsToType(declaration.params ?? {});
-        const aliasKey = isValidIdentifier(alias) ? alias : JSON.stringify(alias);
-        lines.push(`    ${aliasKey}: ${valueType};`);
-    }
-    return `${HEADER}
-declare module "@lotics/app-sdk" {
-  interface AppQueries {
-${lines.join("\n")}
-  }
-}
-`;
-}

package/dist/generate_app_workflows_dts.d.ts

@@ -1,39 +0,0 @@
-/**
- * Codegen: emit `.lotics/app_workflows.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 `AppWorkflows` for every alias declared in
- * `package.json#lotics.workflows`:
- *
- *   - Shorthand `"alias": "wfl_..."`        → `alias: Record<string, unknown>`
- *     (untyped — callsite accepts any payload)
- *   - Full `"alias": { workflow_id, inputs }` → `alias: { …declared shape… }`
- *     (typed — `useWorkflow<"alias">` returns a callable with shaped inputs)
- *
- * Pure function. Same inputs → same output. Idempotent.
- */
-import type { AppWorkflowDeclaration } from "./app_commands.js";
-export declare function generateAppWorkflowsDts(workflows: Record<string, AppWorkflowDeclaration> | undefined): string;
-/**
- * Map an `inputs: { key: AppWorkflowInput }` schema to a TS literal type
- * string. Mirrors the backend .d.ts generator's behavior — same vocabulary,
- * same conventions — so workflow body types and app call-site types agree.
- *
- * Note: `inputs` here is `Record<string, unknown>` rather than typed because
- * the CLI doesn't import zod or the apps schema (zero-dep policy in @lotics/sdk).
- * We pattern-match on the `type` field and let unknown shapes fall through
- * to `unknown` rather than throwing — the server's deploy-time schema parse
- * catches structurally-invalid declarations before they reach us.
- */
-export declare function inputsToType(inputs: Record<string, unknown>, opts?: {
-    nullableOptional?: boolean;
-}): string;
-/**
- * Map an output `fields` map (also the top-level `outputs`) to a TS object type.
- * Mirrors the backend `outputObjectToTsType`; recursive for nested object/array.
- * Zero-dep like `inputsToType` — pattern-matches on `type`, falls through to
- * `unknown` for shapes the server's schema parse rejects before we see them.
- */
-export declare function objectFieldsToType(fields: Record<string, unknown>): string;
-export declare function isValidIdentifier(name: string): boolean;

package/dist/generate_app_workflows_dts.js

@@ -1,229 +0,0 @@
-/**
- * Codegen: emit `.lotics/app_workflows.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 `AppWorkflows` for every alias declared in
- * `package.json#lotics.workflows`:
- *
- *   - Shorthand `"alias": "wfl_..."`        → `alias: Record<string, unknown>`
- *     (untyped — callsite accepts any payload)
- *   - Full `"alias": { workflow_id, inputs }` → `alias: { …declared shape… }`
- *     (typed — `useWorkflow<"alias">` returns a callable with shaped inputs)
- *
- * Pure function. Same inputs → same output. Idempotent.
- */
-const HEADER = `// Auto-generated by 'lotics app pull/dev/deploy'.
-// DO NOT EDIT — regenerated from package.json#lotics.workflows.
-//
-// This file gives \`useWorkflow("alias")\` a typed input parameter at call
-// sites by augmenting the @lotics/app-sdk \`AppWorkflows\` interface.
-
-import "@lotics/app-sdk";
-`;
-export function generateAppWorkflowsDts(workflows) {
-    const entries = Object.entries(workflows ?? {});
-    if (entries.length === 0) {
-        return `${HEADER}
-// No workflows declared in package.json#lotics.workflows.
-// Add an entry to enable typed useWorkflow<"alias"> at call sites.
-declare module "@lotics/app-sdk" {
-  interface AppWorkflows {}
-}
-`;
-    }
-    // Sort alphabetically for deterministic output across regenerations.
-    entries.sort(([a], [b]) => a.localeCompare(b));
-    const inputLines = [];
-    const resultLines = [];
-    for (const [alias, declaration] of entries) {
-        // declaration is `{ workflow_id, inputs?, outputs? }` per manifest schema.
-        // No typed inputs ⇒ untyped `Record<string, unknown>` callable. An alias with
-        // declared `outputs` also gets an `AppWorkflowResults` entry → typed result.data.
-        const valueType = declaration.inputs
-            ? inputsToType(declaration.inputs, { nullableOptional: true })
-            : "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 AppWorkflowResults {
-${resultLines.join("\n")}
-  }`
-        : "";
-    return `${HEADER}
-declare module "@lotics/app-sdk" {
-  interface AppWorkflows {
-${inputLines.join("\n")}
-  }${resultsBlock}
-}
-`;
-}
-/**
- * Map an `inputs: { key: AppWorkflowInput }` schema to a TS literal type
- * string. Mirrors the backend .d.ts generator's behavior — same vocabulary,
- * same conventions — so workflow body types and app call-site types agree.
- *
- * Note: `inputs` here is `Record<string, unknown>` rather than typed because
- * the CLI doesn't import zod or the apps schema (zero-dep policy in @lotics/sdk).
- * We pattern-match on the `type` field and let unknown shapes fall through
- * to `unknown` rather than throwing — the server's deploy-time schema parse
- * catches structurally-invalid declarations before they reach us.
- */
-export function inputsToType(inputs, opts) {
-    // A WORKFLOW optional input also accepts `null` — the diff-write "clear this
-    // field" signal (the backend validates it, the body forwards it to
-    // `update_records({ set: { fld: null } })`). So `useWorkflow` call sites can
-    // pass `null` to unset a field without a loose `Record<string, unknown>` cast.
-    // Query params + agent inputs have no "clear", so they stay `T` (the caller
-    // omits the flag). Only the TOP level is nullable: a nested object's optional
-    // field mirrors the backend's plain `.optional()` (the recursive call below
-    // omits the flag), so the type never claims a nested clear the server rejects.
-    const nullableOptional = opts?.nullableOptional === true;
-    const fields = [];
-    for (const [key, decl] of Object.entries(inputs)) {
-        if (decl === null || typeof decl !== "object")
-            continue;
-        const d = decl;
-        const tsType = inputDeclToTsType(d);
-        const isOptional = d.required === false;
-        const fieldType = isOptional && nullableOptional ? `${tsType} | null` : tsType;
-        const optional = isOptional ? "?" : "";
-        const fieldKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-        fields.push(`      ${fieldKey}${optional}: ${fieldType};`);
-    }
-    if (fields.length === 0)
-        return "Record<string, never>";
-    return `{\n${fields.join("\n")}\n    }`;
-}
-function inputDeclToTsType(decl) {
-    const type = decl.type;
-    switch (type) {
-        case "text":
-        case "email":
-        case "date":
-        case "datetime":
-            return "string";
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "record_link":
-        case "member": {
-            const inner = "string";
-            return decl.multi === true ? `ReadonlyArray<${inner}>` : inner;
-        }
-        case "select": {
-            const options = Array.isArray(decl.options) ? decl.options : [];
-            const literals = options
-                .map((o) => {
-                if (o !== null && typeof o === "object" && "value" in o && typeof o.value === "string") {
-                    return JSON.stringify(o.value);
-                }
-                return null;
-            })
-                .filter((v) => v !== null);
-            // The literal union keeps autocomplete for hand-typed ids, but a package
-            // app addresses options through the runtime-resolved OPT map (typed
-            // string — consumer workspaces bind DIFFERENT concrete ids), so the
-            // input must also accept string. `(string & {})` widens without
-            // collapsing the union in intellisense.
-            const inner = literals.length > 0 ? `${literals.join(" | ")} | (string & {})` : "string";
-            return decl.multi === true ? `ReadonlyArray<${inner}>` : inner;
-        }
-        case "date_range":
-            return "{ start: string; end: string }";
-        case "file":
-            return decl.multi === true ? "ReadonlyArray<string>" : "string";
-        case "object": {
-            const fields = decl.fields !== null && typeof decl.fields === "object"
-                ? decl.fields
-                : {};
-            return inputsToType(fields);
-        }
-        case "array": {
-            const items = decl.items !== null && typeof decl.items === "object"
-                ? decl.items
-                : null;
-            return items ? `ReadonlyArray<${inputDeclToTsType(items)}>` : "ReadonlyArray<unknown>";
-        }
-        case "json":
-            return "unknown";
-        default:
-            return "unknown";
-    }
-}
-/**
- * Map an output `fields` map (also the top-level `outputs`) to a TS object type.
- * Mirrors the backend `outputObjectToTsType`; recursive for nested object/array.
- * Zero-dep like `inputsToType` — pattern-matches on `type`, falls through to
- * `unknown` for shapes the server's schema parse rejects before we see them.
- */
-export function objectFieldsToType(fields) {
-    const parts = [];
-    for (const [key, decl] of Object.entries(fields)) {
-        if (decl === null || typeof decl !== "object")
-            continue;
-        const d = decl;
-        const optional = d.required === false ? "?" : "";
-        const fieldKey = isValidIdentifier(key) ? key : JSON.stringify(key);
-        parts.push(`${fieldKey}${optional}: ${outputDeclToTsType(d)}`);
-    }
-    if (parts.length === 0)
-        return "Record<string, never>";
-    return `{ ${parts.join("; ")} }`;
-}
-function outputDeclToTsType(decl) {
-    const type = decl.type;
-    switch (type) {
-        case "text":
-        case "email":
-        case "date":
-        case "datetime":
-            return "string";
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "record_link":
-            return decl.multi === true ? "ReadonlyArray<string>" : "string";
-        case "select": {
-            const options = Array.isArray(decl.options) ? decl.options : [];
-            const literals = options
-                .map((o) => o !== null && typeof o === "object" && "value" in o && typeof o.value === "string"
-                ? JSON.stringify(o.value)
-                : null)
-                .filter((v) => v !== null);
-            // Same widening on the READ side: a package app's runtime output value is
-            // the CONSUMER workspace's concrete opt_ id, not the origin's literal —
-            // exhaustive narrowing over origin literals would be unsound. `(string & {})`
-            // keeps autocomplete without lying about the value space.
-            const inner = literals.length > 0 ? `${literals.join(" | ")} | (string & {})` : "string";
-            return decl.multi === true ? `ReadonlyArray<${inner}>` : inner;
-        }
-        case "object": {
-            const fields = decl.fields !== null && typeof decl.fields === "object"
-                ? decl.fields
-                : {};
-            return objectFieldsToType(fields);
-        }
-        case "array": {
-            const items = decl.items !== null && typeof decl.items === "object"
-                ? decl.items
-                : null;
-            return items ? `ReadonlyArray<${outputDeclToTsType(items)}>` : "ReadonlyArray<unknown>";
-        }
-        case "json":
-            return "unknown";
-        default:
-            return "unknown";
-    }
-}
-const IDENTIFIER_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-export function isValidIdentifier(name) {
-    return IDENTIFIER_REGEX.test(name);
-}

package/dist/generate_app_workflows_dts.test.d.ts

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

package/dist/generate_app_workflows_dts.test.js

@@ -1,109 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generateAppWorkflowsDts } from "./generate_app_workflows_dts.js";
-describe("generateAppWorkflowsDts", () => {
-    it("emits no AppWorkflowResults block when no alias declares outputs", () => {
-        const dts = generateAppWorkflowsDts({
-            issue: { workflow_id: "wfl_1", inputs: { record_id: { type: "text" } } },
-        });
-        expect(dts).toContain("interface AppWorkflows {");
-        expect(dts).toContain("issue: {\n      record_id: string;\n    };");
-        expect(dts).not.toContain("AppWorkflowResults");
-    });
-    it("emits a typed AppWorkflowResults entry for an alias with a nested outputs schema", () => {
-        const dts = generateAppWorkflowsDts({
-            computeQuote: {
-                workflow_id: "wfl_2",
-                outputs: {
-                    total: { type: "number" },
-                    note: { type: "text", required: false },
-                    lines: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            fields: { name: { type: "text" }, amount: { type: "number" } },
-                        },
-                    },
-                },
-            },
-        });
-        expect(dts).toContain("interface AppWorkflowResults {");
-        // Nested array-of-object + optional field render correctly.
-        expect(dts).toContain("computeQuote: { total: number; note?: string; lines: ReadonlyArray<{ name: string; amount: number }> };");
-        // No declared inputs → untyped callable in AppWorkflows.
-        expect(dts).toContain("computeQuote: Record<string, unknown>;");
-    });
-    it("types an array-of-objects INPUT as ReadonlyArray<{…}>", () => {
-        const dts = generateAppWorkflowsDts({
-            importLines: {
-                workflow_id: "wfl_4",
-                inputs: {
-                    lines: {
-                        type: "array",
-                        items: {
-                            type: "object",
-                            fields: {
-                                sku: { type: "text" },
-                                qty: { type: "number" },
-                                note: { type: "text", required: false },
-                                ref: { type: "record_link", table_id: "tbl_x" },
-                            },
-                        },
-                    },
-                },
-            },
-        });
-        expect(dts).toContain("lines: ReadonlyArray<{");
-        expect(dts).toContain("sku: string;");
-        expect(dts).toContain("qty: number;");
-        expect(dts).toContain("note?: string;");
-        expect(dts).toContain("ref: string;");
-    });
-    it("types a TOP-LEVEL optional workflow input as `T | null` (the diff-write clear signal), required stays `T`, nested stays plain optional", () => {
-        const dts = generateAppWorkflowsDts({
-            updateTask: {
-                workflow_id: "wfl_u",
-                inputs: {
-                    record_id: { type: "record_link", table_id: "tbl_x" },
-                    due: { type: "date", required: false },
-                    status: { type: "select", required: false, options: [{ label: "Done", value: "opt_done" }] },
-                    tags: { type: "select", multi: true, required: false, options: [{ label: "A", value: "opt_a" }] },
-                    meta: {
-                        type: "object",
-                        required: false,
-                        fields: { note: { type: "text", required: false } },
-                    },
-                },
-            },
-        });
-        expect(dts).toContain("record_id: string;"); // required → NOT nullable
-        expect(dts).toContain("due?: string | null;"); // optional scalar → clearable
-        expect(dts).toContain('status?: "opt_done" | (string & {}) | null;');
-        expect(dts).toContain('tags?: ReadonlyArray<"opt_a" | (string & {})> | null;'); // optional multi
-        // The object itself is a top-level optional → nullable; its NESTED optional
-        // field mirrors the backend's plain `.optional()` (no `| null`).
-        expect(dts).toContain("note?: string;");
-        expect(dts).not.toContain("note?: string | null;");
-    });
-    it("maps record_link/select outputs the same way as inputs", () => {
-        const dts = generateAppWorkflowsDts({
-            lookup: {
-                workflow_id: "wfl_3",
-                outputs: {
-                    owner: { type: "record_link", table_id: "tbl_x" },
-                    tags: { type: "select", options: [{ label: "A", value: "a" }, { label: "B", value: "b" }], multi: true },
-                },
-            },
-        });
-        expect(dts).toContain('owner: string; tags: ReadonlyArray<"a" | "b" | (string & {})>');
-    });
-    it("types a multi file input as ReadonlyArray<string>, single file as string", () => {
-        const dts = generateAppWorkflowsDts({
-            attach: {
-                workflow_id: "wfl_f",
-                inputs: { one: { type: "file" }, many: { type: "file", multi: true } },
-            },
-        });
-        expect(dts).toContain("one: string");
-        expect(dts).toContain("many: ReadonlyArray<string>");
-    });
-});

package/dist/generate_package_fields.d.ts

@@ -1,49 +0,0 @@
-/**
- * Codegen: emit a RUNTIME `.lotics/app_fields.ts` for a PUBLISHED / linked app
- * (a package installation — its own published origin, or an install of another
- * org's package) from that installation's LIVE binding.
- *
- * The bespoke twin (`generate_app_fields.ts`) bakes THIS workspace's concrete
- * `fld_…`/`opt_…` ids at codegen time — correct when source and workspace
- * co-live, fundamentally wrong for a linked app (the source is portable and
- * installs into many workspaces, each with different ids). A linked app instead
- * resolves the SAME `F` / `OPT` / `ROLE` surface at MODULE LOAD from the
- * installation's binding via the SDK's `getAppBinding()` (the `binding` RPC op),
- * using top-level await — the ESM graph waits for the binding before any
- * importer evaluates, so `F.TASKS.title` is a plain string everywhere, including
- * module-top-level constants. A published origin's source is portable by
- * construction: same import path, same `F`/`OPT` shapes the bespoke codegen
- * emitted (contract aliases derive from the same display names it slugifies), so
- * the deployed source compiles unchanged, resolved per-install.
- *
- * The generator sources the alias SET from the app's LIVE binding (the `binding`
- * RPC / `appBinding` client method), NOT a contract file: every bound field
- * (`entity.field`), option (`entity.field:opt`), and role becomes an `F` / `OPT`
- * / `ROLE` entry keyed by its stable alias.
- *
- * A missing alias fails LOUD at boot (the binding is install-verified complete,
- * so a miss means the generated file is stale relative to the installed contract
- * version) — never a silent undefined key in a write.
- *
- * Requires the app build to target es2022+ (the starter's `build.target`) —
- * top-level await does not exist below it.
- */
-/**
- * A materialized app installation's binding — the exact shape the `binding` RPC
- * / `client.appBinding()` returns (a subset of the full package binding: only
- * the maps the client-side `F`/`OPT`/`ROLE` surface resolves through). Keys are
- * fully-qualified contract aliases: `fields` keyed `entity.field`, `options`
- * keyed `entity.field:opt`, `roles` keyed by role alias.
- */
-export interface AppFieldsBinding {
-    fields: Record<string, string>;
-    options: Record<string, string>;
-    roles: Record<string, string>;
-}
-/**
- * Generate the full binding-resolved `.lotics/app_fields.ts` source from an
- * installation's live binding. Pure — same binding → same bytes. Idempotent.
- * An empty binding yields valid, empty `F`/`OPT`/`ROLE` maps so the file always
- * compiles and imports resolve.
- */
-export declare function generatePackageAppFields(binding: AppFieldsBinding): string;

package/dist/generate_package_fields.js

@@ -1,157 +0,0 @@
-/**
- * Codegen: emit a RUNTIME `.lotics/app_fields.ts` for a PUBLISHED / linked app
- * (a package installation — its own published origin, or an install of another
- * org's package) from that installation's LIVE binding.
- *
- * The bespoke twin (`generate_app_fields.ts`) bakes THIS workspace's concrete
- * `fld_…`/`opt_…` ids at codegen time — correct when source and workspace
- * co-live, fundamentally wrong for a linked app (the source is portable and
- * installs into many workspaces, each with different ids). A linked app instead
- * resolves the SAME `F` / `OPT` / `ROLE` surface at MODULE LOAD from the
- * installation's binding via the SDK's `getAppBinding()` (the `binding` RPC op),
- * using top-level await — the ESM graph waits for the binding before any
- * importer evaluates, so `F.TASKS.title` is a plain string everywhere, including
- * module-top-level constants. A published origin's source is portable by
- * construction: same import path, same `F`/`OPT` shapes the bespoke codegen
- * emitted (contract aliases derive from the same display names it slugifies), so
- * the deployed source compiles unchanged, resolved per-install.
- *
- * The generator sources the alias SET from the app's LIVE binding (the `binding`
- * RPC / `appBinding` client method), NOT a contract file: every bound field
- * (`entity.field`), option (`entity.field:opt`), and role becomes an `F` / `OPT`
- * / `ROLE` entry keyed by its stable alias.
- *
- * A missing alias fails LOUD at boot (the binding is install-verified complete,
- * so a miss means the generated file is stale relative to the installed contract
- * version) — never a silent undefined key in a write.
- *
- * Requires the app build to target es2022+ (the starter's `build.target`) —
- * top-level await does not exist below it.
- */
-import { propKey } from "./generate_app_fields.js";
-const HEADER = `// Auto-generated by 'lotics app codegen' (linked/published app; also app pull/dev/deploy).
-// DO NOT EDIT — regenerated from the installation's live binding.
-//
-// A package installation resolves F/OPT/ROLE at MODULE LOAD from its binding
-// (contract alias → THIS workspace's concrete id) via the SDK's \`binding\` RPC.
-// Top-level await: the module graph waits for the binding before any importer
-// evaluates, so every entry is a plain string.
-import { getAppBinding } from "@lotics/app-sdk";
-
-const binding = await getAppBinding();
-
-function bound(map: Record<string, string>, key: string, kind: string): string {
-  const id = map[key];
-  if (id === undefined) {
-    throw new Error(
-      \`app_fields: \${kind} "\${key}" is not in this installation's binding — \` +
-        \`the generated app_fields.ts is stale relative to the installed contract version.\`,
-    );
-  }
-  return id;
-}
-`;
-/**
- * Reconstruct the entity → field → option nesting (plus role list) from the flat
- * binding maps. Entity/field/option aliases are slug-grammar (`[a-z][a-z0-9_]*`,
- * no `.` or `:`), so a field key splits on its single `.` and an option key on
- * its single `:`. First-seen order is preserved (the binding is written in
- * contract order), so the output is deterministic for a given binding. An option
- * whose owning field is absent from `fields` is skipped defensively — the binding
- * is the authority, and a select field is always present among the fields.
- */
-function parseBinding(binding) {
-    const entities = [];
-    const entityByAlias = new Map();
-    const fieldByKey = new Map();
-    for (const key of Object.keys(binding.fields)) {
-        const dot = key.indexOf(".");
-        if (dot <= 0 || dot >= key.length - 1)
-            continue;
-        const entityAlias = key.slice(0, dot);
-        const fieldAlias = key.slice(dot + 1);
-        let entity = entityByAlias.get(entityAlias);
-        if (entity === undefined) {
-            entity = { alias: entityAlias, fields: [] };
-            entityByAlias.set(entityAlias, entity);
-            entities.push(entity);
-        }
-        const field = { alias: fieldAlias, key, options: [] };
-        entity.fields.push(field);
-        fieldByKey.set(key, field);
-    }
-    for (const key of Object.keys(binding.options)) {
-        const colon = key.indexOf(":");
-        if (colon <= 0 || colon >= key.length - 1)
-            continue;
-        const fieldKey = key.slice(0, colon);
-        const optionAlias = key.slice(colon + 1);
-        const field = fieldByKey.get(fieldKey);
-        if (field === undefined)
-            continue;
-        field.options.push({ alias: optionAlias, key });
-    }
-    return { entities, roles: Object.keys(binding.roles) };
-}
-/** Emit the `F` map: `{ ENTITY: { field: bound(binding.fields, "entity.field", "field") } }`. */
-function emitFieldMap(entities) {
-    if (entities.length === 0)
-        return `export const F = {} as const;`;
-    const blocks = entities.map((entity) => {
-        const lines = entity.fields.map((field) => `    ${propKey(field.alias)}: bound(binding.fields, ${JSON.stringify(field.key)}, "field"),`);
-        return `  ${propKey(entity.alias.toUpperCase())}: {\n${lines.join("\n")}\n  },`;
-    });
-    return `export const F = {\n${blocks.join("\n")}\n} as const;`;
-}
-/**
- * Emit the `OPT` map: `{ ENTITY: { field: { opt: bound(binding.options, …) } } }`.
- * Only fields carrying options appear (an option-less field/entity is omitted).
- */
-function emitOptionMap(entities) {
-    const entityBlocks = [];
-    for (const entity of entities) {
-        const fieldBlocks = [];
-        for (const field of entity.fields) {
-            if (field.options.length === 0)
-                continue;
-            const lines = field.options.map((option) => `      ${propKey(option.alias)}: bound(binding.options, ${JSON.stringify(option.key)}, "option"),`);
-            fieldBlocks.push(`    ${propKey(field.alias)}: {\n${lines.join("\n")}\n    },`);
-        }
-        if (fieldBlocks.length === 0)
-            continue;
-        entityBlocks.push(`  ${propKey(entity.alias.toUpperCase())}: {\n${fieldBlocks.join("\n")}\n  },`);
-    }
-    if (entityBlocks.length === 0)
-        return `export const OPT = {} as const;`;
-    return `export const OPT = {\n${entityBlocks.join("\n")}\n} as const;`;
-}
-/** Emit the `ROLE` map: `{ role: bound(binding.roles, "role", "role") }`. */
-function emitRoleMap(roles) {
-    if (roles.length === 0)
-        return `export const ROLE = {} as const;`;
-    const lines = roles.map((role) => `  ${propKey(role)}: bound(binding.roles, ${JSON.stringify(role)}, "role"),`);
-    return `export const ROLE = {\n${lines.join("\n")}\n} as const;`;
-}
-/**
- * Generate the full binding-resolved `.lotics/app_fields.ts` source from an
- * installation's live binding. Pure — same binding → same bytes. Idempotent.
- * An empty binding yields valid, empty `F`/`OPT`/`ROLE` maps so the file always
- * compiles and imports resolve.
- */
-export function generatePackageAppFields(binding) {
-    const { entities, roles } = parseBinding(binding);
-    return `${HEADER}
-${emitFieldMap(entities)}
-
-${emitOptionMap(entities)}
-
-${emitRoleMap(roles)}
-
-/** Field-id alias map: \`F[<ENTITY>][<field>]\` is this installation's \`fld_…\` id. */
-export type AppFields = typeof F;
-/** Select-option alias map: \`OPT[<ENTITY>][<field>][<option>]\` is this installation's \`opt_…\` id. */
-export type AppOptions = typeof OPT;
-/** Role alias map: \`ROLE[<role>]\` is this installation's \`grp_…\` id. */
-export type AppRoles = typeof ROLE;
-`;
-}

package/dist/generate_package_fields.test.d.ts

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