@fctc/interface-logic 4.3.1 → 4.3.3

package/dist/provider.js

@@ -2316,9 +2316,9 @@ function applyBinaryOp(ast, context) {
 var DICT = {
   get(...args) {
     const { key, defValue } = parseArgs(args, ["key", "defValue"]);
-    const self2 = this;
-    if (key in self2) {
-      return self2[key];
+    const self = this;
+    if (key in self) {
+      return self[key];
     } else if (defValue !== void 0) {
       return defValue;
     }
@@ -2922,6 +2922,13 @@ function cleanObject(obj) {
   }
   return result;
 }
+var extractIdFromDomain = (domain) => {
+  if (!domain || !Array.isArray(domain)) return null;
+  const idCond = domain.find(
+    ([field, operator]) => field === "id" && operator === "="
+  );
+  return idCond ? Number(idCond[2]) : null;
+};
 
 // src/utils/storage/local-storage.ts
 var localStorageUtils = () => {
@@ -5208,130 +5215,647 @@ var getASessionService = (env) => {
 
 // src/services/pos-service/add-entity.ts
 var import_react14 = require("react");
-var addEntityService = (env) => {
-  const addEntity = (0, import_react14.useCallback)(
-    ({
-      model,
-      values,
-      xNode,
-      service,
-      isCreateEndpoint = false
-    }) => {
-      const jsonData = {
-        model,
-        values
-      };
-      return env?.requests.post(
-        isCreateEndpoint ? "/create" /* CREATE_PATH */ : "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    addEntity
-  };
+
+// src/services/filesystem-service/file-service.ts
+var import_filesystem = require("@capacitor/filesystem");
+var fileService = {
+  read: async (path) => {
+    try {
+      const res = await import_filesystem.Filesystem.readFile({
+        path,
+        directory: import_filesystem.Directory.Data,
+        encoding: import_filesystem.Encoding.UTF8
+      });
+      if (typeof res.data === "string") return res.data;
+      if (res.data instanceof Blob) return await res.data.text();
+      return null;
+    } catch {
+      return null;
+    }
+  },
+  write: async (path, data) => {
+    await import_filesystem.Filesystem.writeFile({
+      path,
+      data,
+      directory: import_filesystem.Directory.Data,
+      encoding: import_filesystem.Encoding.UTF8,
+      recursive: true
+    });
+  },
+  writeAtomic: async (path, data) => {
+    const tempPath = path + ".tmp";
+    await import_filesystem.Filesystem.writeFile({
+      path: tempPath,
+      data,
+      directory: import_filesystem.Directory.Data,
+      encoding: import_filesystem.Encoding.UTF8,
+      recursive: true
+    });
+    try {
+      await import_filesystem.Filesystem.deleteFile({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+    } catch {
+    }
+    await import_filesystem.Filesystem.rename({
+      from: tempPath,
+      to: path,
+      directory: import_filesystem.Directory.Data
+    });
+  },
+  delete: async (path) => {
+    try {
+      await import_filesystem.Filesystem.deleteFile({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+    } catch {
+    }
+  },
+  exists: async (path) => {
+    try {
+      await import_filesystem.Filesystem.stat({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  mkdir: async (path) => {
+    try {
+      await import_filesystem.Filesystem.mkdir({
+        path,
+        directory: import_filesystem.Directory.Data,
+        recursive: true
+      });
+    } catch (e) {
+      if (!String(e?.message).includes("Exists")) {
+        throw e;
+      }
+    }
+  },
+  list: async (path) => {
+    return import_filesystem.Filesystem.readdir({
+      path,
+      directory: import_filesystem.Directory.Data
+    });
+  },
+  getUri: async (path) => {
+    return import_filesystem.Filesystem.getUri({
+      path,
+      directory: import_filesystem.Directory.Data
+    });
+  }
 };
 
-// src/services/pos-service/change-order-preparation-state.ts
-var import_react15 = require("react");
-var changOrderPreparationStateService = (env) => {
-  const changeOrderPreparationState = (0, import_react15.useCallback)(
-    ({
-      orderId,
-      stageId,
-      preparationDisplayId,
-      xNode,
-      service
-    }) => {
-      const jsonData = {
-        model: "pos_preparation_display.order" /* POS_PREPARATION_ORDER */,
-        method: "change_order_stage" /* CHANGE_ORDER_STAGE */,
-        ids: orderId,
-        kwargs: {
-          stage_id: stageId,
-          preparation_display_id: preparationDisplayId
+// src/services/filesystem-service/json-worker.ts
+function createWorkerBlob() {
+  const workerCode = `
+    self.addEventListener("message", async (ev) => {
+      const { id, cmd, payload } = ev.data;
+      try {
+        if (cmd === "parse") {
+          const parsed = JSON.parse(payload);
+          self.postMessage({ id, ok: true, result: parsed });
+        } else if (cmd === "stringify") {
+          const str = JSON.stringify(payload);
+          self.postMessage({ id, ok: true, result: str });
         }
-      };
-      return env?.requests.post(
-        "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    changeOrderPreparationState
-  };
-};
+      } catch (err) {
+        self.postMessage({ id, ok: false, error: err?.message || String(err) });
+      }
+    });
+  `;
+  const blob = new Blob([workerCode], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function spawnParseWorker(raw) {
+  return new Promise((resolve, reject) => {
+    const workerUrl = createWorkerBlob();
+    const worker = new Worker(workerUrl);
+    const id = Math.random().toString(36).slice(2);
+    worker.onmessage = (ev) => {
+      const { ok, result, error } = ev.data;
+      if (ok) {
+        resolve(result);
+      } else {
+        reject(new Error(error));
+      }
+      URL.revokeObjectURL(workerUrl);
+      worker.terminate();
+    };
+    worker.onerror = (err) => {
+      reject(err);
+      URL.revokeObjectURL(workerUrl);
+      worker.terminate();
+    };
+    worker.postMessage({ id, cmd: "parse", payload: raw });
+  });
+}
+function spawnStringifyWorker(obj) {
+  return new Promise((resolve, reject) => {
+    const workerUrl = createWorkerBlob();
+    const worker = new Worker(workerUrl);
+    worker.onmessage = (ev) => {
+      const { ok, result, error } = ev.data;
+      if (ok) resolve(result);
+      else reject(new Error(error));
+      URL.revokeObjectURL(workerUrl);
+      worker.terminate();
+    };
+    worker.onerror = (err) => {
+      reject(err);
+      URL.revokeObjectURL(workerUrl);
+      worker.terminate();
+    };
+    worker.postMessage({ cmd: "stringify", payload: obj });
+  });
+}
 
-// src/services/pos-service/check-payment.ts
-var import_react16 = require("react");
-var checkPaymentService = (env) => {
-  const checkPayment = (0, import_react16.useCallback)(
-    ({
-      model,
-      ids,
-      withContext,
-      xNode,
-      service
-    }) => {
-      const jsonData = {
-        model,
-        method: "check" /* CHECK */,
-        ids,
-        with_context: withContext
-      };
-      return env?.requests.post(
-        "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    checkPayment
-  };
-};
+// src/services/filesystem-service/manifest.ts
+var MANIFEST_PATH = "pos/manifest.json";
+var MANIFEST_BAK_PATH = "pos/manifest.bak.json";
+async function writeManifest(manifest) {
+  const oldRaw = await fileService.read(MANIFEST_PATH);
+  if (oldRaw !== null) {
+    await fileService.writeAtomic(MANIFEST_BAK_PATH, oldRaw);
+  }
+  await fileService.writeAtomic(MANIFEST_PATH, JSON.stringify(manifest));
+  try {
+    await fileService.delete(MANIFEST_BAK_PATH);
+  } catch {
+  }
+}
 
-// src/services/pos-service/create-e-invoice.ts
-var import_react17 = require("react");
-var createEInvoiceService = (env) => {
-  const createEInvoice = (0, import_react17.useCallback)(
-    async ({
-      service,
-      xNode,
-      kwargs,
-      ids,
-      withContext
-    }) => {
-      const body = {
-        model: "pos.order" /* POS_ORDER */,
-        method: "create_e_invoice" /* CREATE_E_INVOICE */,
-        kwargs,
-        ids,
-        with_context: withContext
+// src/services/filesystem-service/import-snapshot.ts
+var DATA_DIR = "pos";
+var MODELS_DIR = `${DATA_DIR}/models`;
+var MODELS_META_DIR = `${DATA_DIR}/models_meta`;
+var importSnapshot = async ({ data, onProgress }) => {
+  onProgress?.(1, "Parsing snapshot");
+  const parsed = await spawnParseWorker(data);
+  const modelNames = Object.keys(parsed);
+  const total = modelNames.length;
+  const manifest = { version: (/* @__PURE__ */ new Date()).toISOString(), models: {} };
+  const TMP_PREFIX = `pos/data/tmp_import_${Date.now()}`;
+  await fileService.writeAtomic(`${TMP_PREFIX}/.marker`, "1");
+  let i = 0;
+  for (const model of modelNames) {
+    i++;
+    onProgress?.(
+      Math.round(i / total * 100),
+      `Processing ${model} (${i}/${total})`
+    );
+    const block = parsed[model];
+    const dataPart = block?.data ?? block ?? [];
+    const fields = block?.fields ?? [];
+    const relations = block?.relations ?? {};
+    const serialized = await spawnStringifyWorker(dataPart);
+    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
+    await fileService.writeAtomic(tmpModelPath, serialized);
+    const meta = {
+      fields,
+      relations,
+      count: Array.isArray(dataPart) ? dataPart.length : 0,
+      writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
+    await fileService.writeAtomic(tmpMetaPath, JSON.stringify(meta));
+    manifest.models[model] = {
+      file: `${MODELS_DIR}/${encodeURIComponent(model)}.json`,
+      metaFile: `${MODELS_META_DIR}/${encodeURIComponent(model)}.meta.json`,
+      count: meta.count,
+      updatedAt: meta.writtenAt
+    };
+  }
+  onProgress?.(95, "Committing import (moving files)");
+  for (const model of modelNames) {
+    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
+    const finalModelPath = `${MODELS_DIR}/${encodeURIComponent(model)}.json`;
+    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
+    const finalMetaPath = `${MODELS_META_DIR}/${encodeURIComponent(
+      model
+    )}.meta.json`;
+    const tmpRaw = await fileService.read(tmpModelPath);
+    if (tmpRaw !== null) await fileService.writeAtomic(finalModelPath, tmpRaw);
+    const tmpMetaRaw = await fileService.read(tmpMetaPath);
+    if (tmpMetaRaw !== null)
+      await fileService.writeAtomic(finalMetaPath, tmpMetaRaw);
+    onProgress?.(
+      95 + Math.round(
+        (Object.keys(manifest.models).indexOf(model) + 1) / modelNames.length * 5
+      ),
+      `Committed ${model}`
+    );
+  }
+  await writeManifest(manifest);
+  try {
+    for (const model of modelNames) {
+      await fileService.delete(
+        `${TMP_PREFIX}/${encodeURIComponent(model)}.json`
+      );
+      await fileService.delete(
+        `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`
+      );
+    }
+    await fileService.delete(`${TMP_PREFIX}/.marker`);
+  } catch (e) {
+    console.log("Failed to cleanup tmp import files:", e);
+  }
+  onProgress?.(100, "Import complete");
+  return manifest;
+};
+var import_snapshot_default = importSnapshot;
+
+// src/services/filesystem-service/memory-cache.ts
+var MemoryCache = class {
+  map = /* @__PURE__ */ new Map();
+  get(k) {
+    const e = this.map.get(k);
+    if (!e) return null;
+    if (e.ttl && Date.now() - e.t > e.ttl) {
+      this.map.delete(k);
+      return null;
+    }
+    return e.value;
+  }
+  set(k, v, ttl = 5 * 60 * 1e3) {
+    this.map.set(k, { value: v, t: Date.now(), ttl });
+  }
+  del(k) {
+    this.map.delete(k);
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var memoryCache = new MemoryCache();
+
+// src/services/filesystem-service/model-loader.ts
+var MODELS_DIR2 = "pos/models";
+var MODELS_META_DIR2 = "pos/models_meta";
+async function loadModelData(modelName, includeMeta = true) {
+  const key = `model:${modelName}:meta:${includeMeta}`;
+  const cached = memoryCache.get(key);
+  if (cached) return cached;
+  const dataPath = `${MODELS_DIR2}/${encodeURIComponent(modelName)}.json`;
+  const metaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
+    modelName
+  )}.meta.json`;
+  const rawData = await fileService.read(dataPath);
+  if (!rawData) return null;
+  const parsedData = await spawnParseWorker(rawData);
+  const data = Array.isArray(parsedData) ? parsedData : [];
+  if (!includeMeta) {
+    const result2 = { data };
+    memoryCache.set(key, result2, 1e3 * 60 * 60);
+    return result2;
+  }
+  const rawMeta = await fileService.read(metaPath);
+  let fields = [];
+  let relations = {};
+  if (rawMeta) {
+    const parsedMeta = await spawnParseWorker(rawMeta);
+    fields = parsedMeta?.fields ?? [];
+    relations = parsedMeta?.relations ?? {};
+  }
+  const result = {
+    data,
+    fields,
+    relations
+  };
+  memoryCache.set(key, result, 1e3 * 60 * 60);
+  return result;
+}
+async function loadData(includeMeta = true) {
+  try {
+    const listResult = await fileService.list(MODELS_DIR2);
+    if (!listResult || !Array.isArray(listResult.files)) {
+      console.log("No models found");
+      return {};
+    }
+    const result = {};
+    for (const file of listResult.files) {
+      if (file.type !== "file") continue;
+      if (!file.name.endsWith(".json")) continue;
+      const fileName = file.name;
+      const modelName = fileName.replace(/\.json$/, "");
+      const dataPath = `${MODELS_DIR2}/${fileName}`;
+      const rawData = await fileService.read(dataPath);
+      if (!rawData) continue;
+      const parsedData = await spawnParseWorker(rawData);
+      const data = Array.isArray(parsedData) ? parsedData : [];
+      if (!includeMeta) {
+        result[modelName] = { data };
+        continue;
+      }
+      const metaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
+        modelName
+      )}.meta.json`;
+      const rawMeta = await fileService.read(metaPath);
+      let fields = [];
+      let relations = {};
+      if (rawMeta) {
+        const parsedMeta = await spawnParseWorker(rawMeta);
+        fields = parsedMeta?.fields ?? [];
+        relations = parsedMeta?.relations ?? {};
+      }
+      result[modelName] = {
+        data,
+        fields,
+        relations
+      };
+    }
+    return result;
+  } catch (error) {
+    console.error("Error loading data:", error);
+    throw error;
+  }
+}
+
+// src/services/filesystem-service/snapshot-helper.ts
+var createEmptySnapshot = () => {
+  return {
+    data: []
+  };
+};
+var generateNextId = (existingIds, startFrom = 1) => {
+  if (!existingIds || existingIds.length === 0) {
+    return startFrom;
+  }
+  const maxId = Math.max(...existingIds, startFrom - 1);
+  return maxId + 1;
+};
+var loadSnapshot = async ({
+  modelName
+}) => {
+  try {
+    const snapshot = await loadModelData(modelName);
+    if (!snapshot || typeof snapshot !== "object") {
+      console.warn("invalid snapshot, creating new one");
+      return createEmptySnapshot();
+    }
+    return {
+      data: Array.isArray(snapshot.data) ? snapshot.data : []
+    };
+  } catch (error) {
+    console.error("Failed to load snapshot:", error);
+    return createEmptySnapshot();
+  }
+};
+var getExistingIds = (snapshot) => {
+  return snapshot.data.map((order) => order.id).filter((id) => typeof id === "number");
+};
+var saveSnapshot = async ({
+  snapshot,
+  modelName
+}) => {
+  try {
+    await import_snapshot_default({
+      data: JSON.stringify({
+        [modelName]: snapshot
+      })
+    });
+    return true;
+  } catch (error) {
+    console.error("failed to save snapshot:", error);
+    return false;
+  }
+};
+
+// src/services/filesystem-service/model-repository.ts
+var ModelRepository = class {
+  getRecord = async ({
+    id,
+    modelName
+  }) => {
+    try {
+      const snapshot = await loadSnapshot({
+        modelName
+      });
+      return snapshot.data.find((record) => record.id === id) || null;
+    } catch (error) {
+      console.error("failed to get record:", error);
+      return null;
+    }
+  };
+  addRecord = async ({
+    newRecord,
+    modelName
+  }) => {
+    try {
+      const snapshot = await loadSnapshot({
+        modelName
+      });
+      const existingIds = getExistingIds(snapshot);
+      const newId = generateNextId(existingIds, snapshot.data.length);
+      snapshot.data.push({
+        ...newRecord,
+        id: newId
+      });
+      const saved = await saveSnapshot({
+        snapshot,
+        modelName
+      });
+      if (!saved) {
+        console.error("failed to add new record");
+        return [];
+      }
+      console.log(`\u2705 ${snapshot.data.length} records saved`);
+      return snapshot.data;
+    } catch (error) {
+      console.error("failed to add new record:", error);
+      return [];
+    }
+  };
+  updateRecord = async ({
+    id,
+    update,
+    modelName
+  }) => {
+    try {
+      const snapshot = await loadSnapshot({
+        modelName
+      });
+      const index = snapshot.data.findIndex((record) => record.id === id);
+      if (index === -1) {
+        console.error(`record with id ${id} not found`);
+        return false;
+      }
+      snapshot.data[index] = {
+        ...snapshot.data[index],
+        ...update
+      };
+      return await saveSnapshot({
+        snapshot,
+        modelName
+      });
+    } catch (error) {
+      console.error("error updating record:", error);
+      return false;
+    }
+  };
+  deleteRecord = async ({
+    id,
+    modelName
+  }) => {
+    try {
+      const snapshot = await loadSnapshot({
+        modelName
+      });
+      const before = snapshot.data.length;
+      snapshot.data = snapshot.data.filter((record) => record.id !== id);
+      if (snapshot.data.length === before) {
+        console.error(`record with id ${id} not found`);
+        return false;
+      }
+      return await saveSnapshot({
+        snapshot,
+        modelName
+      });
+    } catch (error) {
+      console.error("error deleting record:", error);
+      return false;
+    }
+  };
+};
+
+// src/services/pos-service/add-entity.ts
+var addEntityService = (env) => {
+  const isLocalMode = env?.isLocalMode;
+  const repo = new ModelRepository();
+  const addEntity = (0, import_react14.useCallback)(
+    ({
+      model,
+      values,
+      xNode,
+      service,
+      isCreateEndpoint = false
+    }) => {
+      if (isLocalMode) {
+        return repo.addRecord({
+          newRecord: values,
+          modelName: model
+        });
+      }
+      const jsonData = {
+        model,
+        values
+      };
+      return env?.requests.post(
+        isCreateEndpoint ? "/create" /* CREATE_PATH */ : "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env, isLocalMode]
+  );
+  return {
+    addEntity
+  };
+};
+
+// src/services/pos-service/change-order-preparation-state.ts
+var import_react15 = require("react");
+var changOrderPreparationStateService = (env) => {
+  const changeOrderPreparationState = (0, import_react15.useCallback)(
+    ({
+      orderId,
+      stageId,
+      preparationDisplayId,
+      xNode,
+      service
+    }) => {
+      const jsonData = {
+        model: "pos_preparation_display.order" /* POS_PREPARATION_ORDER */,
+        method: "change_order_stage" /* CHANGE_ORDER_STAGE */,
+        ids: orderId,
+        kwargs: {
+          stage_id: stageId,
+          preparation_display_id: preparationDisplayId
+        }
+      };
+      return env?.requests.post(
+        "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env]
+  );
+  return {
+    changeOrderPreparationState
+  };
+};
+
+// src/services/pos-service/check-payment.ts
+var import_react16 = require("react");
+var checkPaymentService = (env) => {
+  const checkPayment = (0, import_react16.useCallback)(
+    ({
+      model,
+      ids,
+      withContext,
+      xNode,
+      service
+    }) => {
+      const jsonData = {
+        model,
+        method: "check" /* CHECK */,
+        ids,
+        with_context: withContext
+      };
+      return env?.requests.post(
+        "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env]
+  );
+  return {
+    checkPayment
+  };
+};
+
+// src/services/pos-service/create-e-invoice.ts
+var import_react17 = require("react");
+var createEInvoiceService = (env) => {
+  const createEInvoice = (0, import_react17.useCallback)(
+    async ({
+      service,
+      xNode,
+      kwargs,
+      ids,
+      withContext
+    }) => {
+      const body = {
+        model: "pos.order" /* POS_ORDER */,
+        method: "create_e_invoice" /* CREATE_E_INVOICE */,
+        kwargs,
+        ids,
+        with_context: withContext
       };
       return env?.requests?.post(
         `${"/call" /* CALL_PATH */}`,
@@ -5355,6 +5879,8 @@ var createEInvoiceService = (env) => {
 // src/services/pos-service/create-entity.ts
 var import_react18 = require("react");
 var createEntityService = (env) => {
+  const isLocalMode = env?.isLocalMode;
+  const repo = new ModelRepository();
   const createEntity = (0, import_react18.useCallback)(
     ({
       model,
@@ -5362,6 +5888,12 @@ var createEntityService = (env) => {
       xNode,
       service
     }) => {
+      if (isLocalMode) {
+        return repo.addRecord({
+          newRecord: args,
+          modelName: model
+        });
+      }
       const jsonData = {
         model,
         method: "create" /* CREATE */,
@@ -5379,7 +5911,7 @@ var createEntityService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     createEntity
@@ -5464,6 +5996,8 @@ var createSessionService = (env) => {
 // src/services/pos-service/delete-entity.ts
 var import_react21 = require("react");
 var deleteEntityService = (env) => {
+  const isLocalMode = env?.isLocalMode;
+  const repo = new ModelRepository();
   const deleteEntity = (0, import_react21.useCallback)(
     ({
       model,
@@ -5472,6 +6006,14 @@ var deleteEntityService = (env) => {
       service,
       method
     }) => {
+      if (isLocalMode) {
+        const id = ids[0];
+        if (!id) return;
+        return repo.deleteRecord({
+          modelName: model,
+          id
+        });
+      }
       const jsonData = {
         model,
         ids,
@@ -5489,7 +6031,7 @@ var deleteEntityService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     deleteEntity
@@ -5822,341 +6364,111 @@ var handleCloseSessionService = (env) => {
   const handleCloseSession = (0, import_react30.useCallback)(
     ({
       model,
-      ids,
-      xNode,
-      service,
-      method
-    }) => {
-      const jsonData = {
-        model,
-        ids,
-        method
-      };
-      return env?.requests.post(
-        "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    handleCloseSession
-  };
-};
-
-// src/services/pos-service/handle-closing-detail-session.ts
-var import_react31 = require("react");
-var handleClosingDetailSessionService = (env) => {
-  const handleClosingDetailSession = (0, import_react31.useCallback)(
-    ({
-      model,
-      ids,
-      method,
-      xNode,
-      service,
-      kwargs
-    }) => {
-      const jsonData = {
-        model,
-        ids,
-        method,
-        kwargs
-      };
-      return env?.requests.post(
-        "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    handleClosingDetailSession
-  };
-};
-
-// src/services/pos-service/handle-closing-session.ts
-var import_react32 = require("react");
-var handleClosingSessionService = (env) => {
-  const handleClosingSession = (0, import_react32.useCallback)(
-    ({
-      model,
-      method,
-      ids,
-      kwargs,
-      xNode,
-      service
-    }) => {
-      const jsonData = {
-        model,
-        method,
-        ids,
-        kwargs
-      };
-      return env?.requests.post(
-        "/call" /* CALL_PATH */,
-        jsonData,
-        {
-          headers: {
-            "Content-Type": "application/json",
-            ...xNode ? { "X-Node": xNode } : {}
-          }
-        },
-        service
-      );
-    },
-    [env]
-  );
-  return {
-    handleClosingSession
-  };
-};
-
-// src/services/pos-service/load-data-pos-session.ts
-var import_react33 = require("react");
-
-// src/services/filesystem-service/file-service.ts
-var import_filesystem = require("@capacitor/filesystem");
-var fileService = {
-  async read(path) {
-    try {
-      const res = await import_filesystem.Filesystem.readFile({
-        path,
-        directory: import_filesystem.Directory.Data,
-        encoding: import_filesystem.Encoding.UTF8
-      });
-      if (typeof res.data === "string") return res.data;
-      if (res.data instanceof Blob) return await res.data.text();
-      return null;
-    } catch {
-      return null;
-    }
-  },
-  async write(path, data) {
-    await import_filesystem.Filesystem.writeFile({
-      path,
-      data,
-      directory: import_filesystem.Directory.Data,
-      encoding: import_filesystem.Encoding.UTF8,
-      recursive: true
-    });
-  },
-  async writeAtomic(path, data) {
-    const tempPath = path + ".tmp";
-    await import_filesystem.Filesystem.writeFile({
-      path: tempPath,
-      data,
-      directory: import_filesystem.Directory.Data,
-      encoding: import_filesystem.Encoding.UTF8,
-      recursive: true
-    });
-    try {
-      await import_filesystem.Filesystem.deleteFile({
-        path,
-        directory: import_filesystem.Directory.Data
-      });
-    } catch {
-    }
-    await import_filesystem.Filesystem.rename({
-      from: tempPath,
-      to: path,
-      directory: import_filesystem.Directory.Data
-    });
-  },
-  async delete(path) {
-    try {
-      await import_filesystem.Filesystem.deleteFile({
-        path,
-        directory: import_filesystem.Directory.Data
-      });
-    } catch {
-    }
-  },
-  async exists(path) {
-    try {
-      await import_filesystem.Filesystem.stat({
-        path,
-        directory: import_filesystem.Directory.Data
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  async mkdir(path) {
-    try {
-      await import_filesystem.Filesystem.mkdir({
-        path,
-        directory: import_filesystem.Directory.Data,
-        recursive: true
-      });
-    } catch (e) {
-      if (!String(e?.message).includes("Exists")) {
-        throw e;
-      }
-    }
-  },
-  async list(path) {
-    return import_filesystem.Filesystem.readdir({
-      path,
-      directory: import_filesystem.Directory.Data
-    });
-  },
-  async getUri(path) {
-    return import_filesystem.Filesystem.getUri({
-      path,
-      directory: import_filesystem.Directory.Data
-    });
-  }
-};
-
-// src/services/filesystem-service/json-worker.ts
-var import_meta = {};
-self.addEventListener("message", async (ev) => {
-  const { id, cmd, payload } = ev.data;
-  try {
-    if (cmd === "parse") {
-      const parsed = JSON.parse(payload);
-      self.postMessage({ id, ok: true, result: parsed });
-    } else if (cmd === "stringify") {
-      const str = JSON.stringify(payload);
-      self.postMessage({ id, ok: true, result: str });
-    }
-  } catch (err) {
-    self.postMessage({ id, ok: false, error: err?.message || String(err) });
-  }
-});
-function spawnParseWorker(raw) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(new URL("./json-worker.ts", import_meta.url), {
-      type: "module"
-    });
-    const id = Math.random().toString(36).slice(2);
-    worker.onmessage = (ev) => {
-      const { ok, result, error } = ev.data;
-      if (ok) {
-        resolve(result);
-      } else {
-        reject(new Error(error));
-      }
-      worker.terminate();
-    };
-    worker.postMessage({ id, cmd: "parse", payload: raw });
-  });
-}
-function spawnStringifyWorker(obj) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(new URL("./json-worker.ts", import_meta.url), {
-      type: "module"
-    });
-    worker.onmessage = (ev) => {
-      const { ok, result, error } = ev.data;
-      if (ok) resolve(result);
-      else reject(new Error(error));
-      worker.terminate();
-    };
-    worker.postMessage({ cmd: "stringify", payload: obj });
-  });
-}
+      ids,
+      xNode,
+      service,
+      method
+    }) => {
+      const jsonData = {
+        model,
+        ids,
+        method
+      };
+      return env?.requests.post(
+        "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env]
+  );
+  return {
+    handleCloseSession
+  };
+};
 
-// src/services/filesystem-service/memory-cache.ts
-var MemoryCache = class {
-  map = /* @__PURE__ */ new Map();
-  get(k) {
-    const e = this.map.get(k);
-    if (!e) return null;
-    if (e.ttl && Date.now() - e.t > e.ttl) {
-      this.map.delete(k);
-      return null;
-    }
-    return e.value;
-  }
-  set(k, v, ttl = 5 * 60 * 1e3) {
-    this.map.set(k, { value: v, t: Date.now(), ttl });
-  }
-  del(k) {
-    this.map.delete(k);
-  }
-  clear() {
-    this.map.clear();
-  }
+// src/services/pos-service/handle-closing-detail-session.ts
+var import_react31 = require("react");
+var handleClosingDetailSessionService = (env) => {
+  const handleClosingDetailSession = (0, import_react31.useCallback)(
+    ({
+      model,
+      ids,
+      method,
+      xNode,
+      service,
+      kwargs
+    }) => {
+      const jsonData = {
+        model,
+        ids,
+        method,
+        kwargs
+      };
+      return env?.requests.post(
+        "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env]
+  );
+  return {
+    handleClosingDetailSession
+  };
 };
-var memoryCache = new MemoryCache();
 
-// src/services/filesystem-service/model-loader.ts
-var MODELS_DIR = "pos/models";
-var MODELS_META_DIR = "pos/models_meta";
-async function loadData(includeMeta = true) {
-  console.log("\u{1F50D} loadData START");
-  try {
-    const listResult = await fileService.list(MODELS_DIR);
-    console.log("\u{1F4CB} listResult:", listResult);
-    if (!listResult || !Array.isArray(listResult.files)) {
-      console.log("\u26A0\uFE0F No files found");
-      return {};
-    }
-    const result = {};
-    for (const file of listResult.files) {
-      console.log("\u{1F4C4} Processing file:", file.name);
-      if (file.type !== "file") continue;
-      if (!file.name.endsWith(".json")) continue;
-      const fileName = file.name;
-      const modelName = fileName.replace(/\.json$/, "");
-      const dataPath = `${MODELS_DIR}/${fileName}`;
-      console.log("\u{1F4C2} Reading data from:", dataPath);
-      const rawData = await fileService.read(dataPath);
-      console.log("\u2705 Data read, length:", rawData?.length);
-      if (!rawData) continue;
-      console.log("\u{1F504} Parsing data...");
-      const parsedData = await spawnParseWorker(rawData);
-      console.log("\u2705 Data parsed");
-      const data = Array.isArray(parsedData) ? parsedData : [];
-      if (!includeMeta) {
-        result[modelName] = { data };
-        continue;
-      }
-      const metaPath = `${MODELS_META_DIR}/${encodeURIComponent(
-        modelName
-      )}.meta.json`;
-      console.log("\u{1F4C2} Reading meta from:", metaPath);
-      const rawMeta = await fileService.read(metaPath);
-      let fields = [];
-      let relations = {};
-      if (rawMeta) {
-        console.log("\u{1F504} Parsing meta...");
-        const parsedMeta = await spawnParseWorker(rawMeta);
-        fields = parsedMeta?.fields ?? [];
-        relations = parsedMeta?.relations ?? {};
-        console.log("\u2705 Meta parsed");
-      }
-      result[modelName] = {
-        data,
-        fields,
-        relations
+// src/services/pos-service/handle-closing-session.ts
+var import_react32 = require("react");
+var handleClosingSessionService = (env) => {
+  const handleClosingSession = (0, import_react32.useCallback)(
+    ({
+      model,
+      method,
+      ids,
+      kwargs,
+      xNode,
+      service
+    }) => {
+      const jsonData = {
+        model,
+        method,
+        ids,
+        kwargs
       };
-    }
-    console.log("\u2705 loadData COMPLETE:", Object.keys(result));
-    return result;
-  } catch (error) {
-    console.error("\u274C loadData ERROR:", error);
-    throw error;
-  }
-}
+      return env?.requests.post(
+        "/call" /* CALL_PATH */,
+        jsonData,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            ...xNode ? { "X-Node": xNode } : {}
+          }
+        },
+        service
+      );
+    },
+    [env]
+  );
+  return {
+    handleClosingSession
+  };
+};
 
 // src/services/pos-service/load-data-pos-session.ts
+var import_react33 = require("react");
 var loadDataPosSessionService = (env) => {
   const isLocalMode = env?.isLocalMode;
   const loadDataPosSession = (0, import_react33.useCallback)(
@@ -6169,10 +6481,8 @@ var loadDataPosSessionService = (env) => {
       modelsToLoad = [],
       searchParams
     }) => {
-      console.log("isLocalMode", isLocalMode);
       if (isLocalMode) {
         const data = await loadData();
-        console.log("\u2705 loadData resolved:", data);
         return data;
       }
       const jsonData = {
@@ -6426,6 +6736,8 @@ var updateClosedSessionService = (env) => {
 // src/services/pos-service/update-entity.ts
 var import_react40 = require("react");
 var updateEntityService = (env) => {
+  const isLocalMode = env?.isLocalMode;
+  const repo = new ModelRepository();
   const updateEntity = (0, import_react40.useCallback)(
     ({
       model,
@@ -6435,6 +6747,15 @@ var updateEntityService = (env) => {
       xNode,
       service
     }) => {
+      if (isLocalMode) {
+        const id = extractIdFromDomain(domain);
+        if (!id) return;
+        return repo.updateRecord({
+          update: values,
+          modelName: model,
+          id
+        });
+      }
       const jsonData = {
         model,
         domain,
@@ -6452,7 +6773,7 @@ var updateEntityService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     updateEntity
@@ -6534,101 +6855,6 @@ var usePosService = () => {
   return service;
 };
 
-// src/services/filesystem-service/manifest.ts
-var MANIFEST_PATH = "pos/manifest.json";
-var MANIFEST_BAK_PATH = "pos/manifest.bak.json";
-async function writeManifest(manifest) {
-  const oldRaw = await fileService.read(MANIFEST_PATH);
-  if (oldRaw !== null) {
-    await fileService.writeAtomic(MANIFEST_BAK_PATH, oldRaw);
-  }
-  await fileService.writeAtomic(MANIFEST_PATH, JSON.stringify(manifest));
-  try {
-    await fileService.delete(MANIFEST_BAK_PATH);
-  } catch {
-  }
-}
-
-// src/services/filesystem-service/import-snapshot.ts
-var DATA_DIR = "pos";
-var MODELS_DIR2 = `${DATA_DIR}/models`;
-var MODELS_META_DIR2 = `${DATA_DIR}/models_meta`;
-var importSnapshot = async ({ data, onProgress }) => {
-  onProgress?.(1, "Parsing snapshot");
-  const parsed = await spawnParseWorker(data);
-  const modelNames = Object.keys(parsed);
-  const total = modelNames.length;
-  const manifest = { version: (/* @__PURE__ */ new Date()).toISOString(), models: {} };
-  const TMP_PREFIX = `pos/data/tmp_import_${Date.now()}`;
-  await fileService.writeAtomic(`${TMP_PREFIX}/.marker`, "1");
-  let i = 0;
-  for (const model of modelNames) {
-    i++;
-    onProgress?.(
-      Math.round(i / total * 100),
-      `Processing ${model} (${i}/${total})`
-    );
-    const block = parsed[model];
-    const dataPart = block?.data ?? block ?? [];
-    const fields = block?.fields ?? [];
-    const relations = block?.relations ?? {};
-    const serialized = await spawnStringifyWorker(dataPart);
-    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
-    await fileService.writeAtomic(tmpModelPath, serialized);
-    const meta = {
-      fields,
-      relations,
-      count: Array.isArray(dataPart) ? dataPart.length : 0,
-      writtenAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
-    await fileService.writeAtomic(tmpMetaPath, JSON.stringify(meta));
-    manifest.models[model] = {
-      file: `${MODELS_DIR2}/${encodeURIComponent(model)}.json`,
-      metaFile: `${MODELS_META_DIR2}/${encodeURIComponent(model)}.meta.json`,
-      count: meta.count,
-      updatedAt: meta.writtenAt
-    };
-  }
-  onProgress?.(95, "Committing import (moving files)");
-  for (const model of modelNames) {
-    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
-    const finalModelPath = `${MODELS_DIR2}/${encodeURIComponent(model)}.json`;
-    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
-    const finalMetaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
-      model
-    )}.meta.json`;
-    const tmpRaw = await fileService.read(tmpModelPath);
-    if (tmpRaw !== null) await fileService.writeAtomic(finalModelPath, tmpRaw);
-    const tmpMetaRaw = await fileService.read(tmpMetaPath);
-    if (tmpMetaRaw !== null)
-      await fileService.writeAtomic(finalMetaPath, tmpMetaRaw);
-    onProgress?.(
-      95 + Math.round(
-        (Object.keys(manifest.models).indexOf(model) + 1) / modelNames.length * 5
-      ),
-      `Committed ${model}`
-    );
-  }
-  await writeManifest(manifest);
-  try {
-    for (const model of modelNames) {
-      await fileService.delete(
-        `${TMP_PREFIX}/${encodeURIComponent(model)}.json`
-      );
-      await fileService.delete(
-        `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`
-      );
-    }
-    await fileService.delete(`${TMP_PREFIX}/.marker`);
-  } catch (e) {
-    console.log("Failed to cleanup tmp import files:", e);
-  }
-  onProgress?.(100, "Import complete");
-  return manifest;
-};
-var import_snapshot_default = importSnapshot;
-
 // src/services/filesystem-service/init-snapshot.ts
 var isSnapshotReady = async () => {
   try {