@anthusai/papyrus 5.50.0 → 5.52.0

package/components/topic-steering-workspace.tsx

@@ -103,7 +103,8 @@ import { NewsroomCurationBootstrap } from "./newsroom-curation-bootstrap";
 import { NewsroomReferencesView } from "./newsroom-references-view";
 import { NewsroomAssignmentsView } from "./newsroom-assignments-view";
 import { NewsroomTopicsView } from "./newsroom-topics-view";
-import { NewsroomOpsSearchButton, NewsroomOpsSectionIntro, NewsroomOpsShell, NewsroomOpsStatusBanner, type NewsroomNavCount } from "./newsroom-ops-shell";
+import { MarkdownContext } from "./markdown-context";
+import { NewsroomOpsSectionIntro, NewsroomOpsShell, NewsroomOpsStatusBanner, type NewsroomNavCount } from "./newsroom-ops-shell";
 import { Button, buttonVariants } from "./ui/button";
 import { Badge } from "./ui/badge";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "./ui/tabs";
@@ -3060,14 +3061,8 @@ function NewsDeskDashboard({
             {dashboard.isDemo ? (
               dashboard.realDataPreview ? null : <Badge variant="outline">Demo</Badge>
             ) : (
-              <Link className={cn(buttonVariants({ variant: "ghost", size: "sm" }))} href="/settings">Settings</Link>
+              <Link className={cn(buttonVariants({ variant: "ghost", size: "sm" }), "organizer-header-settings")} href="/settings">Settings</Link>
             )}
-            {canEdit && editorShellReady && !dashboard.isDemo ? (
-              <NewsroomOpsSearchButton
-                disabled={false}
-                onPress={activeTab === "search" ? focusNewsroomSearchForm : topBarSearchControl.open}
-              />
-            ) : null}
             <NewsroomConsoleProgressToggle />
           </>
         )}
@@ -9861,415 +9856,6 @@ function SearchDeskView({
   );
 }
 
-function MarkdownContext({ className, text }: { className?: string; text: string }) {
-  const blocks = useMemo(() => parseMarkdownBlocks(normalizeMarkdownForRendering(text)), [text]);
-  return (
-    <div className={className ? `news-desk-markdown-context ${className}` : "news-desk-markdown-context"}>
-      {blocks.map((block, index) => renderMarkdownBlock(block, index))}
-    </div>
-  );
-}
-
-type MarkdownBlock =
-  | { type: "code"; text: string }
-  | { type: "heading"; depth: number; text: string }
-  | { type: "list"; items: string[]; ordered: boolean }
-  | { type: "table"; headers: string[]; rows: string[][] }
-  | { type: "paragraph"; text: string };
-
-function normalizeMarkdownForRendering(text: string): string {
-  const trimmed = text.trim();
-  const fencedMarkdown = /^```(?:markdown|md|mdx)?\s*\n([\s\S]*?)\n```$/i.exec(trimmed);
-  const unwrapped = fencedMarkdown ? (fencedMarkdown[1] ?? "") : text;
-  return normalizeMultilineMarkdownLinks(unwrapped);
-}
-
-function parseMarkdownBlocks(text: string): MarkdownBlock[] {
-  const blocks: MarkdownBlock[] = [];
-  const lines = text.split(/\r?\n/);
-  let paragraph: string[] = [];
-  let list: string[] = [];
-  let listOrdered = false;
-  let code: string[] = [];
-  let inCode = false;
-  const flushParagraph = () => {
-    if (paragraph.length) {
-      blocks.push({ type: "paragraph", text: paragraph.join(" ").trim() });
-      paragraph = [];
-    }
-  };
-  const flushList = () => {
-    if (list.length) {
-      blocks.push({ type: "list", items: list, ordered: listOrdered });
-      list = [];
-      listOrdered = false;
-    }
-  };
-  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-    const line = lines[lineIndex];
-    if (line.trim().startsWith("```")) {
-      if (inCode) {
-        blocks.push({ type: "code", text: code.join("\n") });
-        code = [];
-        inCode = false;
-      } else {
-        flushParagraph();
-        flushList();
-        inCode = true;
-      }
-      continue;
-    }
-    if (inCode) {
-      code.push(line);
-      continue;
-    }
-    const trimmed = line.trim();
-    if (!trimmed) {
-      flushParagraph();
-      flushList();
-      continue;
-    }
-    if (
-      lineIndex + 1 < lines.length
-      && looksLikeMarkdownTableHeaderLine(line)
-      && isMarkdownTableDividerLine(lines[lineIndex + 1] ?? "")
-    ) {
-      flushParagraph();
-      flushList();
-      const headerCells = splitMarkdownTableCells(line);
-      const dividerCells = splitMarkdownTableCells(lines[lineIndex + 1] ?? "");
-      const columnCount = Math.max(headerCells.length, dividerCells.length, 1);
-      const headers = normalizeMarkdownTableCells(headerCells, columnCount);
-      const rows: string[][] = [];
-      lineIndex += 2;
-      while (lineIndex < lines.length) {
-        const rowLine = lines[lineIndex] ?? "";
-        if (!looksLikeMarkdownTableRowLine(rowLine)) {
-          lineIndex -= 1;
-          break;
-        }
-        rows.push(normalizeMarkdownTableCells(splitMarkdownTableCells(rowLine), columnCount));
-        lineIndex += 1;
-      }
-      if (lineIndex >= lines.length) lineIndex -= 1;
-      blocks.push({ type: "table", headers, rows });
-      continue;
-    }
-    const heading = /^(#{1,4})\s+(.+)$/.exec(trimmed);
-    if (heading) {
-      flushParagraph();
-      flushList();
-      blocks.push({ type: "heading", depth: heading[1].length, text: heading[2].trim() });
-      continue;
-    }
-    const bullet = /^(?:([-*+])\s+|(\d+)[.)]\s+)(.+)$/.exec(trimmed);
-    if (bullet) {
-      flushParagraph();
-      const ordered = Boolean(bullet[2]);
-      if (list.length && listOrdered !== ordered) flushList();
-      listOrdered = ordered;
-      list.push((bullet[3] ?? "").trim());
-      continue;
-    }
-    flushList();
-    paragraph.push(trimmed);
-  }
-  flushParagraph();
-  flushList();
-  if (code.length) blocks.push({ type: "code", text: code.join("\n") });
-  return blocks;
-}
-
-function renderMarkdownBlock(block: MarkdownBlock, index: number): ReactNode {
-  const key = `${block.type}-${index}`;
-  if (block.type === "code") return <pre className="news-desk-analysis-command" key={key}>{block.text}</pre>;
-  if (block.type === "list") {
-    const ListTag = block.ordered ? "ol" : "ul";
-    return (
-      <ListTag key={key}>
-        {block.items.map((item, itemIndex) => <li key={`${key}-${itemIndex}`}>{renderInlineMarkdown(item)}</li>)}
-      </ListTag>
-    );
-  }
-  if (block.type === "heading") {
-    if (block.depth <= 1) return <h3 key={key}>{block.text}</h3>;
-    if (block.depth === 2) return <h4 key={key}>{block.text}</h4>;
-    return <h5 key={key}>{block.text}</h5>;
-  }
-  if (block.type === "table") {
-    return (
-      <table key={key}>
-        <thead>
-          <tr>
-            {block.headers.map((header, headerIndex) => (
-              <th key={`${key}-head-${headerIndex}`} scope="col">{renderInlineMarkdown(header)}</th>
-            ))}
-          </tr>
-        </thead>
-        {block.rows.length ? (
-          <tbody>
-            {block.rows.map((row, rowIndex) => (
-              <tr key={`${key}-row-${rowIndex}`}>
-                {row.map((cell, cellIndex) => (
-                  <td key={`${key}-row-${rowIndex}-cell-${cellIndex}`}>{renderInlineMarkdown(cell)}</td>
-                ))}
-              </tr>
-            ))}
-          </tbody>
-        ) : null}
-      </table>
-    );
-  }
-  return <p key={key}>{renderInlineMarkdown(block.text)}</p>;
-}
-
-function renderInlineMarkdown(text: string): ReactNode[] {
-  const nodes: ReactNode[] = [];
-  let index = 0;
-  let plain = "";
-  const flushPlain = () => {
-    if (!plain) return;
-    nodes.push(plain);
-    plain = "";
-  };
-
-  while (index < text.length) {
-    const linkLike = parseMarkdownLinkLikeAt(text, index);
-    if (linkLike) {
-      flushPlain();
-      if (!linkLike.image) {
-        const href = normalizeInlineMarkdownHref(linkLike.hrefRaw);
-        const label = collapseMarkdownLinkLabel(linkLike.label);
-        if (href) {
-          nodes.push(
-            <a href={href} key={`${index}-link`} rel="noopener noreferrer" target="_blank">
-              {renderInlineMarkdown(label)}
-            </a>,
-          );
-        } else {
-          nodes.push(linkLike.raw);
-        }
-      }
-      index += linkLike.length;
-      continue;
-    }
-
-    if (text.startsWith("**", index) || text.startsWith("__", index)) {
-      const marker = text.slice(index, index + 2);
-      const end = text.indexOf(marker, index + 2);
-      if (end > index + 2) {
-        flushPlain();
-        nodes.push(<strong key={`${index}-strong`}>{renderInlineMarkdown(text.slice(index + 2, end))}</strong>);
-        index = end + 2;
-        continue;
-      }
-    }
-
-    if (text.startsWith("~~", index)) {
-      const end = text.indexOf("~~", index + 2);
-      if (end > index + 2) {
-        flushPlain();
-        nodes.push(<del key={`${index}-strike`}>{renderInlineMarkdown(text.slice(index + 2, end))}</del>);
-        index = end + 2;
-        continue;
-      }
-    }
-
-    if (text[index] === "*" || text[index] === "_") {
-      const marker = text[index];
-      const end = text.indexOf(marker, index + 1);
-      if (end > index + 1) {
-        flushPlain();
-        nodes.push(<em key={`${index}-em`}>{renderInlineMarkdown(text.slice(index + 1, end))}</em>);
-        index = end + 1;
-        continue;
-      }
-    }
-
-    if (text[index] === "`") {
-      const end = text.indexOf("`", index + 1);
-      if (end > index + 1) {
-        flushPlain();
-        nodes.push(<code key={`${index}-code`}>{text.slice(index + 1, end)}</code>);
-        index = end + 1;
-        continue;
-      }
-    }
-
-    const autolinkMatch = /^(<https?:\/\/[^>\s]+>|https?:\/\/[^\s<]+)/.exec(text.slice(index));
-    if (autolinkMatch) {
-      flushPlain();
-      const token = autolinkMatch[1];
-      const href = normalizeInlineMarkdownHref(token);
-      if (href) {
-        nodes.push(
-          <a href={href} key={`${index}-autolink`} rel="noopener noreferrer" target="_blank">
-            {href}
-          </a>,
-        );
-      } else {
-        nodes.push(token);
-      }
-      index += token.length;
-      continue;
-    }
-
-    plain += text[index];
-    index += 1;
-  }
-
-  flushPlain();
-  return nodes;
-}
-
-function normalizeInlineMarkdownHref(rawHref: string): string | null {
-  const href = extractMarkdownHrefDestination(rawHref);
-  if (!href) return null;
-  if (/^(https?:\/\/|mailto:)/i.test(href)) return href;
-  return null;
-}
-
-function normalizeMultilineMarkdownLinks(text: string): string {
-  let normalized = "";
-  let index = 0;
-  while (index < text.length) {
-    const linkLike = parseMarkdownLinkLikeAt(text, index);
-    if (!linkLike || linkLike.image || !linkLike.raw.includes("\n")) {
-      normalized += text[index];
-      index += 1;
-      continue;
-    }
-    const href = extractMarkdownHrefDestination(linkLike.hrefRaw);
-    const label = collapseMarkdownLinkLabel(linkLike.label);
-    if (!href || !label) {
-      normalized += linkLike.raw;
-      index += linkLike.length;
-      continue;
-    }
-    normalized += `[${label}](${href})`;
-    index += linkLike.length;
-  }
-  return normalized;
-}
-
-function collapseMarkdownLinkLabel(label: string): string {
-  const withoutImages = label.replace(/!\[[^\]]*\]\((?:[^)(]|\([^)(]*\))*\)/g, " ");
-  return withoutImages
-    .replace(/\r?\n+/g, " ")
-    .replace(/(^|\s)#{1,6}\s+/g, "$1")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-function extractMarkdownHrefDestination(rawHref: string): string {
-  const trimmed = rawHref.trim();
-  if (!trimmed) return "";
-  if (trimmed.startsWith("<")) {
-    const closing = trimmed.indexOf(">");
-    if (closing > 1) return trimmed.slice(1, closing).trim();
-  }
-  const match = /^(\S+)/.exec(trimmed);
-  return match?.[1]?.trim() ?? "";
-}
-
-function parseMarkdownLinkLikeAt(
-  source: string,
-  startIndex: number,
-): { hrefRaw: string; image: boolean; label: string; length: number; raw: string } | null {
-  const image = source.startsWith("![", startIndex);
-  const link = source[startIndex] === "[";
-  if (!image && !link) return null;
-  const labelStart = startIndex + (image ? 2 : 1);
-  const labelEnd = findMatchingBracketIndex(source, labelStart, "[", "]");
-  if (labelEnd < 0) return null;
-  let next = labelEnd + 1;
-  while (next < source.length && /\s/.test(source[next])) next += 1;
-  if (source[next] !== "(") return null;
-  const hrefStart = next + 1;
-  const hrefEnd = findMatchingBracketIndex(source, hrefStart, "(", ")");
-  if (hrefEnd < 0) return null;
-  const raw = source.slice(startIndex, hrefEnd + 1);
-  return {
-    image,
-    label: source.slice(labelStart, labelEnd),
-    hrefRaw: source.slice(hrefStart, hrefEnd),
-    length: raw.length,
-    raw,
-  };
-}
-
-function findMatchingBracketIndex(source: string, contentStart: number, open: string, close: string): number {
-  let depth = 1;
-  for (let index = contentStart; index < source.length; index += 1) {
-    const ch = source[index];
-    if (ch === "\\") {
-      index += 1;
-      continue;
-    }
-    if (ch === open) {
-      depth += 1;
-      continue;
-    }
-    if (ch !== close) continue;
-    depth -= 1;
-    if (depth === 0) return index;
-  }
-  return -1;
-}
-
-function looksLikeMarkdownTableHeaderLine(line: string): boolean {
-  return /\|/.test(line.trim());
-}
-
-function looksLikeMarkdownTableRowLine(line: string): boolean {
-  const trimmed = line.trim();
-  if (!trimmed) return false;
-  if (!/\|/.test(trimmed)) return false;
-  if (isMarkdownTableDividerLine(trimmed)) return false;
-  return true;
-}
-
-function isMarkdownTableDividerLine(line: string): boolean {
-  const cells = splitMarkdownTableCells(line);
-  if (!cells.length) return false;
-  return cells.every((cell) => /^:?-{3,}:?$/.test(cell.trim()));
-}
-
-function splitMarkdownTableCells(line: string): string[] {
-  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
-  if (!trimmed) return [];
-  const cells: string[] = [];
-  let current = "";
-  let escaping = false;
-  for (let index = 0; index < trimmed.length; index += 1) {
-    const ch = trimmed[index];
-    if (escaping) {
-      current += ch;
-      escaping = false;
-      continue;
-    }
-    if (ch === "\\") {
-      escaping = true;
-      current += ch;
-      continue;
-    }
-    if (ch === "|") {
-      cells.push(current.trim());
-      current = "";
-      continue;
-    }
-    current += ch;
-  }
-  cells.push(current.trim());
-  return cells;
-}
-
-function normalizeMarkdownTableCells(cells: string[], columnCount: number): string[] {
-  const normalized = cells.slice(0, columnCount);
-  while (normalized.length < columnCount) normalized.push("");
-  return normalized;
-}
-
 function PayloadDetailBlock({
   fallback,
   hideLabel = false,
@@ -14571,17 +14157,6 @@ function buildNewsroomSearchHref(request: NewsroomSearchRequest, demo?: boolean)
   return toPublicNewsroomPath(queryString ? `/newsroom/search?${queryString}` : "/newsroom/search");
 }
 
-function focusNewsroomSearchForm() {
-  if (typeof window === "undefined") return;
-  const input = document.getElementById("newsroom-search-query");
-  if (input instanceof HTMLElement) {
-    input.focus();
-    input.scrollIntoView({ behavior: "smooth", block: "center" });
-    return;
-  }
-  window.dispatchEvent(new CustomEvent("papyrus:newsroom-search-focus"));
-}
-
 function resolveCurrentRouteAnchor(activeTab: NewsDeskTab): KnowledgeQueryAnchor | null {
   if (typeof window === "undefined") return null;
   const url = new URL(window.location.href);

package/lib/content-actions-client.ts

@@ -35,12 +35,14 @@ export type CorrectReferenceCaptureInput = {
   referenceId: string;
   /** The full corrected or pasted text. */
   text?: string;
+  /** The id of a PDF the editor uploaded to this Reference (a ModelAttachment); the server reads its text. Sent instead of `text`. */
+  pdfAttachmentId?: string;
   grobid?: Record<string, unknown>;
   /** Required with text; alone it is just a label on the capture. */
   assessment?: CaptureAssessment;
   note?: string;
 };
-export type CorrectReferenceCaptureResult = { ok: true; referenceId: string; status: string; edits: unknown[]; label: unknown; summaryStale: boolean };
+export type CorrectReferenceCaptureResult = { ok: true; referenceId: string; status: string; edits: Array<{ sortKey?: string; via?: string }>; label: unknown; summaryStale: boolean };
 
 export class ContentActionFailure extends Error {
   readonly errors: ContentActionError[];

package/lib/newsroom-index-filters.ts

@@ -167,3 +167,21 @@ export function parseAssignmentIdFromNewsroomPathname(pathname: string | null |
     return segment;
   }
 }
+
+/** The Notification Center's deep link to one item: `/newsroom/needs-me/<id>` (public `/needs-me/<id>` on a root-path newsroom). */
+export function buildNeedsMeItemPath(itemId: string): string {
+  return toPublicNewsroomPath(`/newsroom/needs-me/${encodeURIComponent(itemId)}`);
+}
+
+/** Item id from `/newsroom/needs-me/<id>`, else null. */
+export function parseNeedsMeItemIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
+  const internalPathname = pathname ? browserPathToInternalNewsroomPath(pathname) : null;
+  if (!internalPathname?.startsWith("/newsroom/needs-me/")) return null;
+  const segment = internalPathname.slice("/newsroom/needs-me/".length).split("/")[0]?.trim() ?? "";
+  if (!segment) return null;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}

package/lib/newsroom-references.ts

@@ -96,7 +96,31 @@ export function formatReferenceListDate(reference: ReferenceRecord): string {
 }
 
 export function referenceDisplayTitle(reference: ReferenceRecord): string {
-  return reference.title?.trim() || reference.externalItemId;
+  const title = reference.title?.trim();
+  if (!title) return reference.externalItemId;
+  let host: string | null = null;
+  try { host = reference.sourceUri ? new URL(reference.sourceUri).hostname : null; } catch { host = null; }
+  return withoutSiteName(title, host);
+}
+
+const TITLE_SEPARATORS = [" | ", " – ", " — ", " - "] as const;
+
+/**
+ * A page title without the site's name tacked on: "Auditing employment algorithms | Brookings" reads "Auditing employment
+ * algorithms". Only a last segment that names the site (its host's name, such as "brookings" in brookings.edu) is dropped,
+ * and with a pipe, which sites use for furniture, the section names before it go too ("… | Poverty and Development | Al Jazeera").
+ */
+export function withoutSiteName(title: string, host: string | null): string {
+  const label = (host ?? "").toLowerCase().replace(/^www\./, "").split(".").slice(0, -1).filter((part) => part.length >= 4).at(-1);
+  if (!label) return title;
+  const plain = (text: string) => text.toLowerCase().replace(/[^a-z0-9]/g, "");
+  // The separator whose last segment is shortest wins, so "… groups – report - Amnesty International" keeps "– report".
+  const match = TITLE_SEPARATORS.map((separator) => ({ separator, parts: title.split(separator) }))
+    .filter(({ parts }) => parts.length > 1 && plain(parts.at(-1)!).includes(label))
+    .sort((left, right) => left.parts.at(-1)!.length - right.parts.at(-1)!.length)[0];
+  if (!match) return title;
+  const kept = match.separator === " | " ? match.parts[0] : match.parts.slice(0, -1).join(match.separator);
+  return kept.trim() || title;
 }
 
 export function referenceStatusLabel(status: string): string {

package/lib/reference-capture.ts

@@ -23,7 +23,7 @@ export type CurationCard = {
   editedSignals: Record<string, unknown> | null;
   summary: { status?: string; text?: string; stale?: boolean; reason?: string } | null;
   grobid: { status?: string; reason?: string; title?: string; authorCount?: number; hasAbstract?: boolean; sectionCount?: number; referenceCount?: number; fieldsSortKey?: string } | null;
-  current: { textSortKey?: string; grobidSortKey?: string } | null;
+  current: { textSortKey?: string; grobidSortKey?: string; textVia?: string } | null;
   labels: Array<{ kind?: string; assessment?: string; labeledAt?: string }>;
 };
 
@@ -196,8 +196,9 @@ export function captureStatus(attachments: readonly ReferenceAttachmentRecord[],
     const flags = completenessFlags(card.editedSignals ?? card.signals);
     const thin = words !== null && words < teaserLine;
     const edited = Boolean(card.current?.textSortKey?.startsWith("curation-edit"));
-    // A complete text an editor vouched for is not second-guessed by the signals.
-    const doubtful = !edited && assessment !== "complete" && flags.length > 0 && !thin ? flags.some((flag) => /ends with|stops|no longer|not free|cut|declares/.test(flag)) : false;
+    // A complete text an editor vouched for is not second-guessed by the signals. A long text that merely ends without a full stop
+    // (a byline, a footnote, a list) is listed as a fact but is not on its own a reason to ask for a capture check.
+    const doubtful = !edited && assessment !== "complete" && flags.length > 0 && !thin ? flags.some((flag) => /ends with|stops with|no longer|not free|cut|declares/.test(flag)) : false;
     return { state: thin || doubtful ? "thin" : "full", words, estimated: false, source: "curation", curation: card.status, reason: null, flags, assessment, summaryStale, ...(thin ? { thinBy: "length" as const } : doubtful ? { thinBy: "signals" as const } : {}) };
   }
   if (primaryTextAttachment(attachments)) {

package/lib/source-frameable.ts

@@ -47,23 +47,31 @@ export async function publicHttpUrl(raw: string): Promise<URL | null> {
   }
 }
 
-/** Asks the page itself. Anything that fails (bad address, error status, timeout, too many redirects) counts as not frameable. */
-export async function checkSourceFrameable(raw: string, { timeoutMs = 5000, maxRedirects = 4 } = {}): Promise<boolean> {
+/** GETs a public address, following up to `maxRedirects` redirects and checking every hop with publicHttpUrl. Null on any failure. */
+export async function fetchPublic(raw: string, { accept, timeoutMs = 5000, maxRedirects = 4 }: { accept: string; timeoutMs?: number; maxRedirects?: number }): Promise<Response | null> {
   let next = await publicHttpUrl(raw);
   for (let hop = 0; next && hop <= maxRedirects; hop += 1) {
     let response: Response;
     try {
-      response = await fetch(next, { method: "GET", redirect: "manual", signal: AbortSignal.timeout(timeoutMs), headers: { accept: "text/html" } });
+      response = await fetch(next, { method: "GET", redirect: "manual", signal: AbortSignal.timeout(timeoutMs), headers: { accept } });
     } catch {
-      return false;
+      return null;
     }
-    void response.body?.cancel();
     const location = response.headers.get("location");
     if (response.status >= 300 && response.status < 400 && location) {
+      void response.body?.cancel();
       next = await publicHttpUrl(new URL(location, next).toString());
       continue;
     }
-    return response.ok && frameableFromHeaders(response.headers);
+    return response;
   }
-  return false;
+  return null;
+}
+
+/** Asks the page itself. Anything that fails (bad address, error status, timeout, too many redirects) counts as not frameable. */
+export async function checkSourceFrameable(raw: string, options: { timeoutMs?: number; maxRedirects?: number } = {}): Promise<boolean> {
+  const response = await fetchPublic(raw, { accept: "text/html", ...options });
+  if (!response) return false;
+  void response.body?.cancel();
+  return response.ok && frameableFromHeaders(response.headers);
 }