@ai-matrx/media 0.8.0 → 0.9.0

package/dist/files/engine/host/supabase.js

@@ -0,0 +1,33 @@
+import { createSessionRetry } from "@ai-matrx/data/db";
+import { getFilesHost } from "./configure.js";
+import {
+  isMissingSessionError,
+  SessionUnavailableError
+} from "@ai-matrx/data/db";
+import { getClaimsUser } from "../support/claimsUser.js";
+function createClient() {
+  return getFilesHost("db").db;
+}
+const supabase = new Proxy({}, {
+  get(_target, key) {
+    const db = createClient();
+    const value = db[key];
+    return typeof value === "function" ? value.bind(db) : value;
+  }
+});
+function iamDb(client) {
+  return client.schema("iam");
+}
+const runWithSessionRetry = createSessionRetry({
+  auth: { getSession: () => createClient().auth.getSession() }
+});
+export {
+  SessionUnavailableError,
+  createClient,
+  getClaimsUser,
+  iamDb,
+  isMissingSessionError,
+  runWithSessionRetry,
+  supabase
+};
+//# sourceMappingURL=supabase.js.map

package/dist/files/engine/host/supabase.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/host/supabase.ts"],"sourcesContent":["/**\n * Database seam — the host's supabase-js client, read at CALL time. Same\n * names the call sites imported from matrx-frontend's `utils/supabase/*` and\n * `lib/supabase/authRetry`.\n */\n\nimport type { SupabaseClient } from \"@supabase/supabase-js\";\nimport { createSessionRetry } from \"@ai-matrx/data/db\";\nimport type { FilesDatabase } from \"../db-types\";\nimport { getFilesHost } from \"./configure\";\n\nexport {\n  isMissingSessionError,\n  SessionUnavailableError,\n  type AuthRetryableResult,\n} from \"@ai-matrx/data/db\";\nexport { getClaimsUser } from \"../support/claimsUser\";\n\nexport type FilesDb = SupabaseClient<FilesDatabase>;\n\n/** The configured host's database client. */\nexport function createClient(): FilesDb {\n  return getFilesHost(\"db\").db as unknown as FilesDb;\n}\n\n/**\n * `supabase` as the call sites knew it: every property read goes to the\n * configured host's client at that moment (methods stay bound to it).\n */\nexport const supabase: FilesDb = new Proxy({} as FilesDb, {\n  get(_target, key) {\n    const db = createClient() as unknown as Record<PropertyKey, unknown>;\n    const value = db[key];\n    return typeof value === \"function\" ? (value as (...a: unknown[]) => unknown).bind(db) : value;\n  },\n});\n\nexport function iamDb<C extends FilesDb>(client: C) {\n  return client.schema(\"iam\");\n}\n\nexport const runWithSessionRetry = createSessionRetry({\n  auth: { getSession: () => createClient().auth.getSession() },\n});\n"],"mappings":"AAOA,SAAS,0BAA0B;AAEnC,SAAS,oBAAoB;AAE7B;AAAA,EACE;AAAA,EACA;AAAA,OAEK;AACP,SAAS,qBAAqB;AAKvB,SAAS,eAAwB;AACtC,SAAO,aAAa,IAAI,EAAE;AAC5B;AAMO,MAAM,WAAoB,IAAI,MAAM,CAAC,GAAc;AAAA,EACxD,IAAI,SAAS,KAAK;AAChB,UAAM,KAAK,aAAa;AACxB,UAAM,QAAQ,GAAG,GAAG;AACpB,WAAO,OAAO,UAAU,aAAc,MAAuC,KAAK,EAAE,IAAI;AAAA,EAC1F;AACF,CAAC;AAEM,SAAS,MAAyB,QAAW;AAClD,SAAO,OAAO,OAAO,KAAK;AAC5B;AAEO,MAAM,sBAAsB,mBAAmB;AAAA,EACpD,MAAM,EAAE,YAAY,MAAM,aAAa,EAAE,KAAK,WAAW,EAAE;AAC7D,CAAC;","names":[]}

package/dist/files/engine/host/toast.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Notification seam — the host's toasts. A host without one logs to the
+ * console, so a failure is never silent.
+ */
+type Options = {
+    description?: string;
+    id?: string | number;
+    duration?: number;
+};
+export declare const toast: {
+    success(message: string, options?: Options): void;
+    error(message: string, options?: Options): void;
+};
+export {};

package/dist/files/engine/host/toast.js

@@ -0,0 +1,20 @@
+import { getFilesHost, isFilesHostConfigured } from "./configure.js";
+function port() {
+  return isFilesHostConfigured() ? getFilesHost("notify").notify : void 0;
+}
+const toast = {
+  success(message, options) {
+    const notify = port();
+    if (notify) notify.success(message, options);
+    else console.info(`[files] ${message}`, options?.description ?? "");
+  },
+  error(message, options) {
+    const notify = port();
+    if (notify) notify.error(message, options);
+    else console.error(`[files] ${message}`, options?.description ?? "");
+  }
+};
+export {
+  toast
+};
+//# sourceMappingURL=toast.js.map

package/dist/files/engine/host/toast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/host/toast.ts"],"sourcesContent":["/**\n * Notification seam — the host's toasts. A host without one logs to the\n * console, so a failure is never silent.\n */\n\nimport { getFilesHost, isFilesHostConfigured } from \"./configure\";\n\ntype Options = { description?: string; id?: string | number; duration?: number };\n\nfunction port() {\n  return isFilesHostConfigured() ? getFilesHost(\"notify\").notify : undefined;\n}\n\nexport const toast = {\n  success(message: string, options?: Options): void {\n    const notify = port();\n    if (notify) notify.success(message, options);\n    else console.info(`[files] ${message}`, options?.description ?? \"\");\n  },\n  error(message: string, options?: Options): void {\n    const notify = port();\n    if (notify) notify.error(message, options);\n    else console.error(`[files] ${message}`, options?.description ?? \"\");\n  },\n};\n"],"mappings":"AAKA,SAAS,cAAc,6BAA6B;AAIpD,SAAS,OAAO;AACd,SAAO,sBAAsB,IAAI,aAAa,QAAQ,EAAE,SAAS;AACnE;AAEO,MAAM,QAAQ;AAAA,EACnB,QAAQ,SAAiB,SAAyB;AAChD,UAAM,SAAS,KAAK;AACpB,QAAI,OAAQ,QAAO,QAAQ,SAAS,OAAO;AAAA,QACtC,SAAQ,KAAK,WAAW,OAAO,IAAI,SAAS,eAAe,EAAE;AAAA,EACpE;AAAA,EACA,MAAM,SAAiB,SAAyB;AAC9C,UAAM,SAAS,KAAK;AACpB,QAAI,OAAQ,QAAO,MAAM,SAAS,OAAO;AAAA,QACpC,SAAQ,MAAM,WAAW,OAAO,IAAI,SAAS,eAAe,EAAE;AAAA,EACrE;AACF;","names":[]}

package/dist/files/engine/host/typed-client.d.ts

@@ -0,0 +1,136 @@
+/**
+ * lib/api/typed-client.ts
+ *
+ * Path-keyed, contract-bound wrapper around the raw Python client
+ * (`lib/python-client.ts`). This is the ONLY sanctioned way to call the
+ * Python backend from feature code.
+ *
+ * Why this exists
+ * ---------------
+ * The raw helpers (`postJson<T>`, `postMultipart<T>`, …) take a plain
+ * `string` path and an *asserted* response type `T`. Nothing links the
+ * path you call, the body you send, and the response you claim to the
+ * server's actual OpenAPI contract. That gap shipped a production 400:
+ * the FE hand-mirrored `PreviewVariantSpec` with a `key` field while the
+ * backend had renamed it to `preset_id`. TypeScript was green because it
+ * was checking a hand-written lie against itself.
+ *
+ * These wrappers close the gap. Every function is generic over a *path
+ * literal* from the generated `paths` interface. The request body and the
+ * success response are DERIVED from `operations[...]`, never asserted:
+ *
+ *   - Wrong path              → compile error (not a key of `paths`).
+ *   - Wrong body shape / key  → compile error (must match `requestBody`).
+ *   - Wrong response field     → compile error (response is the real type).
+ *
+ * When the backend changes and `pnpm sync-types` regenerates
+ * `@ai-matrx/agents/generated/api-types`, every drifted callsite lights up
+ * red in the same PR. That is the whole point.
+ *
+ * Regenerate the contract: `pnpm sync-types` (Supabase + Python OpenAPI).
+ *
+ * NOTE: path-parameter endpoints (`/assets/{file_id}`) are handled by
+ * `buildPath()` — pass the template literal + params so the key still
+ * type-checks against `paths`. Query-only and no-param endpoints pass the
+ * path literal directly.
+ */
+import type { paths } from "@ai-matrx/agents/generated/api-types";
+import { type RequestOptions, type ResponseMeta } from "./python-client.js";
+type HttpMethod = "get" | "post" | "put" | "patch" | "delete";
+/** Every path literal in the contract that defines a real operation for M. */
+export type PathWith<M extends HttpMethod> = {
+    [P in keyof paths]: paths[P] extends Record<M, infer Op> ? Op extends undefined | never ? never : P : never;
+}[keyof paths];
+/** The operation object registered for (path P, method M). */
+type OpOf<P extends keyof paths, M extends HttpMethod> = paths[P] extends Record<M, infer O> ? O : never;
+/** JSON request body of an operation. `undefined` when the body is optional. */
+export type JsonBodyOf<O> = O extends {
+    requestBody: {
+        content: {
+            "application/json": infer B;
+        };
+    };
+} ? B : O extends {
+    requestBody?: {
+        content: {
+            "application/json": infer B;
+        };
+    };
+} ? B | undefined : never;
+/** The 2xx `application/json` success payload of an operation. */
+export type OkJsonOf<O> = O extends {
+    responses: {
+        200: {
+            content: {
+                "application/json": infer T;
+            };
+        };
+    };
+} ? T : O extends {
+    responses: {
+        201: {
+            content: {
+                "application/json": infer T;
+            };
+        };
+    };
+} ? T : O extends {
+    responses: {
+        204: unknown;
+    };
+} ? null : unknown;
+type PostBody<P extends keyof paths> = JsonBodyOf<OpOf<P, "post">>;
+type PatchBody<P extends keyof paths> = JsonBodyOf<OpOf<P, "patch">>;
+type PutBody<P extends keyof paths> = JsonBodyOf<OpOf<P, "put">>;
+type GetResult<P extends keyof paths> = OkJsonOf<OpOf<P, "get">>;
+type PostResult<P extends keyof paths> = OkJsonOf<OpOf<P, "post">>;
+type PatchResult<P extends keyof paths> = OkJsonOf<OpOf<P, "patch">>;
+type PutResult<P extends keyof paths> = OkJsonOf<OpOf<P, "put">>;
+type DeleteResult<P extends keyof paths> = OkJsonOf<OpOf<P, "delete">>;
+type Envelope<T> = Promise<{
+    data: T;
+    meta: ResponseMeta;
+}>;
+/**
+ * Fill a path template's `{param}` slots while keeping the *template* literal
+ * (not the interpolated runtime string) as the type the client checks against
+ * `paths`. Usage:
+ *
+ *   apiGet(buildPath("/assets/{file_id}", { file_id }))
+ *
+ * The returned branded string carries the template's literal type so the call
+ * still resolves to the correct operation.
+ */
+export declare function buildPath<P extends keyof paths>(template: P, params: Record<string, string | number>): P;
+/** A query-string value; `null`/`undefined` entries are dropped. */
+export type QueryScalar = string | number | boolean | null | undefined;
+/** A query value: a scalar, or an array emitted as REPEATED params (`?k=a&k=b`). */
+export type QueryValue = QueryScalar | readonly QueryScalar[];
+/** Append a query object to a path literal, dropping empty values. */
+export declare function withQuery<P extends string>(path: P, query?: Record<string, QueryValue>): P;
+/**
+ * GET a JSON endpoint. Response is derived from the contract; the path literal
+ * stays contract-checked even with query params (passed via `opts.query`, which
+ * `withQuery` serializes onto the URL).
+ */
+export declare function apiGet<P extends PathWith<"get">>(path: P, opts?: RequestOptions & {
+    query?: Record<string, QueryValue>;
+}): Envelope<GetResult<P>>;
+/** POST a JSON body. Body AND response are derived from the contract. */
+export declare function apiPost<P extends PathWith<"post">>(path: P, body: PostBody<P> extends never ? undefined : PostBody<P>, opts?: RequestOptions): Envelope<PostResult<P>>;
+/** PATCH a JSON body. Body AND response are derived from the contract. */
+export declare function apiPatch<P extends PathWith<"patch">>(path: P, body: PatchBody<P>, opts?: RequestOptions): Envelope<PatchResult<P>>;
+/** PUT a JSON body. Body AND response are derived from the contract. */
+export declare function apiPut<P extends PathWith<"put">>(path: P, body: PutBody<P>, opts?: RequestOptions): Envelope<PutResult<P>>;
+/** DELETE an endpoint. Response is derived from the contract. */
+export declare function apiDelete<P extends PathWith<"delete">>(path: P, opts?: RequestOptions): Envelope<DeleteResult<P>>;
+/**
+ * POST a `multipart/form-data` body. The FormData is built by the caller
+ * (multipart field values are stringly at the wire), but the RESPONSE is
+ * still derived from the contract — killing the unchecked `<T>` assertion
+ * that let the preview 400 through. Type the objects you `JSON.stringify`
+ * into the form against their generated `components["schemas"][…]` type so
+ * the encoded payload can't drift either.
+ */
+export declare function apiMultipart<P extends PathWith<"post">>(path: P, form: FormData, opts?: RequestOptions): Envelope<PostResult<P>>;
+export {};

package/dist/files/engine/host/typed-client.js

@@ -0,0 +1,66 @@
+import {
+  del,
+  getJson,
+  patchJson,
+  postJson,
+  postMultipart,
+  putJson
+} from "./python-client.js";
+function buildPath(template, params) {
+  return template.replace(/\{([^}]+)\}/g, (_, k) => {
+    const v = params[k];
+    if (v === void 0) {
+      throw new Error(
+        `buildPath: missing path parameter "${k}" for template "${String(template)}"`
+      );
+    }
+    return encodeURIComponent(String(v));
+  });
+}
+function withQuery(path, query) {
+  if (!query) return path;
+  const qs = new URLSearchParams();
+  const appendScalar = (k, v) => {
+    if (v === null || v === void 0 || v === "") return;
+    qs.append(k, String(v));
+  };
+  for (const [k, v] of Object.entries(query)) {
+    if (Array.isArray(v)) {
+      for (const item of v) appendScalar(k, item);
+    } else {
+      appendScalar(k, v);
+    }
+  }
+  const s = qs.toString();
+  return s ? `${path}${path.includes("?") ? "&" : "?"}${s}` : path;
+}
+function apiGet(path, opts) {
+  const { query, ...rest } = opts ?? {};
+  return getJson(withQuery(path, query), rest);
+}
+function apiPost(path, body, opts) {
+  return postJson(path, body, opts);
+}
+function apiPatch(path, body, opts) {
+  return patchJson(path, body, opts);
+}
+function apiPut(path, body, opts) {
+  return putJson(path, body, opts);
+}
+function apiDelete(path, opts) {
+  return del(path, opts);
+}
+function apiMultipart(path, form, opts) {
+  return postMultipart(path, form, opts);
+}
+export {
+  apiDelete,
+  apiGet,
+  apiMultipart,
+  apiPatch,
+  apiPost,
+  apiPut,
+  buildPath,
+  withQuery
+};
+//# sourceMappingURL=typed-client.js.map

package/dist/files/engine/host/typed-client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/host/typed-client.ts"],"sourcesContent":["/**\n * lib/api/typed-client.ts\n *\n * Path-keyed, contract-bound wrapper around the raw Python client\n * (`lib/python-client.ts`). This is the ONLY sanctioned way to call the\n * Python backend from feature code.\n *\n * Why this exists\n * ---------------\n * The raw helpers (`postJson<T>`, `postMultipart<T>`, …) take a plain\n * `string` path and an *asserted* response type `T`. Nothing links the\n * path you call, the body you send, and the response you claim to the\n * server's actual OpenAPI contract. That gap shipped a production 400:\n * the FE hand-mirrored `PreviewVariantSpec` with a `key` field while the\n * backend had renamed it to `preset_id`. TypeScript was green because it\n * was checking a hand-written lie against itself.\n *\n * These wrappers close the gap. Every function is generic over a *path\n * literal* from the generated `paths` interface. The request body and the\n * success response are DERIVED from `operations[...]`, never asserted:\n *\n *   - Wrong path              → compile error (not a key of `paths`).\n *   - Wrong body shape / key  → compile error (must match `requestBody`).\n *   - Wrong response field     → compile error (response is the real type).\n *\n * When the backend changes and `pnpm sync-types` regenerates\n * `@ai-matrx/agents/generated/api-types`, every drifted callsite lights up\n * red in the same PR. That is the whole point.\n *\n * Regenerate the contract: `pnpm sync-types` (Supabase + Python OpenAPI).\n *\n * NOTE: path-parameter endpoints (`/assets/{file_id}`) are handled by\n * `buildPath()` — pass the template literal + params so the key still\n * type-checks against `paths`. Query-only and no-param endpoints pass the\n * path literal directly.\n */\n\nimport type { paths } from \"@ai-matrx/agents/generated/api-types\";\nimport {\n  del,\n  getJson,\n  patchJson,\n  postJson,\n  postMultipart,\n  putJson,\n  type RequestOptions,\n  type ResponseMeta,\n} from \"./python-client\";\n\n// ---------------------------------------------------------------------------\n// Contract-derivation helpers (type-level only — zero runtime cost)\n// ---------------------------------------------------------------------------\n\ntype HttpMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\n\n/** Every path literal in the contract that defines a real operation for M. */\nexport type PathWith<M extends HttpMethod> = {\n  [P in keyof paths]: paths[P] extends Record<M, infer Op>\n    ? Op extends undefined | never\n      ? never\n      : P\n    : never;\n}[keyof paths];\n\n/** The operation object registered for (path P, method M). */\ntype OpOf<P extends keyof paths, M extends HttpMethod> = paths[P] extends Record<\n  M,\n  infer O\n>\n  ? O\n  : never;\n\n/** JSON request body of an operation. `undefined` when the body is optional. */\nexport type JsonBodyOf<O> = O extends {\n  requestBody: { content: { \"application/json\": infer B } };\n}\n  ? B\n  : O extends { requestBody?: { content: { \"application/json\": infer B } } }\n    ? B | undefined\n    : never;\n\n/** The 2xx `application/json` success payload of an operation. */\nexport type OkJsonOf<O> = O extends {\n  responses: { 200: { content: { \"application/json\": infer T } } };\n}\n  ? T\n  : O extends { responses: { 201: { content: { \"application/json\": infer T } } } }\n    ? T\n    : O extends { responses: { 204: unknown } }\n      ? null\n      : unknown;\n\n// Convenience aliases keyed by (path, method).\ntype PostBody<P extends keyof paths> = JsonBodyOf<OpOf<P, \"post\">>;\ntype PatchBody<P extends keyof paths> = JsonBodyOf<OpOf<P, \"patch\">>;\ntype PutBody<P extends keyof paths> = JsonBodyOf<OpOf<P, \"put\">>;\n\ntype GetResult<P extends keyof paths> = OkJsonOf<OpOf<P, \"get\">>;\ntype PostResult<P extends keyof paths> = OkJsonOf<OpOf<P, \"post\">>;\ntype PatchResult<P extends keyof paths> = OkJsonOf<OpOf<P, \"patch\">>;\ntype PutResult<P extends keyof paths> = OkJsonOf<OpOf<P, \"put\">>;\ntype DeleteResult<P extends keyof paths> = OkJsonOf<OpOf<P, \"delete\">>;\n\ntype Envelope<T> = Promise<{ data: T; meta: ResponseMeta }>;\n\n// ---------------------------------------------------------------------------\n// Path-parameter interpolation\n// ---------------------------------------------------------------------------\n\n/**\n * Fill a path template's `{param}` slots while keeping the *template* literal\n * (not the interpolated runtime string) as the type the client checks against\n * `paths`. Usage:\n *\n *   apiGet(buildPath(\"/assets/{file_id}\", { file_id }))\n *\n * The returned branded string carries the template's literal type so the call\n * still resolves to the correct operation.\n */\nexport function buildPath<P extends keyof paths>(\n  template: P,\n  params: Record<string, string | number>,\n): P {\n  return (template as string).replace(/\\{([^}]+)\\}/g, (_, k: string) => {\n    const v = params[k];\n    if (v === undefined) {\n      throw new Error(\n        `buildPath: missing path parameter \"${k}\" for template \"${String(template)}\"`,\n      );\n    }\n    return encodeURIComponent(String(v));\n  }) as P;\n}\n\n// ---------------------------------------------------------------------------\n// Contract-bound verbs\n// ---------------------------------------------------------------------------\n\n/** A query-string value; `null`/`undefined` entries are dropped. */\nexport type QueryScalar = string | number | boolean | null | undefined;\n/** A query value: a scalar, or an array emitted as REPEATED params (`?k=a&k=b`). */\nexport type QueryValue = QueryScalar | readonly QueryScalar[];\n\n/** Append a query object to a path literal, dropping empty values. */\nexport function withQuery<P extends string>(\n  path: P,\n  query?: Record<string, QueryValue>,\n): P {\n  if (!query) return path;\n  const qs = new URLSearchParams();\n  const appendScalar = (k: string, v: QueryScalar) => {\n    // Drop null / undefined / empty-string so absent params stay absent\n    // (an empty value must not become `?k=` — that can change server behavior).\n    if (v === null || v === undefined || v === \"\") return;\n    qs.append(k, String(v));\n  };\n  for (const [k, v] of Object.entries(query)) {\n    if (Array.isArray(v)) {\n      // Arrays → repeated params (`?k=a&k=b`), matching FastAPI's List[str]\n      // query parsing. An empty array emits nothing.\n      for (const item of v) appendScalar(k, item);\n    } else {\n      appendScalar(k, v as QueryScalar);\n    }\n  }\n  const s = qs.toString();\n  return (s ? `${path}${path.includes(\"?\") ? \"&\" : \"?\"}${s}` : path) as P;\n}\n\n/**\n * GET a JSON endpoint. Response is derived from the contract; the path literal\n * stays contract-checked even with query params (passed via `opts.query`, which\n * `withQuery` serializes onto the URL).\n */\nexport function apiGet<P extends PathWith<\"get\">>(\n  path: P,\n  opts?: RequestOptions & { query?: Record<string, QueryValue> },\n): Envelope<GetResult<P>> {\n  const { query, ...rest } = opts ?? {};\n  return getJson<GetResult<P>>(withQuery(path, query), rest);\n}\n\n/** POST a JSON body. Body AND response are derived from the contract. */\nexport function apiPost<P extends PathWith<\"post\">>(\n  path: P,\n  body: PostBody<P> extends never ? undefined : PostBody<P>,\n  opts?: RequestOptions,\n): Envelope<PostResult<P>> {\n  return postJson<PostResult<P>, PostBody<P>>(path, body as PostBody<P>, opts);\n}\n\n/** PATCH a JSON body. Body AND response are derived from the contract. */\nexport function apiPatch<P extends PathWith<\"patch\">>(\n  path: P,\n  body: PatchBody<P>,\n  opts?: RequestOptions,\n): Envelope<PatchResult<P>> {\n  return patchJson<PatchResult<P>, PatchBody<P>>(path, body, opts);\n}\n\n/** PUT a JSON body. Body AND response are derived from the contract. */\nexport function apiPut<P extends PathWith<\"put\">>(\n  path: P,\n  body: PutBody<P>,\n  opts?: RequestOptions,\n): Envelope<PutResult<P>> {\n  return putJson<PutResult<P>, PutBody<P>>(path, body, opts);\n}\n\n/** DELETE an endpoint. Response is derived from the contract. */\nexport function apiDelete<P extends PathWith<\"delete\">>(\n  path: P,\n  opts?: RequestOptions,\n): Envelope<DeleteResult<P>> {\n  return del<DeleteResult<P>>(path, opts) as Envelope<DeleteResult<P>>;\n}\n\n/**\n * POST a `multipart/form-data` body. The FormData is built by the caller\n * (multipart field values are stringly at the wire), but the RESPONSE is\n * still derived from the contract — killing the unchecked `<T>` assertion\n * that let the preview 400 through. Type the objects you `JSON.stringify`\n * into the form against their generated `components[\"schemas\"][…]` type so\n * the encoded payload can't drift either.\n */\nexport function apiMultipart<P extends PathWith<\"post\">>(\n  path: P,\n  form: FormData,\n  opts?: RequestOptions,\n): Envelope<PostResult<P>> {\n  return postMultipart<PostResult<P>>(path, form, opts);\n}\n"],"mappings":"AAsCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAwEA,SAAS,UACd,UACA,QACG;AACH,SAAQ,SAAoB,QAAQ,gBAAgB,CAAC,GAAG,MAAc;AACpE,UAAM,IAAI,OAAO,CAAC;AAClB,QAAI,MAAM,QAAW;AACnB,YAAM,IAAI;AAAA,QACR,sCAAsC,CAAC,mBAAmB,OAAO,QAAQ,CAAC;AAAA,MAC5E;AAAA,IACF;AACA,WAAO,mBAAmB,OAAO,CAAC,CAAC;AAAA,EACrC,CAAC;AACH;AAYO,SAAS,UACd,MACA,OACG;AACH,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,KAAK,IAAI,gBAAgB;AAC/B,QAAM,eAAe,CAAC,GAAW,MAAmB;AAGlD,QAAI,MAAM,QAAQ,MAAM,UAAa,MAAM,GAAI;AAC/C,OAAG,OAAO,GAAG,OAAO,CAAC,CAAC;AAAA,EACxB;AACA,aAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC1C,QAAI,MAAM,QAAQ,CAAC,GAAG;AAGpB,iBAAW,QAAQ,EAAG,cAAa,GAAG,IAAI;AAAA,IAC5C,OAAO;AACL,mBAAa,GAAG,CAAgB;AAAA,IAClC;AAAA,EACF;AACA,QAAM,IAAI,GAAG,SAAS;AACtB,SAAQ,IAAI,GAAG,IAAI,GAAG,KAAK,SAAS,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC,KAAK;AAC/D;AAOO,SAAS,OACd,MACA,MACwB;AACxB,QAAM,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC;AACpC,SAAO,QAAsB,UAAU,MAAM,KAAK,GAAG,IAAI;AAC3D;AAGO,SAAS,QACd,MACA,MACA,MACyB;AACzB,SAAO,SAAqC,MAAM,MAAqB,IAAI;AAC7E;AAGO,SAAS,SACd,MACA,MACA,MAC0B;AAC1B,SAAO,UAAwC,MAAM,MAAM,IAAI;AACjE;AAGO,SAAS,OACd,MACA,MACA,MACwB;AACxB,SAAO,QAAkC,MAAM,MAAM,IAAI;AAC3D;AAGO,SAAS,UACd,MACA,MAC2B;AAC3B,SAAO,IAAqB,MAAM,IAAI;AACxC;AAUO,SAAS,aACd,MACA,MACA,MACyB;AACzB,SAAO,cAA6B,MAAM,MAAM,IAAI;AACtD;","names":[]}

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

@@ -0,0 +1,22 @@
+/**
+ * `@ai-matrx/media/files/engine` — the Matrx files engine's front door (P16f):
+ * the `cloudFiles` slice and its two middlewares, the file handler (normalize →
+ * resolve → upload → target), our-file URL recognition, the upload guard, and
+ * the host port that wires it to a client. Every engine module is also its own
+ * subpath (`@ai-matrx/media/files/engine/<dir>/<module>`), so a host keeps
+ * module-level imports and mocks.
+ *
+ * Mount: `configureFilesHost({ db, server, store })` once, then put
+ * `cloudFilesReducer` under the `cloudFiles` key and add both middlewares.
+ */
+export { configureFilesHost, isFilesHostConfigured, FilesHostNotConfiguredError, type FilesHost, type FilesServerClient, type FilesShareLinks, type FilesShareLink, type FilesCreateShareLinkOptions, type FilesStore, type FilesScope, type FilesNotifyPort, type FilesRequestOptions, type FilesResponseMeta, type FilesUploadProgressEvent, type FilesDownloadProgressEvent, } from "./host/configure.js";
+export { cloudFilesReducer } from "./redux/slice.js";
+export { cloudFilesRealtimeMiddleware, attachCloudFilesRealtime, detachCloudFilesRealtime, } from "./redux/realtime-middleware.js";
+export { cloudFilesMutationToastMiddleware } from "./redux/mutation-toast-middleware.js";
+export { fileHandler } from "./handler/handler.js";
+export type { FileSource, FileTarget, NormalizedFile, UploadedNormalizedFile, UploadOpts, } from "./handler/types.js";
+export { normalize, fromCloudFile } from "./handler/input/normalize.js";
+export { toMediaRef, toTarget } from "./handler/output/target.js";
+export { OUR_FILE_URL_MARKERS, recognizeOurFileUrl, mightBeOurFileUrl, fileIdFromFileEndpointUrl, type OurFileMatch, } from "./media/our-file-sources.js";
+export { requestUpload, registerUploadGuardHandler, unregisterUploadGuardHandler, type UploadGuardHandler, type UploadGuardResult, } from "./upload/uploadGuardOpeners.js";
+export type { CloudFilesState, CloudFile } from "./types.js";

package/dist/files/engine/index.js

@@ -0,0 +1,49 @@
+import {
+  configureFilesHost,
+  isFilesHostConfigured,
+  FilesHostNotConfiguredError
+} from "./host/configure.js";
+import { cloudFilesReducer } from "./redux/slice.js";
+import {
+  cloudFilesRealtimeMiddleware,
+  attachCloudFilesRealtime,
+  detachCloudFilesRealtime
+} from "./redux/realtime-middleware.js";
+import { cloudFilesMutationToastMiddleware } from "./redux/mutation-toast-middleware.js";
+import { fileHandler } from "./handler/handler.js";
+import { normalize, fromCloudFile } from "./handler/input/normalize.js";
+import { toMediaRef, toTarget } from "./handler/output/target.js";
+import {
+  OUR_FILE_URL_MARKERS,
+  recognizeOurFileUrl,
+  mightBeOurFileUrl,
+  fileIdFromFileEndpointUrl
+} from "./media/our-file-sources.js";
+import {
+  requestUpload,
+  registerUploadGuardHandler,
+  unregisterUploadGuardHandler
+} from "./upload/uploadGuardOpeners.js";
+export {
+  FilesHostNotConfiguredError,
+  OUR_FILE_URL_MARKERS,
+  attachCloudFilesRealtime,
+  cloudFilesMutationToastMiddleware,
+  cloudFilesRealtimeMiddleware,
+  cloudFilesReducer,
+  configureFilesHost,
+  detachCloudFilesRealtime,
+  fileHandler,
+  fileIdFromFileEndpointUrl,
+  fromCloudFile,
+  isFilesHostConfigured,
+  mightBeOurFileUrl,
+  normalize,
+  recognizeOurFileUrl,
+  registerUploadGuardHandler,
+  requestUpload,
+  toMediaRef,
+  toTarget,
+  unregisterUploadGuardHandler
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/files/engine/index.ts"],"sourcesContent":["/**\n * `@ai-matrx/media/files/engine` — the Matrx files engine's front door (P16f):\n * the `cloudFiles` slice and its two middlewares, the file handler (normalize →\n * resolve → upload → target), our-file URL recognition, the upload guard, and\n * the host port that wires it to a client. Every engine module is also its own\n * subpath (`@ai-matrx/media/files/engine/<dir>/<module>`), so a host keeps\n * module-level imports and mocks.\n *\n * Mount: `configureFilesHost({ db, server, store })` once, then put\n * `cloudFilesReducer` under the `cloudFiles` key and add both middlewares.\n */\n\nexport {\n  configureFilesHost,\n  isFilesHostConfigured,\n  FilesHostNotConfiguredError,\n  type FilesHost,\n  type FilesServerClient,\n  type FilesShareLinks,\n  type FilesShareLink,\n  type FilesCreateShareLinkOptions,\n  type FilesStore,\n  type FilesScope,\n  type FilesNotifyPort,\n  type FilesRequestOptions,\n  type FilesResponseMeta,\n  type FilesUploadProgressEvent,\n  type FilesDownloadProgressEvent,\n} from \"./host/configure\";\n\nexport { cloudFilesReducer } from \"./redux/slice\";\nexport {\n  cloudFilesRealtimeMiddleware,\n  attachCloudFilesRealtime,\n  detachCloudFilesRealtime,\n} from \"./redux/realtime-middleware\";\nexport { cloudFilesMutationToastMiddleware } from \"./redux/mutation-toast-middleware\";\n\nexport { fileHandler } from \"./handler/handler\";\nexport type {\n  FileSource,\n  FileTarget,\n  NormalizedFile,\n  UploadedNormalizedFile,\n  UploadOpts,\n} from \"./handler/types\";\nexport { normalize, fromCloudFile } from \"./handler/input/normalize\";\nexport { toMediaRef, toTarget } from \"./handler/output/target\";\n\nexport {\n  OUR_FILE_URL_MARKERS,\n  recognizeOurFileUrl,\n  mightBeOurFileUrl,\n  fileIdFromFileEndpointUrl,\n  type OurFileMatch,\n} from \"./media/our-file-sources\";\n\nexport {\n  requestUpload,\n  registerUploadGuardHandler,\n  unregisterUploadGuardHandler,\n  type UploadGuardHandler,\n  type UploadGuardResult,\n} from \"./upload/uploadGuardOpeners\";\n\nexport type { CloudFilesState, CloudFile } from \"./types\";\n"],"mappings":"AAYA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAaK;AAEP,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,yCAAyC;AAElD,SAAS,mBAAmB;AAQ5B,SAAS,WAAW,qBAAqB;AACzC,SAAS,YAAY,gBAAgB;AAErC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;","names":[]}

package/dist/files/engine/media/our-file-sources.d.ts

@@ -0,0 +1,39 @@
+import type { FileSource } from "../handler/types.js";
+import { fileNameFromUrl, mimeFromUrl } from "@ai-matrx/data/files";
+export { fileNameFromUrl, mimeFromUrl };
+/**
+ * `{base}/files/{file_id}/download[?…]` or `{base}/media/{file_id}/v/{class}`
+ * on our hosts — an identity in disguise (QA F2). Delegates to the package
+ * recognizer; kept as a named export for the block/annotate call sites.
+ */
+export declare function fileIdFromFileEndpointUrl(url: string): string | null;
+export interface OurFileMatch {
+    /** Strongest source we can hand the universal file handler. */
+    source: FileSource;
+    /** Stable identifier when we could recover one (re-mintable forever). */
+    fileId: string | null;
+    /** Best-effort mime sniffed from the URL (query content-type or extension). */
+    mime: string | null;
+    /** Human label for the origin, for debugging / telemetry. */
+    origin: string;
+    /**
+     * Whether the URL itself is durable (non-expiring). A signed S3 URL is NOT
+     * durable, but we still match it because we recovered a `fileId` to re-mint.
+     */
+    durableUrl: boolean;
+}
+/**
+ * The set of host/path markers that identify a URL as ours. This is the cheap
+ * pre-gate (substring test) used by the prefilter + splitter. Keep in sync
+ * with `eslint.config.mjs`.
+ */
+export declare const OUR_FILE_URL_MARKERS: readonly ["matrx-user-files.s3", "cdn.matrxserver", "/podcast-assets/", "/share/", "matrxserver.com/files/", "matrxserver.com/media/"];
+/** Fast substring pre-check — no URL parse. Safe to run on every line. */
+export declare function mightBeOurFileUrl(text: string): boolean;
+/**
+ * Recognize an arbitrary URL as one of our files. Returns the strongest
+ * `FileSource` (identity beats opaque URL) plus a sniffed mime, or `null`
+ * when the URL is not ours. Pure + synchronous — no network. Ordered most
+ * specific / identity-recoverable first; the first match wins.
+ */
+export declare function recognizeOurFileUrl(url: string): OurFileMatch | null;

package/dist/files/engine/media/our-file-sources.js

@@ -0,0 +1,83 @@
+import {
+  createFileUrlRecognizer,
+  fileNameFromUrl,
+  isSignedUrl,
+  mimeFromUrl
+} from "@ai-matrx/data/files";
+import { extractFileIdFromUrl } from "../../../files.js";
+const recognizer = createFileUrlRecognizer();
+function fileIdFromFileEndpointUrl(url) {
+  return recognizer.fileIdFromFileEndpointUrl(url);
+}
+const OUR_FILE_URL_MARKERS = [
+  "matrx-user-files.s3",
+  "cdn.matrxserver",
+  "/podcast-assets/",
+  "/share/",
+  // Authenticated durable byte endpoints on our backend hosts
+  // (`{base}/files/{id}/download`, `{base}/media/{id}/v/{class}`).
+  "matrxserver.com/files/",
+  "matrxserver.com/media/"
+];
+function mightBeOurFileUrl(text) {
+  for (const marker of OUR_FILE_URL_MARKERS) {
+    if (text.includes(marker)) return true;
+  }
+  return false;
+}
+const SHARE_TOKEN_PATH_RE = /\/share\/([^/]+)(?:\/download)?$/i;
+function recognizeOurFileUrl(url) {
+  if (!url || !mightBeOurFileUrl(url)) return null;
+  const mime = mimeFromUrl(url);
+  const durableUrl = !isSignedUrl(url);
+  const match = (origin, source, fileId) => ({ source, fileId, mime, origin, durableUrl });
+  const endpointFileId = recognizer.fileIdFromFileEndpointUrl(url);
+  if (endpointFileId) {
+    return match(
+      "files-endpoint",
+      { kind: "file_id", fileId: endpointFileId, mime: mime ?? void 0 },
+      endpointFileId
+    );
+  }
+  const bucketFileId = recognizer.fileIdFromUserFilesUrl(url);
+  if (bucketFileId) {
+    return match(
+      "user-files-signed",
+      { kind: "file_id", fileId: bucketFileId, mime: mime ?? void 0 },
+      bucketFileId
+    );
+  }
+  let parsed = null;
+  try {
+    parsed = new URL(url);
+  } catch {
+    parsed = null;
+  }
+  if (!parsed) return null;
+  if (/(^|\.)cdn\.matrxserver\.com$/i.test(parsed.hostname)) {
+    const cdnFileId = extractFileIdFromUrl(url);
+    return match(
+      "cdn",
+      cdnFileId ? { kind: "file_id", fileId: cdnFileId, mime: mime ?? void 0 } : { kind: "public_cdn", url, mime: mime ?? void 0 },
+      cdnFileId
+    );
+  }
+  const token = parsed.pathname.match(SHARE_TOKEN_PATH_RE)?.[1] ?? null;
+  if (token) {
+    return match(
+      "share-link",
+      { kind: "share_link", token, mime: mime ?? void 0 },
+      null
+    );
+  }
+  return null;
+}
+export {
+  OUR_FILE_URL_MARKERS,
+  fileIdFromFileEndpointUrl,
+  fileNameFromUrl,
+  mightBeOurFileUrl,
+  mimeFromUrl,
+  recognizeOurFileUrl
+};
+//# sourceMappingURL=our-file-sources.js.map

package/dist/files/engine/media/our-file-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/media/our-file-sources.ts"],"sourcesContent":["// lib/media/our-file-sources.ts\n//\n// \"Is this URL one of OUR files?\" — the host wiring over the canonical\n// recognizer in `@ai-matrx/data/files` (the C9 collapse of the former\n// module-local regex engine). The package owns URL policy: byte-endpoint\n// promotion (QA F2), signed-bucket file_id recovery, CDN detection, mime and\n// file-name sniffing, signed-URL classification. What stays here is HOST\n// IDENTITY only:\n//\n//   - `OUR_FILE_URL_MARKERS` — the cheap substring pre-gate values used by\n//     the prefilter + splitter so plain text and third-party links never pay\n//     for a full `new URL()` parse (keep in sync with `eslint.config.mjs`);\n//   - the mapping from a recognized URL to the handler's `FileSource`\n//     vocabulary (`file_id` / `public_cdn` / `share_link`) — identity beats\n//     an opaque URL, because the handler can re-mint a durable URL from\n//     identity but not from an expiring one.\n\nimport type { FileSource } from \"../handler/types\";\nimport {\n  createFileUrlRecognizer,\n  fileNameFromUrl,\n  isSignedUrl,\n  mimeFromUrl,\n} from \"@ai-matrx/data/files\";\nimport { extractFileIdFromUrl } from \"../../../files\";\n\nexport { fileNameFromUrl, mimeFromUrl };\n\n/** The canonical recognizer, bound to the shipped Matrx origin defaults\n * (`*.matrxserver.com`, the user-files bucket, `cdn.matrxserver.com`).\n * Stateless — the media client's instance shares the same policy. */\nconst recognizer = createFileUrlRecognizer();\n\n/**\n * `{base}/files/{file_id}/download[?…]` or `{base}/media/{file_id}/v/{class}`\n * on our hosts — an identity in disguise (QA F2). Delegates to the package\n * recognizer; kept as a named export for the block/annotate call sites.\n */\nexport function fileIdFromFileEndpointUrl(url: string): string | null {\n  return recognizer.fileIdFromFileEndpointUrl(url);\n}\n\nexport interface OurFileMatch {\n  /** Strongest source we can hand the universal file handler. */\n  source: FileSource;\n  /** Stable identifier when we could recover one (re-mintable forever). */\n  fileId: string | null;\n  /** Best-effort mime sniffed from the URL (query content-type or extension). */\n  mime: string | null;\n  /** Human label for the origin, for debugging / telemetry. */\n  origin: string;\n  /**\n   * Whether the URL itself is durable (non-expiring). A signed S3 URL is NOT\n   * durable, but we still match it because we recovered a `fileId` to re-mint.\n   */\n  durableUrl: boolean;\n}\n\n/**\n * The set of host/path markers that identify a URL as ours. This is the cheap\n * pre-gate (substring test) used by the prefilter + splitter. Keep in sync\n * with `eslint.config.mjs`.\n */\nexport const OUR_FILE_URL_MARKERS = [\n  \"matrx-user-files.s3\",\n  \"cdn.matrxserver\",\n  \"/podcast-assets/\",\n  \"/share/\",\n  // Authenticated durable byte endpoints on our backend hosts\n  // (`{base}/files/{id}/download`, `{base}/media/{id}/v/{class}`).\n  \"matrxserver.com/files/\",\n  \"matrxserver.com/media/\",\n] as const;\n\n/** Fast substring pre-check — no URL parse. Safe to run on every line. */\nexport function mightBeOurFileUrl(text: string): boolean {\n  for (const marker of OUR_FILE_URL_MARKERS) {\n    if (text.includes(marker)) return true;\n  }\n  return false;\n}\n\nconst SHARE_TOKEN_PATH_RE = /\\/share\\/([^/]+)(?:\\/download)?$/i;\n\n/**\n * Recognize an arbitrary URL as one of our files. Returns the strongest\n * `FileSource` (identity beats opaque URL) plus a sniffed mime, or `null`\n * when the URL is not ours. Pure + synchronous — no network. Ordered most\n * specific / identity-recoverable first; the first match wins.\n */\nexport function recognizeOurFileUrl(url: string): OurFileMatch | null {\n  if (!url || !mightBeOurFileUrl(url)) return null;\n\n  const mime = mimeFromUrl(url);\n  const durableUrl = !isSignedUrl(url);\n  const match = (\n    origin: string,\n    source: FileSource,\n    fileId: string | null,\n  ): OurFileMatch => ({ source, fileId, mime, origin, durableUrl });\n\n  // 1. Our authenticated durable byte endpoints → the file_id lane (QA F2).\n  const endpointFileId = recognizer.fileIdFromFileEndpointUrl(url);\n  if (endpointFileId) {\n    return match(\n      \"files-endpoint\",\n      { kind: \"file_id\", fileId: endpointFileId, mime: mime ?? undefined },\n      endpointFileId,\n    );\n  }\n\n  // 2. Legacy signed user-files bucket → recover the file_id so the handler\n  //    re-mints a durable URL forever.\n  const bucketFileId = recognizer.fileIdFromUserFilesUrl(url);\n  if (bucketFileId) {\n    return match(\n      \"user-files-signed\",\n      { kind: \"file_id\", fileId: bucketFileId, mime: mime ?? undefined },\n      bucketFileId,\n    );\n  }\n\n  let parsed: URL | null = null;\n  try {\n    parsed = new URL(url);\n  } catch {\n    parsed = null;\n  }\n  if (!parsed) return null;\n\n  // 3. Public CDN — recover the file_id when present (durable identity);\n  //    otherwise the CDN URL is itself durable so we use it as-is.\n  if (/(^|\\.)cdn\\.matrxserver\\.com$/i.test(parsed.hostname)) {\n    const cdnFileId = extractFileIdFromUrl(url);\n    return match(\n      \"cdn\",\n      cdnFileId\n        ? { kind: \"file_id\", fileId: cdnFileId, mime: mime ?? undefined }\n        : { kind: \"public_cdn\", url, mime: mime ?? undefined },\n      cdnFileId,\n    );\n  }\n\n  // 4. Share-link byte endpoint — `{backend}/share/{token}[/download]`. The\n  //    handler resolves bytes by token; lifetime is backend-managed.\n  const token = parsed.pathname.match(SHARE_TOKEN_PATH_RE)?.[1] ?? null;\n  if (token) {\n    return match(\n      \"share-link\",\n      { kind: \"share_link\", token, mime: mime ?? undefined },\n      null,\n    );\n  }\n\n  return null;\n}\n"],"mappings":"AAkBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,4BAA4B;AAOrC,MAAM,aAAa,wBAAwB;AAOpC,SAAS,0BAA0B,KAA4B;AACpE,SAAO,WAAW,0BAA0B,GAAG;AACjD;AAuBO,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA,EAGA;AAAA,EACA;AACF;AAGO,SAAS,kBAAkB,MAAuB;AACvD,aAAW,UAAU,sBAAsB;AACzC,QAAI,KAAK,SAAS,MAAM,EAAG,QAAO;AAAA,EACpC;AACA,SAAO;AACT;AAEA,MAAM,sBAAsB;AAQrB,SAAS,oBAAoB,KAAkC;AACpE,MAAI,CAAC,OAAO,CAAC,kBAAkB,GAAG,EAAG,QAAO;AAE5C,QAAM,OAAO,YAAY,GAAG;AAC5B,QAAM,aAAa,CAAC,YAAY,GAAG;AACnC,QAAM,QAAQ,CACZ,QACA,QACA,YACkB,EAAE,QAAQ,QAAQ,MAAM,QAAQ,WAAW;AAG/D,QAAM,iBAAiB,WAAW,0BAA0B,GAAG;AAC/D,MAAI,gBAAgB;AAClB,WAAO;AAAA,MACL;AAAA,MACA,EAAE,MAAM,WAAW,QAAQ,gBAAgB,MAAM,QAAQ,OAAU;AAAA,MACnE;AAAA,IACF;AAAA,EACF;AAIA,QAAM,eAAe,WAAW,uBAAuB,GAAG;AAC1D,MAAI,cAAc;AAChB,WAAO;AAAA,MACL;AAAA,MACA,EAAE,MAAM,WAAW,QAAQ,cAAc,MAAM,QAAQ,OAAU;AAAA,MACjE;AAAA,IACF;AAAA,EACF;AAEA,MAAI,SAAqB;AACzB,MAAI;AACF,aAAS,IAAI,IAAI,GAAG;AAAA,EACtB,QAAQ;AACN,aAAS;AAAA,EACX;AACA,MAAI,CAAC,OAAQ,QAAO;AAIpB,MAAI,gCAAgC,KAAK,OAAO,QAAQ,GAAG;AACzD,UAAM,YAAY,qBAAqB,GAAG;AAC1C,WAAO;AAAA,MACL;AAAA,MACA,YACI,EAAE,MAAM,WAAW,QAAQ,WAAW,MAAM,QAAQ,OAAU,IAC9D,EAAE,MAAM,cAAc,KAAK,MAAM,QAAQ,OAAU;AAAA,MACvD;AAAA,IACF;AAAA,EACF;AAIA,QAAM,QAAQ,OAAO,SAAS,MAAM,mBAAmB,IAAI,CAAC,KAAK;AACjE,MAAI,OAAO;AACT,WAAO;AAAA,MACL;AAAA,MACA,EAAE,MAAM,cAAc,OAAO,MAAM,QAAQ,OAAU;AAAA,MACrD;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/files/engine/media/signed-url.d.ts

@@ -0,0 +1 @@
+export { isSignedUrl, SIGNED_URL_RE } from "@ai-matrx/data/files";

package/dist/files/engine/media/signed-url.js

@@ -0,0 +1,6 @@
+import { isSignedUrl, SIGNED_URL_RE } from "@ai-matrx/data/files";
+export {
+  SIGNED_URL_RE,
+  isSignedUrl
+};
+//# sourceMappingURL=signed-url.js.map

package/dist/files/engine/media/signed-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/files/engine/media/signed-url.ts"],"sourcesContent":["// lib/media/signed-url.ts\n//\n// THE single source of truth for \"is this a LEGACY signed, time-limited URL?\"\n// is now `@ai-matrx/data/files` (the C9 collapse) — both AWS signing dialects,\n// one regex, canonical in the package. Re-exported here so the existing call\n// sites (durability guards, adapters) keep one import path. The service\n// worker keeps its own byte-identical mirror (`cache/service-worker/src/sw.ts`\n// has no app imports) — change the package and the mirror together.\n\nexport { isSignedUrl, SIGNED_URL_RE } from \"@ai-matrx/data/files\";\n"],"mappings":"AASA,SAAS,aAAa,qBAAqB;","names":[]}

package/dist/files/engine/redux/converters.d.ts

@@ -0,0 +1,73 @@
+/**
+ * features/files/redux/converters.ts
+ *
+ * Pure functions that translate DB rows (snake_case) and REST API shapes
+ * (snake_case) into the domain types (camelCase) used throughout the app.
+ *
+ * No Redux, no Supabase client — these are pure and testable.
+ */
+import type { CloudFile, CloudFilePermission, CloudFilePermissionRow, CloudFileReadRow, CloudFileVersion, CloudFileVersionReadRow, CloudFolder, CloudFolderRow, CloudShareLink, CloudTreeRow, FileRecordApi, IamResourcePermissionRpcRow, MediaRef, ResourceType } from "../types.js";
+import type { ShareLink as CanonicalShareLink } from "../host/share-links.js";
+import { toVisibility, fileIdToMediaRef, urlToMediaRef } from "../../../files.js";
+export { toVisibility, fileIdToMediaRef, urlToMediaRef };
+export declare function dbRowToCloudFile(row: CloudFileReadRow): CloudFile;
+/**
+ * Convert the REST API's FileRecord (snake_case) to the domain type. Shape
+ * is identical to CloudFileRow modulo a few nullable defaults.
+ */
+export declare function apiFileRecordToCloudFile(row: FileRecordApi): CloudFile;
+export declare function dbRowToCloudFolder(row: CloudFolderRow): CloudFolder;
+export declare function dbRowToCloudFileVersion(row: CloudFileVersionReadRow): CloudFileVersion;
+/**
+ * Map a canonical `iam.permissions` row (resource_type='file') into the file
+ * domain's grant shape.
+ *
+ * `iam.permissions` distinguishes the grant target by which of three mutually-
+ * exclusive columns is set — enforced by the CHECK `user_or_org_or_public`:
+ *   - user grant:   `granted_to_user_id` set    → `granteeType: "user"`,   `granteeId` = user id
+ *   - org grant:    `granted_to_organization_id`→ `granteeType: "group"`,  `granteeId` = org id
+ *   - public grant: `is_public = true` (both FKs null) → `granteeType: "public"`
+ *
+ * A PUBLIC grant has no grantee id. We must NOT collapse it to a
+ * `granteeType: "user"` grant with `granteeId: ""` — that silently mislabels
+ * "anyone with access" as an empty user grant (member counts, avatar stacks,
+ * and the user/group revoke path all then act on a bogus "" grantee). Instead
+ * it is modeled distinctly (`granteeType: "public"`) and carries the row's own
+ * `id` as `granteeId` so the value is real and unique (never `""`). Downstream
+ * member/avatar UIs exclude `"public"` grants; revoking one flips the
+ * resource's visibility rather than deleting a by-grantee grant.
+ *
+ * Grant expiry: `iam.permissions.expires_at` (timestamptz, nullable) is the
+ * canonical column — wire it straight through to the domain's `expiresAt`.
+ */
+export declare function dbRowToCloudFilePermission(row: CloudFilePermissionRow): CloudFilePermission;
+/**
+ * Map the summary JSON from `iam.fn_*_resource_permission` RPCs into the file
+ * domain shape. The RPC omits the row `id` and canonical columns — callers
+ * that need the full row should read `iam.permissions` directly (see
+ * `loadPermissions`).
+ */
+export declare function rpcPermissionRowToCloudFilePermission(row: IamResourcePermissionRpcRow): CloudFilePermission;
+/**
+ * Map a canonical share link (`utils/permissions/shareLinks.ts` `ShareLink`,
+ * from the `list_share_links` / `create_share_link` RPC family over
+ * `platform.share_links`) into the file domain shape. The RPCs don't echo the
+ * resource identity, so the caller supplies it.
+ */
+export declare function canonicalShareLinkToCloudShareLink(link: CanonicalShareLink, resourceType: ResourceType, resourceId: string): CloudShareLink;
+/**
+ * Parse one row from `cloud_get_user_file_tree`. Returns null if the row
+ * doesn't have enough shape to use.
+ *
+ * Supports two shapes:
+ *   - Explicit `kind: 'file' | 'folder'` discriminator.
+ *   - Implicit: presence of `file_name` vs `folder_name`.
+ */
+export declare function parseCloudTreeRow(raw: unknown): CloudTreeRow | null;
+/**
+ * Parse the full RPC return (array of rows). Skips malformed rows rather than
+ * throwing — a single bad row shouldn't blank the tree.
+ */
+export declare function parseCloudTreeRows(raw: unknown): CloudTreeRow[];
+/** Build a MediaRef from an in-store CloudFile. Prefers `file_id`. */
+export declare function cloudFileToMediaRef(file: CloudFile): MediaRef;