@lotics/cli 0.111.0 → 0.113.0

package/dist/src/cli.js

@@ -33334,8 +33334,8 @@ var require_utils2 = __commonJS({
     var { Address } = require_helpers();
     var { Prefix, Postfix, Infix, Operators } = require_operators();
     var Collection = require_collection();
-    var MAX_ROW = 1048576;
-    var MAX_COLUMN = 16384;
+    var MAX_ROW2 = 1048576;
+    var MAX_COLUMN2 = 16384;
     var { NotAllInputParsedException } = require_api();
     var Utils = class {
       constructor(context) {
@@ -33564,7 +33564,7 @@ var require_utils2 = __commonJS({
        // * @return {{ref: {from: {col: number, row: number}, to: {col: number, row: number}}}}
        */
       applyRange(refs) {
-        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW + 1, minCol = MAX_COLUMN + 1;
+        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW2 + 1, minCol = MAX_COLUMN2 + 1;
         refs.forEach((ref2) => {
           if (this.isFormulaError(ref2))
             return ref2;
@@ -33574,11 +33574,11 @@ var require_utils2 = __commonJS({
           ref2 = ref2.ref;
           if (ref2.row === void 0) {
             minRow = 1;
-            maxRow = MAX_ROW;
+            maxRow = MAX_ROW2;
           }
           if (ref2.col === void 0) {
             minCol = 1;
-            maxCol = MAX_COLUMN;
+            maxCol = MAX_COLUMN2;
           }
           if (ref2.row > maxRow)
             maxRow = ref2.row;
@@ -34014,8 +34014,8 @@ var require_utils3 = __commonJS({
     var { FormulaHelpers, Types, Address } = require_helpers();
     var { Prefix, Postfix, Infix, Operators } = require_operators();
     var Collection = require_collection();
-    var MAX_ROW = 1048576;
-    var MAX_COLUMN = 16384;
+    var MAX_ROW2 = 1048576;
+    var MAX_COLUMN2 = 16384;
     var Utils = class {
       constructor(context) {
         this.context = context;
@@ -34161,7 +34161,7 @@ var require_utils3 = __commonJS({
        // * @return {{ref: {from: {col: number, row: number}, to: {col: number, row: number}}}}
        */
       applyRange(refs) {
-        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW + 1, minCol = MAX_COLUMN + 1;
+        let res, maxRow = -1, maxCol = -1, minRow = MAX_ROW2 + 1, minCol = MAX_COLUMN2 + 1;
         refs.forEach((ref2) => {
           if (this.isFormulaError(ref2))
             return ref2;
@@ -34171,11 +34171,11 @@ var require_utils3 = __commonJS({
           ref2 = ref2.ref;
           if (ref2.row === void 0) {
             minRow = 1;
-            maxRow = MAX_ROW;
+            maxRow = MAX_ROW2;
           }
           if (ref2.col === void 0) {
             minCol = 1;
-            maxCol = MAX_COLUMN;
+            maxCol = MAX_COLUMN2;
           }
           if (ref2.row > maxRow)
             maxRow = ref2.row;
@@ -44124,9 +44124,9 @@ var require_load = __commonJS({
 var require_lib4 = __commonJS({
   "../../node_modules/jszip/lib/index.js"(exports2, module2) {
     "use strict";
-    function JSZip4() {
-      if (!(this instanceof JSZip4)) {
-        return new JSZip4();
+    function JSZip5() {
+      if (!(this instanceof JSZip5)) {
+        return new JSZip5();
       }
       if (arguments.length) {
         throw new Error("The constructor with parameters has been removed in JSZip 3.0, please check the upgrade guide.");
@@ -44135,7 +44135,7 @@ var require_lib4 = __commonJS({
       this.comment = null;
       this.root = "";
       this.clone = function() {
-        var newObj = new JSZip4();
+        var newObj = new JSZip5();
         for (var i2 in this) {
           if (typeof this[i2] !== "function") {
             newObj[i2] = this[i2];
@@ -44144,16 +44144,16 @@ var require_lib4 = __commonJS({
         return newObj;
       };
     }
-    JSZip4.prototype = require_object();
-    JSZip4.prototype.loadAsync = require_load();
-    JSZip4.support = require_support();
-    JSZip4.defaults = require_defaults();
-    JSZip4.version = "3.10.1";
-    JSZip4.loadAsync = function(content, options) {
-      return new JSZip4().loadAsync(content, options);
+    JSZip5.prototype = require_object();
+    JSZip5.prototype.loadAsync = require_load();
+    JSZip5.support = require_support();
+    JSZip5.defaults = require_defaults();
+    JSZip5.version = "3.10.1";
+    JSZip5.loadAsync = function(content, options) {
+      return new JSZip5().loadAsync(content, options);
     };
-    JSZip4.external = require_external();
-    module2.exports = JSZip4;
+    JSZip5.external = require_external();
+    module2.exports = JSZip5;
   }
 });
 
@@ -62234,353 +62234,6 @@ var templatePartSchema = zod_default.lazy(
   ])
 );
 
-// ../shared/src/schemas/table_filters.ts
-var tableRecordNumberFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("number"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum([
-    "equals",
-    "not_equals",
-    "greater_than",
-    "less_than",
-    "greater_than_or_equal_to",
-    "less_than_or_equal_to",
-    "is_empty",
-    "is_not_empty"
-  ]),
-  value: zod_default.number().nullable()
-});
-var tableRecordTextFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("text"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum([
-    "equals",
-    "not_equals",
-    "contains",
-    "does_not_contain",
-    "starts_with",
-    "ends_with",
-    "is_empty",
-    "is_not_empty",
-    "is_any_of",
-    "is_none_of"
-  ]),
-  value: zod_default.union([zod_default.string(), zod_default.array(zod_default.string())]).nullable()
-});
-var dateTimePointExactSchema = zod_default.object({
-  type: zod_default.literal("exact"),
-  date: zod_default.string().nullable().describe("ISO 8601 date (YYYY-MM-DD)"),
-  time: zod_default.string().nullable().optional().describe("Time HH:mm")
-});
-var timeUnitSchema = zod_default.enum(["minutes", "hours", "days", "weeks", "months", "years"]);
-var dateTimePointRelativeSchema = zod_default.object({
-  type: zod_default.literal("relative"),
-  offset: zod_default.number().describe("Negative=past, positive=future"),
-  unit: timeUnitSchema,
-  time: zod_default.string().nullable().optional().describe("Fixed time HH:mm")
-});
-var dateTimePointPeriodSchema = zod_default.object({
-  type: zod_default.literal("period"),
-  period: zod_default.enum(["day", "week", "month", "quarter", "year"]),
-  boundary: zod_default.enum(["start", "end"]),
-  offset: zod_default.number().optional().describe("0=current, -1=last, 1=next"),
-  time: zod_default.string().nullable().optional().describe("Fixed time HH:mm")
-});
-var dateTimePointSchema = zod_default.discriminatedUnion("type", [
-  dateTimePointExactSchema,
-  dateTimePointRelativeSchema,
-  dateTimePointPeriodSchema
-]);
-var betweenRangeValueSchema = zod_default.object({
-  start: dateTimePointSchema.nullable().describe("Null=no lower bound"),
-  end: dateTimePointSchema.nullable().describe("Null=no upper bound")
-});
-var timeOnlyValueSchema = zod_default.object({
-  start_time: zod_default.string().nullable().describe("HH:mm"),
-  end_time: zod_default.string().nullable().describe("HH:mm")
-});
-var durationValueSchema = zod_default.object({
-  amount: zod_default.number(),
-  unit: zod_default.enum(["minutes", "hours", "days"])
-});
-var tableRecordDateFieldFilterBaseSchema = zod_default.object({
-  type: zod_default.literal("date"),
-  field_key: zod_default.string()
-});
-var tableRecordDateFieldFilterEmptySchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("is_empty"),
-  value: zod_default.null()
-});
-var tableRecordDateFieldFilterNotEmptySchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("is_not_empty"),
-  value: zod_default.null()
-});
-var tableRecordDateFieldFilterBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("before"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("after"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterOnOrBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("on_or_before"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterOnOrAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("on_or_after"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterOnSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("on"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterBetweenSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("between"),
-  value: betweenRangeValueSchema.nullable()
-});
-var tableRecordDateFieldFilterTimeOfDaySchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("time_of_day"),
-  value: timeOnlyValueSchema.nullable()
-});
-var tableRecordDateFieldFilterOverlapsSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("overlaps"),
-  value: betweenRangeValueSchema.nullable()
-});
-var tableRecordDateFieldFilterContainsSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("contains"),
-  value: betweenRangeValueSchema.nullable()
-});
-var tableRecordDateFieldFilterWithinSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("within"),
-  value: betweenRangeValueSchema.nullable()
-});
-var tableRecordDateFieldFilterStartsBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("starts_before"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterStartsAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("starts_after"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterEndsBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("ends_before"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterEndsAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("ends_after"),
-  value: dateTimePointSchema.nullable()
-});
-var tableRecordDateFieldFilterDurationEqualsSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("duration_equals"),
-  value: durationValueSchema.nullable()
-});
-var tableRecordDateFieldFilterDurationGreaterThanSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("duration_greater_than"),
-  value: durationValueSchema.nullable()
-});
-var tableRecordDateFieldFilterDurationLessThanSchema = tableRecordDateFieldFilterBaseSchema.extend({
-  operator: zod_default.literal("duration_less_than"),
-  value: durationValueSchema.nullable()
-});
-var tableRecordDateFieldFilterSchema = zod_default.discriminatedUnion("operator", [
-  tableRecordDateFieldFilterEmptySchema,
-  tableRecordDateFieldFilterNotEmptySchema,
-  tableRecordDateFieldFilterBeforeSchema,
-  tableRecordDateFieldFilterAfterSchema,
-  tableRecordDateFieldFilterOnOrBeforeSchema,
-  tableRecordDateFieldFilterOnOrAfterSchema,
-  tableRecordDateFieldFilterOnSchema,
-  tableRecordDateFieldFilterBetweenSchema,
-  tableRecordDateFieldFilterTimeOfDaySchema,
-  tableRecordDateFieldFilterOverlapsSchema,
-  tableRecordDateFieldFilterContainsSchema,
-  tableRecordDateFieldFilterWithinSchema,
-  tableRecordDateFieldFilterStartsBeforeSchema,
-  tableRecordDateFieldFilterStartsAfterSchema,
-  tableRecordDateFieldFilterEndsBeforeSchema,
-  tableRecordDateFieldFilterEndsAfterSchema,
-  tableRecordDateFieldFilterDurationEqualsSchema,
-  tableRecordDateFieldFilterDurationGreaterThanSchema,
-  tableRecordDateFieldFilterDurationLessThanSchema
-]);
-var tableRecordBooleanFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("boolean"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum(["equals"]),
-  value: zod_default.boolean().nullable()
-});
-var tableRecordSelectFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("select"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum([
-    "has_any_of",
-    "has_none_of",
-    "is_empty",
-    "is_not_empty",
-    "has_all_of"
-  ]),
-  value: zod_default.array(zod_default.string()).nullable()
-});
-var tableRecordSelectMemberFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("select_member"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum([
-    "has_any_of",
-    "has_none_of",
-    "is_empty",
-    "is_not_empty",
-    "has_all_of",
-    "is_current_member",
-    "is_not_current_member"
-  ]),
-  value: zod_default.array(zod_default.string()).nullable()
-});
-var tableRecordSelectRecordLinkFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("select_record_link"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum([
-    // Membership operators — match linked record IDs. value: string[].
-    "has_any_of",
-    "has_none_of",
-    "has_all_of",
-    // Text operators — match the cached display text. value: string.
-    "contains",
-    "not_contains",
-    "starts_with",
-    "ends_with",
-    "is_empty",
-    "is_not_empty"
-  ]),
-  value: zod_default.union([zod_default.string(), zod_default.array(zod_default.string())]).nullable()
-});
-var tableRecordFilesFieldFilterSchema = zod_default.object({
-  type: zod_default.literal("files"),
-  field_key: zod_default.string(),
-  operator: zod_default.enum(["has_filename", "has_mime_type", "has_file_count", "is_empty", "is_not_empty"]),
-  value: zod_default.string().nullable()
-});
-var tableRecordLockedFilterSchema = zod_default.object({
-  type: zod_default.literal("locked"),
-  operator: zod_default.enum(["is_locked", "is_not_locked"]),
-  value: zod_default.null()
-});
-var tableRecordCurrentMemberFilterSchema = zod_default.object({
-  type: zod_default.literal("current_member"),
-  operator: zod_default.enum(["in_any_group"]),
-  value: zod_default.array(zod_default.string())
-});
-var tableRecordRecordIdFilterSchema = zod_default.object({
-  type: zod_default.literal("record_id"),
-  operator: zod_default.enum(["is_any_of", "is_none_of"]),
-  value: zod_default.array(zod_default.string())
-});
-var tableRecordFieldFilterConditionSchema = zod_default.union([
-  tableRecordTextFieldFilterSchema,
-  tableRecordNumberFieldFilterSchema,
-  tableRecordDateFieldFilterSchema,
-  tableRecordBooleanFieldFilterSchema,
-  tableRecordSelectMemberFieldFilterSchema,
-  tableRecordSelectFieldFilterSchema,
-  tableRecordSelectRecordLinkFieldFilterSchema,
-  tableRecordFilesFieldFilterSchema
-]);
-var tableRecordFiltersConditionNodeSchema = zod_default.object({
-  node_type: zod_default.literal("condition"),
-  field_key: zod_default.string().optional(),
-  type: zod_default.string().optional(),
-  operator: zod_default.string(),
-  value: zod_default.unknown().optional()
-});
-var tableRecordFiltersTraversalNodeSchema = zod_default.object({
-  node_type: zod_default.literal("traversal"),
-  path: zod_default.array(zod_default.string()),
-  condition: tableRecordFiltersConditionNodeSchema
-});
-var tableRecordFiltersGroupNodeSchema = zod_default.lazy(
-  () => zod_default.object({
-    node_type: zod_default.literal("group"),
-    logic: zod_default.enum(["and", "or"]),
-    children: zod_default.array(
-      zod_default.union([
-        tableRecordFiltersConditionNodeSchema,
-        tableRecordFiltersTraversalNodeSchema,
-        tableRecordFiltersGroupNodeSchema
-      ])
-    )
-  })
-);
-var tableRecordFiltersSchema = zod_default.union([
-  tableRecordFiltersConditionNodeSchema,
-  tableRecordFiltersTraversalNodeSchema,
-  tableRecordFiltersGroupNodeSchema
-]);
-var optionColorSchema = zod_default.enum([
-  "red",
-  "orange",
-  "amber",
-  "yellow",
-  "lime",
-  "green",
-  "emerald",
-  "teal",
-  "cyan",
-  "sky",
-  "blue",
-  "indigo",
-  "violet",
-  "purple",
-  "fuchsia",
-  "pink",
-  "rose",
-  "slate",
-  "gray",
-  "zinc",
-  "neutral",
-  "stone"
-]);
-var tableRecordColorSchema = zod_default.object({
-  filters: tableRecordFiltersGroupNodeSchema.nullable().describe(
-    "The filter conditions that determine when this color rule applies. Null means no filtering."
-  ),
-  color: optionColorSchema.describe(
-    "The color to apply to records matching the filters."
-  )
-});
-var tableRecordColorsSchema = zod_default.array(tableRecordColorSchema);
-var tableRecordSortSchema = zod_default.array(
-  zod_default.object({
-    field_key: zod_default.string().describe("Field key to sort by"),
-    order: zod_default.enum(["asc", "desc"]).nullable().describe("Sort order: 'asc' for ascending, 'desc' for descending"),
-    blank_position: zod_default.enum(["top", "bottom"]).optional().describe("Blank position: 'top' for top, 'bottom' for bottom")
-  })
-);
-var TEXT_OPS = tableRecordTextFieldFilterSchema.shape.operator.options;
-var NUMBER_OPS = tableRecordNumberFieldFilterSchema.shape.operator.options;
-var DATE_OPS = tableRecordDateFieldFilterSchema.options.map((s) => s.shape.operator.value);
-var BOOLEAN_OPS = tableRecordBooleanFieldFilterSchema.shape.operator.options;
-var SELECT_OPS = tableRecordSelectFieldFilterSchema.shape.operator.options;
-var SELECT_MEMBER_OPS = tableRecordSelectMemberFieldFilterSchema.shape.operator.options;
-var SELECT_RECORD_LINK_OPS = tableRecordSelectRecordLinkFieldFilterSchema.shape.operator.options;
-var FILES_OPS = tableRecordFilesFieldFilterSchema.shape.operator.options;
-var LOCKED_OPS = tableRecordLockedFilterSchema.shape.operator.options;
-var CURRENT_MEMBER_OPS = tableRecordCurrentMemberFilterSchema.shape.operator.options;
-var RECORD_ID_OPS = tableRecordRecordIdFilterSchema.shape.operator.options;
-var VALID_OPERATORS = {
-  text: TEXT_OPS,
-  number: NUMBER_OPS,
-  date: DATE_OPS,
-  boolean: BOOLEAN_OPS,
-  select: SELECT_OPS,
-  select_member: SELECT_MEMBER_OPS,
-  select_record_link: SELECT_RECORD_LINK_OPS,
-  files: FILES_OPS,
-  locked: LOCKED_OPS,
-  current_member: CURRENT_MEMBER_OPS,
-  record_id: RECORD_ID_OPS
-};
-var VALID_FILTER_TYPES = Object.keys(VALID_OPERATORS);
-
 // ../../node_modules/date-fns/constants.js
 var daysInYear = 365.2425;
 var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
@@ -64461,13 +64114,374 @@ for (const [operation, fieldTypes] of Object.entries(OPERATION_FIELD_TYPES)) {
 }
 var AGGREGATABLE_FIELD_TYPES = new Set(FIELD_TYPE_OPERATIONS.keys());
 
+// ../shared/src/schemas/table_filters.ts
+var tableRecordNumberFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("number"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum([
+    "equals",
+    "not_equals",
+    "greater_than",
+    "less_than",
+    "greater_than_or_equal_to",
+    "less_than_or_equal_to",
+    "is_empty",
+    "is_not_empty"
+  ]),
+  value: zod_default.number().nullable()
+});
+var tableRecordTextFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("text"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum([
+    "equals",
+    "not_equals",
+    "contains",
+    "does_not_contain",
+    "starts_with",
+    "ends_with",
+    "is_empty",
+    "is_not_empty",
+    "is_any_of",
+    "is_none_of"
+  ]),
+  value: zod_default.union([zod_default.string(), zod_default.array(zod_default.string())]).nullable()
+});
+var dateTimePointExactSchema = zod_default.object({
+  type: zod_default.literal("exact"),
+  date: zod_default.string().nullable().describe("ISO 8601 date (YYYY-MM-DD)"),
+  time: zod_default.string().nullable().optional().describe("Time HH:mm")
+});
+var timeUnitSchema = zod_default.enum(["minutes", "hours", "days", "weeks", "months", "years"]);
+var dateTimePointRelativeSchema = zod_default.object({
+  type: zod_default.literal("relative"),
+  offset: zod_default.number().describe("Negative=past, positive=future"),
+  unit: timeUnitSchema,
+  time: zod_default.string().nullable().optional().describe("Fixed time HH:mm")
+});
+var dateTimePointPeriodSchema = zod_default.object({
+  type: zod_default.literal("period"),
+  period: zod_default.enum(["day", "week", "month", "quarter", "year"]),
+  boundary: zod_default.enum(["start", "end"]),
+  offset: zod_default.number().optional().describe("0=current, -1=last, 1=next"),
+  time: zod_default.string().nullable().optional().describe("Fixed time HH:mm")
+});
+var dateTimePointSchema = zod_default.discriminatedUnion("type", [
+  dateTimePointExactSchema,
+  dateTimePointRelativeSchema,
+  dateTimePointPeriodSchema
+]);
+var betweenRangeValueSchema = zod_default.object({
+  start: dateTimePointSchema.nullable().describe("Null=no lower bound"),
+  end: dateTimePointSchema.nullable().describe("Null=no upper bound")
+});
+var timeOnlyValueSchema = zod_default.object({
+  start_time: zod_default.string().nullable().describe("HH:mm"),
+  end_time: zod_default.string().nullable().describe("HH:mm")
+});
+var durationValueSchema = zod_default.object({
+  amount: zod_default.number(),
+  unit: zod_default.enum(["minutes", "hours", "days"])
+});
+var tableRecordDateFieldFilterBaseSchema = zod_default.object({
+  type: zod_default.literal("date"),
+  field_key: zod_default.string()
+});
+var tableRecordDateFieldFilterEmptySchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("is_empty"),
+  value: zod_default.null()
+});
+var tableRecordDateFieldFilterNotEmptySchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("is_not_empty"),
+  value: zod_default.null()
+});
+var tableRecordDateFieldFilterBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("before"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("after"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterOnOrBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("on_or_before"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterOnOrAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("on_or_after"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterOnSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("on"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterBetweenSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("between"),
+  value: betweenRangeValueSchema.nullable()
+});
+var tableRecordDateFieldFilterTimeOfDaySchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("time_of_day"),
+  value: timeOnlyValueSchema.nullable()
+});
+var tableRecordDateFieldFilterOverlapsSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("overlaps"),
+  value: betweenRangeValueSchema.nullable()
+});
+var tableRecordDateFieldFilterContainsSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("contains"),
+  value: betweenRangeValueSchema.nullable()
+});
+var tableRecordDateFieldFilterWithinSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("within"),
+  value: betweenRangeValueSchema.nullable()
+});
+var tableRecordDateFieldFilterStartsBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("starts_before"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterStartsAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("starts_after"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterEndsBeforeSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("ends_before"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterEndsAfterSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("ends_after"),
+  value: dateTimePointSchema.nullable()
+});
+var tableRecordDateFieldFilterDurationEqualsSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("duration_equals"),
+  value: durationValueSchema.nullable()
+});
+var tableRecordDateFieldFilterDurationGreaterThanSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("duration_greater_than"),
+  value: durationValueSchema.nullable()
+});
+var tableRecordDateFieldFilterDurationLessThanSchema = tableRecordDateFieldFilterBaseSchema.extend({
+  operator: zod_default.literal("duration_less_than"),
+  value: durationValueSchema.nullable()
+});
+var tableRecordDateFieldFilterSchema = zod_default.discriminatedUnion("operator", [
+  tableRecordDateFieldFilterEmptySchema,
+  tableRecordDateFieldFilterNotEmptySchema,
+  tableRecordDateFieldFilterBeforeSchema,
+  tableRecordDateFieldFilterAfterSchema,
+  tableRecordDateFieldFilterOnOrBeforeSchema,
+  tableRecordDateFieldFilterOnOrAfterSchema,
+  tableRecordDateFieldFilterOnSchema,
+  tableRecordDateFieldFilterBetweenSchema,
+  tableRecordDateFieldFilterTimeOfDaySchema,
+  tableRecordDateFieldFilterOverlapsSchema,
+  tableRecordDateFieldFilterContainsSchema,
+  tableRecordDateFieldFilterWithinSchema,
+  tableRecordDateFieldFilterStartsBeforeSchema,
+  tableRecordDateFieldFilterStartsAfterSchema,
+  tableRecordDateFieldFilterEndsBeforeSchema,
+  tableRecordDateFieldFilterEndsAfterSchema,
+  tableRecordDateFieldFilterDurationEqualsSchema,
+  tableRecordDateFieldFilterDurationGreaterThanSchema,
+  tableRecordDateFieldFilterDurationLessThanSchema
+]);
+var tableRecordBooleanFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("boolean"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum(["equals"]),
+  value: zod_default.boolean().nullable()
+});
+var tableRecordSelectFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("select"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum([
+    "has_any_of",
+    "has_none_of",
+    "is_empty",
+    "is_not_empty",
+    "has_all_of"
+  ]),
+  value: zod_default.array(zod_default.string()).nullable()
+});
+var tableRecordSelectMemberFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("select_member"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum([
+    "has_any_of",
+    "has_none_of",
+    "is_empty",
+    "is_not_empty",
+    "has_all_of",
+    "is_current_member",
+    "is_not_current_member"
+  ]),
+  value: zod_default.array(zod_default.string()).nullable()
+});
+var tableRecordSelectRecordLinkFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("select_record_link"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum([
+    // Membership operators — match linked record IDs. value: string[].
+    "has_any_of",
+    "has_none_of",
+    "has_all_of",
+    // Text operators — match the cached display text. value: string.
+    "contains",
+    "not_contains",
+    "starts_with",
+    "ends_with",
+    "is_empty",
+    "is_not_empty"
+  ]),
+  value: zod_default.union([zod_default.string(), zod_default.array(zod_default.string())]).nullable()
+});
+var tableRecordFilesFieldFilterSchema = zod_default.object({
+  type: zod_default.literal("files"),
+  field_key: zod_default.string(),
+  operator: zod_default.enum(["has_filename", "has_mime_type", "has_file_count", "is_empty", "is_not_empty"]),
+  value: zod_default.string().nullable()
+});
+var tableRecordLockedFilterSchema = zod_default.object({
+  type: zod_default.literal("locked"),
+  operator: zod_default.enum(["is_locked", "is_not_locked"]),
+  value: zod_default.null()
+});
+var tableRecordCurrentMemberFilterSchema = zod_default.object({
+  type: zod_default.literal("current_member"),
+  operator: zod_default.enum(["in_any_group"]),
+  value: zod_default.array(zod_default.string())
+});
+var tableRecordRecordIdFilterSchema = zod_default.object({
+  type: zod_default.literal("record_id"),
+  operator: zod_default.enum(["is_any_of", "is_none_of"]),
+  value: zod_default.array(zod_default.string())
+});
+var tableRecordFieldFilterConditionSchema = zod_default.union([
+  tableRecordTextFieldFilterSchema,
+  tableRecordNumberFieldFilterSchema,
+  tableRecordDateFieldFilterSchema,
+  tableRecordBooleanFieldFilterSchema,
+  tableRecordSelectMemberFieldFilterSchema,
+  tableRecordSelectFieldFilterSchema,
+  tableRecordSelectRecordLinkFieldFilterSchema,
+  tableRecordFilesFieldFilterSchema
+]);
+var tableRecordFiltersConditionNodeSchema = zod_default.object({
+  node_type: zod_default.literal("condition"),
+  field_key: zod_default.string().optional(),
+  type: zod_default.string().optional(),
+  operator: zod_default.string(),
+  value: zod_default.unknown().optional()
+});
+var tableRecordFiltersTraversalNodeSchema = zod_default.object({
+  node_type: zod_default.literal("traversal"),
+  path: zod_default.array(zod_default.string()),
+  condition: tableRecordFiltersConditionNodeSchema
+});
+var tableRecordFiltersGroupNodeSchema = zod_default.lazy(
+  () => zod_default.object({
+    node_type: zod_default.literal("group"),
+    logic: zod_default.enum(["and", "or"]),
+    children: zod_default.array(
+      zod_default.union([
+        tableRecordFiltersConditionNodeSchema,
+        tableRecordFiltersTraversalNodeSchema,
+        tableRecordFiltersGroupNodeSchema
+      ])
+    )
+  })
+);
+var tableRecordFiltersSchema = zod_default.union([
+  tableRecordFiltersConditionNodeSchema,
+  tableRecordFiltersTraversalNodeSchema,
+  tableRecordFiltersGroupNodeSchema
+]);
+var optionColorSchema = zod_default.enum([
+  "red",
+  "orange",
+  "amber",
+  "yellow",
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  "sky",
+  "blue",
+  "indigo",
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose",
+  "slate",
+  "gray",
+  "zinc",
+  "neutral",
+  "stone"
+]);
+var tableRecordColorSchema = zod_default.object({
+  filters: tableRecordFiltersGroupNodeSchema.nullable().describe(
+    "The filter conditions that determine when this color rule applies. Null means no filtering."
+  ),
+  color: optionColorSchema.describe(
+    "The color to apply to records matching the filters."
+  )
+});
+var tableRecordColorsSchema = zod_default.array(tableRecordColorSchema);
+var tableRecordSortSchema = zod_default.array(
+  zod_default.object({
+    field_key: zod_default.string().describe("Field key to sort by"),
+    order: zod_default.enum(["asc", "desc"]).nullable().describe("Sort order: 'asc' for ascending, 'desc' for descending"),
+    blank_position: zod_default.enum(["top", "bottom"]).optional().describe("Blank position: 'top' for top, 'bottom' for bottom")
+  })
+);
+var TEXT_OPS = tableRecordTextFieldFilterSchema.shape.operator.options;
+var NUMBER_OPS = tableRecordNumberFieldFilterSchema.shape.operator.options;
+var DATE_OPS = tableRecordDateFieldFilterSchema.options.map((s) => s.shape.operator.value);
+var BOOLEAN_OPS = tableRecordBooleanFieldFilterSchema.shape.operator.options;
+var SELECT_OPS = tableRecordSelectFieldFilterSchema.shape.operator.options;
+var SELECT_MEMBER_OPS = tableRecordSelectMemberFieldFilterSchema.shape.operator.options;
+var SELECT_RECORD_LINK_OPS = tableRecordSelectRecordLinkFieldFilterSchema.shape.operator.options;
+var FILES_OPS = tableRecordFilesFieldFilterSchema.shape.operator.options;
+var LOCKED_OPS = tableRecordLockedFilterSchema.shape.operator.options;
+var CURRENT_MEMBER_OPS = tableRecordCurrentMemberFilterSchema.shape.operator.options;
+var RECORD_ID_OPS = tableRecordRecordIdFilterSchema.shape.operator.options;
+var VALID_OPERATORS = {
+  text: TEXT_OPS,
+  number: NUMBER_OPS,
+  date: DATE_OPS,
+  boolean: BOOLEAN_OPS,
+  select: SELECT_OPS,
+  select_member: SELECT_MEMBER_OPS,
+  select_record_link: SELECT_RECORD_LINK_OPS,
+  files: FILES_OPS,
+  locked: LOCKED_OPS,
+  current_member: CURRENT_MEMBER_OPS,
+  record_id: RECORD_ID_OPS
+};
+var VALID_FILTER_TYPES = Object.keys(VALID_OPERATORS);
+
 // ../shared/src/chat_models.ts
-var CHAT_MODEL_IDS = ["claude-haiku-4-5", "claude-sonnet-5", "claude-opus-5"];
-var LEGACY_CHAT_MODEL_IDS = [];
-var ACCEPTED_CHAT_MODEL_IDS = [...CHAT_MODEL_IDS, ...LEGACY_CHAT_MODEL_IDS];
-var UTILITY_MODEL_ID = "claude-haiku-4-5";
-var PICKER_MODEL_IDS = CHAT_MODEL_IDS.filter(
-  (id) => id !== UTILITY_MODEL_ID
+var MODEL_TIERS = ["haiku", "sonnet", "opus"];
+var TIER_MODELS = {
+  haiku: "claude-haiku-4-5",
+  sonnet: "claude-sonnet-5",
+  opus: "claude-opus-5"
+};
+var RESOLVED_MODEL_IDS = MODEL_TIERS.map(
+  (tier) => TIER_MODELS[tier]
+);
+function tierForModelId(modelId) {
+  for (const tier of MODEL_TIERS) {
+    if (modelId.startsWith(`claude-${tier}-`)) return tier;
+  }
+  return null;
+}
+var DEFAULT_MODEL_TIER = "sonnet";
+var UTILITY_MODEL_TIER = "haiku";
+var DEFAULT_MODEL_ID = TIER_MODELS[DEFAULT_MODEL_TIER];
+var PICKER_MODEL_TIERS = MODEL_TIERS.filter(
+  (tier) => tier !== UTILITY_MODEL_TIER
 );
 var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 
@@ -64927,11 +64941,20 @@ var appAgentDeclarationSchema = zod_default.object({
   workflow_aliases: zod_default.array(zod_default.string().min(1)).optional().describe(
     "Workflows from this app's manifest the agent may invoke via `run_app_workflow`, validated at declare time against the app's own workflows. This is the agent's ENTIRE write surface \u2014 the same declared mutation path the app's UI uses, so table hooks and side-effect harvesting apply. Omit for a read-only agent."
   ),
-  model_id: zod_default.string().min(1).optional().describe(
-    "Chat model id the agent runs on, validated against ACCEPTED_CHAT_MODEL_IDS. Omit to follow the platform default chat model, resolved at run time \u2014 the preferred choice: the agent tracks model generations with no per-app rewrite. Pin only a deliberate, tested choice."
+  model_tier: zod_default.enum(MODEL_TIERS).optional().describe(
+    "Model tier the agent runs on \u2014 `haiku`, `sonnet`, or `opus`. Omit to follow the platform default tier, resolved at run time: the preferred choice. A tier names capability, not a version, so the generation behind it moves with the platform and this declaration never needs a rewrite. Pin only a deliberate, tested choice."
   ),
+  /**
+   * LEGACY, read-only. A version pin written by a release from before tiers.
+   * Parsed so a declaration an older release wrote during the rollout window
+   * still resolves (via `tierForModelId`) instead of reading as unpinned
+   * and silently dropping to the default. Never written by this release, and
+   * rejected on the write surface. Deleted with the strip migration, once no
+   * deployed release writes it.
+   */
+  model_id: zod_default.string().min(1).optional(),
   effort_level: zod_default.enum(EFFORT_LEVELS).optional().describe(
-    "Reasoning depth for adaptive-thinking models \u2014 one of the chosen model's supported levels (validated against model_id at declare time). Omit to use the model default; ignored on models without adaptive thinking."
+    "Reasoning depth for adaptive-thinking tiers \u2014 one of the chosen tier's supported levels (validated against model_tier at declare time). Omit to use the model default; ignored on tiers without adaptive thinking."
   ),
   inputs: zod_default.record(zod_default.string(), appWorkflowInputSchema).optional().describe(
     "Typed input schema for one run. Keys are input names; values declare type + constraints. The server validates the run payload against this before invoking; CLI codegen emits a typed `useAgentRun<alias>` signature. Omit for an untyped payload."
@@ -65070,6 +65093,8 @@ var agentStepSchema = stepBaseSchema.extend({
   instructions: zod_default.string().min(1),
   input: zod_default.record(zod_default.string(), toolInputValueSchema),
   tool_names: zod_default.array(zod_default.string().min(1)),
+  model_tier: zod_default.enum(MODEL_TIERS).optional(),
+  /** LEGACY, read-only — see `appAgentDeclarationSchema.model_id`. */
   model_id: zod_default.string().min(1).optional(),
   output: agentOutputSpecSchema
 });
@@ -69683,8 +69708,6 @@ function walkAgentInvocation(call, scope, stepId, description) {
   const toolsNode = kw.get("tools");
   if (!toolsNode) fail(arg, "agent requires `tools` (use [] for none).");
   const tool_names = readStaticStringArray(toolsNode, "agent `tools`");
-  const modelNode = kw.get("model");
-  const model_id = modelNode ? readStaticString(modelNode, "agent `model`") : void 0;
   const outputNode = kw.get("output");
   if (!outputNode) fail(arg, "agent requires `output`.");
   const outputResult = agentOutputSpecSchema.safeParse(walkStaticJsonLiteral(outputNode));
@@ -69692,6 +69715,19 @@ function walkAgentInvocation(call, scope, stepId, description) {
     const detail = outputResult.error.issues.map((i2) => `${i2.path.join(".") || "<root>"}: ${i2.message}`).join("; ");
     fail(outputNode, `Invalid agent \`output\`: ${detail}`);
   }
+  const modelNode = kw.get("model");
+  let model_tier;
+  if (modelNode) {
+    const literal2 = readStaticString(modelNode, "agent `model`");
+    const tier = MODEL_TIERS.includes(literal2) ? literal2 : tierForModelId(literal2);
+    if (!tier) {
+      fail(
+        modelNode,
+        `Unknown agent \`model\` "${literal2}" \u2014 expected one of: ${MODEL_TIERS.join(", ")}.`
+      );
+    }
+    model_tier = tier;
+  }
   return {
     id: stepId,
     description: description ?? "agent",
@@ -69699,7 +69735,7 @@ function walkAgentInvocation(call, scope, stepId, description) {
     instructions,
     input,
     tool_names,
-    ...model_id !== void 0 ? { model_id } : {},
+    ...model_tier !== void 0 ? { model_tier } : {},
     output: outputResult.data
   };
 }
@@ -77943,6 +77979,59 @@ function hueToRgb(p, q, t) {
   return p;
 }
 
+// ../xlsx/src/excel_utils.ts
+function colLettersToNum(letters) {
+  let result = 0;
+  for (let i2 = 0; i2 < letters.length; i2++) {
+    result = result * 26 + (letters.charCodeAt(i2) - 64);
+  }
+  return result;
+}
+function colNumToLetters(col) {
+  let result = "";
+  let n = col;
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(65 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+}
+function refToRowCol(ref2) {
+  const match2 = ref2.match(/^(\$?)([A-Z]+)(\$?)(\d+)$/);
+  if (!match2) return void 0;
+  return { col: colLettersToNum(match2[2]), row: parseInt(match2[4], 10) };
+}
+function rowColToRef(row, col) {
+  return colNumToLetters(col) + String(row);
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var PACK_COL_BITS = 14;
+var PACK_COL_MULT = 1 << PACK_COL_BITS;
+function packRowCol(row, col) {
+  return row * PACK_COL_MULT + col;
+}
+function unpackRowCol(packed) {
+  const row = Math.floor(packed / PACK_COL_MULT);
+  const col = packed - row * PACK_COL_MULT;
+  return { row, col };
+}
+function packRef(ref2) {
+  const rc = refToRowCol(ref2);
+  if (!rc) return -1;
+  return packRowCol(rc.row, rc.col);
+}
+function unpackRef(packed) {
+  const { row, col } = unpackRowCol(packed);
+  return rowColToRef(row, col);
+}
+function stripNsPrefix(tag) {
+  const colon = tag.indexOf(":");
+  return colon === -1 ? tag : tag.slice(colon + 1);
+}
+
 // ../xlsx/src/excel_pattern_fills.ts
 var PATTERNS = {
   darkVertical: (fg, bg) => `repeating-linear-gradient(90deg, ${fg} 0px, ${fg} 1px, ${bg} 1px, ${bg} 4px)`,
@@ -78010,6 +78099,10 @@ var BUILTIN_NUM_FMTS = {
 var xmlParser2 = new XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
+  // A producer may bind spreadsheetml to a prefix (`<x:styleSheet>`) rather than
+  // making it the default namespace; the prefix carries no meaning, so it is
+  // dropped before anything looks a tag up — see `stripNsPrefix`.
+  transformTagName: stripNsPrefix,
   processEntities: false,
   isArray: (tagName) => tagName === "numFmt" || tagName === "font" || tagName === "fill" || tagName === "border" || tagName === "xf" || tagName === "rgbColor" || tagName === "stop"
 });
@@ -78339,10 +78432,24 @@ function emptyStyleResolver() {
   };
 }
 
+// ../xlsx/src/malformed_part_error.ts
+var MalformedPartError = class extends Error {
+  constructor(reason) {
+    super(
+      `${reason} \u2014 the file is not a readable spreadsheet. If it opens in Excel, the reader is at fault: report the producer that wrote it.`
+    );
+    this.name = "MalformedPartError";
+  }
+};
+
 // ../xlsx/src/ooxml_workbook.ts
 var xmlParser3 = new XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
+  // A producer may bind spreadsheetml to a prefix (`<x:workbook>`) rather than
+  // making it the default namespace; the prefix carries no meaning, so it is
+  // dropped before anything looks a tag up — see `stripNsPrefix`.
+  transformTagName: stripNsPrefix,
   // Shared-string and workbook text is textual BY DEFINITION (tax IDs, phone
   // numbers, account codes, sheet/defined names). fast-xml-parser's default tag
   // coercion would parse `<t>0312345678</t>` as the number 312345678 — silently
@@ -78356,7 +78463,7 @@ var xmlParser3 = new XMLParser({
 function parseWorkbook(workbookXml) {
   const doc = xmlParser3.parse(workbookXml);
   const wb = doc?.["workbook"];
-  if (!wb) return { sheets: [], activeSheetIndex: 0, date1904: false, namedRanges: /* @__PURE__ */ new Map(), printTitlesBySheet: /* @__PURE__ */ new Map(), fullCalcOnLoad: false };
+  if (!wb) throw new MalformedPartError("xl/workbook.xml has no <workbook> root");
   const sheetsEl = wb["sheets"];
   const sheetArr = sheetsEl?.["sheet"];
   const sheets = (sheetArr ?? []).map((s) => ({
@@ -79414,55 +79521,6 @@ function buildCellContent(displayValue, sharedString, hyperlink) {
   return { type: "plain", text: displayValue };
 }
 
-// ../xlsx/src/excel_utils.ts
-function colLettersToNum(letters) {
-  let result = 0;
-  for (let i2 = 0; i2 < letters.length; i2++) {
-    result = result * 26 + (letters.charCodeAt(i2) - 64);
-  }
-  return result;
-}
-function colNumToLetters(col) {
-  let result = "";
-  let n = col;
-  while (n > 0) {
-    n--;
-    result = String.fromCharCode(65 + n % 26) + result;
-    n = Math.floor(n / 26);
-  }
-  return result;
-}
-function refToRowCol(ref2) {
-  const match2 = ref2.match(/^(\$?)([A-Z]+)(\$?)(\d+)$/);
-  if (!match2) return void 0;
-  return { col: colLettersToNum(match2[2]), row: parseInt(match2[4], 10) };
-}
-function rowColToRef(row, col) {
-  return colNumToLetters(col) + String(row);
-}
-function escapeXml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-var PACK_COL_BITS = 14;
-var PACK_COL_MULT = 1 << PACK_COL_BITS;
-function packRowCol(row, col) {
-  return row * PACK_COL_MULT + col;
-}
-function unpackRowCol(packed) {
-  const row = Math.floor(packed / PACK_COL_MULT);
-  const col = packed - row * PACK_COL_MULT;
-  return { row, col };
-}
-function packRef(ref2) {
-  const rc = refToRowCol(ref2);
-  if (!rc) return -1;
-  return packRowCol(rc.row, rc.col);
-}
-function unpackRef(packed) {
-  const { row, col } = unpackRowCol(packed);
-  return rowColToRef(row, col);
-}
-
 // ../xlsx/src/ooxml_sheet.ts
 var MAX_ROWS_PER_SHEET = 1e4;
 var MAX_IMAGES = 50;
@@ -79478,7 +79536,11 @@ var xmlParser4 = new XMLParser({
   ignoreAttributes: false,
   attributeNamePrefix: "@_",
   processEntities: false,
-  isArray: (tagName) => tagName === "row" || tagName === "c" || tagName === "col" || tagName === "mergeCell" || tagName === "conditionalFormatting" || tagName === "cfRule" || tagName === "cfvo" || tagName === "color" || tagName === "hyperlink" || tagName === "Relationship" || tagName === "sheetView" || tagName === "xdr:twoCellAnchor" || tagName === "xdr:oneCellAnchor" || tagName === "dataValidation" || tagName === "filterColumn" || tagName === "filter" || tagName === "brk" || tagName === "ext",
+  // A producer may bind spreadsheetml to a prefix (`<x:worksheet>`) instead of
+  // making it the default namespace. The prefix carries no meaning, so it is
+  // dropped before anything looks a tag up — see `stripNsPrefix`.
+  transformTagName: stripNsPrefix,
+  isArray: (tagName) => tagName === "row" || tagName === "c" || tagName === "col" || tagName === "mergeCell" || tagName === "conditionalFormatting" || tagName === "cfRule" || tagName === "cfvo" || tagName === "color" || tagName === "hyperlink" || tagName === "Relationship" || tagName === "sheetView" || tagName === "dataValidation" || tagName === "filterColumn" || tagName === "filter" || tagName === "brk" || tagName === "ext",
   // Preserve whitespace in cell values
   trimValues: false
 });
@@ -79497,7 +79559,7 @@ var drawingParser = new XMLParser({
 function parseSheet(sheetXml, sheetRelsXml, styles, sharedStrings, theme, indexedColors, zipEntries, date1904, maxRows = MAX_ROWS_PER_SHEET) {
   const doc = xmlParser4.parse(sheetXml);
   const worksheet = doc?.["worksheet"];
-  if (!worksheet) return emptySheet("Sheet");
+  if (!worksheet) throw new MalformedPartError("A worksheet part has no <worksheet> root");
   const rels = sheetRelsXml ? parseSheetRels(sheetRelsXml) : /* @__PURE__ */ new Map();
   const sheetFormatPr = worksheet["sheetFormatPr"];
   const defaultRowHeight = sheetFormatPr?.["@_defaultRowHeight"] ? parseFloat(sheetFormatPr["@_defaultRowHeight"]) : 15;
@@ -81747,9 +81809,7 @@ function parseExcelFromZip(zip, options) {
   const stylesEntry = findEntry(zip, "xl/styles.xml");
   const styles = stylesEntry ? parseStyles(decodeUtf8(stylesEntry), theme) : emptyStyleResolver();
   const wbEntry = findEntry(zip, "xl/workbook.xml");
-  if (!wbEntry) {
-    return { sheets: [emptySheet("Sheet1")], activeSheetIndex: 0 };
-  }
+  if (!wbEntry) throw new MalformedPartError("The package has no xl/workbook.xml");
   const workbookInfo = parseWorkbook(decodeUtf8(wbEntry));
   const wbRelsEntry = findEntry(zip, "xl/_rels/workbook.xml.rels");
   const wbRels = wbRelsEntry ? parseWorkbookRels(decodeUtf8(wbRelsEntry)) : /* @__PURE__ */ new Map();
@@ -81763,22 +81823,20 @@ function parseExcelFromZip(zip, options) {
   });
   const parseXmlDoc = (xml) => xmlParser5.parse(xml);
   const pivotCaches = /* @__PURE__ */ new Map();
-  if (wbEntry) {
-    const wbDoc = parseXmlDoc(decodeUtf8(wbEntry));
-    const wbCacheMap = extractWorkbookPivotCaches(wbDoc);
-    for (const [cacheId, rId] of wbCacheMap) {
-      const cacheTarget = wbRels.get(rId);
-      if (!cacheTarget) continue;
-      const cachePath = cacheTarget.startsWith("/") ? cacheTarget.slice(1) : `xl/${cacheTarget}`;
-      const cacheEntry = findEntry(zip, cachePath);
-      if (!cacheEntry) continue;
-      try {
-        pivotCaches.set(
-          cacheId,
-          parsePivotCacheDefinitionXml(decodeUtf8(cacheEntry), cacheId, parseXmlDoc)
-        );
-      } catch {
-      }
+  const wbDoc = parseXmlDoc(decodeUtf8(wbEntry));
+  const wbCacheMap = extractWorkbookPivotCaches(wbDoc);
+  for (const [cacheId, rId] of wbCacheMap) {
+    const cacheTarget = wbRels.get(rId);
+    if (!cacheTarget) continue;
+    const cachePath = cacheTarget.startsWith("/") ? cacheTarget.slice(1) : `xl/${cacheTarget}`;
+    const cacheEntry = findEntry(zip, cachePath);
+    if (!cacheEntry) continue;
+    try {
+      pivotCaches.set(
+        cacheId,
+        parsePivotCacheDefinitionXml(decodeUtf8(cacheEntry), cacheId, parseXmlDoc)
+      );
+    } catch {
     }
   }
   const sheets = [];
@@ -81902,6 +81960,11 @@ function parseExcelFromZip(zip, options) {
     }
     visibleIndex++;
   }
+  if (sheets.length === 0 && workbookInfo.sheets.length > 0) {
+    throw new MalformedPartError(
+      `xl/workbook.xml declares ${workbookInfo.sheets.length} sheet(s) and none of their parts could be resolved`
+    );
+  }
   if (sheets.length === 0) {
     return { sheets: [emptySheet("Sheet1")], activeSheetIndex: 0 };
   }
@@ -83136,6 +83199,8 @@ function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMa
     }
     arr.push({ col: rc.col, cell });
   }
+  for (const rowNum of sheet.rowHeights.keys()) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
+  for (const rowNum of sheet.hiddenRows) if (!rowMap.has(rowNum)) rowMap.set(rowNum, []);
   const sortedRows = Array.from(rowMap.keys()).sort((a, b) => a - b);
   for (const rowNum of sortedRows) {
     const cells = rowMap.get(rowNum);
@@ -83292,11 +83357,12 @@ function buildSheetXml(sheet, styles, ssIndex, isActive, xfMap, numFmtMap, dxfMa
     }
   }
   let dimensionRef = "A1";
-  if (sortedRows.length > 0) {
+  const cellRows = sortedRows.filter((rowNum) => rowMap.get(rowNum).length > 0);
+  if (cellRows.length > 0) {
     let minCol = Infinity, maxCol = 0;
-    const minRow = sortedRows[0];
-    const maxRow = sortedRows[sortedRows.length - 1];
-    for (const rowNum of sortedRows) {
+    const minRow = cellRows[0];
+    const maxRow = cellRows[cellRows.length - 1];
+    for (const rowNum of cellRows) {
       const cells = rowMap.get(rowNum);
       for (const { col } of cells) {
         if (col < minCol) minCol = col;
@@ -92892,6 +92958,9 @@ function adjustMergedCellsForColDelete(sheet, atCol, count) {
 
 // src/xlsx.ts
 var SIMPLE_CELL_KEYS = /* @__PURE__ */ new Set(["value", "formula", "numFmt", "style"]);
+var SIMPLE_SHEET_KEYS = /* @__PURE__ */ new Set(["name", "cells", "merges", "freeze", "colWidths", "rowHeights"]);
+var MAX_COLUMN = 16384;
+var MAX_ROW = 1048576;
 function loadFile(filePath) {
   if (!fs6.existsSync(filePath)) fail2(`File not found: ${filePath}`);
   const buffer = fs6.readFileSync(filePath);
@@ -92943,7 +93012,7 @@ function lazyEngine(workbook) {
     }
   };
 }
-function readToJson(filePath, filter3) {
+function readToJson(filePath, filter3, opts) {
   const buffer = fs6.readFileSync(filePath);
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const parsed = parseExcelBuffer(arrayBuffer);
@@ -92962,13 +93031,13 @@ function readToJson(filePath, filter3) {
       name: s.name,
       totalRowCount: s.totalRowCount,
       truncated: s.truncated,
-      cells: cellsFromParsedRows(s.rows, filter3?.range),
+      cells: cellsFromParsedRows(s.rows, filter3?.range, opts?.withFormat === true),
       merges: s.mergedCells.map((m) => `${rowColToRef(m.startRow, m.startCol)}:${rowColToRef(m.endRow, m.endCol)}`),
       freeze: s.freezePane ? { row: s.freezePane.frozenRows, col: s.freezePane.frozenCols } : void 0
     }))
   };
 }
-function cellsFromParsedRows(rows, range2) {
+function cellsFromParsedRows(rows, range2, withFormat = false) {
   const out = {};
   for (const row of rows) {
     if (range2 && (row.index < range2.startRow || row.index > range2.endRow)) continue;
@@ -92978,6 +93047,8 @@ function cellsFromParsedRows(rows, range2) {
       const value2 = cell.typedValue ?? cell.value;
       const entry = { value: value2 };
       if (cell.formula) entry.formula = cell.formula;
+      if (cell.numFmtCode && cell.numFmtCode !== "General") entry.numFmt = cell.numFmtCode;
+      if (withFormat && cell.style && Object.keys(cell.style).length > 0) entry.style = cell.style;
       out[ref2] = entry;
     }
   }
@@ -92998,6 +93069,10 @@ function buildWorkbookFromJson(input) {
 }
 function validateSimpleSheet(s, index) {
   if (!s || typeof s !== "object") fail2(`sheets[${index}] must be an object`);
+  const unknown2 = Object.keys(s).filter((k) => !SIMPLE_SHEET_KEYS.has(k));
+  if (unknown2.length > 0) {
+    fail2(`sheets[${index}] has unknown propert${unknown2.length > 1 ? "ies" : "y"}: ${unknown2.join(", ")}. Supported: ${[...SIMPLE_SHEET_KEYS].join(", ")}.`);
+  }
   if (typeof s.name !== "string" || s.name === "") fail2(`sheets[${index}].name must be a non-empty string`);
   if (s.cells !== void 0 && (typeof s.cells !== "object" || s.cells === null || Array.isArray(s.cells))) {
     fail2(`sheets[${index}].cells must be an object keyed by cell ref (e.g. {"A1": "value"})`);
@@ -93011,6 +93086,23 @@ function validateSimpleSheet(s, index) {
       fail2(`sheets[${index}].freeze.row and .col must be numbers`);
     }
   }
+  validateDimensionMap(s.colWidths, `sheets[${index}].colWidths`, "column letter within A..XFD", (k) => {
+    const coord = /^[A-Za-z]+$/.test(k) ? refToRowCol(`${k.toUpperCase()}1`) : void 0;
+    return coord !== void 0 && coord.col <= MAX_COLUMN;
+  });
+  validateDimensionMap(s.rowHeights, `sheets[${index}].rowHeights`, `row number within 1..${MAX_ROW}`, (k) => /^[0-9]+$/.test(k) && Number(k) >= 1 && Number(k) <= MAX_ROW);
+}
+function validateDimensionMap(map3, label, keyHint, keyOk) {
+  if (map3 === void 0) return;
+  if (typeof map3 !== "object" || map3 === null || Array.isArray(map3)) {
+    fail2(`${label} must be an object keyed by ${keyHint}`);
+  }
+  for (const [key, value2] of Object.entries(map3)) {
+    if (!keyOk(key)) fail2(`${label} key "${key}" must be a ${keyHint}`);
+    if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) {
+      fail2(`${label}["${key}"] must be a positive number`);
+    }
+  }
 }
 function applySheetCells(workbook, sheetIndex, def) {
   const sheet = workbook.sheets[sheetIndex];
@@ -93043,6 +93135,20 @@ function applySheetCells(workbook, sheetIndex, def) {
   if (def.freeze) {
     sheet.freeze = { row: def.freeze.row, col: def.freeze.col };
   }
+  if (def.colWidths) {
+    for (const [letter, width] of Object.entries(def.colWidths)) {
+      const coord = refToRowCol(`${letter.toUpperCase()}1`);
+      if (!coord) fail2(`Invalid column in sheet "${def.name}".colWidths: ${letter}`);
+      sheet.colWidths.set(coord.col, width);
+    }
+  }
+  if (def.rowHeights) {
+    for (const [rowKey, height] of Object.entries(def.rowHeights)) {
+      const row = Number(rowKey);
+      if (!Number.isInteger(row) || row < 1) fail2(`Invalid row in sheet "${def.name}".rowHeights: ${rowKey}`);
+      sheet.rowHeights.set(row, height);
+    }
+  }
 }
 function normalizeSimpleCell(raw, sheetName, ref2) {
   if (raw && typeof raw === "object" && !Array.isArray(raw)) {
@@ -93073,9 +93179,10 @@ function splitOptionalSheetRef(spec) {
   return { sheet: spec.slice(0, idx), ref: spec.slice(idx + 1) };
 }
 function xlsxRead(filePath, rest2) {
-  if (!filePath) fail2("Usage: lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>]");
+  if (!filePath) fail2("Usage: lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>] [--with-format]");
   const rangeArg = readOptionFlag(rest2, "--range");
   const sheetArg = readOptionFlag(rest2, "--sheet");
+  const withFormat = rest2.includes("--with-format");
   let filter3;
   if (rangeArg !== void 0) {
     const { sheet, ref: ref2 } = splitOptionalSheetRef(rangeArg);
@@ -93087,7 +93194,7 @@ function xlsxRead(filePath, rest2) {
   } else if (sheetArg !== void 0) {
     filter3 = { sheet: sheetArg };
   }
-  const data2 = readToJson(filePath, filter3);
+  const data2 = readToJson(filePath, filter3, { withFormat });
   console.log(JSON.stringify(data2, null, 2));
 }
 function xlsxWrite(filePath, json2) {
@@ -93324,14 +93431,17 @@ function printXlsxHelp() {
   console.error(`Lotics xlsx commands \u2014 manipulate .xlsx files in place.
 Uses Lotics' own xlsx engine; round-trips faithfully with the Lotics editor and templates.
 
-  lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>]
+  lotics xlsx read <file> [--sheet <name>] [--range <sheet>!<A1:G60>] [--with-format]
                                                    Dump file as JSON (sheets, cells, merges, freeze).
                                                    --sheet limits to one sheet; --range to a cell window
                                                    (its <sheet>! prefix is optional when --sheet is given)
+                                                   A cell carries numFmt when it has one; --with-format
+                                                   adds the resolved style (always present, hence a flag)
   lotics xlsx write <file> '<json>'                Create .xlsx from {"sheets":[{"name","cells":{"A1":...}}]}
                                                    A cell is a bare value, or {value|formula, numFmt, style}:
                                                    {"A1":{"value":1234,"numFmt":"#,##0 \\"\u20AB\\"","style":{"fontBold":true}}}
-                                                   Unknown cell properties are rejected, not ignored.
+                                                   A sheet also takes merges, freeze, colWidths ({"A":34}),
+                                                   rowHeights ({"1":44}). Unknown properties are rejected.
   lotics xlsx set-cell <file> <sheet>!<ref> '<v>'  Set cell value (prefix '=' for formula)
   lotics xlsx clear-range <file> <sheet>!<range>   Clear all cells in a range
   lotics xlsx merge <file> <sheet>!<range>         Merge a range into one cell
@@ -95325,7 +95435,7 @@ function parseLegacyDoc(bytes) {
 }
 
 // ../ooxml/src/document.ts
-var import_jszip = __toESM(require_lib4(), 1);
+var import_jszip2 = __toESM(require_lib4(), 1);
 
 // ../ooxml/node_modules/fast-xml-parser/src/util.js
 var nameStartChar2 = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
@@ -98004,6 +98114,14 @@ async function docModelToDocx(model) {
   return doc;
 }
 
+// ../ooxml/src/opc.ts
+var import_jszip = __toESM(require_lib4(), 1);
+function dropFolderEntries(zip) {
+  for (const [path8, entry] of Object.entries(zip.files)) {
+    if (entry.dir) delete zip.files[path8];
+  }
+}
+
 // ../ooxml/src/document.ts
 var DOCUMENT_ATTRS = {
   "@_xmlns:wpc": "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
@@ -98013,6 +98131,10 @@ var DOCUMENT_ATTRS = {
   "@_xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
   "@_xmlns:v": "urn:schemas-microsoft-com:vml",
   "@_xmlns:wp": "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
+  // Declared because mc:Ignorable below names it. Markup Compatibility (ECMA-376 Part 3) requires
+  // every prefix listed there to be a declared namespace prefix; an undeclared one made Word
+  // report unreadable content and offer to repair EVERY document this package wrote.
+  "@_xmlns:wp14": "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
   "@_xmlns:w10": "urn:schemas-microsoft-com:office:word",
   "@_xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
   "@_xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
@@ -98108,7 +98230,7 @@ async function loadDocxFromBuffer(buffer) {
   if (isLegacyDoc(buffer)) {
     return docxFromLegacyDoc(buffer);
   }
-  const zip = await import_jszip.default.loadAsync(buffer);
+  const zip = await import_jszip2.default.loadAsync(buffer);
   const docFile = zip.file("word/document.xml");
   if (!docFile) {
     throw new Error("Invalid .docx: missing word/document.xml");
@@ -98133,19 +98255,38 @@ async function loadDocxFromBuffer(buffer) {
   const bodyElements = getChildren(bodyEl);
   return { zip, bodyElements, documentAttrs };
 }
+function withTrailingParagraph(body) {
+  const sectPrAt = body.findIndex((e) => getTagName(e) === "w:sectPr");
+  const lastBlock = sectPrAt >= 0 ? sectPrAt - 1 : body.length - 1;
+  if (lastBlock < 0 || getTagName(body[lastBlock]) !== "w:tbl") return body;
+  const out = [...body];
+  out.splice(lastBlock + 1, 0, { "w:p": [] });
+  return out;
+}
+function pruneIgnorable(attrs) {
+  const listed = (attrs["@_mc:Ignorable"] ?? "").split(/\s+/).filter(Boolean);
+  if (listed.length === 0) return attrs;
+  const kept = listed.filter((prefix) => `@_xmlns:${prefix}` in attrs);
+  if (kept.length === listed.length) return attrs;
+  const next = { ...attrs };
+  if (kept.length === 0) delete next["@_mc:Ignorable"];
+  else next["@_mc:Ignorable"] = kept.join(" ");
+  return next;
+}
 async function saveDocxToBuffer(doc) {
-  const bodyChildren = [...doc.bodyElements];
+  const bodyChildren = withTrailingParagraph(doc.bodyElements);
   const documentEl = {
     "w:document": [{ "w:body": bodyChildren }],
-    ":@": { ...doc.documentAttrs }
+    ":@": pruneIgnorable(doc.documentAttrs)
   };
   const xml = buildXml([documentEl]);
   doc.zip.file("word/document.xml", xml);
+  dropFolderEntries(doc.zip);
   const buffer = await doc.zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
   return buffer;
 }
 function createBlankDocx(opts) {
-  const zip = new import_jszip.default();
+  const zip = new import_jszip2.default();
   zip.file("[Content_Types].xml", CONTENT_TYPES_XML);
   zip.file("_rels/.rels", RELS_XML);
   zip.file("word/_rels/document.xml.rels", DOCUMENT_RELS_XML);
@@ -98204,9 +98345,9 @@ async function ensureContentTypeOverride(doc, partName, contentType) {
 }
 
 // ../docx/src/parse/parser.ts
-var import_jszip2 = __toESM(require_lib4(), 1);
+var import_jszip3 = __toESM(require_lib4(), 1);
 async function parseDocx(buffer) {
-  const zip = await import_jszip2.default.loadAsync(buffer);
+  const zip = await import_jszip3.default.loadAsync(buffer);
   const parts = /* @__PURE__ */ new Map();
   const filePromises = [];
   zip.forEach((path8, file2) => {
@@ -98341,7 +98482,7 @@ function parseOpaqueRunChild(el) {
 }
 
 // ../docx/src/serialize/serializer.ts
-var import_jszip3 = __toESM(require_lib4(), 1);
+var import_jszip4 = __toESM(require_lib4(), 1);
 
 // ../docx/src/serialize/default_parts.ts
 var encoder = new TextEncoder();
@@ -98455,7 +98596,7 @@ function fillDefaultParts(parts) {
 
 // ../docx/src/serialize/serializer.ts
 async function serializeDocx(doc) {
-  const zip = new import_jszip3.default();
+  const zip = new import_jszip4.default();
   const parts = fillDefaultParts(new Map(doc.parts));
   for (const [path8, bytes] of parts) {
     if (path8 === "word/document.xml") continue;
@@ -98463,6 +98604,7 @@ async function serializeDocx(doc) {
   }
   const documentXml = serializeDocumentXml(doc);
   zip.file("word/document.xml", documentXml);
+  dropFolderEntries(zip);
   const out = await zip.generateAsync({
     type: "uint8array",
     compression: "DEFLATE"
@@ -100293,7 +100435,7 @@ Available workspaces:`);
     if (subcommand === "query") {
       const action = toolArgs;
       if (action === "set") {
-        if (restArgs.includes("--all")) {
+        if (flags.all) {
           await appQuerySet(client, { all: true });
           return;
         }