ask-marcel-office-cli 1.0.0 → 1.5.0

package/dist/infra/auth.d.ts

@@ -31,6 +31,30 @@ type AuthManager = {
      * via headless Playwright. Used by the 3 historical-version commands.
      */
     getElevatedAccessToken: () => Promise<Result<AccessToken, AuthError>>;
+    /**
+     * Returns a chatsvcagg-audience token (same Teams web client identity
+     * as `getAccessToken`, but issued for the chatsvcagg resource). Falls
+     * through cache → re-capture via headless Playwright. Used by the
+     * `list-teams-chats-with-messages` family of commands.
+     */
+    getChatsvcaggAccessToken: () => Promise<Result<AccessToken, AuthError>>;
+    /**
+     * Returns the regional segment used to construct chatsvcagg substrate
+     * URLs (`teams.microsoft.com/api/csa/<region>/api/...`). Captured at
+     * login from the first such URL the chatsvcagg bearer rides on. Falls
+     * back to `DEFAULT_CHATSVCAGG_REGION` ('emea') when the cache is
+     * either absent or pre-2026-05-migration. Synchronous on cache; calls
+     * `getChatsvcaggAccessToken()` first if no cache exists so a region is
+     * available immediately after login.
+     */
+    getChatsvcaggRegion: () => Promise<string>;
+    /**
+     * Returns an IC3-audience bearer (Teams web client identity, aud
+     * `https://ic3.teams.office.com`). Falls through cache → re-capture
+     * via headless Playwright. Used by `list-teams-chat-history` to walk
+     * paginated chat-message history beyond the 200-message chatsvcagg cap.
+     */
+    getIc3AccessToken: () => Promise<Result<AccessToken, AuthError>>;
     logout: () => Promise<Result<void, AuthError>>;
     /**
      * Inspect the elevated-capture outcome from the most recent
@@ -39,13 +63,42 @@ type AuthManager = {
      * Login-fix round-1 Wave D.
      */
     getLastElevatedOutcome: () => ElevatedOutcome | null;
+    /**
+     * Inspect the chatsvcagg-capture outcome from the most recent
+     * `acquireViaBrowser` invocation. Same shape and lifetime semantics
+     * as `getLastElevatedOutcome`.
+     */
+    getLastChatsvcaggOutcome: () => ElevatedOutcome | null;
 };
-declare const createAuthManagerFromApi: (browserAuth: BrowserAuth, cachePath: string, browserProfileDir: string, logger: Logger, fs: FileSystem) => AuthManager;
+type SystemBrowserAuthFn = () => Promise<Result<{
+    accessToken: AccessToken;
+    refreshToken: string | null;
+    elevatedAccessToken?: AccessToken | null;
+    chatsvcaggAccessToken?: AccessToken | null;
+    ic3AccessToken?: AccessToken | null;
+    chatsvcaggRegion?: string;
+}, {
+    type: string;
+    message: string;
+}>>;
+declare const createAuthManagerFromApi: (browserAuth: BrowserAuth, cachePath: string, browserProfileDir: string, logger: Logger, fs: FileSystem, systemBrowserAuthFn?: SystemBrowserAuthFn, usePlaywrightFallback?: boolean, skipSystemBrowser?: boolean) => AuthManager;
+/**
+ * QA-010: probe the token cache for a fresh access token. Handed to the
+ * browser capture so its poll loop can short-circuit the multi-minute dance
+ * when a concurrent process refreshes first (AAD rotates SPA refresh tokens,
+ * so the loser of the race cannot refresh and falls into the browser leg).
+ * Exported for the composition test; pure read, never writes.
+ */
+declare const createFreshCachedTokenProbe: (fs: FileSystem, cachePath: string) => (() => Promise<string | null>);
+declare const stderrProgress: (line: string) => void;
 declare const createAuthManager: (deps: {
     cachePath: string;
     logger: Logger;
     fs?: FileSystem;
     browserProfileDir?: string;
+    systemBrowserAuth?: SystemBrowserAuthFn;
+    usePlaywrightFallback?: boolean;
+    skipSystemBrowser?: boolean;
 }) => AuthManager;
-export { createAuthManager, createAuthManagerFromApi };
-export type { AuthError, AuthManager, ElevatedOutcome };
+export { createAuthManager, createAuthManagerFromApi, createFreshCachedTokenProbe, stderrProgress };
+export type { AuthError, AuthManager, ElevatedOutcome, SystemBrowserAuthFn };

package/dist/infra/browser-auth.d.ts

@@ -26,19 +26,70 @@ type ElevatedTokenResult = {
     readonly reason: ElevatedFailureReason;
 };
 /**
- * Combined outcome of capturing BOTH the Teams web client token AND the
- * elevated M365ChatClient token inside one browser session. Login-fix
- * round-2 introduced this to fix the user-visible "second browser asks
- * me to log in again" symptom on federated tenants (LVMH / Okta): the
- * old flow opened two separate browser sessions, and silent SSO for the
- * elevated identity wouldn't pick up the cookies just freshly written
- * by the first session. Capturing both in one context means cookies are
- * live in memory — no disk-commit-vs-read race, no separate sign-in
- * prompt for the elevated identity.
+ * chatsvcagg capture result. Carries the same three failure modes as
+ * `ElevatedTokenResult` PLUS the parsed regional segment from the URL
+ * the bearer rode on (`emea` / `amer` / `apac` / etc.) — the new
+ * substrate host (`teams.microsoft.com/api/csa/<region>/api/...`) routes
+ * per region, so callers must persist this alongside the token to
+ * construct future URLs. See `gotcha_chatsvcagg_substrate_moved` in
+ * the project memory for the 2026-05 migration that made this
+ * necessary.
+ */
+type ChatsvcaggTokenResult = {
+    readonly ok: true;
+    readonly token: AccessToken;
+    readonly region: string;
+} | {
+    readonly ok: false;
+    readonly reason: ElevatedFailureReason;
+};
+/**
+ * IC3 capture result. The "next-gen" Teams chat-message substrate at
+ * `teams.microsoft.com/api/chatsvc/<region>/v1/users/ME/conversations/{id}/messages`
+ * — the path Teams web actually uses for chat scrollback (the existing
+ * chatsvcagg substrate at `/api/csa/<region>/api/v1/chats/{id}/messages`
+ * is the chat-list aggregator and caps at the 200 most recent messages
+ * with no working pagination cursor). The IC3 path supports `syncState`
+ * + `startTime` pagination, unlocking arbitrary-depth chat history.
+ *
+ * Bearer audience: `https://ic3.teams.office.com`. Standard `Bearer`
+ * authorization (NOT the purple-teams-documented `skype_token X`
+ * header — those forks predate Teams' move to OAuth bearer on this
+ * surface). Empirically discovered 2026-05-21 by widening the
+ * Playwright capture listener.
+ */
+type Ic3TokenResult = {
+    readonly ok: true;
+    readonly token: AccessToken;
+    readonly region: string;
+} | {
+    readonly ok: false;
+    readonly reason: ElevatedFailureReason;
+};
+/**
+ * Combined outcome of capturing all four tokens (Teams basic / M365
+ * elevated / chatsvcagg substrate / IC3 substrate) inside one browser
+ * session. Login-fix round-2 introduced this for the basic+elevated
+ * pair; chatsvcagg was added next; IC3 is the most recent leg, capturing
+ * the bearer Teams web uses for unbounded chat-history reads.
+ *
+ * All four legs ride on the SAME `teams.microsoft.com` session, so
+ * adding capture legs is essentially free — MSAL multiplexes the
+ * audience-scoped bearers via silent acquisition.
  */
 type BothTokensResult = {
     readonly teams: BrowserTokenResult | null;
     readonly elevated: ElevatedTokenResult;
+    readonly chatsvcagg: ChatsvcaggTokenResult;
+    readonly ic3: Ic3TokenResult;
+    /**
+     * Set when the Teams poll short-circuited because `freshCachedToken`
+     * found a token written by a concurrent process (QA-010). The caller
+     * must NOT persist this result — the cache is already the source of
+     * truth, and `refreshToken` is null here (persisting would clobber the
+     * winner's rotated refresh token).
+     */
+    readonly fromCache?: true;
 };
 type BrowserAuth = {
     acquireToken: (scopes: string[], startUrl: string) => Promise<BrowserTokenResult | null>;
@@ -62,6 +113,28 @@ type BrowserAuth = {
      * `acquireBothTokens` instead so the user sees only one browser.
      */
     acquireElevatedToken: () => Promise<ElevatedTokenResult>;
+    /**
+     * Capture a chatsvcagg-audience bearer (Teams basic identity, but the
+     * `chatsvcagg.teams.microsoft.com` resource instead of Graph) by
+     * navigating headless to `teams.microsoft.com/v2/`. The persistent
+     * profile's SSO cookies do the auth silently. Used by
+     * `getChatsvcaggAccessToken()` when the cached chatsvcagg token has
+     * expired and the basic Teams session is still warm.
+     *
+     * Same failure-mode shape as `acquireElevatedToken` — launch hang,
+     * navigation failure, silent SSO timeout — so the auth-manager can
+     * reuse the same auto-heal logic.
+     */
+    acquireChatsvcaggToken: () => Promise<ChatsvcaggTokenResult>;
+    /**
+     * Capture an IC3-audience bearer (aud `https://ic3.teams.office.com`,
+     * same basic Teams appid). The bearer Teams web client uses to call
+     * `teams.microsoft.com/api/chatsvc/<region>/v1/users/ME/conversations/{id}/messages`
+     * — the chat-message substrate with proper `syncState` pagination,
+     * enabling reads beyond the 200-message chatsvcagg cap. Same failure
+     * modes as `acquireChatsvcaggToken`.
+     */
+    acquireIc3Token: () => Promise<Ic3TokenResult>;
     /**
      * Login-fix round-2: capture BOTH tokens inside ONE browser session.
      * After the Teams response listener intercepts the Teams token,
@@ -125,6 +198,21 @@ type BrowserAuthConfig = {
     readonly logger: Logger;
     readonly fs: FileSystem;
     readonly trace?: TraceFn;
+    /**
+     * QA-010 (login hang): probe for a fresh token that landed in the cache
+     * WHILE the browser capture is polling. AAD SPA refresh tokens rotate, so
+     * when two processes race, the loser's refresh fails and it falls into the
+     * full multi-minute browser dance — while the winner's fresh token sits in
+     * the cache the whole time. The Teams poll loop calls this every interval
+     * and short-circuits (closing the browser) the moment it returns a token.
+     */
+    readonly freshCachedToken?: () => Promise<string | null>;
+    /**
+     * User-visible progress sink (stderr in production). The browser capture
+     * can legitimately take minutes (federated SSO, interactive sign-in); these
+     * one-liners are what separates "waiting on the user" from "hung" (QA-010).
+     */
+    readonly onProgress?: (line: string) => void;
     readonly profileDir?: string;
     readonly initialSettleMs?: number;
     readonly postReloginSettleMs?: number;
@@ -158,6 +246,8 @@ declare const createBrowserAuthFromApi: (api: BrowserAuthApi, config: BrowserAut
 declare const createBrowserAuth: (deps: {
     logger: Logger;
     fs?: FileSystem;
+    freshCachedToken?: () => Promise<string | null>;
+    onProgress?: (line: string) => void;
 }) => BrowserAuth;
 export { createBrowserAuth, createBrowserAuthFromApi, createPlaywrightApi };
-export type { BothTokensResult, BrowserAuth, BrowserAuthApi, BrowserAuthConfig, BrowserTokenResult, ChromiumLike, ContextLike, ElevatedFailureReason, ElevatedTokenResult, PageLike, PlaywrightLoader, RequestLike, ResponseLike, };
+export type { BothTokensResult, BrowserAuth, BrowserAuthApi, BrowserAuthConfig, BrowserTokenResult, ChatsvcaggTokenResult, Ic3TokenResult, ChromiumLike, ContextLike, ElevatedFailureReason, ElevatedTokenResult, PageLike, PlaywrightLoader, RequestLike, ResponseLike, };

package/dist/infra/graph-client.d.ts

@@ -5,6 +5,7 @@ type GraphError = {
     status: number;
     message: string;
     code?: string;
+    retryAfterSeconds?: number;
 } | {
     type: 'auth_failed';
     message: string;
@@ -35,7 +36,38 @@ type GraphClient = {
      * elevated token).
      */
     getElevated: (path: string) => Promise<Result<unknown, GraphError>>;
+    /**
+     * JSON-GET against the Teams chat substrate (post-2026-05:
+     * `teams.microsoft.com/api/csa/<region>/api/v{N}/...` — see
+     * `gotcha_chatsvcagg_substrate_moved` in memory for the migration
+     * away from `chatsvcagg.teams.microsoft.com`). Signs the request
+     * with the chatsvcagg-audience bearer captured at login (same Teams
+     * web client identity as `get`, different audience), and injects the
+     * cached substrate region between the host and `path`. Used by
+     * commands that need to read chat message BODIES, which the basic
+     * Graph token cannot reach (`Chat.Read*` scopes are missing).
+     *
+     * `path` MUST start with `/api/v{N}/...` — the host + `/api/csa/<region>`
+     * prefix are added by this client.
+     */
+    teamsChat: (path: string) => Promise<Result<unknown, GraphError>>;
+    /**
+     * JSON-GET against the Teams IC3 chat-message substrate at
+     * `teams.microsoft.com/api/chatsvc/<region>/v1/...`. Same host as
+     * `teamsChat` but a DIFFERENT path prefix AND a different bearer
+     * audience (`https://ic3.teams.office.com` instead of
+     * `https://chatsvcagg.teams.microsoft.com`). The path supports
+     * `syncState` + `startTime` pagination — unlocking arbitrary-depth
+     * chat-history reads beyond the chatsvcagg 200-message cap (see
+     * `gotcha_chatsvcagg_substrate_moved` in memory). Used by
+     * `list-teams-chat-history`.
+     *
+     * `path` MUST start with `/v1/...` (e.g. `/v1/users/ME/conversations/{id}/messages?startTime=...`)
+     * — the host + `/api/chatsvc/<region>` prefix are added here.
+     */
+    teamsChatIc3: (path: string) => Promise<Result<unknown, GraphError>>;
     post: (path: string, body: unknown) => Promise<Result<unknown, GraphError>>;
+    patch: (path: string, body: unknown) => Promise<Result<unknown, GraphError>>;
     getBinary: (path: string) => Promise<Result<unknown, GraphError>>;
     /**
      * Same shape as `getBinary` but signs the request with an "elevated"
@@ -74,6 +106,14 @@ type TokenInfo = {
     readonly scopes: ReadonlyArray<string>;
     readonly audience: string | undefined;
     readonly expiresAt: string | undefined;
+    /**
+     * Seconds remaining until the cached token's `exp` claim — derived from
+     * `expiresAt - now`. Negative when the token has already expired. Absent
+     * when the JWT did not carry an `exp` claim. Audit Jane-session §4: lets
+     * an LLM decide pre-emptively to run `ask-marcel login` (re-auth typically
+     * worth doing under ~5 minutes) without parsing the ISO string itself.
+     */
+    readonly expiresInSeconds: number | undefined;
 };
 type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
 declare const createGraphClient: (auth: AuthManager, fetchFn?: FetchFn) => GraphClient;

package/dist/infra/legacy-doc-extractor.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Extract the text of a legacy Word .doc — the pre-2007 OLE binary "Compound
+ * File" format that mammoth (which only reads the OOXML .docx zip) cannot parse —
+ * via word-extractor (pure-JS, walks the WordDocument OLE stream; no native deps).
+ * Body text only: legacy .doc carries no structure this CLI surfaces (headings,
+ * tables, and styling are lost), so callers return it as text/plain.
+ *
+ * try/catch is permitted here per the infra-boundary rule: word-extractor throws
+ * on a non-.doc / corrupt OLE container, and we translate that into a Result.
+ */
+declare const extractDocText: (bytes: Uint8Array) => Promise<Result<string, GraphError>>;
+export { extractDocText };

package/dist/infra/msg-reader-adapter.d.ts

@@ -0,0 +1,83 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Parse an Outlook `.msg` file — the OLE Compound File (CFBF) container Outlook
+ * writes when you drag an email to disk, same binary family as legacy .doc/.xls —
+ * into a clean {@link ParsedMsg} via @kenjiuno/msgreader (pure-JS, no native deps,
+ * lazy-imported like word-extractor / unpdf so it stays out of the cold-start path).
+ *
+ * The adapter is the anti-corruption layer: msgreader returns a wide `FieldsData`
+ * (X500 sender addresses, RTF body, hundreds of MAPI props); {@link mapRawMsg}
+ * narrows it to the half-dozen fields the markdown renderer needs and resolves the
+ * sender SMTP / delivery-time fallbacks. `mapRawMsg` is pure and exported so every
+ * fallback branch is unit-tested with plain objects — the binary fixture only
+ * exercises one field combination.
+ *
+ * try/catch is permitted here per the infra-boundary rule: msgreader throws on a
+ * non-OLE / corrupt container, and a single unreadable attachment must not sink the
+ * whole parse, so attachment reads are individually guarded.
+ */
+type MsgRecipientKind = 'to' | 'cc' | 'bcc' | 'unknown';
+type MsgRecipient = {
+    readonly kind: MsgRecipientKind;
+    readonly name?: string;
+    readonly email?: string;
+};
+type MsgAttachment = {
+    readonly fileName?: string;
+    readonly content?: Uint8Array;
+};
+type ParsedMsg = {
+    readonly subject?: string;
+    readonly senderName?: string;
+    readonly senderEmail?: string;
+    readonly date?: string;
+    readonly body?: string;
+    readonly bodyHtml?: string;
+    readonly recipients: readonly MsgRecipient[];
+    readonly attachments: readonly MsgAttachment[];
+};
+type RawRecipient = {
+    readonly recipType?: string;
+    readonly name?: string;
+    readonly smtpAddress?: string;
+    readonly email?: string;
+};
+type RawAttachment = {
+    readonly fileName?: string;
+};
+type RawMsg = {
+    readonly subject?: string;
+    readonly senderName?: string;
+    readonly senderSmtpAddress?: string;
+    readonly senderEmail?: string;
+    readonly messageDeliveryTime?: string;
+    readonly clientSubmitTime?: string;
+    readonly body?: string;
+    readonly bodyHtml?: string;
+    readonly recipients?: readonly RawRecipient[];
+    readonly attachments?: readonly RawAttachment[];
+};
+declare const mapRawMsg: (raw: RawMsg, attachmentContents: readonly (Uint8Array | undefined)[]) => ParsedMsg;
+type AttachmentReader = {
+    readonly getAttachment: (index: number) => {
+        readonly content?: unknown;
+    };
+};
+type MsgReaderInstance = AttachmentReader & {
+    readonly getFileData: () => unknown;
+};
+type MsgReaderCtor = new (input: ArrayBuffer | DataView) => MsgReaderInstance;
+declare const readAttachmentContent: (reader: AttachmentReader, index: number) => Uint8Array | undefined;
+/**
+ * Resolve the MsgReader class from the dynamic import's `default`, whichever
+ * interop shape it arrives in. msgreader is CJS with `exports.default = class`
+ * (+ `__esModule`): Bun's RUNTIME import hands us the class directly, but Bun's
+ * BUNDLER (node-mode `__toESM`) sets `default` to the whole exports object —
+ * so in `dist/cli.js` the class sits one level deeper at `default.default`
+ * ("Object is not a constructor" at runtime, invisible to source-run tests).
+ */
+declare const resolveMsgReaderCtor: (defaultExport: unknown) => MsgReaderCtor;
+declare const extractMsg: (bytes: Uint8Array) => Promise<Result<ParsedMsg, GraphError>>;
+export { extractMsg, mapRawMsg, readAttachmentContent, resolveMsgReaderCtor };
+export type { MsgAttachment, MsgRecipient, MsgRecipientKind, ParsedMsg };

package/dist/infra/network-error.d.ts

@@ -0,0 +1,9 @@
+export declare const REQUEST_TIMEOUT_MS = 60000;
+export declare const BINARY_TRANSFER_TIMEOUT_MS: number;
+export declare const REQUEST_TIMEOUT_LABEL = "60s";
+export declare const BINARY_TRANSFER_TIMEOUT_LABEL = "5min";
+export declare const networkErrorMessage: (e: unknown, label: string, timeoutLabel: string) => string;
+export type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+export type TimeoutTier = 'json' | 'binary';
+export declare const timeoutLabelFor: (tier: TimeoutTier) => string;
+export declare const timeoutMsFor: (tier: TimeoutTier) => number;

package/dist/infra/ooxml-media-extractor.d.ts

@@ -0,0 +1,27 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Pulls the image parts out of an OOXML package (.docx / .xlsx /
+ * .pptx and their macro-enabled / template variants). Images live as binary
+ * parts under `word/media/`, `xl/media/`, or `ppt/media/` — including
+ * original full-resolution / un-cropped originals and images on hidden
+ * slides that the rendered view never shows.
+ *
+ * Separate from `ooxml-zip-adapter` on purpose: that adapter pre-decodes
+ * every entry as a UTF-8 string (correct for XML, corrupting for binary),
+ * whereas media must come back as raw bytes. try/catch is permitted here
+ * (src/infra/**, atelier rule 17): a malformed-zip throw becomes a Result.err.
+ *
+ * Raster formats (png/jpg/gif/bmp/tiff/webp) a vision model can read directly,
+ * plus svg — the one vector format a model can use, because its XML source
+ * carries the diagram's own text labels (and modern Office embeds it as the
+ * high-fidelity original beside a png fallback). Legacy vector (emf/wmf) and
+ * audio/video are still excluded — neither a model can use.
+ */
+type MediaPart = {
+    readonly path: string;
+    readonly bytes: Uint8Array;
+};
+declare const extractOoxmlMedia: (bytes: Uint8Array) => Promise<Result<ReadonlyArray<MediaPart>, GraphError>>;
+export { extractOoxmlMedia };
+export type { MediaPart };

package/dist/infra/ooxml-zip-adapter.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Thin wrapper around JSZip for opening already-fetched OOXML bytes
+ * (.docx / .xlsx / .pptx — all ZIP packages with a shared docProps/* core).
+ * Pure CPU on bytes already in memory — no IO — so this matches the
+ * mammoth-adapter pattern: a Result-returning factory, no port, no fake.
+ * Tests work end-to-end against real fixtures built with the `docx` /
+ * `xlsx` packages (or hand-rolled JSZip) via test-helpers/office-fixtures.ts.
+ *
+ * try/catch is permitted under src/infra/** (atelier hard rule 17): any
+ * malformed-zip throw from JSZip translates into a Result.err with a
+ * GraphError shape so callers stay on the Result rail.
+ *
+ * The returned reader is synchronous on purpose: callers in the use-case
+ * layer are pure XML walkers that don't model async/await internally.
+ * Every text entry is pre-decoded once at open time, then served from
+ * an in-memory map. `list()` exposes the entry paths so callers can
+ * enumerate numbered parts (`xl/comments1.xml`, `ppt/slides/slide*.xml`,
+ * every `*.rels`) that can't be hardcoded.
+ */
+type OoxmlZip = {
+    readonly read: (path: string) => string | undefined;
+    readonly list: () => ReadonlyArray<string>;
+};
+declare const openOoxmlZip: (bytes: Uint8Array) => Promise<Result<OoxmlZip, GraphError>>;
+export { openOoxmlZip };
+export type { OoxmlZip };

package/dist/infra/pdf-image-extractor.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+import type { MediaPart } from './ooxml-media-extractor.js';
+/**
+ * Extract embedded raster images from a PDF via unpdf (a pure-JS pdfjs build — no
+ * native deps, runs under Bun). unpdf walks each page's painted image XObjects and
+ * returns *decoded* pixels, which we PNG-encode.
+ *
+ * Scope note: this is page-oriented — it sees images AS PAINTED on each page. It does
+ * NOT reach OCG/layer-hidden images, unpainted/orphan XObjects, or the full uncropped
+ * original behind a clipped image; capturing those needs an object-graph walk (a much
+ * heavier dependency). All PAGES are always walked (PDF has no "hidden page" concept).
+ *
+ * `try/catch` is permitted here per the infra-boundary rule: pdfjs throws on malformed
+ * input and we translate that into a Result rather than letting it escape.
+ */
+declare const extractPdfImages: (bytes: Uint8Array) => Promise<Result<ReadonlyArray<MediaPart>, GraphError>>;
+export { extractPdfImages };

package/dist/infra/pdf-text-extractor.d.ts

@@ -0,0 +1,41 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Extract a PDF's text layer via unpdf (a pure-JS pdfjs build — no native deps,
+ * runs under Bun). Returns the reading-order text of every page merged into one
+ * string. A born-digital PDF (exported from Word/LaTeX/Chrome/…) yields its text;
+ * a scanned / image-only PDF has no text layer, so the string comes back empty —
+ * callers treat that as "needs OCR / a vision model", never as success-with-text.
+ *
+ * Scope note: this is the embedded text layer, NOT OCR. It also does not preserve
+ * layout structure (headings, tables, columns flatten into reading order).
+ *
+ * `try/catch` is permitted here per the infra-boundary rule: pdfjs throws on
+ * malformed input and we translate that into a Result rather than letting it escape.
+ *
+ * `verbosity: 0` (pdfjs `VerbosityLevel.ERRORS`) silences pdfjs's TrueType
+ * font-hinting log spam — `Warning: TT: undefined function: N`, `Required "glyf"
+ * table is not found`, `Indexing all PDF objects` — which it emits via its own
+ * `console.warn` while parsing a PDF's embedded fonts. Font hinting is sub-pixel
+ * glyph rendering, completely irrelevant to text extraction (the text still comes
+ * out fine); the default level (WARNINGS) just floods the host app's logs once per
+ * quirky font. We lower it at the boundary because the noise originates inside
+ * pdfjs — the `no-console` rule keeps us from emitting or intercepting it ourselves.
+ */
+/**
+ * Map a pdfjs throw to an actionable message. The special case is an encrypted
+ * PDF: pdfjs raises `PasswordException` ("No password given") — QA run-1 found a
+ * real tenant file surfacing that raw string with zero guidance. Password
+ * handling is genuinely unsupported (and Graph's `format=pdf` cannot unlock
+ * encrypted sources either), so say that honestly instead of leaking pdfjs
+ * internals. Pure and exported: the branch is unit-tested with shaped errors —
+ * no encrypted-PDF fixture exists in the toolchain.
+ */
+declare const pdfErrorMessage: (e: unknown) => string;
+type PdfText = {
+    readonly text: string;
+    readonly pageCount: number;
+};
+declare const extractPdfText: (bytes: Uint8Array) => Promise<Result<PdfText, GraphError>>;
+export { extractPdfText, pdfErrorMessage };
+export type { PdfText };

package/dist/infra/png-encode.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Minimal, dependency-free PNG encoder for raw 8-bit pixel buffers. unpdf hands
+ * back *decoded* pixels (1=grayscale, 3=RGB, 4=RGBA channels), so to write usable
+ * image files without a native dep (sharp/canvas) we wrap them in a PNG ourselves:
+ * signature + IHDR + a single zlib-compressed IDAT (filter-0 scanlines) + IEND.
+ */
+type RawImage = {
+    readonly width: number;
+    readonly height: number;
+    readonly channels: number;
+    readonly data: Uint8Array;
+};
+declare const encodePng: (image: RawImage) => Uint8Array;
+export { encodePng };
+export type { RawImage };

package/dist/infra/sheetjs-adapter.d.ts

@@ -4,6 +4,6 @@ type SheetCsv = {
     readonly name: string;
     readonly csv: string;
 };
-declare const readSheetsAsCsv: (bytes: Uint8Array) => Result<ReadonlyArray<SheetCsv>, GraphError>;
+declare const readSheetsAsCsv: (bytes: Uint8Array) => Promise<Result<ReadonlyArray<SheetCsv>, GraphError>>;
 export { readSheetsAsCsv };
 export type { SheetCsv };

package/dist/infra/system-browser-auth.d.ts

@@ -0,0 +1,35 @@
+import type { AccessToken } from '../domain/access-token.js';
+import type { Result } from '../domain/result.js';
+import type { Logger } from '../use-cases/ports/logger.js';
+type SystemBrowserAuthDeps = {
+    readonly logger: Logger;
+    readonly timeoutMs?: number;
+    readonly extensionTimeoutMs?: number;
+};
+type SystemBrowserTokenResult = {
+    readonly accessToken: AccessToken;
+    readonly refreshToken: string | null;
+    readonly elevatedAccessToken?: AccessToken | null;
+    readonly chatsvcaggAccessToken?: AccessToken | null;
+    readonly ic3AccessToken?: AccessToken | null;
+    readonly chatsvcaggRegion?: string;
+};
+type SystemBrowserAuthError = {
+    type: 'server_bind_failed';
+    message: string;
+} | {
+    type: 'browser_open_failed';
+    message: string;
+} | {
+    type: 'extension_timeout';
+    message: string;
+} | {
+    type: 'invalid_token';
+    message: string;
+} | {
+    type: 'cancelled';
+    message: string;
+};
+declare const authenticateViaSystemBrowser: (deps: SystemBrowserAuthDeps) => Promise<Result<SystemBrowserTokenResult, SystemBrowserAuthError>>;
+export { authenticateViaSystemBrowser };
+export type { SystemBrowserAuthDeps, SystemBrowserAuthError, SystemBrowserTokenResult };

package/dist/infra/system-browser-loader.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from '../use-cases/ports/logger.js';
+import type { SystemBrowserAuthFn } from './auth.js';
+export declare const defaultSystemBrowserAuth: (logger: Logger, skipSystemBrowser: boolean) => SystemBrowserAuthFn;

package/dist/infra/token-callback-server.d.ts

@@ -0,0 +1,31 @@
+import type { Result } from '../domain/result.js';
+import type { Logger } from '../use-cases/ports/logger.js';
+type TokenCallbackPayload = {
+    readonly access_token: string;
+    readonly refresh_token?: string;
+    readonly elevated_access_token?: string;
+    readonly chatsvcagg_access_token?: string;
+    readonly ic3_access_token?: string;
+    readonly chatsvcagg_region?: string;
+};
+type TokenCallbackServer = {
+    readonly port: number;
+    readonly start: () => Promise<Result<TokenCallbackPayload, TokenCallbackError>>;
+    readonly stop: () => Promise<void>;
+};
+type TokenCallbackError = {
+    type: 'bind_failed';
+    message: string;
+} | {
+    type: 'timeout';
+    message: string;
+} | {
+    type: 'invalid_payload';
+    message: string;
+} | {
+    type: 'server_closed';
+    message: string;
+};
+declare const createTokenCallbackServer: (logger: Logger, timeoutMs?: number) => TokenCallbackServer;
+export { createTokenCallbackServer };
+export type { TokenCallbackError, TokenCallbackPayload, TokenCallbackServer };

package/dist/infra/zip-reader.d.ts

@@ -0,0 +1,32 @@
+import type { Result } from '../domain/result.js';
+import type { GraphError } from './graph-client.js';
+/**
+ * Reads every file entry out of an arbitrary `.zip` archive as raw bytes,
+ * sorted by path, directories excluded. Generic counterpart to
+ * `ooxml-media-extractor` (which matches only media paths) and
+ * `ooxml-zip-adapter` (which decodes entries as UTF-8 strings) — used by the
+ * zip-conversion commands to fan each contained file out to the right
+ * converter. try/catch is permitted here (src/infra/**, atelier rule 17): a
+ * malformed-zip throw becomes a Result.err.
+ */
+type ZipEntry = {
+    readonly path: string;
+    readonly bytes: Uint8Array;
+};
+/**
+ * Decode a legacy zip entry name — the raw filename bytes of an entry whose
+ * UTF-8 flag (general-purpose bit 11) is NOT set and which carries no Info-ZIP
+ * Unicode-path extra field. JSZip's default decoder assumes UTF-8 and mojibakes
+ * these (the `unzip -O GBK` case): Chinese vendor archives written by WinRAR /
+ * Windows Explorer store names in GBK. Try strict UTF-8 first (some archivers
+ * emit UTF-8 bytes without setting the flag), then fall back to GB18030 — a GBK
+ * superset whose 0x00–0x7F bytes are plain ASCII, so legacy ASCII/CP437 names
+ * survive unchanged while CJK byte sequences decode correctly.
+ *
+ * Only reached for non-UTF-8-flagged names (JSZip handles UTF-8 names itself),
+ * so a UTF-8 archive's path-handling is unchanged.
+ */
+declare const decodeZipFileName: (bytes: Uint8Array) => string;
+declare const openZipEntries: (bytes: Uint8Array) => Promise<Result<ReadonlyArray<ZipEntry>, GraphError>>;
+export { decodeZipFileName, openZipEntries };
+export type { ZipEntry };