@superxd-studio/adptr 0.5.0

package/source/reusable/langgraph-review/index.ts

@@ -0,0 +1,73 @@
+/** Server-side optional integration; never import into a browser renderer. */
+import {
+  Annotation,
+  StateGraph,
+  MemorySaver,
+  START,
+  END,
+  interrupt,
+  Command,
+  isInterrupted,
+} from "@langchain/langgraph";
+import {
+  parseReviewDecision,
+  parseReviewProposal,
+  parseReviewReceipt,
+  type ReviewProposal,
+  type ReviewDecision,
+  type ReviewReceipt,
+} from "../review/types.js";
+export function createLangGraphReviewDriver(
+  commit: (decision: ReviewDecision) => Promise<ReviewReceipt>,
+) {
+  const State = Annotation.Root({
+    proposal: Annotation<ReviewProposal>(),
+    decision: Annotation<ReviewDecision | null>(),
+    receipt: Annotation<ReviewReceipt | null>(),
+  });
+  const graph = new StateGraph(State)
+    .addNode("review", (state) => ({
+      decision: parseReviewDecision(interrupt({ proposal: state.proposal })),
+    }))
+    // The host's gate rechecks permissions/revision and atomically records the receipt.
+    .addNode("apply", async (state) => {
+      if (!state.decision) throw new Error("Decision required");
+      return { receipt: await commit(state.decision) };
+    })
+    .addEdge(START, "review")
+    .addEdge("review", "apply")
+    .addEdge("apply", END)
+    .compile({ checkpointer: new MemorySaver() });
+  const config = (threadId: string) => ({ configurable: { thread_id: threadId } });
+  return {
+    async start(proposal: ReviewProposal, threadId: string) {
+      const result = await graph.invoke(
+        { proposal: parseReviewProposal(proposal), decision: null, receipt: null },
+        config(threadId),
+      );
+      if (!isInterrupted(result) || !result.__interrupt__?.length)
+        throw new Error("Approval did not pause");
+      return result.__interrupt__[0];
+    },
+    async resume(value: ReviewDecision, threadId: string) {
+      const decision = parseReviewDecision(value);
+      const snapshot = await graph.getState(config(threadId));
+      const proposal = parseReviewProposal(snapshot.values.proposal);
+      if (proposal.id !== decision.proposalId || proposal.revision !== decision.revision)
+        throw new Error("Decision does not match the paused proposal");
+      const stored = snapshot.values.decision
+        ? parseReviewDecision(snapshot.values.decision)
+        : null;
+      if (stored && JSON.stringify(stored) !== JSON.stringify(decision))
+        throw new Error("A different decision already owns this checkpoint");
+      if (snapshot.values.receipt) return parseReviewReceipt(snapshot.values.receipt);
+      // Retry a failed commit with the original approved decision; do not reinterpret it as a new resume.
+      const result = await graph.invoke(
+        stored ? null : new Command({ resume: decision }),
+        config(threadId),
+      );
+      if (!result.receipt) throw new Error("Missing decision receipt");
+      return parseReviewReceipt(result.receipt);
+    },
+  };
+}

package/source/reusable/review/controller.ts

@@ -0,0 +1,263 @@
+import {
+  ReviewFault,
+  parseReviewRecord,
+  parseReviewReceipt,
+  parseReviewRecovery,
+  type ReviewAdapter,
+  type ReviewDecision,
+  type ReviewRecord,
+  type ReviewReceipt,
+  type ReviewSnapshot,
+} from "./types.js";
+function freezeSnapshot(value: ReviewSnapshot): ReviewSnapshot {
+  if (value.record) {
+    value.record.proposal.changes.forEach(Object.freeze);
+    Object.freeze(value.record.proposal.changes);
+    Object.freeze(value.record.proposal);
+    Object.freeze(value.record.appliedIds);
+    Object.freeze(value.record.remainingIds);
+    Object.freeze(value.record);
+  }
+  if (value.decision) {
+    Object.freeze(value.decision.changeIds);
+    Object.freeze(value.decision);
+  }
+  Object.freeze(value.selectedIds);
+  return Object.freeze(value);
+}
+const empty: ReviewSnapshot = freezeSnapshot({
+  status: "idle",
+  record: null,
+  selectedIds: [],
+  decision: null,
+  issue: null,
+});
+type Action =
+  | { type: "loading" }
+  | { type: "loaded"; record: ReviewRecord }
+  | { type: "selected"; ids: readonly string[] }
+  | { type: "prepared"; decision: ReviewDecision }
+  | { type: "back" }
+  | { type: "sending" }
+  | { type: "checking" }
+  | { type: "settled"; receipt: ReviewReceipt }
+  | { type: "unapplied" }
+  | { type: "failed"; status: "load-error" | "uncertain" | "conflict" | "blocked" };
+function recordStatus(record: ReviewRecord): ReviewSnapshot["status"] {
+  if (record.outcome === "complete" || record.outcome === "denied") return record.outcome;
+  if (!record.proposal.canDecide) return "blocked";
+  return record.outcome === "partial" ? "partial" : "ready";
+}
+/** One owner for the task, selection and immutable confirmation across all presentations. */
+export function reviewReducer(state: ReviewSnapshot, action: Action): ReviewSnapshot {
+  switch (action.type) {
+    case "loading":
+      return { ...state, status: "loading", decision: null, issue: null };
+    case "loaded":
+      return { ...empty, status: recordStatus(action.record), record: action.record };
+    case "selected":
+      return { ...state, selectedIds: action.ids, issue: null };
+    case "prepared":
+      return { ...state, status: "confirming", decision: action.decision, issue: null };
+    case "back":
+      return {
+        ...state,
+        status: state.record?.outcome === "partial" ? "partial" : "ready",
+        decision: null,
+        issue: null,
+      };
+    case "sending":
+      return { ...state, status: "submitting", issue: null };
+    case "checking":
+      return { ...state, status: "checking", issue: null };
+    case "settled":
+      return {
+        ...empty,
+        record: action.receipt.record,
+        status: recordStatus(action.receipt.record),
+        selectedIds:
+          action.receipt.record.outcome === "partial" ? action.receipt.record.remainingIds : [],
+      };
+    case "unapplied":
+      return { ...state, status: "confirming", issue: "not-applied" };
+    case "failed":
+      return {
+        ...state,
+        status: action.status,
+        decision:
+          action.status === "conflict" || action.status === "blocked" ? null : state.decision,
+      };
+  }
+}
+export class ReviewController {
+  private state: ReviewSnapshot = empty;
+  private listeners = new Set<() => void>();
+  private operation: AbortController | null = null;
+  private generation = 0;
+  constructor(
+    private adapter: ReviewAdapter,
+    private newId: () => string = () => crypto.randomUUID(),
+  ) {}
+  getSnapshot = (): ReviewSnapshot => this.state;
+  subscribe = (callback: () => void): (() => void) => {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  };
+  private dispatch(action: Action) {
+    this.state = freezeSnapshot(reviewReducer(this.state, action));
+    this.listeners.forEach((listener) => listener());
+  }
+  private async run(
+    task: (signal: AbortSignal) => Promise<void>,
+    failure: "load-error" | "uncertain",
+  ) {
+    const generation = ++this.generation;
+    this.operation?.abort();
+    const operation = new AbortController();
+    this.operation = operation;
+    try {
+      await task(operation.signal);
+    } catch (error) {
+      if (generation === this.generation && !operation.signal.aborted)
+        this.dispatch({
+          type: "failed",
+          status: error instanceof ReviewFault ? error.kind : failure,
+        });
+    } finally {
+      if (generation === this.generation) this.operation = null;
+    }
+  }
+  load = (): boolean => {
+    if (
+      this.operation ||
+      this.state.decision ||
+      !["idle", "load-error", "conflict", "blocked"].includes(this.state.status)
+    )
+      return false;
+    this.dispatch({ type: "loading" });
+    void this.run(async (signal) => {
+      const record = parseReviewRecord(await this.adapter.load(signal));
+      if (!signal.aborted) this.dispatch({ type: "loaded", record });
+    }, "load-error");
+    return true;
+  };
+  select = (id: string, selected: boolean): boolean => {
+    if (
+      !["ready", "partial"].includes(this.state.status) ||
+      !this.state.record?.proposal.canDecide ||
+      !this.state.record.remainingIds.includes(id)
+    )
+      return false;
+    const ids = new Set(this.state.selectedIds);
+    if (selected) ids.add(id);
+    else ids.delete(id);
+    this.dispatch({ type: "selected", ids: [...ids] });
+    return true;
+  };
+  prepare = (choice: ReviewDecision["choice"]): boolean => {
+    const { record, status, selectedIds } = this.state;
+    if (
+      !record?.proposal.canDecide ||
+      !["ready", "partial"].includes(status) ||
+      (choice === "approve" && !selectedIds.length)
+    )
+      return false;
+    this.dispatch({
+      type: "prepared",
+      decision: {
+        requestId: this.newId(),
+        proposalId: record.proposal.id,
+        revision: record.proposal.revision,
+        choice,
+        changeIds: choice === "approve" ? [...selectedIds].sort() : [],
+      },
+    });
+    return true;
+  };
+  back = (): boolean => {
+    // Receipt absence is a snapshot, not proof that an earlier request cannot still arrive.
+    if (this.state.status !== "confirming" || this.state.issue === "not-applied") return false;
+    this.dispatch({ type: "back" });
+    return true;
+  };
+  private verifyReceipt(receipt: ReviewReceipt, decision: ReviewDecision) {
+    if (
+      receipt.requestId !== decision.requestId ||
+      receipt.choice !== decision.choice ||
+      receipt.record.proposal.id !== decision.proposalId ||
+      receipt.appliedIds.some((id) => !decision.changeIds.includes(id)) ||
+      receipt.record.proposal.revision <= decision.revision
+    )
+      throw new Error("Receipt does not match decision");
+    const previous = this.state.record?.appliedIds ?? [];
+    const added = receipt.record.appliedIds.filter((id) => !previous.includes(id));
+    if (
+      previous.some((id) => !receipt.record.appliedIds.includes(id)) ||
+      added.length !== receipt.appliedIds.length ||
+      added.some((id) => !receipt.appliedIds.includes(id)) ||
+      receipt.record.remainingIds.some((id) => !decision.changeIds.includes(id)) ||
+      (decision.choice === "approve" &&
+        decision.changeIds.some(
+          (id) => !receipt.appliedIds.includes(id) && !receipt.record.remainingIds.includes(id),
+        ))
+    )
+      throw new Error("Receipt has an unexpected scope");
+  }
+  submit = (): boolean => {
+    const decision = this.state.decision;
+    if (this.state.status !== "confirming" || !decision || this.operation) return false;
+    this.dispatch({ type: "sending" });
+    void this.run(async (signal) => {
+      const receipt = parseReviewReceipt(await this.adapter.decide(decision, signal));
+      this.verifyReceipt(receipt, decision);
+      if (!signal.aborted) this.dispatch({ type: "settled", receipt });
+    }, "uncertain");
+    return true;
+  };
+  recover = (): boolean => {
+    const decision = this.state.decision;
+    if (
+      !(
+        this.state.status === "uncertain" ||
+        (this.state.status === "confirming" && this.state.issue === "not-applied")
+      ) ||
+      !decision ||
+      this.operation
+    )
+      return false;
+    this.dispatch({ type: "checking" });
+    void this.run(async (signal) => {
+      const recovery = parseReviewRecovery(await this.adapter.recover(decision.requestId, signal));
+      if (signal.aborted) return;
+      if (recovery.receipt) {
+        this.verifyReceipt(recovery.receipt, decision);
+        this.dispatch({ type: "settled", receipt: recovery.receipt });
+      } else if (
+        recovery.record.proposal.id !== decision.proposalId ||
+        recovery.record.proposal.revision !== decision.revision ||
+        recovery.record.outcome === "complete" ||
+        recovery.record.outcome === "denied"
+      )
+        this.dispatch({ type: "failed", status: "conflict" });
+      else if (!recovery.record.proposal.canDecide)
+        this.dispatch({ type: "failed", status: "blocked" });
+      else this.dispatch({ type: "unapplied" });
+    }, "uncertain");
+    return true;
+  };
+  /** End host-owned observation explicitly, never on a presentation unmount. Cannot undo server work. */
+  disconnect = () => {
+    ++this.generation;
+    this.operation?.abort();
+    this.operation = null;
+    const status = ["submitting", "checking"].includes(this.state.status)
+      ? "uncertain"
+      : this.state.status === "loading"
+        ? "idle"
+        : this.state.status;
+    if (status !== this.state.status) {
+      this.state = freezeSnapshot({ ...this.state, status });
+      this.listeners.forEach((listener) => listener());
+    }
+  };
+}

package/source/reusable/review/index.ts

@@ -0,0 +1,47 @@
+export * from "./types.js";
+export { ReviewController, reviewReducer } from "./controller.js";
+import {
+  ReviewFault,
+  parseReviewRecord,
+  parseReviewReceipt,
+  parseReviewRecovery,
+  type ReviewAdapter,
+} from "./types.js";
+export interface HttpReviewOptions {
+  /** URL for an existing customer-owned review. Never place credentials in this URL. */
+  endpoint: string;
+  headers?: () => HeadersInit | Promise<HeadersInit>;
+  credentials?: RequestCredentials;
+  fetch?: typeof globalThis.fetch;
+  timeoutMs?: number;
+}
+export function createHttpReviewAdapter(options: HttpReviewOptions): ReviewAdapter {
+  const endpoint = options.endpoint.replace(/\/$/, "");
+  async function request(path: string, signal: AbortSignal, body?: unknown): Promise<unknown> {
+    const timeout = AbortSignal.timeout(options.timeoutMs ?? 15_000);
+    const response = await (options.fetch ?? globalThis.fetch)(endpoint + path, {
+      signal: AbortSignal.any([signal, timeout]),
+      method: body === undefined ? "GET" : "POST",
+      credentials: options.credentials ?? "same-origin",
+      headers: {
+        ...Object.fromEntries(new Headers(await options.headers?.()).entries()),
+        ...(body === undefined ? {} : { "content-type": "application/json" }),
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    if (response.status === 409) throw new ReviewFault("conflict");
+    if (response.status === 401 || response.status === 403) throw new ReviewFault("blocked");
+    if (!response.ok || !response.headers.get("content-type")?.startsWith("application/json"))
+      throw new Error("Review unavailable");
+    const content = await response.text();
+    if (content.length > 220_000) throw new Error("Review response too large");
+    return JSON.parse(content);
+  }
+  return {
+    load: async (signal) => parseReviewRecord(await request("", signal)),
+    decide: async (decision, signal) =>
+      parseReviewReceipt(await request("/decisions", signal, decision)),
+    recover: async (requestId, signal) =>
+      parseReviewRecovery(await request(`/receipts/${encodeURIComponent(requestId)}`, signal)),
+  };
+}

package/source/reusable/review/types.ts

@@ -0,0 +1,189 @@
+/** Portable review contract. The host owns authorization, revisions and side effects. */
+export interface ReviewChange {
+  readonly id: string;
+  readonly title: string;
+  readonly before: string;
+  readonly after: string;
+  readonly reason: string;
+}
+export interface ReviewProposal {
+  readonly id: string;
+  readonly revision: number;
+  readonly title: string;
+  readonly destination: string;
+  readonly changes: readonly ReviewChange[];
+  readonly canDecide: boolean;
+}
+export interface ReviewRecord {
+  readonly proposal: ReviewProposal;
+  readonly appliedIds: readonly string[];
+  readonly remainingIds: readonly string[];
+  readonly outcome: "pending" | "partial" | "complete" | "denied";
+}
+export interface ReviewDecision {
+  readonly requestId: string;
+  readonly proposalId: string;
+  readonly revision: number;
+  readonly choice: "approve" | "deny";
+  readonly changeIds: readonly string[];
+}
+export interface ReviewReceipt {
+  readonly requestId: string;
+  readonly choice: "approve" | "deny";
+  readonly appliedIds: readonly string[];
+  readonly record: ReviewRecord;
+}
+export interface ReviewRecovery {
+  readonly record: ReviewRecord;
+  readonly receipt: ReviewReceipt | null;
+}
+export interface ReviewAdapter {
+  load(signal: AbortSignal): Promise<ReviewRecord>;
+  decide(decision: ReviewDecision, signal: AbortSignal): Promise<ReviewReceipt>;
+  recover(requestId: string, signal: AbortSignal): Promise<ReviewRecovery>;
+}
+export type ReviewStatus =
+  | "idle"
+  | "loading"
+  | "ready"
+  | "confirming"
+  | "submitting"
+  | "checking"
+  | "load-error"
+  | "uncertain"
+  | "conflict"
+  | "blocked"
+  | "partial"
+  | "complete"
+  | "denied";
+export interface ReviewSnapshot {
+  readonly status: ReviewStatus;
+  readonly record: ReviewRecord | null;
+  readonly selectedIds: readonly string[];
+  readonly decision: ReviewDecision | null;
+  readonly issue: "not-applied" | null;
+}
+export class ReviewFault extends Error {
+  constructor(readonly kind: "conflict" | "blocked") {
+    super(kind);
+  }
+}
+
+function object(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid review data");
+  return value as Record<string, unknown>;
+}
+function text(value: unknown, max = 6000): string {
+  if (typeof value !== "string" || !value.trim() || value.length > max)
+    throw new Error("Invalid review text");
+  return value;
+}
+function id(value: unknown): string {
+  const result = text(value, 100);
+  if (!/^[\w-]+$/.test(result)) throw new Error("Invalid review id");
+  return result;
+}
+function ids(value: unknown): string[] {
+  if (!Array.isArray(value) || value.length > 32) throw new Error("Invalid review selection");
+  const result = value.map(id);
+  if (new Set(result).size !== result.length) throw new Error("Duplicate review ids");
+  return result;
+}
+function revision(value: unknown): number {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)
+    throw new Error("Invalid review revision");
+  return value;
+}
+export function parseReviewProposal(value: unknown): ReviewProposal {
+  const p = object(value);
+  if (!Array.isArray(p.changes) || p.changes.length > 32 || typeof p.canDecide !== "boolean")
+    throw new Error("Invalid proposal");
+  const changes = p.changes.map((value): ReviewChange => {
+    const c = object(value);
+    return {
+      id: id(c.id),
+      title: text(c.title, 200),
+      before: text(c.before),
+      after: text(c.after),
+      reason: text(c.reason, 1000),
+    };
+  });
+  if (new Set(changes.map((c) => c.id)).size !== changes.length)
+    throw new Error("Duplicate changes");
+  return {
+    id: id(p.id),
+    revision: revision(p.revision),
+    title: text(p.title, 200),
+    destination: text(p.destination, 200),
+    changes,
+    canDecide: p.canDecide,
+  };
+}
+export function parseReviewDecision(value: unknown): ReviewDecision {
+  const d = object(value);
+  if (
+    Object.keys(d).sort().join() !==
+    ["changeIds", "choice", "proposalId", "requestId", "revision"].sort().join()
+  )
+    throw new Error("Invalid decision fields");
+  if (d.choice !== "approve" && d.choice !== "deny") throw new Error("Invalid decision");
+  const changeIds = ids(d.changeIds).sort();
+  if ((d.choice === "approve" && !changeIds.length) || (d.choice === "deny" && changeIds.length))
+    throw new Error("Invalid decision selection");
+  return {
+    requestId: id(d.requestId),
+    proposalId: id(d.proposalId),
+    revision: revision(d.revision),
+    choice: d.choice,
+    changeIds,
+  };
+}
+export function parseReviewRecord(value: unknown): ReviewRecord {
+  const r = object(value);
+  const proposal = parseReviewProposal(r.proposal);
+  if (!["pending", "partial", "complete", "denied"].includes(String(r.outcome)))
+    throw new Error("Invalid review outcome");
+  const appliedIds = ids(r.appliedIds),
+    remainingIds = ids(r.remainingIds);
+  const available = new Set(proposal.changes.map((c) => c.id));
+  if (
+    [...appliedIds, ...remainingIds].some((i) => !available.has(i)) ||
+    remainingIds.some((i) => appliedIds.includes(i))
+  )
+    throw new Error("Invalid review scope");
+  if ((r.outcome === "complete" || r.outcome === "denied") && remainingIds.length)
+    throw new Error("Closed review still has pending changes");
+  if (r.outcome === "denied" && appliedIds.length)
+    throw new Error("Denied review has applied changes");
+  if (r.outcome === "pending" && appliedIds.length)
+    throw new Error("Pending review has applied changes");
+  if (r.outcome === "partial" && (!appliedIds.length || !remainingIds.length))
+    throw new Error("Invalid partial result");
+  return { proposal, appliedIds, remainingIds, outcome: r.outcome as ReviewRecord["outcome"] };
+}
+export function parseReviewReceipt(value: unknown): ReviewReceipt {
+  const r = object(value);
+  const record = parseReviewRecord(r.record);
+  if (r.choice !== "approve" && r.choice !== "deny") throw new Error("Invalid receipt");
+  const appliedIds = ids(r.appliedIds);
+  if (
+    appliedIds.some((i) => !record.appliedIds.includes(i)) ||
+    (r.choice === "deny" &&
+      (appliedIds.length ||
+        !(
+          record.outcome === "denied" ||
+          (record.outcome === "complete" && record.appliedIds.length > 0)
+        ))) ||
+    (r.choice === "approve" && !["complete", "partial"].includes(record.outcome))
+  )
+    throw new Error("Invalid receipt outcome");
+  return { requestId: id(r.requestId), choice: r.choice, appliedIds, record };
+}
+export function parseReviewRecovery(value: unknown): ReviewRecovery {
+  const r = object(value);
+  return {
+    record: parseReviewRecord(r.record),
+    receipt: r.receipt === null ? null : parseReviewReceipt(r.receipt),
+  };
+}

package/source/reusable/ui/index.ts

@@ -0,0 +1,25 @@
+/** Standalone React web foundations, styled by the host's SuperXD tokens. */
+export * from "../../components/ui/selection.js";
+export * from "../../components/ui/navigation.js";
+export * from "../../components/ui/display.js";
+export { uiCopy } from "../../components/ui/copy.js";
+export { Button, ButtonLink, TextLink, buttonStyles } from "../../components/button.js";
+export type {
+  ButtonProps,
+  ButtonLinkProps,
+  ButtonSize,
+  ButtonVariant,
+} from "../../components/button.js";
+export type { TextFieldProps } from "../../components/text-field.js";
+export { Switch } from "../../components/switch.js";
+export { SearchPicker } from "../../components/search-picker.js";
+export { SegmentedControl } from "../../components/segmented-control.js";
+export { Callout } from "../../components/callout.js";
+export { Avatar } from "../../components/avatar.js";
+export { Skeleton } from "../../components/skeleton.js";
+export { Spinner } from "../../components/spinner.js";
+export { ScrollArea } from "../../components/scroll-area.js";
+export { ResponsiveOverlay } from "../../components/responsive-overlay.js";
+export { DateTimeField } from "../../components/date-time-field.js";
+
+export { ScenarioPicker } from "../../components/scenario-picker/index.js";

package/source/reusable/uploads/index.ts

@@ -0,0 +1,48 @@
+import { parseChatFile, type UploadAdapter } from "../core/index.js";
+
+export interface HttpUploadOptions {
+  endpoint: string;
+  headers?: () => HeadersInit | Promise<HeadersInit>;
+  credentials?: RequestCredentials;
+  fetch?: typeof globalThis.fetch;
+  /** Consumer-provided deletion endpoint, only for draft references it owns. */
+  releaseEndpoint?: (id: string) => string;
+}
+/** Raw binary upload, with Unicode-safe filename metadata. Auth is consumer-owned. */
+export function createHttpUploadAdapter(options: HttpUploadOptions): UploadAdapter<Blob> {
+  const request = options.fetch ?? globalThis.fetch;
+  const releaseEndpoint = options.releaseEndpoint;
+  return {
+    async upload(source, signal) {
+      const response = await request(options.endpoint, {
+        method: "POST",
+        signal,
+        credentials: options.credentials ?? "same-origin",
+        headers: {
+          ...Object.fromEntries(new Headers(await options.headers?.()).entries()),
+          "content-type": source.mediaType,
+          "x-file-name": encodeURIComponent(source.name),
+          "x-upload-id": source.id ?? globalThis.crypto.randomUUID(),
+        },
+        body: source.data,
+      });
+      if (!response.ok || !response.headers.get("content-type")?.startsWith("application/json"))
+        throw new Error("Upload unavailable");
+      const body = await response.text();
+      if (body.length > 10_000) throw new Error("Upload reference too large");
+      return parseChatFile(JSON.parse(body));
+    },
+    ...(releaseEndpoint
+      ? {
+          async release(file) {
+            const response = await request(releaseEndpoint(file.id), {
+              method: "DELETE",
+              credentials: options.credentials ?? "same-origin",
+              headers: await options.headers?.(),
+            });
+            if (!response.ok) throw new Error("Release unavailable");
+          },
+        }
+      : {}),
+  };
+}

package/source/reusable/web/attachments/copy.ts

@@ -0,0 +1,23 @@
+export const attachmentCopy = {
+  label: "Attachments",
+  add: "Add files",
+  empty: "No files attached",
+  uploading: "Uploading",
+  ready: "Ready",
+  error: "Upload failed",
+  cancelled: "Upload stopped",
+  rejected: "Can’t attach this file",
+  remove: "Remove",
+  retry: "Retry upload",
+  cancel: "Stop upload",
+  type: "Choose a supported file type.",
+  size: "This file is empty or exceeds the size limit.",
+  count: "The file limit is reached. Remove a file before adding more.",
+  failed: "The file couldn’t upload. Retry or remove it; your message is still here.",
+  unavailable: "File uploads aren’t available in this connection.",
+  selected: "files selected",
+  image: "Image",
+  document: "Document",
+  file: "File",
+} as const;
+export type AttachmentCopy = { [Key in keyof typeof attachmentCopy]: string };