diff --git a/apps/web/src/pages/library-page.tsx b/apps/web/src/pages/library-page.tsx
index 14e26c6b5..e53bf2235 100644
--- a/apps/web/src/pages/library-page.tsx
+++ b/apps/web/src/pages/library-page.tsx
@@ -32,6 +32,7 @@ import {
   ArtifactRenderer,
   artifactMatchesLibraryKindSegment,
   filterArtifacts,
+  isTextDecodableMediaType,
   libraryArtifactIdFromPath,
   libraryKindSegmentFromPath,
   resolveArtifactRendererKind,
@@ -84,6 +85,7 @@ import {
   LIBRARY_BULK_OPERATION_IDS,
   mapArtifactListToSummaries,
   uploadArtifactFiles,
+  uploadMimeTypeFromSource,
 } from "../shell/library-artifacts";
 import { StageTopBar } from "../shell/stage-top-bar";
 
@@ -250,6 +252,19 @@ function PreviewPane({
     detail !== null && rendererKind === "html" && tenantId !== null
       ? artifactPreviewPath(tenantId, detail.id)
       : undefined;
+  // Empty `content` on a file artifact is ambiguous on its own: it's the
+  // honest "nothing here" for an inline-content artifact, but it's also
+  // what a real upload's row carries when its bytes live out-of-band and
+  // aren't text-decodable (an image, a real PDF, a legacy `.docx`/`.xlsx`).
+  // `source.upload.mimeType` disambiguates — present only when this
+  // artifact really does have stored bytes behind it.
+  const uploadMimeType =
+    detail !== null ? uploadMimeTypeFromSource(detail.source) : null;
+  const contentUnavailable =
+    detail !== null &&
+    detail.content === "" &&
+    uploadMimeType !== null &&
+    !isTextDecodableMediaType(uploadMimeType);
   return (
     <aside className="flex min-h-0 min-w-0 flex-col border-l border-border bg-card">
       <div className="flex items-center justify-between gap-2 border-b border-border px-4 py-3">
@@ -301,6 +316,7 @@ function PreviewPane({
             rendererKind={rendererKind}
             title={detail.title}
             content={detail.content}
+            contentUnavailable={contentUnavailable}
             {...(previewSrc !== undefined ? { previewSrc } : {})}
           />
         ) : null}
diff --git a/apps/web/src/shell/library-artifacts.test.ts b/apps/web/src/shell/library-artifacts.test.ts
index 27b930654..a11c4946e 100644
--- a/apps/web/src/shell/library-artifacts.test.ts
+++ b/apps/web/src/shell/library-artifacts.test.ts
@@ -4,6 +4,7 @@ import {
   artifactUploadToast,
   copyArtifactLinksActionLabel,
   copyArtifactLinksToastLabel,
+  uploadMimeTypeFromSource,
 } from "./library-artifacts";
 
 describe("copy-link labels", () => {
@@ -31,3 +32,23 @@ describe("artifactUploadToast", () => {
     );
   });
 });
+
+describe("uploadMimeTypeFromSource", () => {
+  test("reads the mime type off a real upload's source", () => {
+    expect(
+      uploadMimeTypeFromSource({
+        origin: "library-upload",
+        upload: { id: "u1", mimeType: "text/markdown", filename: "a.md" },
+      }),
+    ).toBe("text/markdown");
+  });
+
+  test("is null for an artifact with no upload backing", () => {
+    expect(uploadMimeTypeFromSource({ origin: "chat" })).toBeNull();
+  });
+
+  test("is null when the upload field is malformed", () => {
+    expect(uploadMimeTypeFromSource({ upload: "not-an-object" })).toBeNull();
+    expect(uploadMimeTypeFromSource({ upload: { id: "u1" } })).toBeNull();
+  });
+});
diff --git a/apps/web/src/shell/library-artifacts.ts b/apps/web/src/shell/library-artifacts.ts
index 78c97e287..f17df0a08 100644
--- a/apps/web/src/shell/library-artifacts.ts
+++ b/apps/web/src/shell/library-artifacts.ts
@@ -150,3 +150,20 @@ export function copyArtifactLinksToastLabel(count: number): string {
 export function copyArtifactLinksActionLabel(count: number): string {
   return count > 1 ? `Copy ${count} links` : "Copy link";
 }
+
+/**
+ * The MIME type of a file artifact's out-of-band upload blob, read off
+ * `source.upload.mimeType` — present on every artifact minted through
+ * `createFileArtifact` (`@corbits/artifacts`), regardless of whether the
+ * hub could inline its bytes into `content` as text. Null for an artifact
+ * with no upload backing at all (e.g. a co-edited doc), which is the only
+ * case where an empty `content` genuinely means "nothing here yet."
+ */
+export function uploadMimeTypeFromSource(
+  source: Record<string, unknown>,
+): string | null {
+  const upload = source.upload;
+  if (typeof upload !== "object" || upload === null) return null;
+  const mimeType = (upload as Record<string, unknown>).mimeType;
+  return typeof mimeType === "string" ? mimeType : null;
+}
diff --git a/packages/artifact-ui/package.json b/packages/artifact-ui/package.json
index 8217e7222..916ad7d5a 100644
--- a/packages/artifact-ui/package.json
+++ b/packages/artifact-ui/package.json
@@ -8,7 +8,8 @@
   "sideEffects": false,
   "exports": {
     ".": "./src/index.ts",
-    "./kind-filter": "./src/kind-filter.ts"
+    "./kind-filter": "./src/kind-filter.ts",
+    "./renderer-kind": "./src/renderer-kind.ts"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
diff --git a/packages/artifact-ui/src/artifact-renderer.tsx b/packages/artifact-ui/src/artifact-renderer.tsx
index 95029fec9..379eb47f4 100644
--- a/packages/artifact-ui/src/artifact-renderer.tsx
+++ b/packages/artifact-ui/src/artifact-renderer.tsx
@@ -18,6 +18,17 @@ export type ArtifactRenderProps = {
    * never distinguished from "not fetched yet" (the host's own loading
    * state handles that before this component ever mounts). */
   readonly content: string;
+  /**
+   * True when `content` is empty NOT because the artifact is genuinely
+   * blank, but because its real bytes are stored out-of-band (a file
+   * upload) in a format this renderer can't decode as text — a binary
+   * `.docx`/`.xlsx`, an image, a real PDF. Empty `content` alone can't
+   * carry that distinction, so the host that fetched the artifact passes
+   * it explicitly. Swaps the per-kind "no content yet" copy for an honest
+   * "couldn't read this file" message — the artifact was NOT uploaded
+   * empty, its contents just can't be shown here.
+   */
+  readonly contentUnavailable?: boolean;
   /** Overrides the default "unsupported" copy with something specific to
    * why this content can't be shown (e.g. a binary MIME type). */
   readonly unavailableReason?: string;
@@ -67,9 +78,23 @@ function parseDocLines(content: string): readonly DocLine[] {
     });
 }
 
-function DocRenderer({ content }: { readonly content: string }) {
+function DocRenderer({
+  content,
+  contentUnavailable,
+}: {
+  readonly content: string;
+  readonly contentUnavailable: boolean;
+}) {
   if (content === "") {
-    return <EmptyContent message="This document has no content yet." />;
+    return (
+      <EmptyContent
+        message={
+          contentUnavailable
+            ? "We couldn't read this file's contents for preview."
+            : "This document has no content yet."
+        }
+      />
+    );
   }
   const lines = parseDocLines(content);
   const HeadingTag = ["h1", "h2", "h3"] as const;
@@ -97,9 +122,23 @@ function DocRenderer({ content }: { readonly content: string }) {
   );
 }
 
-function SheetRenderer({ content }: { readonly content: string }) {
+function SheetRenderer({
+  content,
+  contentUnavailable,
+}: {
+  readonly content: string;
+  readonly contentUnavailable: boolean;
+}) {
   if (content === "") {
-    return <EmptyContent message="This sheet has no rows yet." />;
+    return (
+      <EmptyContent
+        message={
+          contentUnavailable
+            ? "We couldn't read this file's contents for preview."
+            : "This sheet has no rows yet."
+        }
+      />
+    );
   }
   return <CsvTable text={content} caption="Sheet contents" />;
 }
@@ -111,13 +150,21 @@ function SheetRenderer({ content }: { readonly content: string }) {
 function PdfRenderer({
   title,
   content,
+  contentUnavailable,
 }: {
   readonly title: string;
   readonly content: string;
+  readonly contentUnavailable: boolean;
 }) {
   if (content === "") {
     return (
-      <EmptyContent message="No extracted text is stored for this PDF — inline preview isn't available yet." />
+      <EmptyContent
+        message={
+          contentUnavailable
+            ? "We couldn't read this file's contents for preview."
+            : "No extracted text is stored for this PDF — inline preview isn't available yet."
+        }
+      />
     );
   }
   return (
@@ -181,16 +228,33 @@ export function ArtifactRenderer({
   rendererKind,
   title,
   content,
+  contentUnavailable,
   unavailableReason,
   previewSrc,
 }: ArtifactRenderProps) {
   switch (rendererKind) {
     case "doc":
-      return <DocRenderer content={content} />;
+      return (
+        <DocRenderer
+          content={content}
+          contentUnavailable={contentUnavailable ?? false}
+        />
+      );
     case "sheet":
-      return <SheetRenderer content={content} />;
+      return (
+        <SheetRenderer
+          content={content}
+          contentUnavailable={contentUnavailable ?? false}
+        />
+      );
     case "pdf":
-      return <PdfRenderer title={title} content={content} />;
+      return (
+        <PdfRenderer
+          title={title}
+          content={content}
+          contentUnavailable={contentUnavailable ?? false}
+        />
+      );
     case "html":
       return (
         <HtmlPreviewRenderer
diff --git a/packages/artifact-ui/test/artifact-renderer.test.tsx b/packages/artifact-ui/test/artifact-renderer.test.tsx
index f31e6c543..4a654992e 100644
--- a/packages/artifact-ui/test/artifact-renderer.test.tsx
+++ b/packages/artifact-ui/test/artifact-renderer.test.tsx
@@ -58,6 +58,60 @@ describe("ArtifactRenderer sheet cutover", () => {
   });
 });
 
+describe("ArtifactRenderer contentUnavailable — stored-but-unreadable file", () => {
+  test("doc renderer says the file couldn't be read, not that it's empty", () => {
+    const markup = renderToStaticMarkup(
+      <ArtifactRenderer
+        rendererKind="doc"
+        title="notes.docx"
+        content=""
+        contentUnavailable
+      />,
+    );
+    expect(markup).toContain(
+      "We couldn&#x27;t read this file&#x27;s contents for preview.",
+    );
+    expect(markup).not.toContain("This document has no content yet.");
+  });
+
+  test("sheet renderer says the file couldn't be read, not that it's empty", () => {
+    const markup = renderToStaticMarkup(
+      <ArtifactRenderer
+        rendererKind="sheet"
+        title="budget.xlsx"
+        content=""
+        contentUnavailable
+      />,
+    );
+    expect(markup).toContain(
+      "We couldn&#x27;t read this file&#x27;s contents for preview.",
+    );
+    expect(markup).not.toContain("This sheet has no rows yet.");
+  });
+
+  test("pdf renderer says the file couldn't be read, not that no text is stored", () => {
+    const markup = renderToStaticMarkup(
+      <ArtifactRenderer
+        rendererKind="pdf"
+        title="contract.pdf"
+        content=""
+        contentUnavailable
+      />,
+    );
+    expect(markup).toContain(
+      "We couldn&#x27;t read this file&#x27;s contents for preview.",
+    );
+    expect(markup).not.toContain("No extracted text is stored");
+  });
+
+  test("a genuinely empty doc still reads as empty, not unreadable", () => {
+    const markup = renderToStaticMarkup(
+      <ArtifactRenderer rendererKind="doc" title="Untitled" content="" />,
+    );
+    expect(markup).toContain("This document has no content yet.");
+  });
+});
+
 describe("ArtifactRenderer html preview", () => {
   test("renders a sandboxed iframe pointed at the preview route", () => {
     const markup = renderToStaticMarkup(
diff --git a/packages/artifacts-hub/src/routes.test.ts b/packages/artifacts-hub/src/routes.test.ts
index ae7cf2ca4..18ebbfce1 100644
--- a/packages/artifacts-hub/src/routes.test.ts
+++ b/packages/artifacts-hub/src/routes.test.ts
@@ -1,10 +1,12 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 import type { RequireGrant } from "@intx/hub-api";
+import type { ArtifactDb, ArtifactRow, ContentStore } from "@corbits/artifacts";
 import { Hono } from "hono";
 
 import {
   createArtifactRoutes,
   createUnavailableArtifactRoutes,
+  resolvePreviewableContent,
   type ArtifactPreviewResult,
   type ArtifactRoutesStore,
   type ArtifactUploadInput,
@@ -248,6 +250,25 @@ describe("artifact routes", () => {
     expect(res.status).toBe(400);
   });
 
+  test("POST /upload rejects a file over the per-file byte limit instead of storing it empty", async () => {
+    const oversized = new Uint8Array(10 * 1024 * 1024 + 1);
+    const form = new FormData();
+    form.append(
+      "file",
+      new File([oversized], "huge.txt", { type: "text/plain" }),
+    );
+    const res = await app.request("/artifacts/upload", {
+      method: "POST",
+      body: form,
+    });
+    expect(res.status).toBe(413);
+    const body = (await res.json()) as { error: { code: string } };
+    expect(body.error.code).toBe("payload_too_large");
+    // The whole point: an oversized file never reaches the store at all, so
+    // there is no empty/partial artifact row left behind to look uploaded.
+    expect(store.rows).toHaveLength(0);
+  });
+
   test("GET /counts is all zero for a tenant with no artifacts", async () => {
     const res = await app.request("/artifacts/counts");
     expect(res.status).toBe(200);
@@ -442,3 +463,96 @@ describe("unavailable artifact routes", () => {
     }
   });
 });
+
+describe("resolvePreviewableContent", () => {
+  const NOT_CALLED: ArtifactDb = undefined as unknown as ArtifactDb;
+
+  function blobBackedRow(overrides: Partial<ArtifactRow> = {}): ArtifactRow {
+    return {
+      id: "a1",
+      tenantId: "tenant_a",
+      principalId: "prin_1",
+      ownerPrincipalId: "prin_1",
+      kind: "file",
+      title: "SKILL.md",
+      content: "",
+      source: { origin: "library-upload", upload: { id: "up_1" } },
+      version: 1,
+      archivedAt: null,
+      createdAt: new Date("2026-01-01T00:00:00.000Z"),
+      updatedAt: new Date("2026-01-01T00:00:00.000Z"),
+      ...overrides,
+    } as ArtifactRow;
+  }
+
+  function contentStoreReturning(
+    blob: { filename: string; mimeType: string; bytes: Uint8Array } | null,
+  ): ContentStore {
+    return {
+      put: () => {
+        throw new Error(
+          "put should not be called by resolvePreviewableContent",
+        );
+      },
+      get: async () => blob,
+    };
+  }
+
+  test("inlines the out-of-band blob when it decodes as text", async () => {
+    const bytes = new TextEncoder().encode("---\nname: SKILL\n---\nbody");
+    const store = contentStoreReturning({
+      filename: "SKILL.md",
+      mimeType: "text/markdown",
+      bytes,
+    });
+    const content = await resolvePreviewableContent(
+      NOT_CALLED,
+      store,
+      blobBackedRow(),
+    );
+    expect(content).toBe("---\nname: SKILL\n---\nbody");
+  });
+
+  test("leaves content empty for a non-text-decodable blob instead of decoding garbage", async () => {
+    const store = contentStoreReturning({
+      filename: "photo.png",
+      mimeType: "image/png",
+      bytes: new Uint8Array([0x89, 0x50, 0x4e, 0x47]),
+    });
+    const content = await resolvePreviewableContent(
+      NOT_CALLED,
+      store,
+      blobBackedRow({ title: "photo.png" }),
+    );
+    expect(content).toBe("");
+  });
+
+  test("never touches the content store when the row already carries inline content", async () => {
+    const store: ContentStore = {
+      put: () => {
+        throw new Error("put should not be called");
+      },
+      get: () => {
+        throw new Error(
+          "get should not be called when content is already inline",
+        );
+      },
+    };
+    const content = await resolvePreviewableContent(
+      NOT_CALLED,
+      store,
+      blobBackedRow({ content: "already inline", source: {} }),
+    );
+    expect(content).toBe("already inline");
+  });
+
+  test("leaves content empty when the referenced blob cannot be found", async () => {
+    const store = contentStoreReturning(null);
+    const content = await resolvePreviewableContent(
+      NOT_CALLED,
+      store,
+      blobBackedRow(),
+    );
+    expect(content).toBe("");
+  });
+});
diff --git a/packages/artifacts-hub/src/routes.ts b/packages/artifacts-hub/src/routes.ts
index 2ed84510a..dd36032c2 100644
--- a/packages/artifacts-hub/src/routes.ts
+++ b/packages/artifacts-hub/src/routes.ts
@@ -20,6 +20,7 @@ import {
   serializeArtifactListItem,
   UnsupportedUploadTypeError,
   type ArtifactDb,
+  type ArtifactRow,
   type ContentStore,
   type SerializedArtifact,
   type SerializedArtifactListItem,
@@ -29,6 +30,7 @@ import {
   artifactMatchesLibraryKindSegment,
   type LibraryKindSegment,
 } from "@corbits/artifact-ui/kind-filter";
+import { isTextDecodableMediaType } from "@corbits/artifact-ui/renderer-kind";
 import type { RequireGrant, TenantEnv } from "@intx/hub-api";
 import { Hono } from "hono";
 
@@ -91,6 +93,36 @@ function baseMimeType(mimeType: string): string {
   return mimeType.split(";")[0]?.trim().toLowerCase() ?? "";
 }
 
+/**
+ * `createFileArtifact` (the ONE path a browser upload goes through) always
+ * leaves the artifact row's own `content` column empty — the bytes it just
+ * accepted live out-of-band, in `ContentStore`, referenced by
+ * `source.upload.id`. That is correct for the store, but a naive detail read
+ * of `content` alone reads back as "no content" even when the upload was a
+ * plain-text file (Markdown, CSV, JSON, ...) whose bytes are intact.
+ *
+ * This resolves the out-of-band blob and inlines it into `content` whenever
+ * it decodes as text — the same thing `/preview` already does for HTML,
+ * generalized to every text-decodable MIME type. A non-text blob (an image,
+ * a real PDF, a legacy `.docx`) is left as `""`: its bytes are still safe in
+ * the content store, this route only ever projects them into `content` when
+ * doing so is an honest text rendering.
+ */
+export async function resolvePreviewableContent(
+  db: ArtifactDb,
+  contentStore: ContentStore,
+  row: ArtifactRow,
+): Promise<string> {
+  if (row.content !== "") return row.content;
+  const download = await resolveDownload(db, contentStore, row, false);
+  if ("status" in download || !isTextDecodableMediaType(download.mimeType)) {
+    return row.content;
+  }
+  return typeof download.body === "string"
+    ? download.body
+    : new TextDecoder().decode(download.body);
+}
+
 export type CreateArtifactRoutesDeps = {
   store: ArtifactRoutesStore;
   requireGrant: RequireGrant;
@@ -216,7 +248,8 @@ export function createArtifactDbStore(
     async get(tenantId, artifactId) {
       const row = await getArtifact(db, artifactId);
       if (row === null || row.tenantId !== tenantId) return null;
-      return serializeArtifact(row);
+      const content = await resolvePreviewableContent(db, contentStore, row);
+      return { ...serializeArtifact(row), content };
     },
     async upload(tenantId, principalId, files) {
       const scope = { tenantId, principalId };