@ai-matrx/media 0.8.0 → 0.9.1

package/dist/files/engine/filesDb.js

@@ -0,0 +1,28 @@
+function filesDb(client) {
+  return client.schema("files");
+}
+const FILES_TABLE_COLUMNS = "id, created_by, updated_by, version, file_path, file_name, mime_type, size_bytes, checksum, visibility, current_version, parent_folder_id, metadata, created_at, updated_at, deleted_at, organization_id, parent_file_id, derivation_kind, derivation_metadata, duplicate_of_file_id, canonical_processed_document_id, width, height, duration_ms, origin_device_id, artifact_kind";
+const FILE_VERSIONS_TABLE_COLUMNS = "id, file_id, version_number, size_bytes, checksum, created_by, created_at, change_summary, organization_id, metadata";
+async function readFileRowById(client, fileId) {
+  const { data, error } = await filesDb(client).from("files").select(FILES_TABLE_COLUMNS).eq("id", fileId).is("deleted_at", null).maybeSingle();
+  if (error) throw error;
+  return data;
+}
+async function readFileSizesByIds(client, fileIds) {
+  const out = /* @__PURE__ */ new Map();
+  if (fileIds.length === 0) return out;
+  const { data, error } = await filesDb(client).from("files").select("id, size_bytes").in("id", fileIds).is("deleted_at", null);
+  if (error) throw error;
+  for (const row of data ?? []) {
+    out.set(row.id, row.size_bytes ?? null);
+  }
+  return out;
+}
+export {
+  FILES_TABLE_COLUMNS,
+  FILE_VERSIONS_TABLE_COLUMNS,
+  filesDb,
+  readFileRowById,
+  readFileSizesByIds
+};
+//# sourceMappingURL=filesDb.js.map

package/dist/files/engine/filesDb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/files/engine/filesDb.ts"],"sourcesContent":["/**\n * features/files/filesDb.ts\n *\n * The cloud-files tables live in the dedicated `files` Postgres schema (moved\n * out of `public` in the 2026 DB restructure; the `cld_` prefix was dropped).\n * supabase-js reaches a non-public schema via `.schema(...)`, so every table\n * read/write for these tables must go through `client.schema('files')`.\n *\n * Use this helper instead of inlining `.schema('files')` everywhere:\n *\n *   const db = filesDb(supabase);\n *   const { data } = await db.from('files').select(FILES_TABLE_COLUMNS);\n *   await db.from('folders').upsert(...);                  // files.folders\n *\n * NEVER `select('*')` on `files.files` / `files.file_versions` — the\n * server-only `storage_uri` column grant is REVOKEd and `*` errors.\n *\n * Works with the browser client, the SSR server client, and the admin client —\n * they all expose `.schema()`.\n *\n * NOTE: file-permission grants are NOT in this schema — they live in the\n * canonical `iam.permissions` store (resource_type='file'/'folder'). Reach\n * those via `iamDb(supabase).rpc('fn_list_resource_permissions', ...)` (see\n * utils/supabase/iamDb.ts) — list/grant/revoke are admin-gated inside the\n * RPC (iam.has_access), never a plain `.from('permissions')` select.\n */\nimport type { SupabaseClient } from \"@supabase/supabase-js\";\nimport type { Database } from \"./db-types\";\n\n/** A supabase client scoped to the `files` schema. */\nexport function filesDb<C extends SupabaseClient<Database>>(client: C) {\n  return client.schema(\"files\");\n}\n\n/**\n * The ONLY legal column list for reading `files.files` from the client.\n *\n * `storage_uri` (the native S3 location) is server-only: the column grant is\n * REVOKEd from `authenticated`, so `select(\"*\")` on `files.files` ERRORS with\n * \"permission denied for column storage_uri\". Never select `*` on this table\n * and never add `storage_uri` here. Renderable URLs come from the server's\n * FileRecord/FileRef URL contract (`url` / `cdn_url` / `download_url`),\n * never assembled client-side from a storage location.\n */\nexport const FILES_TABLE_COLUMNS =\n  \"id, created_by, updated_by, version, file_path, file_name, mime_type, size_bytes, checksum, visibility, current_version, parent_folder_id, metadata, created_at, updated_at, deleted_at, organization_id, parent_file_id, derivation_kind, derivation_metadata, duplicate_of_file_id, canonical_processed_document_id, width, height, duration_ms, origin_device_id, artifact_kind\";\n\n/**\n * Same rule for `files.file_versions` — its `storage_uri` is server-only.\n * Version bytes download via the server (`/files/{id}/versions/{n}/download`).\n */\nexport const FILE_VERSIONS_TABLE_COLUMNS =\n  \"id, file_id, version_number, size_bytes, checksum, created_by, created_at, change_summary, organization_id, metadata\";\n\n/**\n * Read one complete, RLS-authorized file row by durable identity.\n *\n * REST `FileRecord` is a render/navigation envelope and historically omitted\n * the owning organization. Mutation preparation must use this canonical DB\n * row so a path-targeted version write can preserve ownership exactly.\n */\nexport async function readFileRowById<C extends SupabaseClient<Database>>(\n  client: C,\n  fileId: string,\n) {\n  const { data, error } = await filesDb(client)\n    .from(\"files\")\n    .select(FILES_TABLE_COLUMNS)\n    .eq(\"id\", fileId)\n    .is(\"deleted_at\", null)\n    .maybeSingle();\n  if (error) throw error;\n  return data;\n}\n\n/**\n * Batch-read just the byte size for a set of file ids, RLS-authorized like\n * every other read here.\n *\n * Built for a source list that names files by id (a Rulebook's attached\n * sources, a resource pile) and needs to show — before any run touches\n * them — which of those files are genuinely empty. `size_bytes` alone (no\n * `storage_uri`, no need for the single-row reader's full column list) keeps\n * this cheap enough to call for a whole pile at once.\n */\nexport async function readFileSizesByIds<C extends SupabaseClient<Database>>(\n  client: C,\n  fileIds: string[],\n): Promise<Map<string, number | null>> {\n  const out = new Map<string, number | null>();\n  if (fileIds.length === 0) return out;\n  const { data, error } = await filesDb(client)\n    .from(\"files\")\n    .select(\"id, size_bytes\")\n    .in(\"id\", fileIds)\n    .is(\"deleted_at\", null);\n  if (error) throw error;\n  for (const row of data ?? []) {\n    out.set(row.id, row.size_bytes ?? null);\n  }\n  return out;\n}\n"],"mappings":"AA8BO,SAAS,QAA4C,QAAW;AACrE,SAAO,OAAO,OAAO,OAAO;AAC9B;AAYO,MAAM,sBACX;AAMK,MAAM,8BACX;AASF,eAAsB,gBACpB,QACA,QACA;AACA,QAAM,EAAE,MAAM,MAAM,IAAI,MAAM,QAAQ,MAAM,EACzC,KAAK,OAAO,EACZ,OAAO,mBAAmB,EAC1B,GAAG,MAAM,MAAM,EACf,GAAG,cAAc,IAAI,EACrB,YAAY;AACf,MAAI,MAAO,OAAM;AACjB,SAAO;AACT;AAYA,eAAsB,mBACpB,QACA,SACqC;AACrC,QAAM,MAAM,oBAAI,IAA2B;AAC3C,MAAI,QAAQ,WAAW,EAAG,QAAO;AACjC,QAAM,EAAE,MAAM,MAAM,IAAI,MAAM,QAAQ,MAAM,EACzC,KAAK,OAAO,EACZ,OAAO,gBAAgB,EACvB,GAAG,MAAM,OAAO,EAChB,GAAG,cAAc,IAAI;AACxB,MAAI,MAAO,OAAM;AACjB,aAAW,OAAO,QAAQ,CAAC,GAAG;AAC5B,QAAI,IAAI,IAAI,IAAI,IAAI,cAAc,IAAI;AAAA,EACxC;AACA,SAAO;AACT;","names":[]}

package/dist/files/engine/handler/handler.d.ts

@@ -0,0 +1,82 @@
+/**
+ * features/files/handler/handler.ts
+ *
+ * The single public entry point. Every callsite that touches a file —
+ * components, thunks, server routes, agent prep — uses one of these
+ * three primitives. Direct construction of media blocks, direct calls
+ * to direct object-store SDKs, and uploads through `useFileUpload` are
+ * all banned (see `.eslintrc`).
+ *
+ *   fileHandler.use(source).as(target)         — read path
+ *   fileHandler.upload(source, opts)           — write path
+ *   fileHandler.refresh(file)                  — repair path
+ */
+import type { EnsureFolderPathArg } from "../types.js";
+import type { FileSource, FileTarget, NormalizedFile, RenderedFor, UploadedNormalizedFile, UploadOpts } from "./types.js";
+declare class HandlerHandle {
+    private file;
+    constructor(file: NormalizedFile);
+    as<T extends FileTarget>(target: T): Promise<RenderedFor<T>>;
+    resolve(): Promise<NormalizedFile>;
+}
+export declare const fileHandler: {
+    /**
+     * Start a chain. The chain is sync up until you call `as(...)`, which
+     * resolves and renders for the chosen target.
+     *
+     *   const url = await fileHandler.use({ kind: "file_id", fileId }).as({ kind: "html_src" });
+     */
+    use(source: FileSource): HandlerHandle;
+    /**
+     * One-shot resolve when you don't have a target yet (e.g. you want to
+     * inspect capabilities before deciding what to do).
+     */
+    resolve(source: FileSource): Promise<NormalizedFile>;
+    /**
+     * One-shot upload. Resolves to a fully-hydrated NormalizedFile pointing
+     * at the freshly-created cld_files row.
+     */
+    upload(source: FileSource, opts?: UploadOpts): Promise<UploadedNormalizedFile>;
+    /**
+     * Re-resolve a file after a DB event (visibility change, share
+     * revocation) so origin/capabilities and the bound URL are current.
+     */
+    refresh(file: NormalizedFile): Promise<NormalizedFile>;
+    /**
+     * Convenience: skip straight to a media block (the most common use).
+     */
+    toMediaBlock(source: FileSource): Promise<import("./types.js").MediaBlock>;
+    /**
+     * Convenience: skip straight to a MediaRef (for outbound APIs that
+     * already accept MediaRef directly).
+     */
+    toMediaRef(source: FileSource): Promise<import("../types.js").MediaRef>;
+    /**
+     * Convenience: skip straight to a persisted JSONB content part for
+     * `cx_message.content[]`.
+     */
+    toContentPart(source: FileSource): Promise<import("@ai-matrx/agents/generated/stream-events").MessagePart>;
+    /**
+     * Imperatively move a file to Trash (soft delete — restorable; there is
+     * no hard delete). Routes through the
+     * `deleteFile` thunk against the store singleton so the slice and
+     * realtime channel stay in sync — identical to `useFileMutation().remove()`.
+     *
+     * For service-layer and non-React callers (e.g. cleanup after a failed
+     * upload). React components should prefer `useFileMutation` so they get
+     * hook-lifecycle guarantees.
+     */
+    remove(fileId: string): Promise<void>;
+    /**
+     * Idempotently create (or look up) a folder path like `"Images/Crops"`,
+     * walking each segment and creating any that are missing. Returns the
+     * leaf folder id.
+     *
+     * Non-React entry point — for services and thunks that need to stage
+     * an upload destination without owning a React hook. Routes through
+     * the `ensureFolderPath` thunk against the store singleton, so realtime
+     * channel updates land in the slice the same way.
+     */
+    ensureFolderPath(arg: EnsureFolderPathArg): Promise<string>;
+};
+export type { FileSource, FileTarget, NormalizedFile, UploadedNormalizedFile, UploadOpts, } from "./types.js";

package/dist/files/engine/handler/handler.js

@@ -0,0 +1,124 @@
+import { uploadInternal } from "./upload.js";
+import { normalize } from "./input/normalize.js";
+import { resolve as resolveImpl } from "./resolver.js";
+import { toTarget } from "./output/target.js";
+import { getStoreSingleton } from "../host/store.js";
+import {
+  deleteFile as deleteFileThunk,
+  ensureFolderPath as ensureFolderPathThunk
+} from "../redux/thunks.js";
+class HandlerHandle {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  async as(target) {
+    const resolved = await resolveImpl(this.file, {
+      needsUrl: targetNeedsUrl(target.kind),
+      sniffMime: target.kind === "media_block"
+    });
+    return toTarget(resolved, target);
+  }
+  async resolve() {
+    return resolveImpl(this.file);
+  }
+}
+function targetNeedsUrl(kind) {
+  return kind !== "media_block" && kind !== "media_ref";
+}
+const fileHandler = {
+  /**
+   * Start a chain. The chain is sync up until you call `as(...)`, which
+   * resolves and renders for the chosen target.
+   *
+   *   const url = await fileHandler.use({ kind: "file_id", fileId }).as({ kind: "html_src" });
+   */
+  use(source) {
+    return new HandlerHandle(normalize(source));
+  },
+  /**
+   * One-shot resolve when you don't have a target yet (e.g. you want to
+   * inspect capabilities before deciding what to do).
+   */
+  async resolve(source) {
+    return resolveImpl(normalize(source));
+  },
+  /**
+   * One-shot upload. Resolves to a fully-hydrated NormalizedFile pointing
+   * at the freshly-created cld_files row.
+   */
+  async upload(source, opts = {}) {
+    return uploadInternal(source, opts);
+  },
+  /**
+   * Re-resolve a file after a DB event (visibility change, share
+   * revocation) so origin/capabilities and the bound URL are current.
+   */
+  async refresh(file) {
+    return resolveImpl(file, { needsUrl: true });
+  },
+  /**
+   * Convenience: skip straight to a media block (the most common use).
+   */
+  async toMediaBlock(source) {
+    return this.use(source).as({ kind: "media_block" });
+  },
+  /**
+   * Convenience: skip straight to a MediaRef (for outbound APIs that
+   * already accept MediaRef directly).
+   */
+  async toMediaRef(source) {
+    return this.use(source).as({ kind: "media_ref" });
+  },
+  /**
+   * Convenience: skip straight to a persisted JSONB content part for
+   * `cx_message.content[]`.
+   */
+  async toContentPart(source) {
+    return this.use(source).as({ kind: "jsonb_content_part" });
+  },
+  /**
+   * Imperatively move a file to Trash (soft delete — restorable; there is
+   * no hard delete). Routes through the
+   * `deleteFile` thunk against the store singleton so the slice and
+   * realtime channel stay in sync — identical to `useFileMutation().remove()`.
+   *
+   * For service-layer and non-React callers (e.g. cleanup after a failed
+   * upload). React components should prefer `useFileMutation` so they get
+   * hook-lifecycle guarantees.
+   */
+  async remove(fileId) {
+    const store = getStoreSingleton();
+    if (!store) {
+      throw new Error(
+        "fileHandler.remove called before the Redux store was ready."
+      );
+    }
+    const dispatch = store.dispatch;
+    await dispatch(deleteFileThunk({ fileId })).unwrap();
+  },
+  /**
+   * Idempotently create (or look up) a folder path like `"Images/Crops"`,
+   * walking each segment and creating any that are missing. Returns the
+   * leaf folder id.
+   *
+   * Non-React entry point — for services and thunks that need to stage
+   * an upload destination without owning a React hook. Routes through
+   * the `ensureFolderPath` thunk against the store singleton, so realtime
+   * channel updates land in the slice the same way.
+   */
+  async ensureFolderPath(arg) {
+    const store = getStoreSingleton();
+    if (!store) {
+      throw new Error(
+        "fileHandler.ensureFolderPath called before the Redux store was ready."
+      );
+    }
+    const dispatch = store.dispatch;
+    return await dispatch(ensureFolderPathThunk(arg)).unwrap();
+  }
+};
+export {
+  fileHandler
+};
+//# sourceMappingURL=handler.js.map

package/dist/files/engine/handler/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/handler/handler.ts"],"sourcesContent":["/**\n * features/files/handler/handler.ts\n *\n * The single public entry point. Every callsite that touches a file —\n * components, thunks, server routes, agent prep — uses one of these\n * three primitives. Direct construction of media blocks, direct calls\n * to direct object-store SDKs, and uploads through `useFileUpload` are\n * all banned (see `.eslintrc`).\n *\n *   fileHandler.use(source).as(target)         — read path\n *   fileHandler.upload(source, opts)           — write path\n *   fileHandler.refresh(file)                  — repair path\n */\n\nimport { uploadInternal } from \"./upload\";\nimport { normalize } from \"./input/normalize\";\nimport { resolve as resolveImpl } from \"./resolver\";\nimport { toTarget } from \"./output/target\";\nimport { getStoreSingleton } from \"../host/store\";\nimport {\n  deleteFile as deleteFileThunk,\n  ensureFolderPath as ensureFolderPathThunk,\n} from \"../redux/thunks\";\nimport type { EnsureFolderPathArg } from \"../types\";\nimport type { AppDispatch } from \"../host/store\";\nimport type {\n  FileSource,\n  FileTarget,\n  NormalizedFile,\n  RenderedFor,\n  UploadedNormalizedFile,\n  UploadOpts,\n} from \"./types\";\n\nclass HandlerHandle {\n  constructor(private file: NormalizedFile) {}\n\n  async as<T extends FileTarget>(target: T): Promise<RenderedFor<T>> {\n    const resolved = await resolveImpl(this.file, {\n      needsUrl: targetNeedsUrl(target.kind),\n      sniffMime: target.kind === \"media_block\",\n    });\n    return toTarget(resolved, target);\n  }\n\n  async resolve(): Promise<NormalizedFile> {\n    return resolveImpl(this.file);\n  }\n}\n\nfunction targetNeedsUrl(kind: FileTarget[\"kind\"]): boolean {\n  return kind !== \"media_block\" && kind !== \"media_ref\";\n}\n\nexport const fileHandler = {\n  /**\n   * Start a chain. The chain is sync up until you call `as(...)`, which\n   * resolves and renders for the chosen target.\n   *\n   *   const url = await fileHandler.use({ kind: \"file_id\", fileId }).as({ kind: \"html_src\" });\n   */\n  use(source: FileSource): HandlerHandle {\n    return new HandlerHandle(normalize(source));\n  },\n\n  /**\n   * One-shot resolve when you don't have a target yet (e.g. you want to\n   * inspect capabilities before deciding what to do).\n   */\n  async resolve(source: FileSource): Promise<NormalizedFile> {\n    return resolveImpl(normalize(source));\n  },\n\n  /**\n   * One-shot upload. Resolves to a fully-hydrated NormalizedFile pointing\n   * at the freshly-created cld_files row.\n   */\n  async upload(\n    source: FileSource,\n    opts: UploadOpts = {},\n  ): Promise<UploadedNormalizedFile> {\n    return uploadInternal(source, opts);\n  },\n\n  /**\n   * Re-resolve a file after a DB event (visibility change, share\n   * revocation) so origin/capabilities and the bound URL are current.\n   */\n  async refresh(file: NormalizedFile): Promise<NormalizedFile> {\n    return resolveImpl(file, { needsUrl: true });\n  },\n\n  /**\n   * Convenience: skip straight to a media block (the most common use).\n   */\n  async toMediaBlock(source: FileSource) {\n    return this.use(source).as({ kind: \"media_block\" });\n  },\n\n  /**\n   * Convenience: skip straight to a MediaRef (for outbound APIs that\n   * already accept MediaRef directly).\n   */\n  async toMediaRef(source: FileSource) {\n    return this.use(source).as({ kind: \"media_ref\" });\n  },\n\n  /**\n   * Convenience: skip straight to a persisted JSONB content part for\n   * `cx_message.content[]`.\n   */\n  async toContentPart(source: FileSource) {\n    return this.use(source).as({ kind: \"jsonb_content_part\" });\n  },\n\n  /**\n   * Imperatively move a file to Trash (soft delete — restorable; there is\n   * no hard delete). Routes through the\n   * `deleteFile` thunk against the store singleton so the slice and\n   * realtime channel stay in sync — identical to `useFileMutation().remove()`.\n   *\n   * For service-layer and non-React callers (e.g. cleanup after a failed\n   * upload). React components should prefer `useFileMutation` so they get\n   * hook-lifecycle guarantees.\n   */\n  async remove(fileId: string): Promise<void> {\n    const store = getStoreSingleton();\n    if (!store) {\n      throw new Error(\n        \"fileHandler.remove called before the Redux store was ready.\",\n      );\n    }\n    const dispatch = store.dispatch as AppDispatch;\n    await dispatch(deleteFileThunk({ fileId })).unwrap();\n  },\n\n  /**\n   * Idempotently create (or look up) a folder path like `\"Images/Crops\"`,\n   * walking each segment and creating any that are missing. Returns the\n   * leaf folder id.\n   *\n   * Non-React entry point — for services and thunks that need to stage\n   * an upload destination without owning a React hook. Routes through\n   * the `ensureFolderPath` thunk against the store singleton, so realtime\n   * channel updates land in the slice the same way.\n   */\n  async ensureFolderPath(arg: EnsureFolderPathArg): Promise<string> {\n    const store = getStoreSingleton();\n    if (!store) {\n      throw new Error(\n        \"fileHandler.ensureFolderPath called before the Redux store was ready.\",\n      );\n    }\n    const dispatch = store.dispatch as AppDispatch;\n    return await dispatch(ensureFolderPathThunk(arg)).unwrap();\n  },\n};\n\nexport type {\n  FileSource,\n  FileTarget,\n  NormalizedFile,\n  UploadedNormalizedFile,\n  UploadOpts,\n} from \"./types\";\n"],"mappings":"AAcA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,WAAW,mBAAmB;AACvC,SAAS,gBAAgB;AACzB,SAAS,yBAAyB;AAClC;AAAA,EACE,cAAc;AAAA,EACd,oBAAoB;AAAA,OACf;AAYP,MAAM,cAAc;AAAA,EAClB,YAAoB,MAAsB;AAAtB;AAAA,EAAuB;AAAA,EAAvB;AAAA,EAEpB,MAAM,GAAyB,QAAoC;AACjE,UAAM,WAAW,MAAM,YAAY,KAAK,MAAM;AAAA,MAC5C,UAAU,eAAe,OAAO,IAAI;AAAA,MACpC,WAAW,OAAO,SAAS;AAAA,IAC7B,CAAC;AACD,WAAO,SAAS,UAAU,MAAM;AAAA,EAClC;AAAA,EAEA,MAAM,UAAmC;AACvC,WAAO,YAAY,KAAK,IAAI;AAAA,EAC9B;AACF;AAEA,SAAS,eAAe,MAAmC;AACzD,SAAO,SAAS,iBAAiB,SAAS;AAC5C;AAEO,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB,IAAI,QAAmC;AACrC,WAAO,IAAI,cAAc,UAAU,MAAM,CAAC;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ,QAA6C;AACzD,WAAO,YAAY,UAAU,MAAM,CAAC;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,OACJ,QACA,OAAmB,CAAC,GACa;AACjC,WAAO,eAAe,QAAQ,IAAI;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,QAAQ,MAA+C;AAC3D,WAAO,YAAY,MAAM,EAAE,UAAU,KAAK,CAAC;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAAa,QAAoB;AACrC,WAAO,KAAK,IAAI,MAAM,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,WAAW,QAAoB;AACnC,WAAO,KAAK,IAAI,MAAM,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,cAAc,QAAoB;AACtC,WAAO,KAAK,IAAI,MAAM,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,OAAO,QAA+B;AAC1C,UAAM,QAAQ,kBAAkB;AAChC,QAAI,CAAC,OAAO;AACV,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,UAAM,WAAW,MAAM;AACvB,UAAM,SAAS,gBAAgB,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO;AAAA,EACrD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,iBAAiB,KAA2C;AAChE,UAAM,QAAQ,kBAAkB;AAChC,QAAI,CAAC,OAAO;AACV,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,UAAM,WAAW,MAAM;AACvB,WAAO,MAAM,SAAS,sBAAsB,GAAG,CAAC,EAAE,OAAO;AAAA,EAC3D;AACF;","names":[]}

package/dist/files/engine/handler/hooks/useFile.d.ts

@@ -0,0 +1,17 @@
+/**
+ * features/files/handler/hooks/useFile.ts
+ *
+ * Resolve a `FileSource` to a `NormalizedFile`. Re-runs when the source's
+ * identity changes (its `kind` plus the relevant identifier — fileId, url,
+ * token, blob ref). The returned object is stable across renders that
+ * don't change those identifiers.
+ */
+import type { FileSource, NormalizedFile } from "../types.js";
+export type FileStatus = "idle" | "resolving" | "ready" | "error";
+export interface UseFileResult {
+    file: NormalizedFile | null;
+    status: FileStatus;
+    error: Error | null;
+    reload: () => void;
+}
+export declare function useFile(source: FileSource | null | undefined): UseFileResult;

package/dist/files/engine/handler/hooks/useFile.js

@@ -0,0 +1,75 @@
+"use client";
+import { useEffect, useState } from "react";
+import { fileHandler } from "../handler.js";
+function useFile(source) {
+  const [file, setFile] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (!source) {
+      setFile(null);
+      setStatus("idle");
+      setError(null);
+      return void 0;
+    }
+    let cancelled = false;
+    setStatus("resolving");
+    setError(null);
+    fileHandler.resolve(source).then((resolved) => {
+      if (cancelled) return;
+      setFile(resolved);
+      setStatus("ready");
+    }).catch((err) => {
+      if (cancelled) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [sourceKey(source), tick]);
+  return {
+    file,
+    status,
+    error,
+    reload: () => setTick((t) => t + 1)
+  };
+}
+function sourceKey(source) {
+  if (!source) return "<none>";
+  switch (source.kind) {
+    case "blob":
+      return `blob:${source.blob.size}:${source.fileName ?? ""}`;
+    case "file":
+      return `file:${source.file.name}:${source.file.size}:${source.file.lastModified}`;
+    case "buffer":
+      return `buffer:${source.fileName ?? ""}:${source.mime}`;
+    case "stream":
+      return `stream:${source.fileName ?? ""}`;
+    case "data_uri":
+      return `data:${source.dataUri.slice(0, 64)}`;
+    case "base64":
+      return `b64:${source.mime}:${source.base64.slice(0, 32)}`;
+    case "external_url":
+      return `ext:${source.url}`;
+    case "youtube":
+      return `yt:${source.url}`;
+    case "cloud_file":
+      return `cf:${source.cloudFile.id}`;
+    case "file_id":
+      return `id:${source.fileId}`;
+    case "share_link":
+      return `share:${source.token}`;
+    case "public_cdn":
+      return `cdn:${source.fileId ?? source.url}`;
+    case "upload_result":
+      return `up:${source.uploadResult.fileId ?? source.uploadResult.url}`;
+    case "stream_event":
+      return `ev:${JSON.stringify(source.payload).slice(0, 64)}`;
+  }
+}
+export {
+  useFile
+};
+//# sourceMappingURL=useFile.js.map

package/dist/files/engine/handler/hooks/useFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/files/engine/handler/hooks/useFile.ts"],"sourcesContent":["/**\n * features/files/handler/hooks/useFile.ts\n *\n * Resolve a `FileSource` to a `NormalizedFile`. Re-runs when the source's\n * identity changes (its `kind` plus the relevant identifier — fileId, url,\n * token, blob ref). The returned object is stable across renders that\n * don't change those identifiers.\n */\n\n\"use client\";\n\nimport { useEffect, useState } from \"react\";\nimport { fileHandler } from \"../handler\";\nimport type { FileSource, NormalizedFile } from \"../types\";\n\nexport type FileStatus = \"idle\" | \"resolving\" | \"ready\" | \"error\";\n\nexport interface UseFileResult {\n  file: NormalizedFile | null;\n  status: FileStatus;\n  error: Error | null;\n  reload: () => void;\n}\n\nexport function useFile(source: FileSource | null | undefined): UseFileResult {\n  const [file, setFile] = useState<NormalizedFile | null>(null);\n  const [status, setStatus] = useState<FileStatus>(\"idle\");\n  const [error, setError] = useState<Error | null>(null);\n  const [tick, setTick] = useState(0);\n\n  useEffect(() => {\n    if (!source) {\n      setFile(null);\n      setStatus(\"idle\");\n      setError(null);\n      return undefined;\n    }\n\n    let cancelled = false;\n    setStatus(\"resolving\");\n    setError(null);\n\n    fileHandler\n      .resolve(source)\n      .then((resolved) => {\n        if (cancelled) return;\n        setFile(resolved);\n        setStatus(\"ready\");\n      })\n      .catch((err) => {\n        if (cancelled) return;\n        setError(err instanceof Error ? err : new Error(String(err)));\n        setStatus(\"error\");\n      });\n\n    return () => {\n      cancelled = true;\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [sourceKey(source), tick]);\n\n  return {\n    file,\n    status,\n    error,\n    reload: () => setTick((t) => t + 1),\n  };\n}\n\n/**\n * Stable identity key for a FileSource. Different shapes have different\n * meaningful identifiers — this collapses each into one string so React\n * effects re-run only when the source actually changes.\n */\nfunction sourceKey(source: FileSource | null | undefined): string {\n  if (!source) return \"<none>\";\n  switch (source.kind) {\n    case \"blob\":\n      return `blob:${source.blob.size}:${source.fileName ?? \"\"}`;\n    case \"file\":\n      return `file:${source.file.name}:${source.file.size}:${source.file.lastModified}`;\n    case \"buffer\":\n      return `buffer:${source.fileName ?? \"\"}:${source.mime}`;\n    case \"stream\":\n      return `stream:${source.fileName ?? \"\"}`;\n    case \"data_uri\":\n      return `data:${source.dataUri.slice(0, 64)}`;\n    case \"base64\":\n      return `b64:${source.mime}:${source.base64.slice(0, 32)}`;\n    case \"external_url\":\n      return `ext:${source.url}`;\n    case \"youtube\":\n      return `yt:${source.url}`;\n    case \"cloud_file\":\n      return `cf:${source.cloudFile.id}`;\n    case \"file_id\":\n      return `id:${source.fileId}`;\n    case \"share_link\":\n      return `share:${source.token}`;\n    case \"public_cdn\":\n      return `cdn:${source.fileId ?? source.url}`;\n    case \"upload_result\":\n      return `up:${source.uploadResult.fileId ?? source.uploadResult.url}`;\n    case \"stream_event\":\n      return `ev:${JSON.stringify(source.payload).slice(0, 64)}`;\n  }\n}\n"],"mappings":";AAWA,SAAS,WAAW,gBAAgB;AACpC,SAAS,mBAAmB;AAYrB,SAAS,QAAQ,QAAsD;AAC5E,QAAM,CAAC,MAAM,OAAO,IAAI,SAAgC,IAAI;AAC5D,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAqB,MAAM;AACvD,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAuB,IAAI;AACrD,QAAM,CAAC,MAAM,OAAO,IAAI,SAAS,CAAC;AAElC,YAAU,MAAM;AACd,QAAI,CAAC,QAAQ;AACX,cAAQ,IAAI;AACZ,gBAAU,MAAM;AAChB,eAAS,IAAI;AACb,aAAO;AAAA,IACT;AAEA,QAAI,YAAY;AAChB,cAAU,WAAW;AACrB,aAAS,IAAI;AAEb,gBACG,QAAQ,MAAM,EACd,KAAK,CAAC,aAAa;AAClB,UAAI,UAAW;AACf,cAAQ,QAAQ;AAChB,gBAAU,OAAO;AAAA,IACnB,CAAC,EACA,MAAM,CAAC,QAAQ;AACd,UAAI,UAAW;AACf,eAAS,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAC5D,gBAAU,OAAO;AAAA,IACnB,CAAC;AAEH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EAEF,GAAG,CAAC,UAAU,MAAM,GAAG,IAAI,CAAC;AAE5B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,QAAQ,MAAM,QAAQ,CAAC,MAAM,IAAI,CAAC;AAAA,EACpC;AACF;AAOA,SAAS,UAAU,QAA+C;AAChE,MAAI,CAAC,OAAQ,QAAO;AACpB,UAAQ,OAAO,MAAM;AAAA,IACnB,KAAK;AACH,aAAO,QAAQ,OAAO,KAAK,IAAI,IAAI,OAAO,YAAY,EAAE;AAAA,IAC1D,KAAK;AACH,aAAO,QAAQ,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,YAAY;AAAA,IACjF,KAAK;AACH,aAAO,UAAU,OAAO,YAAY,EAAE,IAAI,OAAO,IAAI;AAAA,IACvD,KAAK;AACH,aAAO,UAAU,OAAO,YAAY,EAAE;AAAA,IACxC,KAAK;AACH,aAAO,QAAQ,OAAO,QAAQ,MAAM,GAAG,EAAE,CAAC;AAAA,IAC5C,KAAK;AACH,aAAO,OAAO,OAAO,IAAI,IAAI,OAAO,OAAO,MAAM,GAAG,EAAE,CAAC;AAAA,IACzD,KAAK;AACH,aAAO,OAAO,OAAO,GAAG;AAAA,IAC1B,KAAK;AACH,aAAO,MAAM,OAAO,GAAG;AAAA,IACzB,KAAK;AACH,aAAO,MAAM,OAAO,UAAU,EAAE;AAAA,IAClC,KAAK;AACH,aAAO,MAAM,OAAO,MAAM;AAAA,IAC5B,KAAK;AACH,aAAO,SAAS,OAAO,KAAK;AAAA,IAC9B,KAAK;AACH,aAAO,OAAO,OAAO,UAAU,OAAO,GAAG;AAAA,IAC3C,KAAK;AACH,aAAO,MAAM,OAAO,aAAa,UAAU,OAAO,aAAa,GAAG;AAAA,IACpE,KAAK;AACH,aAAO,MAAM,KAAK,UAAU,OAAO,OAAO,EAAE,MAAM,GAAG,EAAE,CAAC;AAAA,EAC5D;AACF;","names":[]}

package/dist/files/engine/handler/hooks/useFileUpload.d.ts

@@ -0,0 +1,76 @@
+/**
+ * features/files/handler/hooks/useFileUpload.ts
+ *
+ * The single React-side upload primitive.
+ *
+ *   upload(source, opts)         — one file. Returns NormalizedFile.
+ *   uploadMany(files, opts)      — many files, with the duplicate-detection
+ *                                  pre-flight dialog. Returns
+ *                                  { uploaded, failed, cancelled }.
+ *
+ * Single-file uploads route through cloudUpload (Python POST +
+ * optimistic Redux dispatch + optional share-link creation). Multi-file
+ * uploads route through `requestUpload` from `<UploadGuardHost/>` so the
+ * SHA-256 dedup pre-flight + DuplicateUploadDialog UX is consistent for
+ * every multi-file drop.
+ *
+ * Anonymous users (visitors on `/p/[slug]`) work via the standard cloud-
+ * files JWT path because Supabase issues an anonymous auth UUID for
+ * them. The handler does not branch on anonymous vs authenticated.
+ */
+import type { UploadFilesArg } from "../../types.js";
+import type { FileSource, UploadedNormalizedFile, UploadOpts } from "../types.js";
+export interface UploadProgress {
+    loaded: number;
+    total: number;
+    ratio: number;
+}
+export interface MultiUploadOptions extends Omit<UploadFilesArg, "files" | "parentFolderId" | "visibility"> {
+    /** Parent cloud-files folder id. null = root. */
+    parentFolderId?: string | null;
+    /** Default visibility for every file in the batch. */
+    visibility?: UploadFilesArg["visibility"];
+}
+export interface MultiUploadResult {
+    /** cld_files UUIDs for every successful upload. */
+    uploaded: string[];
+    /** Per-file failure with the real backend error message. */
+    failed: Array<{
+        name: string;
+        error: string;
+    }>;
+    /** True when the user dismissed the duplicate-upload dialog. */
+    cancelled: boolean;
+    /**
+     * Files the user chose to attach as the EXISTING copy (via "Use
+     * existing" in the duplicate dialog) instead of re-uploading. Each
+     * entry carries the index into the original `files` argument plus
+     * the live `cld_files.id` the caller should wire into its parent
+     * context (chat attachment, agent resource, etc.). Follows the
+     * `duplicate_of_file_id` chain so dup ids resolve to live keepers.
+     *
+     * Empty for the normal no-conflict path. See
+     * `features/files/upload/uploadGuardOpeners.ts` for the underlying
+     * shape.
+     */
+    aliased: Array<{
+        inputIndex: number;
+        existingFileId: string;
+    }>;
+}
+export interface UseFileUploadResult {
+    /** Upload one file (or any FileSource — paste, blob, base64, url). */
+    upload: (source: FileSource, opts?: UploadOpts) => Promise<UploadedNormalizedFile>;
+    /**
+     * Upload many files at once. Runs the SHA-256 dedup pre-flight and shows
+     * the duplicate-resolution dialog when conflicts are found. Returns
+     * per-file success/failure so callers can render their own progress UI.
+     */
+    uploadMany: (files: File[], opts?: MultiUploadOptions) => Promise<MultiUploadResult>;
+    uploading: boolean;
+    progress: UploadProgress | null;
+    result: UploadedNormalizedFile | null;
+    error: Error | null;
+    reset: () => void;
+}
+export declare function useFileUpload(): UseFileUploadResult;

package/dist/files/engine/handler/hooks/useFileUpload.js

@@ -0,0 +1,67 @@
+"use client";
+import { useCallback, useState } from "react";
+import { fileHandler } from "../handler.js";
+import { requestUpload } from "../../upload/uploadGuardOpeners.js";
+function useFileUpload() {
+  const [uploading, setUploading] = useState(false);
+  const [progress, setProgress] = useState(null);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const upload = useCallback(
+    async (source, opts = {}) => {
+      setUploading(true);
+      setError(null);
+      setProgress(null);
+      try {
+        const normalized = await fileHandler.upload(source, {
+          ...opts,
+          onProgress: (loaded, total) => {
+            setProgress({
+              loaded,
+              total,
+              ratio: total > 0 ? loaded / total : 0
+            });
+            opts.onProgress?.(loaded, total);
+          }
+        });
+        setResult(normalized);
+        return normalized;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setUploading(false);
+      }
+    },
+    []
+  );
+  const uploadMany = useCallback(
+    async (files, opts = {}) => {
+      const arg = {
+        files,
+        parentFolderId: opts.parentFolderId ?? null,
+        folderPath: opts.folderPath ?? null,
+        visibility: opts.visibility ?? "personal",
+        shareWith: opts.shareWith,
+        shareLevel: opts.shareLevel,
+        changeSummary: opts.changeSummary,
+        metadata: opts.metadata,
+        options: opts.options,
+        concurrency: opts.concurrency
+      };
+      return requestUpload(arg);
+    },
+    []
+  );
+  const reset = useCallback(() => {
+    setResult(null);
+    setError(null);
+    setProgress(null);
+  }, []);
+  return { upload, uploadMany, uploading, progress, result, error, reset };
+}
+export {
+  useFileUpload
+};
+//# sourceMappingURL=useFileUpload.js.map

package/dist/files/engine/handler/hooks/useFileUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/files/engine/handler/hooks/useFileUpload.ts"],"sourcesContent":["/**\n * features/files/handler/hooks/useFileUpload.ts\n *\n * The single React-side upload primitive.\n *\n *   upload(source, opts)         — one file. Returns NormalizedFile.\n *   uploadMany(files, opts)      — many files, with the duplicate-detection\n *                                  pre-flight dialog. Returns\n *                                  { uploaded, failed, cancelled }.\n *\n * Single-file uploads route through cloudUpload (Python POST +\n * optimistic Redux dispatch + optional share-link creation). Multi-file\n * uploads route through `requestUpload` from `<UploadGuardHost/>` so the\n * SHA-256 dedup pre-flight + DuplicateUploadDialog UX is consistent for\n * every multi-file drop.\n *\n * Anonymous users (visitors on `/p/[slug]`) work via the standard cloud-\n * files JWT path because Supabase issues an anonymous auth UUID for\n * them. The handler does not branch on anonymous vs authenticated.\n */\n\n\"use client\";\n\nimport { useCallback, useState } from \"react\";\nimport { fileHandler } from \"../handler\";\nimport { requestUpload } from \"../../upload/uploadGuardOpeners\";\nimport type { UploadFilesArg } from \"../../types\";\nimport type {\n  FileSource,\n  UploadedNormalizedFile,\n  UploadOpts,\n} from \"../types\";\n\nexport interface UploadProgress {\n  loaded: number;\n  total: number;\n  ratio: number;\n}\n\nexport interface MultiUploadOptions extends Omit<\n  UploadFilesArg,\n  \"files\" | \"parentFolderId\" | \"visibility\"\n> {\n  /** Parent cloud-files folder id. null = root. */\n  parentFolderId?: string | null;\n  /** Default visibility for every file in the batch. */\n  visibility?: UploadFilesArg[\"visibility\"];\n}\n\nexport interface MultiUploadResult {\n  /** cld_files UUIDs for every successful upload. */\n  uploaded: string[];\n  /** Per-file failure with the real backend error message. */\n  failed: Array<{ name: string; error: string }>;\n  /** True when the user dismissed the duplicate-upload dialog. */\n  cancelled: boolean;\n  /**\n   * Files the user chose to attach as the EXISTING copy (via \"Use\n   * existing\" in the duplicate dialog) instead of re-uploading. Each\n   * entry carries the index into the original `files` argument plus\n   * the live `cld_files.id` the caller should wire into its parent\n   * context (chat attachment, agent resource, etc.). Follows the\n   * `duplicate_of_file_id` chain so dup ids resolve to live keepers.\n   *\n   * Empty for the normal no-conflict path. See\n   * `features/files/upload/uploadGuardOpeners.ts` for the underlying\n   * shape.\n   */\n  aliased: Array<{ inputIndex: number; existingFileId: string }>;\n}\n\nexport interface UseFileUploadResult {\n  /** Upload one file (or any FileSource — paste, blob, base64, url). */\n  upload: (\n    source: FileSource,\n    opts?: UploadOpts,\n  ) => Promise<UploadedNormalizedFile>;\n  /**\n   * Upload many files at once. Runs the SHA-256 dedup pre-flight and shows\n   * the duplicate-resolution dialog when conflicts are found. Returns\n   * per-file success/failure so callers can render their own progress UI.\n   */\n  uploadMany: (\n    files: File[],\n    opts?: MultiUploadOptions,\n  ) => Promise<MultiUploadResult>;\n  uploading: boolean;\n  progress: UploadProgress | null;\n  result: UploadedNormalizedFile | null;\n  error: Error | null;\n  reset: () => void;\n}\n\nexport function useFileUpload(): UseFileUploadResult {\n  const [uploading, setUploading] = useState(false);\n  const [progress, setProgress] = useState<UploadProgress | null>(null);\n  const [result, setResult] = useState<UploadedNormalizedFile | null>(null);\n  const [error, setError] = useState<Error | null>(null);\n\n  const upload = useCallback(\n    async (\n      source: FileSource,\n      opts: UploadOpts = {},\n    ): Promise<UploadedNormalizedFile> => {\n      setUploading(true);\n      setError(null);\n      setProgress(null);\n      try {\n        const normalized = await fileHandler.upload(source, {\n          ...opts,\n          onProgress: (loaded, total) => {\n            setProgress({\n              loaded,\n              total,\n              ratio: total > 0 ? loaded / total : 0,\n            });\n            opts.onProgress?.(loaded, total);\n          },\n        });\n        setResult(normalized);\n        return normalized;\n      } catch (err) {\n        const e = err instanceof Error ? err : new Error(String(err));\n        setError(e);\n        throw e;\n      } finally {\n        setUploading(false);\n      }\n    },\n    [],\n  );\n\n  const uploadMany = useCallback(\n    async (\n      files: File[],\n      opts: MultiUploadOptions = {},\n    ): Promise<MultiUploadResult> => {\n      const arg: UploadFilesArg = {\n        files,\n        parentFolderId: opts.parentFolderId ?? null,\n        folderPath: opts.folderPath ?? null,\n        visibility: opts.visibility ?? \"personal\",\n        shareWith: opts.shareWith,\n        shareLevel: opts.shareLevel,\n        changeSummary: opts.changeSummary,\n        metadata: opts.metadata,\n        options: opts.options,\n        concurrency: opts.concurrency,\n      };\n      return requestUpload(arg);\n    },\n    [],\n  );\n\n  const reset = useCallback(() => {\n    setResult(null);\n    setError(null);\n    setProgress(null);\n  }, []);\n\n  return { upload, uploadMany, uploading, progress, result, error, reset };\n}\n"],"mappings":";AAuBA,SAAS,aAAa,gBAAgB;AACtC,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB;AAoEvB,SAAS,gBAAqC;AACnD,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAChD,QAAM,CAAC,UAAU,WAAW,IAAI,SAAgC,IAAI;AACpE,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAwC,IAAI;AACxE,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAuB,IAAI;AAErD,QAAM,SAAS;AAAA,IACb,OACE,QACA,OAAmB,CAAC,MACgB;AACpC,mBAAa,IAAI;AACjB,eAAS,IAAI;AACb,kBAAY,IAAI;AAChB,UAAI;AACF,cAAM,aAAa,MAAM,YAAY,OAAO,QAAQ;AAAA,UAClD,GAAG;AAAA,UACH,YAAY,CAAC,QAAQ,UAAU;AAC7B,wBAAY;AAAA,cACV;AAAA,cACA;AAAA,cACA,OAAO,QAAQ,IAAI,SAAS,QAAQ;AAAA,YACtC,CAAC;AACD,iBAAK,aAAa,QAAQ,KAAK;AAAA,UACjC;AAAA,QACF,CAAC;AACD,kBAAU,UAAU;AACpB,eAAO;AAAA,MACT,SAAS,KAAK;AACZ,cAAM,IAAI,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC;AAC5D,iBAAS,CAAC;AACV,cAAM;AAAA,MACR,UAAE;AACA,qBAAa,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,IACA,CAAC;AAAA,EACH;AAEA,QAAM,aAAa;AAAA,IACjB,OACE,OACA,OAA2B,CAAC,MACG;AAC/B,YAAM,MAAsB;AAAA,QAC1B;AAAA,QACA,gBAAgB,KAAK,kBAAkB;AAAA,QACvC,YAAY,KAAK,cAAc;AAAA,QAC/B,YAAY,KAAK,cAAc;AAAA,QAC/B,WAAW,KAAK;AAAA,QAChB,YAAY,KAAK;AAAA,QACjB,eAAe,KAAK;AAAA,QACpB,UAAU,KAAK;AAAA,QACf,SAAS,KAAK;AAAA,QACd,aAAa,KAAK;AAAA,MACpB;AACA,aAAO,cAAc,GAAG;AAAA,IAC1B;AAAA,IACA,CAAC;AAAA,EACH;AAEA,QAAM,QAAQ,YAAY,MAAM;AAC9B,cAAU,IAAI;AACd,aAAS,IAAI;AACb,gBAAY,IAAI;AAAA,EAClB,GAAG,CAAC,CAAC;AAEL,SAAO,EAAE,QAAQ,YAAY,WAAW,UAAU,QAAQ,OAAO,MAAM;AACzE;","names":[]}

package/dist/files/engine/handler/input/normalize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * features/files/handler/input/normalize.ts
+ *
+ * Pure first-pass: turn a `FileSource` into a partial `NormalizedFile`.
+ * "Pure" means no I/O, no Redux. Anything that needs the network or auth
+ * runs in the resolver, not here.
+ *
+ * Each `FileSource` kind gets its own arm. Adding a new shape is a single
+ * edit in this file plus a `FileSource` variant in `../types.ts`.
+ */
+import type { CloudFile } from "../../types.js";
+import type { FileSource, NormalizedFile } from "../types.js";
+export declare function normalize(source: FileSource): NormalizedFile;
+export declare function fromCloudFile(cloudFile: CloudFile, source: FileSource): NormalizedFile;