@alia.onl/sdk 21.3.1 → 21.3.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @alia.onl/sdk
 
+## 21.3.2
+
+### Fixed
+
+- **On web the SDK draws no async chunk boundary of its own**, so an app that lazy-loads its Alia
+  sheet keeps the chat in that chunk instead of its first paint. Expo's Metro serializer hoists
+  every module two async chunks share into `__common.js`, loaded at first paint; the SDK's own
+  `import()` calls (the call's `VoiceSession`, the root entry's `AliaAskProvider` sheet, the
+  `expo-audio`, document-picker and image readers) made such chunks inside the app's, and moved the
+  whole chat and the Bloom it draws with into `__common.js`. On web those now import statically
+  (`.web` forks); native keeps its lazy loads. The root entry's `AliaAskProvider` imports its sheet
+  statically on every platform (the root already holds the chat); `@alia.onl/sdk/ask` keeps its
+  one lazy boundary. CrowdSource's reviewer: first-paint JS 1.57 MiB gzip → 1.23 MiB, largest
+  file 5.05 MiB → 3.79 MiB, its lazy Alia chunk 29 KiB → 404 KiB gzip. `check:entries` holds it.
+- **The source compiles under `erasableSyntaxOnly`.** The SDK ships TypeScript source, and a
+  consumer that compiles it with `erasableSyntaxOnly` (OxyHQ/website, `tsc -b`) failed with TS1294
+  on two constructor parameter properties in `runtime/conversations.ts`
+  (`ConversationNotFoundError.conversationId`, the offline store). They are now declared fields
+  assigned in the constructor, and the SDK's own `tsconfig.json` sets `erasableSyntaxOnly`, so
+  `typecheck` (CI and `prepublishOnly`) refuses parameter properties, enums and namespaces.
+
 ## 21.3.1
 
 - Ask Alia follows the active account language resolved by Oxy Services instead of defaulting to

package/README.md

@@ -174,7 +174,14 @@ dismiss(); // e.g. after a host tool changed the page under the sheet
 
 Mount it from `@alia.onl/sdk/ask`: that entry is the provider and its hook alone, and the sheet
 loads with the first `ask` (fetched in the background once the person is signed in), so the chat
-stays out of the app's entry bundle. The root entry exports the same two, with the whole chat.
+stays out of the app's entry bundle. The root entry exports the same two, with the whole chat
+(its provider imports the sheet statically).
+
+**On web, load the chat through ONE async boundary.** Expo's Metro serializer hoists every module
+two async chunks share into `__common.js`, which loads at first paint. The SDK draws no async chunk
+boundary of its own on web (the call, sounds and pickers import statically there), except the one
+of `@alia.onl/sdk/ask`. So either mount the provider from `@alia.onl/sdk/ask`, or lazy-import your
+own module that imports the root entry — not both, or the chat they share lands in `__common.js`.
 
 The sheet offers the person's latest conversations with its lead under the greeting
 (`recentConversations={false}` turns it off). The code that configures the sheet sits above it, so
@@ -433,7 +440,7 @@ ships no model identifier of its own.
 ```sh
 bun run typecheck       # tsc --noEmit
 bun run test            # vitest
-bun run check:entries   # the root entry reaches the call only through its lazy import; no retired modules
+bun run check:entries   # entry isolation; on web, no async chunk boundary but the ask entry's; no retired modules
 ```
 
 ## Licence

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alia.onl/sdk",
-  "version": "21.3.1",
+  "version": "21.3.2",
   "description": "Alia AI chat SDK — the conversation runtime, chat UI, voice calls and dictation for Oxy apps",
   "main": "src/index.ts",
   "react-native": "src/index.ts",

package/src/ask.ts

@@ -3,5 +3,9 @@
 // An app mounts the provider at its root from here rather than from the root entry, which
 // would bring the whole chat along with it.
 
-export { AliaAskProvider, useAskAgent } from './components/AliaAskProvider';
-export type { AliaAsk, AliaAskAgents, AliaAskProviderProps } from './components/AliaAskProvider';
+export { AliaAskProvider, useAskAgent } from './components/AliaAskProviderLazy';
+export type {
+  AliaAsk,
+  AliaAskAgents,
+  AliaAskProviderProps,
+} from './components/AliaAskProviderLazy';

package/src/components/AliaAskCore.tsx

@@ -0,0 +1,183 @@
+/**
+ * "Ask Alia", "Ask Sindi": one sheet an app mounts once, opened on any agent from anywhere in it.
+ *
+ * The app names the agents it offers (`agents`, by a key of its own) and configures the sheet
+ * once — its host tools, renderers, words, voice, context, upsell and share. A button calls
+ * `useAskAgent().ask(key, turn)`. Signed out, the sheet is not mounted (it could not call Alia):
+ * `ask` opens Oxy's sign-in instead, and the person asks again once signed in.
+ *
+ * This module is the provider without its sheet; each entry builds one with `createAskProvider`:
+ *   - `@alia.onl/sdk/ask` (`AliaAskProviderLazy`) loads the sheet with the first `ask`, through
+ *     the one `import()` that keeps the chat out of the app's entry bundle;
+ *   - the root entry (`AliaAskProvider`) already holds the whole chat, so its sheet is a static
+ *     import. A lazy one there would put an async chunk boundary INSIDE the SDK, and on web Metro
+ *     hoists every module two async chunks share into `__common.js`, loaded at first paint: an app
+ *     that lazy-loads the root entry would get the chat in its first paint instead of its own chunk.
+ * Both read and write the one context below, so `useAskAgent` works under either.
+ */
+
+import { useAuth, useOxy } from '@oxy.so/services/ui/client';
+import {
+  type ComponentType,
+  createContext,
+  forwardRef,
+  type ReactNode,
+  type RefAttributes,
+  useCallback,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import type { AliaTurn } from '../hooks/useChatComposer';
+import type { AliaChatSheetProps, AliaChatSheetRef } from './AliaChatSheet';
+import type { AliaAskOpening, AliaAskSheetProps } from './AliaAskSheet';
+
+/** The agents an app offers, by its own key. An entry without `id` is Alia. */
+export type AliaAskAgents = Readonly<Record<string, { id?: string }>>;
+
+export interface AliaAskProviderProps
+  extends Pick<
+    AliaChatSheetProps,
+    | 'app'
+    | 'hostTools'
+    | 'toolRenderers'
+    | 'labels'
+    | 'voice'
+    | 'clientContext'
+    | 'onFeatureLocked'
+    | 'onShare'
+    | 'model'
+    | 'apiUrl'
+    | 'characterRuntimeUrl'
+    | 'headerMenu'
+    | 'recentConversations'
+  > {
+  /** The agents `ask` opens, by key. Omitted, the sheet only ever opens on Alia. */
+  agents?: AliaAskAgents;
+  /** The lines offered over Alia's empty composer; an agent offers its own starters. */
+  welcomeSuggestions?: AliaChatSheetProps['welcomeSuggestions'];
+  children: ReactNode;
+}
+
+export interface AliaAsk {
+  /**
+   * Open the sheet on the agent `agentKey` (omitted, Alia), with `turn` already sent when given
+   * ("ask Sindi about this listing"). Signed out, opens Oxy's sign-in instead.
+   */
+  ask: (agentKey?: string, turn?: AliaTurn) => void;
+  /** Open the sheet on the agent `agentKey` (omitted, Alia), on its stored conversation `conversationId`. */
+  resume: (agentKey: string | undefined, conversationId: string) => void;
+  /**
+   * Close the sheet — a host tool that changed the page under it shows the person the result, once
+   * the turn has been written.
+   */
+  dismiss: () => void;
+}
+
+const AskContext = createContext<AliaAsk | null>(null);
+
+/** The app's way to open its one Alia sheet. Must be used under `AliaAskProvider`. */
+export function useAskAgent(): AliaAsk {
+  const ask = useContext(AskContext);
+  if (ask === null) throw new Error('useAskAgent must be used within an AliaAskProvider');
+  return ask;
+}
+
+/** The opening that waits for the sheet of agent `key` to be the one mounted. */
+interface Opening extends AliaAskOpening {
+  key: string | undefined;
+}
+
+/** The sheet a provider mounts: `AliaAskSheet`, imported statically or behind `lazy` + `Suspense`. */
+export type AskSheetComponent = ComponentType<AliaAskSheetProps & RefAttributes<AliaChatSheetRef>>;
+
+/**
+ * Builds the provider around `Sheet`. `preload`, when given, fetches the sheet's module in the
+ * background once signed in, so the first `ask` does not wait on the network.
+ */
+export function createAskProvider(Sheet: AskSheetComponent, preload?: () => Promise<unknown>) {
+  /**
+   * Mounts the app's one sheet. Its ref is the same `AliaAsk` as `useAskAgent()`, for the code
+   * that configures the sheet and so sits above it — a host-tool executor that closes it.
+   */
+  return forwardRef<AliaAsk, AliaAskProviderProps>(function AliaAskProvider(
+    { agents, welcomeSuggestions, children, labels, ...sheet },
+    ref,
+  ) {
+    const { canUsePrivateApi, signIn } = useAuth();
+    const { currentLanguage } = useOxy();
+    const localizedLabels = useMemo(
+      () => ({ ...labels, locale: labels?.locale ?? currentLanguage }),
+      [labels, currentLanguage],
+    );
+    const sheetRef = useRef<AliaChatSheetRef>(null);
+    const [opening, setOpening] = useState<Opening | null>(null);
+    const [current, setCurrent] = useState<string | undefined>(undefined);
+    /** Nothing is mounted before the first `ask`. */
+    const [asked, setAsked] = useState(false);
+    const agentsRef = useRef(agents);
+    agentsRef.current = agents;
+
+    const open = useCallback(
+      (agentKey: string | undefined, turn?: AliaTurn, conversationId?: string) => {
+        if (agentKey !== undefined && agentsRef.current?.[agentKey] === undefined) {
+          throw new Error(`AliaAskProvider has no agent "${agentKey}"`);
+        }
+        if (!canUsePrivateApi) {
+          void signIn().catch(() => undefined);
+          return;
+        }
+        setAsked(true);
+        setCurrent(agentKey);
+        setOpening((previous) => ({
+          key: agentKey,
+          turn,
+          ...(conversationId === undefined ? {} : { conversationId }),
+          serial: (previous?.serial ?? 0) + 1,
+        }));
+      },
+      [canUsePrivateApi, signIn],
+    );
+    const ask = useCallback((agentKey?: string, turn?: AliaTurn) => open(agentKey, turn), [open]);
+    const resume = useCallback(
+      (agentKey: string | undefined, conversationId: string) =>
+        open(agentKey, undefined, conversationId),
+      [open],
+    );
+    const dismiss = useCallback(() => sheetRef.current?.dismiss(), []);
+
+    const opened = useCallback(() => setOpening(null), []);
+
+    // Signed in, the sheet's module comes down in the background, ahead of the first `ask`.
+    useEffect(() => {
+      if (canUsePrivateApi && preload !== undefined) void preload().catch(() => undefined);
+    }, [canUsePrivateApi]);
+
+    const agentId = current === undefined ? undefined : agents?.[current]?.id;
+    const agent = useMemo(() => (agentId === undefined ? undefined : { id: agentId }), [agentId]);
+    const value = useMemo<AliaAsk>(() => ({ ask, resume, dismiss }), [ask, resume, dismiss]);
+    useImperativeHandle(ref, () => value, [value]);
+
+    return (
+      <AskContext.Provider value={value}>
+        {children}
+        {canUsePrivateApi && asked ? (
+          <Sheet
+            key={agentId ?? 'alia'}
+            ref={sheetRef}
+            {...sheet}
+            labels={localizedLabels}
+            agent={agent}
+            welcomeSuggestions={agent === undefined ? welcomeSuggestions : undefined}
+            // A different agent is a new sheet: the opening waits for that one to mount.
+            opening={opening !== null && opening.key === current ? opening : null}
+            onOpened={opened}
+          />
+        ) : null}
+      </AskContext.Provider>
+    );
+  });
+}

package/src/components/AliaAskProvider.tsx

@@ -1,175 +1,18 @@
 /**
- * "Ask Alia", "Ask Sindi": one sheet an app mounts once, opened on any agent from anywhere in it.
+ * The ask provider of the root entry (`@alia.onl/sdk`): its sheet is a static import.
  *
- * The app names the agents it offers (`agents`, by a key of its own) and configures the sheet
- * once — its host tools, renderers, words, voice, context, upsell and share. A button calls
- * `useAskAgent().ask(key, turn)`. Signed out, the sheet is not mounted (it could not call Alia):
- * `ask` opens Oxy's sign-in instead, and the person asks again once signed in.
- *
- * The sheet itself (`AliaAskSheet`) is loaded lazily and mounted on the first `ask`, so an app
- * that mounts this provider at its root — imported from `@alia.onl/sdk/ask` — keeps the chat out
- * of its entry bundle. Signed in, its module is fetched in the background so the first `ask`
- * does not wait on the network.
- */
-
-import { useAuth, useOxy } from '@oxy.so/services/ui/client';
-import {
-  createContext,
-  forwardRef,
-  lazy,
-  type ReactNode,
-  Suspense,
-  useCallback,
-  useContext,
-  useEffect,
-  useImperativeHandle,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
-import type { AliaTurn } from '../hooks/useChatComposer';
-import type { AliaChatSheetProps, AliaChatSheetRef } from './AliaChatSheet';
-import type { AliaAskOpening } from './AliaAskSheet';
-
-const loadSheet = () => import('./AliaAskSheet');
-const LazyAskSheet = lazy(() => loadSheet().then((module) => ({ default: module.AliaAskSheet })));
-
-/** The agents an app offers, by its own key. An entry without `id` is Alia. */
-export type AliaAskAgents = Readonly<Record<string, { id?: string }>>;
-
-export interface AliaAskProviderProps
-  extends Pick<
-    AliaChatSheetProps,
-    | 'app'
-    | 'hostTools'
-    | 'toolRenderers'
-    | 'labels'
-    | 'voice'
-    | 'clientContext'
-    | 'onFeatureLocked'
-    | 'onShare'
-    | 'model'
-    | 'apiUrl'
-    | 'characterRuntimeUrl'
-    | 'headerMenu'
-    | 'recentConversations'
-  > {
-  /** The agents `ask` opens, by key. Omitted, the sheet only ever opens on Alia. */
-  agents?: AliaAskAgents;
-  /** The lines offered over Alia's empty composer; an agent offers its own starters. */
-  welcomeSuggestions?: AliaChatSheetProps['welcomeSuggestions'];
-  children: ReactNode;
-}
-
-export interface AliaAsk {
-  /**
-   * Open the sheet on the agent `agentKey` (omitted, Alia), with `turn` already sent when given
-   * ("ask Sindi about this listing"). Signed out, opens Oxy's sign-in instead.
-   */
-  ask: (agentKey?: string, turn?: AliaTurn) => void;
-  /** Open the sheet on the agent `agentKey` (omitted, Alia), on its stored conversation `conversationId`. */
-  resume: (agentKey: string | undefined, conversationId: string) => void;
-  /**
-   * Close the sheet — a host tool that changed the page under it shows the person the result, once
-   * the turn has been written.
-   */
-  dismiss: () => void;
-}
-
-const AskContext = createContext<AliaAsk | null>(null);
-
-/** The app's way to open its one Alia sheet. Must be used under `AliaAskProvider`. */
-export function useAskAgent(): AliaAsk {
-  const ask = useContext(AskContext);
-  if (ask === null) throw new Error('useAskAgent must be used within an AliaAskProvider');
-  return ask;
-}
-
-/** The opening that waits for the sheet of agent `key` to be the one mounted. */
-interface Opening extends AliaAskOpening {
-  key: string | undefined;
-}
-
-/**
- * Mounts the app's one sheet. Its ref is the same `AliaAsk` as `useAskAgent()`, for the code that
- * configures the sheet and so sits above it — a host-tool executor that closes it.
+ * The root entry already holds the whole chat, so loading `AliaAskSheet` lazily here would save
+ * nothing and cost a lot on web: it is an async chunk boundary inside the SDK, and Metro hoists
+ * every module two async chunks share into `__common.js`, which loads at first paint. An app that
+ * lazy-loads its Alia sheet would then get the chat (and the Bloom it draws with) in its first
+ * paint. An app that wants the chat out of its entry bundle mounts the provider from
+ * `@alia.onl/sdk/ask` (`AliaAskProviderLazy`) instead. See `AliaAskCore` for the provider itself.
  */
-export const AliaAskProvider = forwardRef<AliaAsk, AliaAskProviderProps>(function AliaAskProvider(
-  { agents, welcomeSuggestions, children, labels, ...sheet },
-  ref,
-) {
-  const { canUsePrivateApi, signIn } = useAuth();
-  const { currentLanguage } = useOxy();
-  const localizedLabels = useMemo(
-    () => ({ ...labels, locale: labels?.locale ?? currentLanguage }),
-    [labels, currentLanguage],
-  );
-  const sheetRef = useRef<AliaChatSheetRef>(null);
-  const [opening, setOpening] = useState<Opening | null>(null);
-  const [current, setCurrent] = useState<string | undefined>(undefined);
-  /** Nothing is mounted before the first `ask`. */
-  const [asked, setAsked] = useState(false);
-  const agentsRef = useRef(agents);
-  agentsRef.current = agents;
-
-  const open = useCallback(
-    (agentKey: string | undefined, turn?: AliaTurn, conversationId?: string) => {
-      if (agentKey !== undefined && agentsRef.current?.[agentKey] === undefined) {
-        throw new Error(`AliaAskProvider has no agent "${agentKey}"`);
-      }
-      if (!canUsePrivateApi) {
-        void signIn().catch(() => undefined);
-        return;
-      }
-      setAsked(true);
-      setCurrent(agentKey);
-      setOpening((previous) => ({
-        key: agentKey,
-        turn,
-        ...(conversationId === undefined ? {} : { conversationId }),
-        serial: (previous?.serial ?? 0) + 1,
-      }));
-    },
-    [canUsePrivateApi, signIn],
-  );
-  const ask = useCallback((agentKey?: string, turn?: AliaTurn) => open(agentKey, turn), [open]);
-  const resume = useCallback(
-    (agentKey: string | undefined, conversationId: string) =>
-      open(agentKey, undefined, conversationId),
-    [open],
-  );
-  const dismiss = useCallback(() => sheetRef.current?.dismiss(), []);
-
-  const opened = useCallback(() => setOpening(null), []);
 
-  // Signed in, the sheet's module comes down in the background, ahead of the first `ask`.
-  useEffect(() => {
-    if (canUsePrivateApi) void loadSheet().catch(() => undefined);
-  }, [canUsePrivateApi]);
+import { createAskProvider } from './AliaAskCore';
+import { AliaAskSheet } from './AliaAskSheet';
 
-  const agentId = current === undefined ? undefined : agents?.[current]?.id;
-  const agent = useMemo(() => (agentId === undefined ? undefined : { id: agentId }), [agentId]);
-  const value = useMemo<AliaAsk>(() => ({ ask, resume, dismiss }), [ask, resume, dismiss]);
-  useImperativeHandle(ref, () => value, [value]);
+export type { AliaAsk, AliaAskAgents, AliaAskProviderProps } from './AliaAskCore';
+export { useAskAgent } from './AliaAskCore';
 
-  return (
-    <AskContext.Provider value={value}>
-      {children}
-      {canUsePrivateApi && asked ? (
-        <Suspense fallback={null}>
-          <LazyAskSheet
-            key={agentId ?? 'alia'}
-            ref={sheetRef}
-            {...sheet}
-            labels={localizedLabels}
-            agent={agent}
-            welcomeSuggestions={agent === undefined ? welcomeSuggestions : undefined}
-            // A different agent is a new sheet: the opening waits for that one to mount.
-            opening={opening !== null && opening.key === current ? opening : null}
-            onOpened={opened}
-          />
-        </Suspense>
-      ) : null}
-    </AskContext.Provider>
-  );
-});
+export const AliaAskProvider = createAskProvider(AliaAskSheet);

package/src/components/AliaAskProviderLazy.tsx

@@ -0,0 +1,27 @@
+/**
+ * The ask provider of `@alia.onl/sdk/ask`: its sheet is loaded lazily and mounted on the first
+ * `ask`, so an app that mounts this provider at its root keeps the chat out of its entry bundle.
+ * Signed in, the sheet's module is fetched in the background so the first `ask` does not wait on
+ * the network.
+ *
+ * This `import()` is the ONE async boundary the SDK draws, and only for this entry: everything
+ * behind it (`AliaAskSheet` and the chat) imports statically on web, so Metro emits one chunk for
+ * the sheet and hoists nothing of it into `__common.js` (`scripts/check-entry-isolation.mjs`).
+ */
+
+import { lazy, Suspense } from 'react';
+import { type AskSheetComponent, createAskProvider } from './AliaAskCore';
+
+const loadSheet = () => import('./AliaAskSheet');
+const LazyAskSheet = lazy(() => loadSheet().then((module) => ({ default: module.AliaAskSheet })));
+
+const SuspendedAskSheet: AskSheetComponent = (props) => (
+  <Suspense fallback={null}>
+    <LazyAskSheet {...props} />
+  </Suspense>
+);
+
+export type { AliaAsk, AliaAskAgents, AliaAskProviderProps } from './AliaAskCore';
+export { useAskAgent } from './AliaAskCore';
+
+export const AliaAskProvider = createAskProvider(SuspendedAskSheet, loadSheet);

package/src/components/voice/AliaVoiceCall.web.tsx

@@ -0,0 +1,17 @@
+/**
+ * The call of a conversation screen, on web: its bar, while a call is open.
+ *
+ * Native loads the call lazily (`AliaVoiceCall.tsx`) so a screen that never calls never evaluates
+ * `react-native-audio-api`. Web never reaches that engine (`lib/voice-audio-engine.ts` is the Web
+ * Audio one), and a lazy `import()` here would be an async chunk boundary inside the SDK: Metro
+ * hoists every module two async chunks share into `__common.js`, loaded at first paint, so an app
+ * that lazy-loads its Alia sheet would get the chat in its first paint. On web the call is a
+ * static import and travels in whatever chunk holds the chat.
+ */
+
+import type { VoiceSessionProps } from '../../types';
+import { VoiceSession } from './VoiceSession';
+
+export function AliaVoiceCall(props: VoiceSessionProps) {
+  return <VoiceSession {...props} />;
+}

package/src/hooks/useAttachMenu.ts

@@ -2,6 +2,7 @@ import { RiFileTextLine } from '@oxy.so/bloom/icons/RiFileTextLine';
 import { RiImageLine } from '@oxy.so/bloom/icons/RiImageLine';
 import { useCallback, useMemo } from 'react';
 import type { AliaAddMenu } from '../lib/add-menu';
+import { loadDocumentPicker } from '../lib/deferred/document-picker';
 import type { IntakeKind } from '../lib/attachment-intake';
 import { useLabels } from '../lib/labels';
 import { ALIA_FEATURES, type FeatureOffer } from '../runtime/agents';
@@ -71,17 +72,15 @@ export function useAttachMenu(
               size: asset.size,
               mimeType: asset.mimeType,
             }))
-          : // The picker loads with the first document: a chat that never attaches one never does.
-            ((await (await import('../lib/document-picker')).pickDocuments()) ?? []).map(
-              (asset) => ({
-                id: attachmentId('doc'),
-                type: 'document' as const,
-                name: asset.name,
-                uri: asset.uri,
-                size: asset.size,
-                mimeType: asset.mimeType,
-              }),
-            );
+          : // On native the picker loads with the first document: a chat that never attaches one never does.
+            ((await (await loadDocumentPicker()).pickDocuments()) ?? []).map((asset) => ({
+              id: attachmentId('doc'),
+              type: 'document' as const,
+              name: asset.name,
+              uri: asset.uri,
+              size: asset.size,
+              mimeType: asset.mimeType,
+            }));
       for (const attachment of picked) store.addAttachment(address, attachment);
     },
     [offers, onFeatureLocked, pickImage, address],

package/src/hooks/useSoundEffects.ts

@@ -9,6 +9,7 @@
 
 import { useEffect, useRef, useCallback } from 'react';
 import type { AudioPlayer, AudioSource } from 'expo-audio';
+import { loadExpoAudio } from '../lib/deferred/expo-audio';
 import type { AgentState } from '../types';
 
 export type SoundName = 'thinking' | 'toolCall' | 'voiceConnect' | 'voiceDisconnect';
@@ -37,7 +38,7 @@ export function useSoundEffects(enabled: boolean = false, sounds: SoundSources =
 
     (async () => {
       try {
-        const { createAudioPlayer } = await import('expo-audio');
+        const { createAudioPlayer } = await loadExpoAudio();
         if (!mounted) return;
 
         for (const name of SOUND_NAMES) {

package/src/hooks/useTTS.ts

@@ -5,6 +5,7 @@ import { useOxy } from '@oxy.so/services/ui/client';
 import { errorMessage } from '../lib/utils';
 import { create } from 'zustand';
 import { createAudioLevelMeter } from '../lib/audio-level';
+import { loadExpoAudio } from '../lib/deferred/expo-audio';
 import { requestSpeechClip } from '../lib/speech-synthesis';
 import { ALIA_API_URL } from '../lib/origins';
 
@@ -142,7 +143,7 @@ export function useTTS(options: UseTTSOptions = {}) {
 
       (async () => {
         try {
-          const { createAudioPlayer } = await import('expo-audio');
+          const { createAudioPlayer } = await loadExpoAudio();
           if (signal.aborted) return;
           /**
            * `crossOrigin` is web-only and ignored elsewhere, and it is what makes

package/src/lib/deferred/document-picker.ts

@@ -0,0 +1,2 @@
+/** The document picker, loaded when the person picks a file: native evaluates nothing of it before. */
+export const loadDocumentPicker = () => import('../document-picker');

package/src/lib/deferred/document-picker.web.ts

@@ -0,0 +1,12 @@
+/**
+ * The document picker on web, imported with the composer.
+ *
+ * On web this is a static import: a lazy `import()` would be an async chunk boundary inside the SDK,
+ * and Metro hoists every module two async chunks share into `__common.js`, loaded at first paint —
+ * an app that lazy-loads its Alia sheet would get the chat in its first paint. Native keeps the
+ * lazy load (`./document-picker.ts`); `scripts/check-entry-isolation.mjs` holds that web has no boundary.
+ */
+
+import * as DocumentPicker from '../document-picker';
+
+export const loadDocumentPicker = async () => DocumentPicker;

package/src/lib/deferred/expo-audio.ts

@@ -0,0 +1,2 @@
+/** `expo-audio`, loaded on first use: native evaluates nothing of it until the chat plays a sound. */
+export const loadExpoAudio = () => import('expo-audio');

package/src/lib/deferred/expo-audio.web.ts

@@ -0,0 +1,12 @@
+/**
+ * `expo-audio` on web, imported with the chat.
+ *
+ * On web this is a static import: a lazy `import()` would be an async chunk boundary inside the SDK,
+ * and Metro hoists every module two async chunks share into `__common.js`, loaded at first paint —
+ * an app that lazy-loads its Alia sheet would get the chat in its first paint. Native keeps the
+ * lazy load (`./expo-audio.ts`); `scripts/check-entry-isolation.mjs` holds that web has no boundary.
+ */
+
+import * as ExpoAudio from 'expo-audio';
+
+export const loadExpoAudio = async () => ExpoAudio;

package/src/lib/deferred/image-data-url.ts

@@ -0,0 +1,5 @@
+/**
+ * The attachment reader, loaded on the first attachment: on native a turn of plain text (and the
+ * runtime entry that sends it) never evaluates `expo-file-system`.
+ */
+export const loadImageDataUrl = () => import('../image-data-url');

package/src/lib/deferred/image-data-url.web.ts

@@ -0,0 +1,12 @@
+/**
+ * The attachment reader on web, imported with the runtime.
+ *
+ * On web this is a static import: a lazy `import()` would be an async chunk boundary inside the SDK,
+ * and Metro hoists every module two async chunks share into `__common.js`, loaded at first paint —
+ * an app that lazy-loads its Alia sheet would get the chat in its first paint. Native keeps the
+ * lazy load (`./image-data-url.ts`); `scripts/check-entry-isolation.mjs` holds that web has no boundary.
+ */
+
+import * as ImageDataUrl from '../image-data-url';
+
+export const loadImageDataUrl = async () => ImageDataUrl;

package/src/lib/speech-synthesis.ts

@@ -9,6 +9,7 @@
  */
 
 import { createAudioLevelMeter } from './audio-level';
+import { loadExpoAudio } from './deferred/expo-audio';
 
 export type ProductVoice = 'male' | 'female';
 
@@ -171,7 +172,7 @@ export interface PlayClipOptions {
 export async function playSpeechClip(uri: string, options: PlayClipOptions): Promise<void> {
   const { signal, onLevel } = options;
   if (signal.aborted) return;
-  const { createAudioPlayer } = await import('expo-audio');
+  const { createAudioPlayer } = await loadExpoAudio();
   if (signal.aborted) return;
 
   const player = createAudioPlayer({ uri }, { crossOrigin: 'anonymous' });

package/src/runtime/attachment-utils.ts

@@ -1,3 +1,4 @@
+import { loadImageDataUrl } from '../lib/deferred/image-data-url';
 import type { AliaAttachment } from '../types';
 
 export type MessageContentPart =
@@ -60,9 +61,9 @@ export async function buildMessageContent(
 
   const parts: MessageContentPart[] = [{ type: 'text', text }];
 
-  // The readers need the platform's file access, loaded on the first attachment: a turn of plain
-  // text (and everything that imports this module) never touches it.
-  const { imageUriToDataUrl } = await import('../lib/image-data-url');
+  // The readers need the platform's file access, loaded on the first attachment: on native a turn
+  // of plain text (and everything that imports this module) never touches it.
+  const { imageUriToDataUrl } = await loadImageDataUrl();
   for (const att of usable) {
     if (att.type !== 'image' && upload !== undefined) {
       try {

package/src/runtime/conversations.ts

@@ -30,8 +30,11 @@ const FIVE_MINUTES = 1000 * 60 * 5;
 
 /** A stable signal for a URL whose server-side conversation no longer exists. */
 export class ConversationNotFoundError extends Error {
-  constructor(readonly conversationId: string) {
+  readonly conversationId: string;
+
+  constructor(conversationId: string) {
     super('Conversation not found');
+    this.conversationId = conversationId;
     this.name = 'ConversationNotFoundError';
   }
 }
@@ -54,7 +57,11 @@ function messageText(message: Message | undefined): string {
  * it holds nothing, and the 401 is the caller's to handle.
  */
 class OfflineConversations {
-  constructor(private readonly store: OfflineConversationStore | null) {}
+  private readonly store: OfflineConversationStore | null;
+
+  constructor(store: OfflineConversationStore | null) {
+    this.store = store;
+  }
 
   get available(): boolean {
     return this.store !== null;

package/tsconfig.json

@@ -5,6 +5,7 @@
     "moduleResolution": "bundler",
     "jsx": "react-jsx",
     "strict": true,
+    "erasableSyntaxOnly": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "esModuleInterop": true,