zinkee 0.1.40 → 0.1.42

package/dist/index.js

@@ -9,6 +9,27 @@ import chalk from "chalk";
 var readOutput = "table-json";
 var writeOutput = "json-only";
 var commandRegistry = {
+  "formulas recompute field": {
+    command: "formulas recompute field",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "formulas recompute schema": {
+    command: "formulas recompute schema",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
+  "formulas recompute workspace": {
+    command: "formulas recompute workspace",
+    accessLevel: "write",
+    supportsExample: true,
+    supportsRaw: false,
+    output: writeOutput
+  },
   "config path": {
     command: "config path",
     accessLevel: "read",
@@ -2229,6 +2250,60 @@ function buildCommandExamples(examples) {
 }
 var SAMPLE_UUID = "550e8400-e29b-41d4-a716-446655440001";
 var specificExamples = {
+  "formulas recompute field": buildCommandExamples([
+    {
+      description: "Queue a full recalculation of one formula column.",
+      command: "zinkee --json formulas recompute field invoices total",
+      raw: `{
+  "scope": "FIELD",
+  "schema": "invoices",
+  "field": "total"
+}`,
+      response: `{
+  "requestId": "02ab5d47-cb5f-4eb2-afb8-e9a3a9eb34d4",
+  "scope": "FIELD",
+  "formulaCount": 1,
+  "skippedFormulaCount": 0,
+  "eventsQueued": 1,
+  "status": "QUEUED"
+}`
+    }
+  ]),
+  "formulas recompute schema": buildCommandExamples([
+    {
+      description: "Queue recalculation of every active formula in one schema.",
+      command: "zinkee --json formulas recompute schema invoices --yes",
+      raw: `{
+  "scope": "SCHEMA",
+  "schema": "invoices"
+}`,
+      response: `{
+  "requestId": "02ab5d47-cb5f-4eb2-afb8-e9a3a9eb34d4",
+  "scope": "SCHEMA",
+  "formulaCount": 8,
+  "skippedFormulaCount": 1,
+  "eventsQueued": 8,
+  "status": "QUEUED"
+}`
+    }
+  ]),
+  "formulas recompute workspace": buildCommandExamples([
+    {
+      description: "Queue recalculation of every active formula in the workspace.",
+      command: "zinkee --json formulas recompute workspace --yes",
+      raw: `{
+  "scope": "WORKSPACE"
+}`,
+      response: `{
+  "requestId": "02ab5d47-cb5f-4eb2-afb8-e9a3a9eb34d4",
+  "scope": "WORKSPACE",
+  "formulaCount": 24,
+  "skippedFormulaCount": 2,
+  "eventsQueued": 24,
+  "status": "QUEUED"
+}`
+    }
+  ]),
   "profiles list": buildCommandExamples([
     {
       description: "List all local profiles. The CLI always redacts the apiKey to ******** plus the last 4 chars.",
@@ -6573,7 +6648,7 @@ ${index + 1}. ${example.description}
 
 // src/program.ts
 import { createRequire } from "module";
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/config.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -7392,23 +7467,45 @@ function readJsonValueOption(raw, rawFile, rawLabel, rawFileLabel) {
 function readJsonObjectOption(raw, rawFile, rawLabel, rawFileLabel) {
   return readJsonValueOption(raw, rawFile, rawLabel, rawFileLabel) ?? {};
 }
+var NO_VALUE_COMPARATORS = /* @__PURE__ */ new Set([
+  "chg",
+  "changes",
+  "ie",
+  "is_empty",
+  "ine",
+  "is_not_empty"
+]);
+function isNoValueComparator(comparator) {
+  return NO_VALUE_COMPARATORS.has(comparator.toLowerCase());
+}
+function conditionFormatError(input) {
+  return new CliError(
+    "invalid_cli_usage",
+    `Expected condition in the form field:comparator:value, or field:comparator for comparators without value (chg, ie, ine), received "${input}".`
+  );
+}
 function parseCondition(input) {
   const firstSeparator = input.indexOf(":");
   const secondSeparator = input.indexOf(":", firstSeparator + 1);
-  if (firstSeparator <= 0 || secondSeparator <= firstSeparator + 1) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected condition in the form field:comparator:value, received "${input}".`
-    );
+  if (firstSeparator <= 0) {
+    throw conditionFormatError(input);
+  }
+  if (secondSeparator === -1) {
+    const field2 = input.slice(0, firstSeparator).trim();
+    const comparator2 = input.slice(firstSeparator + 1).trim();
+    if (!field2 || !comparator2 || !isNoValueComparator(comparator2)) {
+      throw conditionFormatError(input);
+    }
+    return { field: field2, comparator: comparator2, values: [] };
+  }
+  if (secondSeparator <= firstSeparator + 1) {
+    throw conditionFormatError(input);
   }
   const field = input.slice(0, firstSeparator).trim();
   const comparator = input.slice(firstSeparator + 1, secondSeparator).trim();
   const value = input.slice(secondSeparator + 1).trim();
   if (!field || !comparator || !value) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected condition in the form field:comparator:value, received "${input}".`
-    );
+    throw conditionFormatError(input);
   }
   return {
     field,
@@ -7555,10 +7652,11 @@ function normalizeAutomationConditions(conditions, label, options) {
     const field = typeof condition.field === "string" ? condition.field.trim() : "";
     const comparator = typeof condition.comparator === "string" ? condition.comparator.trim() : "";
     const values = condition.values;
-    if (!field || !comparator || !Array.isArray(values) || values.length === 0) {
+    const allowsEmptyValues = isNoValueComparator(comparator);
+    if (!field || !comparator || !Array.isArray(values) || values.length === 0 && !allowsEmptyValues) {
       throw new CliError(
         "invalid_cli_usage",
-        `Expected ${label} ${index + 1} to contain "field", "comparator", and a non-empty "values" array.`
+        `Expected ${label} ${index + 1} to contain "field", "comparator", and a non-empty "values" array (comparators without value, e.g. chg/ie/ine, accept an empty array).`
       );
     }
     return {
@@ -8035,7 +8133,7 @@ function addTriggerPayloadOptions(command) {
     []
   ).option(
     "--condition <field:comparator:value>",
-    "trigger condition",
+    "trigger condition (use field:comparator for comparators without value: chg, ie, ine)",
     collectValues,
     []
   ).option(
@@ -8062,7 +8160,12 @@ function addActionPayloadOptions(command) {
   return command.option(
     "--type <type>",
     "action type (create_record|update_record|search_records|send_message|http_request|execute_plugin|generate_document)"
-  ).option("--name <name>", "action name").option("--target-schema <uuid>", "target schema id").option("--map <field=value>", "field mapping", collectValues, []).option("--map-json <field=json>", "JSON field mapping", collectValues, []).option("--condition <field:comparator:value>", "action condition", collectValues, []).option("--condition-json <json>", "action condition as JSON", collectValues, []).option("--use-trigger-record", "use the triggering record").option("--method <method>", "HTTP method").option("--url <url>", "HTTP target URL").option("--header <key=value>", "HTTP header", collectValues, []).option("--body <json>", "HTTP request body as JSON").option("--body-file <path>", "path to HTTP request body JSON").option("--content-type <type>", "HTTP content type").option(
+  ).option("--name <name>", "action name").option("--target-schema <uuid>", "target schema id").option("--map <field=value>", "field mapping", collectValues, []).option("--map-json <field=json>", "JSON field mapping", collectValues, []).option(
+    "--condition <field:comparator:value>",
+    "action condition (use field:comparator for comparators without value: ie, ine)",
+    collectValues,
+    []
+  ).option("--condition-json <json>", "action condition as JSON", collectValues, []).option("--use-trigger-record", "use the triggering record").option("--method <method>", "HTTP method").option("--url <url>", "HTTP target URL").option("--header <key=value>", "HTTP header", collectValues, []).option("--body <json>", "HTTP request body as JSON").option("--body-file <path>", "path to HTTP request body JSON").option("--content-type <type>", "HTTP content type").option(
     "--timeout-ms <n>",
     "HTTP timeout in milliseconds",
     parseNonNegativeInteger
@@ -10502,42 +10605,220 @@ function registerFilesCommands(program, options = {}) {
   });
 }
 
-// src/commands/logs.ts
+// src/commands/formulas.ts
 import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
 
-// src/api/logs.ts
+// src/api/formulas.ts
 function selectorValue6(selector) {
   return selector.value;
 }
+function toRequestBody(input) {
+  if (input.scope === "FIELD") {
+    return {
+      scope: input.scope,
+      schema: selectorValue6(input.schema),
+      field: selectorValue6(input.field)
+    };
+  }
+  if (input.scope === "SCHEMA") {
+    return {
+      scope: input.scope,
+      schema: selectorValue6(input.schema)
+    };
+  }
+  return { scope: input.scope };
+}
+var FormulasApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  recompute(input) {
+    return this.client.requestJson(
+      "/api/v2/formulas:recompute",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(toRequestBody(input))
+      }
+    );
+  }
+};
+
+// src/commands/formulas.ts
+function getCommandIo7(stdout) {
+  return stdout ?? process.stdout;
+}
+function writeLine7(stdout, value) {
+  stdout.write(`${value}
+`);
+}
+function getGlobalOptions7(command) {
+  return command.optsWithGlobals();
+}
+function toConfigurationError7(filePath, error) {
+  if (error instanceof CliError) {
+    throw error;
+  }
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
+  }
+  if (error instanceof Error) {
+    throw new CliError("configuration_error", error.message);
+  }
+  throw error;
+}
+function createFormulasApi(command, filePath) {
+  try {
+    const config = readRuntimeConfig(filePath);
+    const runtime = resolveRuntimeContext(config, getGlobalOptions7(command));
+    if (!runtime.baseUrl) {
+      throw new CliError(
+        "configuration_error",
+        `Resolved profile "${runtime.profile}" is missing a base URL.`
+      );
+    }
+    return {
+      api: new FormulasApi(
+        new ApiClient({
+          baseUrl: runtime.baseUrl,
+          apiKey: runtime.apiKey
+        })
+      ),
+      json: runtime.json,
+      readOnly: runtime.readOnly
+    };
+  } catch (error) {
+    toConfigurationError7(filePath, error);
+  }
+}
+function ensureWritable6(commandName, readOnly) {
+  if (readOnly) {
+    throw new CliError(
+      "command_not_allowed_in_read_only_mode",
+      `Command "${commandName}" is not allowed in read-only mode.`,
+      {
+        commandMode: "write",
+        executionMode: "read-only"
+      }
+    );
+  }
+}
+function ensureConfirmed(commandName, confirmed) {
+  if (!confirmed) {
+    throw new CliError(
+      "invalid_cli_usage",
+      `Command "${commandName}" requires --yes because it may enqueue a large recalculation.`
+    );
+  }
+}
+function parseUuidOrSlugSelector6(input) {
+  try {
+    return normalizeUuidOrSlug(input);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid selector.";
+    throw new InvalidArgumentError6(message);
+  }
+}
+function emitResult(stdout, commandName, result, configPath, json) {
+  if (json) {
+    writeLine7(
+      stdout,
+      JSON.stringify(buildJsonSuccess(result, { command: commandName, configPath }))
+    );
+    return;
+  }
+  writeLine7(
+    stdout,
+    `Queued ${result.eventsQueued} formula recalculation event(s) for ${result.scope.toLowerCase()} scope (request ${result.requestId}).`
+  );
+}
+async function recompute(command, commandName, input, options, requireConfirmation, confirmed) {
+  const configPath = options.configPath ?? defaultConfigPath;
+  const stdout = getCommandIo7(options.stdout);
+  const { api, json, readOnly } = createFormulasApi(command, configPath);
+  ensureWritable6(commandName, readOnly);
+  if (requireConfirmation) {
+    ensureConfirmed(commandName, confirmed);
+  }
+  const result = await api.recompute(input);
+  emitResult(stdout, commandName, result, configPath, json);
+}
+function registerFormulasCommands(program, options = {}) {
+  const formulas = program.command("formulas").description("Recalculate formula values");
+  const recomputeCommand = formulas.command("recompute").description("Queue a full formula recalculation");
+  recomputeCommand.command("field").description("Queue recalculation of one formula column").argument("<schema>", "schema UUID or slug", parseUuidOrSlugSelector6).argument("<field>", "formula field UUID or slug", parseUuidOrSlugSelector6).action(
+    async function action(schema, field) {
+      await recompute(
+        this,
+        "formulas recompute field",
+        { scope: "FIELD", schema, field },
+        options,
+        false
+      );
+    }
+  );
+  recomputeCommand.command("schema").description("Queue recalculation of all active formulas in one schema").argument("<schema>", "schema UUID or slug", parseUuidOrSlugSelector6).option("--yes", "confirm the potentially expensive recalculation").action(
+    async function action(schema, commandOptions) {
+      await recompute(
+        this,
+        "formulas recompute schema",
+        { scope: "SCHEMA", schema },
+        options,
+        true,
+        commandOptions.yes
+      );
+    }
+  );
+  recomputeCommand.command("workspace").description("Queue recalculation of all active formulas in the workspace").option("--yes", "confirm the potentially expensive recalculation").action(async function action(commandOptions) {
+    await recompute(
+      this,
+      "formulas recompute workspace",
+      { scope: "WORKSPACE" },
+      options,
+      true,
+      commandOptions.yes
+    );
+  });
+}
+
+// src/commands/logs.ts
+import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
+
+// src/api/logs.ts
+function selectorValue7(selector) {
+  return selector.value;
+}
 var LogsApi = class {
   constructor(client) {
     this.client = client;
   }
   listLogs(schema, recordId) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue6(schema)}/records/${recordId}/logs`
+      `/api/v2/schemas/${selectorValue7(schema)}/records/${recordId}/logs`
     );
   }
 };
 
 // src/commands/logs.ts
-function getCommandIo7(stdout) {
+function getCommandIo8(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine7(stdout, value) {
+function writeLine8(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions7(command) {
+function getGlobalOptions8(command) {
   return command.optsWithGlobals();
 }
 function emitJson7(stdout, commandName, data, ..._extra) {
-  writeLine7(
+  writeLine8(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName }))
   );
 }
-function toConfigurationError7(filePath, error) {
+function toConfigurationError8(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -10552,7 +10833,7 @@ function toConfigurationError7(filePath, error) {
 function createLogsApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions7(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions8(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -10569,15 +10850,15 @@ function createLogsApi(command, filePath) {
       json: runtime.json
     };
   } catch (error) {
-    toConfigurationError7(filePath, error);
+    toConfigurationError8(filePath, error);
   }
 }
-function parseUuidOrSlugSelector6(input) {
+function parseUuidOrSlugSelector7(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError6(message);
+    throw new InvalidArgumentError7(message);
   }
 }
 function isJsonObject5(value) {
@@ -10597,9 +10878,9 @@ function emitTable3(stdout, data) {
 }
 function registerLogsCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo7(options.stdout);
+  const stdout = getCommandIo8(options.stdout);
   const logs = program.command("logs").description("Inspect record change logs");
-  logs.command("list").description("List change logs for a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector6).action(async function action(schema, record) {
+  logs.command("list").description("List change logs for a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, record) {
     const { api, json } = createLogsApi(this, filePath);
     const data = await api.listLogs(schema, record.value);
     if (json) {
@@ -10612,7 +10893,7 @@ function registerLogsCommands(program, options = {}) {
 
 // src/commands/navigation.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
 
 // src/api/navigation.ts
 function jsonOptions5(body, method) {
@@ -10624,7 +10905,7 @@ function jsonOptions5(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue7(selector) {
+function selectorValue8(selector) {
   return selector.value;
 }
 var NavigationApi = class {
@@ -10642,13 +10923,13 @@ var NavigationApi = class {
   }
   updateFolder(folder, body) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
+      `/api/v2/navigation/folders/${selectorValue8(folder)}`,
       jsonOptions5(body, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
+      `/api/v2/navigation/folders/${selectorValue8(folder)}`,
       { method: "DELETE" }
     );
   }
@@ -10661,20 +10942,20 @@ var NavigationApi = class {
 };
 
 // src/commands/navigation.ts
-function getCommandIo8(stdout) {
+function getCommandIo9(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine8(stdout, value) {
+function writeLine9(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions8(command) {
+function getGlobalOptions9(command) {
   return command.optsWithGlobals();
 }
 function emitJson8(stdout, commandName, data, configPath) {
-  writeLine8(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
+  writeLine9(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
 }
-function toConfigurationError8(filePath, error) {
+function toConfigurationError9(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -10689,7 +10970,7 @@ function toConfigurationError8(filePath, error) {
 function createNavigationApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions8(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions9(command));
     if (!runtime.baseUrl) {
       throw new CliError("configuration_error", `Resolved profile "${runtime.profile}" is missing a base URL.`);
     }
@@ -10704,10 +10985,10 @@ function createNavigationApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError8(filePath, error);
+    toConfigurationError9(filePath, error);
   }
 }
-function ensureWritable6(commandName, readOnly, mode) {
+function ensureWritable7(commandName, readOnly, mode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -10716,12 +10997,12 @@ function ensureWritable6(commandName, readOnly, mode) {
     );
   }
 }
-function parseUuidOrSlugSelector7(input) {
+function parseUuidOrSlugSelector8(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function parseInteger(value, flagName) {
@@ -10800,7 +11081,7 @@ function folderRows2(folders) {
 }
 function registerNavigationCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo8(options.stdout);
+  const stdout = getCommandIo9(options.stdout);
   const navigation = program.command("navigation").description("Manage workspace navigation");
   const folders = navigation.command("folders").description("Manage navigation folders");
   folders.command("list").description("List navigation folders").action(async function action() {
@@ -10812,7 +11093,7 @@ function registerNavigationCommands(program, options = {}) {
     }
     printTable(folderRows2(data), ["id", "order", "name", "resourceCount"], stdout);
   });
-  folders.command("get").description("Get a navigation folder by UUID or exact name").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).action(async function action(folder) {
+  folders.command("get").description("Get a navigation folder by UUID or exact name").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector8).action(async function action(folder) {
     const { api, json } = createNavigationApi(this, filePath);
     const data = await api.listFolders();
     const resolved = resolveFolder2(data, folder);
@@ -10824,17 +11105,17 @@ function registerNavigationCommands(program, options = {}) {
   });
   folders.command("create").description("Create a navigation folder").requiredOption("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)").option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"color":"blue","icon":"chart-line"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable6("navigation folders create", readOnly, "write");
+    ensureWritable7("navigation folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderBody(commandOptions));
     if (json) {
       emitJson8(stdout, "navigation folders create", data, filePath);
       return;
     }
-    writeLine8(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
+    writeLine9(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
   });
-  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).option("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)").option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"color":"blue","icon":"chart-line"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector8).option("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)").option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"color":"blue","icon":"chart-line"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable6("navigation folders update", readOnly, "write");
+    ensureWritable7("navigation folders update", readOnly, "write");
     const allFolders = await api.listFolders();
     const resolved = resolveFolder2(allFolders, folder);
     const body = buildFolderBody(commandOptions);
@@ -10846,11 +11127,11 @@ function registerNavigationCommands(program, options = {}) {
       emitJson8(stdout, "navigation folders update", data, filePath);
       return;
     }
-    writeLine8(stdout, `Updated navigation folder "${String(data.name ?? resolved.name ?? resolved.id)}".`);
+    writeLine9(stdout, `Updated navigation folder "${String(data.name ?? resolved.name ?? resolved.id)}".`);
   });
-  folders.command("delete").description("Delete a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector7).action(async function action(folder) {
+  folders.command("delete").description("Delete a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector8).action(async function action(folder) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable6("navigation folders delete", readOnly, "destructive");
+    ensureWritable7("navigation folders delete", readOnly, "destructive");
     const allFolders = await api.listFolders();
     const resolved = resolveFolder2(allFolders, folder);
     const data = await api.deleteFolder({ kind: "uuid", value: resolved.id });
@@ -10858,15 +11139,15 @@ function registerNavigationCommands(program, options = {}) {
       emitJson8(stdout, "navigation folders delete", data, filePath);
       return;
     }
-    writeLine8(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
+    writeLine9(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
   });
   navigation.command("resources").description("Manage navigation resources").command("move").description(
     "Move a schema into a navigation folder. Only schemas can be moved (the navigation menu holds databases); schedules and sub-schemas follow their parent schema. Use the root folder UUID 00000000-0000-0000-0000-000000000000 to move it back to the workspace root."
   ).argument("<resource>", "schema UUID").requiredOption("--to <folder>", "target folder UUID or exact name").action(async function action(resourceId, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
-    ensureWritable6("navigation resources move", readOnly, "write");
+    ensureWritable7("navigation resources move", readOnly, "write");
     const allFolders = await api.listFolders();
-    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector7(commandOptions.to));
+    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector8(commandOptions.to));
     const data = await api.moveResource({
       resourceId,
       targetFolderId: resolved.id
@@ -10875,23 +11156,23 @@ function registerNavigationCommands(program, options = {}) {
       emitJson8(stdout, "navigation resources move", data, filePath);
       return;
     }
-    writeLine8(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
+    writeLine9(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
   });
 }
 
 // src/commands/profiles.ts
-function getCommandIo9(stdout) {
+function getCommandIo10(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine9(stdout, value) {
+function writeLine10(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions9(command) {
+function getGlobalOptions10(command) {
   return command.optsWithGlobals();
 }
 function emitJson9(stdout, commandName, data, configPath) {
-  writeLine9(
+  writeLine10(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
@@ -10947,14 +11228,14 @@ function emitProfilesTable(stdout, data) {
 }
 function registerProfilesCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo9(options.stdout);
+  const stdout = getCommandIo10(options.stdout);
   const profiles = program.command("profiles").description("Manage local CLI profiles");
   profiles.command("list").description("List configured profiles").action(function action() {
     const config = readRequiredConfig(filePath);
     const data = Object.entries(config.profiles).map(
       ([name, profile]) => toDisplayProfile(name, profile, config.defaultProfile)
     );
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles list", data, filePath);
       return;
     }
@@ -10964,7 +11245,7 @@ function registerProfilesCommands(program, options = {}) {
     const config = readRequiredConfig(filePath);
     const profile = getRequiredProfile(config, profileName);
     const data = toDisplayProfile(profileName, profile, config.defaultProfile);
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles get", data, filePath);
       return;
     }
@@ -10979,11 +11260,11 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles use", data, filePath);
       return;
     }
-    writeLine9(stdout, `Using profile "${profileName}".`);
+    writeLine10(stdout, `Using profile "${profileName}".`);
   });
   profiles.command("add").description("Add a profile to the local config").argument("<profile>", "profile name").requiredOption("--api-key <token>", "API key").option("--base-url <url>", "base URL").action(function action(profileName, commandOptions) {
     const config = loadConfigForAdd(filePath);
@@ -11007,11 +11288,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles add", data, filePath);
       return;
     }
-    writeLine9(stdout, `Added profile "${profileName}".`);
+    writeLine10(stdout, `Added profile "${profileName}".`);
   });
   profiles.command("update").description("Update an existing profile").argument("<profile>", "profile name").option("--api-key <token>", "API key").option("--base-url <url>", "base URL").action(function action(profileName, commandOptions) {
     if (commandOptions.apiKey === void 0 && commandOptions.baseUrl === void 0) {
@@ -11033,11 +11314,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles update", data, filePath);
       return;
     }
-    writeLine9(stdout, `Updated profile "${profileName}".`);
+    writeLine10(stdout, `Updated profile "${profileName}".`);
   });
   profiles.command("remove").description("Remove a profile from the local config").argument("<profile>", "profile name").action(function action(profileName) {
     const config = readRequiredConfig(filePath);
@@ -11048,17 +11329,17 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions9(this).json) {
+    if (getGlobalOptions10(this).json) {
       emitJson9(stdout, "profiles remove", data, filePath);
       return;
     }
-    writeLine9(stdout, `Removed profile "${profileName}".`);
+    writeLine10(stdout, `Removed profile "${profileName}".`);
   });
 }
 
 // src/commands/records.ts
 import { readFileSync as readFileSync8 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError9 } from "commander";
 
 // src/api/records.ts
 function jsonOptions6(body, method) {
@@ -11070,7 +11351,7 @@ function jsonOptions6(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue8(selector) {
+function selectorValue9(selector) {
   return selector.value;
 }
 var RecordsApi = class {
@@ -11085,7 +11366,7 @@ var RecordsApi = class {
     if (query.offset !== void 0) {
       params.set("offset", String(query.offset));
     }
-    const path = `/api/v2/schemas/${selectorValue8(schema)}/records`;
+    const path = `/api/v2/schemas/${selectorValue9(schema)}/records`;
     const queryString = params.toString();
     return this.client.getJson(
       queryString ? `${path}?${queryString}` : path
@@ -11094,36 +11375,36 @@ var RecordsApi = class {
   queryRecords(schema, query) {
     const body = this.normalizeQueryInput(query);
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records:query`,
+      `/api/v2/schemas/${selectorValue9(schema)}/records:query`,
       jsonOptions6(body, "POST")
     );
   }
   getRecord(schema, record) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`
+      `/api/v2/schemas/${selectorValue9(schema)}/records/${selectorValue9(record)}`
     );
   }
   createRecords(schema, records) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records`,
+      `/api/v2/schemas/${selectorValue9(schema)}/records`,
       jsonOptions6({ records }, "POST")
     );
   }
   updateRecord(schema, record, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
+      `/api/v2/schemas/${selectorValue9(schema)}/records/${selectorValue9(record)}`,
       jsonOptions6(input, "PATCH")
     );
   }
   deleteRecords(schema, recordIds) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records:delete`,
+      `/api/v2/schemas/${selectorValue9(schema)}/records:delete`,
       jsonOptions6({ recordIds }, "POST")
     );
   }
   clearRecords(schema) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records:clear`,
+      `/api/v2/schemas/${selectorValue9(schema)}/records:clear`,
       { method: "DELETE" }
     );
   }
@@ -11165,7 +11446,7 @@ function jsonOptions7(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue9(selector) {
+function selectorValue10(selector) {
   return selector.value;
 }
 var SchemasApi = class {
@@ -11176,26 +11457,26 @@ var SchemasApi = class {
     return this.client.getJson("/api/v2/schemas");
   }
   getSchema(schema) {
-    return this.client.getJson(`/api/v2/schemas/${selectorValue9(schema)}`);
+    return this.client.getJson(`/api/v2/schemas/${selectorValue10(schema)}`);
   }
   createSchema(input) {
     return this.client.requestJson("/api/v2/schemas", jsonOptions7(input, "POST"));
   }
   updateSchema(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}`,
+      `/api/v2/schemas/${selectorValue10(schema)}`,
       jsonOptions7(input, "PATCH")
     );
   }
   setUniqueFields(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}/unique-fields`,
+      `/api/v2/schemas/${selectorValue10(schema)}/unique-fields`,
       jsonOptions7(input, "PUT")
     );
   }
   deleteSchema(schema) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}`,
+      `/api/v2/schemas/${selectorValue10(schema)}`,
       { method: "DELETE" }
     );
   }
@@ -11205,47 +11486,47 @@ var SchemasApi = class {
   }
   getField(schema, field) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`
+      `/api/v2/schemas/${selectorValue10(schema)}/fields/${selectorValue10(field)}`
     );
   }
   createField(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}/fields`,
+      `/api/v2/schemas/${selectorValue10(schema)}/fields`,
       jsonOptions7(input, "POST")
     );
   }
   updateField(schema, field, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`,
+      `/api/v2/schemas/${selectorValue10(schema)}/fields/${selectorValue10(field)}`,
       jsonOptions7(input, "PATCH")
     );
   }
   deleteField(schema, field) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue9(schema)}/fields/${selectorValue9(field)}`,
+      `/api/v2/schemas/${selectorValue10(schema)}/fields/${selectorValue10(field)}`,
       { method: "DELETE" }
     );
   }
 };
 
 // src/commands/records.ts
-function getCommandIo10(stdout) {
+function getCommandIo11(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine10(stdout, value) {
+function writeLine11(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions10(command) {
+function getGlobalOptions11(command) {
   return command.optsWithGlobals();
 }
 function emitJson10(stdout, commandName, data, configPath, meta = {}) {
-  writeLine10(
+  writeLine11(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath, ...meta }))
   );
 }
-function toConfigurationError9(filePath, error) {
+function toConfigurationError10(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -11260,7 +11541,7 @@ function toConfigurationError9(filePath, error) {
 function createRecordsApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions10(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions11(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -11279,10 +11560,10 @@ function createRecordsApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError9(filePath, error);
+    toConfigurationError10(filePath, error);
   }
 }
-function ensureWritable7(commandName, readOnly, commandMode) {
+function ensureWritable8(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -11294,24 +11575,24 @@ function ensureWritable7(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector8(input) {
+function parseUuidOrSlugSelector9(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError9(message);
   }
 }
 function parseNonNegativeInteger2(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError8(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError9(`Expected a non-negative integer, received "${input}".`);
   }
   return Number(input);
 }
 function parseCommaSeparatedValues(input, label) {
   const values = input.split(",").map((value) => value.trim()).filter(Boolean);
   if (values.length === 0) {
-    throw new InvalidArgumentError8(`Expected ${label} to contain at least one value.`);
+    throw new InvalidArgumentError9(`Expected ${label} to contain at least one value.`);
   }
   return values;
 }
@@ -11320,7 +11601,7 @@ function parseExpressionValue(input) {
     return parseExpression(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid expression.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError9(message);
   }
 }
 function parseKeyValueAssignment(input) {
@@ -11328,7 +11609,7 @@ function parseKeyValueAssignment(input) {
     return parseKeyValue(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid assignment.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError9(message);
   }
 }
 function parseJsonKeyValueAssignment(input) {
@@ -11336,7 +11617,7 @@ function parseJsonKeyValueAssignment(input) {
     return parseJsonAssignment(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid JSON assignment.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError9(message);
   }
 }
 function dedupeStrings(values) {
@@ -11353,7 +11634,7 @@ function toRecordUuid(value) {
 function collectRecordIds(value, previous = []) {
   const uuid = toRecordUuid(value.trim());
   if (!uuid) {
-    throw new InvalidArgumentError8(`Expected a record UUID, received "${value}".`);
+    throw new InvalidArgumentError9(`Expected a record UUID, received "${value}".`);
   }
   return [...previous, uuid];
 }
@@ -11640,9 +11921,9 @@ async function resolveSchemaSelector(api, selector) {
 }
 function registerRecordsCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo10(options.stdout);
+  const stdout = getCommandIo11(options.stdout);
   const records = program.command("records").description("Manage schema records");
-  records.command("list").description("List records for a schema with simple pagination").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).action(async function action(schema, commandOptions) {
+  records.command("list").description("List records for a schema with simple pagination").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.listRecords(
@@ -11662,7 +11943,7 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, recordsData);
   });
-  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--select <fields>", "field selection (comma-separated, repeatable)", collectSelectValues, []).option("--where <expression>", "where expression", collectWhereExpressions, []).option(
+  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--select <fields>", "field selection (comma-separated, repeatable)", collectSelectValues, []).option("--where <expression>", "where expression", collectWhereExpressions, []).option(
     "--search <term>",
     "free-text search term (matched across the schema's searchable fields)"
   ).option("--sort <field:direction>", "sort field(s)", collectSortValues, []).option("--limit <number>", "limit results", parseNonNegativeInteger2).option("--offset <number>", "offset results", parseNonNegativeInteger2).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
@@ -11685,7 +11966,7 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, recordsData);
   });
-  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, record) {
+  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema, record) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.getRecord(resolvedSchema, record);
@@ -11695,7 +11976,7 @@ function registerRecordsCommands(program, options = {}) {
     }
     emitTable4(stdout, data);
   });
-  records.command("create").description("Create one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option(
+  records.command("create").description("Create one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option(
     "--set <field=value>",
     "set a string field (reference fields: a record id, 'recordId::label', or an exact display value)",
     collectKeyValueAssignments,
@@ -11705,7 +11986,7 @@ function registerRecordsCommands(program, options = {}) {
     "path to a JSON array of record objects (mutually exclusive with --set/--set-json/--raw/--raw-file)"
   ).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable7("records create", readOnly, "write");
+    ensureWritable8("records create", readOnly, "write");
     const records2 = buildCreateRecords(commandOptions);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.createRecords(resolvedSchema, records2);
@@ -11713,22 +11994,22 @@ function registerRecordsCommands(program, options = {}) {
       emitJson10(stdout, "records create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created ${data.created.length} record(s) in schema "${schema.value}".`);
+    writeLine11(stdout, `Created ${data.created.length} record(s) in schema "${schema.value}".`);
     if (data.errors.length > 0) {
-      writeLine10(stdout, `${data.errors.length} record(s) rejected:`);
+      writeLine11(stdout, `${data.errors.length} record(s) rejected:`);
       for (const error of data.errors) {
-        writeLine10(stdout, `  - index ${error.index}: ${error.message}`);
+        writeLine11(stdout, `  - index ${error.index}: ${error.message}`);
       }
     }
   });
-  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector8).option(
+  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector9).option(
     "--set <field=value>",
     "set a string field (reference fields: a record id, 'recordId::label', or an exact display value)",
     collectKeyValueAssignments,
     []
   ).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object of fields to set").option("--raw-file <path>", "path to a JSON object of fields to set").action(async function action(schema, record, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable7("records update", readOnly, "write");
+    ensureWritable8("records update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.updateRecord(
       resolvedSchema,
@@ -11739,14 +12020,14 @@ function registerRecordsCommands(program, options = {}) {
       emitJson10(stdout, "records update", data, filePath);
       return;
     }
-    writeLine10(stdout, `Updated record "${getRecordIdentifier(data)}".`);
+    writeLine11(stdout, `Updated record "${getRecordIdentifier(data)}".`);
   });
-  records.command("delete").description("Delete one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--record <uuid>", "record uuid to delete (repeatable)", collectRecordIds, []).option(
+  records.command("delete").description("Delete one or more records").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--record <uuid>", "record uuid to delete (repeatable)", collectRecordIds, []).option(
     "--records-file <path>",
     "path to a file with one record uuid per line (merged with --record)"
   ).action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable7("records delete", readOnly, "destructive");
+    ensureWritable8("records delete", readOnly, "destructive");
     const recordIds = resolveDeleteRecordIds(commandOptions);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.deleteRecords(resolvedSchema, recordIds);
@@ -11754,27 +12035,27 @@ function registerRecordsCommands(program, options = {}) {
       emitJson10(stdout, "records delete", data, filePath);
       return;
     }
-    writeLine10(
+    writeLine11(
       stdout,
       `Deleted ${recordIds.length} record(s) from schema "${schema.value}".`
     );
   });
-  records.command("clear").description("Delete all records from a schema's table").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  records.command("clear").description("Delete all records from a schema's table").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
-    ensureWritable7("records clear", readOnly, "destructive");
+    ensureWritable8("records clear", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.clearRecords(resolvedSchema);
     if (json) {
       emitJson10(stdout, "records clear", data, filePath);
       return;
     }
-    writeLine10(stdout, `Cleared all records from schema "${schema.value}".`);
+    writeLine11(stdout, `Cleared all records from schema "${schema.value}".`);
   });
 }
 
 // src/commands/schemas.ts
 import { readFileSync as readFileSync9 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError9 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError10 } from "commander";
 var HIGHLIGHTED_FIELD_HELP = `
 Highlighted field:
   The schema's "main" field. The frontend uses its value as each record's
@@ -11784,23 +12065,23 @@ Highlighted field:
     - Detail view: the record's name in the left-hand record list you
       browse to open each record's form.
 `;
-function getCommandIo11(stdout) {
+function getCommandIo12(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine11(stdout, value) {
+function writeLine12(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions11(command) {
+function getGlobalOptions12(command) {
   return command.optsWithGlobals();
 }
 function emitJson11(stdout, commandName, data, configPath) {
-  writeLine11(
+  writeLine12(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError10(filePath, error) {
+function toConfigurationError11(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -11815,7 +12096,7 @@ function toConfigurationError10(filePath, error) {
 function createSchemasApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions11(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions12(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -11834,10 +12115,10 @@ function createSchemasApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError10(filePath, error);
+    toConfigurationError11(filePath, error);
   }
 }
-function ensureWritable8(commandName, readOnly, commandMode) {
+function ensureWritable9(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -11849,16 +12130,16 @@ function ensureWritable8(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector9(input) {
+function parseUuidOrSlugSelector10(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError9(message);
+    throw new InvalidArgumentError10(message);
   }
 }
 function collectFieldSelectors(value, previous = []) {
-  return [...previous, parseUuidOrSlugSelector9(value)];
+  return [...previous, parseUuidOrSlugSelector10(value)];
 }
 function parseBooleanFlag(input) {
   const normalized = input.trim().toLowerCase();
@@ -11868,7 +12149,7 @@ function parseBooleanFlag(input) {
   if (["false", "0", "no", "n", "off"].includes(normalized)) {
     return false;
   }
-  throw new InvalidArgumentError9(`Expected a boolean value, received "${input}".`);
+  throw new InvalidArgumentError10(`Expected a boolean value, received "${input}".`);
 }
 function isJsonObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12083,7 +12364,7 @@ function isEmptyObject6(value) {
 }
 function registerSchemasCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo11(options.stdout);
+  const stdout = getCommandIo12(options.stdout);
   const schemas = program.command("schemas").description("Manage schemas and schema fields");
   schemas.command("list").description("List schemas").action(async function action() {
     const { api, json } = createSchemasApi(this, filePath);
@@ -12094,7 +12375,7 @@ function registerSchemasCommands(program, options = {}) {
     }
     emitSchemasTable(stdout, data);
   });
-  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
+  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.getSchema(resolvedSchema);
@@ -12106,7 +12387,7 @@ function registerSchemasCommands(program, options = {}) {
   });
   schemas.command("create").description("Create a schema").requiredOption("--name <name>", "schema name").requiredOption("--slug <slug>", "schema slug").option("--auditable", "mark schema as auditable").option("--commentable", "mark schema as commentable").action(async function action(commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas create", readOnly, "write");
+    ensureWritable9("schemas create", readOnly, "write");
     const input = {
       name: commandOptions.name,
       slug: commandOptions.slug,
@@ -12118,15 +12399,15 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas create", data, filePath);
       return;
     }
-    writeLine11(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
+    writeLine12(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
   });
-  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).option(
+  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).option(
     "--highlighted-field <field>",
     "its value is used as each record's display name in the UI (field uuid or slug)",
-    parseUuidOrSlugSelector9
+    parseUuidOrSlugSelector10
   ).action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas update", readOnly, "write");
+    ensureWritable9("schemas update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const input = buildSchemaUpdateInput(commandOptions);
     if (commandOptions.highlightedField !== void 0) {
@@ -12148,16 +12429,16 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas update", data, filePath);
       return;
     }
-    writeLine11(stdout, `Updated schema "${data.slug ?? schema.value}".`);
+    writeLine12(stdout, `Updated schema "${data.slug ?? schema.value}".`);
   }).addHelpText("after", HIGHLIGHTED_FIELD_HELP);
-  schemas.command("set-unique-fields").description("Set or clear the composite unique-field constraint on a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option(
+  schemas.command("set-unique-fields").description("Set or clear the composite unique-field constraint on a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).option(
     "--field <field>",
     "field uuid or slug to include in the unique constraint (repeatable)",
     collectFieldSelectors,
     []
   ).option("--clear", "clear the unique constraint (sends an empty field list)").action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas set-unique-fields", readOnly, "write");
+    ensureWritable9("schemas set-unique-fields", readOnly, "write");
     const selectors = commandOptions.field ?? [];
     if (commandOptions.clear && selectors.length > 0) {
       throw new CliError(
@@ -12184,18 +12465,18 @@ function registerSchemasCommands(program, options = {}) {
       return;
     }
     if (input.fieldIds.length === 0) {
-      writeLine11(stdout, `Cleared unique fields on schema "${schema.value}".`);
+      writeLine12(stdout, `Cleared unique fields on schema "${schema.value}".`);
       return;
     }
     const count = input.fieldIds.length;
-    writeLine11(
+    writeLine12(
       stdout,
       `Set unique fields on schema "${schema.value}" (${count} field${count === 1 ? "" : "s"}).`
     );
   });
-  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
+  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).action(async function action(schema) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas delete", readOnly, "destructive");
+    ensureWritable9("schemas delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     await api.deleteSchema(resolvedSchema);
     const data = {
@@ -12206,10 +12487,10 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas delete", data, filePath);
       return;
     }
-    writeLine11(stdout, `Deleted schema "${schema.value}".`);
+    writeLine12(stdout, `Deleted schema "${schema.value}".`);
   });
   const fields = schemas.command("fields").description("Manage schema fields");
-  fields.command("list").description("List fields for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema) {
+  fields.command("list").description("List fields for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.listFields(resolvedSchema);
@@ -12219,7 +12500,7 @@ function registerSchemasCommands(program, options = {}) {
     }
     emitFieldsTable(stdout, data);
   });
-  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema, field) {
+  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector10).action(async function action(schema, field) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
@@ -12230,9 +12511,9 @@ function registerSchemasCommands(program, options = {}) {
     }
     emitFieldsTable(stdout, [data]);
   });
-  fields.command("create").description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`).argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).option("--type <type>", `field type (${formatSchemaFieldTypes()})`).option("--slug <slug>", "field slug").option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload (see type-specific shapes in --help)").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  fields.command("create").description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`).argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).option("--type <type>", `field type (${formatSchemaFieldTypes()})`).option("--slug <slug>", "field slug").option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload (see type-specific shapes in --help)").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas fields create", readOnly, "write");
+    ensureWritable9("schemas fields create", readOnly, "write");
     const input = buildFieldCreateInput(commandOptions);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     let data;
@@ -12245,11 +12526,11 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas fields create", data, filePath);
       return;
     }
-    writeLine11(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
+    writeLine12(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
   });
-  fields.command("update").description("Update a field in a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, field, commandOptions) {
+  fields.command("update").description("Update a field in a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector10).option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).option("--default <value>", "default field value").option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, field, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas fields update", readOnly, "write");
+    ensureWritable9("schemas fields update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
     const currentField = await api.getField(resolvedSchema, resolvedField);
@@ -12269,11 +12550,11 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas fields update", data, filePath);
       return;
     }
-    writeLine11(stdout, `Updated field "${data.slug ?? field.value}".`);
+    writeLine12(stdout, `Updated field "${data.slug ?? field.value}".`);
   });
-  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector9).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector9).action(async function action(schema, field) {
+  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector10).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector10).action(async function action(schema, field) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
-    ensureWritable8("schemas fields delete", readOnly, "destructive");
+    ensureWritable9("schemas fields delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
     await api.deleteField(resolvedSchema, resolvedField);
@@ -12286,13 +12567,13 @@ function registerSchemasCommands(program, options = {}) {
       emitJson11(stdout, "schemas fields delete", data, filePath);
       return;
     }
-    writeLine11(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
+    writeLine12(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
   });
 }
 
 // src/commands/teamspace.ts
 import { readFileSync as readFileSync10 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError10 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError11 } from "commander";
 
 // src/api/teamspace.ts
 function jsonOptions8(body, method) {
@@ -12304,7 +12585,7 @@ function jsonOptions8(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue10(selector) {
+function selectorValue11(selector) {
   return selector.value;
 }
 var TeamspaceApi = class {
@@ -12330,13 +12611,13 @@ var TeamspaceApi = class {
   }
   updateFolder(folder, input) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue10(folder)}`,
+      `/api/v2/teamspaces/folders/${selectorValue11(folder)}`,
       jsonOptions8(input, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue10(folder)}`,
+      `/api/v2/teamspaces/folders/${selectorValue11(folder)}`,
       { method: "DELETE" }
     );
   }
@@ -12355,23 +12636,23 @@ var TeamspaceApi = class {
 };
 
 // src/commands/teamspace.ts
-function getCommandIo12(stdout) {
+function getCommandIo13(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine12(stdout, value) {
+function writeLine13(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions12(command) {
+function getGlobalOptions13(command) {
   return command.optsWithGlobals();
 }
 function emitJson12(stdout, commandName, data, configPath) {
-  writeLine12(
+  writeLine13(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError11(filePath, error) {
+function toConfigurationError12(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -12386,7 +12667,7 @@ function toConfigurationError11(filePath, error) {
 function createTeamspaceApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions12(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions13(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -12404,10 +12685,10 @@ function createTeamspaceApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError11(filePath, error);
+    toConfigurationError12(filePath, error);
   }
 }
-function ensureWritable9(commandName, readOnly, commandMode) {
+function ensureWritable10(commandName, readOnly, commandMode) {
   if (readOnly) {
     throw new CliError(
       "command_not_allowed_in_read_only_mode",
@@ -12419,17 +12700,17 @@ function ensureWritable9(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector10(input) {
+function parseUuidOrSlugSelector11(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError10(message);
+    throw new InvalidArgumentError11(message);
   }
 }
 function parseNonNegativeInteger3(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError10(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError11(`Expected a non-negative integer, received "${input}".`);
   }
   return Number(input);
 }
@@ -12585,7 +12866,7 @@ async function resolveFolderSelector2(api, selector) {
 }
 function registerTeamspaceCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo12(options.stdout);
+  const stdout = getCommandIo13(options.stdout);
   const teamspace = program.command("teamspace").description("Manage teamspace folders and resources");
   const folders = teamspace.command("folders").description("Manage teamspace folders");
   folders.command("list").description("List teamspace folders").option("--include-resources", "include the published resources inside each folder").action(async function action(commandOptions) {
@@ -12597,7 +12878,7 @@ function registerTeamspaceCommands(program, options = {}) {
     }
     emitTable5(stdout, data);
   });
-  folders.command("get").description("Get a teamspace folder by exact name or UUID").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).option("--include-resources", "include the published resources inside each folder").action(async function action(folder, commandOptions) {
+  folders.command("get").description("Get a teamspace folder by exact name or UUID").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector11).option("--include-resources", "include the published resources inside each folder").action(async function action(folder, commandOptions) {
     const { api, json } = createTeamspaceApi(this, filePath);
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const allFolders = await api.listFolders(Boolean(commandOptions.includeResources));
@@ -12610,46 +12891,46 @@ function registerTeamspaceCommands(program, options = {}) {
   });
   folders.command("create").description("Create a teamspace folder").requiredOption("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)", parseNonNegativeInteger3).option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"icon":"folder-users","color":"gold"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable9("teamspace folders create", readOnly, "write");
+    ensureWritable10("teamspace folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderCreateInput(commandOptions));
     if (json) {
       emitJson12(stdout, "teamspace folders create", data, filePath);
       return;
     }
-    writeLine12(stdout, `Created folder "${getFolderIdentifier(data)}".`);
+    writeLine13(stdout, `Created folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).option("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)", parseNonNegativeInteger3).option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"icon":"folder-users","color":"gold"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector11).option("--name <name>", "folder name").option("--order <n>", "display order (lower values appear first)", parseNonNegativeInteger3).option("--props <json>", 'additionalProperties JSON: free-form client metadata, e.g. {"icon":"folder-users","color":"gold"}').option("--props-file <path>", "path to a file with the additionalProperties JSON").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable9("teamspace folders update", readOnly, "write");
+    ensureWritable10("teamspace folders update", readOnly, "write");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.updateFolder(resolvedFolder, buildFolderUpdateInput(commandOptions));
     if (json) {
       emitJson12(stdout, "teamspace folders update", data, filePath);
       return;
     }
-    writeLine12(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
+    writeLine13(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector10).action(async function action(folder) {
+  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector11).action(async function action(folder) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable9("teamspace folders delete", readOnly, "destructive");
+    ensureWritable10("teamspace folders delete", readOnly, "destructive");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.deleteFolder(resolvedFolder);
     if (json) {
       emitJson12(stdout, "teamspace folders delete", data, filePath);
       return;
     }
-    writeLine12(stdout, `Deleted folder "${resolvedFolder.value}".`);
+    writeLine13(stdout, `Deleted folder "${resolvedFolder.value}".`);
   });
   const resources = teamspace.command("resources").description("Manage teamspace resources");
   resources.command("publish").description(
     "Publish a resource to a teamspace folder. Publishing an already-published resource moves it to the new folder."
-  ).argument("<resource>", "schema UUID, schema slug, or display UUID", parseUuidOrSlugSelector10).requiredOption(
+  ).argument("<resource>", "schema UUID, schema slug, or display UUID", parseUuidOrSlugSelector11).requiredOption(
     "--to <folder>",
     "target folder UUID or exact name (root folder UUID is 00000000-0000-0000-0000-000000000000)",
-    parseUuidOrSlugSelector10
+    parseUuidOrSlugSelector11
   ).action(async function action(resource, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable9("teamspace resources publish", readOnly, "write");
+    ensureWritable10("teamspace resources publish", readOnly, "write");
     const folder = await resolveFolderSelector2(api, commandOptions.to);
     const data = await api.publishResource({
       resourceId: resource.value,
@@ -12659,17 +12940,17 @@ function registerTeamspaceCommands(program, options = {}) {
       emitJson12(stdout, "teamspace resources publish", data, filePath);
       return;
     }
-    writeLine12(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
+    writeLine13(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
   });
-  resources.command("unpublish").description("Unpublish a resource from teamspace (removes it from its shared folder)").argument("<resource>", "schema UUID, schema slug, or display UUID", parseUuidOrSlugSelector10).action(async function action(resource) {
+  resources.command("unpublish").description("Unpublish a resource from teamspace (removes it from its shared folder)").argument("<resource>", "schema UUID, schema slug, or display UUID", parseUuidOrSlugSelector11).action(async function action(resource) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
-    ensureWritable9("teamspace resources unpublish", readOnly, "write");
+    ensureWritable10("teamspace resources unpublish", readOnly, "write");
     const data = await api.unpublishResource(resource.value);
     if (json) {
       emitJson12(stdout, "teamspace resources unpublish", data, filePath);
       return;
     }
-    writeLine12(stdout, `Unpublished resource "${resource.value}".`);
+    writeLine13(stdout, `Unpublished resource "${resource.value}".`);
   });
 }
 
@@ -12677,7 +12958,7 @@ function registerTeamspaceCommands(program, options = {}) {
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function buildProgram(options = {}) {
-  const program = new Command11();
+  const program = new Command12();
   program.name("zinkee").description("CLI for Zinkee API v2").version(version).enablePositionalOptions().showHelpAfterError().option("--profile <name>", "select a profile from config").option("--base-url <url>", "override the configured base URL").option("--api-key <token>", "override the configured API key").option("--read-only", "run in read-only mode").option("--example", "show examples for a command").option("--json", "emit JSON output").option("--install-completion [shell]", "install shell completion (bash, zsh, fish, powershell)").option("--show-completion [shell]", "print shell completion script for the current shell");
   registerProfilesCommands(program, options);
   registerAutomationsCommands(program, options);
@@ -12685,6 +12966,7 @@ function buildProgram(options = {}) {
   registerDisplaysCommands(program, options);
   registerDocumentTemplatesCommands(program, options);
   registerFilesCommands(program, options);
+  registerFormulasCommands(program, options);
   registerNavigationCommands(program, options);
   registerSchemasCommands(program, options);
   registerRecordsCommands(program, options);