@lotics/app-sdk 0.107.0 → 0.109.0

package/dist/index.js

@@ -15261,6 +15261,198 @@ function isEmptyFieldValue(value) {
   return false;
 }
 
+// ../shared/src/schemas/files.ts
+var processedFileSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the processed file"),
+  filename: zod_default.string().describe("Original filename of the uploaded file"),
+  mime_type: zod_default.string().describe("MIME type of the file (e.g., 'image/png', 'application/pdf')"),
+  // Stable proxy URL (`/v1/files/<file_storage_key>`), resolved at serving time
+  // — never stored in the DB.
+  url: zod_default.string().optional().describe("Stable file serving URL, resolved at serving time"),
+  thumbnail_url: zod_default.string().optional().describe("Thumbnail URL for image files, resolved at serving time"),
+  preview_url: zod_default.string().optional().describe("Preview URL for legacy Excel files, resolved at serving time"),
+  provider: zod_default.string().describe("Storage provider name (e.g., 'aws', 'gcs')"),
+  file_storage_key: zod_default.string().describe("Storage key/path where the file is stored"),
+  workspace_id: zod_default.string().describe("ID of the workspace this file belongs to"),
+  size: zod_default.number().nullish().describe("Byte size of the stored object (null until backfilled)"),
+  created_at: zod_default.string().describe("Timestamp when file was uploaded"),
+  metadata: zod_default.unknown().describe("Additional metadata about the file"),
+  data: zod_default.unknown().describe("File-type-specific data (e.g., {width, height, orientation} for images)")
+});
+var fileUploadErrorSchema = zod_default.object({
+  filename: zod_default.string().describe("Original filename that failed to upload"),
+  error: zod_default.string().describe("Error message describing the failure reason")
+});
+var fileUploadResponseSchema = zod_default.object({
+  files: zod_default.array(processedFileSchema).describe("Successfully uploaded files"),
+  errors: zod_default.array(fileUploadErrorSchema).describe("Files that failed to upload with error details")
+});
+var fileFieldValueSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the file"),
+  /**
+   * Present on a STORED cell and on its way off responses.
+   *
+   * Optional here because this schema types both, and a response is the half
+   * that loses it — no client reads it, and one that required it would reject
+   * the first response without it. Nothing weakens at write time: a file cell
+   * is written from file IDS and `resolveFileFieldIds` mints this from the
+   * `files` row, so a caller never supplies it and a stored cell always has it.
+   * Code that derives a serving URL guards for it (`file_url_resolver.ts`).
+   */
+  file_storage_key: zod_default.string().optional().describe("Storage key for the file"),
+  filename: zod_default.string().describe("Original filename"),
+  mime_type: zod_default.string().describe("MIME type of the file"),
+  url: zod_default.string().optional().describe("Public URL for the file, resolved at serving time"),
+  thumbnail_url: zod_default.string().optional().describe("Thumbnail URL for image files, resolved at serving time"),
+  preview_url: zod_default.string().optional().describe("Preview URL for legacy Excel files, resolved at serving time"),
+  // Immutable file-object metadata, resolved at serving time from the `files`
+  // row (never stored on the denormalized cell) — like `url`. `size` may be
+  // absent for older files not yet backfilled.
+  size: zod_default.number().nullish().describe("Byte size, resolved at serving time from the file object (null/absent until backfilled)"),
+  created_at: zod_default.string().optional().describe("Upload timestamp, resolved at serving time from the file object"),
+  document_template_id: zod_default.string().optional().describe("The document template the file was generated from, resolved at serving time from the file object; absent on a file a person brought")
+});
+function storedFileIds(list2) {
+  if (!Array.isArray(list2)) return [];
+  return list2.flatMap((entry) => {
+    if (typeof entry === "string") return [entry];
+    const id = typeof entry === "object" && entry !== null ? Reflect.get(entry, "id") : void 0;
+    return typeof id === "string" ? [id] : [];
+  });
+}
+function cellFileIds(cell) {
+  if (!Array.isArray(cell)) return [];
+  return cell.flatMap((entry) => Array.isArray(entry) ? cellFileIds(entry) : storedFileIds([entry]));
+}
+var servedFileSchema = zod_default.object({
+  id: zod_default.string(),
+  filename: zod_default.string(),
+  mime_type: zod_default.string(),
+  url: zod_default.string().optional().describe("Serving URL, signed for 24 hours."),
+  thumbnail_url: zod_default.string().optional().describe("Signed thumbnail, for an image."),
+  preview_url: zod_default.string().optional(),
+  size: zod_default.number().nullish().describe("Bytes, where the object records it."),
+  created_at: zod_default.string().optional().describe("When the file was uploaded."),
+  document_template_id: zod_default.string().optional().describe("The document template the file was generated from.")
+});
+var SERVED_FILE_KEYS = servedFileSchema.keyof().options;
+var MAX_UPLOAD_FILE_SIZE = 2 * 1024 * 1024 * 1024;
+var PROFILE_IMAGE_MAX_SIZE = 10 * 1024 * 1024;
+var UPLOAD_TICKET_TTL_SECONDS = 5 * 60;
+var MAX_TICKET_UPLOAD_BYTES = 20 * 1024 * 1024;
+var uploadTicketRequestSchema = zod_default.object({
+  filename: zod_default.string().min(1),
+  mime_type: zod_default.string().optional(),
+  /** Declared up front so an oversize file is refused before its bytes move,
+   *  rather than after the transfer is already spent. Optional because a caller
+   *  streaming from a pipe may genuinely not know; the PUT enforces the cap
+   *  either way. */
+  size_bytes: zod_default.number().int().positive().optional()
+});
+var uploadTicketResponseSchema = zod_default.object({
+  upload_url: zod_default.string(),
+  ticket_id: zod_default.string(),
+  method: zod_default.literal("PUT"),
+  expires_at: zod_default.string(),
+  max_bytes: zod_default.number(),
+  required_headers: zod_default.record(zod_default.string(), zod_default.string())
+});
+var uploadTicketResultSchema = zod_default.object({
+  file_id: zod_default.string(),
+  file_name: zod_default.string(),
+  mime_type: zod_default.string(),
+  size_bytes: zod_default.number(),
+  sha256: zod_default.string(),
+  /** True when these bytes were already in the workspace and no second copy was
+   *  stored. Stated rather than left to inference, because the caller then gets
+   *  back a `file_name` it did not send — the stored file's, not the one it
+   *  uploaded under — and a silent difference reads as a bug. */
+  deduplicated: zod_default.boolean()
+});
+var fileSizeSchema = zod_default.number().int().positive().max(MAX_UPLOAD_FILE_SIZE);
+var directUploadInitRequestSchema = zod_default.object({
+  file_id: zod_default.string().optional(),
+  filename: zod_default.string(),
+  mime_type: zod_default.string(),
+  file_size: fileSizeSchema
+});
+var directUploadInitResponseSchema = zod_default.object({
+  file_id: zod_default.string(),
+  file_storage_key: zod_default.string(),
+  upload_url: zod_default.string()
+});
+var directUploadCompleteRequestSchema = zod_default.object({
+  file_id: zod_default.string(),
+  file_storage_key: zod_default.string(),
+  filename: zod_default.string(),
+  mime_type: zod_default.string(),
+  original_file_id: zod_default.string().optional().describe(
+    "When set, this upload becomes a new version of the original file. The server resolves the current latest, links the new row via source_file_id, and bumps the original's latest_version_id pointer."
+  )
+});
+var multipartInitRequestSchema = zod_default.object({
+  file_id: zod_default.string().optional(),
+  filename: zod_default.string(),
+  mime_type: zod_default.string(),
+  file_size: fileSizeSchema,
+  network_effective_type: zod_default.enum(["slow-2g", "2g", "3g", "4g"]).optional(),
+  network_rtt_ms: zod_default.number().nonnegative().optional()
+});
+var multipartInitResponseSchema = zod_default.object({
+  file_id: zod_default.string(),
+  upload_id: zod_default.string(),
+  file_storage_key: zod_default.string(),
+  part_size: zod_default.number(),
+  parts: zod_default.array(
+    zod_default.object({
+      part_number: zod_default.number(),
+      url: zod_default.string()
+    })
+  )
+});
+var multipartCompleteRequestSchema = zod_default.object({
+  file_id: zod_default.string(),
+  upload_id: zod_default.string(),
+  file_storage_key: zod_default.string(),
+  filename: zod_default.string(),
+  mime_type: zod_default.string(),
+  parts: zod_default.array(
+    zod_default.object({
+      part_number: zod_default.number(),
+      etag: zod_default.string()
+    })
+  ),
+  original_file_id: zod_default.string().optional().describe(
+    "When set, this upload becomes a new version of the original file. The server resolves the current latest, links the new row via source_file_id, and bumps the original's latest_version_id pointer."
+  )
+});
+var multipartAbortRequestSchema = zod_default.object({
+  upload_id: zod_default.string(),
+  file_storage_key: zod_default.string()
+});
+var fileVersionEntrySchema = zod_default.object({
+  id: zod_default.string(),
+  filename: zod_default.string(),
+  /**
+   * Resolved by the server, because deriving it needs the storage key and a
+   * caller that derives is a caller that must be handed one. Every other file
+   * shape already resolves its URL at serving time; this one did not, which is
+   * the whole reason the key still travels here.
+   */
+  url: zod_default.string(),
+  /** @deprecated Unread by any client — resolve bytes through `url` or `id`. */
+  file_storage_key: zod_default.string(),
+  mime_type: zod_default.string(),
+  created_at: zod_default.string(),
+  is_current: zod_default.boolean(),
+  source_file_id: zod_default.string().nullable()
+});
+var fileVersionListResponseSchema = zod_default.object({
+  original_file_id: zod_default.string(),
+  current_version_id: zod_default.string(),
+  versions: zod_default.array(fileVersionEntrySchema).describe("Ordered newest \u2192 oldest. Index 0 is the current version.")
+});
+
 // ../../node_modules/date-fns/constants.js
 var daysInYear = 365.2425;
 var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
@@ -15812,7 +16004,7 @@ function aggregateByField(records, fieldType, option, subject) {
         operation
       );
     case "files":
-      return aggregateGenericField(values2, operation);
+      return aggregateGenericField(values2.map((value) => Array.isArray(value) ? storedFileIds(value) : value), operation);
     case "rollup":
       return aggregateRollupField(
         values2,
@@ -27401,9 +27593,6 @@ function lookupElementToString(element) {
     if (element.length > 0 && typeof element[0] === "object" && element[0] !== null && "display" in element[0]) {
       return element.map((item) => item.display).filter(Boolean).join(", ");
     }
-    if (element.length > 0 && typeof element[0] === "object" && element[0] !== null && "filename" in element[0]) {
-      return element.map((file2) => file2.filename).filter(Boolean).join(", ");
-    }
     return element.filter(Boolean).join(", ");
   }
   return String(element);
@@ -27453,6 +27642,10 @@ function getFieldDisplayValue(field, value) {
     case "lookup": {
       if (typeof value === "string") return value;
       if (!Array.isArray(value)) return String(value);
+      if (field.lookup_field_type === "files") {
+        const count = cellFileIds(value).length;
+        return count === 0 ? "" : `${count} file(s)`;
+      }
       return value.map(lookupElementToString).filter(Boolean).join(", ");
     }
     case "autonumber":
@@ -29015,7 +29208,16 @@ function filterTraversalPaths(filter2) {
   visit(filter2);
   return paths;
 }
-function filterRecords(records, fields, filters, memberContext, traversalContext) {
+var FileNamesUnavailableError = class extends Error {
+  constructor(fieldKey, operator) {
+    super(
+      `Filter on "${fieldKey}": '${operator}' reads a file's name or type, and the cell names its files by id \u2014 the files' rows must be supplied to evaluate it.`
+    );
+    this.name = "FileNamesUnavailableError";
+  }
+};
+var FILE_NAME_OPERATORS = /* @__PURE__ */ new Set(["has_filename", "has_mime_type"]);
+function filterRecords(records, fields, filters, memberContext, traversalContext, fileFacts) {
   if (!filters) {
     return records;
   }
@@ -29027,23 +29229,23 @@ function filterRecords(records, fields, filters, memberContext, traversalContext
     fieldByKey[field.key] = field;
   });
   return records.filter(
-    (record2) => filterRecord(record2, fieldByKey, filters, memberContext, traversalContext)
+    (record2) => filterRecord(record2, fieldByKey, filters, memberContext, traversalContext, fileFacts)
   );
 }
-function filterRecord(record2, fields, filters, memberContext, traversalContext) {
+function filterRecord(record2, fields, filters, memberContext, traversalContext, fileFacts) {
   if (!filters) {
     return true;
   }
   if (filters.node_type !== "group") {
-    const result = evaluateFilterNode(record2, fields, filters, memberContext, traversalContext);
+    const result = evaluateFilterNode(record2, fields, filters, memberContext, traversalContext, fileFacts);
     return result ?? true;
   }
   if (!filters.children || filters.children.length === 0) {
     return true;
   }
-  return evaluateFilterNode(record2, fields, filters, memberContext, traversalContext);
+  return evaluateFilterNode(record2, fields, filters, memberContext, traversalContext, fileFacts);
 }
-function evaluateFilterNode(record2, fields, node, memberContext, traversalContext) {
+function evaluateFilterNode(record2, fields, node, memberContext, traversalContext, fileFacts) {
   if (node.node_type === "group") {
     const evaluatedResults = [];
     for (const child of node.children) {
@@ -29052,7 +29254,8 @@ function evaluateFilterNode(record2, fields, node, memberContext, traversalConte
         fields,
         child,
         memberContext,
-        traversalContext
+        traversalContext,
+        fileFacts
       );
       if (childResult !== null) {
         evaluatedResults.push(childResult);
@@ -29063,14 +29266,14 @@ function evaluateFilterNode(record2, fields, node, memberContext, traversalConte
     }
     return node.logic === "and" ? evaluatedResults.every((result) => result) : evaluatedResults.some((result) => result);
   } else if (node.node_type === "traversal") {
-    const result = evaluateTraversal(record2, fields, node, memberContext, traversalContext);
+    const result = evaluateTraversal(record2, fields, node, memberContext, traversalContext, fileFacts);
     return result ?? true;
   } else {
-    const result = evaluateCondition(record2, fields, node, memberContext);
+    const result = evaluateCondition(record2, fields, node, memberContext, fileFacts);
     return result ?? true;
   }
 }
-function evaluateTraversal(record2, fields, node, memberContext, traversalContext) {
+function evaluateTraversal(record2, fields, node, memberContext, traversalContext, fileFacts) {
   if (node.condition.type !== "locked" && node.condition.type !== "current_member" && (typeof node.condition.field_key !== "string" || !node.condition.field_key)) {
     return null;
   }
@@ -29098,12 +29301,12 @@ function evaluateTraversal(record2, fields, node, memberContext, traversalContex
     if (currentRecords.length === 0) return true;
     const positiveCondition = { ...inner, operator: positiveOp };
     return !currentRecords.some(
-      (r) => evaluateCondition(r, currentFields, positiveCondition, memberContext) === true
+      (r) => evaluateCondition(r, currentFields, positiveCondition, memberContext, fileFacts) === true
     );
   }
   if (currentRecords.length === 0) return false;
   return currentRecords.some(
-    (r) => evaluateCondition(r, currentFields, inner, memberContext) === true
+    (r) => evaluateCondition(r, currentFields, inner, memberContext, fileFacts) === true
   );
 }
 function requireMemberContext(memberContext, operator) {
@@ -29114,7 +29317,7 @@ function requireMemberContext(memberContext, operator) {
   }
   return memberContext;
 }
-function evaluateCondition(record2, fieldByKey, looseCondition, memberContext) {
+function evaluateCondition(record2, fieldByKey, looseCondition, memberContext, fileFacts) {
   if (looseCondition.type === "locked") {
     const locked = record2.locked;
     if (locked === void 0) return null;
@@ -29153,26 +29356,26 @@ function evaluateCondition(record2, fieldByKey, looseCondition, memberContext) {
       const factor = rowUnitFactor(reading.unit, data);
       if (factor === void 0) return false;
       const inBase = { ...filterCondition, value: filterCondition.value * reading.unit.factor };
-      return matchCell(columnValue, field, inBase, looseCondition, memberContext, factor);
+      return matchCell(columnValue, field, inBase, looseCondition, memberContext, fileFacts, factor);
     }
   }
   if (field?.type === "lookup" && (Array.isArray(columnValue) || columnValue == null)) {
     const values2 = Array.isArray(columnValue) ? columnValue : [];
-    return matchLookup(values2, field, filterCondition, looseCondition, memberContext);
+    return matchLookup(values2, field, filterCondition, looseCondition, memberContext, fileFacts);
   }
-  return matchCell(columnValue, field, filterCondition, looseCondition, memberContext);
+  return matchCell(columnValue, field, filterCondition, looseCondition, memberContext, fileFacts);
 }
 function flattenLookupValues(values2) {
   return values2.flatMap((value) => Array.isArray(value) ? flattenLookupValues(value) : [value]);
 }
-function matchLookup(cell, field, filterCondition, looseCondition, memberContext) {
+function matchLookup(cell, field, filterCondition, looseCondition, memberContext, fileFacts) {
   switch (filterCondition.type) {
     case "select":
     case "select_member":
     case "select_record_link":
     case "files": {
       const union2 = cell.flatMap((list2) => Array.isArray(list2) ? list2 : []);
-      return matchCell(union2, field, filterCondition, looseCondition, memberContext);
+      return matchCell(union2, field, filterCondition, looseCondition, memberContext, fileFacts);
     }
     case "text":
     case "number":
@@ -29192,7 +29395,7 @@ function matchLookup(cell, field, filterCondition, looseCondition, memberContext
   let anyMatched = false;
   for (const value of values2) {
     const element = filterCondition.type === "text" && typeof value !== "string" && value !== null && value !== void 0 ? String(value) : value;
-    const result = matchCell(element, field, positive, looseCondition, memberContext);
+    const result = matchCell(element, field, positive, looseCondition, memberContext, fileFacts);
     if (result !== null) allSkipped = false;
     if (result === true) {
       anyMatched = true;
@@ -29202,7 +29405,16 @@ function matchLookup(cell, field, filterCondition, looseCondition, memberContext
   if (values2.length > 0 && allSkipped) return null;
   return positiveOperator ? !anyMatched : anyMatched;
 }
-function matchCell(cell, field, filterCondition, looseCondition, memberContext, figureFactor = 1) {
+function fileProperty(entry, property, fileFacts, fieldKey, operator) {
+  if (fileFacts) {
+    const [id] = storedFileIds([entry]);
+    return id === void 0 ? "" : fileFacts.get(id)?.[property] ?? "";
+  }
+  if (typeof entry === "string") throw new FileNamesUnavailableError(fieldKey, operator);
+  const own = typeof entry === "object" && entry !== null ? Reflect.get(entry, property) : void 0;
+  return typeof own === "string" ? own : "";
+}
+function matchCell(cell, field, filterCondition, looseCondition, memberContext, fileFacts, figureFactor = 1) {
   let columnValue = cell;
   const resolvedType = filterCondition.type;
   const fieldKey = filterCondition.field_key;
@@ -29574,7 +29786,7 @@ function matchCell(cell, field, filterCondition, looseCondition, memberContext,
       if (typeof filterCondition.value !== "string") return null;
       const term = filterCondition.value.trim().toLowerCase();
       if (!term) return null;
-      matches = files !== null && files.some((file2) => String(file2?.[property] ?? "").toLowerCase().includes(term));
+      matches = files !== null && files.some((entry) => fileProperty(entry, property, fileFacts, fieldKey, filterCondition.operator).toLowerCase().includes(term));
     }
   } else {
     const op = typeof looseCondition.operator === "string" ? looseCondition.operator : "(unset)";
@@ -29593,6 +29805,7 @@ function condition(node, subject) {
   if (node.field_key === void 0 || node.unit_option !== void 0) return "unknown";
   if (typeof node.value === "string" && node.value.includes("{{")) return "unknown";
   if (BY_VIEWER.has(node.operator) && subject.member_id === null) return "unknown";
+  if (FILE_NAME_OPERATORS.has(node.operator)) return "unknown";
   const field = subject.field(node.field_key);
   const held2 = subject.cell(node.field_key);
   if (field === void 0 || held2 === void 0) return "unknown";
@@ -29845,7 +30058,7 @@ function prepareFormulaContext(fields) {
     nonFormulaFields
   };
 }
-function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecords = /* @__PURE__ */ new Map(), linkedTableFields = /* @__PURE__ */ new Map(), timezone, loadedLinkKeys, linkExpandedTableIds) {
+function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecords = /* @__PURE__ */ new Map(), linkedTableFields = /* @__PURE__ */ new Map(), timezone, loadedLinkKeys, linkExpandedTableIds, fileFacts) {
   const result = { ...row2 };
   const mayRecompute = (linkKey) => loadedLinkKeys === void 0 || loadedLinkKeys.has(linkKey) || isEmptyFieldValue(row2[linkKey]);
   for (const { field, sourceField } of context.rollupFields) {
@@ -29890,7 +30103,8 @@ function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecor
           definition: `Rollup "${field.name}" (${field.key})`,
           source: `"${linkedFieldType.name}" (${linkedFieldType.key})`
         } : void 0,
-        traversal.context
+        traversal.context,
+        fileFacts
       );
       result[field.key] = rollupValue;
     } else {
@@ -30213,13 +30427,13 @@ function planFilterTraversal(filter2, aggregatedTableId, aggregatedFields, linke
     }
   };
 }
-function calculateRollupValue(value, fieldType, allLinkedTableRecords, aggregateOption, filter2, linkedTableFields, subject, traversalContext) {
+function calculateRollupValue(value, fieldType, allLinkedTableRecords, aggregateOption, filter2, linkedTableFields, subject, traversalContext, fileFacts) {
   if (aggregateOption?.operation === "count") {
     if (!value) return 0;
     const recordIds2 = extractRecordLinkIds(value);
     let relevantRecords2 = allLinkedTableRecords.filter((r) => recordIds2.includes(r.id));
     if (filter2 && linkedTableFields) {
-      relevantRecords2 = filterRecords(relevantRecords2, linkedTableFields, filter2, null, traversalContext);
+      relevantRecords2 = filterRecords(relevantRecords2, linkedTableFields, filter2, null, traversalContext, fileFacts);
     }
     return relevantRecords2.length;
   }
@@ -30232,7 +30446,7 @@ function calculateRollupValue(value, fieldType, allLinkedTableRecords, aggregate
     return null;
   }
   if (filter2 && linkedTableFields) {
-    relevantRecords = filterRecords(relevantRecords, linkedTableFields, filter2, null, traversalContext);
+    relevantRecords = filterRecords(relevantRecords, linkedTableFields, filter2, null, traversalContext, fileFacts);
   }
   if (relevantRecords.length === 0) {
     return null;

package/dist/shared_types.d.ts

@@ -4,7 +4,7 @@
  * tarball. Written at every build, never edited.
  */
 export type QueryAggregate = { by?: readonly string[]; day?: string; sum?: string; };
-export type ReportColumn = { key: string; header: string; type: "number" | "text" | "date"; };
+export type ReportColumn = { key: string; header: string; type: "number" | "text" | "date"; labels?: { readonly [x: string]: string; }; };
 export type ReportLanguage = "vi" | "en";
 export type ReportPart = { label: string; value: number; share: number | null; };
 export type ReportPivotColumn = { label: string; total: number | null; };

package/docs/members_and_options.md

@@ -321,15 +321,14 @@ updateComment, deleteComment, refetch }`.
 - `comments` — newest first on the wire (server order); a thread usually reads oldest-first, so
   reverse it for display. Each `AppComment`: `{ id, record_id,
   table_id, member_id, author, content, files, workspace_id, created_at, updated_at }`. Attachments
-  (`AppCommentFile`) carry `id` / `filename` / `mime_type` — a file's identity is its `id`, and
-  the server re-reads every attachment from storage by that id, so nothing else you hold about a
-  file can affect what is stored. The `url` / `thumbnail_url` / `preview_url` fields exist on the type
-  but the server does not populate them today — render attachments by name and type (what
-  `Timeline`'s default file row does), never by counting on a fetchable URL.
+  (`AppCommentFile`) carry `id` / `filename` / `mime_type` and a presigned `url` (plus
+  `thumbnail_url` for an image), valid 24 hours and refreshed by every read. A file's identity is
+  its `id`: the server reads every attachment from the file by that id, so nothing else you hold
+  about a file can affect what is stored.
 - `createComment({ content, file_ids? })` — posts as the viewing member. `file_ids` come from
   `useFileUpload` / `useAttachments` (see [files](./files.md)). A comment must have content or at
-  least one file (empty input is a client no-op; the server enforces the same rule). Content max
-  10,000 characters.
+  least one file (empty input is a client no-op; the server enforces the same rule). A file id
+  that names no live file in this workspace refuses the comment. Content max 10,000 characters.
 - `updateComment(id, { content, files? })` — omit `files` to keep the current attachment set (a
   text-only edit never drops attachments); pass `files` to replace the whole set.
 - All three mutations apply **optimistically** with rollback on error, then repopulate from the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.107.0",
+  "version": "0.109.0",
   "description": "The SDK a Lotics custom-code app reads and writes through \u2014 typed hooks over the host bridge, cell readers, mount() and AppRouter",
   "type": "module",
   "exports": {