@dialt/sdk 0.23.0

package/README.md

@@ -0,0 +1,319 @@
+# @dialt/sdk
+
+The browser SDK for the [Dialt realtime voice API](https://dialt.com/docs/api/) -
+the simplest way to build a realtime voice experience on the web. It owns microphone capture, echo
+cancellation, streaming playback, interruptions and reconnects; Dialt runs the conversation loop.
+
+```sh
+npm install @dialt/sdk
+```
+
+Keep your persistent `ck_…` API key on your backend. Exchange it for a scoped browser credential
+with `POST /api/v1/session-keys`, then connect from a user gesture:
+
+```js
+import { ConverseClient } from '@dialt/sdk';
+
+const credential = await fetch('/voice/session', {
+  method: 'POST',
+  credentials: 'same-origin',
+}).then((response) => {
+  if (!response.ok) throw new Error(`Voice credential failed: ${response.status}`);
+  return response.json();
+});
+
+const client = new ConverseClient({
+  url: 'wss://dialt.com/ws',
+  sessionId: credential.session_id,
+  apiKey: credential.api_key,
+  mode: { kind: 'converse' },
+});
+
+startButton.addEventListener('click', async () => {
+  await client.unlockAudio();
+  await client.connect();
+  await client.startMic();
+});
+```
+
+`startMic()` resolves only after the AudioWorklet delivers an actual audio frame. A frame containing
+all zero samples is valid silence; only receiving no frames is a stalled capture. The SDK waits a
+bounded period, fully releases the track, worklet, and `AudioContext`, then reacquires once. If the
+replacement also stalls, the promise rejects with `error.code === 'capture_stalled'` and
+`error.retryable === false`.
+
+Render capture status from the lifecycle events; do not add another retry or a timer that treats an
+opened device as ready:
+
+```js
+client.addEventListener('warming_up', () => showMicStatus('Preparing microphone…'));
+client.addEventListener('recovering', ({ detail }) => {
+  showMicStatus(detail.code === 'capture_stalled'
+    ? 'Reconnecting microphone…'
+    : 'Updating microphone…');
+});
+client.addEventListener('listening', () => showMicStatus('Listening'));
+client.addEventListener('failed', ({ detail }) => {
+  showMicError(detail.code, detail.error);
+});
+```
+
+`warming_up`, `listening`, `recovering`, and `failed` are emitted as typed events and through the
+catch-all `event` listener. `startMic()` accepts `deviceId`; the constructor accepts
+`inputDeviceId` and `captureStartupTimeoutMs` (default 2000 ms). Device management is generic:
+
+```js
+const inputs = await client.getInputDevices();
+await client.setInputDevice(inputs[0].deviceId); // restarts an active capture safely
+
+client.addEventListener('devices_changed', ({ detail }) => {
+  renderInputPicker(detail.devices, detail.device_id);
+});
+client.addEventListener('input_device_changed', ({ detail }) => {
+  selectInput(detail.device_id); // null means follow the system default
+});
+```
+
+The SDK listens for `navigator.mediaDevices.devicechange` while its microphone is active. It
+restarts capture when the selected input disappears or the system-default input changes, and emits
+the refreshed audio-input list. Call `setInputDevice(null)` to return to the system default.
+`stopMic()` removes the listener and is a cancellation barrier: when it resolves, even an earlier
+non-abortable `getUserMedia()` request has settled and any late track has been released.
+
+A `silent_mic` event means the server has received sustained digital silence or an unusually
+low startup signal. Treat it as a nonfatal warning: keep the session live while prompting the
+user to check the selected input, hardware mute, and browser and operating-system permissions.
+The event includes `reason`, `duration_ms`, and the observed PCM16 `peak`.
+
+### Browser support
+
+The same Browser SDK runs across platforms; there is no separate Chrome SDK. Its API compatibility
+targets are Chromium (including Chrome, Brave and Edge), Firefox and WebKit (including Safari and
+current iOS builds of Chrome and Brave). This is not a production-certification matrix: browser and
+device combinations still require the physical validation described below. WebSocket is the
+default transport everywhere. Experimental WebRTC automatically falls back to WebSocket on WebKit
+so the SDK-owned echo-cancellation path remains in the audio loop.
+
+Browser automation cannot validate acoustic echo cancellation, physical output level or Bluetooth
+routing. Certify those on real devices when adding a new browser/engine version, especially an iOS
+build using Apple's alternative-browser-engine entitlement.
+
+Playback stays at unity gain. The SDK does not add a limiter, boost output, select a physical
+speaker, or manipulate `navigator.audioSession`: browsers and operating systems own maximum device
+volume and routing, and mobile browsers may attenuate playback while microphone capture is active.
+Keeping capture active preserves barge-in; applications that require guaranteed speaker routing
+need a native media integration.
+
+Each inbound JSON frame is emitted once under its typed event name and once under the catch-all
+`event` name. Choose one subscription style for a given handler; registering it on both will render
+the same transcript twice.
+
+Automatic WebSocket reconnect resumes conversation context and deferred jobs with the latest server
+token. To preserve the same bounded resume opportunity across a full page reload, persist the SDK's
+opaque state in tab-scoped storage and import it into the replacement client:
+
+```js
+const storageKey = 'converse-resume-state';
+const clientOptions = {
+  url: 'wss://dialt.com/ws',
+  sessionId: credential.session_id,
+  apiKey: credential.api_key,
+  mode: originalMode, // reconstruct the same options used before reload
+};
+
+let savedResumeState = null;
+try {
+  savedResumeState = JSON.parse(sessionStorage.getItem(storageKey) || 'null');
+} catch {
+  sessionStorage.removeItem(storageKey);
+}
+
+const client = new ConverseClient(clientOptions);
+if (savedResumeState !== null) {
+  try {
+    client.importResumeState(savedResumeState);
+  } catch {
+    sessionStorage.removeItem(storageKey);
+  }
+}
+
+client.addEventListener('resume_state', ({ detail }) => {
+  if (detail.state) sessionStorage.setItem(storageKey, JSON.stringify(detail.state));
+  else sessionStorage.removeItem(storageKey);
+});
+```
+
+`exportResumeState()` returns the current versioned state (or `null`), and
+`importResumeState(state)` may install it before `connect()`. Reconstruct the same client options on
+the new page: explicit mode fields override stashed configuration, so relying on constructor defaults
+can change the resumed session. Treat the value like a short-lived credential: prefer `sessionStorage` over cross-tab or long-lived storage, and never send it anywhere
+except back to Dialt through the SDK. The server accepts it only during its short resume window
+and only for the identity that created it. The SDK rotates the saved state after every successful
+connection and clears it after an intentional end or `resume_failed`. If a persisted token has
+expired, `connect()` rejects and emits `resume_failed`; offer a deliberate fresh start.
+
+A terminal `resume_failed` event stops automatic retries; end local capture and let the caller
+deliberately start a fresh session.
+
+Text sessions use the ordinary Dialt model, instructions, tools and events without opening a
+microphone or audio pipeline:
+
+```js
+const textClient = new ConverseClient({
+  url: 'wss://dialt.com/ws',
+  sessionId: credential.session_id,
+  apiKey: credential.api_key,
+  mode: { kind: 'converse', modality: 'text' },
+});
+await textClient.connect();
+textClient.sendText('What is the weather like?');
+```
+
+`sendText(text)` commits one user turn and returns whether it was written to the live connection. (In a voice session `sendText` remains the user-role `injectContext` shorthand and returns its acknowledgement promise.)
+The usual `asr`, `turn`, `text_delta`, `utterance`, and `done` events follow without audio. Text
+mode is WebSocket-only; microphone and caller-owned audio methods reject.
+
+Hosts can also add silent application context to either modality. Set `reply: true` when the model
+should proactively announce the update:
+
+```js
+client.injectContext('Claude Code finished. Tell the user briefly.', {
+  role: 'context',
+  reply: true,
+  messageId: 'job-42-complete',
+});
+```
+
+`injectContext()` returns a promise resolving to the broker's correlated
+`{type: 'inject_context_ack', message_id, accepted, ...}`. Its role defaults to `'context'`; use
+`'user'` only when the text should be represented as a real user turn. `reply` defaults to false.
+
+Browser setup and events are in the [browser guide](https://dialt.com/docs/api/browser/).
+Wire-level playback and tools are in the [WebSocket guide](https://dialt.com/docs/api/websocket/).
+
+Tool declarations pass through in `mode.tools`. `expected_duration` says what the caller should
+hear: `"instant"` for fast lookups (the caller hears the answer directly), `"seconds"` for anything
+that takes more than about a second (the assistant acknowledges first, then answers when the result
+arrives), `"long"` for agent or batch jobs; leave it out and Dialt learns from observed results.
+`status_label` supplies a short user-safe name for pending work:
+
+```js
+mode: {
+  kind: "converse",
+  tools: [{
+    name: "lookup_order",
+    description: "Look up an order by ID.",
+    parameters: { type: "object", properties: { order_id: { type: "string" } } },
+    read_only: true,
+    expected_duration: "instant",
+    status_label: "order lookup",
+  }],
+}
+```
+
+For host jobs that should outlive the current voice turn — a coding-agent task, report generation,
+anything the caller should not wait on — declare the tool as a background job:
+
+```js
+mode: {
+  kind: "converse",
+  tools: [{
+    name: "run_task",
+    description: "Run a long coding task and report when done.",
+    parameters: { type: "object", properties: { instruction: { type: "string" } } },
+    deferred: true,          // job may outlive the voice turn
+    deferred_timeout: 7200,  // seconds the detached job may run
+    notify_on_complete: true, // speak up when the result lands, even mid-topic
+    status_label: "coding task",
+  }],
+}
+```
+
+Acknowledge the individual call to release the voice turn, then continue the work in the background:
+
+```js
+client.sendToolDeferred(event.detail.id, {
+  handle: `cc-${event.detail.id}`, statusLabel: "Claude Code task",
+});
+```
+
+The handle names *that call*, not your worker — mint a fresh one each time (deriving it from the
+call id, as above, is the simplest way) and check the acknowledgement. Re-using a live handle is
+rejected with `{ accepted: false, reason: "handle_in_use" }`, and a rejected defer is not a
+deferral: the call stays on the ordinary tool timeout and will expire while you believe it is
+running in the background. Route several calls to one long-lived worker with your own
+handle-to-worker map instead.
+
+The conversation carries on while the job runs: the agent narrates the hand-off, the caller can talk
+about something else, and when the host reports the result the broker voices it as a completion
+turn (`notify_on_complete`). The user can interrupt that narration or cancel the pending job at any
+point, and reconnects resume pending jobs via the latest server token. See the
+[background tools guide](https://dialt.com/docs/api/background-tools/) for the full
+lifecycle, including progress updates and the delivery-failure contract.
+
+A running job that discovers it needs a mid-call decision raises it with
+`sendToolPartialResult(id, content, { interaction: { id, prompt, options } })` — the broker asks
+the user by voice at the next opportunity, with a wire-visible lifecycle (`tool_job_narration`,
+tracked via `narrationState`/`interactionState`). If the decision gets made elsewhere first (e.g.
+clicked in your own UI) or newer intent makes it moot, close it without completing the call:
+
+```js
+const ack = await client.sendToolInteractionUpdate(
+  event.detail.id, "overwrite-1", "resolved", { note: "approved in the IDE" });
+// ack.applied === false carries a stable reason (e.g. "already_closed") for late duplicates.
+```
+
+Built-in web search remains bridge-first. A server `tool_cancel` can represent timeout/discard or
+an explicit user request to cancel pending work; hosts should stop that call promptly.
+
+### WebRTC transport (experimental)
+
+Experimental: the API is stable, but this transport is newly shipped and still being hardened on
+real networks; `ws` remains the default and recommended fallback.
+
+Pass `transport: 'webrtc'` to `ConverseClient` to carry the call over WebRTC (UDP) instead of the
+default WebSocket — more resilient to jitter and packet loss on weak networks. `ws` remains the
+default. Safari/WebKit falls back to `ws` automatically. See the
+[browser guide's WebRTC section](https://dialt.com/docs/api/browser/#webrtc).
+
+Dialt-authored SDK code is licensed under the [Apache License 2.0](LICENSE). The bundled AEC
+module contains components under their own terms; see [NOTICE](NOTICE) and
+[THIRD_PARTY_LICENSES](THIRD_PARTY_LICENSES/README.md). These licenses do not apply to the hosted
+Dialt service, its models, or its server-side implementation.
+
+### Ambience: background music and the thinking sound
+
+```js
+const client = new ConverseClient({ url, sessionId, apiKey, mode, ambience: 'thinking' });
+client.setAmbience('continuous');   // switch live; 'off' | 'thinking' | 'continuous'
+```
+
+`ambience` (default `'thinking'`; pass `'off'` to opt out) plays a soft generative bed through the
+SDK's own player:
+
+- `'continuous'`: under the whole call from the first reply onward (it never leads), so the silence
+  between turns feels connected.
+- `'thinking'`: silent, except while Dialt is blocking on a tool result with nothing to say (the
+  server's `working` event - client tools, `web_search`, `think_deeply`). After ~1.5 s it fades in;
+  it fades out again under the first syllables of the reply. A caller waiting on a slow backend
+  hears "still working" instead of dead air, and nothing else.
+
+Pass an object to tune the envelope: `{ mode: 'thinking', afterS: 1.5, fadeInS: 1.5, fadeOutS: 0.3,
+level: 1 }` (`level` is a linear multiplier on the bed's built-in peak of about -21 dBFS). The bed is
+mixed into the same scheduled chunks as reply audio, so it is inside the echo canceller's far-end
+reference, including the SDK's WASM canceller on WebKit/iOS; it is never queued ahead of a reply and
+never counts toward barge `discarded_ms`. WebSocket transport only: over webrtc the SDK player is not
+in the audio path, so the local ambience stays silent and the server-mixed `mode.background_audio`
+bed is the option there.
+
+## Repository development
+
+`package.json` is the version source and `CHANGELOG.md` records compatibility changes. Production
+uses the checked-in copy under `web/vendor/converse/`.
+
+Before release, run:
+
+```sh
+npm run check
+npm run pack:check
+```

package/THIRD_PARTY_LICENSES/README.md

@@ -0,0 +1,9 @@
+# Third-party components
+
+`src/aec3-wasm.js` is generated with Emscripten from `webrtc-audio-processing` v2.1,
+WebRTC, Abseil 20240722.0, and their audio-processing dependencies. The generated runtime may
+also contain portions of Emscripten system libraries, including musl and libc++abi.
+
+The corresponding copyright, license, disclaimer, and patent texts are reproduced in this
+directory. These components remain under their respective terms; the SDK Apache License 2.0
+does not replace them.

package/THIRD_PARTY_LICENSES/abseil-Apache-2.0.txt

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

package/THIRD_PARTY_LICENSES/emscripten.txt

@@ -0,0 +1,102 @@
+Emscripten is available under 2 licenses, the MIT license and the
+University of Illinois/NCSA Open Source License.
+
+Both are permissive open source licenses, with little if any
+practical difference between them.
+
+The reason for offering both is that (1) the MIT license is
+well-known, while (2) the University of Illinois/NCSA Open Source
+License allows Emscripten's code to be integrated upstream into
+LLVM, which uses that license, should the opportunity arise.
+
+The full text of both licenses follows.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal with the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimers
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    Neither the names of Mozilla,
+    nor the names of its contributors may be used to endorse
+    or promote products derived from this Software without specific prior
+    written permission. 
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE.
+
+==============================================================================
+
+This program uses portions of Node.js source code located in src/library_path.js,
+in accordance with the terms of the MIT license. Node's license follows:
+
+    """
+        Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to
+        deal in the Software without restriction, including without limitation the
+        rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+        sell copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+        FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+        IN THE SOFTWARE.
+    """
+
+The musl libc project is bundled in this repo, and it has the MIT license, see
+system/lib/libc/musl/COPYRIGHT
+
+The third_party/ subdirectory contains code with other licenses. None of it is
+used by default, but certain options use it (e.g., the optional closure compiler
+flag will run closure compiler from third_party/).
+

package/THIRD_PARTY_LICENSES/fft-Mark-Olesen.txt

@@ -0,0 +1,25 @@
+/*
+ * Copyright(c)1995,97 Mark Olesen <olesen@me.QueensU.CA>
+ *    Queen's Univ at Kingston (Canada)
+ *
+ * Permission to use, copy, modify, and distribute this software for
+ * any purpose without fee is hereby granted, provided that this
+ * entire notice is included in all copies of any software which is
+ * or includes a copy or modification of this software and in all
+ * copies of the supporting documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR QUEEN'S
+ * UNIVERSITY AT KINGSTON MAKES ANY REPRESENTATION OR WARRANTY OF ANY
+ * KIND CONCERNING THE MERCHANTABILITY OF THIS SOFTWARE OR ITS
+ * FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * All of which is to say that you can do what you like with this
+ * source code provided you don't try to sell it as your own and you
+ * include an unaltered copy of this message (including the
+ * copyright).
+ *
+ * It is also implicitly understood that bug fixes and improvements
+ * should make their way back to the general Internet community so
+ * that everyone benefits.
+ */