@foir/sdk 0.8.0 → 0.10.0

package/dist/server.js

@@ -351,6 +351,20 @@ var FoirRequestError = class extends Error {
   status;
   /** GraphQL errors, when the request failed with a no-data error envelope. */
   graphQLErrors;
+  /**
+   * The `data` the server did return, when a STRICT read refused a partial
+   * response. Present only on that path: without it, opting into strictness
+   * would trade a silent wrong answer for a thrown one that discards the answer,
+   * and a caller that wants to log what it nearly rendered could not.
+   */
+  partialData;
+  /**
+   * The selections the server stripped, when the refusal was a pruned document
+   * rather than a partial error. Same purpose as `partialData`: a caller that
+   * wants to log what it nearly rendered, or name the offending path in a
+   * developer-facing message, has it without re-parsing anything.
+   */
+  prunedSelections;
   cause;
   constructor(message, options) {
     super(message);
@@ -358,6 +372,8 @@ var FoirRequestError = class extends Error {
     this.cause = options?.cause;
     this.status = options?.status;
     this.graphQLErrors = options?.graphQLErrors;
+    this.partialData = options?.partialData;
+    this.prunedSelections = options?.prunedSelections;
   }
   /**
    * The code of the first error, if the response carried one.
@@ -423,6 +439,9 @@ function buildFoirHeaders(input) {
   if (input.bearerToken) {
     headers["Authorization"] = `Bearer ${input.bearerToken}`;
   }
+  if (input.orgId) {
+    headers["X-Org-Id"] = input.orgId;
+  }
   if (input.extra) {
     for (const [key, value] of Object.entries(input.extra)) {
       headers[key] = value;
@@ -438,6 +457,372 @@ function foirApiEndpoint(apiUrl, path) {
   return base + path;
 }
 
+// src/data/transport.ts
+async function resolveBearerToken(config) {
+  const source = config.bearerToken;
+  if (typeof source === "function") return await source() ?? void 0;
+  return source ?? void 0;
+}
+
+// src/data/ws-transport.ts
+var GQL = {
+  connectionInit: "connection_init",
+  connectionAck: "connection_ack",
+  ping: "ping",
+  pong: "pong",
+  subscribe: "subscribe",
+  next: "next",
+  error: "error",
+  complete: "complete"
+};
+var SUBPROTOCOL = "graphql-transport-ws";
+var OPEN_READY_STATE = 1;
+var DEFAULT_RECONNECT = {
+  maxAttempts: Infinity,
+  initialDelayMs: 500,
+  maxDelayMs: 15e3,
+  jitter: 0.25
+};
+function foirSocketEndpoint(apiUrl) {
+  const trimmed = apiUrl.replace(/\/+$/, "").replace(/\/graphql$/, "");
+  return `${trimmed.replace(/^http/, "ws")}/graphql/ws`;
+}
+var FoirSocketTransport = class {
+  config;
+  policy;
+  registrations = /* @__PURE__ */ new Map();
+  socket = null;
+  acknowledged = false;
+  connecting = false;
+  attempt = 0;
+  nextId = 0;
+  disposed = false;
+  keepAlive = null;
+  retryTimer = null;
+  constructor(config) {
+    this.config = config;
+    this.policy = { ...DEFAULT_RECONNECT, ...config.reconnect ?? {} };
+  }
+  /**
+   * Start a subscription.
+   *
+   * Returns synchronously so a caller can hold the handle immediately, while
+   * the connect and the handshake proceed in the background. A subscription
+   * registered before the socket is acknowledged is sent the moment it is —
+   * which is the same path a reconnect takes, so the ordinary case and the
+   * recovery case exercise one piece of code.
+   */
+  subscribe(request, handlers) {
+    if (this.disposed) {
+      throw new FoirRequestError("[foir] this client has been disposed; create a new one");
+    }
+    this.nextId += 1;
+    const id = String(this.nextId);
+    this.registrations.set(id, {
+      id,
+      request,
+      handlers,
+      sent: false,
+      established: false
+    });
+    this.ensureConnected();
+    this.flush();
+    return {
+      unsubscribe: () => this.cancel(id)
+    };
+  }
+  /** Close the socket and drop every subscription. */
+  dispose() {
+    this.disposed = true;
+    this.registrations.clear();
+    this.teardownSocket(true);
+  }
+  /** Live subscription count. Exposed for tests and diagnostics. */
+  get size() {
+    return this.registrations.size;
+  }
+  // -------------------------------------------------------------------------
+  // Connection
+  // -------------------------------------------------------------------------
+  ensureConnected() {
+    if (this.disposed || this.socket || this.connecting) return;
+    this.connecting = true;
+    const factory = this.config.webSocketImpl ?? defaultWebSocketFactory();
+    const url = this.config.wsUrl ?? foirSocketEndpoint(this.config.apiUrl);
+    let socket;
+    try {
+      socket = factory(url, SUBPROTOCOL);
+    } catch (cause) {
+      this.connecting = false;
+      this.scheduleReconnect(
+        new FoirRequestError(`[foir] could not open a WebSocket to ${url}: ${String(cause)}`)
+      );
+      return;
+    }
+    this.socket = socket;
+    socket.onopen = () => {
+      void this.sendConnectionInit(socket);
+    };
+    socket.onmessage = (event) => this.receive(event.data);
+    socket.onerror = () => {
+    };
+    socket.onclose = () => this.handleClose();
+  }
+  async sendConnectionInit(socket) {
+    this.connecting = false;
+    try {
+      const headers = buildFoirHeaders({
+        apiKey: this.config.apiKey,
+        draftChannel: this.config.channel === "draft",
+        bearerToken: await resolveBearerToken(this.config),
+        orgId: this.config.orgId,
+        extra: this.config.headers
+      });
+      const { "Content-Type": _contentType, ...params } = headers;
+      const extra = await this.config.connectionParams?.() ?? {};
+      this.send(socket, {
+        type: GQL.connectionInit,
+        payload: { ...params, ...extra }
+      });
+    } catch (cause) {
+      this.failAll(
+        new FoirRequestError(`[foir] could not resolve the subscription credential: ${String(cause)}`)
+      );
+      this.teardownSocket(true);
+    }
+  }
+  handleClose() {
+    const wasAcknowledged = this.acknowledged;
+    this.teardownSocket(false);
+    if (this.disposed || this.registrations.size === 0) return;
+    for (const registration of this.registrations.values()) {
+      registration.sent = false;
+    }
+    this.scheduleReconnect(
+      new FoirRequestError(
+        wasAcknowledged ? "[foir] the subscription socket closed and could not be re-established" : "[foir] the subscription socket closed before the credential was accepted"
+      )
+    );
+  }
+  scheduleReconnect(error) {
+    if (this.disposed || this.registrations.size === 0) return;
+    if (this.attempt >= this.policy.maxAttempts) {
+      this.failAll(error);
+      return;
+    }
+    const exponent = Math.min(this.attempt, 20);
+    const base = Math.min(
+      this.policy.initialDelayMs * 2 ** exponent,
+      this.policy.maxDelayMs
+    );
+    const delay = base + base * this.policy.jitter * Math.random();
+    this.attempt += 1;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      this.ensureConnected();
+    }, delay);
+    const timer = this.retryTimer;
+    if (typeof timer?.unref === "function") timer.unref();
+  }
+  teardownSocket(closeIt) {
+    if (this.keepAlive !== null) {
+      clearInterval(this.keepAlive);
+      this.keepAlive = null;
+    }
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    const socket = this.socket;
+    this.socket = null;
+    this.acknowledged = false;
+    this.connecting = false;
+    if (!socket) return;
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onerror = null;
+    socket.onclose = null;
+    if (closeIt) {
+      try {
+        socket.close(1e3, "client disposed");
+      } catch {
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Frames
+  // -------------------------------------------------------------------------
+  receive(data) {
+    if (typeof data !== "string") return;
+    let message;
+    try {
+      message = JSON.parse(data);
+    } catch {
+      return;
+    }
+    switch (message.type) {
+      case GQL.connectionAck:
+        this.acknowledged = true;
+        this.attempt = 0;
+        this.startKeepAlive();
+        this.flush();
+        return;
+      case GQL.ping:
+        if (this.socket) this.send(this.socket, { type: GQL.pong });
+        return;
+      case GQL.pong:
+        return;
+      case GQL.next: {
+        const registration = message.id ? this.registrations.get(message.id) : void 0;
+        if (!registration) return;
+        const payload = message.payload;
+        const root = payload?.data;
+        if (!root) return;
+        const keys = Object.keys(root);
+        if (keys.length !== 1) return;
+        registration.handlers.onData(root[keys[0]]);
+        return;
+      }
+      case GQL.error: {
+        const error = new FoirRequestError(`[foir] subscription refused: ${describe(message.payload)}`, {
+          graphQLErrors: graphQLErrorItems(message.payload)
+        });
+        if (!message.id) {
+          this.failAll(error);
+          this.teardownSocket(true);
+          return;
+        }
+        const registration = this.registrations.get(message.id);
+        this.registrations.delete(message.id);
+        registration?.handlers.onError?.(error);
+        this.closeIfIdle();
+        return;
+      }
+      case GQL.complete: {
+        if (!message.id) return;
+        const registration = this.registrations.get(message.id);
+        this.registrations.delete(message.id);
+        registration?.handlers.onComplete?.();
+        this.closeIfIdle();
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /**
+   * Send every registration the current socket has not yet been told about.
+   *
+   * This IS the resubscribe path. A reconnect clears `sent` on every
+   * registration and lands here, so a subscription re-established after a drop
+   * takes the same code as one opened for the first time — there is no second
+   * implementation that can be correct in one case and wrong in the other.
+   */
+  flush() {
+    const socket = this.socket;
+    if (!socket || !this.acknowledged || socket.readyState !== OPEN_READY_STATE) return;
+    for (const registration of this.registrations.values()) {
+      if (registration.sent) continue;
+      this.send(socket, {
+        id: registration.id,
+        type: GQL.subscribe,
+        payload: registration.request
+      });
+      registration.sent = true;
+      if (registration.established) {
+        registration.handlers.onReconnect?.();
+      } else {
+        registration.established = true;
+      }
+    }
+  }
+  cancel(id) {
+    const registration = this.registrations.get(id);
+    if (!registration) return;
+    this.registrations.delete(id);
+    if (this.socket && registration.sent && this.socket.readyState === OPEN_READY_STATE) {
+      this.send(this.socket, { id, type: GQL.complete });
+    }
+    this.closeIfIdle();
+  }
+  /**
+   * Close the socket once nothing is using it.
+   *
+   * A socket held open with no subscriptions is a connection the server has to
+   * keep, a keepalive timer that keeps a serverless invocation alive, and
+   * nothing in return.
+   */
+  closeIfIdle() {
+    if (this.registrations.size === 0) this.teardownSocket(true);
+  }
+  failAll(error) {
+    const registrations = [...this.registrations.values()];
+    this.registrations.clear();
+    for (const registration of registrations) {
+      registration.handlers.onError?.(error);
+    }
+  }
+  /**
+   * Client-side keepalive.
+   *
+   * The server pings on its own timer and this client answers, which is enough
+   * for the server to know the client is alive. This is the other direction:
+   * an idle subscription can sit for hours with no events, and a proxy that
+   * times out idle sockets will drop it. A periodic `ping` keeps it warm, and
+   * the pong that comes back proves the path is still there.
+   */
+  startKeepAlive() {
+    if (this.keepAlive !== null) clearInterval(this.keepAlive);
+    this.keepAlive = setInterval(() => {
+      const socket = this.socket;
+      if (!socket || socket.readyState !== OPEN_READY_STATE) return;
+      this.send(socket, { type: GQL.ping });
+    }, 2e4);
+    const timer = this.keepAlive;
+    if (typeof timer?.unref === "function") timer.unref();
+  }
+  send(socket, message) {
+    try {
+      socket.send(JSON.stringify(message));
+    } catch {
+    }
+  }
+};
+function defaultWebSocketFactory() {
+  const Impl = globalThis.WebSocket;
+  if (typeof Impl !== "function") {
+    throw new FoirRequestError(
+      "[foir] no WebSocket implementation is available in this runtime. Pass one as `webSocketImpl` \u2014 e.g. `webSocketImpl: (url, protocols) => new WebSocket(url, protocols)` from the `ws` package on Node < 22."
+    );
+  }
+  return (url, protocols) => new Impl(url, protocols);
+}
+function graphQLErrorItems(payload) {
+  const list = Array.isArray(payload) ? payload : payload == null ? [] : [payload];
+  const items = [];
+  for (const entry of list) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { message, path, extensions } = entry;
+    if (extensions === void 0 && path === void 0) continue;
+    items.push({
+      message: typeof message === "string" ? message : describe(entry),
+      ...Array.isArray(path) ? { path } : {},
+      ...typeof extensions === "object" && extensions !== null ? { extensions } : {}
+    });
+  }
+  return items.length > 0 ? items : void 0;
+}
+function describe(payload) {
+  if (payload == null) return "no reason given";
+  if (typeof payload === "string") return payload;
+  if (Array.isArray(payload)) return payload.map(describe).join("; ");
+  if (typeof payload === "object") {
+    const message = payload.message;
+    if (typeof message === "string") return message;
+  }
+  return JSON.stringify(payload);
+}
+
 // src/server/events-client.ts
 var FOIR_EVENTS_PATH = "/v1/events";
 var FOIR_EVENTS_SCOPE = "events:list.project";
@@ -486,7 +871,7 @@ function assertOperatorKey(apiKey) {
   }
   if (!key.startsWith("sk_")) {
     throw new FoirRequestError(
-      `[foir] createEventsClient: apiKey must be an sk_ secret key (sk_ or sk_t_), got a key starting "${key.slice(0, 4)}". The event log is reachable by an sk_ api key or an admin session only.`
+      `[foir] createEventsClient: apiKey must be an sk_ secret key, got a key starting "${key.slice(0, 4)}". The event log is reachable by an sk_ api key or an admin session only.`
     );
   }
   return key;
@@ -629,7 +1014,74 @@ function createEventsClient(config) {
       after = page.nextCursor;
     }
   }
-  return { list, stream };
+  let socket = null;
+  let live = 0;
+  function subscribe(params) {
+    const { after, events, onData, onError, onComplete, onReconnect } = params;
+    socket ??= new FoirSocketTransport({
+      apiUrl: config.apiUrl,
+      apiKey,
+      ...config.headers ? { headers: config.headers } : {},
+      ...config.wsUrl ? { wsUrl: config.wsUrl } : {},
+      ...config.webSocketImpl ? { webSocketImpl: config.webSocketImpl } : {},
+      ...config.reconnect ? { reconnect: config.reconnect } : {}
+    });
+    const variables = {
+      ...after !== void 0 ? { after: readSeq(after, "after") } : {},
+      ...events && events.length > 0 ? { events } : {}
+    };
+    live += 1;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      live -= 1;
+      if (live === 0 && socket) {
+        socket.dispose();
+        socket = null;
+      }
+    };
+    const handle = socket.subscribe(
+      { query: EVENTS_SUBSCRIPTION, variables },
+      {
+        onData: (event) => {
+          if (typeof event?.seq === "number" && event.seq > (variables.after ?? 0)) {
+            variables.after = event.seq;
+          }
+          onData(event);
+        },
+        onError: (error) => {
+          release();
+          onError?.(asEventsSocketError(error, variables.after));
+        },
+        onComplete: () => {
+          release();
+          onComplete?.();
+        },
+        ...onReconnect ? { onReconnect } : {}
+      }
+    );
+    return {
+      unsubscribe: () => {
+        handle.unsubscribe();
+        release();
+      }
+    };
+  }
+  return { list, stream, subscribe };
+}
+var EVENTS_SUBSCRIPTION = "subscription FoirEvents($after: EventSeq, $events: [String!]) {\n  events(after: $after, events: $events) {\n    id\n    seq\n    event\n    payload\n    actor { kind ref }\n    causationChain\n    createdAt\n  }\n}";
+function asEventsSocketError(error, requestedCursor) {
+  for (const item of error.graphQLErrors ?? []) {
+    if (item.extensions?.code !== "cursor_expired") continue;
+    const resumeFrom = item.extensions.resumeFrom;
+    return new FoirEventCursorExpiredError(`[foir] events: cursor expired: ${item.message}`, {
+      status: 410,
+      ...typeof resumeFrom === "number" ? { resumeFrom } : {},
+      ...requestedCursor !== void 0 ? { requestedCursor } : {}
+    });
+  }
+  return error;
 }
 export {
   FOIR_EVENTS_PATH,

package/dist/transport/foir-http.d.ts

@@ -69,6 +69,42 @@ export interface FoirGraphQLErrorItem {
     path?: Array<string | number>;
     extensions?: FoirErrorExtensions;
 }
+/**
+ * One selection the server stripped from the document before executing it.
+ *
+ * The data plane PRUNES rather than refuses: a selection that does not match
+ * the project's current schema is removed and the rest of the query runs, so an
+ * editor-driven model change cannot fail a deployed client's query mid-flight.
+ * The report arrives in `extensions.pruned` and deliberately NOT in `errors`,
+ * because clients treat any `errors` entry as a failed response.
+ *
+ * Which is why this type exists here. Pruning is the ONLY signal for the
+ * commonest way to get a quietly incomplete object — asking for a field the
+ * type does not have — and it produces no error for `strict` to catch.
+ */
+export interface FoirPrunedSelection {
+    /** Dotted path to the stripped selection, e.g. `pageBySlug.logo.id`. */
+    path: string;
+    /** Why it was stripped. See `MALFORMED_PRUNE_REASONS`. */
+    reason: string;
+    /** The parent type the selection was made on, when the server named one. */
+    type?: string;
+}
+/**
+ * The prune reasons that mean THE DOCUMENT IS WRONG, as opposed to the schema
+ * having moved underneath a document that was right when it shipped.
+ *
+ * A field the type does not have, a subselection on a scalar, or a composite
+ * asked for without one: each is a query that could never have been served as
+ * written. They are the shape that silently returns a plausible object with a
+ * key missing, which is how an empty file id became a `setNull` and would have
+ * deleted a logo on the next save.
+ *
+ * The rest — dead type conditions, dead fragment spreads, unreferenced
+ * fragments, unused variables — are what the pruner exists to absorb, and they
+ * stay a warning.
+ */
+export declare const MALFORMED_PRUNE_REASONS: ReadonlySet<string>;
 /** What the `X-RateLimit-*` headers said on the response that carried them. */
 export interface FoirRateLimitSnapshot {
     /** Requests allowed per window for this credential. */
@@ -83,11 +119,27 @@ export declare class FoirRequestError extends Error {
     readonly status?: number;
     /** GraphQL errors, when the request failed with a no-data error envelope. */
     readonly graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
+    /**
+     * The `data` the server did return, when a STRICT read refused a partial
+     * response. Present only on that path: without it, opting into strictness
+     * would trade a silent wrong answer for a thrown one that discards the answer,
+     * and a caller that wants to log what it nearly rendered could not.
+     */
+    readonly partialData?: unknown;
+    /**
+     * The selections the server stripped, when the refusal was a pruned document
+     * rather than a partial error. Same purpose as `partialData`: a caller that
+     * wants to log what it nearly rendered, or name the offending path in a
+     * developer-facing message, has it without re-parsing anything.
+     */
+    readonly prunedSelections?: ReadonlyArray<FoirPrunedSelection>;
     readonly cause?: unknown;
     constructor(message: string, options?: {
         cause?: unknown;
         status?: number;
         graphQLErrors?: ReadonlyArray<FoirGraphQLErrorItem>;
+        partialData?: unknown;
+        prunedSelections?: ReadonlyArray<FoirPrunedSelection>;
     });
     /**
      * The code of the first error, if the response carried one.
@@ -158,6 +210,26 @@ export interface FoirRequestOptions {
      * (e.g. `myProfile`). Used by `@foir/sdk/auth`'s post-login profile fetch.
      */
     bearerToken?: string;
+    /**
+     * The organization this request acts in, sent as `X-Org-Id`. For a
+     * project-scoped key: the server resolves it to an active organization of
+     * the key's own project (else `NOT_FOUND`) and binds the request to it — a
+     * key already confined to an organization may only name that one (else
+     * `PERMISSION_DENIED`). See `FoirClientConfig.orgId` for the full contract.
+     *
+     * PER CALL, which is the narrower and riskier of the two spellings. The
+     * client-level option is the one to reach for: set it once where the
+     * organization is resolved and every request from that client carries it,
+     * so there is no call left to forget. This one is for the odd request that
+     * has to act somewhere else — and a request that omits it is not refused,
+     * it reads the project-shared tier, which is a smaller answer rather than an
+     * error.
+     *
+     * ⚠️ It names a SUBTREE. Organizations nest and reach runs downward, so a
+     * reseller's id covers every client beneath it. Send the narrowest id that
+     * covers what the request is about.
+     */
+    orgId?: string;
     /**
      * Called with the `X-RateLimit-*` headers of every response, successful or
      * not, and with `undefined` when a response carried none.
@@ -192,6 +264,12 @@ export interface FoirHeaderInput {
      */
     draftChannel?: boolean;
     bearerToken?: string;
+    /**
+     * The organization the request acts in (`X-Org-Id`). Set from
+     * `FoirClientConfig.orgId` / `FoirRequestOptions.orgId`; a caller who
+     * spells the header in `extra` still wins, because `extra` is applied last.
+     */
+    orgId?: string;
     /** Caller-supplied extras, applied last so a caller can override. */
     extra?: Readonly<Record<string, string>>;
 }
@@ -218,17 +296,42 @@ export declare function buildFoirHeaders(input: FoirHeaderInput): Record<string,
  * accepted. `data/transport.ts` re-exports it under its published name.
  */
 export declare function foirApiEndpoint(apiUrl: string, path: `/${string}`): string;
+/**
+ * Foir DISCARDED a credential you sent, and served the request without it.
+ *
+ * A customer JWT is optional: if it fails to verify, the read is served as an
+ * ordinary anonymous one rather than refused, because plenty of reads
+ * legitimately have nobody signed in. That is the right behaviour and it has a
+ * sharp edge — a lapsed token and a genuinely anonymous request produce the
+ * same 200, so the failure surfaces as WRONG CONTENT rather than as an error.
+ * This block is how you find out.
+ *
+ * Present only when a token was actually sent and rejected. Its presence is
+ * always a signal.
+ */
+export interface FoirAuthDowngrade {
+    /** Always `"rejected"`. */
+    customerToken: string;
+    /**
+     * `expired` — re-exchange and retry. `invalid` — not a customer token for
+     * this environment. `wrong_project` — the token and the api-key name
+     * different projects.
+     */
+    reason: 'expired' | 'invalid' | 'wrong_project';
+    /** The authority the request actually ran under. */
+    servedAs: string;
+}
 export interface FoirResponseEnvelope<T> {
     data?: T;
     errors?: Array<FoirGraphQLErrorItem>;
+    extensions?: {
+        auth?: FoirAuthDowngrade;
+        pruned?: {
+            selections?: Array<FoirPrunedSelection>;
+        };
+        [key: string]: unknown;
+    };
 }
-/**
- * Unwrap a Foir `{ data, errors }` envelope.
- *
- * GraphQL can return partial data alongside errors; when data is present the
- * errors are logged and the data returned (callers handle nulls), and we only
- * throw when there is no data at all. Both Foir data-plane routes — `/graphql`
- * and `/cdn/graphql` — hand their document to the same executor, so the two
- * return this envelope and get the same treatment.
- */
-export declare function readFoirEnvelope<T>(json: FoirResponseEnvelope<T>): T;
+export declare function readFoirEnvelope<T>(json: FoirResponseEnvelope<T>, options?: {
+    strict?: boolean;
+}): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foir/sdk",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Official Foir SDK — editor iframe client + server-side platform helpers",
   "type": "module",
   "publishConfig": {
@@ -25,6 +25,14 @@
       "types": "./dist/data/index.d.ts",
       "import": "./dist/data.js"
     },
+    "./live": {
+      "types": "./dist/live/index.d.ts",
+      "import": "./dist/live.js"
+    },
+    "./live/react": {
+      "types": "./dist/live/react/index.d.ts",
+      "import": "./dist/live-react.js"
+    },
     "./media": {
       "types": "./dist/media/index.d.ts",
       "import": "./dist/media.js"
@@ -157,7 +165,7 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsup && tsc -p tsconfig.build.json && node scripts/assert-export-types.mjs && node scripts/assert-public-exports.mjs",
+    "build": "node scripts/clean-dist.mjs && tsup && tsc -p tsconfig.build.json && node scripts/assert-export-types.mjs && node scripts/assert-public-exports.mjs",
     "snapshot:exports": "node scripts/assert-public-exports.mjs --update",
     "dev": "node scripts/dev-watch.mjs",
     "check-types": "tsc --noEmit",