@stigmer/react 3.12.3 → 3.12.5

package/src/__tests__/bare-host-resets.layout.test.tsx

@@ -0,0 +1,184 @@
+// Bare-host regression suite for the per-element UA resets (#695).
+//
+// Runs in a real Chromium via `vitest.a11y.config.ts` — the defect under
+// guard is the user agent's OWN default list/fieldset/flow-content styling
+// (bullets, 40px indents, stacked margins), which only a real browser
+// applies. happy-dom has no UA stylesheet, so it would pass vacuously.
+//
+// The contract: every SDK component is authored against a zeroed-margin
+// baseline (our consoles ship a global reset). In a host WITHOUT one —
+// third-party embeds, the SDK's stated audience — UI lists and fieldsets
+// carry the `UNSTYLED_LIST`/`UNSTYLED_FIELDSET` per-component resets
+// (`internal/element-resets.ts` records why this class of reset cannot live
+// in styles.css), and the markdown map declares its own top/inline margins.
+// Like the sibling #374 suite (preflight-parity.layout.test.tsx), this
+// renders against the SHIPPED stylesheet (`dist/styles.css`, rebuilt by
+// `npm run build:css`) and nothing else — the page IS the bare host.
+//
+// Three directions, all load-bearing:
+// 1. A control proving the harness is genuinely bare (a raw <ul> DOES show
+//    UA bullets — if this fails, every other assertion here is vacuous).
+// 2. The resets neutralize UA defaults on real, swept components.
+// 3. Utilities and deliberate styling still win (markdown lists keep their
+//    explicit bullets; spacing utilities compose on top of the reset).
+
+import "../../dist/styles.css";
+
+import { describe, it, expect, afterEach } from "vitest";
+import { render, cleanup } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import Markdown from "react-markdown";
+import type { Stigmer } from "@stigmer/sdk";
+import { TodoItemSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/todo_pb";
+import { TodoStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { StigmerProvider } from "../provider";
+import { TodoList } from "../execution/TodoList.js";
+import { UNSTYLED_FIELDSET, UNSTYLED_LIST } from "../internal/element-resets.js";
+import { MARKDOWN_COMPONENTS } from "../internal/markdown-components.js";
+
+afterEach(cleanup);
+
+// A minimal client (the preflight-parity suite's idiom): a null credential
+// keeps the provider's registry fetches non-blocking so rendering is
+// synchronous and never touches the network.
+function makeClient(): Stigmer {
+  return {
+    baseUrl: "https://example.test",
+    getAuthCredential: async () => null,
+    fetch: (async () => {
+      throw new Error("network disabled in test");
+    }) as unknown as typeof globalThis.fetch,
+  } as unknown as Stigmer;
+}
+
+function renderScoped(ui: React.ReactNode): HTMLElement {
+  render(
+    <StigmerProvider client={makeClient()}>
+      <div data-testid="probe">{ui}</div>
+    </StigmerProvider>,
+  );
+  return document.querySelector('[data-testid="probe"]') as HTMLElement;
+}
+
+function computed(el: Element): CSSStyleDeclaration {
+  return getComputedStyle(el);
+}
+
+const ZERO_MARGINS = ["0px", "0px", "0px", "0px"];
+
+function margins(style: CSSStyleDeclaration): string[] {
+  return [style.marginTop, style.marginRight, style.marginBottom, style.marginLeft];
+}
+
+describe("bare-host per-element resets (#695)", () => {
+  it("CONTROL: the harness is genuinely bare — a raw <ul> wears UA bullets and indent", () => {
+    const probe = renderScoped(
+      <ul>
+        <li>raw</li>
+      </ul>,
+    );
+    const style = computed(probe.querySelector("ul")!);
+
+    expect(style.listStyleType, "no global reset may leak into this page").toBe("disc");
+    expect(style.paddingLeft, "UA padding-inline-start must be present").toBe("40px");
+  });
+
+  describe("UNSTYLED_LIST", () => {
+    it("neutralizes bullets, indent, and margins", () => {
+      const probe = renderScoped(
+        <ul className={UNSTYLED_LIST}>
+          <li>item</li>
+        </ul>,
+      );
+      const style = computed(probe.querySelector("ul")!);
+
+      expect(style.listStyleType).toBe("none");
+      expect(style.paddingLeft).toBe("0px");
+      expect(margins(style)).toEqual(ZERO_MARGINS);
+    });
+
+    it("spacing utilities still win over the reset (tailwind-merge + layer order)", () => {
+      const probe = renderScoped(
+        <ul className={`${UNSTYLED_LIST} stg:p-2`}>
+          <li>item</li>
+        </ul>,
+      );
+
+      expect(computed(probe.querySelector("ul")!).paddingLeft).toBe("8px");
+    });
+
+    it("a real swept organism (TodoList) renders without UA list styling", () => {
+      const probe = renderScoped(
+        <TodoList
+          todos={{
+            t1: create(TodoItemSchema, {
+              id: "t1",
+              content: "Scaffold the component",
+              status: TodoStatus.TODO_IN_PROGRESS,
+            }),
+          }}
+        />,
+      );
+      const style = computed(probe.querySelector('ul[aria-label="Tasks"]')!);
+
+      expect(style.listStyleType).toBe("none");
+      expect(style.paddingLeft).toBe("0px");
+      expect(margins(style)).toEqual(ZERO_MARGINS);
+    });
+  });
+
+  describe("UNSTYLED_FIELDSET", () => {
+    it("neutralizes UA fieldset margins, padding, and min-inline-size", () => {
+      const probe = renderScoped(
+        <>
+          <fieldset data-testid="raw">
+            <legend>raw</legend>
+          </fieldset>
+          <fieldset data-testid="reset" className={UNSTYLED_FIELDSET}>
+            <legend>reset</legend>
+          </fieldset>
+        </>,
+      );
+
+      // Control half: UA fieldset padding really is present in this page.
+      expect(computed(probe.querySelector('[data-testid="raw"]')!).paddingLeft).not.toBe("0px");
+
+      const style = computed(probe.querySelector('[data-testid="reset"]')!);
+      expect(margins(style)).toEqual(ZERO_MARGINS);
+      expect(style.paddingLeft).toBe("0px");
+      expect(style.minWidth, "min-inline-size: min-content breaks flex shrinking").toBe("0px");
+    });
+  });
+
+  describe("markdown map (content elements declare their own margins)", () => {
+    function renderMarkdown(md: string): HTMLElement {
+      return renderScoped(<Markdown components={MARKDOWN_COMPONENTS}>{md}</Markdown>);
+    }
+
+    it("paragraphs carry no UA top margin, so mb-* spacing is the whole rhythm", () => {
+      const probe = renderMarkdown("first\n\nsecond");
+      const [, second] = Array.from(probe.querySelectorAll("p"));
+
+      expect(computed(second).marginTop).toBe("0px");
+    });
+
+    it("blockquotes lose the UA 1em/40px box but keep the authored border+padding treatment", () => {
+      const probe = renderMarkdown("> quoted");
+      const style = computed(probe.querySelector("blockquote")!);
+
+      expect(style.marginTop).toBe("0px");
+      expect(style.marginLeft, "UA margin-inline: 40px must be cleared").toBe("0px");
+      expect(style.marginRight).toBe("0px");
+      expect(style.paddingLeft, "the authored pl-4 treatment stays").toBe("16px");
+    });
+
+    it("content lists KEEP their bullets — the reset is for UI lists only", () => {
+      const probe = renderMarkdown("- one\n- two");
+      const style = computed(probe.querySelector("ul")!);
+
+      expect(style.listStyleType).toBe("disc");
+      expect(style.marginTop, "stacked UA margin-top must be cleared").toBe("0px");
+      expect(style.paddingLeft, "authored pl-5 replaces the UA 40px").toBe("20px");
+    });
+  });
+});

package/src/agent/steps/IdentityStep.tsx

@@ -2,6 +2,7 @@
 
 import { useCallback, useId } from "react";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_FIELDSET } from "../../internal/element-resets.js";
 import { generateSlug } from "../../internal/slug.js";
 import type { AgentWizardData } from "./types.js";
 
@@ -173,7 +174,7 @@ export function IdentityStep({
           />
         </div>
 
-        <fieldset className="stg:space-y-1.5">
+        <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-1.5")}>
           <legend className="stg:text-sm stg:font-medium stg:text-foreground">
             Visibility
           </legend>

package/src/agent-instance/AgentInstanceDetailPanel.tsx

@@ -2,6 +2,7 @@
 
 import { useCallback, useState } from "react";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_LIST } from "../internal/element-resets.js";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import type { AgentInstance } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
 import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
@@ -233,7 +234,7 @@ export function AgentInstanceDetailPanel({
               {(spec?.environmentRefs?.length ?? 0) === 0 ? (
                 <p className="stg:text-xs stg:text-muted-foreground">No environments bound.</p>
               ) : (
-                <ol className="stg:space-y-1">
+                <ol className={cn(UNSTYLED_LIST, "stg:space-y-1")}>
                   {spec!.environmentRefs.map((ref, idx) => (
                     <li key={`${ref.slug}-${idx}`} className="stg:flex stg:items-center stg:gap-2 stg:text-sm">
                       <span className="stg:text-xs stg:text-muted-foreground stg:w-4 stg:text-right">{idx + 1}.</span>

package/src/api-key/CreateApiKeyForm.tsx

@@ -2,6 +2,7 @@
 
 import { useCallback, useId, useState, type FormEvent } from "react";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_FIELDSET } from "../internal/element-resets.js";
 import { getUserMessage } from "@stigmer/sdk";
 import type { ApiKey } from "@stigmer/protos/ai/stigmer/iam/apikey/v1/api_pb";
 import { useCreateApiKey } from "./useCreateApiKey.js";
@@ -122,7 +123,7 @@ export function CreateApiKeyForm({
         </div>
 
         {/* Expiry */}
-        <fieldset className="stg:space-y-1.5">
+        <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-1.5")}>
           <legend className="stg:text-xs stg:font-medium stg:text-foreground">
             Expiration
           </legend>

package/src/attachment/AttachmentChipList.tsx

@@ -154,9 +154,20 @@ function AttachmentChip({
 
 /** Shared accessible name: filename, size, and upload status. */
 function chipAriaLabel(entry: AttachmentEntry): string {
+  const isPreparing = entry.phase === "preparing";
   const isUploading = entry.phase === "uploading";
   const isError = entry.phase === "error";
-  return `${entry.file.name}, ${formatFileSize(entry.file.size)}${isUploading ? ", uploading" : ""}${isError ? ", upload failed" : ""}`;
+  return `${entry.file.name}, ${formatFileSize(entry.file.size)}${isPreparing ? ", preparing" : ""}${isUploading ? ", uploading" : ""}${isError ? ", upload failed" : ""}`;
+}
+
+/**
+ * True while the entry has work in flight (`preparing` or `uploading`) —
+ * the chips render both identically (dimmed + spinner): to the user each
+ * means "your file is on its way", and the split is audible in the
+ * accessible label where it actually informs.
+ */
+function isChipBusy(entry: AttachmentEntry): boolean {
+  return entry.phase === "preparing" || entry.phase === "uploading";
 }
 
 // ---------------------------------------------------------------------------
@@ -212,7 +223,7 @@ function ImageAttachmentChip({
   }
 
   const isError = entry.phase === "error";
-  const isUploading = entry.phase === "uploading";
+  const isBusy = isChipBusy(entry);
 
   return (
     // The remove badge and retry pill are SIBLINGS of the preview button,
@@ -250,7 +261,7 @@ function ImageAttachmentChip({
               onError={() => setLoadFailed(true)}
               className={cn(
                 "stg:h-full stg:w-full stg:object-cover",
-                (isUploading || isError) && "stg:opacity-50",
+                (isBusy || isError) && "stg:opacity-50",
               )}
             />
           ) : (
@@ -261,7 +272,7 @@ function ImageAttachmentChip({
               aria-hidden="true"
             />
           )}
-          {isUploading && (
+          {isBusy && (
             <span className="stg:absolute stg:inset-0 stg:flex stg:items-center stg:justify-center">
               <ChipSpinner size={16} />
             </span>
@@ -322,7 +333,7 @@ function FileAttachmentChip({
   readonly disabled?: boolean;
 }) {
   const isError = entry.phase === "error";
-  const isUploading = entry.phase === "uploading";
+  const isBusy = isChipBusy(entry);
 
   return (
     <span
@@ -333,12 +344,12 @@ function FileAttachmentChip({
         isError
           ? "stg:border stg:border-destructive/30 stg:bg-destructive-subtle stg:text-destructive"
           : "stg:bg-muted-subtle stg:text-foreground",
-        isUploading && "stg:opacity-70",
+        isBusy && "stg:opacity-70",
       )}
     >
-      {isUploading && <ChipSpinner />}
+      {isBusy && <ChipSpinner />}
       {isError && <ErrorDot />}
-      {!isUploading && !isError && <FileIcon />}
+      {!isBusy && !isError && <FileIcon />}
 
       <span className="stg:truncate">{entry.file.name}</span>
 

package/src/attachment/__tests__/AttachmentChipList.test.tsx

@@ -101,6 +101,18 @@ describe("AttachmentChipList — image miniature", () => {
     expect(container.querySelector("svg.stg\\:animate-spin")).toBeTruthy();
   });
 
+  it("treats the preparing phase as busy: spinner over the miniature, 'preparing' in the accessible label (#369)", async () => {
+    const preparing = entry({ id: "prep", phase: "preparing", storageKey: null });
+
+    const { container } = renderChips([preparing]);
+
+    await waitFor(() => expect(chipImage(container)).toBeTruthy());
+    expect(container.querySelector("svg.stg\\:animate-spin")).toBeTruthy();
+    expect(
+      screen.getByRole("listitem", { name: /shot\.png.*preparing/ }),
+    ).toBeTruthy();
+  });
+
   it("renders image chips preview-only: no visible filename or size text", async () => {
     const { container } = renderChips([entry()]);
 

package/src/attachment/__tests__/useAttachments.test.ts

@@ -0,0 +1,293 @@
+/**
+ * useAttachments lifecycle tests, centered on the `preparing` phase
+ * (stigmer/stigmer#369): entries must exist from the instant a
+ * prepare-flagged file is added, transition through preparation to
+ * upload, and honor the deferred-validation and cancellation contracts
+ * documented on {@link AddFilesOptions.prepareImages}.
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+
+vi.mock("../../hooks", () => ({
+  useStigmer: vi.fn(),
+}));
+vi.mock("../prepare-image.js", () => ({
+  prepareImageForVision: vi.fn(),
+}));
+
+import { useStigmer } from "../../hooks";
+import { prepareImageForVision } from "../prepare-image.js";
+import { useAttachments } from "../useAttachments.js";
+import { MAX_ATTACHMENT_BYTES } from "../attachment-utils.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+function makeFile(name: string, sizeBytes: number, type = "image/png"): File {
+  return new File([new Uint8Array(sizeBytes)], name, { type });
+}
+
+/** Wires useStigmer to an uploadAttachment mock that resolves immediately. */
+function mockStigmer() {
+  const uploadAttachment = vi
+    .fn()
+    .mockResolvedValue({ storageKey: "attachments/test/key" });
+  vi.mocked(useStigmer).mockReturnValue({
+    agentExecution: { uploadAttachment },
+  } as unknown as ReturnType<typeof useStigmer>);
+  return { uploadAttachment };
+}
+
+const prepareMock = vi.mocked(prepareImageForVision);
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// The preparing phase
+// ---------------------------------------------------------------------------
+
+describe("useAttachments — prepareImages lifecycle", () => {
+  it("shows the entry immediately in the preparing phase, gating submit", () => {
+    mockStigmer();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() => useAttachments());
+
+    act(() => {
+      result.current.addFiles([makeFile("shot.png", 1024)], {
+        prepareImages: true,
+      });
+    });
+
+    expect(result.current.entries).toHaveLength(1);
+    expect(result.current.entries[0].phase).toBe("preparing");
+    expect(result.current.entries[0].file.name).toBe("shot.png");
+    expect(result.current.isPreparing).toBe(true);
+    // preparing gates exactly like uploading — the silent-drop guard.
+    expect(result.current.isUploading).toBe(true);
+    expect(result.current.allReady).toBe(false);
+  });
+
+  it("swaps to the prepared file (name, type) and proceeds to upload → ready", async () => {
+    const { uploadAttachment } = mockStigmer();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() => useAttachments());
+
+    act(() => {
+      result.current.addFiles([makeFile("shot.png", 4096)], {
+        prepareImages: true,
+      });
+    });
+
+    // Preparation re-encoded to JPEG: name and MIME follow.
+    act(() => {
+      gap.resolve(makeFile("shot.jpg", 2048, "image/jpeg"));
+    });
+
+    await waitFor(() => {
+      expect(result.current.entries[0].phase).toBe("ready");
+    });
+    expect(result.current.entries[0].file.name).toBe("shot.jpg");
+    expect(result.current.entries[0].contentType).toBe("image/jpeg");
+    expect(uploadAttachment).toHaveBeenCalledTimes(1);
+    expect(result.current.toAttachmentInputs()).toEqual([
+      {
+        filename: "shot.jpg",
+        storageKey: "attachments/test/key",
+        contentType: "image/jpeg",
+      },
+    ]);
+  });
+
+  it("accepts a raw file over the size limit when preparation brings it under (the #369 paste contract)", async () => {
+    const { uploadAttachment } = mockStigmer();
+    const onValidationError = vi.fn();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() =>
+      useAttachments({ onValidationError }),
+    );
+
+    // 10 MB + 1 raw screenshot — would be rejected by up-front validation.
+    act(() => {
+      result.current.addFiles(
+        [makeFile("huge-screenshot.png", MAX_ATTACHMENT_BYTES + 1)],
+        { prepareImages: true },
+      );
+    });
+    expect(result.current.entries[0].phase).toBe("preparing");
+
+    act(() => {
+      gap.resolve(makeFile("huge-screenshot.png", 512 * 1024));
+    });
+
+    await waitFor(() => {
+      expect(result.current.entries[0].phase).toBe("ready");
+    });
+    expect(onValidationError).not.toHaveBeenCalled();
+    expect(uploadAttachment).toHaveBeenCalledTimes(1);
+  });
+
+  it("removes the entry and reports via onValidationError when still oversized after preparation", async () => {
+    const { uploadAttachment } = mockStigmer();
+    const onValidationError = vi.fn();
+    const oversized = makeFile("giant.zip", MAX_ATTACHMENT_BYTES + 1, "application/zip");
+    // Non-image passthrough: preparation returns the original untouched.
+    prepareMock.mockResolvedValue(oversized);
+
+    const { result } = renderHook(() =>
+      useAttachments({ onValidationError }),
+    );
+
+    act(() => {
+      result.current.addFiles([oversized], { prepareImages: true });
+    });
+    expect(result.current.entries).toHaveLength(1);
+
+    await waitFor(() => {
+      expect(result.current.entries).toHaveLength(0);
+    });
+    expect(onValidationError).toHaveBeenCalledWith(
+      expect.stringContaining("giant.zip"),
+    );
+    expect(uploadAttachment).not.toHaveBeenCalled();
+  });
+
+  it("discards the preparation result when the entry is removed mid-preparation", async () => {
+    const { uploadAttachment } = mockStigmer();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() => useAttachments());
+
+    act(() => {
+      result.current.addFiles([makeFile("shot.png", 1024)], {
+        prepareImages: true,
+      });
+    });
+    const id = result.current.entries[0].id;
+
+    act(() => {
+      result.current.removeEntry(id);
+    });
+    expect(result.current.entries).toHaveLength(0);
+
+    // Late completion must not resurrect the entry or start an upload.
+    await act(async () => {
+      gap.resolve(makeFile("shot.jpg", 512, "image/jpeg"));
+      await gap.promise;
+    });
+    expect(result.current.entries).toHaveLength(0);
+    expect(uploadAttachment).not.toHaveBeenCalled();
+  });
+
+  it("discards the preparation result on clear()", async () => {
+    const { uploadAttachment } = mockStigmer();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() => useAttachments());
+
+    act(() => {
+      result.current.addFiles([makeFile("shot.png", 1024)], {
+        prepareImages: true,
+      });
+    });
+
+    act(() => {
+      result.current.clear();
+    });
+
+    await act(async () => {
+      gap.resolve(makeFile("shot.jpg", 512, "image/jpeg"));
+      await gap.promise;
+    });
+    expect(result.current.entries).toHaveLength(0);
+    expect(uploadAttachment).not.toHaveBeenCalled();
+  });
+
+  it("uniquifies the prepared name against other entries' settled names", async () => {
+    mockStigmer();
+    const gap = deferred<File>();
+    prepareMock.mockReturnValue(gap.promise);
+
+    const { result } = renderHook(() => useAttachments());
+
+    // A settled entry already owns "pasted-image.png".
+    act(() => {
+      result.current.addFiles([makeFile("pasted-image.png", 256)]);
+    });
+    // The prepared file lands on the same name.
+    act(() => {
+      result.current.addFiles([makeFile("other.png", 256)], {
+        prepareImages: true,
+      });
+    });
+    act(() => {
+      gap.resolve(makeFile("pasted-image.png", 128));
+    });
+
+    await waitFor(() => {
+      expect(result.current.entries[1].phase).toBe("ready");
+    });
+    expect(result.current.entries[1].file.name).toBe("pasted-image-2.png");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// The unflagged path — byte-identical to the pre-#369 behavior
+// ---------------------------------------------------------------------------
+
+describe("useAttachments — unflagged addFiles", () => {
+  it("never enters the preparing phase and never calls prepareImageForVision", async () => {
+    mockStigmer();
+
+    const { result } = renderHook(() => useAttachments());
+
+    act(() => {
+      result.current.addFiles([makeFile("picked.png", 1024)]);
+    });
+
+    expect(result.current.entries[0].phase).toBe("uploading");
+    expect(result.current.isPreparing).toBe(false);
+    expect(prepareMock).not.toHaveBeenCalled();
+
+    await waitFor(() => {
+      expect(result.current.entries[0].phase).toBe("ready");
+    });
+  });
+
+  it("still validates size up front and rejects without creating an entry", () => {
+    const { uploadAttachment } = mockStigmer();
+    const onValidationError = vi.fn();
+
+    const { result } = renderHook(() =>
+      useAttachments({ onValidationError }),
+    );
+
+    act(() => {
+      result.current.addFiles([
+        makeFile("too-big.png", MAX_ATTACHMENT_BYTES + 1),
+      ]);
+    });
+
+    expect(result.current.entries).toHaveLength(0);
+    expect(onValidationError).toHaveBeenCalledTimes(1);
+    expect(uploadAttachment).not.toHaveBeenCalled();
+  });
+});

package/src/attachment/index.ts

@@ -1,5 +1,6 @@
 export { useAttachments } from "./useAttachments.js";
 export type {
+  AddFilesOptions,
   AttachmentPhase,
   AttachmentEntry,
   UseAttachmentsOptions,