zinkee 0.1.7 → 0.1.9

package/dist/index.js

@@ -674,13 +674,6 @@ var commandRegistry = {
     supportsRaw: true,
     output: writeOutput
   },
-  "logs list": {
-    command: "logs list",
-    accessLevel: "read",
-    supportsExample: true,
-    supportsRaw: false,
-    output: readOutput
-  },
   "teamspace folders list": {
     command: "teamspace folders list",
     accessLevel: "read",
@@ -3724,47 +3717,6 @@ var specificExamples = {
       { "type": "TEXT", "value": " for follow up." }
     ]
   }
-]`
-    }
-  ]),
-  "logs list": buildCommandExamples([
-    {
-      description: "List the change history for a record (CREATE entry plus UPDATE entries with before/after values per field).",
-      command: `zinkee --json logs list contacts ${SAMPLE_UUID}`,
-      response: `[
-  {
-    "recordId": "550e8400-e29b-41d4-a716-446655440000",
-    "timestamp": "2026-04-22T10:00:00Z",
-    "changeField": "",
-    "change": {
-      "beforeValue": null,
-      "afterValue": null,
-      "author": "developer@zinkee.com",
-      "operation": "CREATE"
-    }
-  },
-  {
-    "recordId": "550e8400-e29b-41d4-a716-446655440000",
-    "timestamp": "2026-04-22T10:15:00Z",
-    "changeField": "status",
-    "change": {
-      "beforeValue": "1",
-      "afterValue": "2",
-      "author": "developer@zinkee.com",
-      "operation": "UPDATE"
-    }
-  },
-  {
-    "recordId": "550e8400-e29b-41d4-a716-446655440000",
-    "timestamp": "2026-04-22T10:20:00Z",
-    "changeField": "amount",
-    "change": {
-      "beforeValue": "1000.00",
-      "afterValue": "1250.50",
-      "author": "developer@zinkee.com",
-      "operation": "UPDATE"
-    }
-  }
 ]`
     }
   ]),
@@ -5065,8 +5017,8 @@ function buildSchemaFieldCreateExamples(type) {
       }
       return [
         {
-          description: "Create a plain number field",
-          command: `zinkee --json schemas fields create contacts --raw '{"type":"number","slug":"amount","label":"Amount"}'`
+          description: "Create a required number field with a default value",
+          command: "zinkee --json schemas fields create contacts --type number --slug amount --label Amount --required true --default 0"
         },
         {
           description: "Create a number field formatted like Moneda",
@@ -5665,7 +5617,7 @@ ${index + 1}. ${example.description}
 
 // src/program.ts
 import { createRequire } from "module";
-import { Command as Command10 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/config.ts
 function getCommandIo(stdout) {
@@ -8158,117 +8110,9 @@ function registerFilesCommands(program, options = {}) {
   });
 }
 
-// src/commands/logs.ts
-import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
-
-// src/api/logs.ts
-function selectorValue6(selector2) {
-  return selector2.value;
-}
-var LogsApi = class {
-  constructor(client) {
-    this.client = client;
-  }
-  listLogs(schema, recordId) {
-    return this.client.getJson(
-      `/api/v2/schemas/${selectorValue6(schema)}/records/${recordId}/logs`
-    );
-  }
-};
-
-// src/commands/logs.ts
-function getCommandIo6(stdout) {
-  return stdout ?? process.stdout;
-}
-function writeLine6(stdout, value) {
-  stdout.write(`${value}
-`);
-}
-function getGlobalOptions6(command) {
-  return command.optsWithGlobals();
-}
-function emitJson6(stdout, commandName, data, ..._extra) {
-  writeLine6(
-    stdout,
-    JSON.stringify(buildJsonSuccess(data, { command: commandName }))
-  );
-}
-function toConfigurationError6(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 createLogsApi(command, filePath) {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions6(command));
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`
-      );
-    }
-    return {
-      api: new LogsApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey
-        })
-      ),
-      json: runtime.json
-    };
-  } catch (error) {
-    toConfigurationError6(filePath, error);
-  }
-}
-function parseUuidOrSlugSelector5(input) {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError5(message);
-  }
-}
-function isJsonObject4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toTableRows3(data) {
-  if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject4(entry) ? entry : { value: entry });
-  }
-  if (isJsonObject4(data)) {
-    return [data];
-  }
-  return [{ value: data }];
-}
-function emitTable3(stdout, data) {
-  printTable(toTableRows3(data), void 0, stdout);
-}
-function registerLogsCommands(program, options = {}) {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo6(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", parseUuidOrSlugSelector5).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector5).action(async function action(schema, record) {
-    const { api, json } = createLogsApi(this, filePath);
-    const data = await api.listLogs(schema, record.value);
-    if (json) {
-      emitJson6(stdout, "logs list", data, filePath);
-      return;
-    }
-    emitTable3(stdout, data);
-  });
-}
-
 // src/commands/navigation.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
 
 // src/api/navigation.ts
 function jsonOptions5(body, method) {
@@ -8280,7 +8124,7 @@ function jsonOptions5(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue7(selector2) {
+function selectorValue6(selector2) {
   return selector2.value;
 }
 var NavigationApi = class {
@@ -8298,13 +8142,13 @@ var NavigationApi = class {
   }
   updateFolder(folder, body) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
+      `/api/v2/navigation/folders/${selectorValue6(folder)}`,
       jsonOptions5(body, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/navigation/folders/${selectorValue7(folder)}`,
+      `/api/v2/navigation/folders/${selectorValue6(folder)}`,
       { method: "DELETE" }
     );
   }
@@ -8317,20 +8161,20 @@ var NavigationApi = class {
 };
 
 // src/commands/navigation.ts
-function getCommandIo7(stdout) {
+function getCommandIo6(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine7(stdout, value) {
+function writeLine6(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions7(command) {
+function getGlobalOptions6(command) {
   return command.optsWithGlobals();
 }
-function emitJson7(stdout, commandName, data, configPath) {
-  writeLine7(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
+function emitJson6(stdout, commandName, data, configPath) {
+  writeLine6(stdout, JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })));
 }
-function toConfigurationError7(filePath, error) {
+function toConfigurationError6(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -8345,7 +8189,7 @@ function toConfigurationError7(filePath, error) {
 function createNavigationApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions7(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions6(command));
     if (!runtime.baseUrl) {
       throw new CliError("configuration_error", `Resolved profile "${runtime.profile}" is missing a base URL.`);
     }
@@ -8360,7 +8204,7 @@ function createNavigationApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError7(filePath, error);
+    toConfigurationError6(filePath, error);
   }
 }
 function ensureWritable5(commandName, readOnly, mode) {
@@ -8372,12 +8216,12 @@ function ensureWritable5(commandName, readOnly, mode) {
     );
   }
 }
-function parseUuidOrSlugSelector6(input) {
+function parseUuidOrSlugSelector5(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError6(message);
+    throw new InvalidArgumentError5(message);
   }
 }
 function parseInteger(value, flagName) {
@@ -8456,24 +8300,24 @@ function folderRows2(folders) {
 }
 function registerNavigationCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo7(options.stdout);
+  const stdout = getCommandIo6(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() {
     const { api, json } = createNavigationApi(this, filePath);
     const data = await api.listFolders();
     if (json) {
-      emitJson7(stdout, "navigation folders list", data, filePath);
+      emitJson6(stdout, "navigation folders list", data, filePath);
       return;
     }
     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", parseUuidOrSlugSelector6).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", parseUuidOrSlugSelector5).action(async function action(folder) {
     const { api, json } = createNavigationApi(this, filePath);
     const data = await api.listFolders();
     const resolved = resolveFolder2(data, folder);
     if (json) {
-      emitJson7(stdout, "navigation folders get", resolved, filePath);
+      emitJson6(stdout, "navigation folders get", resolved, filePath);
       return;
     }
     printTable(folderRows2([resolved]), ["id", "order", "name", "resourceCount"], stdout);
@@ -8483,12 +8327,12 @@ function registerNavigationCommands(program, options = {}) {
     ensureWritable5("navigation folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderBody(commandOptions));
     if (json) {
-      emitJson7(stdout, "navigation folders create", data, filePath);
+      emitJson6(stdout, "navigation folders create", data, filePath);
       return;
     }
-    writeLine7(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
+    writeLine6(stdout, `Created navigation folder "${String(data.name ?? commandOptions.name)}".`);
   });
-  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector6).option("--name <name>", "folder name").option("--order <n>", "folder order").option("--props <json>", "folder additionalProperties JSON").option("--props-file <path>", "folder additionalProperties JSON file").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector5).option("--name <name>", "folder name").option("--order <n>", "folder order").option("--props <json>", "folder additionalProperties JSON").option("--props-file <path>", "folder additionalProperties JSON file").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
     ensureWritable5("navigation folders update", readOnly, "write");
     const allFolders = await api.listFolders();
@@ -8499,54 +8343,54 @@ function registerNavigationCommands(program, options = {}) {
     }
     const data = await api.updateFolder({ kind: "uuid", value: resolved.id }, body);
     if (json) {
-      emitJson7(stdout, "navigation folders update", data, filePath);
+      emitJson6(stdout, "navigation folders update", data, filePath);
       return;
     }
-    writeLine7(stdout, `Updated navigation folder "${String(data.name ?? resolved.name ?? resolved.id)}".`);
+    writeLine6(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", parseUuidOrSlugSelector6).action(async function action(folder) {
+  folders.command("delete").description("Delete a navigation folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector5).action(async function action(folder) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
     ensureWritable5("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 });
     if (json) {
-      emitJson7(stdout, "navigation folders delete", data, filePath);
+      emitJson6(stdout, "navigation folders delete", data, filePath);
       return;
     }
-    writeLine7(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
+    writeLine6(stdout, `Deleted navigation folder "${resolved.name ?? resolved.id}".`);
   });
   navigation.command("resources").description("Manage navigation resources").command("move").description("Move a resource into a folder").argument("<resource>", "resource UUID").requiredOption("--type <type>", "resource type").requiredOption("--to <folder>", "target folder UUID or exact name").action(async function action(resourceId, commandOptions) {
     const { api, json, readOnly } = createNavigationApi(this, filePath);
     ensureWritable5("navigation resources move", readOnly, "write");
     const allFolders = await api.listFolders();
-    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector6(commandOptions.to));
+    const resolved = resolveFolder2(allFolders, parseUuidOrSlugSelector5(commandOptions.to));
     const data = await api.moveResource({
       resourceId,
       resourceType: commandOptions.type.toUpperCase(),
       targetFolderId: resolved.id
     });
     if (json) {
-      emitJson7(stdout, "navigation resources move", data, filePath);
+      emitJson6(stdout, "navigation resources move", data, filePath);
       return;
     }
-    writeLine7(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
+    writeLine6(stdout, `Moved resource "${resourceId}" to "${resolved.name ?? resolved.id}".`);
   });
 }
 
 // src/commands/profiles.ts
-function getCommandIo8(stdout) {
+function getCommandIo7(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine8(stdout, value) {
+function writeLine7(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions8(command) {
+function getGlobalOptions7(command) {
   return command.optsWithGlobals();
 }
-function emitJson8(stdout, commandName, data, configPath) {
-  writeLine8(
+function emitJson7(stdout, commandName, data, configPath) {
+  writeLine7(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
@@ -8589,15 +8433,15 @@ function emitProfilesTable(stdout, data) {
 }
 function registerProfilesCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo8(options.stdout);
+  const stdout = getCommandIo7(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 (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles list", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles list", data, filePath);
       return;
     }
     emitProfilesTable(stdout, data);
@@ -8606,8 +8450,8 @@ function registerProfilesCommands(program, options = {}) {
     const config = readRequiredConfig(filePath);
     const profile = getRequiredProfile(config, profileName);
     const data = toDisplayProfile(profileName, profile, config.defaultProfile);
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles get", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles get", data, filePath);
       return;
     }
     emitProfilesTable(stdout, [data]);
@@ -8621,11 +8465,11 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles use", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles use", data, filePath);
       return;
     }
-    writeLine8(stdout, `Using profile "${profileName}".`);
+    writeLine7(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);
@@ -8648,11 +8492,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles add", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles add", data, filePath);
       return;
     }
-    writeLine8(stdout, `Added profile "${profileName}".`);
+    writeLine7(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) {
@@ -8673,11 +8517,11 @@ function registerProfilesCommands(program, options = {}) {
       nextConfig.profiles[profileName] ?? {},
       nextConfig.defaultProfile
     );
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles update", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles update", data, filePath);
       return;
     }
-    writeLine8(stdout, `Updated profile "${profileName}".`);
+    writeLine7(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);
@@ -8688,17 +8532,17 @@ function registerProfilesCommands(program, options = {}) {
       profile: profileName,
       defaultProfile: nextConfig.defaultProfile
     };
-    if (getGlobalOptions8(this).json) {
-      emitJson8(stdout, "profiles remove", data, filePath);
+    if (getGlobalOptions7(this).json) {
+      emitJson7(stdout, "profiles remove", data, filePath);
       return;
     }
-    writeLine8(stdout, `Removed profile "${profileName}".`);
+    writeLine7(stdout, `Removed profile "${profileName}".`);
   });
 }
 
 // src/commands/records.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError6 } from "commander";
 
 // src/api/records.ts
 function jsonOptions6(body, method) {
@@ -8710,7 +8554,7 @@ function jsonOptions6(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue8(selector2) {
+function selectorValue7(selector2) {
   return selector2.value;
 }
 var RecordsApi = class {
@@ -8725,7 +8569,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/${selectorValue7(schema)}/records`;
     const queryString = params.toString();
     return this.client.getJson(
       queryString ? `${path}?${queryString}` : path
@@ -8734,30 +8578,30 @@ 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/${selectorValue7(schema)}/records:query`,
       jsonOptions6(body, "POST")
     );
   }
   getRecord(schema, record) {
     return this.client.getJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`
+      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`
     );
   }
   createRecord(schema, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records`,
+      `/api/v2/schemas/${selectorValue7(schema)}/records`,
       jsonOptions6(input, "POST")
     );
   }
   updateRecord(schema, record, input) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
+      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`,
       jsonOptions6(input, "PATCH")
     );
   }
   deleteRecord(schema, record) {
     return this.client.requestJson(
-      `/api/v2/schemas/${selectorValue8(schema)}/records/${selectorValue8(record)}`,
+      `/api/v2/schemas/${selectorValue7(schema)}/records/${selectorValue7(record)}`,
       { method: "DELETE" }
     );
   }
@@ -8870,23 +8714,23 @@ function parseExpression(input) {
 }
 
 // src/commands/records.ts
-function getCommandIo9(stdout) {
+function getCommandIo8(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine9(stdout, value) {
+function writeLine8(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions9(command) {
+function getGlobalOptions8(command) {
   return command.optsWithGlobals();
 }
-function emitJson9(stdout, commandName, data, configPath, meta = {}) {
-  writeLine9(
+function emitJson8(stdout, commandName, data, configPath, meta = {}) {
+  writeLine8(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath, ...meta }))
   );
 }
-function toConfigurationError8(filePath, error) {
+function toConfigurationError7(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -8901,7 +8745,7 @@ function toConfigurationError8(filePath, error) {
 function createRecordsApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions9(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions8(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -8920,7 +8764,7 @@ function createRecordsApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError8(filePath, error);
+    toConfigurationError7(filePath, error);
   }
 }
 function ensureWritable6(commandName, readOnly, commandMode) {
@@ -8935,24 +8779,24 @@ function ensureWritable6(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector7(input) {
+function parseUuidOrSlugSelector6(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError6(message);
   }
 }
 function parseNonNegativeInteger2(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError7(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError6(`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 InvalidArgumentError7(`Expected ${label} to contain at least one value.`);
+    throw new InvalidArgumentError6(`Expected ${label} to contain at least one value.`);
   }
   return values;
 }
@@ -8961,7 +8805,7 @@ function parseExpressionValue(input) {
     return parseExpression(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid expression.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError6(message);
   }
 }
 function parseKeyValueAssignment(input) {
@@ -8969,7 +8813,7 @@ function parseKeyValueAssignment(input) {
     return parseKeyValue(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid assignment.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError6(message);
   }
 }
 function parseJsonKeyValueAssignment(input) {
@@ -8977,7 +8821,7 @@ function parseJsonKeyValueAssignment(input) {
     return parseJsonAssignment(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid JSON assignment.";
-    throw new InvalidArgumentError7(message);
+    throw new InvalidArgumentError6(message);
   }
 }
 function collectStringValues(value, previous = []) {
@@ -8995,7 +8839,7 @@ function collectKeyValueAssignments(value, previous = []) {
 function collectJsonAssignments(value, previous = []) {
   return [...previous, parseJsonKeyValueAssignment(value)];
 }
-function isJsonObject5(value) {
+function isJsonObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject2(input, sourceLabel) {
@@ -9009,7 +8853,7 @@ function parseRawJsonObject2(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject5(parsed)) {
+  if (!isJsonObject4(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -9103,7 +8947,7 @@ function readRawSetPayload2(raw) {
   if (setValue === void 0) {
     return {};
   }
-  if (!isJsonObject5(setValue)) {
+  if (!isJsonObject4(setValue)) {
     throw new CliError(
       "invalid_cli_usage",
       'Expected raw update payload field "set" to be a JSON object.'
@@ -9156,17 +9000,17 @@ function buildRecordUpdateInput(options) {
   }
   return input;
 }
-function toTableRows4(data) {
+function toTableRows3(data) {
   if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject5(entry) ? entry : { value: entry });
+    return data.map((entry) => isJsonObject4(entry) ? entry : { value: entry });
   }
-  if (isJsonObject5(data)) {
+  if (isJsonObject4(data)) {
     return [data];
   }
   return [{ value: data }];
 }
-function emitTable4(stdout, data) {
-  printTable(toTableRows4(data), void 0, stdout);
+function emitTable3(stdout, data) {
+  printTable(toTableRows3(data), void 0, stdout);
 }
 function getQueryRecords(result) {
   return Array.isArray(result.records) ? result.records : [];
@@ -9190,9 +9034,9 @@ async function resolveSchemaSelector(api, selector2) {
 }
 function registerRecordsCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo9(options.stdout);
+  const stdout = getCommandIo8(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", parseUuidOrSlugSelector7).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", parseUuidOrSlugSelector6).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(
@@ -9201,7 +9045,7 @@ function registerRecordsCommands(program, options = {}) {
     );
     const recordsData = getQueryRecords(data);
     if (json) {
-      emitJson9(
+      emitJson8(
         stdout,
         "records list",
         recordsData,
@@ -9210,9 +9054,9 @@ function registerRecordsCommands(program, options = {}) {
       );
       return;
     }
-    emitTable4(stdout, recordsData);
+    emitTable3(stdout, recordsData);
   });
-  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--select <fields>", "comma-separated field selection", (value) => parseCommaSeparatedValues(value, "--select")).option("--where <expression>", "where expression", collectWhereExpressions, []).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) {
+  records.command("query").description("Query records for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).option("--select <fields>", "comma-separated field selection", (value) => parseCommaSeparatedValues(value, "--select")).option("--where <expression>", "where expression", collectWhereExpressions, []).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) {
     const { api, schemasApi, json } = createRecordsApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
     const data = await api.queryRecords(
@@ -9221,7 +9065,7 @@ function registerRecordsCommands(program, options = {}) {
     );
     const recordsData = getQueryRecords(data);
     if (json) {
-      emitJson9(
+      emitJson8(
         stdout,
         "records query",
         recordsData,
@@ -9230,19 +9074,19 @@ function registerRecordsCommands(program, options = {}) {
       );
       return;
     }
-    emitTable4(stdout, recordsData);
+    emitTable3(stdout, recordsData);
   });
-  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, record) {
+  records.command("get").description("Get a record by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector6).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);
     if (json) {
-      emitJson9(stdout, "records get", data, filePath);
+      emitJson8(stdout, "records get", data, filePath);
       return;
     }
-    emitTable4(stdout, data);
+    emitTable3(stdout, data);
   });
-  records.command("create").description("Create a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
+  records.command("create").description("Create a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
     ensureWritable6("records create", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
@@ -9251,12 +9095,12 @@ function registerRecordsCommands(program, options = {}) {
       buildRecordCreateInput(commandOptions)
     );
     if (json) {
-      emitJson9(stdout, "records create", data, filePath);
+      emitJson8(stdout, "records create", data, filePath);
       return;
     }
-    writeLine9(stdout, `Created record "${getRecordIdentifier(data)}".`);
+    writeLine8(stdout, `Created record "${getRecordIdentifier(data)}".`);
   });
-  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, record, commandOptions) {
+  records.command("update").description("Update a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector6).option("--set <field=value>", "set a string field", collectKeyValueAssignments, []).option("--set-json <field=json>", "set a structured field", collectJsonAssignments, []).option("--unset <field>", "unset a field", collectStringValues, []).option("--raw <json>", "raw JSON object payload").option("--raw-file <path>", "path to a raw JSON object payload").action(async function action(schema, record, commandOptions) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
     ensureWritable6("records update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
@@ -9266,12 +9110,12 @@ function registerRecordsCommands(program, options = {}) {
       buildRecordUpdateInput(commandOptions)
     );
     if (json) {
-      emitJson9(stdout, "records update", data, filePath);
+      emitJson8(stdout, "records update", data, filePath);
       return;
     }
-    writeLine9(stdout, `Updated record "${getRecordIdentifier(data)}".`);
+    writeLine8(stdout, `Updated record "${getRecordIdentifier(data)}".`);
   });
-  records.command("delete").description("Delete a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, record) {
+  records.command("delete").description("Delete a record").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector6).argument("<record>", "record uuid or slug", parseUuidOrSlugSelector6).action(async function action(schema, record) {
     const { api, schemasApi, json, readOnly } = createRecordsApi(this, filePath);
     ensureWritable6("records delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector(schemasApi, schema);
@@ -9282,33 +9126,33 @@ function registerRecordsCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson9(stdout, "records delete", data, filePath);
+      emitJson8(stdout, "records delete", data, filePath);
       return;
     }
-    writeLine9(stdout, `Deleted record "${record.value}" from schema "${schema.value}".`);
+    writeLine8(stdout, `Deleted record "${record.value}" from schema "${schema.value}".`);
   });
 }
 
 // src/commands/schemas.ts
 import { readFileSync as readFileSync8 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
-function getCommandIo10(stdout) {
+import { InvalidArgumentError as InvalidArgumentError7 } from "commander";
+function getCommandIo9(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine10(stdout, value) {
+function writeLine9(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions10(command) {
+function getGlobalOptions9(command) {
   return command.optsWithGlobals();
 }
-function emitJson10(stdout, commandName, data, configPath) {
-  writeLine10(
+function emitJson9(stdout, commandName, data, configPath) {
+  writeLine9(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError9(filePath, error) {
+function toConfigurationError8(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -9323,7 +9167,7 @@ function toConfigurationError9(filePath, error) {
 function createSchemasApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions10(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions9(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -9342,7 +9186,7 @@ function createSchemasApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError9(filePath, error);
+    toConfigurationError8(filePath, error);
   }
 }
 function ensureWritable7(commandName, readOnly, commandMode) {
@@ -9357,12 +9201,12 @@ function ensureWritable7(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector8(input) {
+function parseUuidOrSlugSelector7(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError8(message);
+    throw new InvalidArgumentError7(message);
   }
 }
 function parseBooleanFlag(input) {
@@ -9373,9 +9217,9 @@ function parseBooleanFlag(input) {
   if (["false", "0", "no", "n", "off"].includes(normalized)) {
     return false;
   }
-  throw new InvalidArgumentError8(`Expected a boolean value, received "${input}".`);
+  throw new InvalidArgumentError7(`Expected a boolean value, received "${input}".`);
 }
-function isJsonObject6(value) {
+function isJsonObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject3(input, sourceLabel) {
@@ -9389,7 +9233,7 @@ function parseRawJsonObject3(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject6(parsed)) {
+  if (!isJsonObject5(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -9464,6 +9308,22 @@ function buildSchemaUpdateInput(options) {
   }
   return input;
 }
+function applyFieldDefaultValue(input, defaultValue) {
+  if (defaultValue === void 0) {
+    return;
+  }
+  const config = input.config;
+  if (config !== void 0 && !isJsonObject5(config)) {
+    throw new CliError(
+      "invalid_cli_usage",
+      'Expected field "config" to be a JSON object when using "--default".'
+    );
+  }
+  input.config = {
+    ...config ?? {},
+    defaultValue
+  };
+}
 function buildFieldCreateInput(options) {
   const raw = normalizeSchemaFieldCreatePayload(readRawObject4(options.raw, options.rawFile));
   const rawType = typeof raw.type === "string" ? raw.type : void 0;
@@ -9492,7 +9352,8 @@ function buildFieldCreateInput(options) {
   if (options.required !== void 0) {
     input.required = options.required;
   }
-  if ("config" in input && isJsonObject6(input.config) && isEmptyObject5(input.config)) {
+  applyFieldDefaultValue(input, options.default);
+  if ("config" in input && isJsonObject5(input.config) && isEmptyObject5(input.config)) {
     delete input.config;
   }
   return input;
@@ -9534,6 +9395,7 @@ function buildFieldUpdateInput(currentType, options) {
   if (options.required !== void 0) {
     input.required = options.required;
   }
+  applyFieldDefaultValue(input, options.default);
   return input;
 }
 async function resolveSchemaSelector2(api, selector2) {
@@ -9569,23 +9431,23 @@ function isEmptyObject5(value) {
 }
 function registerSchemasCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo10(options.stdout);
+  const stdout = getCommandIo9(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);
     const data = await api.listSchemas();
     if (json) {
-      emitJson10(stdout, "schemas list", data, filePath);
+      emitJson9(stdout, "schemas list", data, filePath);
       return;
     }
     emitSchemasTable(stdout, data);
   });
-  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  schemas.command("get").description("Get a schema by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.getSchema(resolvedSchema);
     if (json) {
-      emitJson10(stdout, "schemas get", data, filePath);
+      emitJson9(stdout, "schemas get", data, filePath);
       return;
     }
     emitSchemasTable(stdout, [data]);
@@ -9601,12 +9463,12 @@ function registerSchemasCommands(program, options = {}) {
     };
     const data = await api.createSchema(input);
     if (json) {
-      emitJson10(stdout, "schemas create", data, filePath);
+      emitJson9(stdout, "schemas create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
+    writeLine9(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
   });
-  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).action(async function action(schema, commandOptions) {
+  schemas.command("update").description("Update a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).option("--name <name>", "schema name").option("--slug <slug>", "schema slug").option("--auditable <bool>", "auditable flag", parseBooleanFlag).option("--commentable <bool>", "commentable flag", parseBooleanFlag).action(async function action(schema, commandOptions) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
     ensureWritable7("schemas update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
@@ -9619,12 +9481,12 @@ function registerSchemasCommands(program, options = {}) {
     }
     const data = await api.updateSchema(resolvedSchema, input);
     if (json) {
-      emitJson10(stdout, "schemas update", data, filePath);
+      emitJson9(stdout, "schemas update", data, filePath);
       return;
     }
-    writeLine10(stdout, `Updated schema "${data.slug ?? schema.value}".`);
+    writeLine9(stdout, `Updated schema "${data.slug ?? schema.value}".`);
   });
-  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema) {
+  schemas.command("delete").description("Delete a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
     ensureWritable7("schemas delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
@@ -9634,34 +9496,34 @@ function registerSchemasCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson10(stdout, "schemas delete", data, filePath);
+      emitJson9(stdout, "schemas delete", data, filePath);
       return;
     }
-    writeLine10(stdout, `Deleted schema "${schema.value}".`);
+    writeLine9(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", parseUuidOrSlugSelector8).action(async function action(schema) {
+  fields.command("list").description("List fields for a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema) {
     const { api, json } = createSchemasApi(this, filePath);
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
     const data = await api.listFields(resolvedSchema);
     if (json) {
-      emitJson10(stdout, "schemas fields list", data, filePath);
+      emitJson9(stdout, "schemas fields list", data, filePath);
       return;
     }
     emitFieldsTable(stdout, data);
   });
-  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, field) {
+  fields.command("get").description("Get a field by UUID or slug").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector7).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);
     const data = await api.getField(resolvedSchema, resolvedField);
     if (json) {
-      emitJson10(stdout, "schemas fields get", data, filePath);
+      emitJson9(stdout, "schemas fields get", data, filePath);
       return;
     }
     emitFieldsTable(stdout, [data]);
   });
-  fields.command("create").description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`).argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).option("--type <type>", `field type (${formatSchemaFieldTypes()})`).option("--slug <slug>", "field slug").option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).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", parseUuidOrSlugSelector7).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);
     ensureWritable7("schemas fields create", readOnly, "write");
     const input = buildFieldCreateInput(commandOptions);
@@ -9673,12 +9535,12 @@ function registerSchemasCommands(program, options = {}) {
       toFieldCreateError(error, input);
     }
     if (json) {
-      emitJson10(stdout, "schemas fields create", data, filePath);
+      emitJson9(stdout, "schemas fields create", data, filePath);
       return;
     }
-    writeLine10(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
+    writeLine9(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
   });
-  fields.command("update").description("Update a field in a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).option("--label <label>", "field label").option("--required <bool>", "required flag", parseBooleanFlag).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", parseUuidOrSlugSelector7).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector7).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);
     ensureWritable7("schemas fields update", readOnly, "write");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
@@ -9697,12 +9559,12 @@ function registerSchemasCommands(program, options = {}) {
     }
     const data = await api.updateField(resolvedSchema, resolvedField, input);
     if (json) {
-      emitJson10(stdout, "schemas fields update", data, filePath);
+      emitJson9(stdout, "schemas fields update", data, filePath);
       return;
     }
-    writeLine10(stdout, `Updated field "${data.slug ?? field.value}".`);
+    writeLine9(stdout, `Updated field "${data.slug ?? field.value}".`);
   });
-  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector8).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector8).action(async function action(schema, field) {
+  fields.command("delete").description("Delete a field from a schema").argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector7).argument("<field>", "field uuid or slug", parseUuidOrSlugSelector7).action(async function action(schema, field) {
     const { api, json, readOnly } = createSchemasApi(this, filePath);
     ensureWritable7("schemas fields delete", readOnly, "destructive");
     const resolvedSchema = await resolveSchemaSelector2(api, schema);
@@ -9714,16 +9576,16 @@ function registerSchemasCommands(program, options = {}) {
       deleted: true
     };
     if (json) {
-      emitJson10(stdout, "schemas fields delete", data, filePath);
+      emitJson9(stdout, "schemas fields delete", data, filePath);
       return;
     }
-    writeLine10(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
+    writeLine9(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
   });
 }
 
 // src/commands/teamspace.ts
 import { readFileSync as readFileSync9 } from "fs";
-import { InvalidArgumentError as InvalidArgumentError9 } from "commander";
+import { InvalidArgumentError as InvalidArgumentError8 } from "commander";
 
 // src/api/teamspace.ts
 function jsonOptions7(body, method) {
@@ -9735,7 +9597,7 @@ function jsonOptions7(body, method) {
     body: JSON.stringify(body)
   };
 }
-function selectorValue9(selector2) {
+function selectorValue8(selector2) {
   return selector2.value;
 }
 var TeamspaceApi = class {
@@ -9761,13 +9623,13 @@ var TeamspaceApi = class {
   }
   updateFolder(folder, input) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue9(folder)}`,
+      `/api/v2/teamspaces/folders/${selectorValue8(folder)}`,
       jsonOptions7(input, "PATCH")
     );
   }
   deleteFolder(folder) {
     return this.client.requestJson(
-      `/api/v2/teamspaces/folders/${selectorValue9(folder)}`,
+      `/api/v2/teamspaces/folders/${selectorValue8(folder)}`,
       { method: "DELETE" }
     );
   }
@@ -9786,23 +9648,23 @@ var TeamspaceApi = class {
 };
 
 // src/commands/teamspace.ts
-function getCommandIo11(stdout) {
+function getCommandIo10(stdout) {
   return stdout ?? process.stdout;
 }
-function writeLine11(stdout, value) {
+function writeLine10(stdout, value) {
   stdout.write(`${value}
 `);
 }
-function getGlobalOptions11(command) {
+function getGlobalOptions10(command) {
   return command.optsWithGlobals();
 }
-function emitJson11(stdout, commandName, data, configPath) {
-  writeLine11(
+function emitJson10(stdout, commandName, data, configPath) {
+  writeLine10(
     stdout,
     JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath }))
   );
 }
-function toConfigurationError10(filePath, error) {
+function toConfigurationError9(filePath, error) {
   if (error instanceof CliError) {
     throw error;
   }
@@ -9817,7 +9679,7 @@ function toConfigurationError10(filePath, error) {
 function createTeamspaceApi(command, filePath) {
   try {
     const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions11(command));
+    const runtime = resolveRuntimeContext(config, getGlobalOptions10(command));
     if (!runtime.baseUrl) {
       throw new CliError(
         "configuration_error",
@@ -9835,7 +9697,7 @@ function createTeamspaceApi(command, filePath) {
       readOnly: runtime.readOnly
     };
   } catch (error) {
-    toConfigurationError10(filePath, error);
+    toConfigurationError9(filePath, error);
   }
 }
 function ensureWritable8(commandName, readOnly, commandMode) {
@@ -9850,21 +9712,21 @@ function ensureWritable8(commandName, readOnly, commandMode) {
     );
   }
 }
-function parseUuidOrSlugSelector9(input) {
+function parseUuidOrSlugSelector8(input) {
   try {
     return normalizeUuidOrSlug(input);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError9(message);
+    throw new InvalidArgumentError8(message);
   }
 }
 function parseNonNegativeInteger3(input) {
   if (!/^\d+$/.test(input.trim())) {
-    throw new InvalidArgumentError9(`Expected a non-negative integer, received "${input}".`);
+    throw new InvalidArgumentError8(`Expected a non-negative integer, received "${input}".`);
   }
   return Number(input);
 }
-function isJsonObject7(value) {
+function isJsonObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRawJsonObject4(input, sourceLabel) {
@@ -9878,7 +9740,7 @@ function parseRawJsonObject4(input, sourceLabel) {
       `Failed to parse JSON from ${sourceLabel}: ${message}`
     );
   }
-  if (!isJsonObject7(parsed)) {
+  if (!isJsonObject6(parsed)) {
     throw new CliError(
       "invalid_cli_usage",
       `Expected ${sourceLabel} to contain a JSON object.`
@@ -9950,17 +9812,17 @@ function buildFolderUpdateInput(options) {
   }
   return input;
 }
-function toTableRows5(data) {
+function toTableRows4(data) {
   if (Array.isArray(data)) {
-    return data.map((entry) => isJsonObject7(entry) ? entry : { value: entry });
+    return data.map((entry) => isJsonObject6(entry) ? entry : { value: entry });
   }
-  if (isJsonObject7(data)) {
+  if (isJsonObject6(data)) {
     return [data];
   }
   return [{ value: data }];
 }
-function emitTable5(stdout, data) {
-  printTable(toTableRows5(data), void 0, stdout);
+function emitTable4(stdout, data) {
+  printTable(toTableRows4(data), void 0, stdout);
 }
 function getFolderIdentifier(folder) {
   return typeof folder.id === "string" ? folder.id : typeof folder.name === "string" ? folder.name : "unknown";
@@ -10016,63 +9878,63 @@ async function resolveFolderSelector2(api, selector2) {
 }
 function registerTeamspaceCommands(program, options = {}) {
   const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo11(options.stdout);
+  const stdout = getCommandIo10(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 nested resources").action(async function action(commandOptions) {
     const { api, json } = createTeamspaceApi(this, filePath);
     const data = await api.listFolders(Boolean(commandOptions.includeResources));
     if (json) {
-      emitJson11(stdout, "teamspace folders list", data, filePath);
+      emitJson10(stdout, "teamspace folders list", data, filePath);
       return;
     }
-    emitTable5(stdout, data);
+    emitTable4(stdout, data);
   });
-  folders.command("get").description("Get a teamspace folder by exact name or UUID").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).option("--include-resources", "include nested resources").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", parseUuidOrSlugSelector8).option("--include-resources", "include nested resources").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));
     const data = findFolderEntity(allFolders, resolvedFolder);
     if (json) {
-      emitJson11(stdout, "teamspace folders get", data, filePath);
+      emitJson10(stdout, "teamspace folders get", data, filePath);
       return;
     }
-    emitTable5(stdout, data);
+    emitTable4(stdout, data);
   });
   folders.command("create").description("Create a teamspace folder").requiredOption("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
     ensureWritable8("teamspace folders create", readOnly, "write");
     const data = await api.createFolder(buildFolderCreateInput(commandOptions));
     if (json) {
-      emitJson11(stdout, "teamspace folders create", data, filePath);
+      emitJson10(stdout, "teamspace folders create", data, filePath);
       return;
     }
-    writeLine11(stdout, `Created folder "${getFolderIdentifier(data)}".`);
+    writeLine10(stdout, `Created folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).option("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(folder, commandOptions) {
+  folders.command("update").description("Update a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector8).option("--name <name>", "folder name").option("--order <n>", "folder order", parseNonNegativeInteger3).option("--props <json>", "folder properties payload").option("--props-file <path>", "path to a folder properties JSON payload").action(async function action(folder, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
     ensureWritable8("teamspace folders update", readOnly, "write");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.updateFolder(resolvedFolder, buildFolderUpdateInput(commandOptions));
     if (json) {
-      emitJson11(stdout, "teamspace folders update", data, filePath);
+      emitJson10(stdout, "teamspace folders update", data, filePath);
       return;
     }
-    writeLine11(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
+    writeLine10(stdout, `Updated folder "${getFolderIdentifier(data)}".`);
   });
-  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector9).action(async function action(folder) {
+  folders.command("delete").description("Delete a teamspace folder").argument("<folder>", "folder UUID or exact name", parseUuidOrSlugSelector8).action(async function action(folder) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
     ensureWritable8("teamspace folders delete", readOnly, "destructive");
     const resolvedFolder = await resolveFolderSelector2(api, folder);
     const data = await api.deleteFolder(resolvedFolder);
     if (json) {
-      emitJson11(stdout, "teamspace folders delete", data, filePath);
+      emitJson10(stdout, "teamspace folders delete", data, filePath);
       return;
     }
-    writeLine11(stdout, `Deleted folder "${resolvedFolder.value}".`);
+    writeLine10(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").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector9).requiredOption("--to <folder>", "target folder", parseUuidOrSlugSelector9).action(async function action(resource, commandOptions) {
+  resources.command("publish").description("Publish a resource to a teamspace folder").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector8).requiredOption("--to <folder>", "target folder", parseUuidOrSlugSelector8).action(async function action(resource, commandOptions) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
     ensureWritable8("teamspace resources publish", readOnly, "write");
     const folder = await resolveFolderSelector2(api, commandOptions.to);
@@ -10081,20 +9943,20 @@ function registerTeamspaceCommands(program, options = {}) {
       targetFolderId: folder.value
     });
     if (json) {
-      emitJson11(stdout, "teamspace resources publish", data, filePath);
+      emitJson10(stdout, "teamspace resources publish", data, filePath);
       return;
     }
-    writeLine11(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
+    writeLine10(stdout, `Published resource "${resource.value}" to folder "${folder.value}".`);
   });
-  resources.command("unpublish").description("Unpublish a resource from teamspace").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector9).action(async function action(resource) {
+  resources.command("unpublish").description("Unpublish a resource from teamspace").argument("<resource>", "resource UUID or exact name", parseUuidOrSlugSelector8).action(async function action(resource) {
     const { api, json, readOnly } = createTeamspaceApi(this, filePath);
     ensureWritable8("teamspace resources unpublish", readOnly, "write");
     const data = await api.unpublishResource(resource.value);
     if (json) {
-      emitJson11(stdout, "teamspace resources unpublish", data, filePath);
+      emitJson10(stdout, "teamspace resources unpublish", data, filePath);
       return;
     }
-    writeLine11(stdout, `Unpublished resource "${resource.value}".`);
+    writeLine10(stdout, `Unpublished resource "${resource.value}".`);
   });
 }
 
@@ -10102,7 +9964,7 @@ function registerTeamspaceCommands(program, options = {}) {
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 function buildProgram(options = {}) {
-  const program = new Command10();
+  const program = new Command9();
   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");
   registerProfilesCommands(program, options);
   registerAutomationsCommands(program, options);
@@ -10113,7 +9975,6 @@ function buildProgram(options = {}) {
   registerSchemasCommands(program, options);
   registerRecordsCommands(program, options);
   registerCommentsCommands(program, options);
-  registerLogsCommands(program, options);
   registerTeamspaceCommands(program, options);
   return program;
 }