@bluecopa/core 0.1.68 → 0.1.70

package/dist/index.es.js

@@ -1,12 +1,12 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import axios from "axios";
+import axios, { isAxiosError } from "axios";
 import _ from "lodash";
+import { combineLatest, Subject, map as map$1 } from "rxjs";
 import { createRxDatabase } from "rxdb";
 import { getRxStorageDexie } from "rxdb/plugins/storage-dexie";
 import { replicateRxCollection } from "rxdb/plugins/replication";
-import { Subject } from "rxjs";
 class ConfigSingleton {
   constructor() {
     this.config = {
@@ -707,10 +707,7 @@ const findParentIsMetricSeries = (childId, variables) => {
     return true;
   } else if (parentTableVariable == null ? void 0 : parentTableVariable.transforms[0]) {
     const transform = parentTableVariable.transforms[0];
-    return findParentIsMetricSeries(
-      transform.table,
-      variables
-    );
+    return findParentIsMetricSeries(transform.table, variables);
   }
   return false;
 };
@@ -739,9 +736,7 @@ const getDrilldownFiltersMap = (props) => {
         if (ftba.operator) {
           let uniqueValuesForNegationOperator, uniqueValuesForOperator;
           if (ftba.operator.includes("not")) {
-            uniqueValuesForNegationOperator = getValuesForSpecialOperators(
-              ftba.operator
-            );
+            uniqueValuesForNegationOperator = getValuesForSpecialOperators(ftba.operator);
             uniqueValuesForOperator = [
               {
                 label: col == null ? void 0 : col.label,
@@ -828,9 +823,7 @@ const getDrilldownFiltersMap = (props) => {
 const getFiltersToBeAppliedOnDrilldown = (props) => {
   const { rowGroups, groupKeys } = props;
   const filtersToBeApplied = [];
-  groupKeys == null ? void 0 : groupKeys.forEach(
-    (key, index2) => filtersToBeApplied.push({ field: rowGroups[index2], key })
-  );
+  groupKeys == null ? void 0 : groupKeys.forEach((key, index2) => filtersToBeApplied.push({ field: rowGroups[index2], key }));
   return filtersToBeApplied;
 };
 const getMetricFilterRule = (inputs) => {
@@ -870,34 +863,28 @@ const getUpdatedDefinitionCustomModel = (props) => {
     removeSort
   } = props;
   const parentTableVariable = parentCustomModel.variable;
-  const metricNewColumns = _.filter(
-    metricDefinitionModel.variables ?? [],
-    (v) => {
-      if (!v.transforms || !v.transforms[0]) {
-        return false;
-      }
-      if (removeSort) {
-        return findParentIsMetricSeries(
-          v.transforms[0].table,
-          metricDefinitionModel.variables ?? []
-        ) && v.transforms[0].type !== "Sort";
-      }
+  const metricNewColumns = _.filter(metricDefinitionModel.variables ?? [], (v) => {
+    if (!v.transforms || !v.transforms[0]) {
+      return false;
+    }
+    if (removeSort) {
       return findParentIsMetricSeries(
         v.transforms[0].table,
         metricDefinitionModel.variables ?? []
-      );
+      ) && v.transforms[0].type !== "Sort";
     }
-  );
+    return findParentIsMetricSeries(
+      v.transforms[0].table,
+      metricDefinitionModel.variables ?? []
+    );
+  });
   const definitionVariables = metricDefinitionModel.variables ?? [];
   const analysisVariable = _.find(
     definitionVariables,
     (v) => !!_.find(v.transforms, (t) => t.type === "MetricSeries")
   );
   metricDefinitionModel.imports = _.uniqBy(
-    [
-      ...parentDefinitionModel.imports ?? [],
-      ...metricDefinitionModel.imports ?? []
-    ],
+    [...parentDefinitionModel.imports ?? [], ...metricDefinitionModel.imports ?? []],
     "to"
   );
   const parentDefinitionAliases = parentDefinitionModel.aliases ?? {};
@@ -910,10 +897,7 @@ const getUpdatedDefinitionCustomModel = (props) => {
     if (!parentDefinitionAliases[tableId]) {
       const metricTableAlias = metricDefinitionAliases[tableId];
       for (const [columnName, columnId] of Object.entries(metricTableAlias)) {
-        const pColName = _.findKey(
-          parentTableVariableAlias,
-          (pColId) => pColId === columnId
-        );
+        const pColName = _.findKey(parentTableVariableAlias, (pColId) => pColId === columnId);
         if (pColName && pColName !== columnName) {
           delete metricTableAlias[columnName];
           metricTableAlias[pColName] = parentTableVariableAlias[pColName];
@@ -928,22 +912,15 @@ const getUpdatedDefinitionCustomModel = (props) => {
   );
   const previousVariables = metricDefinitionModel.variables;
   metricDefinitionModel.variables = [...variables];
-  const variableNames = (_a = metricDefinitionModel.variables) == null ? void 0 : _a.map(
-    (v) => v == null ? void 0 : v.name
-  );
+  const variableNames = (_a = metricDefinitionModel.variables) == null ? void 0 : _a.map((v) => v == null ? void 0 : v.name);
   metricDefinitionModel.variables.push(
-    ..._.filter(
-      previousVariables,
-      (v) => variableNames == null ? void 0 : variableNames.includes(v.name)
-    )
+    ..._.filter(previousVariables, (v) => variableNames == null ? void 0 : variableNames.includes(v.name))
   );
   const filterVariable = _.find(
     definitionVariables,
     (v) => {
       var _a2;
-      return (_a2 = v.transforms) == null ? void 0 : _a2.some(
-        (t) => t.type === "RuleFilter" && t.rule === "${rule_pivot}"
-      );
+      return (_a2 = v.transforms) == null ? void 0 : _a2.some((t) => t.type === "RuleFilter" && t.rule === "${rule_pivot}");
     }
   );
   if (filterVariable && parentTableVariable) {
@@ -2055,7 +2032,7 @@ var SubscriptionState;
 function startsWith(value, prefix) {
   return value.lastIndexOf(prefix, 0) === 0;
 }
-function isFunction(value) {
+function isFunction$1(value) {
   if (value === void 0 || value === null) {
     return false;
   }
@@ -2064,7 +2041,7 @@ function isFunction(value) {
 function log(level, args) {
   if (globalThis.console) {
     const logger = globalThis.console[level];
-    if (isFunction(logger)) {
+    if (isFunction$1(logger)) {
       logger.apply(globalThis.console, args);
     }
   }
@@ -2085,7 +2062,7 @@ function errorExists(data) {
 function ttlMilliseconds(ttl) {
   return Math.min(ttl * 1e3, 2147483647);
 }
-class Subscription extends EventEmitter$1 {
+let Subscription$1 = class Subscription extends EventEmitter$1 {
   /** Subscription constructor should not be used directly, create subscriptions using Client method. */
   constructor(centrifuge, channel, options) {
     super();
@@ -2700,7 +2677,7 @@ class Subscription extends EventEmitter$1 {
   _failUnauthorized() {
     this._setUnsubscribed(unsubscribedCodes.unauthorized, "unauthorized", true);
   }
-}
+};
 class SockjsTransport {
   constructor(endpoint, options) {
     this.endpoint = endpoint;
@@ -3582,7 +3559,7 @@ class Centrifuge extends EventEmitter$1 {
     if (this.getSubscription(channel) !== null) {
       throw new Error("Subscription to the channel " + channel + " already exists");
     }
-    const sub = new Subscription(this, channel, options);
+    const sub = new Subscription$1(this, channel, options);
     this._subs[channel] = sub;
     return sub;
   }
@@ -5012,7 +4989,7 @@ class Centrifuge extends EventEmitter$1 {
     };
     this._callbacks[id].timeout = setTimeout(() => {
       delete this._callbacks[id];
-      if (isFunction(errback)) {
+      if (isFunction$1(errback)) {
         errback({ error: this._createErrorObject(errorCodes.timeout, "timeout") });
       }
     }, this._config.timeout);
@@ -5185,17 +5162,17 @@ var pusher = { exports: {} };
         var __webpack_modules__ = {
           /***/
           594(__unused_webpack_module, exports$12) {
-            var __extends = this && this.__extends || /* @__PURE__ */ function() {
-              var extendStatics = function(d, b) {
-                extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+            var __extends2 = this && this.__extends || /* @__PURE__ */ function() {
+              var extendStatics2 = function(d, b) {
+                extendStatics2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
                   d2.__proto__ = b2;
                 } || function(d2, b2) {
                   for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
                 };
-                return extendStatics(d, b);
+                return extendStatics2(d, b);
               };
               return function(d, b) {
-                extendStatics(d, b);
+                extendStatics2(d, b);
                 function __() {
                   this.constructor = d;
                 }
@@ -5347,7 +5324,7 @@ var pusher = { exports: {} };
             var URLSafeCoder = (
               /** @class */
               function(_super) {
-                __extends(URLSafeCoder2, _super);
+                __extends2(URLSafeCoder2, _super);
                 function URLSafeCoder2() {
                   return _super !== null && _super.apply(this, arguments) || this;
                 }
@@ -5868,7 +5845,7 @@ var pusher = { exports: {} };
                 f.call(context || window, array[i], i, array);
               }
             }
-            function map(array, f) {
+            function map2(array, f) {
               var result = [];
               for (var i = 0; i < array.length; i++) {
                 result.push(f(array[i], i, array, result));
@@ -5938,7 +5915,7 @@ var pusher = { exports: {} };
               var params = filterObject(data, function(value) {
                 return value !== void 0;
               });
-              var query = map(flatten(encodeParamsObject(params)), util.method("join", "=")).join("&");
+              var query = map2(flatten(encodeParamsObject(params)), util.method("join", "=")).join("&");
               return query;
             }
             function decycleObject(object) {
@@ -7585,7 +7562,7 @@ var pusher = { exports: {} };
               }
             }
             function connect(strategies, minPriority, callbackBuilder) {
-              var runners = map(strategies, function(strategy, i, _2, rs) {
+              var runners = map2(strategies, function(strategy, i, _2, rs) {
                 return strategy.connect(minPriority, callbackBuilder(i, rs));
               });
               return {
@@ -11329,10 +11306,77 @@ async function reassignTask({
     throw { message, status };
   }
 }
+async function getTriggersBySheet(sheetId) {
+  var _a, _b, _c, _d;
+  if (!(sheetId == null ? void 0 : sheetId.trim())) {
+    throw { message: "sheetId is required", status: 400 };
+  }
+  try {
+    const response = await apiClient.get(
+      `/process/trigger/sheet/${sheetId.trim()}`
+    );
+    const payload = ((_a = response.data) == null ? void 0 : _a.data) ?? response.data;
+    return payload ?? [];
+  } catch (error) {
+    const message = ((_c = (_b = error.response) == null ? void 0 : _b.data) == null ? void 0 : _c.message) || error.message || "Failed to fetch process triggers";
+    const status = ((_d = error.response) == null ? void 0 : _d.status) || 500;
+    throw { message, status };
+  }
+}
+async function registerProcessTrigger(payload) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!((_a = payload == null ? void 0 : payload.trigger_id) == null ? void 0 : _a.trim())) {
+    throw { message: "trigger_id is required", status: 400 };
+  }
+  if (!((_b = payload == null ? void 0 : payload.process_sheet_id) == null ? void 0 : _b.trim())) {
+    throw { message: "process_sheet_id is required", status: 400 };
+  }
+  if (!(payload == null ? void 0 : payload.trigger_component)) {
+    throw { message: "trigger_component is required", status: 400 };
+  }
+  if (!(payload == null ? void 0 : payload.workflowType)) {
+    throw { message: "workflowType is required", status: 400 };
+  }
+  try {
+    const response = await apiClient.post(
+      "/process/trigger/register",
+      payload
+    );
+    const data = ((_c = response.data) == null ? void 0 : _c.data) ?? response.data;
+    if (!data) {
+      throw { message: "Failed to register process trigger", status: 500 };
+    }
+    return data;
+  } catch (error) {
+    const message = ((_e = (_d = error.response) == null ? void 0 : _d.data) == null ? void 0 : _e.message) || error.message || "Failed to register process trigger";
+    const status = ((_f = error.response) == null ? void 0 : _f.status) || 500;
+    throw { message, status };
+  }
+}
+async function deleteProcessTrigger(id) {
+  var _a, _b, _c, _d;
+  if (!(id == null ? void 0 : id.trim())) {
+    throw { message: "id is required", status: 400 };
+  }
+  try {
+    const response = await apiClient.delete(
+      `/process/trigger/${id.trim()}`
+    );
+    const data = ((_a = response.data) == null ? void 0 : _a.data) ?? response.data ?? { deleted: true };
+    return data;
+  } catch (error) {
+    const message = ((_c = (_b = error.response) == null ? void 0 : _b.data) == null ? void 0 : _c.message) || error.message || "Failed to delete process trigger";
+    const status = ((_d = error.response) == null ? void 0 : _d.status) || 500;
+    throw { message, status };
+  }
+}
 const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  deleteProcessTrigger,
+  getTriggersBySheet,
   markTaskDone,
-  reassignTask
+  reassignTask,
+  registerProcessTrigger
 }, Symbol.toStringTag, { value: "Module" }));
 async function getAllInboxItems({
   page,
@@ -12393,135 +12437,6 @@ function deferSubscription(resolve, callback, fallback) {
     innerUnsub == null ? void 0 : innerUnsub();
   };
 }
-const OP_MAP = {
-  "==": "$eq",
-  "!=": "$ne",
-  "<": "$lt",
-  "<=": "$lte",
-  ">": "$gt",
-  ">=": "$gte",
-  in: "$in",
-  "not-in": "$nin"
-};
-class QueryBuilderImpl {
-  constructor(collection, initialWhere, initialOrder, initialLimit, initialSkip, aggregateExecutor) {
-    this.collection = collection;
-    this.aggregateExecutor = aggregateExecutor;
-    this.wheres = [];
-    this.orders = [];
-    if (initialWhere) this.wheres.push(initialWhere);
-    if (initialOrder) this.orders.push(initialOrder);
-    if (initialLimit !== void 0) this.limitCount = initialLimit;
-    if (initialSkip !== void 0) this.skipCount = initialSkip;
-  }
-  where(field, op, value) {
-    this.wheres.push({ field, op, value });
-    return this;
-  }
-  orderBy(field, direction = "asc") {
-    this.orders.push({ field, direction });
-    return this;
-  }
-  limit(count) {
-    this.limitCount = count;
-    return this;
-  }
-  skip(count) {
-    this.skipCount = count;
-    return this;
-  }
-  subscribe(callback) {
-    const query = this.buildQuery();
-    const rxSub = query.$.subscribe((docs) => {
-      callback(docs.map((d) => d.toJSON()));
-    });
-    return () => rxSub.unsubscribe();
-  }
-  async get() {
-    const query = this.buildQuery();
-    const docs = await query.exec();
-    return docs.map((d) => d.toJSON());
-  }
-  async aggregate(spec, options) {
-    if (!this.aggregateExecutor) {
-      throw new InputTableError(
-        "[copaInputTableDb] aggregate() is not available on this QueryBuilder instance",
-        500
-      );
-    }
-    return this.aggregateExecutor(
-      this.wheres,
-      this.orders,
-      this.limitCount,
-      this.skipCount,
-      spec,
-      options == null ? void 0 : options.groupBy
-    );
-  }
-  buildQuery() {
-    const selector = {};
-    for (const { field, op, value } of this.wheres) {
-      const rxOp = OP_MAP[op];
-      if (!selector[field]) selector[field] = {};
-      selector[field][rxOp] = value;
-    }
-    const queryParams = { selector };
-    if (this.orders.length > 0) {
-      queryParams.sort = this.orders.map(({ field, direction }) => ({ [field]: direction }));
-    }
-    if (this.limitCount !== void 0) {
-      queryParams.limit = this.limitCount;
-    }
-    if (this.skipCount !== void 0) {
-      queryParams.skip = this.skipCount;
-    }
-    return this.collection.find(queryParams);
-  }
-}
-const CHECKPOINT_FIELD = "updated_at";
-const MAX_COLLECTIONS = 14;
-const REPLICATION_RETRY_TIME = 5e3;
-const PULL_BATCH_SIZE = 100;
-const PUSH_BATCH_SIZE = 10;
-class DocRefImpl {
-  constructor(collection, id, solutionId, tableName, primaryKeyField, websocketProvider) {
-    this.collection = collection;
-    this.id = id;
-    this.solutionId = solutionId;
-    this.tableName = tableName;
-    this.primaryKeyField = primaryKeyField;
-    this.websocketProvider = websocketProvider;
-  }
-  async get() {
-    const doc = await this.collection.findOne(this.id).exec();
-    return doc ? doc.toJSON() : null;
-  }
-  async update(data) {
-    const doc = await this.collection.findOne(this.id).exec();
-    if (!doc) {
-      throw new InputTableError(`Document "${this.id}" not found`, 404);
-    }
-    const patch = { ...data };
-    delete patch[this.primaryKeyField];
-    delete patch[CHECKPOINT_FIELD];
-    await doc.patch(patch);
-  }
-  async delete() {
-    await apiClient.request({
-      url: `input-table-v2/${this.solutionId}/rows/${this.tableName}`,
-      method: "DELETE",
-      params: { [this.primaryKeyField]: `eq.${this.id}` }
-    });
-    const doc = await this.collection.findOne(this.id).exec();
-    if (doc) await doc.remove();
-  }
-  onSnapshot(callback) {
-    const rxSub = this.collection.findOne(this.id).$.subscribe((doc) => {
-      callback(doc ? doc.toJSON() : null);
-    });
-    return () => rxSub.unsubscribe();
-  }
-}
 const POSTGREST_OP_MAP = {
   "==": "eq",
   "!=": "neq",
@@ -12684,144 +12599,527 @@ function parseGroupedAggregateResponse(spec, groupBy, data) {
     return result;
   });
 }
-class CollectionRefImpl {
-  constructor(collection, solutionId, tableName, primaryKeyField, pkColumn, replicationState, getWebsocketProvider) {
-    this.collection = collection;
-    this.solutionId = solutionId;
-    this.tableName = tableName;
-    this.primaryKeyField = primaryKeyField;
-    this.pkColumn = pkColumn;
-    this.replicationState = replicationState;
-    this.getWebsocketProvider = getWebsocketProvider;
-  }
-  makeQueryBuilder(initialWhere, initialOrder, initialLimit, initialSkip) {
-    return new QueryBuilderImpl(
-      this.collection,
-      initialWhere,
-      initialOrder,
-      initialLimit,
-      initialSkip,
-      (wheres, orders, limit, skip, spec, groupBy) => this.executeAggregate(wheres, orders, limit, skip, spec, groupBy)
-    );
-  }
-  where(field, op, value) {
-    return this.makeQueryBuilder({ field, op, value });
-  }
-  orderBy(field, direction = "asc") {
-    return this.makeQueryBuilder(void 0, { field, direction });
-  }
-  limit(count) {
-    return this.makeQueryBuilder(void 0, void 0, count);
-  }
-  skip(count) {
-    return this.makeQueryBuilder(void 0, void 0, void 0, count);
+function deriveEmbedAlias(columnName, allColumnNames) {
+  const names = new Set(allColumnNames);
+  const primary = columnName.endsWith("_id") ? columnName.slice(0, -3) : `${columnName}_row`;
+  if (!names.has(primary)) return primary;
+  const fallback = `${columnName}_row`;
+  if (!names.has(fallback)) return fallback;
+  return `${columnName}__row`;
+}
+function resolveRelationship(columnName, schema) {
+  var _a;
+  const col = schema.columns.find((c) => c.name === columnName);
+  if (!col) {
+    throw new InputTableError(`Column '${columnName}' does not exist on table '${schema.name}'`, 400);
   }
-  doc(id) {
-    return new DocRefImpl(
-      this.collection,
-      id,
-      this.solutionId,
-      this.tableName,
-      this.primaryKeyField,
-      this.getWebsocketProvider
-    );
+  const rel = (_a = schema.relationships) == null ? void 0 : _a.find((r) => r.column === columnName);
+  if (!rel) {
+    throw new InputTableError(`Column '${columnName}' is not a foreign key on table '${schema.name}'`, 400);
   }
-  async add(data) {
-    var _a, _b;
-    const pk = this.primaryKeyField;
-    const insertData = { ...data };
-    const needsServerPk = ((_a = this.pkColumn) == null ? void 0 : _a.auto_increment) && this.pkColumn.type !== InputTableColumnType.UUID && !insertData[pk];
-    if (needsServerPk) {
-      delete insertData[pk];
-      delete insertData[CHECKPOINT_FIELD];
-      const response = await apiClient.post(
-        `/input-table-v2/${this.solutionId}/rows/${this.tableName}`,
-        insertData,
-        { headers: { Prefer: "return=representation" } }
-      );
-      this.replicationState.reSync();
-      const serverRow = Array.isArray(response.data) ? response.data[0] : response.data;
-      return String((serverRow == null ? void 0 : serverRow[pk]) ?? "");
+  return rel;
+}
+function buildExpandSelectParam(expansions) {
+  if (expansions.length === 0) return "*";
+  const embeds = expansions.map((e) => `${e.alias}:${e.referencedTable}!${e.fkColumn}(*)`).join(",");
+  return `*,${embeds}`;
+}
+function buildExpandDirectives(columnNames, schema) {
+  const allNames = schema.columns.map((c) => c.name);
+  return columnNames.map((name) => {
+    const rel = resolveRelationship(name, schema);
+    return {
+      alias: deriveEmbedAlias(name, allNames),
+      referencedTable: rel.references_table,
+      fkColumn: name
+    };
+  });
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function hasLift(source) {
+  return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
     }
-    if (((_b = this.pkColumn) == null ? void 0 : _b.type) === InputTableColumnType.UUID && this.pkColumn.auto_increment && !insertData[pk]) {
-      insertData[pk] = crypto.randomUUID();
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
     }
-    if (!insertData[pk]) {
-      insertData[pk] = generatePushID();
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
     }
-    insertData[pk] = String(insertData[pk]).trim();
-    delete insertData[CHECKPOINT_FIELD];
-    await this.collection.insert(insertData);
-    return String(insertData[pk]);
-  }
-  subscribe(callback) {
-    const rxSub = this.collection.find().$.subscribe((docs) => {
-      callback(docs.map((d) => d.toJSON()));
-    });
-    return () => rxSub.unsubscribe();
-  }
-  async get() {
-    const docs = await this.collection.find().exec();
-    return docs.map((d) => d.toJSON());
   }
-  count(callback) {
-    const rxSub = this.collection.count().$.subscribe((count) => {
-      callback(count);
-    });
-    return () => rxSub.unsubscribe();
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
   }
-  async aggregate(spec, options) {
-    return this.executeAggregate([], [], void 0, void 0, spec, options == null ? void 0 : options.groupBy);
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index2 = arr.indexOf(item);
+    0 <= index2 && arr.splice(index2, 1);
+  }
+}
+var Subscription2 = function() {
+  function Subscription3(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription3.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription3.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription3) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription3.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription3.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription3.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription3.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription3) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription3.EMPTY = function() {
+    var empty = new Subscription3();
+    empty.closed = true;
+    return empty;
+  }();
+  return Subscription3;
+}();
+Subscription2.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription2 || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
   }
-  async executeAggregate(wheres, orders, limit, skip, spec, groupBy) {
-    var _a, _b, _c;
-    validateAggregateSpec(spec);
-    const activeGroupBy = groupBy && groupBy.length > 0 ? groupBy : void 0;
-    if (activeGroupBy) {
-      validateGroupBySpec(activeGroupBy, spec);
+}
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
     }
-    const selectParam = buildAggregateSelect(spec, activeGroupBy);
-    if (!selectParam) {
-      return activeGroupBy ? [] : {};
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    return clearTimeout(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    {
+      throw err;
     }
-    const filterParams = buildPostgrestFilters(wheres);
-    const params = {
-      select: selectParam,
-      ...filterParams
-    };
-    if (limit !== void 0) params["limit"] = limit;
-    if (skip !== void 0) params["offset"] = skip;
-    if (activeGroupBy && orders.length > 0) {
-      const groupBySet = new Set(activeGroupBy);
-      for (const { field } of orders) {
-        if (!groupBySet.has(field)) {
-          throw new InputTableError(
-            `orderBy field "${field}" must be one of the groupBy columns: [${activeGroupBy.join(", ")}]`,
-            400
-          );
-        }
+  });
+}
+function noop() {
+}
+var Subscriber = function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
       }
-      params["order"] = buildPostgrestOrder(orders);
+    } else {
+      _this.destination = EMPTY_OBSERVER;
     }
-    let response;
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) ;
+    else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
     try {
-      response = await apiClient.get(
-        `/input-table-v2/${this.solutionId}/rows/${this.tableName}`,
-        { params, headers: getSolutionBranchHeaders() }
-      );
-    } catch (err) {
-      const axiosErr = err;
-      throw new InputTableError(
-        ((_b = (_a = axiosErr.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) ?? axiosErr.message ?? "Aggregate query failed",
-        ((_c = axiosErr.response) == null ? void 0 : _c.status) ?? 500
-      );
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
     }
-    const data = Array.isArray(response.data) ? response.data : [response.data];
-    if (activeGroupBy) {
-      return parseGroupedAggregateResponse(spec, activeGroupBy, data);
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
     }
-    return parseAggregateResponse(spec, data);
+  };
+  return Subscriber2;
+}(Subscription2);
+var ConsumerObserver = function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+}();
+var SafeSubscriber = function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+}(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+  return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = function(_super) {
+  __extends(OperatorSubscriber2, _super);
+  function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+    var _this = _super.call(this, destination) || this;
+    _this.onFinalize = onFinalize;
+    _this.shouldUnsubscribe = shouldUnsubscribe;
+    _this._next = onNext ? function(value) {
+      try {
+        onNext(value);
+      } catch (err) {
+        destination.error(err);
+      }
+    } : _super.prototype._next;
+    _this._error = onError ? function(err) {
+      try {
+        onError(err);
+      } catch (err2) {
+        destination.error(err2);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._error;
+    _this._complete = onComplete ? function() {
+      try {
+        onComplete();
+      } catch (err) {
+        destination.error(err);
+      } finally {
+        this.unsubscribe();
+      }
+    } : _super.prototype._complete;
+    return _this;
+  }
+  OperatorSubscriber2.prototype.unsubscribe = function() {
+    var _a;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var closed_1 = this.closed;
+      _super.prototype.unsubscribe.call(this);
+      !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+    }
+  };
+  return OperatorSubscriber2;
+}(Subscriber);
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index2 = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index2++));
+    }));
+  });
+}
+function buildLookupMap(rows, pkField) {
+  const m = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const pk = row[pkField];
+    if (pk === void 0 || pk === null) continue;
+    m.set(pk, row);
   }
+  return m;
+}
+function joinRowsWithLookups(primaryRows, directives, lookups) {
+  return primaryRows.map((row) => {
+    var _a;
+    const out = { ...row };
+    for (const d of directives) {
+      const fkValue = row[d.fkColumn];
+      const found = (_a = lookups[d.referencedTable]) == null ? void 0 : _a.get(fkValue);
+      if (found !== void 0) out[d.alias] = found;
+    }
+    return out;
+  });
+}
+function createExpandedSubscription(config, cb) {
+  const refKeys = Object.keys(config.referenced);
+  const streams = [config.primary$, ...refKeys.map((k) => config.referenced[k].stream$)];
+  const sub = combineLatest(streams).pipe(
+    map(([primary, ...refs]) => {
+      const lookups = {};
+      refKeys.forEach((k, i) => {
+        lookups[k] = buildLookupMap(refs[i], config.referenced[k].pkField);
+      });
+      return joinRowsWithLookups(primary, config.directives, lookups);
+    })
+  ).subscribe({
+    next: cb,
+    error: (err) => console.error("[expandedView] subscription error", err)
+  });
+  return () => sub.unsubscribe();
 }
 let dbPromise = null;
 function getInputTableDatabase() {
@@ -12853,6 +13151,11 @@ async function closeInputTableDatabase() {
     dbPromise = null;
   }
 }
+const CHECKPOINT_FIELD = "updated_at";
+const MAX_COLLECTIONS = 14;
+const REPLICATION_RETRY_TIME = 5e3;
+const PULL_BATCH_SIZE = 100;
+const PUSH_BATCH_SIZE = 10;
 const PG_TO_JSON_SCHEMA = {
   [InputTableColumnType.UUID]: { type: "string" },
   [InputTableColumnType.TEXT]: { type: "string" },
@@ -12939,6 +13242,7 @@ function createReplication(collection, solutionId, tableName, primaryKeyField) {
         const conflicts = [];
         for (const row of changeRows) {
           const doc = row.newDocumentState;
+          if (doc._deleted) continue;
           try {
             if (row.assumedMasterState == null) {
               const insertData = { ...doc };
@@ -13020,14 +13324,30 @@ function createReplication(collection, solutionId, tableName, primaryKeyField) {
     }
   };
 }
-function createRealtimeBinding(provider, replicationState, workspaceId, solutionId, tableName) {
+function createRealtimeBinding(provider, replicationState, collection, primaryKeyField, workspaceId, solutionId, tableName) {
   const channel = `public-input-table-v2-${workspaceId}-${solutionId}-${tableName}`;
-  function handleChangeNotification() {
+  function handleUpsert() {
     replicationState.reSync();
   }
-  provider.bind(channel, "INSERT", handleChangeNotification);
-  provider.bind(channel, "UPDATE", handleChangeNotification);
-  provider.bind(channel, "DELETE", handleChangeNotification);
+  async function handleDelete(payload) {
+    const data = payload;
+    if (!data || data.truncated || !Array.isArray(data.deleted_rows) || data.deleted_rows.length === 0) {
+      replicationState.reSync();
+      return;
+    }
+    for (const row of data.deleted_rows) {
+      const pk = row == null ? void 0 : row[primaryKeyField];
+      if (pk == null) continue;
+      try {
+        const doc = await collection.findOne(String(pk)).exec();
+        if (doc) await doc.remove();
+      } catch {
+      }
+    }
+  }
+  provider.bind(channel, "INSERT", handleUpsert);
+  provider.bind(channel, "UPDATE", handleUpsert);
+  provider.bind(channel, "DELETE", handleDelete);
   return {
     cleanup: () => {
       provider.unbind(channel, "INSERT");
@@ -13038,11 +13358,42 @@ function createRealtimeBinding(provider, replicationState, workspaceId, solution
 }
 const activeCollections = /* @__PURE__ */ new Map();
 const pendingCollections = /* @__PURE__ */ new Map();
+const closingCollections = /* @__PURE__ */ new Map();
 function collectionKey(workspaceId, solutionId, tableName) {
   return `${workspaceId}:${toCollectionName(solutionId, tableName)}`;
 }
+async function pinCollection(solutionId, tableDef, workspaceId, websocketProvider) {
+  const managed = await getOrCreateCollection(solutionId, tableDef, workspaceId, websocketProvider);
+  managed.refCount += 1;
+  managed.lastAccessed = Date.now();
+  return managed;
+}
+async function unpinCollection(solutionId, tableName, workspaceId) {
+  const key = collectionKey(workspaceId, solutionId, tableName);
+  const managed = activeCollections.get(key);
+  if (!managed) return;
+  managed.refCount -= 1;
+  if (managed.refCount > 0) return;
+  const existing = closingCollections.get(key);
+  if (existing) return existing;
+  const teardown = (async () => {
+    var _a;
+    try {
+      (_a = managed.realtimeBinding) == null ? void 0 : _a.cleanup();
+      await managed.replication.cancel();
+      await managed.collection.close();
+    } finally {
+      if (activeCollections.get(key) === managed) activeCollections.delete(key);
+      closingCollections.delete(key);
+    }
+  })();
+  closingCollections.set(key, teardown);
+  await teardown;
+}
 async function getOrCreateCollection(solutionId, tableDef, workspaceId, websocketProvider) {
   const key = collectionKey(workspaceId, solutionId, tableDef.name);
+  const closing = closingCollections.get(key);
+  if (closing) await closing;
   const existing = activeCollections.get(key);
   if (existing) {
     existing.lastAccessed = Date.now();
@@ -13109,6 +13460,8 @@ async function createCollectionInternal(key, solutionId, tableDef, workspaceId,
     realtimeBinding = createRealtimeBinding(
       websocketProvider,
       replication.state,
+      collection,
+      pkField,
       workspaceId,
       solutionId,
       tableDef.name
@@ -13158,41 +13511,527 @@ async function evictLeastRecentlyUsed() {
     );
   }
 }
-const SOLUTION_COOKIE_NAME = "x-bluecopa-solution-id";
-function getCookieValue(name) {
-  try {
-    const cookie = document.cookie.split(";").map((c) => c.trim()).find((c) => c.startsWith(`${name}=`));
-    return cookie ? decodeURIComponent(cookie.split("=").slice(1).join("=")) : null;
-  } catch {
-    return null;
-  }
-}
-function getSolutionId() {
-  const config = getConfig();
-  if (config.solutionId) {
-    return validateIdentifier(config.solutionId, "solutionId");
-  }
-  const cookieValue = getCookieValue(SOLUTION_COOKIE_NAME);
-  if (cookieValue) {
-    return validateIdentifier(cookieValue, "solutionId (cookie)");
-  }
-  throw new InputTableError(
-    "[copaInputTableDb] No solutionId configured. Set via copaSetConfig({ solutionId }) or cookie.",
-    400
+function rxCollectionStream(collection) {
+  return collection.find().$.pipe(
+    map$1((docs) => docs.map((d) => d.toJSON()))
   );
 }
-const _InputTableDBImpl = class _InputTableDBImpl {
-  constructor() {
-    this.schemaCache = /* @__PURE__ */ new Map();
-    this.schemaPending = /* @__PURE__ */ new Map();
-    this.wsWarned = false;
-    this.generation = 0;
+const OP_MAP = {
+  "==": "$eq",
+  "!=": "$ne",
+  "<": "$lt",
+  "<=": "$lte",
+  ">": "$gt",
+  ">=": "$gte",
+  in: "$in",
+  "not-in": "$nin"
+};
+class QueryBuilderImpl {
+  constructor(collection, initialWhere, initialOrder, initialLimit, initialSkip, aggregateExecutor, expandContext) {
+    this.collection = collection;
+    this.aggregateExecutor = aggregateExecutor;
+    this.expandContext = expandContext;
+    this.wheres = [];
+    this.orders = [];
+    if (initialWhere) this.wheres.push(initialWhere);
+    if (initialOrder) this.orders.push(initialOrder);
+    if (initialLimit !== void 0) this.limitCount = initialLimit;
+    if (initialSkip !== void 0) this.skipCount = initialSkip;
   }
-  setWebsocketProvider(provider) {
-    this.wsProvider = provider;
+  where(field, op, value) {
+    this.wheres.push({ field, op, value });
+    return this;
   }
-  getProvider() {
-    return this.wsProvider ?? getConfig().websocketProvider;
+  orderBy(field, direction = "asc") {
+    this.orders.push({ field, direction });
+    return this;
+  }
+  limit(count) {
+    this.limitCount = count;
+    return this;
+  }
+  skip(count) {
+    this.skipCount = count;
+    return this;
+  }
+  expand(columnNames) {
+    if (columnNames.length === 0) {
+      throw new InputTableError(".expand() requires at least one column name", 400);
+    }
+    const existing = this.expandContext;
+    if (!existing) {
+      throw new InputTableError(
+        ".expand() is only available on builders derived from a CollectionRef with a loaded schema",
+        500
+      );
+    }
+    const merged = Array.from(/* @__PURE__ */ new Set([...existing.expandColumns, ...columnNames]));
+    for (const name of merged) {
+      resolveRelationship(name, existing.schema);
+    }
+    this.expandContext = { ...existing, expandColumns: merged };
+    return this;
+  }
+  subscribe(callback) {
+    if (this.expandContext) {
+      return this.subscribeWithExpand(this.expandContext, callback);
+    }
+    const query = this.buildQuery();
+    const rxSub = query.$.subscribe((docs) => {
+      callback(docs.map((d) => d.toJSON()));
+    });
+    return () => rxSub.unsubscribe();
+  }
+  buildPrimaryStream() {
+    const query = this.buildQuery();
+    return query.$.pipe(
+      map$1((docs) => docs.map((d) => d.toJSON()))
+    );
+  }
+  subscribeWithExpand(ctx, callback) {
+    const directives = buildExpandDirectives(ctx.expandColumns, ctx.schema);
+    let cancelled = false;
+    let innerStop = null;
+    const unpinFns = [];
+    const unpinAll = async () => {
+      while (unpinFns.length > 0) {
+        const fn = unpinFns.pop();
+        try {
+          await (fn == null ? void 0 : fn());
+        } catch {
+        }
+      }
+    };
+    const wsProvider = ctx.getWebsocketProvider();
+    void (async () => {
+      var _a;
+      try {
+        await pinCollection(ctx.solutionId, ctx.schema, ctx.workspaceId, wsProvider);
+        unpinFns.push(
+          () => unpinCollection(ctx.solutionId, ctx.tableName, ctx.workspaceId)
+        );
+        if (cancelled) {
+          await unpinAll();
+          return;
+        }
+        const uniqueRefs = Array.from(new Set(directives.map((d) => d.referencedTable)));
+        const referenced = {};
+        for (const refName of uniqueRefs) {
+          if (refName === ctx.tableName) {
+            const pkField = ((_a = ctx.schema.columns.find((c) => c.primary_key)) == null ? void 0 : _a.name) ?? "id";
+            referenced[refName] = {
+              stream$: rxCollectionStream(this.collection),
+              pkField
+            };
+            continue;
+          }
+          const refSchema = ctx.getSchemaForTable(refName);
+          if (!refSchema) {
+            throw new InputTableError(
+              `Referenced table '${refName}' not found in schema cache`,
+              404
+            );
+          }
+          const managed = await pinCollection(
+            ctx.solutionId,
+            refSchema,
+            ctx.workspaceId,
+            wsProvider
+          );
+          unpinFns.push(
+            () => unpinCollection(ctx.solutionId, refName, ctx.workspaceId)
+          );
+          referenced[refName] = {
+            stream$: rxCollectionStream(managed.collection),
+            pkField: managed.primaryKeyField
+          };
+          if (cancelled) {
+            await unpinAll();
+            return;
+          }
+        }
+        if (cancelled) {
+          await unpinAll();
+          return;
+        }
+        innerStop = createExpandedSubscription(
+          { primary$: this.buildPrimaryStream(), referenced, directives },
+          callback
+        );
+        if (cancelled) {
+          innerStop();
+          innerStop = null;
+          await unpinAll();
+        }
+      } catch (err) {
+        console.error("[copaInputTableDb] expand.subscribe wiring failed", err);
+        await unpinAll();
+      }
+    })();
+    return () => {
+      cancelled = true;
+      innerStop == null ? void 0 : innerStop();
+      innerStop = null;
+      void unpinAll();
+    };
+  }
+  async get() {
+    if (this.expandContext) {
+      return this.getWithExpand(this.expandContext);
+    }
+    const query = this.buildQuery();
+    const docs = await query.exec();
+    return docs.map((d) => d.toJSON());
+  }
+  async getWithExpand(ctx) {
+    var _a, _b, _c;
+    const directives = buildExpandDirectives(ctx.expandColumns, ctx.schema);
+    const selectParam = buildExpandSelectParam(directives);
+    const params = {
+      select: selectParam,
+      ...buildPostgrestFilters(this.wheres)
+    };
+    if (this.limitCount !== void 0) params["limit"] = this.limitCount;
+    if (this.skipCount !== void 0) params["offset"] = this.skipCount;
+    if (this.orders.length > 0) params["order"] = buildPostgrestOrder(this.orders);
+    let response;
+    try {
+      response = await apiClient.get(
+        `/input-table-v2/${ctx.solutionId}/rows/${ctx.tableName}`,
+        { params, headers: ctx.getHeaders() }
+      );
+    } catch (err) {
+      const message = isAxiosError(err) ? ((_b = (_a = err.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) ?? err.message : (err == null ? void 0 : err.message) ?? "Expand query failed";
+      const status = isAxiosError(err) ? ((_c = err.response) == null ? void 0 : _c.status) ?? 500 : 500;
+      throw new InputTableError(message, status);
+    }
+    return response.data ?? [];
+  }
+  async aggregate(spec, options) {
+    if (this.expandContext) {
+      throw new InputTableError(".expand() cannot be combined with .aggregate()", 400);
+    }
+    if (!this.aggregateExecutor) {
+      throw new InputTableError(
+        "[copaInputTableDb] aggregate() is not available on this QueryBuilder instance",
+        500
+      );
+    }
+    return this.aggregateExecutor(
+      this.wheres,
+      this.orders,
+      this.limitCount,
+      this.skipCount,
+      spec,
+      options == null ? void 0 : options.groupBy
+    );
+  }
+  buildQuery() {
+    const selector = {};
+    for (const { field, op, value } of this.wheres) {
+      const rxOp = OP_MAP[op];
+      if (!selector[field]) selector[field] = {};
+      selector[field][rxOp] = value;
+    }
+    const queryParams = { selector };
+    if (this.orders.length > 0) {
+      queryParams.sort = this.orders.map(({ field, direction }) => ({ [field]: direction }));
+    }
+    if (this.limitCount !== void 0) {
+      queryParams.limit = this.limitCount;
+    }
+    if (this.skipCount !== void 0) {
+      queryParams.skip = this.skipCount;
+    }
+    return this.collection.find(queryParams);
+  }
+}
+class DocRefImpl {
+  constructor(collection, id, solutionId, tableName, primaryKeyField, websocketProvider) {
+    this.collection = collection;
+    this.id = id;
+    this.solutionId = solutionId;
+    this.tableName = tableName;
+    this.primaryKeyField = primaryKeyField;
+    this.websocketProvider = websocketProvider;
+  }
+  async get() {
+    const doc = await this.collection.findOne(this.id).exec();
+    return doc ? doc.toJSON() : null;
+  }
+  async update(data) {
+    const doc = await this.collection.findOne(this.id).exec();
+    if (!doc) {
+      throw new InputTableError(`Document "${this.id}" not found`, 404);
+    }
+    const patch = { ...data };
+    delete patch[this.primaryKeyField];
+    delete patch[CHECKPOINT_FIELD];
+    await doc.patch(patch);
+  }
+  async delete() {
+    await apiClient.request({
+      url: `input-table-v2/${this.solutionId}/rows/${this.tableName}`,
+      method: "DELETE",
+      params: { [this.primaryKeyField]: `eq.${this.id}` }
+    });
+    const doc = await this.collection.findOne(this.id).exec();
+    if (doc) await doc.remove();
+  }
+  onSnapshot(callback) {
+    const rxSub = this.collection.findOne(this.id).$.subscribe((doc) => {
+      callback(doc ? doc.toJSON() : null);
+    });
+    return () => rxSub.unsubscribe();
+  }
+}
+class CollectionRefImpl {
+  constructor(collection, solutionId, tableName, primaryKeyField, pkColumn, replicationState, getWebsocketProvider, schema, getSchemaForTable) {
+    this.collection = collection;
+    this.solutionId = solutionId;
+    this.tableName = tableName;
+    this.primaryKeyField = primaryKeyField;
+    this.pkColumn = pkColumn;
+    this.replicationState = replicationState;
+    this.getWebsocketProvider = getWebsocketProvider;
+    this.schema = schema;
+    this.getSchemaForTable = getSchemaForTable;
+  }
+  makeQueryBuilder(initialWhere, initialOrder, initialLimit, initialSkip, expandContext) {
+    return new QueryBuilderImpl(
+      this.collection,
+      initialWhere,
+      initialOrder,
+      initialLimit,
+      initialSkip,
+      (wheres, orders, limit, skip, spec, groupBy) => this.executeAggregate(wheres, orders, limit, skip, spec, groupBy),
+      expandContext
+    );
+  }
+  where(field, op, value) {
+    return this.makeQueryBuilder({ field, op, value });
+  }
+  orderBy(field, direction = "asc") {
+    return this.makeQueryBuilder(void 0, { field, direction });
+  }
+  limit(count) {
+    return this.makeQueryBuilder(void 0, void 0, count);
+  }
+  skip(count) {
+    return this.makeQueryBuilder(void 0, void 0, void 0, count);
+  }
+  expand(columnNames) {
+    if (columnNames.length === 0) {
+      throw new InputTableError(".expand() requires at least one column name", 400);
+    }
+    if (!this.schema) {
+      throw new InputTableError(
+        ".expand() requires the collection to be initialised with its schema",
+        500
+      );
+    }
+    for (const name of columnNames) {
+      resolveRelationship(name, this.schema);
+    }
+    const workspaceId = getConfig().workspaceId ?? "";
+    const schema = this.schema;
+    const ctx = {
+      schema,
+      expandColumns: [...columnNames],
+      solutionId: this.solutionId,
+      tableName: this.tableName,
+      workspaceId,
+      getHeaders: () => getSolutionBranchHeaders(),
+      getSchemaForTable: (name) => this.getSchemaForTable ? this.getSchemaForTable(name) : schema.name === name ? schema : null,
+      getWebsocketProvider: () => this.getWebsocketProvider()
+    };
+    return this.makeQueryBuilder(void 0, void 0, void 0, void 0, ctx);
+  }
+  doc(id) {
+    return new DocRefImpl(
+      this.collection,
+      id,
+      this.solutionId,
+      this.tableName,
+      this.primaryKeyField,
+      this.getWebsocketProvider
+    );
+  }
+  async add(data) {
+    var _a, _b;
+    const pk = this.primaryKeyField;
+    const insertData = { ...data };
+    const needsServerPk = ((_a = this.pkColumn) == null ? void 0 : _a.auto_increment) && this.pkColumn.type !== InputTableColumnType.UUID && !insertData[pk];
+    if (needsServerPk) {
+      delete insertData[pk];
+      delete insertData[CHECKPOINT_FIELD];
+      const response = await apiClient.post(
+        `/input-table-v2/${this.solutionId}/rows/${this.tableName}`,
+        insertData,
+        { headers: { Prefer: "return=representation" } }
+      );
+      this.replicationState.reSync();
+      const serverRow = Array.isArray(response.data) ? response.data[0] : response.data;
+      return String((serverRow == null ? void 0 : serverRow[pk]) ?? "");
+    }
+    if (((_b = this.pkColumn) == null ? void 0 : _b.type) === InputTableColumnType.UUID && this.pkColumn.auto_increment && !insertData[pk]) {
+      insertData[pk] = crypto.randomUUID();
+    }
+    if (!insertData[pk]) {
+      insertData[pk] = generatePushID();
+    }
+    insertData[pk] = String(insertData[pk]).trim();
+    delete insertData[CHECKPOINT_FIELD];
+    await this.collection.insert(insertData);
+    return String(insertData[pk]);
+  }
+  /**
+   * Subscribe to live changes on this collection. Auto-manages the underlying
+   * RxDB collection's pin refcount so the collection stays alive for the
+   * lifetime of the subscription.
+   *
+   * Note: `.get()`, `.count()`, and `DocRef.get()` intentionally do NOT pin
+   * the collection. They are one-shot reads where the caller is expected to
+   * tolerate the collection being LRU-evicted between calls. If you need a
+   * long-lived reference, use `.subscribe(...)`.
+   */
+  subscribe(callback) {
+    const rxSub = this.collection.find().$.subscribe((docs) => {
+      callback(docs.map((d) => d.toJSON()));
+    });
+    const workspaceId = getConfig().workspaceId;
+    const shouldManagePin = Boolean(this.schema) && Boolean(workspaceId);
+    let cancelled = false;
+    let pinResolved = false;
+    let teardownRan = false;
+    if (shouldManagePin) {
+      pinCollection(
+        this.solutionId,
+        this.schema,
+        workspaceId,
+        this.getWebsocketProvider()
+      ).then(() => {
+        pinResolved = true;
+        if (cancelled) {
+          void unpinCollection(
+            this.solutionId,
+            this.tableName,
+            workspaceId
+          );
+        }
+      }).catch(() => {
+      });
+    }
+    return () => {
+      if (teardownRan) return;
+      teardownRan = true;
+      rxSub.unsubscribe();
+      if (!shouldManagePin) return;
+      if (pinResolved) {
+        void unpinCollection(this.solutionId, this.tableName, workspaceId);
+      } else {
+        cancelled = true;
+      }
+    };
+  }
+  async get() {
+    const docs = await this.collection.find().exec();
+    return docs.map((d) => d.toJSON());
+  }
+  count(callback) {
+    const rxSub = this.collection.count().$.subscribe((count) => {
+      callback(count);
+    });
+    return () => rxSub.unsubscribe();
+  }
+  async aggregate(spec, options) {
+    return this.executeAggregate([], [], void 0, void 0, spec, options == null ? void 0 : options.groupBy);
+  }
+  async executeAggregate(wheres, orders, limit, skip, spec, groupBy) {
+    var _a, _b, _c;
+    validateAggregateSpec(spec);
+    const activeGroupBy = groupBy && groupBy.length > 0 ? groupBy : void 0;
+    if (activeGroupBy) {
+      validateGroupBySpec(activeGroupBy, spec);
+    }
+    const selectParam = buildAggregateSelect(spec, activeGroupBy);
+    if (!selectParam) {
+      return activeGroupBy ? [] : {};
+    }
+    const filterParams = buildPostgrestFilters(wheres);
+    const params = {
+      select: selectParam,
+      ...filterParams
+    };
+    if (limit !== void 0) params["limit"] = limit;
+    if (skip !== void 0) params["offset"] = skip;
+    if (activeGroupBy && orders.length > 0) {
+      const groupBySet = new Set(activeGroupBy);
+      for (const { field } of orders) {
+        if (!groupBySet.has(field)) {
+          throw new InputTableError(
+            `orderBy field "${field}" must be one of the groupBy columns: [${activeGroupBy.join(", ")}]`,
+            400
+          );
+        }
+      }
+      params["order"] = buildPostgrestOrder(orders);
+    }
+    let response;
+    try {
+      response = await apiClient.get(
+        `/input-table-v2/${this.solutionId}/rows/${this.tableName}`,
+        { params, headers: getSolutionBranchHeaders() }
+      );
+    } catch (err) {
+      const axiosErr = err;
+      throw new InputTableError(
+        ((_b = (_a = axiosErr.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) ?? axiosErr.message ?? "Aggregate query failed",
+        ((_c = axiosErr.response) == null ? void 0 : _c.status) ?? 500
+      );
+    }
+    const data = Array.isArray(response.data) ? response.data : [response.data];
+    if (activeGroupBy) {
+      return parseGroupedAggregateResponse(spec, activeGroupBy, data);
+    }
+    return parseAggregateResponse(spec, data);
+  }
+}
+const SOLUTION_COOKIE_NAME = "x-bluecopa-solution-id";
+function getCookieValue(name) {
+  try {
+    const cookie = document.cookie.split(";").map((c) => c.trim()).find((c) => c.startsWith(`${name}=`));
+    return cookie ? decodeURIComponent(cookie.split("=").slice(1).join("=")) : null;
+  } catch {
+    return null;
+  }
+}
+function getSolutionId() {
+  const config = getConfig();
+  if (config.solutionId) {
+    return validateIdentifier(config.solutionId, "solutionId");
+  }
+  const cookieValue = getCookieValue(SOLUTION_COOKIE_NAME);
+  if (cookieValue) {
+    return validateIdentifier(cookieValue, "solutionId (cookie)");
+  }
+  throw new InputTableError(
+    "[copaInputTableDb] No solutionId configured. Set via copaSetConfig({ solutionId }) or cookie.",
+    400
+  );
+}
+const _InputTableDBImpl = class _InputTableDBImpl {
+  constructor() {
+    this.schemaCache = /* @__PURE__ */ new Map();
+    this.schemaPending = /* @__PURE__ */ new Map();
+    this.wsWarned = false;
+    this.generation = 0;
+  }
+  setWebsocketProvider(provider) {
+    this.wsProvider = provider;
+  }
+  getProvider() {
+    return this.wsProvider ?? getConfig().websocketProvider;
   }
   collection(name) {
     const provider = this.getProvider();
@@ -13228,6 +14067,9 @@ const _InputTableDBImpl = class _InputTableDBImpl {
     );
     if (gen !== this.generation) throw new InputTableError("InputTableDB was destroyed", 410);
     const pkColumn = tableItem.appliedSchema.columns.find((c) => c.primary_key);
+    const schemaByName = new Map(
+      tables.map((t) => [t.name, t.appliedSchema ?? null])
+    );
     return new CollectionRefImpl(
       managed.collection,
       solutionId,
@@ -13235,7 +14077,9 @@ const _InputTableDBImpl = class _InputTableDBImpl {
       managed.primaryKeyField,
       pkColumn,
       managed.replication.state,
-      () => this.getProvider()
+      () => this.getProvider(),
+      tableItem.appliedSchema,
+      (name) => schemaByName.get(name) ?? null
     );
   }
   fetchTableList(solutionId) {
@@ -13297,6 +14141,11 @@ class LazyCollectionRef {
   skip(count) {
     return new LazyQueryBuilder(() => this.getRef().then((ref) => ref.skip(count)));
   }
+  expand(columnNames) {
+    return new LazyQueryBuilder(
+      () => this.getRef().then((ref) => ref.expand(columnNames))
+    );
+  }
   doc(id) {
     return new LazyDocRef(id, () => this.getRef().then((ref) => ref.doc(id)));
   }
@@ -13356,6 +14205,9 @@ class LazyQueryBuilder {
   skip(count) {
     return this.chain((qb) => qb.skip(count));
   }
+  expand(columnNames) {
+    return this.chain((qb) => qb.expand(columnNames));
+  }
   async resolveWithOps() {
     let qb = await this.resolveBase();
     for (const op of this.pendingOps) {