@lotics/cli 0.71.0 → 0.74.0

package/dist/client.d.ts

@@ -43,6 +43,14 @@ export interface WorkspaceInfo {
     default_currency: string;
     organization_id: string;
     created_at: string;
+    /**
+     * Whether this is a throwaway app-package dev workspace (set with
+     * `lotics workspace create <name> --dev`). Gates the destructive package
+     * dev/sync scaffold + the server-side `package reset`. Optional because the
+     * list endpoint only carries it once the server serializes `is_dev`; an absent
+     * value is treated as non-dev by the guard (fail closed).
+     */
+    is_dev?: boolean;
 }
 export interface ToolExecuteResult {
     result: unknown;
@@ -65,6 +73,28 @@ export interface FileUploadResult {
         error: string;
     }>;
 }
+/**
+ * A materialized app package's binding — alias → this workspace's concrete id,
+ * one string-map per namespace. Mirrors the server's `bindingSchema`. The
+ * `workflows` map is the entity-lifecycle table-workflow ROW ledger (an artifact
+ * registry, not a schema binding), carried in the same shape. The CLI never
+ * interprets these maps — it round-trips them verbatim between `extract` (which
+ * emits the origin workspace's) and `adopt` (which replays it onto the app).
+ */
+export interface PackageBinding {
+    entities: Record<string, string>;
+    fields: Record<string, string>;
+    options: Record<string, string>;
+    templates: Record<string, string>;
+    roles: Record<string, string>;
+    workflows: Record<string, string>;
+}
+/** One finding from a bespoke→package extraction (`extractAppPackage`). */
+export interface ExtractFinding {
+    severity: "error" | "warning" | "info";
+    area: string;
+    message: string;
+}
 export declare const API_BASE_URL: string;
 export declare class LoticsClient {
     private apiKey;
@@ -88,10 +118,19 @@ export declare class LoticsClient {
         organization_name: string;
     }>;
     setWorkspaceId(id: string): void;
+    /** The workspace id the client targets (the `x-workspace-id` header), if resolved. */
+    getWorkspaceId(): string | undefined;
     listWorkspaces(): Promise<WorkspaceInfo[]>;
+    /**
+     * Resolve one workspace's info by id from the org's workspace list (the only
+     * API-key-accessible source carrying `is_dev`). Returns null when the
+     * workspace isn't visible to these credentials.
+     */
+    getWorkspaceInfo(id: string): Promise<WorkspaceInfo | null>;
     createWorkspace(body: {
         name: string;
         timezone?: string;
+        is_dev?: boolean;
     }): Promise<WorkspaceInfo>;
     deleteWorkspace(id: string): Promise<{
         id: string;
@@ -155,6 +194,12 @@ export declare class LoticsClient {
             inputs?: Record<string, unknown>;
             outputs?: Record<string, unknown>;
         }> | null;
+        /**
+         * Installation-level customization config values (the `useConfig()`
+         * source). Null/undefined for a bespoke app. The dev harness serves these
+         * through the `context` op for production parity.
+         */
+        config?: Record<string, string | number | boolean> | null;
     }>;
     createApp(body: {
         name: string;
@@ -166,6 +211,276 @@ export declare class LoticsClient {
         workspace_id: string;
         current_version_id: string | null;
     }>;
+    /**
+     * Install an app package version into the current workspace — scaffolds the
+     * data model, deploys the package bundle, materializes its
+     * queries/workflows/agents, and pins the installation. Returns the resulting
+     * installation app. `version` omitted installs the latest published version.
+     */
+    installAppPackage(package_id: string, body: {
+        version?: number;
+    }): Promise<{
+        id: string;
+        name: string;
+        workspace_id: string;
+        package_id: string | null;
+        package_version: number | null;
+        current_version_id: string | null;
+    }>;
+    /**
+     * Eject an installation from its package — re-deploy the pinned version's
+     * source as a workspace-owned app version, then sever the package link
+     * (clears `package_id`/`package_version`, stamps `ejected_at`). One-way: the
+     * app becomes a normal bespoke app and can no longer be upgraded. Returns the
+     * resulting app.
+     */
+    ejectAppPackage(app_id: string): Promise<{
+        id: string;
+        name: string;
+        workspace_id: string;
+        current_version_id: string | null;
+    }>;
+    /**
+     * Extract a DRAFT app package from an existing bespoke app — the promotion
+     * read (docs/app_packages.md § Promotion). Pure: nothing is written. Returns
+     * the alias-keyed draft `contract` (opaque to the CLI — the server is the
+     * validating authority), the origin workspace's `binding` (which doubles as
+     * the adopt binding), a findings `report` (any `error` ⇒ not publishable
+     * as-is), and the file-backed `template_files` the CLI must stage into the
+     * project at their `bytes_ref` paths. Backs `lotics package extract`.
+     * Admin-only.
+     */
+    extractAppPackage(app_id: string): Promise<{
+        contract: unknown;
+        binding: PackageBinding;
+        report: ExtractFinding[];
+        template_files: Array<{
+            bytes_ref: string;
+            file_id: string;
+            filename: string;
+        }>;
+    }>;
+    /**
+     * Adopt a published package onto an EXISTING (bespoke or ejected) app — the
+     * final promotion step. The workspace already holds the concrete objects, so
+     * nothing is scaffolded or rewritten: the server verifies the `binding` is
+     * complete, live, and FAITHFUL to the version's contract, then writes only the
+     * installation pin (the app becomes installation #1, upgradeable again). A
+     * ConflictError names the aliases that diverge. `version` omitted adopts the
+     * latest. Backs `lotics package adopt`. Admin-only.
+     */
+    adoptAppPackage(app_id: string, body: {
+        package_id: string;
+        version?: number;
+        binding: PackageBinding;
+    }): Promise<{
+        id: string;
+        name: string;
+        package_id: string | null;
+        package_version: number | null;
+    }>;
+    /**
+     * Fleet upgrade — bring every installation of a package across the CALLER'S
+     * org to the target version (latest when omitted) in one call. Hands-off
+     * applies only where the preview is clean; installations with breaking/
+     * drift/modified-core findings are skipped and reported for the normal
+     * per-installation consent flow. Backs `lotics package fleet-upgrade`.
+     * Admin-only; org-scoped (no workspace header needed).
+     */
+    fleetUpgradeAppPackage(package_id: string, body: {
+        version?: number;
+    }): Promise<{
+        package_id: string;
+        target_version: number;
+        installations: Array<{
+            app_id: string;
+            app_name: string;
+            workspace_id: string;
+            workspace_name: string;
+            from_version: number | null;
+            outcome: "upgraded" | "up_to_date" | "skipped" | "failed";
+            blockers?: {
+                breaking: number;
+                drift: number;
+                modified: number;
+            };
+            message?: string;
+        }>;
+    }>;
+    /**
+     * Create a registry app package — the Lotics-owned, workspace-agnostic
+     * blueprint. `lotics package publish` calls this on first publish (when the
+     * local manifest has no `package_id`), then publishes version 1 against the
+     * returned id. Admin-only.
+     */
+    createAppPackage(body: {
+        name: string;
+        description?: string | null;
+    }): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        latest_version: number;
+        is_official: boolean;
+        created_at: string;
+        updated_at: string;
+    }>;
+    /**
+     * Fetch a registry app package's metadata (incl. `latest_version` and the
+     * Lotics-backed `is_official` trust badge). Admin-only; cross-tenant by id.
+     */
+    getAppPackage(package_id: string): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        latest_version: number;
+        is_official: boolean;
+        created_at: string;
+        updated_at: string;
+    }>;
+    /**
+     * Publish a new immutable package version — multipart upload of the alias-keyed
+     * contract (JSON) + the prebuilt code bundle (a gzipped tarball carrying
+     * `source.tar.gz` + `dist.tar.gz` members). The server validates the contract +
+     * bundle, then allocates the next monotonic version. The `contract` is opaque
+     * JSON to the transport (the server is the validating authority). Admin-only.
+     */
+    publishAppPackageVersion(package_id: string, args: {
+        contract: unknown;
+        bundle: Buffer;
+        changelog?: string | null;
+    }): Promise<{
+        id: string;
+        package_id: string;
+        version: number;
+        bundle_r2_prefix: string;
+        changelog: string | null;
+        created_at: string;
+    }>;
+    /**
+     * Upgrade a package installation to a newer published version — extends the
+     * binding additively, re-materializes the target version's
+     * queries/workflows/agents (preserving workspace overlay), prunes dropped
+     * package artifacts, and bumps the pin. `version` omitted upgrades to the
+     * latest. Returns the resulting app. Admin-only.
+     */
+    upgradeAppPackage(app_id: string, body: {
+        version?: number;
+        /**
+         * Per preview finding: drifted binding entries (`<namespace>.<alias>`)
+         * take `"recreate"` or `{ bind_to: "<id>" }`; locally modified
+         * artifacts (`<kind>.<alias>`) take `"revert"` or `"keep"`. Required
+         * for every finding — anything unresolved refuses the upgrade.
+         */
+        resolutions?: Record<string, "recreate" | "revert" | "keep" | {
+            bind_to: string;
+        }>;
+    }): Promise<{
+        id: string;
+        name: string;
+        workspace_id: string;
+        package_id: string | null;
+        package_version: number | null;
+        current_version_id: string | null;
+    }>;
+    /**
+     * Preview a package upgrade — the additive plan, informational removals,
+     * breaking contract changes, the binding drift report, and the modified-core
+     * report — with no writes. Admin-only.
+     */
+    previewAppPackageUpgrade(app_id: string, opts?: {
+        version?: number;
+    }): Promise<{
+        app_id: string;
+        package_id: string;
+        from_version: number;
+        to_version: number;
+        changelog: string | null;
+        diff: {
+            added: Record<string, unknown[]>;
+            removed: Record<string, unknown[]>;
+            breaking: Array<{
+                entity: string;
+                alias: string;
+                kind: "field_type" | "link_target";
+                from: string;
+                to: string;
+            }>;
+        };
+        drift: Array<{
+            namespace: string;
+            alias: string;
+            id: string;
+        }>;
+        modified: Array<{
+            kind: string;
+            alias: string;
+        }>;
+    }>;
+    /**
+     * Re-bind a package role to a different workspace group (the current group
+     * still exists). Re-materializes at the pinned version; refuses over
+     * modified-core findings. Admin-only.
+     */
+    rebindAppPackageRole(app_id: string, body: {
+        role_alias: string;
+        group_id: string;
+    }): Promise<{
+        app_id: string;
+        role_alias: string;
+        group_id: string;
+        previous_group_id: string | null;
+    }>;
+    /**
+     * Workspace-wide dangling-reference sweep — active app/workflow artifacts
+     * whose prefixed schema ids no longer resolve. Backs
+     * `lotics workspace doctor`. Admin-only.
+     */
+    getWorkspaceDanglingReferences(): Promise<Array<{
+        namespace: string;
+        id: string;
+        referent: {
+            kind: string;
+            id: string;
+            name: string;
+        };
+    }>>;
+    /**
+     * Health check for a package installation — version pin vs. registry latest,
+     * binding drift, and locally modified core artifacts. Read-only; backs
+     * `lotics package doctor`. Admin-only.
+     */
+    getAppPackageHealth(app_id: string): Promise<{
+        app_id: string;
+        package_id: string;
+        package_name: string;
+        installed_version: number;
+        latest_version: number;
+        update_available: boolean;
+        drift: Array<{
+            namespace: string;
+            alias: string;
+            id: string;
+        }>;
+        modified: Array<{
+            kind: string;
+            alias: string;
+        }>;
+    }>;
+    /**
+     * Reset a package installation in a DEV workspace — drop the package-owned
+     * scaffolded tables and re-scaffold clean. Hard-gated server-side to dev
+     * workspaces (a non-dev workspace is refused). Returns the resulting app.
+     * Admin-only.
+     */
+    resetAppPackage(app_id: string): Promise<{
+        id: string;
+        name: string;
+        workspace_id: string;
+        package_id: string | null;
+        package_version: number | null;
+        current_version_id: string | null;
+    }>;
     /**
      * Resolve the display name + fields (incl. select options) of the given tables
      * — the schema `lotics app codegen` turns into the runtime `.lotics/app_fields.ts`
@@ -244,6 +559,12 @@ export declare class LoticsClient {
             image: string | null;
         }>;
     }>;
+    /** A package installation's alias→id maps (fields/options/roles) — the app's runtime F/OPT resolution. */
+    appBinding(app_id: string): Promise<{
+        fields: Record<string, string>;
+        options: Record<string, string>;
+        roles: Record<string, string>;
+    }>;
     /**
      * Resolve the full option set (key, label, color) of a named query's select
      * columns — the picker companion to `appQuery`. Mirrors

package/dist/client.js

@@ -136,9 +136,22 @@ export class LoticsClient {
     setWorkspaceId(id) {
         this.workspaceId = id;
     }
+    /** The workspace id the client targets (the `x-workspace-id` header), if resolved. */
+    getWorkspaceId() {
+        return this.workspaceId;
+    }
     async listWorkspaces() {
         return this.request("GET", "/v1/workspaces");
     }
+    /**
+     * Resolve one workspace's info by id from the org's workspace list (the only
+     * API-key-accessible source carrying `is_dev`). Returns null when the
+     * workspace isn't visible to these credentials.
+     */
+    async getWorkspaceInfo(id) {
+        const workspaces = await this.listWorkspaces();
+        return workspaces.find((w) => w.id === id) ?? null;
+    }
     async createWorkspace(body) {
         return this.request("POST", "/v1/workspaces", body);
     }
@@ -190,6 +203,153 @@ export class LoticsClient {
     async createApp(body) {
         return this.request("POST", "/v1/apps", body);
     }
+    /**
+     * Install an app package version into the current workspace — scaffolds the
+     * data model, deploys the package bundle, materializes its
+     * queries/workflows/agents, and pins the installation. Returns the resulting
+     * installation app. `version` omitted installs the latest published version.
+     */
+    async installAppPackage(package_id, body) {
+        return this.request("POST", `/v1/app-packages/${encodeURIComponent(package_id)}/installations`, body);
+    }
+    /**
+     * Eject an installation from its package — re-deploy the pinned version's
+     * source as a workspace-owned app version, then sever the package link
+     * (clears `package_id`/`package_version`, stamps `ejected_at`). One-way: the
+     * app becomes a normal bespoke app and can no longer be upgraded. Returns the
+     * resulting app.
+     */
+    async ejectAppPackage(app_id) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/eject`);
+    }
+    /**
+     * Extract a DRAFT app package from an existing bespoke app — the promotion
+     * read (docs/app_packages.md § Promotion). Pure: nothing is written. Returns
+     * the alias-keyed draft `contract` (opaque to the CLI — the server is the
+     * validating authority), the origin workspace's `binding` (which doubles as
+     * the adopt binding), a findings `report` (any `error` ⇒ not publishable
+     * as-is), and the file-backed `template_files` the CLI must stage into the
+     * project at their `bytes_ref` paths. Backs `lotics package extract`.
+     * Admin-only.
+     */
+    async extractAppPackage(app_id) {
+        return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-extract`);
+    }
+    /**
+     * Adopt a published package onto an EXISTING (bespoke or ejected) app — the
+     * final promotion step. The workspace already holds the concrete objects, so
+     * nothing is scaffolded or rewritten: the server verifies the `binding` is
+     * complete, live, and FAITHFUL to the version's contract, then writes only the
+     * installation pin (the app becomes installation #1, upgradeable again). A
+     * ConflictError names the aliases that diverge. `version` omitted adopts the
+     * latest. Backs `lotics package adopt`. Admin-only.
+     */
+    async adoptAppPackage(app_id, body) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-adopt`, body);
+    }
+    /**
+     * Fleet upgrade — bring every installation of a package across the CALLER'S
+     * org to the target version (latest when omitted) in one call. Hands-off
+     * applies only where the preview is clean; installations with breaking/
+     * drift/modified-core findings are skipped and reported for the normal
+     * per-installation consent flow. Backs `lotics package fleet-upgrade`.
+     * Admin-only; org-scoped (no workspace header needed).
+     */
+    async fleetUpgradeAppPackage(package_id, body) {
+        return this.request("POST", `/v1/app-packages/${encodeURIComponent(package_id)}/fleet-upgrade`, body);
+    }
+    // --- App packages (registry authoring + dev harness) ---
+    /**
+     * Create a registry app package — the Lotics-owned, workspace-agnostic
+     * blueprint. `lotics package publish` calls this on first publish (when the
+     * local manifest has no `package_id`), then publishes version 1 against the
+     * returned id. Admin-only.
+     */
+    async createAppPackage(body) {
+        return this.request("POST", "/v1/app-packages", body);
+    }
+    /**
+     * Fetch a registry app package's metadata (incl. `latest_version` and the
+     * Lotics-backed `is_official` trust badge). Admin-only; cross-tenant by id.
+     */
+    async getAppPackage(package_id) {
+        return this.request("GET", `/v1/app-packages/${encodeURIComponent(package_id)}`);
+    }
+    /**
+     * Publish a new immutable package version — multipart upload of the alias-keyed
+     * contract (JSON) + the prebuilt code bundle (a gzipped tarball carrying
+     * `source.tar.gz` + `dist.tar.gz` members). The server validates the contract +
+     * bundle, then allocates the next monotonic version. The `contract` is opaque
+     * JSON to the transport (the server is the validating authority). Admin-only.
+     */
+    async publishAppPackageVersion(package_id, args) {
+        const formData = new FormData();
+        formData.append("contract", JSON.stringify(args.contract));
+        formData.append("bundle", new Blob([new Uint8Array(args.bundle)], { type: "application/gzip" }), "bundle.tar.gz");
+        if (args.changelog)
+            formData.append("changelog", args.changelog);
+        const url = `${this.baseUrl}/v1/app-packages/${encodeURIComponent(package_id)}/versions`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.buildHeaders(), // no Content-Type — fetch sets the multipart boundary
+            body: formData,
+        });
+        if (!response.ok)
+            await this.throwResponseError(response);
+        return response.json();
+    }
+    /**
+     * Upgrade a package installation to a newer published version — extends the
+     * binding additively, re-materializes the target version's
+     * queries/workflows/agents (preserving workspace overlay), prunes dropped
+     * package artifacts, and bumps the pin. `version` omitted upgrades to the
+     * latest. Returns the resulting app. Admin-only.
+     */
+    async upgradeAppPackage(app_id, body) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-upgrade`, body);
+    }
+    /**
+     * Preview a package upgrade — the additive plan, informational removals,
+     * breaking contract changes, the binding drift report, and the modified-core
+     * report — with no writes. Admin-only.
+     */
+    async previewAppPackageUpgrade(app_id, opts = {}) {
+        const query = opts.version !== undefined ? `?version=${opts.version}` : "";
+        return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-upgrade${query}`);
+    }
+    /**
+     * Re-bind a package role to a different workspace group (the current group
+     * still exists). Re-materializes at the pinned version; refuses over
+     * modified-core findings. Admin-only.
+     */
+    async rebindAppPackageRole(app_id, body) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-rebind-role`, body);
+    }
+    /**
+     * Workspace-wide dangling-reference sweep — active app/workflow artifacts
+     * whose prefixed schema ids no longer resolve. Backs
+     * `lotics workspace doctor`. Admin-only.
+     */
+    async getWorkspaceDanglingReferences() {
+        return this.request("GET", "/v1/workspaces/dangling-references");
+    }
+    /**
+     * Health check for a package installation — version pin vs. registry latest,
+     * binding drift, and locally modified core artifacts. Read-only; backs
+     * `lotics package doctor`. Admin-only.
+     */
+    async getAppPackageHealth(app_id) {
+        return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/package-health`);
+    }
+    /**
+     * Reset a package installation in a DEV workspace — drop the package-owned
+     * scaffolded tables and re-scaffold clean. Hard-gated server-side to dev
+     * workspaces (a non-dev workspace is refused). Returns the resulting app.
+     * Admin-only.
+     */
+    async resetAppPackage(app_id) {
+        return this.request("POST", `/v1/apps/${encodeURIComponent(app_id)}/package-reset`);
+    }
     /**
      * Resolve the display name + fields (incl. select options) of the given tables
      * — the schema `lotics app codegen` turns into the runtime `.lotics/app_fields.ts`
@@ -273,6 +433,10 @@ export class LoticsClient {
         const qs = group_id ? `?group_id=${encodeURIComponent(group_id)}` : "";
         return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/members${qs}`);
     }
+    /** A package installation's alias→id maps (fields/options/roles) — the app's runtime F/OPT resolution. */
+    async appBinding(app_id) {
+        return this.request("GET", `/v1/apps/${encodeURIComponent(app_id)}/binding`);
+    }
     /**
      * Resolve the full option set (key, label, color) of a named query's select
      * columns — the picker companion to `appQuery`. Mirrors

package/dist/dev/rpc_handler.d.ts

@@ -6,7 +6,7 @@
  * { message }. Same shape as the production iframe-host's error path.
  */
 import { LoticsClient } from "../client.js";
-export type RpcOp = "query" | "field_options" | "workflow" | "members" | "context" | "upload_url" | "upload_complete" | "comments.list" | "comments.create" | "comments.update" | "comments.delete" | "comments.counts";
+export type RpcOp = "query" | "field_options" | "workflow" | "members" | "context" | "binding" | "upload_url" | "upload_complete" | "comments.list" | "comments.create" | "comments.update" | "comments.delete" | "comments.counts";
 export interface RpcRequest {
     app_id: string;
     op: RpcOp;

package/dist/dev/rpc_handler.js

@@ -11,6 +11,7 @@ const SUPPORTED_OPS = new Set([
     "workflow",
     "members",
     "context",
+    "binding",
     "upload_url",
     "upload_complete",
     "comments.list",
@@ -31,11 +32,16 @@ export async function dispatchRpc(client, body, opts) {
             // In production the iframe host supplies the context; here we resolve the
             // effective viewer from the CLI key (the view-as target when the client
             // carries `x-view-as-member-id`, else the key's owner), so `useViewer`
-            // and `is_current_member` agree in the dev loop.
-            const who = await client.whoami();
+            // and `is_current_member` agree in the dev loop. The installation's
+            // stored config is fetched live for the same parity: `useConfig()` must
+            // render the same values in the dev loop as in production, including
+            // edits made in the product mid-session (fresh on every app load, no
+            // dev-server restart).
+            const [who, app] = await Promise.all([client.whoami(), client.getApp(body.app_id)]);
             return {
                 member_id: who.member_id,
                 comments_enabled: opts?.commentsEnabled ?? false,
+                config: app.config ?? {},
             };
         }
         case "query": {
@@ -71,6 +77,8 @@ export async function dispatchRpc(client, body, opts) {
             const p = body.payload;
             return client.appMembers(body.app_id, p?.group);
         }
+        case "binding":
+            return client.appBinding(body.app_id);
         case "upload_url": {
             const p = body.payload;
             if (!p ||

package/dist/dev/rpc_handler.test.js

@@ -12,15 +12,33 @@ const WHOAMI = {
     organization_name: "Org",
 };
 describe("dispatchRpc — context op", () => {
-    it("resolves the viewer member_id from whoami + manifest comments_enabled", async () => {
-        const client = mockClient({ whoami: async () => WHOAMI });
+    it("resolves the viewer from whoami and the installation's stored config from the live app row", async () => {
+        const client = mockClient({
+            whoami: async () => WHOAMI,
+            getApp: async () => ({
+                id: "app_x",
+                name: "App X",
+                workspace_id: "wsp_1",
+                current_version_id: null,
+                config: { page_size: 50 },
+            }),
+        });
         const result = await dispatchRpc(client, { app_id: "app_x", op: "context", payload: {} }, { commentsEnabled: true });
-        expect(result).toEqual({ member_id: "mbr_viewer", comments_enabled: true });
+        expect(result).toEqual({ member_id: "mbr_viewer", comments_enabled: true, config: { page_size: 50 } });
     });
-    it("defaults comments_enabled to false when the manifest declares none", async () => {
-        const client = mockClient({ whoami: async () => WHOAMI });
+    it("defaults comments_enabled to false and config to empty for a bespoke app", async () => {
+        const client = mockClient({
+            whoami: async () => WHOAMI,
+            getApp: async () => ({
+                id: "app_x",
+                name: "App X",
+                workspace_id: "wsp_1",
+                current_version_id: null,
+                config: null,
+            }),
+        });
         const result = await dispatchRpc(client, { app_id: "app_x", op: "context", payload: {} });
-        expect(result).toEqual({ member_id: "mbr_viewer", comments_enabled: false });
+        expect(result).toEqual({ member_id: "mbr_viewer", comments_enabled: false, config: {} });
     });
     it("rejects an op that isn't supported", async () => {
         const client = mockClient({});

package/dist/generate_app_fields.d.ts

@@ -46,6 +46,8 @@ export interface TableSchema {
  * `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,

package/dist/generate_app_fields.js

@@ -68,7 +68,7 @@ function dedupeAliases(names, upper) {
     });
 }
 /** A property key for an object literal — bare when a valid identifier, else quoted. */
-function propKey(alias) {
+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. */