@alia.onl/sdk 21.3.1 → 21.4.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @alia.onl/sdk
 
+## 21.4.0
+
+### Added
+
+- **`@alia.onl/sdk/text` and `@alia.onl/sdk/ask/text`: the chat without bundling the voice
+  call.** `voice={false}` hid the call, but its code still shipped: since 21.3.2 the web build
+  inlines the call into the chat's chunk, so a text-only app paid for it. The new entries export
+  the same `AliaChatSheet`, `AliaChatScreen` and `AliaChatContent`, and `AliaAskProvider` /
+  `useAskAgent` with a lazily loaded sheet. None of them reaches the call's modules (its socket,
+  protocol and audio engine), and they never offer a call. Read-aloud and dictation stay.
+  CrowdSource's reviewer, which switched `AliaChatSheet` to `@alia.onl/sdk/text`: lazy sheet
+  chunk 1,455,831 → 1,357,287 bytes (413.8 → 374.2 KB gzip), `__common.js` 3,978,158 →
+  3,962,370 bytes, no new chunk. The README has a table of which entry to import.
+
+### Changed
+
+- `AliaChatContent` no longer imports the call. It draws whatever call `VoiceCallContext` hands it,
+  and the root entry and `@alia.onl/sdk/ask` export their chat through `withVoiceCall`, so those
+  two behave as before. `check:entries` checks that the text entries never reach the call, on any
+  platform, and draw no async boundary on web other than the ask sheet's.
+
+## 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

@@ -143,6 +143,26 @@ The sheet, the screen and the Alia app are three frames around ONE conversation
 stop, retry, edit and clear conversations through the same hooks, and a conversation started in
 one is the same conversation in the others.
 
+### Which entry to import
+
+| You want | Import from | Bundles the voice call |
+|---|---|---|
+| The chat with the call (`AliaChatSheet`, `AliaChatScreen`, `AliaChatContent`) | `@alia.onl/sdk` | yes |
+| The same chat, text only | `@alia.onl/sdk/text` | no |
+| One "Ask" sheet at the app's root, loaded with the first `ask` | `@alia.onl/sdk/ask` | yes, in the sheet's chunk |
+| The same, text only | `@alia.onl/sdk/ask/text` | no |
+| Data only: conversations, the stream, the model | `@alia.onl/sdk/runtime`, `@alia.onl/sdk/model` | no |
+| Her face on a button | `@alia.onl/sdk/avatar` | no |
+
+`voice={false}` hides the call, but the code still ships: the root entry and `@alia.onl/sdk/ask`
+bundle the call (its socket, protocol and audio engine) because their chat can open one. A
+text-only app imports from `@alia.onl/sdk/text` or `@alia.onl/sdk/ask/text`. Their chat never
+reaches those modules and never offers a call, whatever `voice` says. Read-aloud and dictation
+are still there, because they belong to the thread and the composer. Types can still come from
+`@alia.onl/sdk`, since type imports are erased. A value imported from the root brings the call
+along with it. In CrowdSource's reviewer, `@alia.onl/sdk/text` made its lazy sheet chunk 98 KB
+smaller (raw; 39 KB gzip).
+
 ## Any agent, from any app
 
 Every agent — Alia included — is the same agent (ADR 0020), and any Oxy app opens any agent the
@@ -174,7 +194,15 @@ 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 (or `@alia.onl/sdk/text`). Don't do both, or the chat they
+share lands in `__common.js`. The text-only entries draw no extra boundary either.
 
 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 +461,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.4.0",
   "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",
@@ -9,11 +9,13 @@
   "exports": {
     ".": "./src/index.ts",
     "./ask": "./src/ask.ts",
+    "./ask/text": "./src/ask-text.ts",
     "./avatar": "./src/avatar.ts",
     "./content": "./src/lib/content-utils.ts",
     "./csp": "./src/csp.ts",
     "./model": "./src/runtime/model.ts",
     "./runtime": "./src/runtime/index.ts",
+    "./text": "./src/text.ts",
     "./tools": "./src/tools.ts",
     "./voice": "./src/voice.ts",
     "./package.json": "./package.json"

package/src/ask-text.ts

@@ -0,0 +1,10 @@
+// @alia.onl/sdk/ask/text — `@alia.onl/sdk/ask` without the voice call, and without bundling it
+// The provider and its hook; the sheet loads with the first `ask`, and neither reaches the call's
+// modules. `useAskAgent` is the same hook as `@alia.onl/sdk/ask`'s.
+
+export { AliaAskProvider, useAskAgent } from './components/AliaAskProviderText';
+export type {
+  AliaAsk,
+  AliaAskAgents,
+  AliaAskProviderProps,
+} from './components/AliaAskProviderText';

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 './AliaAskSheetWithVoice';
 
-  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 (and
+ * `@alia.onl/sdk/ask/text`): everything behind it (`AliaAskSheetWithVoice` 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('./AliaAskSheetWithVoice');
+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/AliaAskProviderText.tsx

@@ -0,0 +1,25 @@
+/**
+ * The ask provider of `@alia.onl/sdk/ask/text`: `AliaAskProviderLazy` without the voice call. Its
+ * sheet is loaded lazily, with the first `ask`, and neither the provider nor the sheet reaches the
+ * call's modules, so a text-only app bundles none of them.
+ *
+ * Its `import()` is the one async boundary of this entry, as in `AliaAskProviderLazy`: behind it
+ * everything imports statically on web (`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/AliaAskSheetWithVoice.tsx

@@ -0,0 +1,10 @@
+/**
+ * The ask sheet with the voice call: what the root entry's `AliaAskProvider` imports and
+ * `@alia.onl/sdk/ask` loads with the first `ask`. `@alia.onl/sdk/ask/text` loads `AliaAskSheet`
+ * itself, which never reaches the call.
+ */
+
+import { AliaAskSheet as TextAskSheet } from './AliaAskSheet';
+import { withVoiceCall } from './voice/withVoiceCall';
+
+export const AliaAskSheet = withVoiceCall(TextAskSheet, 'AliaAskSheet');

package/src/components/AliaChatContent.tsx

@@ -7,8 +7,9 @@
  * (`useChatComposer`, `useChatVoice`, `useThreadView`), and this, which draws it — the thread
  * (`AliaThread`) and the agent's history behind it, the composer with its levels, suggestions and
  * questions, and the voice call: the button that opens it, the bar that replaces the composer, the
- * notices and the transcript in the thread. The call loads on the first call, so nothing here
- * reaches its audio engine at module-evaluation time.
+ * notices and the transcript in the thread. The call itself is not imported here: the entry that
+ * bundles it hands it down (`VoiceCallContext`, `withVoiceCall`), so the text-only entries
+ * (`@alia.onl/sdk/text`, `@alia.onl/sdk/ask/text`) never reach its modules.
  *
  * What a host brings is data and places: the conversation to show, the chrome around it
  * (`chrome`), its rows in the add menu, its words (`labels`), where the thought panel and a
@@ -30,7 +31,15 @@ import { RiEditLine } from '@oxy.so/bloom/icons/RiEditLine';
 import { toast } from '@oxy.so/bloom/toast';
 import { Text } from '@oxy.so/bloom/typography';
 import { useQueryClient } from '@tanstack/react-query';
-import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import {
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import { View } from 'react-native';
 import type { SharedValue } from 'react-native-reanimated';
 import { useAmbientWave } from '../hooks/useAmbientWave';
@@ -66,7 +75,7 @@ import { AmbientField } from './AmbientField';
 import { AliaThread } from './thread/AliaThread';
 import { ThreadSearch } from './thread/ThreadSearch';
 import { VoiceModeIcon } from './VoiceModeIcon';
-import { AliaVoiceCall } from './voice/AliaVoiceCall';
+import { VoiceCallContext } from './voice/VoiceCallContext';
 
 /** The agent a chat is opened on: its lead instead of Alia. */
 export interface AliaChatAgentRef {
@@ -227,7 +236,8 @@ export interface AliaChatContentProps {
    */
   renderUsageLimit?: (limit: { error: UsageLimitError; dismiss: () => void }) => ReactNode;
   /**
-   * The chat's voice call. On by default; `false` makes the chat text-only. An object brings
+   * The chat's voice call. On by default where the call is bundled (the root entry and
+   * `@alia.onl/sdk/ask`); the text-only entries have none. `false` makes the chat text-only. An object brings
    * what only the host knows: the gate before a call (`canStartVoice`, `onVoiceBlocked`), what
    * to refresh when one ends (`onCallEnded`), where its notices go (`onNotice`), the sounds it
    * plays. The call always lives in the chat's conversation, made when it starts if the chat has
@@ -405,8 +415,10 @@ function AliaConversationView({
     onSuggestionPicked,
     presentedProgress,
   });
+  // Without a call handed down (a text-only entry), the chat is text-only whatever `voice` says.
+  const VoiceCall = useContext(VoiceCallContext);
   const voice = useChatVoice({
-    options: voiceOptions,
+    options: VoiceCall === null ? false : voiceOptions,
     conversationId,
     agentId,
     isFocused,
@@ -600,8 +612,8 @@ function AliaConversationView({
 
   const composerNode = (
     <>
-      {voice.enabled && voice.isActive ? (
-        <AliaVoiceCall {...voice.launcher.sessionProps} />
+      {VoiceCall !== null && voice.enabled && voice.isActive ? (
+        <VoiceCall {...voice.launcher.sessionProps} />
       ) : (
         <AliaComposer
           // A different account is a different composer: reads in flight for the last one are

package/src/components/AliaChatWithVoice.tsx

@@ -0,0 +1,13 @@
+/**
+ * The chat components of the root entry: each draws the voice call (`withVoiceCall`). The same
+ * components without it — and without bundling it — are `@alia.onl/sdk/text`.
+ */
+
+import { AliaChatContent as TextChatContent } from './AliaChatContent';
+import { AliaChatScreen as TextChatScreen } from './AliaChatScreen';
+import { AliaChatSheet as TextChatSheet } from './AliaChatSheet';
+import { withVoiceCall } from './voice/withVoiceCall';
+
+export const AliaChatContent = withVoiceCall(TextChatContent, 'AliaChatContent');
+export const AliaChatSheet = withVoiceCall(TextChatSheet, 'AliaChatSheet');
+export const AliaChatScreen = withVoiceCall(TextChatScreen, 'AliaChatScreen');

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/components/voice/VoiceCallContext.ts

@@ -0,0 +1,13 @@
+/**
+ * The voice call a conversation can open, handed down by the entry that bundles it.
+ *
+ * `AliaChatContent` draws the call through this rather than importing it, so a text-only entry
+ * (`@alia.onl/sdk/text`, `@alia.onl/sdk/ask/text`) never reaches the call's modules — its socket,
+ * protocol and audio engine. The root and `@alia.onl/sdk/ask` provide `AliaVoiceCall` around their
+ * chat (`withVoiceCall`); without a provider the chat is text-only, whatever its `voice` prop says.
+ */
+
+import { type ComponentType, createContext } from 'react';
+import type { VoiceSessionProps } from '../../types';
+
+export const VoiceCallContext = createContext<ComponentType<VoiceSessionProps> | null>(null);

package/src/components/voice/withVoiceCall.tsx

@@ -0,0 +1,25 @@
+/**
+ * A chat component with the voice call: `Component` drawn under `VoiceCallContext`, which hands
+ * it `AliaVoiceCall`. The root entry and `@alia.onl/sdk/ask` export their chat through this; the
+ * text-only entries export the components as they are.
+ */
+
+import type { ComponentType } from 'react';
+import { AliaVoiceCall } from './AliaVoiceCall';
+import { VoiceCallContext } from './VoiceCallContext';
+
+export function withVoiceCall<P extends object>(
+  Component: ComponentType<P>,
+  displayName: string,
+): ComponentType<P> {
+  // A ref is a prop of a function component (React 19), so it reaches a `forwardRef` `Component`.
+  function WithVoiceCall(props: P) {
+    return (
+      <VoiceCallContext.Provider value={AliaVoiceCall}>
+        <Component {...props} />
+      </VoiceCallContext.Provider>
+    );
+  }
+  WithVoiceCall.displayName = displayName;
+  return WithVoiceCall;
+}

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/index.ts

@@ -3,7 +3,7 @@
 // Reusable chat UI, voice, and streaming components for Oxy apps
 
 // ── Main components ──
-export { AliaChatContent } from './components/AliaChatContent';
+export { AliaChatContent } from './components/AliaChatWithVoice';
 export type {
   AliaChatAgentRef,
   AliaChatChrome,
@@ -25,11 +25,11 @@ export { AliaSharedConversation } from './components/AliaSharedConversation';
 export type { AliaSharedConversationProps } from './components/AliaSharedConversation';
 export type { AliaAddMenu } from './lib/add-menu';
 export type { AliaVoiceOptions } from './hooks/useChatVoice';
-export { AliaChatSheet } from './components/AliaChatSheet';
+export { AliaChatSheet } from './components/AliaChatWithVoice';
 export type { AliaChatSheetProps, AliaChatSheetRef } from './components/AliaChatSheet';
 export { AliaRecentConversations } from './components/AliaRecentConversations';
 export type { AliaTurn } from './hooks/useChatComposer';
-export { AliaChatScreen } from './components/AliaChatScreen';
+export { AliaChatScreen } from './components/AliaChatWithVoice';
 export type { AliaChatScreenProps } from './components/AliaChatScreen';
 
 // ── Chat UI components ──

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/src/text.ts

@@ -0,0 +1,18 @@
+// @alia.onl/sdk/text — the chat without the voice call, and without bundling it
+// The same `AliaChatSheet`, `AliaChatScreen` and `AliaChatContent` as the root entry, but none of
+// them reaches the call's modules (its socket, protocol and audio engine): a text-only app takes
+// its chat from here. Read-aloud and dictation stay — they are the composer's and the thread's.
+// Types can be imported from the root entry (they are erased); values from the root would bring
+// the call along.
+
+export { AliaChatContent } from './components/AliaChatContent';
+export type {
+  AliaChatAgentRef,
+  AliaChatChrome,
+  AliaChatContentProps,
+  AliaChatState,
+} from './components/AliaChatContent';
+export { AliaChatSheet } from './components/AliaChatSheet';
+export type { AliaChatSheetProps, AliaChatSheetRef } from './components/AliaChatSheet';
+export { AliaChatScreen } from './components/AliaChatScreen';
+export type { AliaChatScreenProps } from './components/AliaChatScreen';

package/tsconfig.json

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