@abyss-project/tools 2.10.0 → 2.11.0

package/src/api/atlas.api.ts

@@ -22,8 +22,9 @@ import {
 export const paginateAtlas = async (
   query: IPaginateAtlasQuery,
 ): Promise<IPaginateAtlasResponse> => {
-  return (await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(`atlas/paginate`, { params: query }))
-    .data;
+  return (
+    await AbyssToolsCore.axios.get<IPaginateAtlasResponse>(`atlas/paginate`, { params: query })
+  ).data;
 };
 
 export const paginateProjectAtlas = async (
@@ -52,7 +53,8 @@ export const updateAtlas = async (
   params: IUpdateAtlasParams,
   body: IUpdateAtlasBody,
 ): Promise<IUpdateAtlasResponse> => {
-  return (await AbyssToolsCore.axios.put<IUpdateAtlasResponse>(`atlas/${params.atlasId}`, body)).data;
+  return (await AbyssToolsCore.axios.put<IUpdateAtlasResponse>(`atlas/${params.atlasId}`, body))
+    .data;
 };
 
 export const createAtlas = async (body: ICreateAtlasBody): Promise<ICreateAtlasResponse> => {
@@ -64,7 +66,10 @@ export const createForOrganizationAtlas = async (
   body: ICreateAtlasBody,
 ): Promise<ICreateAtlasResponse> => {
   return (
-    await AbyssToolsCore.axios.post<ICreateAtlasResponse>(`atlas/organization/${params.organizationId}`, body)
+    await AbyssToolsCore.axios.post<ICreateAtlasResponse>(
+      `atlas/organization/${params.organizationId}`,
+      body,
+    )
   ).data;
 };
 
@@ -92,9 +97,9 @@ export const transferAtlas = async (
   ).data;
 };
 
-export const countOrganizationAtlas = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
+export const countOrganizationAtlas = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
   return (
     await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `atlas/organization/${params.organizationId}/count`,

package/src/api/atlas.public.api.ts

@@ -13,7 +13,9 @@ export const getAtlasPublic = async (
   params: IGetAtlasPublicParams,
 ): Promise<IGetAtlasPublicResponse> => {
   return (
-    await AbyssToolsCore.axios.get<IGetAtlasPublicResponse>(`atlas/public/${params.publicAccessToken}`)
+    await AbyssToolsCore.axios.get<IGetAtlasPublicResponse>(
+      `atlas/public/${params.publicAccessToken}`,
+    )
   ).data;
 };
 

package/src/api/board-card.api.ts

@@ -130,8 +130,11 @@ export const searchBoardCard = async (
   query: ISearchBoardCardQuery,
 ): Promise<ISearchBoardCardResponse> => {
   return (
-    await AbyssToolsCore.axios.get<ISearchBoardCardResponse>(`board/${params.boardId}/card/search`, {
-      params: query,
-    })
+    await AbyssToolsCore.axios.get<ISearchBoardCardResponse>(
+      `board/${params.boardId}/card/search`,
+      {
+        params: query,
+      },
+    )
   ).data;
 };

package/src/api/board-column.api.ts

@@ -49,6 +49,9 @@ export const createBoardColumn = async (
   body: ICreateBoardColumnBody,
 ): Promise<ICreateBoardColumnResponse> => {
   return (
-    await AbyssToolsCore.axios.post<ICreateBoardColumnResponse>(`board/${params.boardId}/column`, body)
+    await AbyssToolsCore.axios.post<ICreateBoardColumnResponse>(
+      `board/${params.boardId}/column`,
+      body,
+    )
   ).data;
 };

package/src/api/board-label.api.ts

@@ -55,7 +55,10 @@ export const createBoardLabel = async (
   body: ICreateBoardLabelBody,
 ): Promise<ICreateBoardLabelResponse> => {
   return (
-    await AbyssToolsCore.axios.post<ICreateBoardLabelResponse>(`board/${params.boardId}/label`, body)
+    await AbyssToolsCore.axios.post<ICreateBoardLabelResponse>(
+      `board/${params.boardId}/label`,
+      body,
+    )
   ).data;
 };
 
@@ -82,6 +85,7 @@ export const removeBoardLabel = async (
 export const listBoardLabels = async (
   params: IListBoardLabelParams,
 ): Promise<IListBoardLabelResponse> => {
-  return (await AbyssToolsCore.axios.get<IListBoardLabelResponse>(`board/${params.boardId}/label/list`))
-    .data;
+  return (
+    await AbyssToolsCore.axios.get<IListBoardLabelResponse>(`board/${params.boardId}/label/list`)
+  ).data;
 };

package/src/api/board.api.ts

@@ -31,7 +31,8 @@ export const getBoard = async (params: IGetBoardParams): Promise<IGetBoardRespon
 export const getBySlugBoard = async (
   params: IGetBySlugBoardParams,
 ): Promise<IGetBySlugBoardResponse> => {
-  return (await AbyssToolsCore.axios.get<IGetBySlugBoardResponse>(`board/slug/${params.slug}`)).data;
+  return (await AbyssToolsCore.axios.get<IGetBySlugBoardResponse>(`board/slug/${params.slug}`))
+    .data;
 };
 
 export const deleteBoard = async (params: IDeleteBoardParams): Promise<IDeleteBoardResponse> => {
@@ -42,7 +43,8 @@ export const updateBoard = async (
   params: IUpdateBoardParams,
   body: IUpdateBoardBody,
 ): Promise<IUpdateBoardResponse> => {
-  return (await AbyssToolsCore.axios.put<IUpdateBoardResponse>(`board/${params.boardId}`, body)).data;
+  return (await AbyssToolsCore.axios.put<IUpdateBoardResponse>(`board/${params.boardId}`, body))
+    .data;
 };
 
 export const createBoard = async (body: ICreateBoardBody): Promise<ICreateBoardResponse> => {
@@ -54,12 +56,18 @@ export const createForOrganizationBoard = async (
   body: ICreateBoardBody,
 ): Promise<ICreateBoardResponse> => {
   return (
-    await AbyssToolsCore.axios.post<ICreateBoardResponse>(`board/organization/${params.organizationId}`, body)
+    await AbyssToolsCore.axios.post<ICreateBoardResponse>(
+      `board/organization/${params.organizationId}`,
+      body,
+    )
   ).data;
 };
 
-export const listBoard = async (query?: { sharedWithMe?: boolean }): Promise<IListBoardUserResponse> => {
-  return (await AbyssToolsCore.axios.get<IListBoardUserResponse>('board/list', { params: query })).data;
+export const listBoard = async (query?: {
+  sharedWithMe?: boolean;
+}): Promise<IListBoardUserResponse> => {
+  return (await AbyssToolsCore.axios.get<IListBoardUserResponse>('board/list', { params: query }))
+    .data;
 };
 
 export const listBoardProject = async (params: {
@@ -71,8 +79,9 @@ export const listBoardProject = async (params: {
 };
 
 export const getNextCardPreviewBoard = async (): Promise<IGetNextCardPreviewBoardResponse> => {
-  return (await AbyssToolsCore.axios.post<IGetNextCardPreviewBoardResponse>(`board/next-card-preview`))
-    .data;
+  return (
+    await AbyssToolsCore.axios.post<IGetNextCardPreviewBoardResponse>(`board/next-card-preview`)
+  ).data;
 };
 
 export const listBoardOrganization = async (
@@ -111,9 +120,9 @@ export const transferBoard = async (
   ).data;
 };
 
-export const countOrganizationBoard = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
+export const countOrganizationBoard = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
   return (
     await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `board/organization/${params.organizationId}/count`,

package/src/api/draw.api.ts

@@ -29,9 +29,12 @@ export const paginateProjectDraw = async (
   query: IPaginateDrawQuery,
 ): Promise<IPaginateDrawResponse> => {
   return (
-    await AbyssToolsCore.axios.get<IPaginateDrawResponse>(`project/${params.projectId}/draw/paginate`, {
-      params: query,
-    })
+    await AbyssToolsCore.axios.get<IPaginateDrawResponse>(
+      `project/${params.projectId}/draw/paginate`,
+      {
+        params: query,
+      },
+    )
   ).data;
 };
 
@@ -58,8 +61,12 @@ export const createForOrganizationDraw = async (
   params: ICreateForOrganizationDrawParams,
   body: ICreateDrawBody,
 ): Promise<ICreateDrawResponse> => {
-  return (await AbyssToolsCore.axios.post<ICreateDrawResponse>(`draw/organization/${params.organizationId}`, body))
-    .data;
+  return (
+    await AbyssToolsCore.axios.post<ICreateDrawResponse>(
+      `draw/organization/${params.organizationId}`,
+      body,
+    )
+  ).data;
 };
 
 export const paginateOrganizationDraw = async (
@@ -79,16 +86,13 @@ export const transferDraw = async (
   body: ITransferContentBody,
 ): Promise<ITransferDrawResponse> => {
   return (
-    await AbyssToolsCore.axios.post<ITransferDrawResponse>(
-      `draw/${params.drawId}/transfer`,
-      body,
-    )
+    await AbyssToolsCore.axios.post<ITransferDrawResponse>(`draw/${params.drawId}/transfer`, body)
   ).data;
 };
 
-export const countOrganizationDraw = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
+export const countOrganizationDraw = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
   return (
     await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `draw/organization/${params.organizationId}/count`,

package/src/api/draw.public.api.ts

@@ -15,7 +15,9 @@ export const getDrawPublic = async (
   params: IGetDrawPublicParams,
 ): Promise<IGetDrawPublicResponse> => {
   return (
-    await AbyssToolsCore.axios.get<IGetDrawPublicResponse>(`draw/public/${params.publicAccessToken}`)
+    await AbyssToolsCore.axios.get<IGetDrawPublicResponse>(
+      `draw/public/${params.publicAccessToken}`,
+    )
   ).data;
 };
 

package/src/api/extraction-plan-preset.api.ts

@@ -11,11 +11,7 @@
 // ──────────────────────────────────────────────
 
 import { AbyssToolsCore } from '..';
-import type {
-  ICreatePlanPresetBody,
-  IUpdatePlanPresetBody,
-  IListPlanPresetQuery,
-} from '../types';
+import type { ICreatePlanPresetBody, IUpdatePlanPresetBody, IListPlanPresetQuery } from '../types';
 import type {
   IListModesResponse,
   IListPlanPresetsResponse,
@@ -30,22 +26,72 @@ function authHeader(apiKey?: string): Record<string, string> {
 }
 
 export const listModes = async (apiKey?: string): Promise<IListModesResponse> =>
-  (await AbyssToolsCore.axios.get<IListModesResponse>(`extract/modes`, { headers: authHeader(apiKey) })).data;
+  (
+    await AbyssToolsCore.axios.get<IListModesResponse>(`extract/modes`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const listExtractionPlanPresets = async (query: IListPlanPresetQuery = {}, apiKey?: string): Promise<IListPlanPresetsResponse> =>
-  (await AbyssToolsCore.axios.get<IListPlanPresetsResponse>(`extract/plans`, { params: query, headers: authHeader(apiKey) })).data;
+export const listExtractionPlanPresets = async (
+  query: IListPlanPresetQuery = {},
+  apiKey?: string,
+): Promise<IListPlanPresetsResponse> =>
+  (
+    await AbyssToolsCore.axios.get<IListPlanPresetsResponse>(`extract/plans`, {
+      params: query,
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const getExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IGetPlanPresetResponse> =>
-  (await AbyssToolsCore.axios.get<IGetPlanPresetResponse>(`extract/plans/${id}`, { headers: authHeader(apiKey) })).data;
+export const getExtractionPlanPreset = async (
+  id: string,
+  apiKey?: string,
+): Promise<IGetPlanPresetResponse> =>
+  (
+    await AbyssToolsCore.axios.get<IGetPlanPresetResponse>(`extract/plans/${id}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const createExtractionPlanPreset = async (body: ICreatePlanPresetBody, apiKey?: string): Promise<IGetPlanPresetResponse> =>
-  (await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(`extract/plans`, body, { headers: authHeader(apiKey) })).data;
+export const createExtractionPlanPreset = async (
+  body: ICreatePlanPresetBody,
+  apiKey?: string,
+): Promise<IGetPlanPresetResponse> =>
+  (
+    await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(`extract/plans`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const updateExtractionPlanPreset = async (id: string, body: IUpdatePlanPresetBody, apiKey?: string): Promise<IGetPlanPresetResponse> =>
-  (await AbyssToolsCore.axios.put<IGetPlanPresetResponse>(`extract/plans/${id}`, body, { headers: authHeader(apiKey) })).data;
+export const updateExtractionPlanPreset = async (
+  id: string,
+  body: IUpdatePlanPresetBody,
+  apiKey?: string,
+): Promise<IGetPlanPresetResponse> =>
+  (
+    await AbyssToolsCore.axios.put<IGetPlanPresetResponse>(`extract/plans/${id}`, body, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const deleteExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IDeletePlanPresetResponse> =>
-  (await AbyssToolsCore.axios.delete<IDeletePlanPresetResponse>(`extract/plans/${id}`, { headers: authHeader(apiKey) })).data;
+export const deleteExtractionPlanPreset = async (
+  id: string,
+  apiKey?: string,
+): Promise<IDeletePlanPresetResponse> =>
+  (
+    await AbyssToolsCore.axios.delete<IDeletePlanPresetResponse>(`extract/plans/${id}`, {
+      headers: authHeader(apiKey),
+    })
+  ).data;
 
-export const setDefaultExtractionPlanPreset = async (id: string, apiKey?: string): Promise<IGetPlanPresetResponse> =>
-  (await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(`extract/plans/${id}/default`, {}, { headers: authHeader(apiKey) })).data;
+export const setDefaultExtractionPlanPreset = async (
+  id: string,
+  apiKey?: string,
+): Promise<IGetPlanPresetResponse> =>
+  (
+    await AbyssToolsCore.axios.post<IGetPlanPresetResponse>(
+      `extract/plans/${id}/default`,
+      {},
+      { headers: authHeader(apiKey) },
+    )
+  ).data;

package/src/api/extraction-settings.api.ts

@@ -9,14 +9,8 @@
 // ──────────────────────────────────────────────
 
 import { AbyssToolsCore } from '..';
-import type {
-  IGetExtractionSettingsQuery,
-  IUpsertExtractionSettingsBody,
-} from '../types';
-import type {
-  IGetExtractionSettingsResponse,
-  IUpsertExtractionSettingsResponse,
-} from '../types';
+import type { IGetExtractionSettingsQuery, IUpsertExtractionSettingsBody } from '../types';
+import type { IGetExtractionSettingsResponse, IUpsertExtractionSettingsResponse } from '../types';
 
 const DEFAULT_API_KEY_HEADER = 'abyss-api-key';
 

package/src/api/extraction.api.ts

@@ -3,6 +3,11 @@
 //
 // Sync helper accepts an inline PDF buffer (multipart) or a storage_file_id.
 // Queue helper enqueues for async processing + webhook delivery.
+//
+// Multipart bodies are built with the global `FormData` + `Blob` — the same
+// code in a browser and on Node (>= 18, see package.json `engines`). axios
+// serializes a spec-compliant FormData on both and sets the multipart
+// boundary itself, so no content-type header is ever set by hand.
 // ──────────────────────────────────────────────
 
 import { AbyssToolsCore } from '..';
@@ -92,16 +97,9 @@ function authHeader(apiKey?: string): Record<string, string> {
   return apiKey ? { [DEFAULT_API_KEY_HEADER]: apiKey } : {};
 }
 
-async function loadFormData(): Promise<any> {
-  if (typeof FormData !== 'undefined' && typeof window !== 'undefined') {
-    return FormData;
-  }
-  // Use indirect eval so bundlers (esbuild/vite/webpack) do not try to
-  // resolve the Node-only "form-data" package when this file is included
-  // in a browser bundle. The require only runs at runtime on Node.
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
-  const nodeRequire: NodeRequire = new Function('return require')();
-  return nodeRequire('form-data');
+/** The PDF bytes as a multipart file part: filename kept, `application/pdf` type. */
+function appendPdfPart(form: FormData, pdf: Buffer | Uint8Array, filename: string): void {
+  form.append('file', new Blob([pdf], { type: 'application/pdf' }), filename);
 }
 
 function serializeParams<T extends object>(o: T): Record<string, unknown> {
@@ -124,18 +122,22 @@ export interface ExtractCallOptions {
   idempotencyKey?: string;
 }
 
+/**
+ * `POST /extract/extract` with `processing: 'sync'`. The route still moves an
+ * async plan (an OCR pass, or more than one pass — inline or reached through
+ * `plan_preset_id`) onto the queue and answers 202 with the queue body, so the
+ * call resolves either the extraction (`extraction_id`) or the queued job
+ * (`job_id`); narrow on `'job_id' in response.data`.
+ */
 export const extractSync = async (
   body: IExtractBody,
   scope: IExtractionContentScopeQuery = {},
   apiKey?: string,
   opts: ExtractCallOptions = {},
-): Promise<IExtractSyncResponse> => {
-  return postExtract(
-    { ...body, processing: 'sync' },
-    scope,
-    apiKey,
-    opts,
-  ) as Promise<IExtractSyncResponse>;
+): Promise<IExtractSyncResponse | IExtractQueueResponse> => {
+  return postExtract({ ...body, processing: 'sync' }, scope, apiKey, opts) as Promise<
+    IExtractSyncResponse | IExtractQueueResponse
+  >;
 };
 
 export const extractQueue = async (
@@ -164,11 +166,11 @@ const postExtract = async (
   }
   const params = serializeParams(scope);
   if (body.pdf) {
-    const { form, formHeaders } = await buildExtractMultipart(body);
+    const form = buildExtractMultipart(body);
     return (
       await AbyssToolsCore.axios.post(`extract/extract`, form, {
         params,
-        headers: { ...formHeaders, ...authHeader(apiKey), ...extraHeaders },
+        headers: { ...authHeader(apiKey), ...extraHeaders },
         maxBodyLength: Infinity,
         maxContentLength: Infinity,
       })
@@ -185,13 +187,13 @@ const postExtract = async (
   ).data;
 };
 
-function appendIf(form: any, key: string, value: unknown): void {
+function appendIf(form: FormData, key: string, value: unknown): void {
   if (value === undefined || value === null) return;
   form.append(key, String(value));
 }
 
 /** Append the shared extract text fields (all optional) onto a multipart form. */
-function appendExtractFields(form: any, body: IExtractBody): void {
+function appendExtractFields(form: FormData, body: IExtractBody): void {
   appendIf(form, 'mode', body.mode);
   if (body.hint) form.append('hint', JSON.stringify(body.hint));
   appendIf(form, 'template_id', body.template_id);
@@ -201,43 +203,32 @@ function appendExtractFields(form: any, body: IExtractBody): void {
   if (typeof body.archive === 'boolean') form.append('archive', String(body.archive));
   if (typeof body.force === 'boolean') form.append('force', String(body.force));
   if (body.processing) form.append('processing', body.processing);
+  if (body.plan) form.append('plan', JSON.stringify(body.plan));
+  appendIf(form, 'plan_preset_id', body.plan_preset_id);
+  // Wire name read by the API's parseExtractRequest ('true' / 'false').
+  if (typeof body.improvementConsent === 'boolean') {
+    form.append('improvement_consent', String(body.improvementConsent));
+  }
 }
 
 /**
- * Build the multipart form for an extract upload — browser `FormData`/`Blob`
- * or Node `Buffer` + lazy-required `form-data` — shared by the personal and
- * application extract clients. Returns the form plus the content-type headers
- * it needs (empty for the browser, which sets its own boundary;
- * `form.getHeaders()` for Node). Scope params + auth headers are added by the
- * caller. Requires `body.pdf` to be set.
+ * Build the multipart form for an extract upload, shared by the personal and
+ * application extract clients: the PDF as the `file` part (filename from
+ * `body.pdf_filename`, default `document.pdf`) plus the extract text fields.
+ * Scope params + auth headers are added by the caller; axios sets the
+ * multipart content type. Requires `body.pdf` to be set.
  */
-export async function buildExtractMultipart(
-  body: IExtractBody,
-): Promise<{ form: any; formHeaders: Record<string, string> }> {
+export function buildExtractMultipart(body: IExtractBody): FormData {
   const pdf = body.pdf;
   if (!pdf) {
     // Precondition: only the multipart-upload path calls this (both callers
     // guard on `body.pdf` first). Enforced here so the helper is self-contained.
     throw new Error('buildExtractMultipart requires body.pdf');
   }
-  const isBrowser = typeof window !== 'undefined' && typeof FormData !== 'undefined';
-  const filename = body.pdf_filename ?? 'document.pdf';
-  if (isBrowser) {
-    const form = new FormData();
-    const blob = new Blob([pdf as Uint8Array], { type: 'application/pdf' });
-    form.append('file', blob, filename);
-    appendExtractFields(form, body);
-    return { form, formHeaders: {} };
-  }
-  const FormDataCtor = await loadFormData();
-  const form = new FormDataCtor();
-  const buf = Buffer.isBuffer(pdf) ? pdf : Buffer.from(pdf);
-  form.append('file', buf, { filename, contentType: 'application/pdf' });
+  const form = new FormData();
+  appendPdfPart(form, pdf, body.pdf_filename ?? 'document.pdf');
   appendExtractFields(form, body);
-  return {
-    form,
-    formHeaders: typeof form.getHeaders === 'function' ? form.getHeaders() : {},
-  };
+  return form;
 }
 
 export const extractBulk = async (
@@ -260,29 +251,11 @@ export const detect = async (
   pdfFilename = 'document.pdf',
   apiKey?: string,
 ): Promise<IDetectResponse> => {
-  const isBrowser = typeof window !== 'undefined' && typeof FormData !== 'undefined';
-  if (isBrowser) {
-    const form = new FormData();
-    const blob = new Blob([pdf as Uint8Array], { type: 'application/pdf' });
-    form.append('file', blob, pdfFilename);
-    return (
-      await AbyssToolsCore.axios.post<IDetectResponse>(`extract/detect`, form, {
-        headers: authHeader(apiKey),
-        maxBodyLength: Infinity,
-        maxContentLength: Infinity,
-      })
-    ).data;
-  }
-  const FormDataCtor = await loadFormData();
-  const form = new FormDataCtor();
-  const buf = Buffer.isBuffer(pdf) ? pdf : Buffer.from(pdf);
-  form.append('file', buf, { filename: pdfFilename, contentType: 'application/pdf' });
+  const form = new FormData();
+  appendPdfPart(form, pdf, pdfFilename);
   return (
     await AbyssToolsCore.axios.post<IDetectResponse>(`extract/detect`, form, {
-      headers: {
-        ...(typeof form.getHeaders === 'function' ? form.getHeaders() : {}),
-        ...authHeader(apiKey),
-      },
+      headers: authHeader(apiKey),
       maxBodyLength: Infinity,
       maxContentLength: Infinity,
     })

package/src/api/extraction.application.api.ts

@@ -6,13 +6,13 @@
 // for inter-service callers (e.g. AbyssBanking) authenticating with a project
 // API key instead of a personal/org session.
 //
-// Reuses extraction.api.ts's `buildExtractMultipart` (the same dual-environment
-// multipart handling — browser `FormData`/`Blob` vs Node `Buffer` +
-// lazy-required `form-data`) and every request/response TYPE verbatim
-// (`IExtractBody`, `IExtractSyncResponse`) — never redefined here. There is NO
-// scope query param: unlike the personal/org route's `?organization_id=`, an
-// application caller's scope is entirely its `:applicationId` URL segment,
-// resolved server-side by ApplicationMiddleware (round-trips to abyss-main).
+// Reuses extraction.api.ts's `buildExtractMultipart` (the same global
+// `FormData` + `Blob` multipart body as the personal client) and every
+// request/response TYPE verbatim (`IExtractBody`, `IExtractSyncResponse`) —
+// never redefined here. There is NO scope query param: unlike the
+// personal/org route's `?organization_id=`, an application caller's scope is
+// entirely its `:applicationId` URL segment, resolved server-side by
+// ApplicationMiddleware (round-trips to abyss-main).
 //
 // `authHeaderApplication` is kept LOCAL and unexported, same convention as the
 // personal client's own `authHeader` — it sends `API_KEY_APPLICATION_HEADER`
@@ -34,11 +34,16 @@ function authHeaderApplication(applicationApiKey?: string): Record<string, strin
 /**
  * `POST /extract/application/:applicationId/extract` — run one synchronous
  * extraction OWNED by `applicationId` and BILLED to its resolved owning
- * organization. Same body contract as the personal {@link
- * ../extraction.api.extractSync | extractSync}: an inline PDF (`body.pdf`,
- * multipart) OR a `body.storage_file_id` reference (JSON), `body.mode`
- * (auto|hint|template), optional hint/template/plan/preset. `options`
- * forwards a Stripe-style `Idempotency-Key` header (24h replay window) when set.
+ * organization. The route accepts only a multipart PDF upload: send
+ * `body.pdf`, with `body.mode` `auto` or `hint`; `body.plan` (inline, single
+ * pass, no OCR, no template pass) and `body.improvementConsent` travel as
+ * multipart fields. The route refuses `storage_file_id`, `plan_preset_id`,
+ * `template_id` and `template` with a 4xx. A body without `pdf` is sent as
+ * JSON and never runs an extraction: the memory watchdog may answer 503 before
+ * the route reads the body; past it, the route answers a 4xx — the
+ * `storage_file_id` refusal when the body carries one, otherwise "Provide file
+ * (multipart pdf)". `options` forwards a Stripe-style
+ * `Idempotency-Key` header (24h replay window) when set.
  */
 export const runExtractionApplication = async (
   applicationId: string,
@@ -53,10 +58,10 @@ export const runExtractionApplication = async (
   const url = `extract/application/${applicationId}/extract`;
 
   if (body.pdf) {
-    const { form, formHeaders } = await buildExtractMultipart(body);
+    const form = buildExtractMultipart(body);
     return (
       await AbyssToolsCore.axios.post<IExtractSyncResponse>(url, form, {
-        headers: { ...formHeaders, ...authHeaderApplication(applicationApiKey), ...extraHeaders },
+        headers: { ...authHeaderApplication(applicationApiKey), ...extraHeaders },
         maxBodyLength: Infinity,
         maxContentLength: Infinity,
       })

package/src/api/retrospective.api.ts

@@ -23,7 +23,9 @@ export const getRetrospective = async (
   params: IGetRetrospectiveParams,
 ): Promise<IGetRetrospectiveResponse> => {
   return (
-    await AbyssToolsCore.axios.get<IGetRetrospectiveResponse>(`retrospective/${params.retrospectiveId}`)
+    await AbyssToolsCore.axios.get<IGetRetrospectiveResponse>(
+      `retrospective/${params.retrospectiveId}`,
+    )
   ).data;
 };
 
@@ -52,7 +54,8 @@ export const paginateRetrospective = async (
 export const createRetrospective = async (
   body: ICreateRetrospectiveBody,
 ): Promise<ICreateRetrospectiveResponse> => {
-  return (await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body)).data;
+  return (await AbyssToolsCore.axios.post<ICreateRetrospectiveResponse>(`retrospective`, body))
+    .data;
 };
 
 export const createForOrganizationRetrospective = async (
@@ -113,9 +116,9 @@ export const transferRetrospective = async (
   ).data;
 };
 
-export const countOrganizationRetrospective = async (
-  params: { organizationId: string },
-): Promise<ICountOrganizationResponse> => {
+export const countOrganizationRetrospective = async (params: {
+  organizationId: string;
+}): Promise<ICountOrganizationResponse> => {
   return (
     await AbyssToolsCore.axios.get<ICountOrganizationResponse>(
       `retrospective/organization/${params.organizationId}/count`,