@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/lib/newsroom-index-filters.ts

@@ -0,0 +1,202 @@
+export type NewsroomIndexTab = "references" | "messages" | "assignments" | "insights";
+
+export type ReferenceIndexOrder = "published" | "imported";
+
+export type ReferencesIndexFilters = { status: string; processing: string; order: ReferenceIndexOrder };
+export type MessagesIndexFilters = { kind: string; domain: string };
+export type AssignmentsIndexFilters = { status: string; type: string; view: string };
+export type InsightsIndexFilters = { domain: string };
+
+export const DEFAULT_REFERENCES_INDEX_FILTERS: ReferencesIndexFilters = {
+  status: "exclude-pending",
+  processing: "",
+  order: "published",
+};
+
+export const DEFAULT_MESSAGES_INDEX_FILTERS: MessagesIndexFilters = {
+  kind: "",
+  domain: "",
+};
+
+export const DEFAULT_ASSIGNMENTS_INDEX_FILTERS: AssignmentsIndexFilters = {
+  status: "",
+  type: "",
+  view: "queue",
+};
+
+export const DEFAULT_INSIGHTS_INDEX_FILTERS: InsightsIndexFilters = {
+  domain: "",
+};
+
+export function referencesStatusFromUrl(value: string): string {
+  return value === "exclude-pending" ? "__exclude_pending" : value;
+}
+
+export function referencesStatusToUrl(value: string): string {
+  return value === "__exclude_pending" ? "exclude-pending" : value;
+}
+
+export function normalizeReferenceIndexOrder(value: string | null | undefined): ReferenceIndexOrder {
+  return value?.trim() === "imported" ? "imported" : "published";
+}
+
+export function effectiveReferencesIndexFilters(partial?: Partial<ReferencesIndexFilters>): ReferencesIndexFilters {
+  const order = normalizeReferenceIndexOrder(partial?.order);
+  const explicitStatus = partial?.status?.trim();
+  let status = explicitStatus || DEFAULT_REFERENCES_INDEX_FILTERS.status;
+  // Import-date sort is for intake triage; the default "reviewed only" filter hides
+  // pending references created by inbound email and other intake paths.
+  if (order === "imported" && !explicitStatus) {
+    status = "";
+  }
+  return {
+    status,
+    processing: partial?.processing?.trim() ?? DEFAULT_REFERENCES_INDEX_FILTERS.processing,
+    order,
+  };
+}
+
+export function effectiveMessagesIndexFilters(partial?: Partial<MessagesIndexFilters>): MessagesIndexFilters {
+  return {
+    kind: partial?.kind?.trim() ?? DEFAULT_MESSAGES_INDEX_FILTERS.kind,
+    domain: partial?.domain?.trim() ?? DEFAULT_MESSAGES_INDEX_FILTERS.domain,
+  };
+}
+
+export function effectiveAssignmentsIndexFilters(partial?: Partial<AssignmentsIndexFilters>): AssignmentsIndexFilters {
+  return {
+    status: partial?.status?.trim() ?? DEFAULT_ASSIGNMENTS_INDEX_FILTERS.status,
+    type: partial?.type?.trim() ?? DEFAULT_ASSIGNMENTS_INDEX_FILTERS.type,
+    view: partial?.view?.trim() || DEFAULT_ASSIGNMENTS_INDEX_FILTERS.view,
+  };
+}
+
+export function effectiveInsightsIndexFilters(partial?: Partial<InsightsIndexFilters>): InsightsIndexFilters {
+  return {
+    domain: partial?.domain?.trim() ?? DEFAULT_INSIGHTS_INDEX_FILTERS.domain,
+  };
+}
+
+export function readReferencesIndexFilters(searchParams: URLSearchParams): ReferencesIndexFilters {
+  const statusParam = searchParams.get("status")?.trim() ?? "";
+  const orderParam = searchParams.get("order")?.trim();
+  return effectiveReferencesIndexFilters({
+    status: statusParam ? referencesStatusFromUrl(statusParam) : undefined,
+    processing: searchParams.get("processing")?.trim() ?? undefined,
+    order: orderParam ? normalizeReferenceIndexOrder(orderParam) : undefined,
+  });
+}
+
+export function readMessagesIndexFilters(searchParams: URLSearchParams): MessagesIndexFilters {
+  return effectiveMessagesIndexFilters({
+    kind: searchParams.get("kind")?.trim() ?? undefined,
+    domain: searchParams.get("domain")?.trim() ?? undefined,
+  });
+}
+
+export function readAssignmentsIndexFilters(searchParams: URLSearchParams): AssignmentsIndexFilters {
+  return effectiveAssignmentsIndexFilters({
+    status: searchParams.get("status")?.trim() ?? undefined,
+    type: searchParams.get("type")?.trim() ?? undefined,
+    view: searchParams.get("view")?.trim() ?? undefined,
+  });
+}
+
+export function readInsightsIndexFilters(searchParams: URLSearchParams): InsightsIndexFilters {
+  return effectiveInsightsIndexFilters({
+    domain: searchParams.get("domain")?.trim() ?? undefined,
+  });
+}
+
+export function buildReferencesIndexQuery(filters: ReferencesIndexFilters): string {
+  const params = new URLSearchParams();
+  if (filters.status && filters.status !== DEFAULT_REFERENCES_INDEX_FILTERS.status) {
+    params.set("status", referencesStatusToUrl(filters.status));
+  }
+  if (filters.processing.trim()) params.set("processing", filters.processing.trim());
+  if (filters.order === "imported") params.set("order", "imported");
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
+export function buildMessagesIndexQuery(filters: MessagesIndexFilters): string {
+  const params = new URLSearchParams();
+  if (filters.kind.trim()) params.set("kind", filters.kind.trim());
+  if (filters.domain.trim()) params.set("domain", filters.domain.trim());
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
+export function buildAssignmentsIndexQuery(filters: AssignmentsIndexFilters): string {
+  const params = new URLSearchParams();
+  if (filters.status.trim()) params.set("status", filters.status.trim());
+  if (filters.type.trim()) params.set("type", filters.type.trim());
+  if (filters.view.trim() === "budget") params.set("view", "budget");
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
+export function buildInsightsIndexQuery(filters: InsightsIndexFilters): string {
+  const params = new URLSearchParams();
+  if (filters.domain.trim()) params.set("domain", filters.domain.trim());
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+
+export function buildNewsroomIndexWebPath(
+  tab: NewsroomIndexTab,
+  filters: ReferencesIndexFilters | MessagesIndexFilters | AssignmentsIndexFilters | InsightsIndexFilters,
+): string {
+  if (tab === "references") return `/newsroom/references${buildReferencesIndexQuery(filters as ReferencesIndexFilters)}`;
+  if (tab === "messages") return `/newsroom/messages${buildMessagesIndexQuery(filters as MessagesIndexFilters)}`;
+  if (tab === "insights") return `/newsroom/insights${buildInsightsIndexQuery(filters as InsightsIndexFilters)}`;
+  return `/newsroom/assignments${buildAssignmentsIndexQuery(filters as AssignmentsIndexFilters)}`;
+}
+
+export function syncBrowserNewsroomIndexUrl(
+  tab: NewsroomIndexTab,
+  filters: ReferencesIndexFilters | MessagesIndexFilters | AssignmentsIndexFilters | InsightsIndexFilters,
+  options?: { replace?: boolean },
+) {
+  if (typeof window === "undefined") return;
+  const nextPath = buildNewsroomIndexWebPath(tab, filters);
+  const current = `${window.location.pathname}${window.location.search}`;
+  if (current === nextPath) return;
+  if (options?.replace) window.history.replaceState(null, "", nextPath);
+  else window.history.pushState(null, "", nextPath);
+}
+
+/** Lineage id from `/newsroom/references/<id>` (not index-only URLs). */
+export function parseReferenceLineageIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
+  if (!pathname?.startsWith("/newsroom/references/")) return null;
+  const segment = pathname.slice("/newsroom/references/".length).split("/")[0]?.trim() ?? "";
+  if (!segment) return null;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+/** Assignment id from `/newsroom/assignments/<id>` (not index-only URLs). */
+export function parseAssignmentIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
+  if (!pathname?.startsWith("/newsroom/assignments/")) return null;
+  const segment = pathname.slice("/newsroom/assignments/".length).split("/")[0]?.trim() ?? "";
+  if (!segment) return null;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+export function parseInsightThreadIdFromNewsroomPathname(pathname: string | null | undefined): string | null {
+  if (!pathname?.startsWith("/newsroom/insights/")) return null;
+  const segment = pathname.slice("/newsroom/insights/".length).split("/")[0]?.trim() ?? "";
+  if (!segment) return null;
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}

package/lib/newsroom-knowledge-query-request.ts

@@ -0,0 +1,51 @@
+export type NewsroomKnowledgeQueryAnchor = {
+  kind: "assignment" | "category" | "categorySet" | "item" | "message" | "newsroomSection" | "reference" | "semanticNode";
+  id: string;
+  lineageId?: string | null;
+};
+
+export type NewsroomKnowledgeQueryTarget = {
+  anchor: NewsroomKnowledgeQueryAnchor;
+  title: string;
+  subtitle?: string | null;
+};
+
+type BuildKnowledgeQueryInputOptions = {
+  profile?: "researcher" | "reporter" | "editor" | "reviewer" | "chat";
+  semanticSearch?: boolean;
+};
+
+export function buildNewsroomKnowledgeQueryInput(
+  target: NewsroomKnowledgeQueryTarget | null,
+  semanticText: string,
+  maxTokens: number,
+  options: BuildKnowledgeQueryInputOptions = {},
+): Record<string, unknown> {
+  const request: Record<string, unknown> = {
+    semanticQuery: semanticText.trim(),
+    scope: {
+      depth: 1,
+      topK: target ? 18 : 24,
+      relatedRecordLimit: target ? 8 : 10,
+      semanticSearch: options.semanticSearch ?? true,
+    },
+    profile: options.profile ?? "editor",
+    ranking: {
+      profile: "balanced",
+      diversity: target ? "balanced" : "broad",
+    },
+    output: {
+      format: "markdown",
+      maxTokens,
+    },
+  };
+  if (target) {
+    const anchor: Record<string, unknown> = {
+      kind: target.anchor.kind,
+      id: target.anchor.id,
+    };
+    if (target.anchor.lineageId) anchor.lineageId = target.anchor.lineageId;
+    request.anchors = [anchor];
+  }
+  return request;
+}

package/lib/newsroom-list-selection.ts

@@ -0,0 +1,42 @@
+import { cn } from "./utils";
+
+/** List-row selection: dark copy on moss/paper tint in light mode; light copy on wash in dark mode. Never invert to primary-foreground. */
+export const NEWSROOM_LIST_ROW_BASE =
+  "w-full rounded-xl border bg-card p-4 text-left text-foreground transition-colors";
+
+export const NEWSROOM_LIST_ROW_INACTIVE =
+  "border-border hover:border-primary/30 hover:bg-primary/5";
+
+export const NEWSROOM_LIST_ROW_ACTIVE =
+  "border-primary/40 bg-primary/10 text-foreground ring-1 ring-primary/15";
+
+export const NEWSROOM_INBOX_ROW_BASE =
+  "flex items-start gap-3 rounded-xl border bg-card p-3 text-foreground transition-colors";
+
+export const NEWSROOM_INBOX_ROW_INACTIVE =
+  "border-border hover:border-primary/30 hover:bg-primary/5";
+
+export const NEWSROOM_INBOX_ROW_ACTIVE =
+  "border-primary/40 bg-primary/10 text-foreground ring-1 ring-primary/15";
+
+export const NEWSROOM_SIDEBAR_NAV_ACTIVE =
+  "bg-primary/10 text-foreground shadow-none hover:bg-primary/15";
+
+export const NEWSROOM_SIDEBAR_NAV_INACTIVE =
+  "text-muted-foreground hover:bg-muted/50 hover:text-foreground";
+
+export function newsroomListRowClassName(active: boolean, className?: string): string {
+  return cn(
+    NEWSROOM_LIST_ROW_BASE,
+    active ? NEWSROOM_LIST_ROW_ACTIVE : NEWSROOM_LIST_ROW_INACTIVE,
+    className,
+  );
+}
+
+export function newsroomInboxRowClassName(active: boolean, className?: string): string {
+  return cn(
+    NEWSROOM_INBOX_ROW_BASE,
+    active ? NEWSROOM_INBOX_ROW_ACTIVE : NEWSROOM_INBOX_ROW_INACTIVE,
+    className,
+  );
+}

package/lib/newsroom-media-backend.ts

@@ -0,0 +1,142 @@
+import { generateClient } from "aws-amplify/data";
+import { getUrl, uploadData } from "aws-amplify/storage";
+import type { Schema } from "../amplify/data/resource";
+import type { MediaAssetFields, MediaAssetRecord, NewsroomMediaBackend } from "./newsroom-media";
+
+type MediaListPage = {
+  data?: (Record<string, unknown> | null)[] | null;
+  nextToken?: string | null;
+  errors?: { message?: string }[] | null;
+};
+
+export type MediaDataClient = {
+  models: {
+    MediaAsset: {
+      create: (
+        input: MediaAssetFields,
+        options: { authMode: "userPool" },
+      ) => Promise<{ errors?: { message?: string }[] | null }>;
+      listMediaAssetsByItemAndSortKey: (
+        input: { itemId: string },
+        options: { authMode: "userPool"; nextToken?: string | null; limit?: number },
+      ) => Promise<MediaListPage>;
+    };
+  };
+};
+
+export type MediaStorageApi = {
+  upload: (input: { path: string; data: Blob; contentType: string }) => Promise<void>;
+  signedUrl: (path: string) => Promise<string>;
+};
+
+function failOnErrors(errors: { message?: string }[] | null | undefined): void {
+  if (errors && errors.length > 0) {
+    throw new Error(errors.map((error) => error.message ?? "GraphQL error").join("; "));
+  }
+}
+
+function srcPathFromMetadata(metadata: unknown): string | null {
+  let parsed = metadata;
+  if (typeof metadata === "string") {
+    try {
+      parsed = JSON.parse(metadata);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const srcPath = (parsed as Record<string, unknown>).srcPath;
+  return typeof srcPath === "string" ? srcPath : null;
+}
+
+export function createMediaBackend(client: () => MediaDataClient, storage: MediaStorageApi): NewsroomMediaBackend {
+  return {
+    uploadImage: ({ storagePath, data, contentType }) =>
+      storage.upload({ path: storagePath, data, contentType }),
+    async createMediaAsset(fields) {
+      const response = await client().models.MediaAsset.create(fields, { authMode: "userPool" });
+      failOnErrors(response.errors);
+    },
+    async listMediaAssets(itemId) {
+      const records: MediaAssetRecord[] = [];
+      let nextToken: string | null | undefined = null;
+      do {
+        const page: MediaListPage = await client().models.MediaAsset.listMediaAssetsByItemAndSortKey(
+          { itemId },
+          { authMode: "userPool", nextToken, limit: 500 },
+        );
+        failOnErrors(page.errors);
+        for (const row of page.data ?? []) {
+          if (!row) continue;
+          records.push({
+            id: String(row.id),
+            sortKey: String(row.sortKey),
+            storagePath: typeof row.storagePath === "string" ? row.storagePath : null,
+            alt: typeof row.alt === "string" ? row.alt : "",
+            srcPath: srcPathFromMetadata(row.metadata),
+          });
+        }
+        nextToken = page.nextToken;
+      } while (nextToken);
+      return records;
+    },
+    imageUrl: (storagePath) => storage.signedUrl(storagePath),
+  };
+}
+
+const amplifyStorage: MediaStorageApi = {
+  async upload({ path, data, contentType }) {
+    await uploadData({ path, data, options: { contentType } }).result;
+  },
+  async signedUrl(path) {
+    const { url } = await getUrl({ path });
+    return url.toString();
+  },
+};
+
+export function createLiveMediaBackend(): NewsroomMediaBackend {
+  let client: MediaDataClient | null = null;
+  return createMediaBackend(() => {
+    if (!client) client = generateClient<Schema>() as unknown as MediaDataClient;
+    return client;
+  }, amplifyStorage);
+}
+
+export function createDemoMediaBackend(): NewsroomMediaBackend {
+  const objects = new Map<string, Blob>();
+  const rows = new Map<string, MediaAssetFields[]>();
+  return {
+    async uploadImage({ storagePath, data }) {
+      objects.set(storagePath, data);
+    },
+    async createMediaAsset(fields) {
+      rows.set(fields.itemId, [...(rows.get(fields.itemId) ?? []), fields]);
+    },
+    async listMediaAssets(itemId) {
+      return (rows.get(itemId) ?? []).map((fields) => ({
+        id: fields.id,
+        sortKey: fields.sortKey,
+        storagePath: fields.storagePath,
+        alt: fields.alt,
+        srcPath: srcPathFromMetadata(fields.metadata),
+      }));
+    },
+    async imageUrl(storagePath) {
+      const object = objects.get(storagePath);
+      if (!object) throw new Error(`No demo object at ${storagePath}.`);
+      return URL.createObjectURL(object);
+    },
+  };
+}
+
+let liveBackend: NewsroomMediaBackend | null = null;
+let demoBackend: NewsroomMediaBackend | null = null;
+
+export function resolveMediaBackend(demo: boolean): NewsroomMediaBackend {
+  if (demo) {
+    demoBackend ??= createDemoMediaBackend();
+    return demoBackend;
+  }
+  liveBackend ??= createLiveMediaBackend();
+  return liveBackend;
+}

package/lib/newsroom-media.ts

@@ -0,0 +1,182 @@
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+export const IMAGE_CONTENT_TYPES: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+};
+
+export type ImageFileLike = { name: string; size: number };
+
+function extensionOf(filename: string): string {
+  const dot = filename.lastIndexOf(".");
+  return dot === -1 ? "" : filename.slice(dot + 1).toLowerCase();
+}
+
+export function contentTypeForFilename(filename: string): string | null {
+  return IMAGE_CONTENT_TYPES[extensionOf(filename)] ?? null;
+}
+
+export function isSvgFilename(filename: string): boolean {
+  return extensionOf(filename) === "svg";
+}
+
+function sanitizeSegment(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-{2,}/g, "-")
+    .replace(/^[-.]+|-+$/g, "");
+}
+
+export function srcPathFor(slug: string, filename: string, existingSrcPaths: Iterable<string> = []): string {
+  const taken = new Set(existingSrcPaths);
+  const extension = sanitizeSegment(extensionOf(filename));
+  const dot = filename.lastIndexOf(".");
+  const rawStem = dot === -1 ? filename : filename.slice(0, dot);
+  const stem = sanitizeSegment(rawStem) || "image";
+  const directory = sanitizeSegment(slug) || "article";
+  const suffix = extension ? `.${extension}` : "";
+  let candidate = `assets/${directory}/${stem}${suffix}`;
+  for (let counter = 2; taken.has(candidate); counter += 1) {
+    candidate = `assets/${directory}/${stem}-${counter}${suffix}`;
+  }
+  return candidate;
+}
+
+export async function sha256Hex(data: string | ArrayBuffer): Promise<string> {
+  const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export async function mediaIdFor(itemId: string, srcPath: string): Promise<string> {
+  return `media-${itemId}-${(await sha256Hex(srcPath)).slice(0, 10)}`;
+}
+
+export function validateImageFile(file: ImageFileLike): string | null {
+  if (contentTypeForFilename(file.name) === null) {
+    return "Choose a PNG, JPEG, GIF, WebP, AVIF or SVG image.";
+  }
+  if (file.size <= 0) return "That file is empty.";
+  if (file.size > MAX_IMAGE_BYTES) return "Images can be at most 10 MB.";
+  return null;
+}
+
+function altAttributeValue(alt: string): string {
+  return alt.replace(/[\r\n]+/g, " ").replace(/"/g, "'").replace(/[{}]/g, "");
+}
+
+export function imageDirective(srcPath: string, alt: string): string {
+  return `::image{src="${srcPath}" alt="${altAttributeValue(alt)}" layout="inline"}`;
+}
+
+export type MediaAssetFields = {
+  id: string;
+  itemId: string;
+  type: "image";
+  role: "body";
+  sortKey: string;
+  storagePath: string;
+  alt: string;
+  width?: number;
+  height?: number;
+  metadata: string;
+};
+
+export function mediaSortKey(position: number, srcPath: string): string {
+  return `${String(position).padStart(3, "0")}#${srcPath}`;
+}
+
+export type SelectionInsertion = { body: string; altSelectionStart: number };
+
+function countEdgeNewlines(text: string, fromEnd: boolean): number {
+  let count = 0;
+  while (count < 2 && (fromEnd ? text[text.length - 1 - count] : text[count]) === "\n") count += 1;
+  return count;
+}
+
+export function insertDirectiveAtSelection(
+  body: string,
+  selectionStart: number,
+  selectionEnd: number,
+  directive: string,
+): SelectionInsertion {
+  const before = body.slice(0, selectionStart);
+  const after = body.slice(selectionEnd);
+  const prefix = before === "" ? "" : "\n".repeat(2 - countEdgeNewlines(before, true));
+  const suffix = after === "" ? "\n" : "\n".repeat(2 - countEdgeNewlines(after, false));
+  const directiveStart = before.length + prefix.length;
+  return {
+    body: `${before}${prefix}${directive}${suffix}${after}`,
+    altSelectionStart: directiveStart + directive.indexOf('alt="') + 'alt="'.length,
+  };
+}
+
+export type MediaAssetRecord = {
+  id: string;
+  sortKey: string;
+  storagePath: string | null;
+  alt: string;
+  srcPath: string | null;
+};
+
+export type NewsroomMediaBackend = {
+  uploadImage: (input: { storagePath: string; data: Blob; contentType: string }) => Promise<void>;
+  createMediaAsset: (fields: MediaAssetFields) => Promise<void>;
+  listMediaAssets: (itemId: string) => Promise<MediaAssetRecord[]>;
+  imageUrl: (storagePath: string) => Promise<string>;
+};
+
+export type ImageDimensionReader = (file: Blob, filename: string) => Promise<{ width: number; height: number } | null>;
+
+export type UploadedImage = { srcPath: string; directive: string; imageUrl: string };
+
+export async function uploadArticleImage(
+  backend: NewsroomMediaBackend,
+  readDimensions: ImageDimensionReader,
+  input: { itemId: string; slug: string; file: File },
+): Promise<UploadedImage> {
+  const problem = validateImageFile(input.file);
+  if (problem) throw new Error(problem);
+  const contentType = contentTypeForFilename(input.file.name) as string;
+  const existing = await backend.listMediaAssets(input.itemId);
+  const srcPath = srcPathFor(
+    input.slug,
+    input.file.name,
+    existing.map((asset) => asset.srcPath).filter((path): path is string => path !== null),
+  );
+  const bytes = await input.file.arrayBuffer();
+  const sha256 = await sha256Hex(bytes);
+  const dimensions = await readDimensions(input.file, input.file.name);
+  const storagePath = `media/${srcPath}`;
+  await backend.uploadImage({ storagePath, data: input.file, contentType });
+  await backend.createMediaAsset({
+    id: await mediaIdFor(input.itemId, srcPath),
+    itemId: input.itemId,
+    type: "image",
+    role: "body",
+    sortKey: mediaSortKey(existing.length + 1, srcPath),
+    storagePath,
+    alt: input.file.name,
+    ...(dimensions ?? {}),
+    metadata: JSON.stringify({ srcPath, sha256, bytes: bytes.byteLength, contentType }),
+  });
+  return { srcPath, directive: imageDirective(srcPath, ""), imageUrl: await backend.imageUrl(storagePath) };
+}
+
+export async function readImageDimensions(file: Blob, filename: string): Promise<{ width: number; height: number } | null> {
+  if (isSvgFilename(filename)) return null;
+  try {
+    const bitmap = await createImageBitmap(file);
+    const size = { width: bitmap.width, height: bitmap.height };
+    bitmap.close();
+    return size;
+  } catch {
+    return null;
+  }
+}

package/lib/newsroom-nav.ts

@@ -0,0 +1,44 @@
+import { newsroomHref, toPublicNewsroomPath } from "./newsroom-base-path";
+
+export type NewsroomNavTabId =
+  | "overview"
+  | "articles"
+  | "messages"
+  | "insights"
+  | "assignments"
+  | "references"
+  | "topics"
+  | "concepts"
+  | "administration"
+  | "search"
+  | "desks";
+
+export type NewsroomNavItem = {
+  id: NewsroomNavTabId;
+  label: string;
+  detail: string;
+  href: string;
+  mobilePrimary?: boolean;
+};
+
+export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
+  { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref(), mobilePrimary: true },
+  { id: "articles", label: "Articles", detail: "Drafts & published", href: newsroomHref("articles"), mobilePrimary: true },
+  { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments"), mobilePrimary: true },
+  { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references"), mobilePrimary: true },
+  { id: "messages", label: "Messages", detail: "Forum", href: newsroomHref("messages") },
+  { id: "insights", label: "Insights", detail: "Research threads", href: newsroomHref("insights") },
+  { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics"), mobilePrimary: true },
+  { id: "concepts", label: "Concepts", detail: "Ontology", href: newsroomHref("concepts") },
+  { id: "administration", label: "Administration", detail: "Users & policies", href: newsroomHref("administration") },
+];
+
+export const NEWSROOM_MOBILE_PRIMARY_NAV = NEWSROOM_OPS_NAV.filter((item) => item.mobilePrimary);
+
+export function getNewsroomNavHref(href: string, demo?: boolean): string {
+  const path = toPublicNewsroomPath(href);
+  if (!demo) return path;
+  const url = new URL(path, "http://localhost");
+  url.searchParams.set("demo", "1");
+  return `${url.pathname}${url.search}`;
+}