@ai-matrx/media 0.8.0 → 0.9.1

package/dist/files/engine/redux/mutation-toast-middleware.js

@@ -0,0 +1,103 @@
+import { toast } from "../host/toast.js";
+const MUTATION_THUNK_NAMES = /* @__PURE__ */ new Set([
+  // files
+  "renameFile",
+  "moveFile",
+  "deleteFile",
+  "restoreFile",
+  "updateFileMetadata",
+  "restoreVersion",
+  // (uploadFiles is intentionally excluded — uploads surface per-file errors
+  //  inline in the UploadProgressList, so a toast would double up.)
+  // folders
+  "createFolder",
+  "updateFolder",
+  "deleteFolder",
+  "restoreFolder",
+  // bulk
+  "bulkDeleteFiles",
+  "bulkMoveFiles",
+  "bulkMoveFolders",
+  // permissions + sharing
+  "grantPermission",
+  "revokePermission",
+  "createShareLink",
+  "revokeShareLink",
+  // virtual sources (notes/code/etc. surfaced as files)
+  "renameAny",
+  "moveAny",
+  "deleteAny",
+  "writeAny"
+]);
+const TITLE = {
+  renameFile: "Couldn't rename",
+  renameAny: "Couldn't rename",
+  moveFile: "Couldn't move",
+  moveAny: "Couldn't move",
+  deleteFile: "Couldn't move to Trash",
+  deleteAny: "Couldn't move to Trash",
+  restoreFile: "Couldn't restore",
+  restoreFolder: "Couldn't restore folder",
+  updateFileMetadata: "Couldn't update file",
+  restoreVersion: "Couldn't restore that version",
+  uploadFiles: "Upload failed",
+  createFolder: "Couldn't create folder",
+  updateFolder: "Couldn't update folder",
+  deleteFolder: "Couldn't move folder to Trash",
+  bulkDeleteFiles: "Couldn't move some items to Trash",
+  bulkMoveFiles: "Couldn't move some items",
+  bulkMoveFolders: "Couldn't move some folders",
+  grantPermission: "Couldn't share",
+  revokePermission: "Couldn't update sharing",
+  createShareLink: "Couldn't create share link",
+  revokeShareLink: "Couldn't revoke share link",
+  writeAny: "Couldn't save"
+};
+function parseThunk(type, phase) {
+  const m = new RegExp(`^cloudFiles/([^/]+)/${phase}$`).exec(type);
+  return m ? m[1] : null;
+}
+const SUCCESS_TITLE = {
+  createShareLink: "Share link created",
+  revokeShareLink: "Share link revoked",
+  grantPermission: "Sharing updated",
+  revokePermission: "Sharing updated",
+  restoreVersion: "Version restored"
+};
+function messageFrom(action) {
+  if (typeof action.payload === "string" && action.payload.trim()) {
+    return action.payload.trim();
+  }
+  const msg = action.error?.message?.trim();
+  if (msg && msg.toLowerCase() !== "rejected") return msg;
+  return "Something went wrong.";
+}
+const cloudFilesMutationToastMiddleware = () => (next) => (action) => {
+  const result = next(action);
+  const a = action;
+  if (typeof a?.type !== "string") return result;
+  if (a.type.endsWith("/rejected")) {
+    const name = parseThunk(a.type, "rejected");
+    if (!name || !MUTATION_THUNK_NAMES.has(name)) return result;
+    if (a.meta?.aborted || a.meta?.condition) return result;
+    if (a.error?.name === "AbortError" || a.error?.name === "ConditionError") {
+      return result;
+    }
+    toast.error(TITLE[name] ?? "Something went wrong", {
+      description: messageFrom(a)
+    });
+    return result;
+  }
+  if (a.type.endsWith("/fulfilled")) {
+    const name = parseThunk(a.type, "fulfilled");
+    if (name && SUCCESS_TITLE[name]) {
+      toast.success(SUCCESS_TITLE[name]);
+    }
+    return result;
+  }
+  return result;
+};
+export {
+  cloudFilesMutationToastMiddleware
+};
+//# sourceMappingURL=mutation-toast-middleware.js.map

package/dist/files/engine/redux/mutation-toast-middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/redux/mutation-toast-middleware.ts"],"sourcesContent":["/**\n * features/files/redux/mutation-toast-middleware.ts\n *\n * Centralised user-facing error feedback for Cloud Files mutations (P0-4).\n *\n * Why this exists\n * ───────────────\n * Every file/folder mutation thunk already rolls back its optimistic update\n * and rethrows on failure — but the ~15 call sites (FileContextMenu,\n * BulkActionsBar, useFileActions, the canonical mutation hooks, …) `.unwrap()`\n * without a catch, so failures were SILENT: a rename that 403s just snapped\n * back with no explanation; a delete that failed left no trace. In an\n * enterprise file manager that is the single biggest \"feels broken\" driver.\n *\n * Rather than touch every call site (and every thunk's catch/finally shape),\n * we listen once, here, for the `<prefix>/rejected` action that RTK's\n * `createAsyncThunk` ALWAYS dispatches when a thunk throws — even when the\n * caller's `.unwrap()` rethrows. One middleware → 100% coverage, no thunk\n * edits, UI concern kept out of the thunk bodies.\n *\n * Reads (loadUserFileTree, loadPermissions, …) are intentionally excluded —\n * we only shout about MUTATIONS the user just attempted. Aborted/conditioned\n * dispatches (RTK `meta.aborted` / `meta.condition`) are skipped so a\n * superseded request never toasts.\n */\n\nimport type { Middleware } from \"@reduxjs/toolkit\";\nimport { toast } from \"../host/toast\";\n\n/**\n * Mutation thunk names (the segment between `cloudFiles/` and `/rejected`).\n * Keep in sync with features/files/redux/thunks.ts + virtual-thunks.ts. A\n * missing entry only means \"no toast for that op\" — never a crash.\n */\nconst MUTATION_THUNK_NAMES = new Set<string>([\n  // files\n  \"renameFile\",\n  \"moveFile\",\n  \"deleteFile\",\n  \"restoreFile\",\n  \"updateFileMetadata\",\n  \"restoreVersion\",\n  // (uploadFiles is intentionally excluded — uploads surface per-file errors\n  //  inline in the UploadProgressList, so a toast would double up.)\n  // folders\n  \"createFolder\",\n  \"updateFolder\",\n  \"deleteFolder\",\n  \"restoreFolder\",\n  // bulk\n  \"bulkDeleteFiles\",\n  \"bulkMoveFiles\",\n  \"bulkMoveFolders\",\n  // permissions + sharing\n  \"grantPermission\",\n  \"revokePermission\",\n  \"createShareLink\",\n  \"revokeShareLink\",\n  // virtual sources (notes/code/etc. surfaced as files)\n  \"renameAny\",\n  \"moveAny\",\n  \"deleteAny\",\n  \"writeAny\",\n]);\n\n/**\n * Toast title per thunk name. Phrased so it reads on its own; the specific\n * error goes in the toast description.\n */\nconst TITLE: Record<string, string> = {\n  renameFile: \"Couldn't rename\",\n  renameAny: \"Couldn't rename\",\n  moveFile: \"Couldn't move\",\n  moveAny: \"Couldn't move\",\n  deleteFile: \"Couldn't move to Trash\",\n  deleteAny: \"Couldn't move to Trash\",\n  restoreFile: \"Couldn't restore\",\n  restoreFolder: \"Couldn't restore folder\",\n  updateFileMetadata: \"Couldn't update file\",\n  restoreVersion: \"Couldn't restore that version\",\n  uploadFiles: \"Upload failed\",\n  createFolder: \"Couldn't create folder\",\n  updateFolder: \"Couldn't update folder\",\n  deleteFolder: \"Couldn't move folder to Trash\",\n  bulkDeleteFiles: \"Couldn't move some items to Trash\",\n  bulkMoveFiles: \"Couldn't move some items\",\n  bulkMoveFolders: \"Couldn't move some folders\",\n  grantPermission: \"Couldn't share\",\n  revokePermission: \"Couldn't update sharing\",\n  createShareLink: \"Couldn't create share link\",\n  revokeShareLink: \"Couldn't revoke share link\",\n  writeAny: \"Couldn't save\",\n};\n\ninterface RejectedAction {\n  type: string;\n  error?: { name?: string; message?: string };\n  meta?: { aborted?: boolean; condition?: boolean; rejectedWithValue?: boolean };\n  payload?: unknown;\n}\n\nfunction parseThunk(type: string, phase: \"rejected\" | \"fulfilled\"): string | null {\n  // `cloudFiles/renameFile/rejected` → `renameFile`\n  const m = new RegExp(`^cloudFiles/([^/]+)/${phase}$`).exec(type);\n  return m ? m[1] : null;\n}\n\n/**\n * P3-11: success toasts ONLY for actions whose result the user can't see\n * directly (a link/permission/version change has no visible row update).\n * Visible actions (rename shows the new name, move/delete change the list)\n * stay silent — a toast for those is noise.\n */\nconst SUCCESS_TITLE: Record<string, string> = {\n  createShareLink: \"Share link created\",\n  revokeShareLink: \"Share link revoked\",\n  grantPermission: \"Sharing updated\",\n  revokePermission: \"Sharing updated\",\n  restoreVersion: \"Version restored\",\n};\n\nfunction messageFrom(action: RejectedAction): string {\n  // Prefer a rejectWithValue string payload, then the serialized error.\n  if (typeof action.payload === \"string\" && action.payload.trim()) {\n    return action.payload.trim();\n  }\n  const msg = action.error?.message?.trim();\n  if (msg && msg.toLowerCase() !== \"rejected\") return msg;\n  return \"Something went wrong.\";\n}\n\nexport const cloudFilesMutationToastMiddleware: Middleware =\n  () => (next) => (action) => {\n    const result = next(action);\n\n    const a = action as RejectedAction;\n    if (typeof a?.type !== \"string\") return result;\n\n    if (a.type.endsWith(\"/rejected\")) {\n      const name = parseThunk(a.type, \"rejected\");\n      if (!name || !MUTATION_THUNK_NAMES.has(name)) return result;\n      // Skip superseded / conditioned dispatches — not real failures.\n      if (a.meta?.aborted || a.meta?.condition) return result;\n      if (a.error?.name === \"AbortError\" || a.error?.name === \"ConditionError\") {\n        return result;\n      }\n      toast.error(TITLE[name] ?? \"Something went wrong\", {\n        description: messageFrom(a),\n      });\n      return result;\n    }\n\n    if (a.type.endsWith(\"/fulfilled\")) {\n      const name = parseThunk(a.type, \"fulfilled\");\n      if (name && SUCCESS_TITLE[name]) {\n        toast.success(SUCCESS_TITLE[name]);\n      }\n      return result;\n    }\n\n    return result;\n  };\n"],"mappings":"AA2BA,SAAS,aAAa;AAOtB,MAAM,uBAAuB,oBAAI,IAAY;AAAA;AAAA,EAE3C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAMD,MAAM,QAAgC;AAAA,EACpC,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,UAAU;AAAA,EACV,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,aAAa;AAAA,EACb,eAAe;AAAA,EACf,oBAAoB;AAAA,EACpB,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,EAClB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,UAAU;AACZ;AASA,SAAS,WAAW,MAAc,OAAgD;AAEhF,QAAM,IAAI,IAAI,OAAO,uBAAuB,KAAK,GAAG,EAAE,KAAK,IAAI;AAC/D,SAAO,IAAI,EAAE,CAAC,IAAI;AACpB;AAQA,MAAM,gBAAwC;AAAA,EAC5C,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,EAClB,gBAAgB;AAClB;AAEA,SAAS,YAAY,QAAgC;AAEnD,MAAI,OAAO,OAAO,YAAY,YAAY,OAAO,QAAQ,KAAK,GAAG;AAC/D,WAAO,OAAO,QAAQ,KAAK;AAAA,EAC7B;AACA,QAAM,MAAM,OAAO,OAAO,SAAS,KAAK;AACxC,MAAI,OAAO,IAAI,YAAY,MAAM,WAAY,QAAO;AACpD,SAAO;AACT;AAEO,MAAM,oCACX,MAAM,CAAC,SAAS,CAAC,WAAW;AAC1B,QAAM,SAAS,KAAK,MAAM;AAE1B,QAAM,IAAI;AACV,MAAI,OAAO,GAAG,SAAS,SAAU,QAAO;AAExC,MAAI,EAAE,KAAK,SAAS,WAAW,GAAG;AAChC,UAAM,OAAO,WAAW,EAAE,MAAM,UAAU;AAC1C,QAAI,CAAC,QAAQ,CAAC,qBAAqB,IAAI,IAAI,EAAG,QAAO;AAErD,QAAI,EAAE,MAAM,WAAW,EAAE,MAAM,UAAW,QAAO;AACjD,QAAI,EAAE,OAAO,SAAS,gBAAgB,EAAE,OAAO,SAAS,kBAAkB;AACxE,aAAO;AAAA,IACT;AACA,UAAM,MAAM,MAAM,IAAI,KAAK,wBAAwB;AAAA,MACjD,aAAa,YAAY,CAAC;AAAA,IAC5B,CAAC;AACD,WAAO;AAAA,EACT;AAEA,MAAI,EAAE,KAAK,SAAS,YAAY,GAAG;AACjC,UAAM,OAAO,WAAW,EAAE,MAAM,WAAW;AAC3C,QAAI,QAAQ,cAAc,IAAI,GAAG;AAC/B,YAAM,QAAQ,cAAc,IAAI,CAAC;AAAA,IACnC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;","names":[]}

package/dist/files/engine/redux/realtime-middleware.d.ts

@@ -0,0 +1,61 @@
+/**
+ * features/files/redux/realtime-middleware.ts
+ *
+ * Bridges Supabase Realtime into Redux.
+ *
+ * LIFECYCLE
+ * ---------
+ *   - Dispatch `cloudFilesRealtime/attach` (from
+ *     CloudFilesRealtimeProvider on mount with a valid user id). Middleware
+ *     opens a channel and subscribes to cld_* table changes.
+ *   - Dispatch `cloudFilesRealtime/detach` on logout/unmount. Middleware tears
+ *     the channel down.
+ *   - On reconnect after error, middleware re-runs the tree RPC via
+ *     `reconcileTree` to close any event gap.
+ *
+ * DEDUP
+ * -----
+ *   Every REST write registers its `requestId` in
+ *   [request-ledger.ts](./request-ledger.ts). Incoming realtime payloads are
+ *   checked with `isOwnEcho`. Matches are skipped — the optimistic update
+ *   already reflects the change. Non-matches are dispatched normally, so
+ *   changes originating from other devices / the server / share-link
+ *   visitors always reach our state.
+ *
+ *   THAT LEDGER IS NOT A SECOND COPY OF THE PACKAGE'S. `@ai-matrx/realtime`'s
+ *   write ledger correlates on (table, id, updated_at, content fingerprint);
+ *   this one correlates on `metadata.request_id`, an end-to-end write id the
+ *   Python backend stamps on every cloud_sync write under a documented wire
+ *   contract (common-docs systems/files/file-service/WIRE_CONTRACT.md). That is
+ *   strictly more precise than a timestamp+fingerprint inference and the package
+ *   has no equivalent, so it stays — as the FEATURE's correlation, on top of
+ *   everything the package does. (A consumer-supplied own-write predicate is a
+ *   fair candidate for the package; until then this is the honest home.)
+ *
+ * REALTIME
+ * --------
+ *   `@ai-matrx/realtime` owns the channel: unique instance topic (this used a
+ *   STATIC `cloud-files:<userId>`, which React 19's double-invoked effects can
+ *   collide on), dedup, the decoupled ordered handler queue, jittered reconnect
+ *   with the stability reset, tab sleep and network awareness, diagnostics.
+ *
+ *   The reconcile that used to hang off the SUBSCRIBED callback is now the
+ *   package's `onBackfill` door, which is a strictly larger set of recovery
+ *   paths: it also fires on tab wake, network restore and queue overflow, none
+ *   of which the old status callback could see. Its cooldown and in-flight
+ *   guards are kept — they are about not storming an expensive tree RPC, which
+ *   is the feature's own economics, not reconnect logic.
+ */
+import type { Middleware } from "@reduxjs/toolkit";
+export declare const ATTACH_ACTION: "cloudFilesRealtime/attach";
+export declare const DETACH_ACTION: "cloudFilesRealtime/detach";
+export declare function attachCloudFilesRealtime(userId: string): {
+    readonly type: "cloudFilesRealtime/attach";
+    readonly payload: {
+        readonly userId: string;
+    };
+};
+export declare function detachCloudFilesRealtime(): {
+    readonly type: "cloudFilesRealtime/detach";
+};
+export declare const cloudFilesRealtimeMiddleware: Middleware;

package/dist/files/engine/redux/realtime-middleware.js

@@ -0,0 +1,431 @@
+"use client";
+import {
+  defineChannelNamespace,
+  subscribeToRealtimeManager
+} from "@ai-matrx/realtime";
+import {
+  canonicalShareLinkToCloudShareLink,
+  dbRowToCloudFile,
+  dbRowToCloudFilePermission,
+  dbRowToCloudFileVersion,
+  dbRowToCloudFolder
+} from "./converters.js";
+import { isOwnEcho, ledgerSize } from "./request-ledger.js";
+import { loadUserFileTree, reconcileTree } from "./thunks.js";
+import {
+  isDocumentHidden,
+  onceDocumentVisible
+} from "../support/document-visibility.js";
+import {
+  isUserVisibleFileRow,
+  isUserVisibleFolderPath
+} from "../utils/user-visible.js";
+import {
+  cachedVersion,
+  invalidate as invalidateBlobCache
+} from "../hooks/blob-cache.js";
+import { invalidateOfficeExtraction } from "../hooks/office-extraction-cache.js";
+import {
+  attachChildToFolder,
+  clearSelection,
+  detachChildFromFolder,
+  removeFile,
+  removeFolder,
+  removeShareLink,
+  setRealtimeStatus,
+  touchRealtime,
+  upsertFile,
+  upsertFolder,
+  upsertPermissionsForResource,
+  upsertShareLinksForResource,
+  upsertVersionsForFile
+} from "./slice.js";
+const ATTACH_ACTION = "cloudFilesRealtime/attach";
+const DETACH_ACTION = "cloudFilesRealtime/detach";
+function attachCloudFilesRealtime(userId) {
+  return { type: ATTACH_ACTION, payload: { userId } };
+}
+function detachCloudFilesRealtime() {
+  return { type: DETACH_ACTION };
+}
+function isAttachAction(a) {
+  return typeof a === "object" && a !== null && a.type === ATTACH_ACTION;
+}
+function isDetachAction(a) {
+  return typeof a === "object" && a !== null && a.type === DETACH_ACTION;
+}
+function extractRequestId(payload) {
+  const row = payload.new ?? payload.old;
+  if (!row) return null;
+  const meta = row.metadata;
+  if (meta && typeof meta.request_id === "string") {
+    return meta.request_id;
+  }
+  return null;
+}
+const RECONCILE_COOLDOWN_MS = 1e4;
+let lastReconcileAt = 0;
+let initialSnapshotDoneAt = null;
+const cloudFilesChannel = defineChannelNamespace({
+  namespace: "cloud-files",
+  parts: ["userId"],
+  description: "files.files / folders / file_versions + iam.permissions + platform.share_links for one user"
+});
+const cloudFilesRealtimeMiddleware = (store) => {
+  let stopChannel = null;
+  let subscribedUserId = null;
+  let cancelDeferredBackfill = null;
+  const dispatch = store.dispatch;
+  function teardown() {
+    cancelDeferredBackfill?.();
+    cancelDeferredBackfill = null;
+    if (stopChannel) {
+      stopChannel();
+      stopChannel = null;
+    }
+    subscribedUserId = null;
+    dispatch(setRealtimeStatus({ status: "detached", userId: null }));
+  }
+  function setup(userId) {
+    if (subscribedUserId === userId && stopChannel) return;
+    teardown();
+    subscribedUserId = userId;
+    initialSnapshotDoneAt = null;
+    dispatch(setRealtimeStatus({ status: "connecting", userId }));
+    const rowId = (row) => typeof row.id === "string" ? row.id : void 0;
+    stopChannel = subscribeToRealtimeManager(() => ({
+      topic: cloudFilesChannel.topic({ userId }),
+      postgresChanges: [
+        // Files — no server-side column filter (a created_by filter would drop
+        // updates to explicitly-shared files), BUT RLS alone is NOT the listing
+        // boundary: the `pub_read` policy makes every public file SELECT-visible,
+        // so handleFilePayload applies the LISTING gate client-side (owner or
+        // already-in-store only — mirror of DB `files.is_listable_for`). Never
+        // remove that gate; without it public files from other users stream
+        // into everyone's tree.
+        {
+          event: "*",
+          schema: "files",
+          table: "files",
+          rowId,
+          onChange: ({ payload }) => handleFilePayload(
+            payload
+          )
+        },
+        // Folders — NO owner filter, same RLS-bounded rationale as files.
+        {
+          event: "*",
+          schema: "files",
+          table: "folders",
+          rowId,
+          onChange: ({ payload }) => handleFolderPayload(
+            payload
+          )
+        },
+        // Versions — no owner filter (FK to files.files; RLS enforces).
+        {
+          event: "*",
+          schema: "files",
+          table: "file_versions",
+          rowId,
+          onChange: ({ payload }) => handleVersionPayload(
+            payload
+          )
+        },
+        // Permissions — canonical grant store `iam.permissions`. Filtered to
+        // grants made TO this user; the handler additionally guards
+        // `resource_type === 'file'` since this table holds grants for every
+        // resource type. (org-grant rows have no granted_to_user_id, so they
+        // won't arrive on this channel — the share panel reload picks them up.)
+        {
+          event: "*",
+          schema: "iam",
+          table: "permissions",
+          filter: `granted_to_user_id=eq.${userId}`,
+          rowId,
+          onChange: ({ payload }) => handlePermissionPayload(
+            payload
+          )
+        },
+        // Share links — canonical platform.share_links. RLS (owner-only
+        // SELECT) bounds delivery to links this user created. Requires the
+        // table in the realtime publication.
+        {
+          event: "*",
+          schema: "platform",
+          table: "share_links",
+          rowId,
+          onChange: ({ payload }) => handleShareLinkPayload(
+            payload
+          )
+        }
+      ],
+      onStatusChange: (status) => {
+        dispatch(
+          setRealtimeStatus({
+            status: status === "connected" ? "subscribed" : status === "connecting" ? "connecting" : "errored",
+            userId: subscribedUserId
+          })
+        );
+      },
+      // THE BACKFILL DOOR — reconnect, tab wake, network restore, queue
+      // overflow. The old code hung this off SUBSCRIBED only, so a slept tab
+      // never reconciled and the tree silently drifted.
+      //
+      // The cooldown and in-flight guards below are NOT reconnect logic (the
+      // package owns that): they exist so a flapping connection cannot storm an
+      // expensive tree RPC or revert optimistic edits mid-write. First
+      // subscribe reconciles ONLY if the initial snapshot already resolved —
+      // its data predates the live channel, which is the gap window; a snapshot
+      // still in flight reads post-subscribe state, so firing here would only
+      // duplicate the RPC it is racing.
+      onBackfill: () => {
+        if (isDocumentHidden()) {
+          if (!cancelDeferredBackfill) {
+            cancelDeferredBackfill = onceDocumentVisible(() => {
+              cancelDeferredBackfill = null;
+              backfill();
+            });
+          }
+          return;
+        }
+        backfill();
+      }
+    }));
+    function backfill() {
+      const now = Date.now();
+      if (initialSnapshotDoneAt !== null && now - lastReconcileAt >= RECONCILE_COOLDOWN_MS && ledgerSize() === 0) {
+        lastReconcileAt = now;
+        void dispatch(reconcileTree({ userId }));
+      }
+    }
+  }
+  function handleFilePayload(payload) {
+    dispatch(touchRealtime());
+    const requestId = extractRequestId(payload);
+    const rowId = payload.new?.id ?? payload.old?.id ?? null;
+    if (isOwnEcho({
+      requestId,
+      resourceId: rowId,
+      resourceType: "file"
+    })) {
+      return;
+    }
+    if (payload.eventType === "DELETE") {
+      if (rowId) {
+        dispatch(removeFile({ id: rowId }));
+        dispatch(clearSelection());
+      }
+      return;
+    }
+    const newRow = payload.new;
+    if (!newRow?.id) return;
+    if (!isUserVisibleFileRow(newRow)) return;
+    const alreadyInStore = Boolean(
+      store.getState().cloudFiles.filesById[newRow.id]
+    );
+    if (newRow.created_by !== subscribedUserId && !alreadyInStore) return;
+    const file = dbRowToCloudFile(newRow);
+    const oldParent = store.getState().cloudFiles.filesById[file.id]?.parentFolderId ?? null;
+    dispatch(upsertFile(file));
+    if (file.deletedAt) {
+      dispatch(removeFile({ id: file.id }));
+      return;
+    }
+    if (payload.eventType === "INSERT") {
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: file.parentFolderId,
+          kind: "file",
+          id: file.id
+        })
+      );
+    } else if (payload.eventType === "UPDATE") {
+      if (oldParent !== file.parentFolderId) {
+        dispatch(
+          detachChildFromFolder({
+            parentFolderId: oldParent,
+            kind: "file",
+            id: file.id
+          })
+        );
+        dispatch(
+          attachChildToFolder({
+            parentFolderId: file.parentFolderId,
+            kind: "file",
+            id: file.id
+          })
+        );
+      }
+    }
+  }
+  function handleFolderPayload(payload) {
+    dispatch(touchRealtime());
+    const requestId = extractRequestId(payload);
+    const rowId = payload.new?.id ?? payload.old?.id ?? null;
+    if (isOwnEcho({
+      requestId,
+      resourceId: rowId,
+      resourceType: "folder"
+    })) {
+      return;
+    }
+    if (payload.eventType === "DELETE") {
+      if (rowId) dispatch(removeFolder({ id: rowId }));
+      return;
+    }
+    const newRow = payload.new;
+    if (!newRow?.id) return;
+    if (!isUserVisibleFolderPath(newRow.folder_path)) return;
+    if (newRow.created_by !== subscribedUserId) return;
+    const folder = dbRowToCloudFolder(newRow);
+    const oldParent = store.getState().cloudFiles.foldersById[folder.id]?.parentId ?? null;
+    dispatch(upsertFolder(folder));
+    if (folder.deletedAt) {
+      dispatch(removeFolder({ id: folder.id }));
+      return;
+    }
+    if (payload.eventType === "INSERT") {
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: folder.parentId,
+          kind: "folder",
+          id: folder.id
+        })
+      );
+    } else if (payload.eventType === "UPDATE" && oldParent !== folder.parentId) {
+      dispatch(
+        detachChildFromFolder({
+          parentFolderId: oldParent,
+          kind: "folder",
+          id: folder.id
+        })
+      );
+      dispatch(
+        attachChildToFolder({
+          parentFolderId: folder.parentId,
+          kind: "folder",
+          id: folder.id
+        })
+      );
+    }
+  }
+  function handleVersionPayload(payload) {
+    dispatch(touchRealtime());
+    const newRow = payload.new;
+    const oldRow = payload.old;
+    const fileId = newRow?.file_id ?? oldRow?.file_id;
+    if (!fileId) return;
+    const state = store.getState();
+    const existing = state.cloudFiles.versionsByFileId[fileId] ?? [];
+    if (payload.eventType === "DELETE") {
+      const deletedId = oldRow?.id;
+      if (!deletedId) return;
+      dispatch(
+        upsertVersionsForFile({
+          fileId,
+          versions: existing.filter((v) => v.id !== deletedId)
+        })
+      );
+      return;
+    }
+    if (!newRow?.id) return;
+    const converted = dbRowToCloudFileVersion(newRow);
+    const next = [
+      converted,
+      ...existing.filter((v) => v.id !== converted.id)
+    ].sort((a, b) => b.versionNumber - a.versionNumber);
+    dispatch(upsertVersionsForFile({ fileId, versions: next }));
+    if (cachedVersion(fileId) === converted.versionNumber) return;
+    void invalidateBlobCache(fileId);
+    invalidateOfficeExtraction(fileId);
+  }
+  function handlePermissionPayload(payload) {
+    dispatch(touchRealtime());
+    const newRow = payload.new;
+    const oldRow = payload.old;
+    const resourceType = newRow?.resource_type ?? oldRow?.resource_type;
+    if (resourceType && resourceType !== "file") return;
+    const resourceId = newRow?.resource_id ?? oldRow?.resource_id;
+    if (!resourceId) return;
+    const state = store.getState();
+    const existing = state.cloudFiles.permissionsByResourceId[resourceId] ?? [];
+    if (payload.eventType === "DELETE") {
+      const deletedId = oldRow?.id;
+      if (!deletedId) return;
+      dispatch(
+        upsertPermissionsForResource({
+          resourceId,
+          permissions: existing.filter((p) => p.id !== deletedId)
+        })
+      );
+      return;
+    }
+    if (!newRow?.id) return;
+    const converted = dbRowToCloudFilePermission(newRow);
+    const next = [converted, ...existing.filter((p) => p.id !== converted.id)];
+    dispatch(upsertPermissionsForResource({ resourceId, permissions: next }));
+  }
+  function handleShareLinkPayload(payload) {
+    dispatch(touchRealtime());
+    const newRow = payload.new;
+    const oldRow = payload.old;
+    const resourceType = newRow?.resource_type ?? oldRow?.resource_type;
+    if (resourceType !== "file" && resourceType !== "folder") return;
+    const resourceId = newRow?.resource_id ?? oldRow?.resource_id;
+    if (!resourceId) return;
+    const state = store.getState();
+    const existing = state.cloudFiles.shareLinksByResourceId[resourceId] ?? [];
+    if (payload.eventType === "DELETE" || newRow?.is_active === false) {
+      const removedId = oldRow?.id ?? newRow?.id;
+      if (removedId) {
+        dispatch(removeShareLink({ linkId: removedId }));
+      }
+      return;
+    }
+    if (!newRow?.id || !newRow.token) return;
+    const converted = canonicalShareLinkToCloudShareLink(
+      {
+        id: newRow.id,
+        token: newRow.token,
+        shortToken: newRow.short_token ?? null,
+        permissionLevel: newRow.permission_level ?? "viewer",
+        label: newRow.label ?? null,
+        expiresAt: newRow.expires_at ?? null,
+        maxUses: newRow.max_uses ?? null,
+        useCount: newRow.use_count ?? 0,
+        isActive: newRow.is_active ?? true,
+        createdAt: newRow.created_at ?? null,
+        lastUsedAt: newRow.last_used_at ?? null
+      },
+      resourceType,
+      resourceId
+    );
+    const next = [converted, ...existing.filter((l) => l.id !== converted.id)];
+    dispatch(upsertShareLinksForResource({ resourceId, shareLinks: next }));
+  }
+  return (next) => (action) => {
+    if (loadUserFileTree.fulfilled.match(action)) {
+      initialSnapshotDoneAt = Date.now();
+      return next(action);
+    }
+    if (isAttachAction(action)) {
+      const userId = action.payload.userId;
+      setup(userId);
+      return next(action);
+    }
+    if (isDetachAction(action)) {
+      teardown();
+      return next(action);
+    }
+    return next(action);
+  };
+};
+export {
+  ATTACH_ACTION,
+  DETACH_ACTION,
+  attachCloudFilesRealtime,
+  cloudFilesRealtimeMiddleware,
+  detachCloudFilesRealtime
+};
+//# sourceMappingURL=realtime-middleware.js.map