@lotics/cli 0.278.0 → 0.279.1

package/dist/src/cli.js

@@ -36089,6 +36089,12 @@ function appDrawnFields(given, app) {
     ...app.register.roster?.of === void 0 ? [] : [app.register.roster.of],
     ...app.register.gantt === void 0 ? [] : ganttFields(app.register.gantt),
     ...app.register.readings.flatMap(readingFields),
+    // A tab narrows, bounds and orders the rows by columns the read returns.
+    ...app.register.tabs.flatMap((tab) => [
+      ...tab.term === void 0 ? [] : tab.term.kind === "in" ? [tab.term.field] : [tab.term.from, tab.term.to],
+      ...tab.where.map((one) => one.field),
+      ...(tab.sort ?? []).map((key) => key.field)
+    ]),
     ...app.record.sections.flatMap((section) => [...section.fields, ...section.when.map((gate) => gate.field)]),
     ...resolvedBlocks(app.record).flatMap((block) => [
       ...block.kind === "files" ? block.fields : block.kind === "text" ? [block.field] : [],
@@ -36482,6 +36488,50 @@ function evaluateFormulaWithJS(preparedExpression, data, timezone, everyReferenc
   }
 }
 
+// ../shared/src/field_value.ts
+function fieldValueInfo(field) {
+  switch (field.type) {
+    case "number":
+      return { type: "number", format: field.format, currency: field.currency ?? void 0, unit: field.unit ?? void 0 };
+    case "text":
+      return { type: "text", format: field.format };
+    case "date":
+      return { type: "date", format: field.format };
+    case "select":
+      return { type: "select", options: field.options };
+    case "formula": {
+      const output = field.formula?.output_type;
+      if (field.formula.options !== void 0) return { type: "select", options: field.formula.options };
+      if (output === "date" || output === "datetime") {
+        return { type: "date", format: output === "datetime" ? "datetime" : "date" };
+      }
+      if (output === "boolean") return { type: "boolean" };
+      if (output === "text") return { type: "text", format: field.formula?.format };
+      return { type: "number", format: field.formula?.format, currency: field.formula?.currency, unit: field.formula?.unit };
+    }
+    case "rollup":
+      return {
+        type: rollupOutputType(field.aggregate_option.operation),
+        format: field.aggregate_field_format,
+        currency: field.aggregate_field_currency,
+        unit: field.aggregate_field_unit
+      };
+    case "lookup":
+      return {
+        type: field.lookup_field_type ?? "text",
+        format: field.lookup_field_format,
+        currency: field.lookup_field_currency,
+        unit: field.lookup_field_unit,
+        options: field.lookup_field_options
+      };
+    // The cell stores the composed DISPLAY string ("KH-001"), never the counter.
+    case "autonumber":
+      return { type: "text" };
+    default:
+      return { type: field.type };
+  }
+}
+
 // ../shared/src/schemas/contract_filter_binding.ts
 function remapContractFilterGroup(group, entity, resolve) {
   return { ...group, children: group.children.map((child) => remapContractFilter(child, entity, resolve)) };
@@ -36545,7 +36595,33 @@ function tableId(t) {
 }
 function syntheticFields(entities) {
   const binding = bindAliases(entities);
-  return entities.map((entity) => entity.fields.map((field) => syntheticField(entity, field, binding)));
+  return withLookedUpValues(entities.map((entity) => entity.fields.map((field) => syntheticField(entity, field, binding))));
+}
+function withLookedUpValues(tables) {
+  let current = tables;
+  for (let pass = 0; pass < SURFACE_HOPS; pass++) {
+    const byKey = new Map(current.flat().map((field) => [field.key, field]));
+    let changed = false;
+    current = current.map(
+      (fields) => fields.map((field) => {
+        if (field.type !== "lookup" || field.lookup_field_type !== void 0) return field;
+        const target = byKey.get(field.lookup_field_key);
+        if (target === void 0 || target.type === "lookup" && target.lookup_field_type === void 0) return field;
+        changed = true;
+        const info = fieldValueInfo(target);
+        return {
+          ...field,
+          lookup_field_type: info.type,
+          ...info.format !== void 0 && { lookup_field_format: info.format },
+          ...info.currency !== void 0 && { lookup_field_currency: info.currency },
+          ...info.unit !== void 0 && { lookup_field_unit: info.unit },
+          ...info.options !== void 0 && { lookup_field_options: info.options }
+        };
+      })
+    );
+    if (!changed) return current;
+  }
+  return current;
 }
 function syntheticFormula(entities, entity, expression) {
   const binding = bindAliases(entities);
@@ -36698,21 +36774,12 @@ function syntheticField(entity, field, binding) {
     }
     case "lookup": {
       const target = requireTarget(binding, entity, field.source_field_alias, at2);
-      const surfaced = requireDeclared(binding, target.alias, field.lookup_field_alias, at2);
-      const resolved = resolvedFieldType(surfaced, target, binding.entities);
-      const carried = resolvedFormatOf(surfaced, target, binding.entities);
+      requireDeclared(binding, target.alias, field.lookup_field_alias, at2);
       return {
         ...base,
         type: "lookup",
         source_field_key: requireField(binding, entity.alias, field.source_field_alias, at2),
         lookup_field_key: requireField(binding, target.alias, field.lookup_field_alias, at2),
-        ...resolved !== void 0 && { lookup_field_type: resolved },
-        ...carried.format !== void 0 && { lookup_field_format: carried.format },
-        ...carried.currency !== void 0 && { lookup_field_currency: carried.currency },
-        ...carried.unit !== void 0 && { lookup_field_unit: carried.unit },
-        ...resolved === "select" && {
-          lookup_field_options: surfacedOptions(binding, carried, at2)
-        },
         ...field.order_by !== void 0 && {
           order_by: {
             field_key: requireField(binding, target.alias, field.order_by.field_key, `${at2}.order_by`),
@@ -36731,13 +36798,6 @@ function mintedOptions(binding, entity, field, options, at2) {
     ...option.mark === void 0 ? {} : { mark: option.mark }
   }));
 }
-function surfacedOptions(binding, carried, at2) {
-  const owner = carried.options;
-  if (owner === void 0) {
-    fail2(`${at2} surfaces a select, but this model states no options for the column it reaches`);
-  }
-  return mintedOptions(binding, owner.entity, owner.field, owner.options, at2);
-}
 var SURFACE_HOPS = 8;
 function resolvedFormatOf(field, entity, entities, hops = 0) {
   if (hops >= SURFACE_HOPS) return {};
@@ -36747,10 +36807,7 @@ function resolvedFormatOf(field, entity, entities, hops = 0) {
     case "text":
     case "date":
       return { format: field.format };
-    case "select":
-      return { options: { entity: entity.alias, field: field.alias, options: field.options } };
     case "formula":
-      if (field.formula.options !== void 0) return { options: { entity: entity.alias, field: field.alias, options: field.formula.options } };
       return {
         format: field.formula.output_type === "datetime" ? "datetime" : field.formula.format,
         currency: field.formula.currency,
@@ -37273,18 +37330,17 @@ function assignee(model, entity) {
   return [...display?.subtitle ?? [], ...started].find((name) => fieldOf(entity, name)?.type === "select_member");
 }
 
-// ../shared/src/schemas/app_model_books.ts
-function fieldColumnType(field, entity, entities) {
+// ../shared/src/app_query_output_schema.ts
+function fieldTypeToColumnType(field) {
   switch (field.type) {
     case "text":
-    case "autonumber":
       return "text";
     case "number":
       return "number";
     case "boolean":
       return "boolean";
     case "date":
-      return datetime3(field.format) ? "datetime" : "date";
+      return field.format === "datetime" || field.format === "datetime_range" ? "datetime" : "date";
     case "select":
       return "select";
     case "select_member":
@@ -37293,32 +37349,83 @@ function fieldColumnType(field, entity, entities) {
       return "select_record_link";
     case "files":
       return "files";
-    case "formula": {
-      if (field.formula.options !== void 0) return "select";
-      const stated = field.formula.output_type;
-      if (stated !== void 0) return stated;
-      return field.formula.format === void 0 ? "json" : field.formula.format === "link" ? "text" : "number";
-    }
-    case "rollup": {
-      if (resolvedFieldType(field, entity, entities) === "number") return "number";
-      const target = linkedOf(entity, entities, field.source_field_alias);
-      const aggregated = target?.fields.find((one) => one.alias === field.aggregate_option.field_key);
-      return aggregated?.type === "date" && datetime3(aggregated.format) ? "datetime" : "date";
-    }
-    case "lookup": {
-      const target = linkedOf(entity, entities, field.source_field_alias);
-      const shown = target?.fields.find((one) => one.alias === field.lookup_field_alias);
-      if (shown === void 0 || target === void 0 || shown.type === "formula" || shown.type === "rollup" || shown.type === "lookup" || shown.type === "autonumber") return "json";
-      return fieldColumnType(shown, target, entities);
+    case "rollup":
+      return rollupColumnType(field);
+    case "lookup":
+      return lookupOutputType(field);
+    case "formula":
+      return formulaOutputType(field);
+    case "button":
+      return "json";
+    case "autonumber":
+      return "text";
+    default: {
+      const _exhaustive = field;
+      void _exhaustive;
+      return "json";
     }
   }
 }
-function datetime3(format2) {
-  return format2 === "datetime" || format2 === "datetime_range";
+function formulaOutputType(field) {
+  switch (field.formula.output_type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "datetime":
+      return "datetime";
+    case "text":
+      return "text";
+    case "select":
+      return "select";
+    default:
+      return "json";
+  }
+}
+function rollupColumnType(field) {
+  if (rollupOutputType(field.aggregate_option.operation) === "number") return "number";
+  return field.aggregate_field_format === "datetime" || field.aggregate_field_format === "datetime_range" ? "datetime" : "date";
+}
+function lookupOutputType(field) {
+  const t = field.lookup_field_type;
+  if (!t) return "json";
+  switch (t) {
+    case "text":
+      return "text";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return field.lookup_field_format === "datetime" || field.lookup_field_format === "datetime_range" ? "datetime" : "date";
+    case "select":
+      return "select";
+    case "select_member":
+      return "select_member";
+    case "select_record_link":
+      return "select_record_link";
+    case "files":
+      return "files";
+    default:
+      return "json";
+  }
 }
-function linkedOf(entity, entities, link) {
-  const field = entity.fields.find((one) => one.alias === link);
-  return field?.type === "select_record_link" ? entities.find((one) => one.alias === field.target_entity) : void 0;
+
+// ../shared/src/schemas/app_model_books.ts
+function fieldColumnType(field, entity, entities) {
+  const index = entities.findIndex((one) => one.alias === entity.alias);
+  const synthesized = synthesizedOf(entities)[index]?.[entity.fields.findIndex((one) => one.alias === field.alias)];
+  return synthesized === void 0 ? fail2(`fieldColumnType: "${entity.alias}.${field.alias}" is not a field of the model.`) : fieldTypeToColumnType(synthesized);
+}
+var SYNTHESIZED = /* @__PURE__ */ new WeakMap();
+function synthesizedOf(entities) {
+  const held = SYNTHESIZED.get(entities);
+  if (held !== void 0) return held;
+  const minted = syntheticFields(entities);
+  SYNTHESIZED.set(entities, minted);
+  return minted;
 }
 function holdsSeveral(field) {
   return fieldHoldsSeveral(field) || field.type === "select_member" && field.multi === true;
@@ -40125,8 +40232,8 @@ function resultSideEffects(result) {
 }
 
 // src/version.ts
-var VERSION = "0.278.0";
-var APP_SDK_VERSION = "0.106.1";
+var VERSION = "0.279.1";
+var APP_SDK_VERSION = "0.107.0";
 
 // src/timezone.ts
 function machineTimezone() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/cli",
-  "version": "0.278.0",
+  "version": "0.279.1",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {