Kino

https://hexdocs.pm/kino/
Admin
Kino is a library that provides client-driven interactive widgets for Livebook, enabling the...
Tokens:16,464
Snippets:158
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Kino.SmartCell Functions

Source: https://hexdocs.pm/kino/Kino.FS

Functions for creating and managing Kino.SmartCells. This includes getting definitions, prefixing variable names, quoting strings, registering cells, and validating variable names.

```Elixir
Kino.SmartCell.definitions()
Kino.SmartCell.prefixed_var_name(name, prefix)
Kino.SmartCell.quoted_to_string(value)
Kino.SmartCell.register(cell)
Kino.SmartCell.valid_variable_name?(name)
```

--------------------------------

### Kino Modules Overview

Source: https://hexdocs.pm/kino/api-reference

Provides a high-level overview of Kino modules, including their purpose and functionality within the Livebook environment. This includes modules for audio, controls, data tables, file system access, and more.

```APIDOC
Kino
Client-driven interactive widgets for Livebook.
Kino.Audio
A kino for rendering a binary audio.
Kino.Control
Various widgets for user interactions.
Kino.DataTable
A kino for interactively viewing tabular data.
Kino.Download
A kino for downloading file content.
Kino.ETS
A kino for interactively viewing an ETS table.
Kino.FS
Provides access to notebook files.
Kino.FS.ForbiddenError
Exception raised when access to a notebook file is forbidden.
Kino.Frame
A placeholder for outputs.
Kino.HTML
A kino for rendering HTML content.
Kino.Image
A kino for rendering a binary image.
Kino.Input
Various input elements for entering data.
Kino.Inspect
A struct wrapping any term for default rendering.
Kino.InterruptError
Exception raised to stop evaluation in expected manner.
Kino.JS
Allows for defining custom JavaScript powered kinos.
Kino.JS.Live
Introduces state and event-driven capabilities to JavaScript powered kinos.
Kino.JS.Live.Context
State available in `Kino.JS.Live` server callbacks.
Kino.Layout
Layout utilities for arranging multiple kinos together.
Kino.Markdown
A kino for rendering Markdown content.
Kino.Mermaid
A kino for rendering Mermaid diagrams.
Kino.Process
This module contains kinos for generating visualizations to help introspect your running processes.
Kino.Proxy
Functionality for handling proxy requests forwarded from Livebook.
Kino.RPC
Functions for working with remote nodes.
Kino.Render
Protocol defining term formatting in the context of Livebook.
Kino.Screen
Provides a LiveView-like experience for building forms in Livebook.
Kino.Shorts
Shortcuts for building Kinos.
Kino.SmartCell
An interface for defining custom smart cells.
Kino.Table
A behaviour module for implementing tabular kinos.
Kino.Test
Conveniences for testing custom Kino components.
Kino.Text
A kino for rendering text content.
Kino.Tree
A kino for interactively viewing nested data as a tree view.
Kino.Video
A kino for rendering a binary video.
Kino.Workspace
Functions related to workspace integrations and Livebook apps.
```

--------------------------------

### Live HTML Replacement with Kino.JS.Live

Source: https://hexdocs.pm/kino/Kino.JS

Demonstrates how to create a live Kino that can replace its HTML content on demand. It uses `Kino.JS.Live` for server-side management and JavaScript for client-side updates via events.

```Elixir
defmodule KinoDocs.LiveHTML do
  use Kino.JS.Live

  def new(html) do
    Kino.JS.Live.new(__MODULE__, html)
  end

  def replace(kino, html) do
    Kino.JS.Live.cast(kino, {:replace, html})
  end

  @impl true
  def init(html, ctx) do
    {:ok, assign(ctx, html: html)}
  end

  @impl true
  def handle_connect(ctx) do
    {:ok, ctx.assigns.html, ctx}
  end

  @impl true
  def handle_cast({:replace, html}, ctx) do
    broadcast_event(ctx, "replace", html)
    {:noreply, assign(ctx, html: html)}
  end

  asset "main.js" do
    """
    export function init(ctx, html) {
      ctx.root.innerHTML = html;

      ctx.handleEvent("replace", (html) => {
        ctx.root.innerHTML = html;
      });
    }
    """
  end
end
```

```JavaScript
export function init(ctx, html) {
  ctx.root.innerHTML = html;

  ctx.handleEvent("replace", (html) => {
    ctx.root.innerHTML = html;
  });
}
```

--------------------------------

### Kino Core Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides core functionalities for Kino, including animation, asynchronous listening, configuration, inspection, and process management.

```elixir
animate/2
animate/3
async_listen/2
beam_paths/0
configure/1
inspect/2
interrupt!/2
listen/2
listen/3
nothing/0
recompile/0
render/1
start_child/1
start_child!/1
terminate_child/1
tmp_dir/0
```

--------------------------------

### Kino Core Functions

Source: https://hexdocs.pm/kino/Kino

Provides core functionalities for Kino, including animation, asynchronous listening, configuration, inspection, and process management.

```elixir
animate/2
animate/3
async_listen/2
beam_paths/0
configure/1
inspect/2
interrupt!/2
listen/2
listen/3
nothing/0
recompile/0
render/1
start_child/1
start_child!/1
terminate_child/1
tmp_dir/0
```

--------------------------------

### Kino Core Functions

Source: https://hexdocs.pm/kino/api-reference

Provides core functionalities for Kino, including animation, asynchronous listening, configuration, inspection, and process management.

```elixir
animate/2
animate/3
async_listen/2
beam_paths/0
configure/1
inspect/2
interrupt!/2
listen/2
listen/3
nothing/0
recompile/0
render/1
start_child/1
start_child!/1
terminate_child/1
tmp_dir/0
```

--------------------------------

### Handling Binary Payloads with Kino.JS.Live

Source: https://hexdocs.pm/kino/Kino.JS

Illustrates sending and receiving binary data between Elixir and JavaScript using Kino.JS.Live. It shows how to structure binary payloads with associated metadata and handle them on both client and server.

```Elixir
defmodule KinoDocs.Binary do
  use Kino.JS.Live

  def new() do
    Kino.JS.Live.new(__MODULE__, nil)
  end

  @impl true
  def handle_connect(ctx) do
    payload = {:binary, %{message: "hello"}, <<1, 2>>}
    {:ok, payload, ctx}
  end

  @impl true
  def handle_event("ping", {:binary, _info, binary}, ctx) do
    reply_payload = {:binary, %{message: "pong"}, <<1, 2, binary::binary>>}
    broadcast_event(ctx, "pong", reply_payload)
    {:noreply, ctx}
  end

  asset "main.js" do
    """
    export function init(ctx, payload) {
      console.log("initial data", payload);

      ctx.handleEvent("pong", ([info, buffer]) => {
        console.log("event data", [info, buffer])
      });

      const buffer = new ArrayBuffer(2);
      const bytes = new Uint8Array(buffer);
      bytes[0] = 4;
      bytes[1] = 250;
      ctx.pushEvent("ping", [{ message: "ping" }, buffer]);
    }
    """
  end
end
```

```JavaScript
export function init(ctx, payload) {
  console.log("initial data", payload);

  ctx.handleEvent("pong", ([info, buffer]) => {
    console.log("event data", [info, buffer])
  });

  const buffer = new ArrayBuffer(2);
  const bytes = new Uint8Array(buffer);
  bytes[0] = 4;
  bytes[1] = 250;
  ctx.pushEvent("ping", [{ message: "ping" }, buffer]);
}
```

--------------------------------

### Kino Server Functions

Source: https://hexdocs.pm/kino/Kino.JS

Provides functions for interacting with a Kino server, including making synchronous calls, sending asynchronous requests, monitoring the server, instantiating new Kinos, and replying to calls.

```Elixir
call(kino, term, timeout \\ 5000)
---
Makes a synchronous call to the kino server and waits for its reply.
```

```Elixir
cast(kino, term)
---
Sends an asynchronous request to the kino server.
```

```Elixir
monitor(kino)
---
Starts monitoring the kino server from the calling process.
```

```Elixir
new(module, init_arg, opts \\ [])
---
Instantiates a live JavaScript kino defined by `module`.
```

```Elixir
reply(kino, term)
---
Replies to the kino server.
```

--------------------------------

### Kino.Process Functions

Source: https://hexdocs.pm/kino/Kino.FS

Facilitates process management and tracing within Kino, including rendering application trees and sequence traces.

```elixir
app_tree/2
render_app_tree/2
render_seq_trace/3
render_sup_tree/2
seq_trace/3
sup_tree/2
```

--------------------------------

### Kino.Table Functions

Source: https://hexdocs.pm/kino/Kino.FS

Functions for creating and updating Kino.Table instances.

```Elixir
Kino.Table.new(columns, rows_spec, opts \\ [])
Kino.Table.update(table, new_rows)
```

--------------------------------

### Kino.Table Callbacks

Source: https://hexdocs.pm/kino/Kino.FS

Callbacks for Kino.Table to handle data export, retrieval, initialization, and updates.

```Elixir
def export_data(table, format, state) do
  # Export table data
end

def get_data(table, state) do
  # Get table data
end

def init(state) do
  # Initialize table
end

def on_update(table, state) do
  # Handle table updates
end
```

--------------------------------

### Kino Core Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Provides core functionalities for Kino, including animation, asynchronous listening, configuration, inspection, and process management.

```elixir
animate/2
animate/3
async_listen/2
beam_paths/0
configure/1
inspect/2
interrupt!/2
listen/2
listen/3
nothing/0
recompile/0
render/1
start_child/1
start_child!/1
terminate_child/1
tmp_dir/0
```

--------------------------------

### Kino.Shorts Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides a collection of utility functions for displaying various media types and data structures within Kino, including audio, images, markdown, and tables.

```elixir
audio/2
data_table/2
download/2
frame/1
grid/2
html/1
image/2
markdown/1
mermaid/2
read_audio/2
read_checkbox/2
read_color/2
read_date/2
read_file/2
read_image/2
read_number/2
read_password/2
read_range/2
read_select/3
read_text/2
read_textarea/2
read_url/2
read_utc_datetime/2
read_utc_time/2
tabs/1
text/1
tree/1
video/2
```

--------------------------------

### Kino.Screen Callbacks and Functions

Source: https://hexdocs.pm/kino/Kino.FS

Defines the interface for Kino screens, including rendering callbacks and functions for creating and controlling screens.

```elixir
render/1
control/2
new/2
```

--------------------------------

### Kino.Shorts Functions

Source: https://hexdocs.pm/kino/Kino

Provides a collection of utility functions for displaying various media types and data structures within Kino, including audio, images, markdown, and tables.

```elixir
audio/2
data_table/2
download/2
frame/1
grid/2
html/1
image/2
markdown/1
mermaid/2
read_audio/2
read_checkbox/2
read_color/2
read_date/2
read_file/2
read_image/2
read_number/2
read_password/2
read_range/2
read_select/3
read_text/2
read_textarea/2
read_url/2
read_utc_datetime/2
read_utc_time/2
tabs/1
text/1
tree/1
video/2
```

--------------------------------

### Kino Core Functions

Source: https://hexdocs.pm/kino/Kino.JS

Provides core functionalities for Kino, including animation, asynchronous listening, configuration, inspection, and process management.

```elixir
animate/2
animate/3
async_listen/2
beam_paths/0
configure/1
inspect/2
interrupt!/2
listen/2
listen/3
nothing/0
recompile/0
render/1
start_child/1
start_child!/1
terminate_child/1
tmp_dir/0
```

--------------------------------

### Kino.Screen Callbacks and Functions

Source: https://hexdocs.pm/kino/Kino

Defines the interface for Kino screens, including rendering callbacks and functions for creating and controlling screens.

```elixir
render/1
control/2
new/2
```

--------------------------------

### Kino.Shorts Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Provides a collection of utility functions for displaying various media types and data structures within Kino, including audio, images, markdown, and tables.

```elixir
audio/2
data_table/2
download/2
frame/1
grid/2
html/1
image/2
markdown/1
mermaid/2
read_audio/2
read_checkbox/2
read_color/2
read_date/2
read_file/2
read_image/2
read_number/2
read_password/2
read_range/2
read_select/3
read_text/2
read_textarea/2
read_url/2
read_utc_datetime/2
read_utc_time/2
tabs/1
text/1
tree/1
video/2
```

--------------------------------

### Kino.Process Functions

Source: https://hexdocs.pm/kino/Kino

Facilitates process management and tracing within Kino, including rendering application trees and sequence traces.

```elixir
app_tree/2
render_app_tree/2
render_seq_trace/3
render_sup_tree/2
seq_trace/3
sup_tree/2
```

--------------------------------

### Kino.JS.Live API Reference

Source: https://hexdocs.pm/kino/api-reference

Introduces state and event-driven capabilities to JavaScript powered kinos. This module facilitates real-time communication and state management between the client and server for enhanced interactivity.

```APIDOC
Kino.JS.Live:
  Sections:
    Example
    Event handlers
    Binary payloads
  Summary
  Types:
    from/0
    payload/0
    t/0
  Callbacks:
    handle_call/3
    handle_cast/2
    handle_connect/1
    handle_event/3
    handle_info/2
    init/2
    terminate/2
  Functions:
    call/3
    cast/2
    monitor/1
    new/3
    reply/2
```

--------------------------------

### Kino.Screen Callbacks and Functions

Source: https://hexdocs.pm/kino/api-reference

Defines the interface for Kino screens, including rendering callbacks and functions for creating and controlling screens.

```elixir
render/1
control/2
new/2
```

--------------------------------

### Kino.Table Callbacks

Source: https://hexdocs.pm/kino/Kino.JS

Callbacks for Kino.Table, handling data export, retrieval, initialization, and updates.

```elixir
export_data/3
get_data/2
init/1
on_update/2
```

--------------------------------

### Kino.Process Functions

Source: https://hexdocs.pm/kino/api-reference

Facilitates process management and tracing within Kino, including rendering application trees and sequence traces.

```elixir
app_tree/2
render_app_tree/2
render_seq_trace/3
render_sup_tree/2
seq_trace/3
sup_tree/2
```

--------------------------------

### Kino.Screen Callbacks and Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Defines the interface for Kino screens, including rendering callbacks and functions for creating and controlling screens.

```elixir
render/1
control/2
new/2
```

--------------------------------

### Kino.JS.Live.Context Properties and Types

Source: https://hexdocs.pm/kino/Kino.JS.Live

Details the properties and types available within the Kino.JS.Live.Context, which holds the server state and client origin information.

```APIDOC
Properties:
  * `:assigns` - custom server state kept across callback calls
  * `:origin` - an opaque identifier of the client that triggered the given action. It is set in `Kino.JS.Live.handle_connect/1` and `Kino.JS.Live.handle_event/3`

Types:
origin() :: nil | term()
t() :: %Kino.JS.Live.Context{
  __private__: map(),
  assigns: map(),
  origin: origin()
}
```

--------------------------------

### Kino Workspace App and User Info

Source: https://hexdocs.pm/kino/Kino

Provides functions to retrieve information about the running application and connected users within a Livebook workspace. Includes type definitions for app_info and user_info.

```APIDOC
Kino.Workspace:
  Functions related to workspace integrations and Livebook apps.

  Types:
    app_info() :: %{type: :single} | %{:type => :multi, optional(:started_by) => user_info()} | %{type: :none}
    user_info() :: %{
      id: String.t(),
      name: String.t() | nil,
      email: String.t() | nil,
      source: atom(),
      payload: map() | nil
    }

  Functions:
    app_info() :: app_info()
      Returns information about the running app. Note that :started_by information is only available for multi-session apps when the app uses a Livebook Teams workspace. Unless called from within an app deployment, returns %{type: :none}.

    user_info(client_id :: String.t()) :: {:ok, user_info()} | {:error, :not_found | :not_available}
      Returns user information for the given connected client id. Note that this information is only available when the session uses Livebook Teams workspace, otherwise :not_available error is returned. If there is no such connected client, :not_found error is returned.
```

--------------------------------

### Kino.Shorts Functions

Source: https://hexdocs.pm/kino/Kino.JS

Provides a collection of utility functions for displaying various media types and data structures within Kino, including audio, images, markdown, and tables.

```elixir
audio/2
data_table/2
download/2
frame/1
grid/2
html/1
image/2
markdown/1
mermaid/2
read_audio/2
read_checkbox/2
read_color/2
read_date/2
read_file/2
read_image/2
read_number/2
read_password/2
read_range/2
read_select/3
read_text/2
read_textarea/2
read_url/2
read_utc_datetime/2
read_utc_time/2
tabs/1
text/1
tree/1
video/2
```

--------------------------------

### Kino.Process Functions

Source: https://hexdocs.pm/kino/Kino.JS

Facilitates process management and tracing within Kino, including rendering application trees and sequence traces.

```elixir
app_tree/2
render_app_tree/2
render_seq_trace/3
render_sup_tree/2
seq_trace/3
sup_tree/2
```

--------------------------------

### Kino.Shorts Functions

Source: https://hexdocs.pm/kino/api-reference

Provides a collection of utility functions for displaying various media types and data structures within Kino, including audio, images, markdown, and tables.

```elixir
audio/2
data_table/2
download/2
frame/1
grid/2
html/1
image/2
markdown/1
mermaid/2
read_audio/2
read_checkbox/2
read_color/2
read_date/2
read_file/2
read_image/2
read_number/2
read_password/2
read_range/2
read_select/3
read_text/2
read_textarea/2
read_url/2
read_utc_datetime/2
read_utc_time/2
tabs/1
text/1
tree/1
video/2
```

--------------------------------

### Kino.Workspace Functions

Source: https://hexdocs.pm/kino/Kino

Provides functions to retrieve information about the Kino workspace and user.

```elixir
app_info/0
user_info/1
```

--------------------------------

### Kino.Process Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Facilitates process management and tracing within Kino, including rendering application trees and sequence traces.

```elixir
app_tree/2
render_app_tree/2
render_seq_trace/3
render_sup_tree/2
seq_trace/3
sup_tree/2
```

--------------------------------

### Kino.Workspace Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides functions to retrieve information about the Kino workspace and user.

```elixir
app_info/0
user_info/1
```

--------------------------------

### Kino.Render API Reference

Source: https://hexdocs.pm/kino/api-reference

Protocol defining term formatting in the context of Livebook. It specifies how different terms should be represented and displayed to ensure consistent rendering across the notebook.

```APIDOC
Kino.Render:
  Summary
  Types:
    t/0
  Functions:
    to_livebook/1
```

--------------------------------

### Kino.Workspace Functions

Source: https://hexdocs.pm/kino/api-reference

Provides functions to retrieve information about the Kino workspace and user.

```elixir
app_info/0
user_info/1
```

--------------------------------

### Kino.Render Functions

Source: https://hexdocs.pm/kino/Kino.FS

Function for rendering Kino output to Livebook.

```Elixir
Kino.Render.to_livebook(renderable)
```

--------------------------------

### Kino.Screen Callbacks and Functions

Source: https://hexdocs.pm/kino/Kino.JS

Defines the interface for Kino screens, including rendering callbacks and functions for creating and controlling screens.

```elixir
render/1
control/2
new/2
```

--------------------------------

### Kino.JS API Reference

Source: https://hexdocs.pm/kino/api-reference

Defines custom JavaScript powered kinos, allowing for client-driven interactivity within Livebook. It enables the creation of dynamic and responsive user interfaces directly in the notebook environment.

```APIDOC
Kino.JS:
  Sections:
    Example
    Assets
    JavaScript API
    Dependencies
    Live kinos
  Summary
  Types:
    t/0
  Functions:
    asset/2
    new/3
```

--------------------------------

### Kino.Audio Functions

Source: https://hexdocs.pm/kino/Kino

Handles audio playback within Kino, allowing for new audio instances, pausing, and playing audio content.

```elixir
new/3
pause/1
play/1
```

--------------------------------

### Kino.Workspace Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Provides functions to retrieve information about the Kino workspace and user.

```elixir
app_info/0
user_info/1
```

--------------------------------

### Kino.JS.Live Functions

Source: https://hexdocs.pm/kino/Kino.JS

Provides functions for interacting with live kinos, allowing for communication and state updates from the Elixir server process.

```elixir
call/3
cast/2
monitor/1
new/3
reply/2
```

--------------------------------

### Kino Server Callbacks

Source: https://hexdocs.pm/kino/Kino.JS

Defines the callback interface for handling server events and messages, including synchronous calls, asynchronous casts, client connections, client events, general information messages, initialization, and termination.

```Elixir
@callback handle_call(msg :: term(), from(), ctx :: Kino.JS.Live.Context.t()) ::
  {:noreply, ctx :: Kino.JS.Live.Context.t()}
  | {:reply, term(), ctx :: Kino.JS.Live.Context.t()}
---
Invoked to handle synchronous `call/3` messages.
```

```Elixir
@callback handle_cast(msg :: term(), ctx :: Kino.JS.Live.Context.t()) ::
  {:noreply, ctx :: Kino.JS.Live.Context.t()}
---
Invoked to handle asynchronous `cast/2` messages.
```

```Elixir
@callback handle_connect(ctx :: Kino.JS.Live.Context.t()) ::
  {:ok, payload(), ctx :: Kino.JS.Live.Context.t()}
---
Invoked whenever a new client connects to the server.
```

```Elixir
@callback handle_event(event :: String.t(), payload(), ctx :: Kino.JS.Live.Context.t()) ::
  {:noreply, ctx :: Kino.JS.Live.Context.t()}
---
Invoked to handle client events.
```

```Elixir
@callback handle_info(msg :: term(), ctx :: Kino.JS.Live.Context.t()) ::
  {:noreply, ctx :: Kino.JS.Live.Context.t()}
---
Invoked to handle all other messages.
```

```Elixir
@callback init(arg :: term(), ctx :: Kino.JS.Live.Context.t()) ::
  {:ok, ctx :: Kino.JS.Live.Context.t()}
  | {:ok, ctx :: Kino.JS.Live.Context.t(), opts :: keyword()}
---
Invoked when the server is started.
```

```Elixir
@callback terminate(reason, ctx :: Kino.JS.Live.Context.t()) :: term()
when reason: :normal | :shutdown | {:shutdown, term()} | term()
---
Invoked when the server is about to exit.
```

--------------------------------

### Kino.HTML Functions

Source: https://hexdocs.pm/kino/Kino.FS

Allows for the rendering of raw HTML content within Kino.

```elixir
new/1
```

--------------------------------

### Kino.SmartCell Callbacks

Source: https://hexdocs.pm/kino/Kino.FS

Callbacks for Kino.SmartCell to handle editor changes, scan results, and convert data for attributes and source code.

```Elixir
def handle_editor_change(change, state) do
  # Handle editor changes
end

def scan_binding(binding, context, state) do
  # Scan bindings
end

def scan_eval_result(result, context, state) do
  # Scan evaluation results
end

def to_attrs(value) do
  # Convert value to attributes
end

def to_source(value) do
  # Convert value to source code
end
```

--------------------------------

### Kino.JS.Live.Context API Reference

Source: https://hexdocs.pm/kino/api-reference

Provides the state available in `Kino.JS.Live` server callbacks. This context object allows access to important information for managing client-server interactions and updating the kino's state.

```APIDOC
Kino.JS.Live.Context:
  Sections:
    Properties
  Summary
  Types:
    origin/0
    t/0
  Functions:
    assign/2
    broadcast_event/3
    emit_event/2
    reconfigure_smart_cell/2
    send_event/4
    update/3
```

--------------------------------

### Kino.Audio Functions

Source: https://hexdocs.pm/kino/Kino.FS

Handles audio playback within Kino, allowing for new audio instances, pausing, and playing audio content.

```elixir
new/3
pause/1
play/1
```

--------------------------------

### Kino.Download Functions

Source: https://hexdocs.pm/kino/Kino.FS

Facilitates file downloads within Kino, allowing users to download specified files.

```elixir
new/2
```

--------------------------------

### JavaScript API for Live Kinos

Source: https://hexdocs.pm/kino/Kino.JS

This section outlines the JavaScript API available for interacting with live kinos. It covers how to handle events, manage state, and communicate between the browser and the Elixir server.

```javascript
// Example of handling an event from the Elixir side
// kx.handleEvent("my_event", (payload) => {
//   console.log("Received event:", payload);
// });

// Example of sending an event to the Elixir side
// kx.sendEvent("user_action", { data: "some data" });

// Example of updating the smart cell editor source
// kx.pushSmartCellEditorSource("new source code");

// Example of asserting a smart cell update (in testing context)
// kx.assertSmartCellUpdate(cellId, expectedUpdate, timeout);
```

--------------------------------

### Kino.JS.Live Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides functions for interacting with Kino.JS.Live sessions from the Elixir backend. This includes making calls, sending casts, monitoring sessions, and replying to requests.

```Elixir
Kino.JS.Live.call(pid, request, timeout \\ :infinity)
Kino.JS.Live.cast(pid, request)
Kino.JS.Live.monitor(pid)
Kino.JS.Live.new(opts \\ [])
Kino.JS.Live.reply(pid, from, reply)
```

--------------------------------

### Kino.HTML Functions

Source: https://hexdocs.pm/kino/Kino

Allows for the rendering of raw HTML content within Kino.

```elixir
new/1
```

--------------------------------

### Kino.Workspace Functions

Source: https://hexdocs.pm/kino/Kino.JS

Provides functions to retrieve information about the Kino workspace and user.

```elixir
app_info/0
user_info/1
```

--------------------------------

### Kino.Download Functions

Source: https://hexdocs.pm/kino/Kino

Facilitates file downloads within Kino, allowing users to download specified files.

```elixir
new/2
```

--------------------------------

### Kino.Audio Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Handles audio playback within Kino, allowing for new audio instances, pausing, and playing audio content.

```elixir
new/3
pause/1
play/1
```

--------------------------------

### Kino.SmartCell Callbacks

Source: https://hexdocs.pm/kino/Kino.JS

Callbacks for Kino.SmartCell, handling editor changes, scanning bindings and evaluation results, and converting data for attributes and source code.

```elixir
handle_editor_change/2
scan_binding/3
scan_eval_result/2
to_attrs/1
to_source/1
```

--------------------------------

### Kino.Audio Functions

Source: https://hexdocs.pm/kino/api-reference

Handles audio playback within Kino, allowing for new audio instances, pausing, and playing audio content.

```elixir
new/3
pause/1
play/1
```

--------------------------------

### Kino.Test Functions

Source: https://hexdocs.pm/kino/Kino.FS

Functions for testing Kino interactions, including asserting events, outputs, and smart cell updates, as well as managing connections and pushing events.

```Elixir
Kino.Test.assert_broadcast_event(session, event, payload, opts \\ [])
Kino.Test.assert_output(session, output)
Kino.Test.assert_output_to(session, target, output)
Kino.Test.assert_output_to_clients(session, event, payload)
Kino.Test.assert_send_event(session, target, event, payload)
Kino.Test.assert_smart_cell_update(session, id, changes)
Kino.Test.configure_livebook_bridge(opts \\ [])
Kino.Test.connect(session, opts \\ [])
Kino.Test.export(session, opts \\ [])
Kino.Test.push_event(session, target, event, payload)
Kino.Test.push_smart_cell_editor_source(session, id, source)
Kino.Test.start_smart_cell!(session, cell)
```

--------------------------------

### Kino.Download Functions

Source: https://hexdocs.pm/kino/api-reference

Facilitates file downloads within Kino, allowing users to download specified files.

```elixir
new/2
```

--------------------------------

### Kino.Text Functions

Source: https://hexdocs.pm/kino/Kino

Handles the display of plain text content within Kino, allowing for basic styling.

```elixir
new/2
```

--------------------------------

### Kino.HTML Functions

Source: https://hexdocs.pm/kino/api-reference

Allows for the rendering of raw HTML content within Kino.

```elixir
new/1
```

--------------------------------

### Kino.Download Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Facilitates file downloads within Kino, allowing users to download specified files.

```elixir
new/2
```

--------------------------------

### Kino.Test API Reference

Source: https://hexdocs.pm/kino/api-reference

Conveniences for testing custom Kino components. This module offers a suite of assertion functions and utilities to facilitate the testing of Kino's behavior and output.

```APIDOC
Kino.Test:
  Summary
  Functions:
    assert_broadcast_event/4
    assert_output/2
    assert_output_to/3
    assert_output_to_clients/2
    assert_send_event/4
    assert_smart_cell_update/4
    configure_livebook_bridge/1
    connect/3
    export/2
    push_event/3
    push_smart_cell_editor_source/2
    start_smart_cell!/2
```

--------------------------------

### Kino.Download Functions

Source: https://hexdocs.pm/kino/Kino.JS

Facilitates file downloads within Kino, allowing users to download specified files.

```elixir
new/2
```

--------------------------------

### Kino.Text Functions

Source: https://hexdocs.pm/kino/Kino.FS

Handles the display of plain text content within Kino, allowing for basic styling.

```elixir
new/2
```

--------------------------------

### Kino.Table Functions

Source: https://hexdocs.pm/kino/Kino.JS

Functions for creating and updating Kino.Table instances, specifying columns and rows.

```elixir
new/3
update/2
```

--------------------------------

### Kino.HTML Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Allows for the rendering of raw HTML content within Kino.

```elixir
new/1
```

--------------------------------

### Kino.JS.Live Callbacks

Source: https://hexdocs.pm/kino/Kino.JS

Defines the callback functions for the Kino.JS.Live behavior, which handle communication and state management between the Elixir server process and the JavaScript client.

```elixir
handle_call/3
handle_cast/2
handle_connect/1
handle_event/3
handle_info/2
init/2
terminate/2
```

--------------------------------

### Kino.Text Functions

Source: https://hexdocs.pm/kino/api-reference

Handles the display of plain text content within Kino, allowing for basic styling.

```elixir
new/2
```

--------------------------------

### Kino.JS JavaScript API

Source: https://hexdocs.pm/kino/Kino.FS

Provides the JavaScript API for Kino.JS, allowing interaction with Livebook from the browser. This includes managing assets, handling live kinos, and defining custom sections.

```JavaScript
/* Kino.JS JavaScript API documentation would go here */
```

--------------------------------

### Kino.Audio Functions

Source: https://hexdocs.pm/kino/Kino.JS

Handles audio playback within Kino, allowing for new audio instances, pausing, and playing audio content.

```elixir
new/3
pause/1
play/1
```

--------------------------------

### Kino.FS Functions

Source: https://hexdocs.pm/kino/Kino.FS

Handles file system operations within Kino, allowing for the specification and retrieval of file paths.

```elixir
file_path/1
file_spec/1
```

--------------------------------

### Kino.FS Functions

Source: https://hexdocs.pm/kino/api-reference

Handles file system operations within Kino, allowing for the specification and retrieval of file paths.

```elixir
file_path/1
file_spec/1
```

--------------------------------

### Kino.Layout Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides layout components for organizing content within Kino, such as grids and tabs.

```elixir
grid/2
tabs/1
```

--------------------------------

### Kino.Layout Functions

Source: https://hexdocs.pm/kino/Kino

Provides layout components for organizing content within Kino, such as grids and tabs.

```elixir
grid/2
tabs/1
```

--------------------------------

### Kino.Markdown Functions

Source: https://hexdocs.pm/kino/Kino.FS

Enables the rendering of Markdown content within Kino.

```elixir
new/2
```

--------------------------------

### Kino.Markdown Functions

Source: https://hexdocs.pm/kino/api-reference

Enables the rendering of Markdown content within Kino.

```elixir
new/2
```

--------------------------------

### Kino.Markdown Functions

Source: https://hexdocs.pm/kino/Kino

Enables the rendering of Markdown content within Kino.

```elixir
new/2
```

--------------------------------

### Kino.Table API Reference

Source: https://hexdocs.pm/kino/api-reference

A behavior module for implementing tabular kinos. It provides functionalities for displaying and interacting with data in a table format, including data retrieval and updates.

```APIDOC
Kino.Table:
  Summary
  Types:
    column/0
    info/0
    rows_spec/0
    state/0
    t/0
    type/0
  Callbacks:
    export_data/3
    get_data/2
    init/1
    on_update/2
  Functions:
    new/3
    update/2
```

--------------------------------

### Kino.FS Functions

Source: https://hexdocs.pm/kino/Kino

Handles file system operations within Kino, allowing for the specification and retrieval of file paths.

```elixir
file_path/1
file_spec/1
```

--------------------------------

### Kino.JS.Live Callbacks

Source: https://hexdocs.pm/kino/Kino.FS

Defines the callback functions for Kino.JS.Live sessions, handling communication between the Elixir backend and the JavaScript frontend. This includes managing calls, casts, connections, events, and lifecycle hooks.

```Elixir
def handle_call(request, from, state) do
  # Handle incoming calls
end

def handle_cast(request, state) do
  # Handle incoming casts
end

def handle_connect(socket) do
  # Handle new connections
end

def handle_event(event, payload, socket) do
  # Handle JavaScript events
end

def handle_info(message, state) do
  # Handle incoming messages
end

def init(args, state) do
  # Initialize the live session
end

def terminate(reason, state) do
  # Terminate the live session
end
```

--------------------------------

### Kino.HTML Functions

Source: https://hexdocs.pm/kino/Kino.JS

Allows for the rendering of raw HTML content within Kino.

```elixir
new/1
```

--------------------------------

### Kino.Test Functions

Source: https://hexdocs.pm/kino/Kino.JS

Functions for testing Kino components, including asserting events, outputs, and smart cell updates, as well as managing connections and pushing events.

```elixir
assert_broadcast_event/4
assert_output/2
assert_output_to/3
assert_output_to_clients/2
assert_send_event/4
assert_smart_cell_update/4
configure_livebook_bridge/1
connect/3
export/2
push_event/3
push_smart_cell_editor_source/2
start_smart_cell!/2
```

--------------------------------

### Kino.Layout Functions

Source: https://hexdocs.pm/kino/api-reference

Provides layout components for organizing content within Kino, such as grids and tabs.

```elixir
grid/2
tabs/1
```

--------------------------------

### Kino.Text Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Handles the display of plain text content within Kino, allowing for basic styling.

```elixir
new/2
```

--------------------------------

### Kino.SmartCell API Reference

Source: https://hexdocs.pm/kino/api-reference

An interface for defining custom smart cells in Livebook. It allows developers to create reusable, interactive components with custom logic and rendering capabilities.

```APIDOC
Kino.SmartCell:
  Sections:
    Usage
    Example
    Collaborative editor
    Other options
  Summary
  Types:
    attrs/0
    eval_result/0
  Callbacks:
    handle_editor_change/2
    scan_binding/3
    scan_eval_result/2
    to_attrs/1
    to_source/1
  Functions:
    definitions/0
    prefixed_var_name/2
    quoted_to_string/1
    register/1
    valid_variable_name?/1
```

--------------------------------

### Kino.Input Functions

Source: https://hexdocs.pm/kino/Kino.FS

Provides various input components for user interaction, including text fields, checkboxes, file uploads, and more. Supports both synchronous and asynchronous operations.

```elixir
audio/2
checkbox/2
color/2
date/2
file/2
file_path/1
image/2
number/2
password/2
range/2
read/1
select/3
text/2
textarea/2
url/2
utc_datetime/2
utc_time/2
```

--------------------------------

### Kino.FS Functions

Source: https://hexdocs.pm/kino/Kino.JS.Live

Handles file system operations within Kino, allowing for the specification and retrieval of file paths.

```elixir
file_path/1
file_spec/1
```

--------------------------------

### Kino Server Function Specifications

Source: https://hexdocs.pm/kino/Kino.JS

Provides type specifications for Kino server functions, detailing their parameters and return types.

```Elixir
@spec call(t(), term(), timeout()) :: term()
```

```Elixir
@spec cast(t(), term()) :: :ok
```

```Elixir
@spec monitor(t()) :: reference()
```

```Elixir
@spec new(module(), term(), keyword()) :: t()
```

```Elixir
@spec reply(from(), term()) :: :ok
```

--------------------------------

### Kino.Input Functions

Source: https://hexdocs.pm/kino/Kino

Provides various input components for user interaction, including text fields, checkboxes, file uploads, and more. Supports both synchronous and asynchronous operations.

```elixir
audio/2
checkbox/2
color/2
date/2
file/2
file_path/1
image/2
number/2
password/2
range/2
read/1
select/3
text/2
textarea/2
url/2
utc_datetime/2
utc_time/2
```

--------------------------------

### Kino.JS.Live.Context Functions

Source: https://hexdocs.pm/kino/Kino.JS

Functions for managing the context of a live kino, including updating attributes, broadcasting events, and sending events to the client.

```elixir
assign/2
broadcast_event/3
emit_event/2
reconfigure_smart_cell/2
send_event/4
update/3
```

--------------------------------

### Deferred Event Handler Registration

Source: https://hexdocs.pm/kino/Kino.JS

Shows how JavaScript event handlers can be registered asynchronously after an initial operation, such as fetching data. Incoming events are buffered until the handler is ready.

```JavaScript
export function init(ctx, data) {
  fetch(data.someUrl).then((resp) => {
    ctx.handleEvent("update", (payload) => {
      // ...
    });
  });
}
```

```JavaScript
export async function init(ctx, data) {
  const response = await fetch(data.someUrl);

  ctx.handleEvent("update", (payload) => {
    // ...
  });
}
```

--------------------------------

### Kino.Frame Functions

Source: https://hexdocs.pm/kino/Kino

Manages frames for rendering, including creating new frames, appending content, clearing frames, and rendering them.

```elixir
append/3
clear/2
new/1
render/3
```

--------------------------------

### Kino.FS Functions

Source: https://hexdocs.pm/kino/Kino.JS

Handles file system operations within Kino, allowing for the specification and retrieval of file paths.

```elixir
file_path/1
file_spec/1
```

--------------------------------

### Kino.Text Functions

Source: https://hexdocs.pm/kino/Kino.JS

Handles the display of plain text content within Kino, allowing for basic styling.

```elixir
new/2
```
Tokens:
Raw