@yodaos-pkg/ink 0.10.0 → 0.11.0

package/index.d.ts

@@ -60,6 +60,8 @@ export interface CreateInkViewOptions {
   clearOnDestroy?: boolean;
   /** Callback fired after Ink reports a new measured content size. */
   onContentSizeChanged?: InkContentSizeChangedHandler | null;
+  /** Optional host-provided capability implementations bridged into the Ink runtime. */
+  hostCapabilities?: InkHostCapabilities | null;
   /** Optional wasm bootstrap overrides. */
   wasm?: InitInkOptions;
 }
@@ -273,6 +275,243 @@ export type InkClosedHandler = (context: InkClosedContext) => void;
 /** Callback invoked after the runtime reports a new measured content size. */
 export type InkContentSizeChangedHandler = (contentSize: InkContentSize) => void;
 
+/**
+ * Host-provided backend configuration returned from
+ * `hostCapabilities.languageModel.getConfig()`.
+ *
+ * The browser host owns this transport-level configuration. Ink uses it when
+ * `LanguageModel.create()` needs a default endpoint, protocol style, headers,
+ * or fallback model selection.
+ */
+export interface InkHostLanguageModelConfig {
+  /** Absolute request URL used for language-model inference requests. */
+  endpoint: string;
+  /** Optional fallback model used when the Ink app does not pass an explicit `model`. */
+  defaultModel?: string | null;
+  /** Provider protocol shape, for example `openai-chat-completions`. */
+  apiStyle: string;
+  /** Static host-owned headers merged into every inference request. */
+  headers?: Record<string, string>;
+  /** Whether Ink should also merge vendor headers resolved through OpenService. */
+  shareVendorHeaders?: boolean;
+  /** Optional environment key used when resolving shared vendor headers. */
+  vendorHeadersEnv?: string | null;
+}
+
+/**
+ * Normalized speech-synthesis request forwarded to `hostCapabilities.speech.speak()`.
+ *
+ * This matches the runtime-side speech synthesis request after the SDK has
+ * converted Rust IPC payloads into a browser-friendly camelCase object.
+ */
+export interface InkHostSpeechSynthesisRequest {
+  /** Text content to speak. */
+  text: string;
+  /** Preferred BCP-47 language tag, such as `en-US`. */
+  lang: string;
+  /** Voice pitch multiplier where `1` is the host default. */
+  pitch: number;
+  /** Speech rate multiplier where `1` is the host default. */
+  rate: number;
+  /** Optional host-specific voice identifier. */
+  voice?: string | null;
+  /** Output volume in the inclusive range `0..1`. */
+  volume: number;
+}
+
+/**
+ * Start request forwarded to `hostCapabilities.speech.startRecognition()`.
+ *
+ * The browser host should treat `targetId` and `sessionId` as stable routing
+ * identifiers and echo them back in later `speech.*` events dispatched through
+ * `hostCapabilitiesTarget`.
+ */
+export interface InkHostSpeechRecognitionRequest {
+  /** Runtime-generated event target identifier for the concrete recognition object. */
+  targetId: string;
+  /** Runtime-generated identifier for the recognition session being started. */
+  sessionId: string;
+  /** Optional BCP-47 language tag requested by the Ink app. */
+  lang?: string | null;
+  /** Whether the host should keep listening after a final result. */
+  continuous: boolean;
+  /** Whether interim recognition results should be surfaced before finalization. */
+  interimResults: boolean;
+  /** Maximum number of alternatives requested for each recognition result. */
+  maxAlternatives: number;
+}
+
+/**
+ * Control request forwarded to `hostCapabilities.speech.stopRecognition()` and
+ * `hostCapabilities.speech.abortRecognition()`.
+ */
+export interface InkHostSpeechRecognitionControlRequest {
+  /** Runtime-generated event target identifier for the concrete recognition object. */
+  targetId: string;
+  /** Identifier of the active recognition session being controlled. */
+  sessionId: string;
+}
+
+/**
+ * Start request shared by orientation and motion sensor capabilities.
+ *
+ * Hosts should echo `targetId` and `sessionId` back in later sensor events such
+ * as `*.activate`, `*.reading`, and `*.error`.
+ */
+export interface InkHostSensorStartRequest {
+  /** Runtime-generated event target identifier for the concrete sensor object. */
+  targetId: string;
+  /** Identifier of the sensor sampling session being started. */
+  sessionId: string;
+  /** Optional preferred sampling frequency in hertz. */
+  frequency?: number | null;
+}
+
+/**
+ * Stop request shared by orientation and motion sensor capabilities.
+ */
+export interface InkHostSensorControlRequest {
+  /** Runtime-generated event target identifier for the concrete sensor object. */
+  targetId: string;
+  /** Identifier of the sensor sampling session being stopped. */
+  sessionId: string;
+}
+
+/**
+ * Host-controlled audio recording options passed into
+ * `hostCapabilities.media.startAudioRecording()`.
+ */
+export interface InkHostAudioRecordingOptions {
+  /** Requested sample rate in hertz. */
+  sampleRate?: number;
+  /** Requested number of audio channels. */
+  numberOfChannels?: number;
+  /** Requested sample or container format, for example `pcm`. */
+  format?: string;
+}
+
+/**
+ * Start request forwarded to `hostCapabilities.media.startAudioRecording()`.
+ */
+export interface InkHostStartAudioRecordingRequest {
+  /** Runtime-generated identifier for the recorder target receiving follow-up events. */
+  targetId: string;
+  /** Host recording options requested by the Ink app. */
+  options: InkHostAudioRecordingOptions;
+}
+
+/**
+ * Photo capture options forwarded to `hostCapabilities.media.takePhoto()`.
+ */
+export interface InkHostTakePhotoOptions {
+  /** Requested quality hint, typically `high`, `normal`, or `low`. */
+  quality: string;
+}
+
+/**
+ * Host photo result returned from `hostCapabilities.media.takePhoto()`.
+ */
+export interface InkHostTakePhotoResult {
+  /** Binary encoded image payload returned by the host camera implementation. */
+  data: Uint8Array | ArrayBuffer | ArrayBufferView;
+  /** MIME type describing the encoded image bytes, for example `image/jpeg`. */
+  mimeType: string;
+}
+
+/**
+ * Shared environment request used by OpenService and LanguageModel helpers.
+ */
+export interface InkHostEnvRequest {
+  /** Optional environment selector used to resolve host-specific configuration. */
+  env?: string | null;
+}
+
+/**
+ * Browser-host capability registry consumed by `InkView.setHostCapabilities()`.
+ *
+ * Each capability group is optional. When a method is omitted, requests for
+ * that method fail fast with a host-side "not configured" error.
+ *
+ * Request/response hooks:
+ * - synchronous or asynchronous return values are both supported
+ * - long-lived asynchronous updates should be pushed separately through
+ *   `view.hostCapabilitiesTarget` or `view.getHostCapabilitiesTarget()`
+ * - session-scoped events should preserve the `targetId` and `sessionId`
+ *   supplied in the originating request
+ */
+export interface InkHostCapabilities {
+  /** Host implementations for speech synthesis and speech recognition entry points. */
+  speech?: {
+    /** Speaks text through a host-provided speech synthesis backend. */
+    speak?(request: InkHostSpeechSynthesisRequest): void | Promise<void>;
+    /** Starts a host-provided speech recognition session. */
+    startRecognition?(request: InkHostSpeechRecognitionRequest): void | Promise<void>;
+    /** Requests graceful completion of an active recognition session. */
+    stopRecognition?(request: InkHostSpeechRecognitionControlRequest): void | Promise<void>;
+    /** Requests immediate termination of an active recognition session. */
+    abortRecognition?(request: InkHostSpeechRecognitionControlRequest): void | Promise<void>;
+  };
+  /** Host implementation of the AbsoluteOrientationSensor-compatible start/stop flow. */
+  absoluteOrientation?: {
+    /** Starts an absolute-orientation session and later emits `absoluteOrientation.*` events. */
+    start?(request: InkHostSensorStartRequest): void | Promise<void>;
+    /** Stops a previously started absolute-orientation session. */
+    stop?(request: InkHostSensorControlRequest): void | Promise<void>;
+  };
+  /** Host implementation of the Accelerometer-compatible start/stop flow. */
+  accelerometer?: {
+    /** Starts an accelerometer session and later emits `accelerometer.*` events. */
+    start?(request: InkHostSensorStartRequest): void | Promise<void>;
+    /** Stops a previously started accelerometer session. */
+    stop?(request: InkHostSensorControlRequest): void | Promise<void>;
+  };
+  /** Host implementation of the Gyroscope-compatible start/stop flow. */
+  gyroscope?: {
+    /** Starts a gyroscope session and later emits `gyroscope.*` events. */
+    start?(request: InkHostSensorStartRequest): void | Promise<void>;
+    /** Stops a previously started gyroscope session. */
+    stop?(request: InkHostSensorControlRequest): void | Promise<void>;
+  };
+  /** Host implementation of the Magnetometer-compatible start/stop flow. */
+  magnetometer?: {
+    /** Starts a magnetometer session and later emits `magnetometer.*` events. */
+    start?(request: InkHostSensorStartRequest): void | Promise<void>;
+    /** Stops a previously started magnetometer session. */
+    stop?(request: InkHostSensorControlRequest): void | Promise<void>;
+  };
+  /** Host implementations for recording audio and capturing still photos. */
+  media?: {
+    /** Starts audio recording and later emits `media.audioRecording*` events. */
+    startAudioRecording?(request: InkHostStartAudioRecordingRequest): void | Promise<void>;
+    /** Stops the currently active audio recording session. */
+    stopAudioRecording?(request: Record<string, never>): void | Promise<void>;
+    /** Pauses the currently active audio recording session. */
+    pauseAudioRecording?(request: Record<string, never>): void | Promise<void>;
+    /** Resumes a previously paused audio recording session. */
+    resumeAudioRecording?(request: Record<string, never>): void | Promise<void>;
+    /** Captures one photo and returns encoded image bytes plus their MIME type. */
+    takePhoto?(
+      request: InkHostTakePhotoOptions,
+    ): InkHostTakePhotoResult | Promise<InkHostTakePhotoResult>;
+  };
+  /** Host implementations for OpenService-backed configuration lookups. */
+  openService?: {
+    /** Resolves the OpenService manifest visible to the Ink runtime. */
+    getManifest?(request: InkHostEnvRequest): unknown | Promise<unknown>;
+    /** Resolves host-owned vendor headers that Ink may merge into outbound requests. */
+    getVendorHeaders?(
+      request: InkHostEnvRequest,
+    ): Record<string, string> | Promise<Record<string, string>>;
+  };
+  /** Host implementation for default LanguageModel backend discovery. */
+  languageModel?: {
+    /** Returns the transport configuration used when Ink initializes `LanguageModel.create()`. */
+    getConfig?(
+      request: InkHostEnvRequest,
+    ): InkHostLanguageModelConfig | Promise<InkHostLanguageModelConfig>;
+  };
+}
+
 /**
  * Initializes the browser SDK and ensures the wasm runtime is ready to create
  * views. Most applications can use {@link InkView.create} or
@@ -474,6 +713,15 @@ export declare class InkView {
    */
   notifyUserInteraction(): this;
 
+  /** Registers host-provided implementations for browser-side IPC-backed capabilities. */
+  setHostCapabilities(capabilities: InkHostCapabilities | null): this;
+
+  /** Returns the EventTarget used to push asynchronous host capability events back into Ink. */
+  getHostCapabilitiesTarget(): EventTarget;
+
+  /** Property-style access to the host capability EventTarget. */
+  readonly hostCapabilitiesTarget: EventTarget;
+
   /** Forwards a pointer-like event directly into the current Ink view. */
   dispatchPointer(
     eventType: string,

package/index.js

@@ -412,32 +412,440 @@ function isResizeOptions(value) {
   return value != null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function normalizeHostLanguageModelConfig(config) {
-  if (config == null) {
-    return null;
+function normalizeStringMap(value, optionName) {
+  if (value == null) {
+    return {};
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError(`\`${optionName}\` must be a plain object when provided.`);
   }
-  if (typeof config !== 'object') {
-    throw new TypeError('`config` must be an object or null.');
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entryValue]) => [String(key), String(entryValue)]),
+  );
+}
+
+function normalizeHostLanguageModelConfig(config) {
+  if (config == null || typeof config !== 'object' || Array.isArray(config)) {
+    throw new TypeError('`languageModel.getConfig()` must resolve to a config object.');
   }
 
-  const headers =
-    config.headers && typeof config.headers === 'object' && !Array.isArray(config.headers)
-      ? Object.fromEntries(
-          Object.entries(config.headers).map(([key, value]) => [String(key), String(value)]),
-        )
-      : {};
+  const endpoint = String(config.endpoint || '').trim();
+  const apiStyle = String(config.apiStyle || '').trim();
+  if (!endpoint) {
+    throw new TypeError('`languageModel.getConfig()` must provide a non-empty `endpoint`.');
+  }
+  if (!apiStyle) {
+    throw new TypeError('`languageModel.getConfig()` must provide a non-empty `apiStyle`.');
+  }
 
   return {
-    endpoint: String(config.endpoint || '').trim(),
-    defaultModel: config.defaultModel == null ? null : String(config.defaultModel).trim(),
-    apiStyle: String(config.apiStyle || '').trim(),
-    headers,
+    endpoint,
+    defaultModel: config.defaultModel == null ? null : String(config.defaultModel).trim() || null,
+    apiStyle,
+    headers: normalizeStringMap(config.headers, 'languageModel.headers'),
     shareVendorHeaders: Boolean(config.shareVendorHeaders),
     vendorHeadersEnv:
-      config.vendorHeadersEnv == null ? null : String(config.vendorHeadersEnv).trim(),
+      config.vendorHeadersEnv == null ? null : String(config.vendorHeadersEnv).trim() || null,
   };
 }
 
+function ensureHostCapabilitiesObject(value) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('`hostCapabilities` must be an object or null.');
+  }
+  return value;
+}
+
+function parseHostCapabilityRequest(requestJson, capability, method) {
+  if (typeof requestJson !== 'string') {
+    throw new TypeError(`Host capability ${capability}.${method} requires a JSON request string.`);
+  }
+  try {
+    return JSON.parse(requestJson);
+  } catch {
+    throw new Error(`Host capability ${capability}.${method} received invalid request JSON.`);
+  }
+}
+
+function serializeIpcResponseData(responseData) {
+  const json = JSON.stringify(responseData);
+  if (typeof json !== 'string') {
+    throw new TypeError('Host capability handler must return JSON-serializable response data.');
+  }
+  return json;
+}
+
+function createSuccessResponseData() {
+  return { type: 'Success' };
+}
+
+function serializeSuccessResponse() {
+  return serializeIpcResponseData(createSuccessResponseData());
+}
+
+function serializeOpenServiceManifestResponse(result) {
+  return serializeIpcResponseData({
+    type: 'OpenService',
+    data: {
+      type: 'Manifest',
+      data: result,
+    },
+  });
+}
+
+function serializeOpenServiceVendorHeadersResponse(result) {
+  return serializeIpcResponseData({
+    type: 'OpenService',
+    data: {
+      type: 'VendorHeaders',
+      data: normalizeStringMap(result, 'openService.getVendorHeaders() result'),
+    },
+  });
+}
+
+function normalizePhotoResult(result) {
+  if (result == null || typeof result !== 'object' || Array.isArray(result)) {
+    throw new TypeError(
+      '`media.takePhoto()` must resolve to an object with `data` and `mimeType`.',
+    );
+  }
+  const mimeType = String(result.mimeType || '').trim();
+  if (!mimeType) {
+    throw new TypeError('`media.takePhoto()` must provide a non-empty `mimeType`.');
+  }
+  const data = cloneUint8Array(result.data ?? result.bytes ?? result.buffer);
+  if (!data) {
+    throw new TypeError(
+      '`media.takePhoto()` must provide binary `data` as Uint8Array, ArrayBuffer, or TypedArray.',
+    );
+  }
+  return { data, mimeType };
+}
+
+function serializeTakePhotoResponse(result) {
+  const photo = normalizePhotoResult(result);
+  return serializeIpcResponseData({
+    type: 'Media',
+    data: {
+      type: 'TakePhotoResult',
+      data: [Array.from(photo.data), photo.mimeType],
+    },
+  });
+}
+
+function serializeLanguageModelConfigResponse(result) {
+  return serializeIpcResponseData({
+    type: 'LanguageModel',
+    data: {
+      type: 'Config',
+      data: normalizeHostLanguageModelConfig(result),
+    },
+  });
+}
+
+const HOST_CAPABILITY_SERIALIZERS = {
+  speech: {
+    speak: () => serializeSuccessResponse(),
+    startRecognition: () => serializeSuccessResponse(),
+    stopRecognition: () => serializeSuccessResponse(),
+    abortRecognition: () => serializeSuccessResponse(),
+  },
+  absoluteOrientation: {
+    start: () => serializeSuccessResponse(),
+    stop: () => serializeSuccessResponse(),
+  },
+  accelerometer: {
+    start: () => serializeSuccessResponse(),
+    stop: () => serializeSuccessResponse(),
+  },
+  gyroscope: {
+    start: () => serializeSuccessResponse(),
+    stop: () => serializeSuccessResponse(),
+  },
+  magnetometer: {
+    start: () => serializeSuccessResponse(),
+    stop: () => serializeSuccessResponse(),
+  },
+  media: {
+    startAudioRecording: () => serializeSuccessResponse(),
+    stopAudioRecording: () => serializeSuccessResponse(),
+    pauseAudioRecording: () => serializeSuccessResponse(),
+    resumeAudioRecording: () => serializeSuccessResponse(),
+    takePhoto: (result) => serializeTakePhotoResponse(result),
+  },
+  openService: {
+    getManifest: (result) => serializeOpenServiceManifestResponse(result),
+    getVendorHeaders: (result) => serializeOpenServiceVendorHeadersResponse(result),
+  },
+  languageModel: {
+    getConfig: (result) => serializeLanguageModelConfigResponse(result),
+  },
+};
+
+function normalizeHostCapabilities(capabilities) {
+  const normalizedCapabilities = ensureHostCapabilitiesObject(capabilities);
+  if (!normalizedCapabilities) {
+    return null;
+  }
+
+  return {
+    async handleRequest(capability, method, requestJson) {
+      const serializer = HOST_CAPABILITY_SERIALIZERS[capability]?.[method];
+      const hook = normalizedCapabilities?.[capability]?.[method];
+      if (typeof serializer !== 'function' || typeof hook !== 'function') {
+        throw new Error(
+          `Host capability ${String(capability)}.${String(method)} is not configured on Web host`,
+        );
+      }
+      const request = parseHostCapabilityRequest(requestJson, capability, method);
+      const result = await hook(request);
+      return serializer(result);
+    },
+  };
+}
+
+function createIpcEvent(type, target, detail) {
+  return {
+    type,
+    target: target || null,
+    bubbles: false,
+    cancelable: false,
+    default_prevented: false,
+    propagation_stopped: false,
+    detail,
+  };
+}
+
+function requireDetailObject(detail, eventType) {
+  if (detail == null || typeof detail !== 'object' || Array.isArray(detail)) {
+    throw new TypeError(
+      `Host capability event \`${eventType}\` requires an object detail payload.`,
+    );
+  }
+  return detail;
+}
+
+function requireStringField(value, fieldName, eventType) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new TypeError(
+      `Host capability event \`${eventType}\` requires a non-empty \`${fieldName}\`.`,
+    );
+  }
+  return value.trim();
+}
+
+function buildSpeechSessionEvent(eventType, variant, detail) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  return createIpcEvent(eventType, targetId, {
+    type: 'Speech',
+    data: {
+      type: variant,
+      data: { sessionId },
+    },
+  });
+}
+
+function buildSpeechResultEvent(eventType, detail) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  const alternatives = Array.isArray(payload.alternatives)
+    ? payload.alternatives.map((alternative) => ({
+        transcript: String(alternative?.transcript || ''),
+        confidence: Number(alternative?.confidence || 0),
+      }))
+    : [];
+  return createIpcEvent(eventType, targetId, {
+    type: 'Speech',
+    data: {
+      type: 'Result',
+      data: {
+        sessionId,
+        resultIndex: Math.max(0, Math.trunc(Number(payload.resultIndex) || 0)),
+        isFinal: Boolean(payload.isFinal),
+        alternatives,
+      },
+    },
+  });
+}
+
+function buildSpeechErrorEvent(eventType, detail) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  return createIpcEvent(eventType, targetId, {
+    type: 'Speech',
+    data: {
+      type: 'Error',
+      data: {
+        sessionId,
+        error: String(payload.error || ''),
+        message: String(payload.message || ''),
+      },
+    },
+  });
+}
+
+function buildSensorSessionEvent(category, eventType, variant, detail) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  return createIpcEvent(eventType, targetId, {
+    type: category,
+    data: {
+      type: variant,
+      data: { sessionId },
+    },
+  });
+}
+
+function buildSensorReadingEvent(category, eventType, detail, valueFields) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  const data = {
+    sessionId,
+    timestamp: Number(payload.timestamp || 0),
+  };
+  for (const fieldName of valueFields) {
+    data[fieldName] = Number(payload[fieldName] || 0);
+  }
+  return createIpcEvent(eventType, targetId, {
+    type: category,
+    data: {
+      type: 'Reading',
+      data,
+    },
+  });
+}
+
+function buildSensorErrorEvent(category, eventType, detail) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  const sessionId = requireStringField(payload.sessionId, 'sessionId', eventType);
+  return createIpcEvent(eventType, targetId, {
+    type: category,
+    data: {
+      type: 'Error',
+      data: {
+        sessionId,
+        error: String(payload.error || ''),
+        message: String(payload.message || ''),
+      },
+    },
+  });
+}
+
+function buildMediaRecordingEvent(eventType, variant, detail, data) {
+  const payload = requireDetailObject(detail, eventType);
+  const targetId = requireStringField(payload.targetId, 'targetId', eventType);
+  return createIpcEvent(eventType, targetId, {
+    type: 'Media',
+    data:
+      data == null
+        ? { type: variant }
+        : {
+            type: variant,
+            data,
+          },
+  });
+}
+
+const HOST_CAPABILITY_EVENT_BUILDERS = {
+  'speech.start': (detail) => buildSpeechSessionEvent('speech.start', 'Start', detail),
+  'speech.audiostart': (detail) =>
+    buildSpeechSessionEvent('speech.audiostart', 'AudioStart', detail),
+  'speech.soundstart': (detail) =>
+    buildSpeechSessionEvent('speech.soundstart', 'SoundStart', detail),
+  'speech.speechstart': (detail) =>
+    buildSpeechSessionEvent('speech.speechstart', 'SpeechStart', detail),
+  'speech.result': (detail) => buildSpeechResultEvent('speech.result', detail),
+  'speech.nomatch': (detail) => buildSpeechSessionEvent('speech.nomatch', 'NoMatch', detail),
+  'speech.error': (detail) => buildSpeechErrorEvent('speech.error', detail),
+  'speech.speechend': (detail) => buildSpeechSessionEvent('speech.speechend', 'SpeechEnd', detail),
+  'speech.soundend': (detail) => buildSpeechSessionEvent('speech.soundend', 'SoundEnd', detail),
+  'speech.audioend': (detail) => buildSpeechSessionEvent('speech.audioend', 'AudioEnd', detail),
+  'speech.end': (detail) => buildSpeechSessionEvent('speech.end', 'End', detail),
+  'absoluteOrientation.activate': (detail) =>
+    buildSensorSessionEvent(
+      'AbsoluteOrientation',
+      'absoluteOrientation.activate',
+      'Activate',
+      detail,
+    ),
+  'absoluteOrientation.reading': (detail) =>
+    buildSensorReadingEvent('AbsoluteOrientation', 'absoluteOrientation.reading', detail, [
+      'x',
+      'y',
+      'z',
+      'w',
+    ]),
+  'absoluteOrientation.error': (detail) =>
+    buildSensorErrorEvent('AbsoluteOrientation', 'absoluteOrientation.error', detail),
+  'accelerometer.activate': (detail) =>
+    buildSensorSessionEvent('Accelerometer', 'accelerometer.activate', 'Activate', detail),
+  'accelerometer.reading': (detail) =>
+    buildSensorReadingEvent('Accelerometer', 'accelerometer.reading', detail, ['x', 'y', 'z']),
+  'accelerometer.error': (detail) =>
+    buildSensorErrorEvent('Accelerometer', 'accelerometer.error', detail),
+  'gyroscope.activate': (detail) =>
+    buildSensorSessionEvent('Gyroscope', 'gyroscope.activate', 'Activate', detail),
+  'gyroscope.reading': (detail) =>
+    buildSensorReadingEvent('Gyroscope', 'gyroscope.reading', detail, ['x', 'y', 'z']),
+  'gyroscope.error': (detail) => buildSensorErrorEvent('Gyroscope', 'gyroscope.error', detail),
+  'magnetometer.activate': (detail) =>
+    buildSensorSessionEvent('Magnetometer', 'magnetometer.activate', 'Activate', detail),
+  'magnetometer.reading': (detail) =>
+    buildSensorReadingEvent('Magnetometer', 'magnetometer.reading', detail, ['x', 'y', 'z']),
+  'magnetometer.error': (detail) =>
+    buildSensorErrorEvent('Magnetometer', 'magnetometer.error', detail),
+  'media.audioRecordingStarted': (detail) =>
+    buildMediaRecordingEvent('media', 'AudioRecordingStarted', detail),
+  'media.audioRecordingStopped': (detail) => {
+    const payload = requireDetailObject(detail, 'media.audioRecordingStopped');
+    return buildMediaRecordingEvent(
+      'media',
+      'AudioRecordingStopped',
+      payload,
+      String(payload.path || ''),
+    );
+  },
+  'media.audioRecordingPaused': (detail) =>
+    buildMediaRecordingEvent('media', 'AudioRecordingPaused', detail),
+  'media.audioRecordingResumed': (detail) =>
+    buildMediaRecordingEvent('media', 'AudioRecordingResumed', detail),
+  'media.audioFrameRecorded': (detail) => {
+    const payload = requireDetailObject(detail, 'media.audioFrameRecorded');
+    const bytes = cloneUint8Array(payload.data ?? payload.bytes ?? payload.buffer);
+    if (!bytes) {
+      throw new TypeError(
+        'Host capability event `media.audioFrameRecorded` requires binary `data`.',
+      );
+    }
+    return buildMediaRecordingEvent('media', 'AudioFrameRecorded', payload, Array.from(bytes));
+  },
+  'media.audioRecordingError': (detail) => {
+    const payload = requireDetailObject(detail, 'media.audioRecordingError');
+    return buildMediaRecordingEvent(
+      'media',
+      'AudioRecordingError',
+      payload,
+      String(payload.message || ''),
+    );
+  },
+  'media.audioRecordingInterruptionBegin': (detail) =>
+    buildMediaRecordingEvent('media', 'AudioRecordingInterruptionBegin', detail),
+  'media.audioRecordingInterruptionEnd': (detail) =>
+    buildMediaRecordingEvent('media', 'AudioRecordingInterruptionEnd', detail),
+};
+
+const HOST_CAPABILITY_EVENT_TYPES = Object.keys(HOST_CAPABILITY_EVENT_BUILDERS);
+
 class InkHostMessageStream {
   #rawStream;
   #requestRender;
@@ -553,6 +961,7 @@ export class InkView {
   #scaleFactor;
   #surfaceBinding;
   #onContentSizeChanged;
+  #hostCapabilitiesTarget;
 
   constructor(rawView, options = {}) {
     this.#rawView = rawView;
@@ -575,7 +984,10 @@ export class InkView {
     this.#scaleFactor = normalizeScaleFactor(options.scaleFactor);
     this.#surfaceBinding = null;
     this.#onContentSizeChanged = null;
+    this.#hostCapabilitiesTarget = new EventTarget();
+    this.#bindHostCapabilityEvents();
     this.onContentSizeChanged = options.onContentSizeChanged || null;
+    this.setHostCapabilities(options.hostCapabilities || null);
   }
 
   #clearSurfaceContents() {
@@ -890,6 +1302,27 @@ export class InkView {
     return true;
   }
 
+  #bindHostCapabilityEvents() {
+    for (const eventType of HOST_CAPABILITY_EVENT_TYPES) {
+      this.#hostCapabilitiesTarget.addEventListener(eventType, (event) => {
+        if (this.#destroyed || typeof this.#rawView.dispatchHostCapabilityEvent !== 'function') {
+          return;
+        }
+        const buildIpcEvent = HOST_CAPABILITY_EVENT_BUILDERS[eventType];
+        if (typeof buildIpcEvent !== 'function') {
+          return;
+        }
+        try {
+          const ipcEvent = buildIpcEvent(event?.detail);
+          this.#rawView.dispatchHostCapabilityEvent(JSON.stringify(ipcEvent));
+          this.requestRender();
+        } catch (error) {
+          console.error(`InkView failed to bridge host capability event \`${eventType}\`.`, error);
+        }
+      });
+    }
+  }
+
   attachSurface(surface) {
     const normalizedSurface = normalizeSurfaceDescriptor(surface);
     if (!normalizedSurface) {
@@ -937,6 +1370,9 @@ export class InkView {
     if (typeof this.#rawView.clearSurface === 'function') {
       this.#rawView.clearSurface();
     }
+    if (typeof this.#rawView.setHostCapabilities === 'function') {
+      this.#rawView.setHostCapabilities(null);
+    }
     this.#surfaceBinding = null;
     this.#surface = null;
     this.#canvas = null;
@@ -1247,17 +1683,22 @@ export class InkView {
     return this;
   }
 
-  setHostLanguageModelConfig(config) {
-    if (typeof this.#rawView.setLanguageModelConfig !== 'function') {
-      return this;
+  setHostCapabilities(capabilities) {
+    const normalizedCapabilities = normalizeHostCapabilities(capabilities);
+    if (typeof this.#rawView.setHostCapabilities === 'function') {
+      this.#rawView.setHostCapabilities(normalizedCapabilities);
     }
-    const normalizedConfig = normalizeHostLanguageModelConfig(config);
-    this.#rawView.setLanguageModelConfig(
-      normalizedConfig == null ? null : JSON.stringify(normalizedConfig),
-    );
     return this;
   }
 
+  getHostCapabilitiesTarget() {
+    return this.#hostCapabilitiesTarget;
+  }
+
+  get hostCapabilitiesTarget() {
+    return this.#hostCapabilitiesTarget;
+  }
+
   dispatchPointer(eventType, x, y, id = 0, button = 0, deltaX = 0, deltaY = 0) {
     this.#rawView.dispatchPointer(eventType, x, y, id, button, deltaX, deltaY);
     this.requestRender();

package/package.json

@@ -10,7 +10,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.com/"
   },
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/pkg/ink_web.d.ts

@@ -24,6 +24,7 @@ export class InkWebView {
     currentContentHeight(): number;
     currentContentWidth(): number;
     destroy(): void;
+    dispatchHostCapabilityEvent(event_json: string): void;
     dispatchInput(event_type: string, code: string, timestamp: number): void;
     dispatchMessageEvent(payload_json: string, origin: string, last_event_id: string): void;
     dispatchPointer(event_type: string, x: number, y: number, id: number, button: number, delta_x: number, delta_y: number): void;
@@ -36,15 +37,15 @@ export class InkWebView {
     openBundle(app_id: string, files: Map<any, any>, initial_page?: string | null, query_json?: string | null): void;
     render(): boolean;
     resolveCloseRequested(allow: boolean): void;
+    setHostCapabilities(capabilities: any): void;
     setInteractive(interactive: boolean): void;
-    setLanguageModelConfig(config_json?: string | null): void;
     setLayoutMode(layout_mode: string): void;
     setViewport(width: number, height: number, scale_factor: number, reset_scroll?: boolean | null): void;
 }
 
 export function get_version(): string;
 
-export function main(): void;
+export function start(): void;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
@@ -67,6 +68,7 @@ export interface InitOutput {
     readonly inkwebview_currentContentHeight: (a: number) => number;
     readonly inkwebview_currentContentWidth: (a: number) => number;
     readonly inkwebview_destroy: (a: number) => void;
+    readonly inkwebview_dispatchHostCapabilityEvent: (a: number, b: number, c: number, d: number) => void;
     readonly inkwebview_dispatchInput: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly inkwebview_dispatchMessageEvent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly inkwebview_dispatchPointer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
@@ -79,16 +81,16 @@ export interface InitOutput {
     readonly inkwebview_openBundle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly inkwebview_render: (a: number, b: number) => void;
     readonly inkwebview_resolveCloseRequested: (a: number, b: number) => void;
+    readonly inkwebview_setHostCapabilities: (a: number, b: number, c: number) => void;
     readonly inkwebview_setInteractive: (a: number, b: number) => void;
-    readonly inkwebview_setLanguageModelConfig: (a: number, b: number, c: number, d: number) => void;
     readonly inkwebview_setLayoutMode: (a: number, b: number, c: number) => void;
     readonly inkwebview_setViewport: (a: number, b: number, c: number, d: number, e: number) => void;
-    readonly main: () => void;
-    readonly __wasm_bindgen_func_elem_9822: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_14048: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_9965: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_14049: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_9963: (a: number, b: number) => void;
+    readonly start: () => void;
+    readonly __wasm_bindgen_func_elem_10696: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_14706: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_10674: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_14707: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_10675: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/pkg/ink_web.js

@@ -164,6 +164,24 @@ export class InkWebView {
     destroy() {
         wasm.inkwebview_destroy(this.__wbg_ptr);
     }
+    /**
+     * @param {string} event_json
+     */
+    dispatchHostCapabilityEvent(event_json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(event_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.inkwebview_dispatchHostCapabilityEvent(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {string} event_type
      * @param {string} code
@@ -346,20 +364,12 @@ export class InkWebView {
         wasm.inkwebview_resolveCloseRequested(this.__wbg_ptr, allow);
     }
     /**
-     * @param {boolean} interactive
-     */
-    setInteractive(interactive) {
-        wasm.inkwebview_setInteractive(this.__wbg_ptr, interactive);
-    }
-    /**
-     * @param {string | null} [config_json]
+     * @param {any} capabilities
      */
-    setLanguageModelConfig(config_json) {
+    setHostCapabilities(capabilities) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            var ptr0 = isLikeNone(config_json) ? 0 : passStringToWasm0(config_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            var len0 = WASM_VECTOR_LEN;
-            wasm.inkwebview_setLanguageModelConfig(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.inkwebview_setHostCapabilities(retptr, this.__wbg_ptr, addHeapObject(capabilities));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             if (r1) {
@@ -369,6 +379,12 @@ export class InkWebView {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @param {boolean} interactive
+     */
+    setInteractive(interactive) {
+        wasm.inkwebview_setInteractive(this.__wbg_ptr, interactive);
+    }
     /**
      * @param {string} layout_mode
      */
@@ -409,8 +425,8 @@ export function get_version() {
     }
 }
 
-export function main() {
-    wasm.main();
+export function start() {
+    wasm.start();
 }
 import * as import1 from "../env.js"
 import * as import2 from "../env.js"
@@ -1217,28 +1233,28 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2633, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2621, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9822, __wasm_bindgen_func_elem_9965);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2675, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2678, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_10696, __wasm_bindgen_func_elem_10674);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2633, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2621, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9822, __wasm_bindgen_func_elem_9965);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2675, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2678, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_10696, __wasm_bindgen_func_elem_10674);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2633, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2621, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9822, __wasm_bindgen_func_elem_9965);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2675, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2678, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_10696, __wasm_bindgen_func_elem_10674);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2633, function: Function { arguments: [], shim_idx: 2634, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9822, __wasm_bindgen_func_elem_9963);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2675, function: Function { arguments: [], shim_idx: 2676, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_10696, __wasm_bindgen_func_elem_10675);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3529, function: Function { arguments: [Externref], shim_idx: 3530, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_14048, __wasm_bindgen_func_elem_14049);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3626, function: Function { arguments: [Externref], shim_idx: 3627, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_14706, __wasm_bindgen_func_elem_14707);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0) {
@@ -1295,16 +1311,16 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_9963(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_9963(arg0, arg1);
+function __wasm_bindgen_func_elem_10675(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_10675(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_9965(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_9965(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_10674(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_10674(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_14049(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_14049(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_14707(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_14707(arg0, arg1, addHeapObject(arg2));
 }
 
 

package/pkg/ink_web_bg.wasm.d.ts

@@ -18,6 +18,7 @@ export const inkwebview_currentClosedSource: (a: number, b: number) => void;
 export const inkwebview_currentContentHeight: (a: number) => number;
 export const inkwebview_currentContentWidth: (a: number) => number;
 export const inkwebview_destroy: (a: number) => void;
+export const inkwebview_dispatchHostCapabilityEvent: (a: number, b: number, c: number, d: number) => void;
 export const inkwebview_dispatchInput: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const inkwebview_dispatchMessageEvent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const inkwebview_dispatchPointer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
@@ -30,16 +31,16 @@ export const inkwebview_open: (a: number, b: number, c: number, d: number, e: nu
 export const inkwebview_openBundle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const inkwebview_render: (a: number, b: number) => void;
 export const inkwebview_resolveCloseRequested: (a: number, b: number) => void;
+export const inkwebview_setHostCapabilities: (a: number, b: number, c: number) => void;
 export const inkwebview_setInteractive: (a: number, b: number) => void;
-export const inkwebview_setLanguageModelConfig: (a: number, b: number, c: number, d: number) => void;
 export const inkwebview_setLayoutMode: (a: number, b: number, c: number) => void;
 export const inkwebview_setViewport: (a: number, b: number, c: number, d: number, e: number) => void;
-export const main: () => void;
-export const __wasm_bindgen_func_elem_9822: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_14048: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_9965: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_14049: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_9963: (a: number, b: number) => void;
+export const start: () => void;
+export const __wasm_bindgen_func_elem_10696: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_14706: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_10674: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_14707: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_10675: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;