@alia.onl/sdk 21.3.0 → 21.3.2

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @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
+  English. Changes to that language update the open sheet without replacing its conversation.
+- Ship a complete Spanish chat catalogue, including composer, voice, menus, thought panel and
+  conversation errors. Regional Spanish tags use it; host label overrides remain supported.
+- Apply the sheet's labels above its hooks and all its sheets, so sharing errors and the thought
+  panel use the same language as the conversation.
+
 ## 21.3.0
 
 The SDK runs on Expo SDK 58 (React Native 0.88, React 19.3) as well as Expo 57.

package/README.md

@@ -56,9 +56,12 @@ The empty chat greets the signed-in person by name ("Hi Nate, what's on your min
 Failures (a voice call that cannot start, a dictation error) are shown with Bloom's `toast`,
 so the app needs a `ToastOutlet` (`OxyProvider` mounts one), or pass `onError` to handle them.
 
-The chat's own copy is English. Pass `labels` to `AliaChatSheet` or
-`AliaChatScreen` to translate it (`AliaChatLabels`; anything omitted stays
-English). Bloom's own strings follow `BloomProvider`'s `locale`.
+`AliaAskProvider` follows the language Oxy Services resolves for the active account, including
+language changes while its sheet is open. The SDK ships English and Spanish (regional Spanish tags
+such as `es-ES` and `es-MX` use Spanish); other languages fall back to English. `AliaChatSheet` and
+`AliaChatScreen` select their built-in copy from `labels.locale`. Pass `labels` to override any copy
+(`AliaChatLabels`), or `labels.t` for another catalogue. Nested overrides preserve the surrounding
+chat's translations. Bloom's own strings follow `BloomProvider`'s `locale`.
 
 Entry points:
 
@@ -171,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
@@ -430,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.0",
+  "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,169 +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 } 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, ...sheet },
-  ref,
-) {
-  const { canUsePrivateApi, signIn } = useAuth();
-  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}
-            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/AliaChatSheet.tsx

@@ -16,7 +16,7 @@ import { useSharedValue } from 'react-native-reanimated';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 import { BREAKPOINTS } from '@oxy.so/bloom/styles';
 import { ALIA_CHARACTER_RUNTIME_URL } from '../lib/character-runtime';
-import type { AliaChatLabels } from '../lib/labels';
+import { AliaChatLabelsProvider, type AliaChatLabels } from '../lib/labels';
 import type { AliaToolRenderers } from '../lib/tool-renderers';
 import { useShareHandler } from '../hooks/useShareHandler';
 import type { AliaRuntimeHost } from '../runtime/config';
@@ -109,6 +109,16 @@ export interface AliaChatSheetRef {
 }
 
 export const AliaChatSheet = forwardRef<AliaChatSheetRef, AliaChatSheetProps>(
+  function AliaChatSheet(props, ref) {
+    return (
+      <AliaChatLabelsProvider labels={props.labels}>
+        <AliaChatSheetBody {...props} ref={ref} />
+      </AliaChatLabelsProvider>
+    );
+  },
+);
+
+const AliaChatSheetBody = forwardRef<AliaChatSheetRef, AliaChatSheetProps>(
   (
     {
       agent,

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/copy-es.ts

@@ -0,0 +1,280 @@
+/** The SDK chat catalogue, matching the Spanish Alia app copy. */
+import type { CopyEntry } from './copy-en';
+
+export const COPY_ES: Readonly<Record<string, CopyEntry>> = {
+  'automations.cron.dailyAt': 'Todos los días a las {{time}}',
+  'automations.cron.dayPlural.0': 'domingos',
+  'automations.cron.dayPlural.1': 'lunes',
+  'automations.cron.dayPlural.2': 'martes',
+  'automations.cron.dayPlural.3': 'miércoles',
+  'automations.cron.dayPlural.4': 'jueves',
+  'automations.cron.dayPlural.5': 'viernes',
+  'automations.cron.dayPlural.6': 'sábados',
+  'automations.cron.daysAt': 'Los {{days}} a las {{time}}',
+  'automations.cron.everyHour': 'Cada hora',
+  'automations.cron.everyHours': 'Cada {{count}} horas',
+  'automations.cron.everyMinutes': { one: 'Cada minuto', other: 'Cada {{count}} minutos' },
+  'automations.cron.weekdaysAt': 'De lunes a viernes a las {{time}}',
+  'automations.cron.weekendsAt': 'Los fines de semana a las {{time}}',
+  'automations.trigger.anyApp': 'Cualquier app',
+  'automations.trigger.anyEvent': 'Cualquier evento',
+  'automations.trigger.manual': 'A petición',
+  'automations.trigger.unscheduled': 'Sin programar',
+  'chat.agentRun.by': 'por %{name}',
+  'chat.agentRun.complete': 'Tarea completada',
+  'chat.agentRun.completed': 'Completada',
+  'chat.agentRun.credits': '%{count} créditos',
+  'chat.agentRun.error': 'Error',
+  'chat.agentRun.failed': 'Fallida',
+  'chat.agentRun.planItems': '%{done}/%{total} pasos del plan',
+  'chat.agentRun.planSummary': 'Resumen del plan',
+  'chat.agentRun.steps': '%{count} pasos',
+  'chat.agentRun.taskComplete': 'Tarea completada',
+  'chat.agentRun.taskFailed': 'La tarea falló',
+  'chat.agentRun.unknown': 'Desconocido',
+  'chat.agentRun.working': 'Agente trabajando',
+  'chat.backToLatest': 'Volver a lo último',
+  'chat.blockFailed': 'Esta parte de la respuesta no se ha podido mostrar.',
+  'chat.bloom.context.freeSpace': 'Espacio libre',
+  'chat.bloom.context.mcp': 'Herramientas MCP',
+  'chat.bloom.context.memory': 'Memoria',
+  'chat.bloom.context.messages': 'Mensajes',
+  'chat.bloom.context.skills': 'Skills',
+  'chat.bloom.context.system': 'Prompt del sistema',
+  'chat.bloom.context.title': 'Ventana de contexto',
+  'chat.bloom.context.tools': 'Herramientas',
+  'chat.bloom.createdFile': 'Creó',
+  'chat.bloom.limits.close': 'Cerrar panel de créditos',
+  'chat.bloom.limits.dailyFree': 'Créditos gratis diarios',
+  'chat.bloom.limits.planUsage': 'Límites de uso del plan',
+  'chat.bloom.limits.resetsDaily': 'Se renueva cada 24 horas',
+  'chat.bloom.limits.resetsInHours': 'Se renueva en {{hours}} h {{minutes}} min',
+  'chat.bloom.limits.resetsInMinutes': 'Se renueva en {{minutes}} min',
+  'chat.bloom.limits.resetsSoon': 'Se renueva pronto',
+  'chat.bloom.limits.window': 'Límite de {{hours}} horas',
+  'chat.bloom.limits.windowFresh': 'Se renueva {{hours}} horas después de tu próximo mensaje',
+  'chat.bloom.noResults': 'Sin resultados',
+  'chat.bloom.researched': 'Investigó',
+  'chat.bloom.researching': 'Investigando',
+  'chat.bloom.resultCount': { one: '1 resultado', other: '{{count}} resultados' },
+  'chat.bloom.scrollToLatest': 'Ir a los últimos mensajes',
+  'chat.bloom.searchCount': { one: '1 búsqueda', other: '{{count}} búsquedas' },
+  'chat.bloom.searchFailed': 'La búsqueda falló',
+  'chat.bloom.searchedWeb': 'Buscó en la web',
+  'chat.bloom.sourceCount': { one: '1 fuente', other: '{{count}} fuentes' },
+  'chat.bloom.taskFailed': 'Devolvió un error',
+  'chat.bloom.taskInput': 'Con',
+  'chat.bloom.taskStopped': 'No terminó',
+  'chat.bloom.visited': 'Visitó',
+  'chat.bloom.writingFile': 'Escribiendo',
+  'chat.copied': '¡Copiado!',
+  'chat.copiedToClipboard': 'Copiado al portapapeles',
+  'chat.copy': 'Copiar',
+  'chat.copyFailed': 'No se pudo copiar al portapapeles',
+  'chat.dislike': 'No me gusta',
+  'chat.edit': 'Editar',
+  'chat.feedbackFailed': 'No se ha podido guardar tu opinión.',
+  'chat.like': 'Me gusta',
+  'chat.loadingHistory': 'Cargando mensajes anteriores…',
+  'chat.newConversationAccept': 'Empezar una nueva',
+  'chat.newConversationDismiss': 'Ahora no',
+  'chat.newConversationOffer': '¿Empezar una conversación nueva?',
+  'chat.newStretch': 'Conversación nueva',
+  'chat.readAloud': 'Leer en voz alta',
+  'chat.readAloudFailed': 'No se pudo leer en voz alta',
+  'chat.regenerate': 'Volver a generar',
+  'chat.retry': 'Reintentar',
+  'chat.richBlocks.source': 'Fuente: {{source}}',
+  'chat.searchThreadAgent': 'Agente',
+  'chat.searchThreadEmpty': 'No hay coincidencias.',
+  'chat.searchThreadFailed': 'No se pudo buscar.',
+  'chat.searchThreadHint':
+    'Busca todo lo que le has dicho a este agente, en todas las conversaciones.',
+  'chat.searchThreadPlaceholder': 'Buscar en este hilo',
+  'chat.searchThreadSearching': 'Buscando…',
+  'chat.searchThreadYou': 'Tú',
+  'chat.sources': 'Fuentes',
+  'chat.stopReading': 'Dejar de leer',
+  'chat.thanksFeedback': '¡Gracias por tu opinión!',
+  'chat.thinking': 'Pensando',
+  'chat.today': 'Hoy',
+  'chat.toolCard.openTask': 'Abrir la tarea programada %{objective}',
+  'chat.toolCard.paused': 'En pausa',
+  'chat.toolCard.scheduled': 'Programada',
+  'chat.turnActions': 'Acciones del mensaje',
+  'chat.consultFailed': '%{name} no pudo responder.',
+  'chat.shareFailed': 'No se pudo crear el enlace para compartir.',
+  'chat.sharedFailed': 'No se pudo cargar esta conversación.',
+  'chat.sharedGone': 'Esta conversación compartida ya no está disponible.',
+  'chat.turnFailed': 'Alia no ha podido responder ahora mismo.',
+  'chat.turnFailedRetryHint': 'Inténtalo de nuevo.',
+  'chat.turnInterrupted': 'Alia se interrumpió antes de terminar.',
+  'chat.working': 'Trabajando',
+  'chat.yesterday': 'Ayer',
+  'common.close': 'Cerrar',
+  'composer.cancelEdit': 'Cancelar',
+  'composer.editPlaceholder': 'Edita tu mensaje',
+  'composer.editingMessage': 'Editando mensaje',
+  'faircoin.indexed':
+    'Precio indexado del pool WFAIR/USDC en Base — FairCoin no cotiza en ningún exchange',
+  'faircoin.liquidity': 'Liquidez',
+  'faircoin.marketCap': 'Capitalización',
+  'faircoin.name': 'FairCoin',
+  'faircoin.noChart': 'Sólo hay una muestra — no bastan para trazar una línea.',
+  'faircoin.noPrice': 'Sin cotización',
+  'faircoin.noPriceHint': 'El pool WFAIR/USDC no tenía precio indexado cuando se preguntó.',
+  'faircoin.noSamples': 'Todavía no hay muestras de este periodo.',
+  'faircoin.range.1y': '1 A',
+  'faircoin.range.24h': '24 h',
+  'faircoin.range.30d': '30 D',
+  'faircoin.range.7d': '7 D',
+  'faircoin.range.all': 'Todo',
+  'faircoin.scale.billion': ' mil M',
+  'faircoin.scale.million': ' M',
+  'faircoin.scale.thousand': ' mil',
+  'faircoin.scale.trillion': ' B',
+  'faircoin.source': 'De %{source}',
+  'faircoin.symbol': 'FAIR',
+  'faircoin.unavailable': 'Sin histórico para %{ranges}',
+  'faircoin.updated': 'Actualizado %{time}',
+  'faircoin.volume': 'Volumen 24 h',
+  'market.dayHigh': 'Máximo del día',
+  'market.dayLow': 'Mínimo del día',
+  'market.marketCap': 'Capitalización',
+  'market.noChart': 'No hay histórico suficiente para dibujar este rango',
+  'market.noPrice': 'Sin cotización disponible',
+  'market.open': 'Apertura',
+  'market.range.1D': '1D',
+  'market.range.1M': '1M',
+  'market.range.1Y': '1A',
+  'market.range.5D': '5D',
+  'market.range.5Y': '5A',
+  'market.range.6M': '6M',
+  'market.range.MAX': 'MAX',
+  'market.range.YTD': 'YTD',
+  'market.volume': 'Volumen (24 h)',
+  'panels.canvas.image': 'Imagen',
+  'panels.canvas.unsupported': 'Tipo de componente no compatible: {{type}}',
+  'panels.chart.share': 'Porcentaje',
+  'panels.chart.value': 'Valor',
+  'panels.code.copied': 'Código copiado',
+  'panels.code.copy': 'Copiar código',
+  'panels.form.enter': 'Escribe {{field}}',
+  'panels.form.select': 'Selecciona…',
+  'panels.form.submit': 'Enviar',
+  'powerLevels.auto.description': 'Elige el nivel adecuado para cada mensaje',
+  'powerLevels.auto.label': 'Auto',
+  'powerLevels.high.description': 'Piensa más en las preguntas difíciles',
+  'powerLevels.high.label': 'Alto',
+  'powerLevels.instant.description': 'Lo más rápido y barato, para respuestas rápidas',
+  'powerLevels.instant.label': 'Instantáneo',
+  'powerLevels.medium.description': 'Rápido y capaz, para el día a día',
+  'powerLevels.medium.label': 'Medio',
+  'powerLevels.onDevice': 'En %{device}',
+  'powerLevels.pro.description': 'Modelos punteros; más lento y más caro',
+  'powerLevels.pro.label': 'Pro',
+  'powerLevels.ultra.description': 'El más capaz; el más lento y el más caro',
+  'powerLevels.ultra.label': 'Ultra',
+  'powerLevels.xhigh.description': 'Piensa aún más; algo más lento',
+  'powerLevels.xhigh.label': 'Muy alto',
+  'tasks.tool.done.agentSearch': 'Buscó agentes',
+  'tasks.tool.done.browse': 'Navegó',
+  'tasks.tool.done.codeInterpreter': 'Ejecutó código',
+  'tasks.tool.done.consultAgent': 'Consultó a un agente',
+  'tasks.tool.done.fileEdit': 'Editó un archivo',
+  'tasks.tool.done.generateFile': 'Generó un archivo',
+  'tasks.tool.done.shellExec': 'Ejecutó un comando',
+  'tasks.tool.done.loadTools': 'Cargó herramientas',
+  'tasks.tool.done.userMemory': 'Recordó',
+  'tasks.tool.done.webScraper': 'Leyó la página',
+  'tasks.tool.pill.agentSearch': 'Buscando agentes',
+  'tasks.tool.pill.browse': 'Navegando',
+  'tasks.tool.pill.codeInterpreter': 'Ejecutando código',
+  'tasks.tool.pill.consultAgent': 'Consultando a un agente',
+  'tasks.tool.pill.fileEdit': 'Editando archivo',
+  'tasks.tool.pill.generateFile': 'Generando archivo',
+  'tasks.tool.pill.sendDiscord': 'Discord',
+  'tasks.tool.pill.sendEmail': 'Correo',
+  'tasks.tool.pill.sendSignal': 'Signal',
+  'tasks.tool.pill.sendSlack': 'Slack',
+  'tasks.tool.pill.sendTelegramMessage': 'Telegram',
+  'tasks.tool.pill.shellExec': 'Ejecutando comando',
+  'tasks.tool.pill.loadTools': 'Cargando herramientas',
+  'tasks.tool.pill.userMemory': 'Recordando',
+  'tasks.tool.pill.webScraper': 'Leyendo la página',
+  'tasks.tool.pill.webSearch': 'Búsqueda web',
+  'thought.activity': 'Actividad',
+  'thought.audit.agent': 'Agente: {{name}}',
+  'thought.audit.fileGenerated': 'Archivo generado',
+  'thought.audit.plan': 'Plan',
+  'thought.audit.planSteps': { one: '1 paso', other: '{{count}} pasos' },
+  'thought.audit.researchComplete': 'Investigación completada',
+  'thought.audit.researchIncomplete': 'Investigación incompleta',
+  'thought.audit.researchPhase.decomposing': 'Investigación: desglosando la pregunta',
+  'thought.audit.researchPhase.finalizing': 'Investigación: terminando',
+  'thought.audit.researchPhase.follow_up': 'Investigación: profundizando',
+  'thought.audit.researchPhase.reading': 'Investigación: leyendo artículos',
+  'thought.audit.researchPhase.searching': 'Investigación: buscando fuentes',
+  'thought.audit.researchPhase.synthesizing': 'Investigación: sintetizando hallazgos',
+  'thought.audit.researching': 'Investigando',
+  'thought.cancelled': 'Detenido',
+  'thought.done': 'Listo',
+  'thought.failed': 'Falló',
+  'thought.failedAfter': 'Falló tras {{elapsed}}',
+  'thought.filesAndSources': 'Archivos y fuentes',
+  'thought.input': 'Entrada',
+  'thought.loadFailed': 'No se pudo cargar esta conversación',
+  'thought.loading': 'Cargando esta conversación…',
+  'thought.messageGone': 'Este mensaje ya no está en la conversación',
+  'thought.noActivity': 'Aún no hay acciones registradas',
+  'thought.noOutputs': 'No se generaron archivos',
+  'thought.noSources': 'No se usaron fuentes',
+  'thought.noSteps': 'No hay pasos para mostrar',
+  'thought.openOutput': 'Abrir {{name}} en el lienzo',
+  'thought.output': 'Salida',
+  'thought.outputs': 'Resultados',
+  'thought.reasoning': 'Razonamiento',
+  'thought.references': 'Referencias',
+  'thought.sourceLabel': 'Fuente {{n}}: {{title}}',
+  'thought.sources': 'Fuentes',
+  'thought.steps': 'Pasos',
+  'thought.stoppedAfter': 'Detenido tras {{elapsed}}',
+  'thought.thinking': 'Pensando',
+  'thought.thinkingFor': 'Pensando por {{seconds}}s...',
+  'thought.thoughtFor': 'Pensó por {{seconds}} segundos',
+  'thought.title': 'Pensamiento',
+  'thought.tool.browse': 'Navegando por la web',
+  'thought.tool.generateFile': 'Generando archivo',
+  'thought.tool.getCurrentDate': 'Consultando la fecha actual',
+  'thought.tool.getTimeline': 'Obteniendo la cronología',
+  'thought.tool.getWhatsAppChats': 'Cargando chats de WhatsApp',
+  'thought.tool.getWhatsAppMessages': 'Leyendo mensajes de WhatsApp',
+  'thought.tool.saveUserMemory': 'Guardando en la memoria',
+  'thought.tool.scrapeURL': 'Leyendo URL',
+  'thought.tool.searchKnowledgeBase': 'Buscando en la base de conocimiento',
+  'thought.tool.sendTelegramMessage': 'Enviando mensaje de Telegram',
+  'thought.tool.sendWhatsAppMessage': 'Enviando mensaje de WhatsApp',
+  'thought.tool.updateUserContext': 'Actualizando contexto',
+  'thought.tool.updateUserPreferences': 'Actualizando preferencias',
+  'thought.tool.webScraper': 'Leyendo página web',
+  'thought.tool.webSearch': 'Buscando en la web',
+  'thought.viewDetails': 'Ver detalles',
+  'thought.websites': 'Sitios web',
+  'thought.worked': 'Trabajó',
+  'thought.workedFor': 'Trabajó durante {{elapsed}}',
+  'thought.working': 'Trabajando…',
+  'thought.workingFor': 'Trabajando desde hace {{elapsed}}…',
+  'thought.writing': 'Escribiendo',
+  'usageLimit.inputDisabledPlaceholder': 'Límite de uso alcanzado',
+  'weather.condition.clear': 'Despejado',
+  'weather.condition.cloudy': 'Nublado',
+  'weather.condition.drizzle': 'Llovizna',
+  'weather.condition.fog': 'Niebla',
+  'weather.condition.partly-cloudy': 'Parcialmente nublado',
+  'weather.condition.rain': 'Lluvia',
+  'weather.condition.showers': 'Chubascos',
+  'weather.condition.snow': 'Nieve',
+  'weather.condition.snow-showers': 'Chubascos de nieve',
+  'weather.condition.thunderstorm': 'Tormenta',
+  'weather.toggleUnit': 'Cambiar unidad de temperatura',
+};

package/src/lib/copy.ts

@@ -1,4 +1,5 @@
 import { COPY_EN, type CopyEntry } from './copy-en';
+import { COPY_ES } from './copy-es';
 
 /**
  * A translator keyed the way the Alia app's own catalogue keys its strings, so the app hands its
@@ -21,12 +22,17 @@ const PLACEHOLDER = /\{\{\s*(\w+)\s*\}\}|%\{(\w+)\}/g;
  * The default translator: the English in `copy-en.ts`, with `{{count}}` plurals and parameters.
  * A key it does not know answers itself, so a missing string is visible rather than blank.
  */
-export const englishCopy: Translate = (key, params) => {
-  const entry = COPY_EN[key];
-  if (entry === undefined) return key;
-  const count = typeof params?.count === 'number' ? params.count : undefined;
-  return entryFor(entry, count).replace(PLACEHOLDER, (placeholder, a?: string, b?: string) => {
-    const value = params?.[(a ?? b) as string];
-    return value === undefined ? placeholder : String(value);
-  });
-};
+function createCopy(catalogue: Readonly<Record<string, CopyEntry>>): Translate {
+  return (key, params) => {
+    const entry = catalogue[key];
+    if (entry === undefined) return key;
+    const count = typeof params?.count === 'number' ? params.count : undefined;
+    return entryFor(entry, count).replace(PLACEHOLDER, (placeholder, a?: string, b?: string) => {
+      const value = params?.[(a ?? b) as string];
+      return value === undefined ? placeholder : String(value);
+    });
+  };
+}
+
+export const englishCopy = createCopy(COPY_EN);
+export const spanishCopy = createCopy(COPY_ES);

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/labels-es.ts

@@ -0,0 +1,113 @@
+import type { AliaChatLabels, VoiceBlockReason } from './labels';
+import { spanishCopy } from './copy';
+import type { VoiceCloseReason } from './voice-protocol';
+import type { VoiceErrorCode } from './speech-messages';
+
+const VOICE_ERRORS: Record<VoiceErrorCode, string> = {
+  'not-authenticated': 'Inicia sesión para usar la voz',
+  'credential-not-supported': 'La voz solo está disponible con tu sesión de Alia',
+  'plan-required': 'El modo voz necesita un plan de pago',
+  'credits-exhausted': 'Te has quedado sin créditos para esta llamada',
+  'agent-unavailable': 'Este agente no está disponible para una llamada',
+  'invalid-request': 'No se pudo iniciar la llamada',
+  'resume-unavailable': 'No se pudo retomar la llamada: empieza una nueva',
+  'realtime-unavailable': 'La voz no está disponible ahora mismo: inténtalo más tarde',
+  'realtime-limited': 'La voz ha llegado a su límite por ahora: inténtalo más tarde',
+  'realtime-rejected': 'No se pudo iniciar la llamada con esta configuración',
+  'realtime-failed': 'La llamada ha fallado: inténtalo de nuevo',
+  'mic-denied': 'Se necesita permiso para usar el micrófono',
+  'mic-unavailable': 'No se pudo usar el micrófono: revisa tus dispositivos de entrada',
+  'connection-lost': 'Se perdió la conexión',
+  'voice-unavailable': 'La voz no está disponible en este dispositivo o navegador',
+  'too-long': 'El dictado era demasiado largo: cinco minutos como máximo',
+  'transcription-unavailable': 'El dictado no está disponible ahora mismo',
+  'transcription-limited': 'El dictado ha llegado a su límite por ahora: inténtalo más tarde',
+  'transcription-rejected': 'No se pudo transcribir esa grabación',
+  'transcription-failed': 'Falló el dictado: inténtalo de nuevo',
+};
+const VOICE_ENDED: Partial<Record<VoiceCloseReason, string>> = {
+  'call-moved-elsewhere': 'La llamada sigue en tu otro dispositivo',
+  'max-duration': 'La llamada llegó a su límite de 30 minutos',
+  'idle-timeout': 'La llamada terminó tras dos minutos de silencio',
+  'credits-exhausted': 'La llamada terminó: te quedaste sin créditos',
+  'server-shutdown': 'La llamada terminó mientras Alia se actualizaba: empieza una nueva',
+};
+const VOICE_BLOCKED: Record<VoiceBlockReason, string> = {
+  'sign-in': 'Inicia sesión para usar la voz',
+  'plan-required': 'El modo voz necesita un plan de pago',
+  'credits-exhausted': 'Te has quedado sin créditos',
+};
+
+/** Built-in Spanish, shared by every app that embeds the chat. */
+export const SPANISH_LABELS: AliaChatLabels = {
+  clear: 'Borrar',
+  back: 'Volver',
+  share: 'Compartir',
+  more: 'Más',
+  chatActions: 'Acciones de la conversación',
+  addMenuGroup: 'Adjuntar',
+  addPhotos: 'Fotos',
+  addDocuments: 'Archivos',
+  startVoice: 'Iniciar llamada',
+  voiceEndingSoon: 'Queda un minuto de llamada',
+  composerMessage: 'Mensaje',
+  composerAddMenu: 'Añadir al chat',
+  composerModes: 'Potencia',
+  composerVoice: 'Dictar',
+  composerSend: 'Enviar mensaje',
+  composerStop: 'Detener la generación',
+  composerRemove: 'Quitar',
+  composerRetry: 'Reintentar',
+  composerUntitled: 'sin título',
+  dropHint: 'Suelta los archivos aquí para adjuntarlos',
+  dropUnavailable: 'Ahora mismo no se pueden adjuntar archivos',
+  greeting: 'Hola, ¿qué tienes en mente?',
+  copy: 'Copiar',
+  helpful: 'Respuesta útil',
+  unhelpful: 'Respuesta poco útil',
+  copied: 'Copiado',
+  edit: 'Editar',
+  save: 'Guardar',
+  cancel: 'Cancelar',
+  readAloud: 'Leer en voz alta',
+  stopReading: 'Dejar de leer',
+  planTitle: 'Este es mi plan',
+  reasoning: 'Razonamiento',
+  locale: 'es',
+  newChat: 'Nueva conversación',
+  recentConversations: 'Recientes',
+  sendFailed:
+    'No se pudo enviar el mensaje. Lo tienes de vuelta en el cuadro de texto, inténtalo otra vez.',
+  signInRequired: 'Inicia sesión para seguir conversando',
+  conversationSaveFailed: 'No se pudo guardar la conversación',
+  conversationDeleteFailed: 'No se pudo eliminar la conversación',
+  conversationCreateFailed: 'No se pudo crear la conversación',
+  conversationClearFailed: 'No se pudo borrar la conversación',
+  placeholder: (name) => `Pregúntale lo que quieras a ${name}`,
+  greetingNamed: (name) => `Hola ${name}, ¿qué tienes en mente?`,
+  fileReadFailed: (name) => `No se pudo leer ${name}: selecciona para reintentar`,
+  fileTooLarge: (name, limit) => `${name} supera ${limit} y no se ha adjuntado`,
+  fileEmpty: (name) => `${name} está vacío: no se pueden adjuntar carpetas`,
+  fileUnsupported: (name) => `No se puede enviar ${name} aquí: solo se admiten fotos`,
+  dictationRemaining: (seconds) => `Quedan ${seconds} s de dictado`,
+  thoughtFor: (seconds) => `Pensó durante ${seconds} segundos`,
+  attachmentNotSent: (name) => `No se envió ${name}: solo se pueden enviar fotos`,
+  attachmentUnreadable: (name) => `No se pudo leer ${name} y no se envió`,
+  voiceError: (code) => VOICE_ERRORS[code],
+  voiceEnded: (reason) => VOICE_ENDED[reason] ?? null,
+  voiceBlocked: (reason) => VOICE_BLOCKED[reason],
+  voiceControls: {
+    connecting: 'Conectando…',
+    reconnecting: 'Reconectando…',
+    connected: 'Conectado',
+    listening: 'Escuchando…',
+    muted: 'Silenciado',
+    thinking: 'Pensando…',
+    usingTool: 'Trabajando en ello…',
+    speaking: 'Hablando…',
+    mute: 'Silenciar',
+    unmute: 'Activar micrófono',
+    end: 'Colgar',
+  },
+  t: spanishCopy,
+};

package/src/lib/labels.tsx

@@ -1,4 +1,5 @@
 import { createContext, type ReactNode, useContext, useMemo } from 'react';
+import { SPANISH_LABELS } from './labels-es';
 import { VOICE_ERROR_MESSAGES, type VoiceErrorCode } from './speech-messages';
 import { englishCopy, type Translate } from './copy';
 import { VOICE_CONTROLS_LABELS, type VoiceControlsLabels } from './voice-controls-labels';
@@ -178,7 +179,7 @@ export const DEFAULT_LABELS: AliaChatLabels = {
   attachmentUnreadable: (name) => `${name} couldn't be read and wasn't sent`,
 };
 
-const LabelsContext = createContext<AliaChatLabels>(DEFAULT_LABELS);
+const LabelsContext = createContext<AliaChatLabels | null>(null);
 
 /** The chat's labels: the defaults, with whatever the host overrides. */
 export function AliaChatLabelsProvider({
@@ -191,10 +192,16 @@ export function AliaChatLabelsProvider({
   // Over whatever labels are already in reach, so a part that takes its own `labels` (the
   // composer) refines the chat's copy instead of resetting it to English.
   const inherited = useContext(LabelsContext);
-  const value = useMemo(() => ({ ...inherited, ...labels }), [inherited, labels]);
+  const value = useMemo(() => {
+    const locale = labels?.locale ?? inherited?.locale ?? 'en';
+    const language = locale.toLowerCase().split('-')[0];
+    const defaults = language === 'es' ? SPANISH_LABELS : DEFAULT_LABELS;
+    const parent = inherited?.locale.toLowerCase().split('-')[0] === language ? inherited : null;
+    return { ...defaults, ...parent, ...labels };
+  }, [inherited, labels]);
   return <LabelsContext.Provider value={value}>{children}</LabelsContext.Provider>;
 }
 
 export function useLabels(): AliaChatLabels {
-  return useContext(LabelsContext);
+  return useContext(LabelsContext) ?? DEFAULT_LABELS;
 }

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,