zzz - API docs - @fuzdev stack

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ index: ZodNumber; }, $strict>; output: ZodVoid; async: true; description: string; }

Action
#

Represents a single action in the system, tracking its full lifecycle through action events.

inheritance

extends:

Cell<typeof ActionJson>

`method`

type ActionMethod

`action_event_data`

type ActionEventData | undefined

`spec`

type ActionSpecUnion

readonly

`kind`

type ActionKind

readonly

`has_error`

readonly

`pending`

Returns true if the action is still pending (not in a terminal state).
An action is complete when it reaches a terminal phase (where next phase is null)
AND the step is terminal (handled or failed).

readonly

`failed`

readonly

`success`

Returns true if the action completed successfully.
Success means: action is complete (terminal phase + step), step is 'handled', and no error.

readonly

`constructor`

type new (options: ActionOptions): Action

`options`

type ActionOptions

`unlisten_to_action_event`

type (() => void) | undefined

`action_event`

type ActionEvent | undefined

`listen_to_action_event`

`action_event`

type

ActionEvent<string, "send_request" | "receive_request" | "send_response" | "receive_response" | "send_error" | "receive_error" | "send" | "receive" | "execute", "initial" | "parsed" | "handling" | "handled" | "failed">

returns () => void

`dispose`

type (): void

returns void

action_specs
#

ActionContextmenu.svelte view source

({ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; ...

ActionContextmenu
#

`action`

type Action

`children`

type Snippet

ActionDetail
#

ActionDetail.svelte view source

`action`

type Action

ActionEventDatas
#

ActionEventDatas

Action event data types indexed by method name.
These represent the full discriminated union of all possible states
for each action's event data, properly typed with inputs and outputs.

`heartbeat`

type

ActionEventRequestResponseData<
		'heartbeat',
		ActionInputs['heartbeat'],
		ActionOutputs['heartbeat']
	>

`cancel`

type ActionEventRemoteNotificationData<'cancel', ActionInputs['cancel']>

`ping`

type ActionEventRequestResponseData<'ping', ActionInputs['ping'], ActionOutputs['ping']>

`session_load`

type

ActionEventRequestResponseData<
		'session_load',
		ActionInputs['session_load'],
		ActionOutputs['session_load']
	>

`filer_change`

type ActionEventRemoteNotificationData<'filer_change', ActionInputs['filer_change']>

`diskfile_update`

type

ActionEventRequestResponseData<
		'diskfile_update',
		ActionInputs['diskfile_update'],
		ActionOutputs['diskfile_update']
	>

`diskfile_delete`

type

ActionEventRequestResponseData<
		'diskfile_delete',
		ActionInputs['diskfile_delete'],
		ActionOutputs['diskfile_delete']
	>

`directory_create`

type

ActionEventRequestResponseData<
		'directory_create',
		ActionInputs['directory_create'],
		ActionOutputs['directory_create']
	>

`completion_create`

type

ActionEventRequestResponseData<
		'completion_create',
		ActionInputs['completion_create'],
		ActionOutputs['completion_create']
	>

`completion_progress`

type

ActionEventRemoteNotificationData<
		'completion_progress',
		ActionInputs['completion_progress']
	>

`ollama_progress`

type

ActionEventRemoteNotificationData<
		'ollama_progress',
		ActionInputs['ollama_progress']
	>

`toggle_main_menu`

type

ActionEventLocalCallData<
		'toggle_main_menu',
		ActionInputs['toggle_main_menu'],
		ActionOutputs['toggle_main_menu']
	>

`ollama_list`

type

ActionEventRequestResponseData<
		'ollama_list',
		ActionInputs['ollama_list'],
		ActionOutputs['ollama_list']
	>

`ollama_ps`

type

ActionEventRequestResponseData<
		'ollama_ps',
		ActionInputs['ollama_ps'],
		ActionOutputs['ollama_ps']
	>

`ollama_show`

type

ActionEventRequestResponseData<
		'ollama_show',
		ActionInputs['ollama_show'],
		ActionOutputs['ollama_show']
	>

`ollama_pull`

type

ActionEventRequestResponseData<
		'ollama_pull',
		ActionInputs['ollama_pull'],
		ActionOutputs['ollama_pull']
	>

`ollama_delete`

type

ActionEventRequestResponseData<
		'ollama_delete',
		ActionInputs['ollama_delete'],
		ActionOutputs['ollama_delete']
	>

`ollama_copy`

type

ActionEventRequestResponseData<
		'ollama_copy',
		ActionInputs['ollama_copy'],
		ActionOutputs['ollama_copy']
	>

`ollama_create`

type

ActionEventRequestResponseData<
		'ollama_create',
		ActionInputs['ollama_create'],
		ActionOutputs['ollama_create']
	>

`ollama_unload`

type

ActionEventRequestResponseData<
		'ollama_unload',
		ActionInputs['ollama_unload'],
		ActionOutputs['ollama_unload']
	>

`provider_load_status`

type

ActionEventRequestResponseData<
		'provider_load_status',
		ActionInputs['provider_load_status'],
		ActionOutputs['provider_load_status']
	>

`provider_update_api_key`

type

ActionEventRequestResponseData<
		'provider_update_api_key',
		ActionInputs['provider_update_api_key'],
		ActionOutputs['provider_update_api_key']
	>

`terminal_create`

type

ActionEventRequestResponseData<
		'terminal_create',
		ActionInputs['terminal_create'],
		ActionOutputs['terminal_create']
	>

`terminal_data_send`

type

ActionEventRequestResponseData<
		'terminal_data_send',
		ActionInputs['terminal_data_send'],
		ActionOutputs['terminal_data_send']
	>

`terminal_data`

type ActionEventRemoteNotificationData<'terminal_data', ActionInputs['terminal_data']>

`terminal_resize`

type

ActionEventRequestResponseData<
		'terminal_resize',
		ActionInputs['terminal_resize'],
		ActionOutputs['terminal_resize']
	>

`terminal_close`

type

ActionEventRequestResponseData<
		'terminal_close',
		ActionInputs['terminal_close'],
		ActionOutputs['terminal_close']
	>

`terminal_exited`

type

ActionEventRemoteNotificationData<
		'terminal_exited',
		ActionInputs['terminal_exited']
	>

`workspace_open`

type

ActionEventRequestResponseData<
		'workspace_open',
		ActionInputs['workspace_open'],
		ActionOutputs['workspace_open']
	>

`workspace_close`

type

ActionEventRequestResponseData<
		'workspace_close',
		ActionInputs['workspace_close'],
		ActionOutputs['workspace_close']
	>

`workspace_list`

type

ActionEventRequestResponseData<
		'workspace_list',
		ActionInputs['workspace_list'],
		ActionOutputs['workspace_list']
	>

`workspace_changed`

type

ActionEventRemoteNotificationData<
		'workspace_changed',
		ActionInputs['workspace_changed']
	>

ActionInputs
#

{ readonly heartbeat: ZodDefault<ZodObject<{}, $strict>>; readonly cancel: ZodObject<{ request_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 29 more ...; readonly workspace_changed: ZodObject<...>; }

Action parameter schemas indexed by method name.
These represent the input data for each action,
e.g. JSON-RPC request/notification params and local call arguments.

ActionJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; method: ZodEnum<...>; action_event_data: ZodOptional<...>; }, $strict>

ActionJsonInput
#

ActionList.svelte view source

{ method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_data?: { .....

ActionList
#

`limit?`

type number | undefined

optional

`selected_action_id?`

type string | null | undefined

optional

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

`onselect?`

type ((action: Action) => void) | undefined

optional

ActionListitem
#

ActionListitem.svelte view source

`action`

type Action

`selected?`

type boolean

optional

`onselect?`

type ((action: Action) => void) | undefined

optional

ActionMethod
#

ZodEnum<{ ping: "ping"; session_load: "session_load"; filer_change: "filer_change"; diskfile_update: "diskfile_update"; diskfile_delete: "diskfile_delete"; directory_create: "directory_create"; ... 25 more ...; cancel: "cancel"; }>

All action method names. Request/response actions have two types per method.

ActionOptions
#

ActionOptions

inheritance

extends:

CellOptions<typeof ActionJson>

ActionOutputs
#

{ readonly heartbeat: ZodObject<{}, $strict>; readonly cancel: ZodVoid; readonly ping: ZodObject<{ ping_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 28 more ...; readonly workspace_changed: ZodVoid; }

Action result schemas indexed by method name.
These represent the output data for each action,
e.g. JSON-RPC response results and local call return values.

Actions
#

Stores the action history.

inheritance

extends:

Cell<typeof ActionsJson>

`items`

type IndexedCollection<Action>

readonly

`history_limit`

type number

`constructor`

type new (options: ActionsOptions): Actions

`options`

type ActionsOptions

`set_json`

Override to populate the indexed collection after parsing JSON.

type (value?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | ... 26 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_data?: { ...; } | undefined; }[] | undefined; } | undefined): void

`value?`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | ... 26 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_dat...

optional

returns void

`add`

type (action: Action): void

`action`

type Action

returns void

`add_from_json`

type (action_json: { method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_data?: { ...; } | undefined; }): Action

`action_json`

type

{ method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_data?: { .....

returns Action

ActionSchema
#

ZodCustom<Action, Action>

ActionsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; }, $strict>

ActionsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | ... 26 more ... | "cancel"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; action_event_dat...

ActionsOptions
#

ActionsOptions

inheritance

extends:

CellOptions<typeof ActionsJson>

`history_limit`

type number

ActionSpecs
#

{ readonly heartbeat: { method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodDefault<ZodObject<{}, $strict>>; output: ZodObject<...>; async: true; description: string; }; ... 30 more ...; readonly workspace_changed: { ...; }; }

Action specifications indexed by method name.
These represent the complete action spec definitions.

all_action_specs
#

({ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; ...

Canonical action spec list — fuz_app's protocol actions (heartbeat,
cancel) plus zzz-owned specs. Single source of truth for codegen and
runtime registries (Frontend.action_registry, Backend.action_registry).
Codegen helpers default-filter protocol actions out of typed surfaces
(FrontendActionsApi, BackendActionHandlers, ActionMethod, etc.) since
they're dispatcher-owned. Server WS registration pairs protocol specs with
fuz_app-shipped handlers via protocol_actions; iteration over
all_action_specs skips them via is_protocol_action_method to avoid
double-registration. Adding a future protocol action requires no consumer
edit — fuz_app's protocol_action_specs is the upstream canonical bundle.

Any
#

ZodAny

API_PATH
#

string

API_PATH_FOR_HTTP_RPC
#

string

API_URL
#

string

API_URL_FOR_HTTP_RPC
#

app.svelte.ts view source

string

App
#

The App is the user's implementation of the Zzz client app.
It extends Frontend and should be able to customize as much as possible,
including both behaviors and types. (both a work in progress)

inheritance

extends:

Frontend

`constructor`

type new (options?: AppOptions | undefined): App

`options?`

type AppOptions | undefined

optional

app_context
#

app.svelte.ts view source

{ get: (error_message?: string | undefined) => App; get_maybe: () => App | undefined; set: (value: App) => App; }

This is an example of a user-typed alias of frontend_context.
I like this pattern in my apps but there are other patterns too.

AppOptions
#

app.svelte.ts view source

AppOptions

inheritance

extends:

FrontendOptions

Backend
#

Server for managing the Zzz application state and handling client messages.

inheritance

implements:

ActionEventEnvironment

`executor`

type ActionExecutor

readonly

`zzz_dir`

The full path to the Zzz directory.

type DiskfileDirectoryPath

readonly

`scoped_dirs`

Filesystem paths that Zzz can access for user files.

type ReadonlyArray<DiskfileDirectoryPath>

readonly

`config`

type ZzzOptions

readonly

`peer`

type ActionPeer

readonly

`api`

API for backend-initiated actions.

type BackendActionsApi

readonly

`pty_manager`

Manages spawned PTY processes for terminal integration.

type PtyManager

readonly

`scoped_fs`

ScopedFs filesystem interface that restricts operations to allowed directories.

type ScopedFs

readonly

`log`

type Logger | null

readonly

`filers`

type Map<string, FilerInstance>

readonly

`action_registry`

readonly

`providers`

Available AI providers.

type Array<BackendProvider>

readonly

`constructor`

type new (options: BackendOptions): Backend

`options`

type BackendOptions

`lookup_action_handler`

type (): undefined

returns undefined

`lookup_action_spec`

type (method: string): { method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 7 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; } | undefined

`method`

type string

returns

{ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; }...

`lookup_provider`

type <T extends keyof BackendProviders>(provider_name: T): BackendProviders[T]

`provider_name`

type T

returns BackendProviders[T]

`destroy`

Server teardown and cleanup.

type (): Promise<void>

returns Promise<void>

`add_provider`

type (provider: BackendProvider<unknown>): void

`provider`

type BackendProvider<unknown>

returns void

`workspaces`

Tracks open workspaces by path.

type Map<string, WorkspaceInfoJson>

readonly

`workspace_open`

Open a workspace directory — adds to ScopedFs, starts a Filer, and persists.

type (path: string, opened_at?: string | undefined): Promise<{ workspace: { path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; name: string; opened_at: string; }; files: { ...; }[]; }>

`path`

absolute directory path

type string

`opened_at?`

optional timestamp to preserve (e.g. from persisted state)

type string | undefined

optional

returns

Promise<{ workspace: { path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; name: string; opened_at: string; }; files: { id: string & $brand<"DiskfilePath">; ... 5 more ...; dependencies: [...][]; }[]; }>

the workspace info and initial file tree

`workspace_close`

Close a workspace directory — stops Filer, removes from ScopedFs, and persists.
Preserves Filers and ScopedFs entries for initial scoped_dirs.

type (path: string): Promise<boolean>

`path`

type string

returns Promise<boolean>

`workspaces_ready`

Wait for persisted workspaces to finish restoring.
Call before returning workspace data to clients.

type (): Promise<void>

returns Promise<void>

`workspace_list`

List all open workspaces.

type (): { path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; name: string; opened_at: string; }[]

returns { path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; name: string; opened_at: string; }[]

BACKEND_ARTIFICIAL_RESPONSE_DELAY
#

server/backend_action_types.ts view source

number

BackendActionHandlers
#

BackendActionHandlers

Typed handler map for request_response actions the backend handles.
One entry per BackendRequestResponseMethod; each handler receives the typed input
and returns the typed output (sync or async).

BackendActionMethod
#

server/backend_action_types.ts view source

ZodEnum<{ ping: "ping"; session_load: "session_load"; filer_change: "filer_change"; diskfile_update: "diskfile_update"; diskfile_delete: "diskfile_delete"; directory_create: "directory_create"; ... 24 more ...; cancel: "cancel"; }>

Names of all actions the backend may encounter — request_response and remote_notification (local_call is frontend-only).

BackendActionsApi
#

BackendActionsApi

Typed dispatch surface for backend-initiated calls. Symmetric counterpart
of FrontendActionsApi. Today exposes broadcast-style remote_notification
methods (1→N fan-out via create_broadcast_api); request-scoped streaming
goes through ctx.notify inside a handler — it's socket-scoped, not a
broadcast. Will widen when a second backend runtime constructor (targeted
send, backend-initiated request_response) lands.

`filer_change`

type (input: ActionInputs['filer_change']) => Promise<void>

`terminal_data`

type (input: ActionInputs['terminal_data']) => Promise<void>

`terminal_exited`

type (input: ActionInputs['terminal_exited']) => Promise<void>

`workspace_changed`

type (input: ActionInputs['workspace_changed']) => Promise<void>

BackendOptions
#

BackendOptions

`zzz_dir`

Zzz directory path, defaults to .zzz.

type string

`scoped_dirs`

Filesystem paths that Zzz can access for user files.

type Array<string>

`config`

Configuration for the backend and AI providers.

type ZzzOptions

`action_specs`

Action specifications that determine what the backend can do.

type Array<ActionSpecUnion>

`handle_filer_change`

Handler function for file system changes.

type FilerChangeHandler

`log`

Optional logger instance.
Disabled when null, and undefined falls back to a new Logger instance.

type Logger | null | undefined

BackendProvider
#

Base class for all backend AI providers.
Provides shared functionality for completion handlers and logging.

generics

`TClient`

default unknown

`name`

type string

abstractreadonly

`client`

type TClient | null

protected

`provider_status`

type ProviderStatus | null

protected

`handle_streaming_completion`

type (options: CompletionHandlerOptions): Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { ...; } | ... 2 more ... | { ...; }; }; _meta?: { ...; } | undefined; }>

abstract

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`handle_non_streaming_completion`

abstract

`options`

server/backend_provider_chatgpt.ts view source

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`get_handler`

type (streaming: boolean): CompletionHandler

`streaming`

type boolean

returns CompletionHandler

`create_client`

type (): void

protectedabstract

returns void

`get_client`

Get the client, throwing an error if not configured.

type (): TClient

abstract

returns TClient

`load_status`

Get status for this provider. Override for custom availability checks.

type (reload?: boolean | undefined): Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

abstract

`reload?`

type boolean | undefined

optional

returns

Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

`invalidate_status`

Invalidate cached status, forcing next load to fetch fresh data.

type (): void

returns void

`validate_streaming_requirements`

Validates that progress_token is provided for streaming requests.

type (progress_token?: (string & $brand<"Uuid">) | undefined): asserts progress_token

protected

`progress_token?`

type (string & $brand<"Uuid">) | undefined

optional

returns void

`send_streaming_progress`

Sends a streaming progress notification to the originating socket.

type (progress_token: string & $brand<"Uuid">, chunk: { [x: string]: unknown; model?: string | undefined; created_at?: string | undefined; done?: boolean | undefined; message?: { [x: string]: unknown; role: string; content: string; } | undefined; } | undefined, on_progress: OnCompletionProgress): Promise<...>

protected

`progress_token`

type string & $brand<"Uuid">

`chunk`

type

{ [x: string]: unknown; model?: string | undefined; created_at?: string | undefined; done?: boolean | undefined; message?: { [x: string]: unknown; role: string; content: string; } | undefined; } | undefined

`on_progress`

type OnCompletionProgress

returns Promise<void>

`log_streaming_chunk`

Logs streaming chunk information.

type (chunk: unknown): void

protected

`chunk`

type unknown

returns void

`log_streaming_completion`

Logs streaming completion information.

type (accumulated_length: number): void

protected

`accumulated_length`

type number

returns void

`log_non_streaming_response`

Logs non-streaming response information.

type (response: unknown): void

protected

`response`

type unknown

returns void

`log_api_response`

Logs final API response information.

type (api_response: unknown): void

protected

`api_response`

type unknown

returns void

BackendProviderChatgpt
#

inheritance

extends:

BackendProviderRemote<OpenAI>

`name`

readonly

`create_client`

type (): void

protected

returns void

`handle_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`handle_non_streaming_completion`

`options`

server/backend_provider_claude.ts view source

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

BackendProviderClaude
#

inheritance

extends:

BackendProviderRemote<Anthropic>

`name`

readonly

`create_client`

type (): void

protected

returns void

`handle_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`handle_non_streaming_completion`

`options`

server/backend_provider_gemini.ts view source

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

BackendProviderGemini
#

inheritance

extends:

BackendProviderRemote<GoogleGenerativeAI>

`name`

readonly

`create_client`

type (): void

protected

returns void

`handle_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`handle_non_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

BackendProviderLocal
#

server/backend_provider_ollama.ts view source

Base class for locally-installed providers (Ollama).
Handles installation checking and provides default error handling for missing installations.

generics

`TClient`

default unknown

inheritance

extends:

BackendProvider<TClient>

`constructor`

type new <TClient = unknown>(): BackendProviderLocal<TClient>

`get_client`

type (): TClient

returns TClient

BackendProviderOllama
#

inheritance

extends:

BackendProviderLocal<Ollama>

`name`

readonly

`create_client`

type (): void

protected

returns void

`load_status`

type (reload?: boolean): Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

`reload`

type boolean

default false

returns

Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

`handle_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

`handle_non_streaming_completion`

`options`

returns

Promise<{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }>

BackendProviderRemote
#

Base class for remote API-based providers (Claude, ChatGPT, Gemini).
Handles API key management and provides default error handling for missing keys.

generics

`TClient`

default unknown

inheritance

extends:

BackendProvider<TClient>

`api_key`

type string | null

protected

`constructor`

type new <TClient = unknown>(options: BackendProviderRemoteOptions): BackendProviderRemote<TClient>

`options`

type BackendProviderRemoteOptions

`set_api_key`

Update the API key and recreate the client.

type (api_key: string | null): void

`api_key`

type string | null

returns void

`get_client`

type (): TClient

returns TClient

`load_status`

type (reload?: boolean): Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

`reload`

type boolean

default false

returns

Promise<{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }>

BackendProviderRemoteOptions
#

BackendProviderRemoteOptions

`api_key`

type string | null

BackendRequestResponseMethod
#

ZodEnum<{ ping: "ping"; session_load: "session_load"; diskfile_update: "diskfile_update"; diskfile_delete: "diskfile_delete"; directory_create: "directory_create"; completion_create: "completion_create"; ... 16 more ...; workspace_list: "workspace_list"; }>

Names of request_response actions the backend handles (initiator excludes backend).

BOTS_DEFAULT
#

server/backend_action_types.ts view source

{ namerbot: string; }

broadcast_action_specs
#

readonly ({ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } ...

BroadcastActionMethod
#

ZodEnum<{ filer_change: "filer_change"; terminal_data: "terminal_data"; terminal_exited: "terminal_exited"; workspace_changed: "workspace_changed"; }>

Names of remote_notification actions exposed by the broadcast API (backend-initiated, excluding request-scoped progress notifications named by another action's streams).

build_allowed_hostnames
#

server/zzz_route_specs.ts view source

(bind_host: string): Set<string>

Build the set of allowed hostnames for Host header validation
based on the server's bind address.
When binding to localhost or 127.0.0.1, both are allowed
(they refer to the same interface). When binding to 0.0.0.0,
all local hostnames are allowed since we can't know which
interface the request arrived on.

`bind_host`

the address the server is binding to

type string

returns

Set<string>

set of hostnames to accept in the Host header

build_rpc_endpoint_specs
#

(ctx: AppServerContext, zzz_deps: ZzzRpcDeps): RpcEndpointSpec[]

Build the /api/rpc endpoint spec(s) for create_app_server.
Pass to rpc_endpoints as a factory — closes over ctx.deps +
ctx.app_settings for the standard admin + role-grant-offer + account
action set. create_app_server auto-mounts each entry via
create_rpc_endpoint.

`ctx`

type AppServerContext

`zzz_deps`

type ZzzRpcDeps

returns

RpcEndpointSpec[]

calculate_reorderable_target_index
#

(source_index: number, current_index: number, position: ReorderableValidDropPosition): number

Calculate the target index based on source, current index, and position.

`source_index`

type number

`current_index`

type number

`position`

type ReorderableValidDropPosition

returns

number

Capabilities
#

A class that encapsulates system capabilities detection and management.
This is NOT generic or extensible - it contains hardcoded logic for
all capabilities the system supports.

inheritance

extends:

Cell<typeof CapabilitiesJson>

`backend`

type Capability<ServerCapabilityData | null | undefined>

`websocket`

WebSocket capability that derives its state from the socket.

type Capability<WebsocketCapabilityData | null | undefined>

readonly

`filesystem`

The filesystem capability derives its state from the backend and zzz_dir.

type Capability<FilesystemCapabilityData | null | undefined>

readonly

`ollama`

Ollama capability that derives its state from provider_status (authoritative)
and app.ollama (for richer data when available).

type Capability<OllamaCapabilityData | null | undefined>

readonly

`claude`

Claude capability that derives its state from provider_status.

type Capability<null | undefined>

readonly

`chatgpt`

ChatGPT capability that derives its state from provider_status.

type Capability<null | undefined>

readonly

`gemini`

Gemini capability that derives its state from provider_status.

type Capability<null | undefined>

readonly

`pings`

Store pings - both pending and completed.

type Array<PingData>

`latest_ping_time`

Most recent completed ping round trip time in milliseconds.

type number | null

readonly

`completed_pings`

Completed pings (for display).

type Array<PingData>

readonly

`pending_ping_count`

Number of pending pings.

type number

readonly

`has_pending_pings`

Has pending pings.

type boolean

readonly

`backend_available`

Convenience accessor for backend availability.
undefined means uninitialized, null means loading/checking.
boolean indicates if available.

type boolean | null | undefined

readonly

`ollama_available`

Convenience accessor for ollama availability.
undefined means uninitialized, null means loading/checking.
boolean indicates if available.

type boolean | null | undefined

readonly

`websocket_available`

Convenience accessor for websocket availability.
undefined means uninitialized, null means loading/checking.
boolean indicates if the socket is actively connected.

type boolean | null | undefined

readonly

`filesystem_available`

Convenience accessor for filesystem availability.
undefined means uninitialized, null means loading/checking.
boolean indicates if filesystem is available.

type boolean | null | undefined

readonly

`ollama_models`

Latest Ollama model list response, if available.

type Array<{ name: string; size: number; model_response: OllamaListResponseItem; }>

readonly

`constructor`

type new (options: CellOptions<ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; }, $strict>>): Capabilities

`options`

type

CellOptions<ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; }, $strict>>

`init_backend_check`

Check backend availability only if it hasn't been checked before.
(when status is 'initial')

type (): Promise<void>

returns Promise<void>

`check_backend`

Check backend availability with a ping.

type (): Promise<void>

returns Promise<void>

`init_ollama_check`

Check Ollama availability only if it hasn't been checked before.
(when status is 'initial')

type (): Promise<void>

returns Promise<void>

`check_ollama`

Check Ollama availability by loading provider status and refreshing models.

type (): Promise<void>

returns Promise<void>

`handle_ping_sent`

type (request_id: string | number): void

`request_id`

type string | number

returns void

`handle_ping_received`

type (ping_id: string | number): void

`ping_id`

type string | number

returns void

`handle_ping_error`

type (ping_id: string | number, error_message: string): void

`ping_id`

type string | number

`error_message`

type string

returns void

`reset_backend`

Reset just the backend capability to uninitialized state.

type (): void

returns void

`init_claude_check`

Check Claude availability only if it hasn't been checked before.

type (): Promise<void>

returns Promise<void>

`check_claude`

Check Claude availability by loading provider status.

type (): Promise<void>

returns Promise<void>

`init_chatgpt_check`

Check ChatGPT availability only if it hasn't been checked before.

type (): Promise<void>

returns Promise<void>

`check_chatgpt`

Check ChatGPT availability by loading provider status.

type (): Promise<void>

returns Promise<void>

`init_gemini_check`

Check Gemini availability only if it hasn't been checked before.

type (): Promise<void>

returns Promise<void>

`check_gemini`

Check Gemini availability by loading provider status.

type (): Promise<void>

returns Promise<void>

CapabilitiesJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; }, $strict>

CapabilitiesJsonInput
#

CapabilitiesView.svelte view source

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

CapabilitiesView
#

Capability
#

CapabilityBackend.svelte view source

Capability<T>

Generic interface for a capability with standardized status tracking.

generics

`T`

`name`

The capability name.

type string

`data`

The capability's status: undefined=not initialized, null=checking, otherwise available or not.

type T

`status`

Async status tracking the connection/check state.

type AsyncStatus

`message_id`

Message id of the last request for this capability's info, if any.

type JsonrpcRequestId | null

`error_message`

Error message if any.

type string | null

`updated`

Timestamp when the capability was last checked.

type number | null

CapabilityBackend
#

CapabilityFilesystem
#

CapabilityFilesystem.svelte view source

CapabilityProvider
#

CapabilityProvider.svelte view source

`provider_name`

type ProviderName

CapabilityProviderApi
#

CapabilityProviderApi.svelte view source

`provider_name`

type 'claude' | 'chatgpt' | 'gemini'

`show_info?`

type boolean

optional

CapabilityProviderOllama
#

CapabilityProviderOllama.svelte view source

CapabilitySystem
#

CapabilitySystem.svelte view source

CapabilityWebsocket
#

CapabilityWebsocket.svelte view source

`socket?`

type Socket | undefined

optional

Cell
#

cell.svelte.ts view source

The Cell is the base class for schema-driven data models in Zzz.
The goals are still evolving, but a main idea is to have fully reactive state
that can be flexibly snapshotted and reinstantiated in a typesafe, extensible system
that uses normal Svelte patterns.
The design aims for:
- Integration with Svelte's reactivity, encouraging single-depth inheritance
		with Svelte class patterns for both persistent and ephemeral state
- Schema-driven parsing/validation and JSON serialization/deserialization
		(supporting snapshot and restore/replay patterns) via Zod
- Custom property encoding/decoding for complex types,
		and no boilerplate for schema-inferrable properties
- Lifecycle management with generic instantiation/registration and disposal
		(conceptually a WIP, partially implemented)
- Runtime type metadata for reflection
Cells are automatically registered in the global registry by id,
making them discoverable and referenceable throughout the system.
Each cell has common properties including id and created/updated timestamps.
There are currently a lot of rough edges and missing features!
My hope is that this could be generic enough to extract to a library, but it's not there yet.
I assume there's a really nice design in this space that takes full advantage of Svelte runes.
Many things will be possible with this pattern, but it's still a work in progress.

generics

`TSchema`

constraint z.ZodType

default z.ZodType

inheritance

implements:

CellJson

`cid`

readonly

`id`

type Uuid

`created`

type Datetime

`updated`

type Datetime

`schema`

type TSchema

readonly

`schema_keys`

type Array<SchemaKeys<TSchema>>

readonly

`field_schemas`

type Map<SchemaKeys<TSchema>, z.ZodType>

readonly

`field_schema_info`

type Map<SchemaKeys<TSchema>, SchemaClassInfo | null>

readonly

`json`

type z.output<TSchema>

readonly

`json_serialized`

type string

readonly

`json_parsed`

type z.ZodSafeParseResult<z.output<TSchema>>

readonly

`app`

type Frontend

readonly

`decoders`

Type-safe decoders for custom field decoding.
Override in subclasses to handle special field types.
Each decoder function takes a value of any type and should either:
1. Return a value (including null) to be assigned to the property
2. Return undefined to use the default decoding behavior
3. Return HANDLED to indicate the decoder has fully processed the property
   (virtual properties MUST return HANDLED if they exist in schema but not in class)

type CellValueDecoder<TSchema>

protected

`created_date`

type Date

readonly

`created_formatted_short_date`

type string

readonly

`created_formatted_datetime`

type string

readonly

`created_formatted_time`

type string

readonly

`updated_date`

type Date

readonly

`updated_formatted_short_date`

type string

readonly

`updated_formatted_datetime`

type string

readonly

`updated_formatted_time`

type string

readonly

`constructor`

type new <TSchema extends z.ZodType = ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>(schema: TSchema, options: CellOptions<TSchema>): Cell<TSchema>

`schema`

type TSchema

`options`

type CellOptions<TSchema>

`init`

Initialize the instance with options.json data if provided.
Must be called before using the instance -
the current pattern is calling it at the end of subclass constructors.
We should investigate deferring to callers so e.g. instantiating from the registry
would init automatically, subclasses need no init logic (which can get unwieldy with inheritance),
and then callers could always do custom init patterns if they wanted.
Can't be called automatically by the Cell's constructor because
the subclass' constructor needs to run first to support field initialization.
A design goal behind the Cell is to support normal TS and Svelte patterns
with the most power and least intrusion. (there's a balance to find from Zzz's POV)

type (): void

protected

returns void

`dispose`

Clean up resources when this cell is no longer needed.

type (): void

returns void

`[Symbol.dispose]`

This is not supported in Safari, don't rely on this yet.
Uncomment temporarily to experiment in dev.

type (): void

returns void

`register`

Register this cell in the global cell registry.
Called automatically by init().

type (): void

protected

returns void

`unregister`

Unregister this cell from the global cell registry.
Called automatically by dispose().

type (): void

protected

returns void

`toJSON`

For Svelte's $snapshot.

type (): output<TSchema>

returns output<TSchema>

`to_json`

Encodes the cell's serializable state as JSON.
Use the derived cell.json if you don't need a fresh copy.

type (): output<TSchema>

returns output<TSchema>

`set_json`

Apply JSON data to this instance.
Overwrites all properties including 'id'.
Special-cases created and updated for synchronization.

type (value: input<TSchema> | undefined): void

`value`

type input<TSchema> | undefined

returns void

`set_json_partial`

Update only the specified properties on this instance.
Preserves current values for any properties not included in the input.

type (partial_value: Partial<input<TSchema>>): void

`partial_value`

type Partial<input<TSchema>>

returns void

`encode_property`

Encode a value during serialization. Can be overridden for custom encoding logic.
Defaults to Svelte's $state.snapshot,
which handles most cases and uses toJSON when available,
so overriding to_json is sufficient for most cases before overriding encode_property.

type (value: unknown, _key: string): unknown

`value`

type unknown

`_key`

type string

returns unknown

`decode_property`

Decode a value based on its schema type information.
This handles instantiating classes, transforming arrays, and special types.
Complex property types might require custom handling in parser functions
rather than using this general decoding mechanism.

type <K extends SchemaKeys<TSchema>>(value: unknown, key: K): any

`value`

type unknown

`key`

type K

returns any

`assign_property`

Process a single schema property during JSON deserialization.
This method handles the workflow for mapping schema properties to instance properties.
Flow:
1. If a decoder exists for this property, try to use it
2. If decoder returns HANDLED, consider the property fully handled (short circuit)
3. If decoder returns a value other than HANDLED or undefined, use that value
4. If decoder returns undefined, fall through to standard decoding
5. For properties not directly represented in the class instance but defined
   in the schema, the decoder MUST return HANDLED to indicate proper handling

type (key: SchemaKeys<TSchema>, value: unknown): void

protected

`key`

type SchemaKeys<TSchema>

`value`

type unknown

returns void

`clone`

Generic clone method that works for any subclass.

type (json?: input<TSchema> | undefined, options?: CellOptions<TSchema> | undefined): this

`json?`

type input<TSchema> | undefined

optional

`options?`

type CellOptions<TSchema> | undefined

optional

returns this

cell_classes
#

{ Parts: typeof Parts; Capabilities: typeof Capabilities; Chat: typeof Chat; Chats: typeof Chats; Diskfile: typeof Diskfile; DiskfileTab: typeof DiskfileTab; DiskfileTabs: typeof DiskfileTabs; ... 23 more ...; Workspaces: typeof Workspaces; }

CellClasses
#

{ Parts: typeof Parts; Capabilities: typeof Capabilities; Chat: typeof Chat; Chats: typeof Chats; Diskfile: typeof Diskfile; DiskfileTab: typeof DiskfileTab; DiskfileTabs: typeof DiskfileTabs; ... 23 more ...; Workspaces: typeof Workspaces; }

CellClassNames
#

"Action" | "Actions" | "Capabilities" | "Parts" | "Chat" | "Chats" | "Diskfile" | "DiskfileTab" | "DiskfileTabs" | "DiskfilePart" | "DiskfileHistory" | "Diskfiles" | "DiskfilesEditor" | ... 17 more ... | "Workspaces"

CellJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; }, $strict>

Base schema that defines common properties for all cells.

CellJsonInput
#

cell.svelte.ts view source

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

CellOptions
#

CellOptions<TSchema>

Any options besides these declared ones are ignored,
so they're safe to forward when subclassing without needing to extract the rest options.

generics

`TSchema`

constraint z.ZodType

`app`

type Frontend

`json`

type z.input<TSchema>

CellRegistry
#

cell_registry.svelte.ts view source

Registry for managing cell classes and their instances.
The goal is to allow dynamic instantiation of all cells from serializable JSON.
CellRegistry does not currently justify its weight/complexity and may be removed in the future,
but I want to continue exploring the ideas behind it until we get fully snapshottable UI.

`app`

type Frontend

readonly

`class_names`

type Array<string>

readonly

`all`

type Map<Uuid, Cell>

readonly

`constructor`

type new (app: Frontend): CellRegistry

`app`

type Frontend

`register`

Register a cell class with the registry.

type (constructor: ClassConstructor<Cell<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>>): void

`constructor`

type ClassConstructor<Cell<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>>

returns void

`unregister`

Unregister a cell class from the registry.

type (class_name: string): boolean

`class_name`

type string

returns boolean

`maybe_instantiate`

Attempt to instantiate a class, returning null if not found.
Logs an error in development if the class isn't registered.

type <K extends keyof CellRegistryMap>(class_name: K, json?: (CellRegistryMap[K] extends Cell<infer TSchema extends ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>> ? input<...> : never) | undefined, options?: object | undefined): CellRegistryMap[K] | null

`class_name`

type K

`json?`

type

(CellRegistryMap[K] extends Cell<infer TSchema extends ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>> ? input<TSchema> : never) | undefined

optional

`options?`

type object | undefined

optional

returns CellRegistryMap[K] | null

`instantiate`

Create an instance of a registered cell class by name.
Throws if the class isn't found.
Type is automatically inferred from class name literals.

`class_name`

type K

`json?`

type

(CellRegistryMap[K] extends Cell<infer TSchema extends ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>> ? input<TSchema> : never) | undefined

optional

`options?`

type object | undefined

optional

returns CellRegistryMap[K]

`add_cell`

type (cell: Cell<any>): void

`cell`

type Cell<any>

returns void

`remove_cell`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

CellRegistryMap
#

CellRegistryMap

CellValueDecoder
#

CellValueDecoder<TSchema, TKey>

Type helper for decoders that includes base schema properties.
Use this instead of ValueParser when creating decoders for cells
to properly type the base properties.

generics

`TSchema`

constraint z.ZodType

`TKey`

constraint keyof z.infer<TSchema>

default keyof z.infer<TSchema>

Chat
#

inheritance

extends:

Cell<typeof ChatJson>

`name`

type string

`thread_ids`

type Array<Uuid>

`main_input`

type string

`view_mode`

type ChatViewMode

`selected_thread_id`

type Uuid | null

`main_input_length`

type number

readonly

`main_input_token_count`

type number

readonly

`threads`

type Array<Thread>

readonly

`enabled_threads`

readonly

`selected_thread`

type Thread | undefined

readonly

`current_thread`

type Thread | undefined

readonly

`init_name_status`

type AsyncStatus

`constructor`

type new (options: ChatOptions): Chat

`options`

type ChatOptions

`add_thread`

type (model: Model, select?: boolean | undefined): void

`model`

type Model

`select?`

type boolean | undefined

optional

returns void

`add_threads_by_model_tag`

type (tag: string): void

`tag`

type string

returns void

`remove_thread`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`remove_threads`

type (ids: (string & $brand<"Uuid">)[]): void

`ids`

type (string & $brand<"Uuid">)[]

returns void

`remove_threads_by_model_tag`

type (tag: string): void

`tag`

type string

returns void

`remove_all_threads`

type (): void

returns void

`send_to_all`

type (content: string): Promise<void>

`content`

type string

returns Promise<void>

`send_to_thread`

type (thread_id: string & $brand<"Uuid">, content: string): Promise<void>

`thread_id`

type string & $brand<"Uuid">

`content`

type string

returns Promise<void>

`init_name_from_turns`

Uses an LLM to name the chat based on the user input and AI response.
Ignores failures and retries on next intention.

type (user_content: string, assistant_content: string): Promise<void>

`user_content`

type string

`assistant_content`

type string

returns Promise<void>

`select_thread`

Reorder threads by moving from one index to another

type (thread_id: (string & $brand<"Uuid">) | null): void

`thread_id`

type (string & $brand<"Uuid">) | null

returns void

`reorder_threads`

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

chat_template_defaults
#

ChatContextmenu.svelte view source

ChatTemplate[]

Default chat templates available in the application

ChatContextmenu
#

`chat`

type Chat

`children`

type Snippet

ChatInitializer
#

ChatInitializer.svelte view source

`chat?`

type Chat

optional

`oninit?`

type (chat_id: Uuid) => void

optional

`heading?`

type string

optional

`items?`

type Array<Model>

optional

ChatJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 5 more ...; selected_thread_id: ZodDefault<...>; }, $strict>

ChatJsonInput
#

ChatList.svelte view source

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | undefined; selected_thread_id?: string | ... 1 more ... | undefined; }

ChatList
#

ChatListitem
#

ChatListitem.svelte view source

`chat`

type Chat

`selected?`

type boolean | undefined

optional

ChatOptions
#

ChatOptions

inheritance

extends:

CellOptions<typeof ChatJson>

Chats
#

inheritance

extends:

Cell<typeof ChatsJson>

`items`

type IndexedCollection<Chat>

readonly

`selected_id_last_non_null`

type Uuid | null

`selected`

type Chat | undefined

readonly

`selected_id_error`

type boolean

readonly

`show_sort_controls`

Controls visibility of sort controls in the chats list.

type boolean

`ordered_items`

Ordered array of chats derived from the manual_order index.

type Array<Chat>

readonly

`items_by_name`

readonly

`constructor`

type new (options: ChatsOptions): Chats

`options`

type ChatsOptions

`add`

type (json?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | undefined; selected_thread_id?: string | ... 1 more ... | undefined; } | undefined, select?: boolean | undefined): Chat

`json?`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | undefined; selected_thread_id?: string | ... 1 more ... | undefined; } | undefined

optional

`select?`

type boolean | undefined

optional

returns Chat

`generate_unique_name`

type (base_name?: string): string

`base_name`

type string

default 'new chat'

returns string

`add_chat`

type (chat: Chat, select?: boolean | undefined): Chat

`chat`

type Chat

`select?`

type boolean | undefined

optional

returns Chat

`add_many`

type (chats_json: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | undefined; selected_thread_id?: string | ... 1 more ... | undefined; }[], select?: number | ... 1 more ... | undefined): Chat[]

`chats_json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | undefined; selected_thread_id?: string | ... 1 more ... | undefined; }[]

`select?`

type number | boolean | undefined

optional

returns Chat[]

`remove`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`remove_many`

type (ids: (string & $brand<"Uuid">)[]): number

`ids`

type (string & $brand<"Uuid">)[]

returns number

`select`

type (chat_id: (string & $brand<"Uuid">) | null): Promise<void>

`chat_id`

type (string & $brand<"Uuid">) | null

returns Promise<void>

`select_next`

type (): Promise<void>

returns Promise<void>

`navigate_to`

type (chat_id: (string & $brand<"Uuid">) | null, force?: boolean): Promise<void>

`chat_id`

type (string & $brand<"Uuid">) | null

`force`

type boolean

default false

returns Promise<void>

`reorder_chats`

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

`toggle_sort_controls`

Toggles the visibility of sort controls in the chats list.

type (value?: boolean): void

`value`

type boolean

default !this.show_sort_controls

returns void

`chat_templates`

`get_template_by_id`

type (id: string): ChatTemplate | undefined

`id`

type string

returns ChatTemplate | undefined

`get_default_template`

type (): ChatTemplate

returns ChatTemplate

ChatSchema
#

ChatsContextmenu.svelte view source

ZodCustom<Chat, Chat>

ChatsContextmenu
#

`children`

type Snippet

ChatsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 4 more ...; show_sort_controls: ZodDefault<...>; }, $strict>

ChatsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; thread_ids?: string[] | undefined; main_input?: string | undefined; view_mode?: "simple" | ... 1 more ... | ...

ChatsOptions
#

ChatsOptions

inheritance

extends:

CellOptions<typeof ChatsJson>

ChatsSchema
#

chat_template.ts view source

ZodCustom<Chats, Chats>

ChatTemplate
#

ChatTemplate

Represents a template for creating a new chat with specific model configurations

`id`

type Uuid

`name`

Human-readable name of the template.

type string

`model_names`

List of model names to include in chats created from this template.

type Array<string>

ChatThread
#

ChatThread.svelte view source

`thread`

type Thread

`onsend`

type (input: string) => Promise<void>

`focus_key?`

type string | number | null | undefined

optional

`pending_element_to_focus_key?`

type string | number | null | undefined

optional bindable

`turns_attrs?`

type SvelteHTMLElements['div'] | undefined

optional

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

ChatThreadAddByModel
#

ChatThreadAddByModel.svelte view source

`chat`

type Chat

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

`children?`

type Snippet | undefined

optional

ChatThreadManageByTag
#

ChatThreadManageByTag.svelte view source

`chat`

type Chat

ChatView
#

ChatView.svelte view source

`chat`

type Chat

ChatViewMode
#

ChatViewMulti.svelte view source

"simple" | "multi"

ChatViewMulti
#

`chat`

type Chat

ChatViewSimple
#

ChatViewSimple.svelte view source

`chat`

type Chat

`thread`

type Thread | undefined

ClassNotRegisteredError
#

cell_registry.svelte.ts view source

Error thrown when attempting to instantiate an unregistered class.

inheritance

extends:

Error

`class_name`

type string

readonly

`available_classes`

type Array<string>

readonly

`constructor`

type new (class_name: string, available_classes: string[], options?: ErrorOptions | undefined): ClassNotRegisteredError

`class_name`

type string

`available_classes`

type string[]

`options?`

type ErrorOptions | undefined

optional

ClearRestoreButton
#

ClearRestoreButton.svelte view source

`value`

type string

bindable

`restore_icon?`

type Snippet | string | undefined

optional

`clear_icon?`

type Snippet | string | undefined

optional

click_outside
#

click_outside.svelte.ts view source

(cb: () => void): Attachment<HTMLElement>

Creates an attachment that calls cb when a mousedown occurs outside the element.

`cb`

type () => void

returns

Attachment<HTMLElement>

completion_create_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ completion_request: ZodObject<{ created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; provider_name: ZodEnum<...>; model: ZodString; prompt: ZodStrin...

completion_progress_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ chunk: ZodOptional<ZodObject<{ model: ZodOptional<ZodString>; created_at: ZodOptional<...>; done: ZodOptional<...>; message: ZodOptional<...>; }, $loose>>; _meta: ZodOptional<...>; }, $strict>; out...

CompletionCreateInput
#

ZodObject<{ completion_request: ZodObject<{ created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; model: ZodString; prompt: ZodString; completion_messages: ZodOptional<...>; }, $strict>; _meta: ZodOp...

Input for completion_create.

CompletionCreateOutput
#

ZodObject<{ completion_response: ZodObject<{ created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; model: ZodString; data: ZodDiscriminatedUnion<...>; }, $strict>; _meta: ZodOptional<...>; }, $strict>

Output for completion_create.

CompletionHandler
#

CompletionHandler

CompletionHandlerOptions
#

CompletionHandlerOptions

`model`

type string

`completion_options`

type CompletionOptions

`completion_messages`

type Array<CompletionMessage> | undefined

`prompt`

type string

`progress_token`

Opts into streaming notifications when provided.

type Uuid

`on_progress`

Routes progress chunks to the originating WS socket via ctx.notify.
Required for streaming handlers; ignored by non-streaming handlers.

type OnCompletionProgress

`signal`

Request-scoped cancel signal. Fires on WS socket close or when the client
sends a cancel notification for this request id. Providers must honor it
on long-running streams — forward to the SDK's native signal option, or
check signal.aborted inside async-iteration loops and break.

type AbortSignal

CompletionMessage
#

ZodObject<{ role: ZodString; content: ZodString; }, $loose>

CompletionOptions
#

CompletionOptions

`frequency_penalty`

type number

`output_token_max`

type number

`presence_penalty`

type number

`seed`

type number

`stop_sequences`

type Array<string>

`system_message`

type string

`temperature`

type number

`top_k`

type number

`top_p`

type number

CompletionProgressInput
#

ZodObject<{ chunk: ZodOptional<ZodObject<{ model: ZodOptional<ZodString>; created_at: ZodOptional<ZodString>; done: ZodOptional<ZodBoolean>; message: ZodOptional<...>; }, $loose>>; _meta: ZodOptional<...>; }, $strict>

Input for completion_progress.
TODO improve chunk schema. Today it's Ollama-shaped (model,
created_at, done, message); add done_reason, timing fields
(total_duration, load_duration, prompt_eval_*, eval_*),
thinking, images, tool_calls as more provider streams land.

CompletionRequest
#

ZodObject<{ created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; model: ZodString; prompt: ZodString; completion_messages: ZodOptional<...>; }, $strict>

CompletionResponse
#

ZodObject<{ created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; model: ZodString; data: ZodDiscriminatedUnion<...>; }, $strict>

CompletionRole
#

ZodString

CONTENT_PREVIEW_LENGTH
#

ContentEditor.svelte view source

100

ContentEditor
#

Focus the textarea element - exposed for parent components.

`content`

type string

bindable

`token_count?`

Estimated if not provided and show_stats is true.

type number | undefined

optional

`placeholder?`

type string | null | undefined

optional

`readonly?`

type boolean | undefined

optional

`show_stats?`

type boolean | undefined

optional

`show_actions?`

type boolean | undefined

optional

`textarea_height?`

type string | undefined

optional

`focus_key?`

type string | number | null | undefined

optional

`pending_element_to_focus_key?`

type string | number | null | undefined

optional bindable

`attrs?`

type SvelteHTMLElements['textarea'] | undefined

optional

`after?`

type Snippet | undefined

optional

`children?`

type Snippet | undefined

optional

`onsave?`

type ((value: string) => void) | undefined

optional

ContentPreview
#

ContentPreview.svelte view source

`content`

type string

`height?`

type string | undefined

optional

`min_height?`

type string | undefined

optional

`max_height?`

type string | undefined

optional

`attrs?`

type SvelteHTMLElements['pre'] | undefined

optional

ContentStats
#

ContentStats.svelte view source

`token_count`

type number

ContextmenuEntryCopyToClipboard
#

ContextmenuEntryCopyToClipboard.svelte view source

`content`

type string | Thunk<string> | undefined

`label?`

type string | undefined

optional

`preview?`

type string | undefined

optional

`preview_limit?`

type number | undefined

optional

`show_preview?`

type boolean | undefined

optional

`children?`

type Snippet | undefined

optional

ContextmenuEntryToggle
#

ContextmenuEntryToggle.svelte view source

`enabled`

type boolean

bindable

`label?`

type string | undefined

optional

`children?`

type Snippet<[enabled: boolean]> | undefined

optional

create_backend_actions_api
#

server/backend_actions_api.ts view source

(backend: Backend): BackendActionsApi

`backend`

type Backend

returns

BackendActionsApi

create_client_id
#

(): string

Creates an id suitable for insecure use on a single client, like for element ids.

returns

string

create_derived_index
#

<T extends IndexedItem, TResult extends Array<T> = T[]>(options: DerivedIndexOptions<T, TResult>): IndexDefinition<T, TResult, void>

Creates an incremental derived collection index.

`options`

type DerivedIndexOptions<T, TResult>

returns

IndexDefinition<T, TResult, void>

create_dynamic_index
#

frontend_action_handlers.ts view source

<T extends IndexedItem, F extends (...args: Array<any>) => any>(options: DynamicIndexOptions<T, F>): IndexDefinition<T, F, Parameters<F>[0]>

Create a dynamic index that computes results on-demand based on query parameters.

`options`

type DynamicIndexOptions<T, F>

returns

IndexDefinition<T, F, Parameters<F>[0]>

create_frontend_action_handlers
#

(frontend: Frontend): FrontendActionHandlers

`frontend`

type Frontend

returns

FrontendActionHandlers

create_host_validation_middleware
#

iterable_helpers.ts view source

(allowed_hostnames: Set<string>): Handler

Create middleware that validates the Host header against an allowlist.
Blocks requests whose Host header hostname doesn't match any allowed value.
The port portion of the Host header is stripped before comparison.
Requests without a Host header are allowed through (non-browser clients like curl or CLI).

`allowed_hostnames`

set of allowed hostnames (without port)

type Set<string>

returns

Handler

Hono middleware handler

create_map_by_property
#

<T, K extends keyof T>(items: Iterable<T>, property: K): Map<T[K], T>

Creates a Map from an iterable, keyed by a specified property.

`items`

type Iterable<T>

`property`

type K

returns

Map<T[K], T>

create_multi_index
#

<T extends IndexedItem, K>(options: MultiIndexOptions<T, K>): IndexDefinition<T, SvelteMap<K, T[]>, K>

Create a multi-value index (one key maps to many items).

`options`

type MultiIndexOptions<T, K>

returns

IndexDefinition<T, SvelteMap<K, T[]>, K>

create_single_index
#

<T extends IndexedItem, K>(options: SingleIndexOptions<T, K>): IndexDefinition<T, SvelteMap<K, T>, K>

Create a single-value index (one key maps to one item).

`options`

type SingleIndexOptions<T, K>

returns

IndexDefinition<T, SvelteMap<K, T>, K>

create_subcommand_router
#

<TContext>(routes: Record<string, SubcommandRoute<TContext>>, default_handler: ((ctx: TContext, flags: { help: boolean; version: boolean; }) => Promise<void>) | undefined, error_message: string): (remaining: ParsedArgs, ctx: TContext, flags: { ...; }) => Promise<...>

Create a subcommand router from route definitions.

`routes`

map of subcommand names to route definitions

type Record<string, SubcommandRoute<TContext>>

`default_handler`

optional handler for when no subcommand is provided

type ((ctx: TContext, flags: { help: boolean; version: boolean; }) => Promise<void>) | undefined

`error_message`

error message for unknown subcommands

type string

returns

(remaining: ParsedArgs, ctx: TContext, flags: { help: boolean; version: boolean; }) => Promise<void>

router function

create_turn_from_part
#

(part: PartUnion, role: string, json: Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; ... 5 more ...; error_message?: string | undefined; }, "role" | "part_ids">>): Turn

`part`

type PartUnion

`role`

type string

`json`

type

Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<"Uuid">)[]; ... 4 more ...; error_message?: string | undefined; }, "role" | "part_ids">>

returns

Turn

create_turn_from_parts
#

(parts: PartUnion[], role: string, json: Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; ... 5 more ...; error_message?: string | undefined; }, "role" | "part_ids">>): Turn

`parts`

type PartUnion[]

`role`

type string

`json`

type

Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<"Uuid">)[]; ... 4 more ...; error_message?: string | undefined; }, "role" | "part_ids">>

returns

Turn

create_turn_from_text
#

server/zzz_action_handlers.ts view source

(content: string, role: string, json: Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<...>)[]; ... 4 more ...; error_message?: string | undefined; }, "role" | "part_ids">>, app: Frontend): Turn

`content`

type string

`role`

type string

`json`

type

Partial<OmitStrict<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<"Uuid">)[]; ... 4 more ...; error_message?: string | undefined; }, "role" | "part_ids">>

`app`

type Frontend

returns

Turn

create_zzz_action_handlers
#

(backend: Backend): BackendActionHandlers

Build the 23 request_response handlers bound to a zzz Backend.
Logic sourced from the RPC versions (cleaner than the old WS handlers —
no Deno-only bug in provider_update_api_key, no console.log noise).

`backend`

type Backend

returns

BackendActionHandlers

create_zzz_app
#

server/create_zzz_app.ts view source

(options: CreateZzzAppOptions): Promise<ZzzApp>

Create the zzz Hono app with auth, database, Backend, providers, and endpoints.
This is the shared factory called by the server entry point.
Uses create_app_backend for database + auth, create_app_server for
middleware assembly, and wires zzz's domain Backend through route deps.

`options`

type CreateZzzAppOptions

returns

Promise<ZzzApp>

create_zzz_app_route_specs
#

server/zzz_route_specs.ts view source

(ctx: AppServerContext, zzz_deps: ZzzAppRouteDeps): RouteSpec[]

Build all zzz route specs.
Used by production server, integration tests, and attack surface helpers.
Does NOT include bootstrap routes (those are factory-managed by create_app_server).
Does NOT include the /api/rpc endpoint — create_app_server auto-mounts
every RpcEndpointSpec passed via rpc_endpoints. Consumers supply that
endpoint spec through build_rpc_endpoint_specs below.

`ctx`

type AppServerContext

`zzz_deps`

type ZzzAppRouteDeps

returns

RouteSpec[]

create_zzz_rpc_actions
#

server/zzz_rpc_actions.ts view source

(deps: ZzzRpcDeps): RpcAction[]

Create all zzz RPC actions.
Returns RpcAction[] for create_rpc_endpoint. Each handler is built
once at boot from create_zzz_action_handlers(backend); the handlers
close over backend and receive fuz_app's unified ActionContext
directly — no per-call adapter shim.
fuz_app's protocol actions (heartbeat, cancel) are excluded — cancel
is remote_notification (filtered by kind), and heartbeat's handler
lives in fuz_app's protocol_actions bundle (WS liveness only), so
HTTP RPC doesn't expose it.
BackendActionHandlers is keyed by BackendRequestResponseMethod,
which is generated from all_action_specs — so every non-protocol
request_response spec is guaranteed at compile time to have a handler.
The cast below is the unavoidable bridge from string to that union.

`deps`

type ZzzRpcDeps

returns

RpcAction[]

CreateZzzAppOptions
#

server/create_zzz_app.ts view source

CreateZzzAppOptions

Options for creating a zzz app.

`config`

Server environment configuration.

type ZzzServerConfig

`password`

Password hashing deps — argon2_password_deps for production, stubs for tests.

type PasswordHashDeps

`runtime`

Runtime filesystem operations.
Provided by create_deno_runtime or create_node_runtime.

type

{
		stat: (path: string) => Promise<StatResult | null>;
		read_text_file: (path: string) => Promise<string>;
		remove: (path: string) => Promise<void>;
	}

`get_connection_ip`

Extract the raw TCP connection IP from the Hono context.

type (c: Context) => string | undefined

daemon_start
#

zzz/commands/daemon.ts view source

(runtime: RuntimeDeps, args: { _: string[]; port?: number | undefined; host?: string | undefined; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Start the daemon in foreground mode.
CLI flags --port and --host override config values.

`runtime`

type RuntimeDeps

`args`

type { _: string[]; port?: number | undefined; host?: string | undefined; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

daemon_status
#

zzz/commands/daemon.ts view source

(runtime: RuntimeDeps, args: { _: string[]; json: boolean; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Show daemon status.

`runtime`

type RuntimeDeps

`args`

type { _: string[]; json: boolean; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

daemon_stop
#

zzz/commands/daemon.ts view source

(runtime: RuntimeDeps, _args: { _: string[]; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Stop the running daemon.

`runtime`

type RuntimeDeps

`_args`

type { _: string[]; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

DaemonStartArgs
#

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; port: ZodOptional<ZodNumber>; host: ZodOptional<ZodString>; }, $strict>

Daemon start arguments.

DaemonStatusArgs
#

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; json: ZodDefault<ZodBoolean>; }, $strict>

Daemon status arguments.

DaemonStopArgs
#

Dashboard.svelte view source

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; }, $strict>

Daemon stop arguments.

Dashboard
#

`children`

type Snippet

DashboardActions
#

DashboardActions.svelte view source

DashboardCapabilities
#

DashboardCapabilities.svelte view source

DashboardChats
#

DashboardChats.svelte view source

DashboardDiskfiles
#

DashboardDiskfiles.svelte view source

DashboardHeader
#

DashboardHeader.svelte view source

`header`

type Snippet

`children`

type Snippet

DashboardHome
#

DashboardHome.svelte view source

DashboardModels
#

DashboardModels.svelte view source

DashboardPrompts
#

DashboardPrompts.svelte view source

DashboardProviders
#

DashboardProviders.svelte view source

DashboardSettings
#

DashboardSettings.svelte view source

DEFAULT_AUTO_RECONNECT
#

true

DEFAULT_HEARTBEAT_INTERVAL
#

300000

DEFAULT_RECONNECT_DELAY
#

1000

DEFAULT_RECONNECT_DELAY_MAX
#

10000

defined
#

<T>(value: T | undefined): T

`value`

type T | undefined

returns

T

DerivedIndexOptions
#

DeskMenu.svelte view source

DerivedIndexOptions<T, TResult>

Options for derived indexes.

generics

`T`

constraint IndexedItem

`TResult`

constraint Array<T>

default Array<T>

inheritance

extends:

IndexOptions<T, void>

`compute`

Function that computes the derived collection from the full collection.

type (collection: IndexedCollection<T>) => TResult

`sort`

Optional sort function for the derived array.

type (a: T, b: T) => number

`onadd`

Optional custom add handler.

type (items: TResult, item: T, collection: IndexedCollection<T>) => TResult

`onremove`

Optional custom remove handler.

type (items: TResult, item: T, collection: IndexedCollection<T>) => TResult

DeskMenu
#

detect_reorderable_direction
#

(element: HTMLElement): ReorderableDirection

Detect layout direction from an element - supports flex and grid.

`element`

type HTMLElement

returns

ReorderableDirection

directory_create_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>; output: ZodNull; async: true; description: string; }

DirectoryCreateInput
#

diskfile.svelte.ts view source

ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>

Input for directory_create.

Diskfile
#

inheritance

extends:

Cell<typeof DiskfileJson>

`path`

type DiskfilePath

`source_dir`

type DiskfileDirectoryPath

`content`

type string | null

`part`

type PartUnion | undefined

readonly

`dependents`

type Array<[DiskfilePath, SerializableDisknode]>

`dependencies`

type Array<[DiskfilePath, SerializableDisknode]>

`dependencies_by_id`

type Map<DiskfilePath, SerializableDisknode>

readonly

`dependents_by_id`

type Map<DiskfilePath, SerializableDisknode>

readonly

`dependency_ids`

type Array<DiskfilePath>

readonly

`dependent_ids`

type Array<DiskfilePath>

readonly

`has_dependencies`

type boolean

readonly

`has_dependents`

type boolean

readonly

`dependencies_count`

type number

readonly

`dependents_count`

type number

readonly

`pathname`

e.g. .zzz/foo/bar.json

type string | null | undefined

readonly

`path_relative`

e.g. bar/foo.json

type string | null | undefined

readonly

`content_length`

type number

readonly

`content_token_count`

type number | null

readonly

`content_preview`

type string

readonly

`constructor`

type new (options: DiskfileOptions): Diskfile

`options`

type DiskfileOptions

diskfile_delete_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>; output: ZodNull; async: true; description: string; }

diskfile_update_action_spec
#

DiskfileActions.svelte view source

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; content: ZodString; }, $strict>; output: ZodNull; async: true; description: string; }

DiskfileActions
#

`diskfile`

type Diskfile

`editor_state`

type DiskfileEditorState

`readonly?`

type boolean | undefined

optional

`auto_save?`

type boolean | undefined

optional

DiskfileChange
#

ZodObject<{ type: ZodEnum<{ add: "add"; change: "change"; delete: "delete"; }>; path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>

DiskfileChangeType
#

DiskfileContextmenu.svelte view source

ZodEnum<{ add: "add"; change: "change"; delete: "delete"; }>

DiskfileContextmenu
#

`diskfile`

type Diskfile | null | undefined

`children`

type Snippet

DiskfileDeleteInput
#

ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>

Input for diskfile_delete.

DiskfileDirectoryPath
#

DiskfileEditorNav.svelte view source

$ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">

These always have a trailing slash.

DiskfileEditorNav
#

`editor_state`

type DiskfileEditorState

DiskfileEditorState
#

diskfile_editor_state.svelte.ts view source

Manages the editor state for a diskfile.

`app`

type Frontend

`diskfile`

type Diskfile

`unsaved_edit_entry_id`

type Uuid | null

`selected_history_entry_id`

type Uuid | null

`content_was_modified_by_user`

type boolean

`last_seen_disk_content`

type string | null

`original_content`

type string | null

readonly

`path`

type DiskfilePath

readonly

`has_changes`

readonly

`history`

type DiskfileHistory | undefined

readonly

`selected_history_entry`

readonly

`content_history`

type Array<HistoryEntry>

readonly

`saved_history_entries`

type Array<HistoryEntry>

readonly

`unsaved_history_entries`

type Array<HistoryEntry>

readonly

`has_history`

readonly

`has_unsaved_edits`

readonly

`can_clear_history`

readonly

`can_clear_unsaved_edits`

readonly

`unsaved_entry_ids`

readonly

`content_matching_entry_ids`

type Array<Uuid>

readonly

`original_length`

readonly

`current_length`

readonly

`length_diff`

readonly

`length_diff_percent`

readonly

`original_token_count`

readonly

`current_token_count`

readonly

`token_diff`

readonly

`token_diff_percent`

readonly

`constructor`

type new (options: { app: Frontend; diskfile: Diskfile; }): DiskfileEditorState

`options`

type { app: Frontend; diskfile: Diskfile; }

`reset`

Clear and reset the editor state to match the current diskfile content.

type (): void

returns void

`check_disk_changes`

Check if the diskfile content has changed on disk.
Call this when receiving file updates from the server.

type (): void

returns void

`save_changes`

Save changes to the diskfile.

type (): Promise<boolean>

returns Promise<boolean>

`set_content_from_history`

Set content from history entry.

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`update_diskfile`

Update the diskfile reference.
This allows reusing the same editor state instance with a new diskfile.

type (diskfile: Diskfile): void

`diskfile`

type Diskfile

returns void

`clear_history`

Clear content history, keeping only specific entries based on selection state.

type (): void

returns void

`clear_unsaved_edits`

Clear all unsaved edit entries from history and reset the editor state if needed.

type (): void

returns void

DiskfileEditorView
#

DiskfileEditorView.svelte view source

`diskfile`

type Diskfile

`onmodified?`

type (diskfile_id: Uuid) => void

optional

DiskfileExplorer
#

DiskfileExplorer.svelte view source

`empty?`

type Snippet | undefined

optional

DiskfileHistory
#

Stores edit history for a single diskfile.

inheritance

extends:

Cell<typeof DiskfileHistoryJson>

`path`

type DiskfilePath

`entries`

type Array<HistoryEntry>

`max_entries`

type number

`current_entry`

The most recent history entry (by creation timestamp)
Since entries are always kept sorted by creation time (newest first),
the most recent is always the first element.

type HistoryEntry | null

readonly

`constructor`

type new (options: DiskfileHistoryOptions): DiskfileHistory

`options`

type DiskfileHistoryOptions

`add_entry`

Add a new history entry.

type (content: string, options?: { is_disk_change?: boolean | undefined; is_unsaved_edit?: boolean | undefined; is_original_state?: boolean | undefined; label?: string | undefined; created?: number | undefined; }): { ...; }

`content`

type string

`options`

type

{ is_disk_change?: boolean | undefined; is_unsaved_edit?: boolean | undefined; is_original_state?: boolean | undefined; label?: string | undefined; created?: number | undefined; }

default EMPTY_OBJECT

returns

{ id: string & $brand<"Uuid">; created: number; content: string; label: string; is_disk_change: boolean; is_unsaved_edit: boolean; is_original_state: boolean; }

`find_entry_by_id`

Find a history entry by id.

type (id: string & $brand<"Uuid">): { id: string & $brand<"Uuid">; created: number; content: string; label: string; is_disk_change: boolean; is_unsaved_edit: boolean; is_original_state: boolean; } | undefined

`id`

type string & $brand<"Uuid">

returns

{ id: string & $brand<"Uuid">; created: number; content: string; label: string; is_disk_change: boolean; is_unsaved_edit: boolean; is_original_state: boolean; } | undefined

`get_content`

Get the content of a specific history entry.

type (id: string & $brand<"Uuid">): string | null

`id`

type string & $brand<"Uuid">

returns string | null

`clear_except_current`

Clear all history entries except the most recent one by creation time
and any entries that match the optional keep predicate.

type (keep?: ((entry: { id: string & $brand<"Uuid">; created: number; content: string; label: string; is_disk_change: boolean; is_unsaved_edit: boolean; is_original_state: boolean; }) => boolean) | undefined): void

`keep?`

type

((entry: { id: string & $brand<"Uuid">; created: number; content: string; label: string; is_disk_change: boolean; is_unsaved_edit: boolean; is_original_state: boolean; }) => boolean) | undefined

optional

returns void

DiskfileHistoryJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; path: $ZodBranded<...>; entries: ZodDefault<...>; max_entries: ZodDefault<...>; }, $strict>

Schema for the DiskfileHistory cell.

DiskfileHistoryJsonInput
#

{ path: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; entries?: { created: number; content: string; label: string; id?: string | undefined; is_disk_change?: boolean | undefined; is_unsaved_edit?: boolean | undefined; is_original_state?: boolean | undefined; }[] | undefi...

DiskfileHistoryOptions
#

DiskfileHistoryView.svelte view source

DiskfileHistoryOptions

DiskfileHistoryView
#

`editor_state`

type DiskfileEditorState

`onselectentry`

type (entry_id: Uuid) => void

`attrs?`

type SvelteHTMLElements['menu'] | undefined

optional

DiskfileInfo
#

DiskfileInfo.svelte view source

`diskfile`

type Diskfile

`editor_state`

type DiskfileEditorState

DiskfileJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 5 more ...; dependencies: ZodDefault<...>; }, $strict>

DiskfileJsonInput
#

DiskfileListitem.svelte view source

{ source_dir: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; path?: string | null | undefined; content?: string | null | undefined; dependents?: [...][] | ... 1 more ... | undefined; dependencies?: [...][] | ... 1 more ... | undefined; }

DiskfileListitem
#

`diskfile`

type Diskfile

`selected?`

type boolean | undefined

optional

`attrs?`

type Record<string, unknown>

optional

`onselect?`

open_not_preview indicates a "open_not_preview select"
like a doubleclick or enter keypress.

type (diskfile: Diskfile, open_not_preview: boolean) => void

optional

DiskfileMetrics
#

DiskfileMetrics.svelte view source

`editor_state`

type DiskfileEditorState

DiskfileOptions
#

diskfile.svelte.ts view source

DiskfileOptions

inheritance

extends:

CellOptions<typeof DiskfileJson>

DiskfilePart
#

Diskfile part - references content from a Diskfile.

inheritance

extends:

Part<typeof DiskfilePartJson>

`type`

readonly

`diskfile`

type Diskfile | null | undefined

readonly

`relative_path`

readonly

`constructor`

type new (options: DiskfilePartOptions): DiskfilePart

`options`

type DiskfilePartOptions

`link_editor_state`

Links this part to an editor state.

type (editor_state: { current_content: string; } | null): void

`editor_state`

type { current_content: string; } | null

returns void

DiskfilePartJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 11 more ...; has_xml_tag: ZodDefault<...>; }, $strict>

Diskfile part schema - references a diskfile.

DiskfilePartJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; xml_tag_name?: string | undefined; ... 6 more ...; has_xml_tag?: boolean | undefined; }

DiskfilePartOptions
#

DiskfilePartOptions

DiskfilePartSchema
#

DiskfilePartView.svelte view source

ZodCustom<DiskfilePart, DiskfilePart>

DiskfilePartView
#

`diskfile`

type Diskfile

DiskfilePath
#

DiskfilePicker.svelte view source

$ZodBranded<ZodString, "DiskfilePath", "out">

An absolute Unix-style file path.

DiskfilePicker
#

`onpick`

type (diskfile: Diskfile | undefined) => boolean | void

`filter?`

type ((diskfile: Diskfile) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

`selected_ids?`

type Array<Uuid> | undefined

optional

DiskfilePickerDialog
#

DiskfilePickerDialog.svelte view source

`onpick`

type (diskfile: Diskfile | undefined) => boolean | void

`show?`

type boolean | undefined

optional bindable

`filter?`

type ((diskfile: Diskfile) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

`selected_ids?`

type Array<Uuid> | undefined

optional

`dialog_props?`

type OmitStrict<ComponentProps<typeof Dialog>, 'children'> | undefined

optional

Diskfiles
#

diskfile.svelte.ts view source

inheritance

extends:

Cell<typeof DiskfilesJson>

`items`

type IndexedCollection<Diskfile>

readonly

`selected_file_id`

type Uuid | null

`selected_file`

type Diskfile | null

readonly

`editor`

The editor for managing diskfiles editing state.

type DiskfilesEditor

readonly

`constructor`

type new (options: DiskfilesOptions): Diskfiles

`options`

type DiskfilesOptions

`handle_change`

type (params: { change: { type: "add" | "change" | "delete"; path: string & $brand<"DiskfilePath">; }; disknode: { id: string & $brand<"DiskfilePath">; source_dir: string & $brand<...> & $brand<...>; ... 4 more ...; dependencies: [...][]; }; }): void

`params`

type

{ change: { type: "add" | "change" | "delete"; path: string & $brand<"DiskfilePath">; }; disknode: { id: string & $brand<"DiskfilePath">; source_dir: string & $brand<"DiskfilePath"> & $brand<...>; ... 4 more ...; dependencies: [...][]; }; }

returns void

`add`

type (json: { source_dir: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; path?: string | null | undefined; content?: string | null | undefined; dependents?: [...][] | ... 1 more ... | undefined; dependencies?: [...][] | ... 1 more ... | undefined; }, auto_select?: boolean): Diskfile

`json`

type

{ source_dir: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; path?: string | null | undefined; content?: string | null | undefined; dependents?: [...][] | ... 1 more ... | undefined; dependencies?: [...][] | ... 1 more ... | undefined; }

`auto_select`

type boolean

default true

returns Diskfile

`update`

type (path: string & $brand<"DiskfilePath">, content: string): Promise<void>

`path`

type string & $brand<"DiskfilePath">

`content`

type string

returns Promise<void>

`delete`

type (path: string & $brand<"DiskfilePath">): Promise<void>

`path`

type string & $brand<"DiskfilePath">

returns Promise<void>

`create_file`

type (filename: string, content?: string): Promise<void>

`filename`

type string

`content`

type string

default ''

returns Promise<void>

`create_directory`

type (dirname: string): Promise<void>

`dirname`

type string

returns Promise<void>

`get_by_path`

type (path: string & $brand<"DiskfilePath">): Diskfile | undefined

`path`

type string & $brand<"DiskfilePath">

returns Diskfile | undefined

`to_relative_path`

The value undefined means uninitialized, null means loading, '' means none.

type (path: string): string | null | undefined

`path`

type string

returns string | null | undefined

`select`

Select a diskfile by id and also update the editor tabs.
Default to the first file if id is undefined.
If id is null, it selects no file.
If open_not_preview is true, opens as a permanent tab, otherwise previews.

type (id: (string & $brand<"Uuid">) | null | undefined, open_not_preview?: boolean): void

`id`

type (string & $brand<"Uuid">) | null | undefined

`open_not_preview`

type boolean

default false

returns void

`select_next`

type (): void

returns void

DiskfileSchema
#

ZodCustom<Diskfile, Diskfile>

DiskfilesEditor
#

Editor state management for diskfiles.

inheritance

extends:

Cell<typeof DiskfilesEditorJson>

`show_sort_controls`

Controls visibility of sort controls in the file explorer.

type boolean

`tabs`

Tabs for managing the open diskfiles.

type DiskfileTabs

readonly

`constructor`

type new (options: DiskfilesEditorOptions): DiskfilesEditor

`options`

type DiskfilesEditorOptions

`preview_diskfile`

Opens a diskfile in preview mode.

type (diskfile_id: string & $brand<"Uuid">): void

`diskfile_id`

type string & $brand<"Uuid">

returns void

`open_diskfile`

Opens a diskfile in permanent mode.

type (diskfile_id: string & $brand<"Uuid">): void

`diskfile_id`

type string & $brand<"Uuid">

returns void

`reorder_tabs`

Reorders tabs.

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

`select_tab`

Selects a tab by id.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`close_tab`

Closes a tab by id.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`reopen_last_closed_tab`

Reopens the last closed tab.

type (): void

returns void

`promote_preview_tab`

Promotes the current preview tab to permanent.

type (): void

returns void

`open_tab`

Opens (makes permanent) a tab by id.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`handle_file_modified`

Handles when a diskfile's content is modified.

type (diskfile_id: string & $brand<"Uuid">): void

`diskfile_id`

type string & $brand<"Uuid">

returns void

`sync_selected_file`

Syncs the selected diskfile in diskfiles with the selected tab.

type (): void

returns void

`toggle_sort_controls`

Toggles the visibility of sort controls in the file explorer.

type (value?: boolean): void

`value`

type boolean

default !this.show_sort_controls

returns void

DiskfilesEditorJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; show_sort_controls: ZodDefault<...>; }, $strict>

DiskfilesEditorJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; show_sort_controls?: boolean | undefined; }

DiskfilesEditorOptions
#

DiskfilesEditorOptions

DiskfilesEditorSchema
#

ZodCustom<DiskfilesEditor, DiskfilesEditor>

DiskfilesJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; diskfiles: ZodDefault<...>; selected_file_id: ZodDefault<...>; }, $strict>

DiskfilesJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; diskfiles?: { source_dir: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; path?: string | ... 1 more ... | undefined; content?: string | ... 1 more ... | undefined; dependents?: [...][]...

DiskfilesOptions
#

DiskfilesOptions

inheritance

extends:

CellOptions<typeof DiskfilesJson>

DiskfileTab
#

inheritance

extends:

Cell<typeof DiskfileTabJson>

`diskfile_id`

type Uuid

`tabs`

Reference to the parent tabs collection,
allowing us to have collection-derived data,
at the cost of requiring exactly 1 parent.
This pattern is somewhat experimental -
the idea is it's more declarative to have things
like the "preview" or "selected" tabs be state on the collection,
so it doesn't need to be separately managed as state on each tab.

type DiskfileTabs

readonly

`is_preview`

Derived from parent collection's state.

type boolean

readonly

`is_selected`

Derived from parent collection's state.

type boolean

readonly

`diskfile`

type Diskfile | undefined

readonly

`constructor`

type new (options: DiskfileTabOptions): DiskfileTab

`options`

type DiskfileTabOptions

DiskfileTabJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; diskfile_id: $ZodBranded<...>; }, $strict>

DiskfileTabJsonInput
#

DiskfileTabListitem.svelte view source

{ diskfile_id: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

DiskfileTabListitem
#

`tab`

type DiskfileTab

`onselect`

type (tab: DiskfileTab) => void

`onclose`

type (tab: DiskfileTab) => void

`onopen`

type (tab: DiskfileTab) => void

DiskfileTabOptions
#

DiskfileTabOptions

inheritance

extends:

CellOptions<typeof DiskfileTabJson>

`tabs`

type DiskfileTabs

DiskfileTabs
#

Manages tabs for diskfiles in the editor with preview behavior.

inheritance

extends:

Cell<typeof DiskfileTabsJson>

`selected_tab_id`

type Uuid | null

`preview_tab_id`

type Uuid | null

`tab_order`

type Array<Uuid>

`recent_tab_ids`

type Array<Uuid>

`max_tab_history`

type number

`items`

type IndexedCollection<DiskfileTab>

`by_diskfile_id`

Map for looking up tabs by their associated diskfile_id.

type Map<Uuid, DiskfileTab>

readonly

`ordered_tabs`

Ordered array of tabs derived directly from tab_order.
Includes tabs in the explicit order plus any tabs not yet in the order.

type Array<DiskfileTab>

readonly

`selected_tab`

The currently selected tab.

type DiskfileTab | undefined

readonly

`selected_diskfile_id`

The selected tab's diskfile id.

type Uuid | null

readonly

`preview_tab`

The preview tab, if any.

type DiskfileTab | undefined

readonly

`recent_tabs`

type Array<DiskfileTab>

readonly

`recently_closed_tabs`

Recently closed tabs for potential reopening.

type Array<DiskfileTab>

`closed_tab_diskfiles`

Map of closed tab ids to their diskfile ids - used for browser navigation.

type SvelteMap<Uuid, Uuid>

readonly

`constructor`

type new (options: DiskfileTabsOptions): DiskfileTabs

`options`

type DiskfileTabsOptions

`find_most_recent_tab`

Returns the most recently accessed tab id that still exists,
excluding the specified tab id.

type (exclude_id: string & $brand<"Uuid">): (string & $brand<"Uuid">) | null

`exclude_id`

type string & $brand<"Uuid">

returns (string & $brand<"Uuid">) | null

`select_tab`

Sets the selected tab.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`preview_diskfile`

Handles preview state when opening a file.
If a preview tab for this file already exists, it just selects it.

type (diskfile_id: string & $brand<"Uuid">): DiskfileTab

`diskfile_id`

type string & $brand<"Uuid">

returns DiskfileTab

`open_diskfile`

Opens a diskfile as a permanent tab (not preview).
If the file is already in a preview tab, promotes it to permanent.

type (diskfile_id: string & $brand<"Uuid">): DiskfileTab

`diskfile_id`

type string & $brand<"Uuid">

returns DiskfileTab

`promote_preview_to_permanent`

Promotes the current preview tab to a permanent tab.

type (): boolean

returns boolean

true if a tab was promoted, false otherwise

`close_tab`

Closes a tab by id.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`navigate_to_tab`

Navigates to a tab by id. If the tab doesn't exist but was previously closed,
creates a preview tab for that diskfile.

type (tab_id: string & $brand<"Uuid">): { resulting_tab_id: (string & $brand<"Uuid">) | null; created_preview: boolean; }

`tab_id`

the tab id to navigate to

type string & $brand<"Uuid">

returns { resulting_tab_id: (string & $brand<"Uuid">) | null; created_preview: boolean; }

object containing the resulting tab id and a boolean indicating if a new tab was created

`open_tab`

Opens (makes permanent) a tab by id.

type (tab_id: string & $brand<"Uuid">): void

`tab_id`

type string & $brand<"Uuid">

returns void

`reorder_tabs`

Reorders tabs by dragging.

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

`reopen_last_closed_tab`

Reopens the last closed tab.

type (): void

returns void

`close_all_tabs`

Closes all tabs.

type (): void

returns void

DiskfileTabSchema
#

ZodCustom<DiskfileTab, DiskfileTab>

DiskfileTabsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 5 more ...; max_tab_history: ZodDefault<...>; }, $strict>

DiskfileTabsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; selected_tab_id?: string | null | undefined; preview_tab_id?: string | null | undefined; tab_order?: string[] | undefined; recent_tab_ids?: string[] | undefined; max_tab_history?: number | undefined; }

DiskfileTabsOptions
#

DiskfileTabsOptions

DiskfileTabsSchema
#

ZodCustom<DiskfileTabs, DiskfileTabs>

DiskfileUpdateInput
#

ZodObject<{ path: $ZodBranded<ZodString, "DiskfilePath", "out">; content: ZodString; }, $strict>

Input for diskfile_update.

disknode_to_diskfile_json
#

(disknode: { id: string & $brand<"DiskfilePath">; source_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; contents: string | null; ctime: number | null; mtime: number | null; dependents: [...][]; dependencies: [...][]; }, existing_id?: string & $brand<...>): { ...; }

Converts a SerializableDisknode to the DiskfileJson format.

`disknode`

the source file to convert

type

{ id: string & $brand<"DiskfilePath">; source_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; contents: string | null; ctime: number | null; mtime: number | null; dependents: [...][]; dependencies: [...][]; }

`existing_id`

optional existing Uuid to preserve id stability across updates

type string & $brand<"Uuid">

default create_uuid()

returns

{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; path: (string & $brand<"DiskfilePath">) | null; source_dir: string & ... 1 more ... & $brand<...>; content: string | null; dependents: [...][] | null; dependencies: [...][] | null; }

dispatch
#

<T extends Record<string, unknown>>(remaining: ParsedArgs, schema: ZodType<T, unknown, $ZodTypeInternals<T, unknown>>, handler: (args: T) => Promise<void>): Promise<...>

Parse args and dispatch to handler, with error handling.

`remaining`

remaining args after global flag extraction

type ParsedArgs

`schema`

Zod schema for the command

type ZodType<T, unknown, $ZodTypeInternals<T, unknown>>

`handler`

command handler to call with parsed args

type (args: T) => Promise<void>

returns

Promise<void>

DRAG_OVER_BOTTOM_CLASS_DEFAULT
#

"drag-over-bottom"

DRAG_OVER_CLASS_DEFAULT
#

"drag-over"

DRAG_OVER_LEFT_CLASS_DEFAULT
#

"drag-over-left"

DRAG_OVER_RIGHT_CLASS_DEFAULT
#

"drag-over-right"

DRAG_OVER_TOP_CLASS_DEFAULT
#

"drag-over-top"

DRAGGING_CLASS_DEFAULT
#

"dragging"

DURATION_LG
#

1000

DURATION_SM
#

180

DynamicIndexOptions
#

EditableText.svelte view source

DynamicIndexOptions<T, F>

Options for dynamic indexes.

generics

`T`

constraint IndexedItem

`F`

constraint (...args: Array<any>) => any

inheritance

extends:

IndexOptions<T, Parameters<F>[0]>

`factory`

Function that creates a query function from the collection.

type (collection: IndexedCollection<T>) => F

`onadd`

Optional custom add handler.

type (fn: F, item: T, collection: IndexedCollection<T>) => F

`onremove`

Optional custom remove handler.

type (fn: F, item: T, collection: IndexedCollection<T>) => F

EditableText
#

`value`

type string

bindable

`attrs?`

type SvelteHTMLElements['span']

optional

`span_attrs?`

type SvelteHTMLElements['span']

optional

`input_attrs?`

type SvelteHTMLElements['input']

optional

ENV_FILE
#

server/constants.ts view source

string

Canonical env file path for daemon-initiated reads and writes.
The write target must match a file that's reloaded on next daemon start,
so user-entered values (e.g. API keys via provider_update_api_key)
survive restart:
- Dev (gro dev, deno task dev): both Vite and scripts/dev.ts
  reload .env.development. .env is shadowed by .env.development in
  Vite's mode-precedence and is not loaded at all by scripts/dev.ts,
  so writing to .env in dev would be invisible on restart.
- Prod (compiled zzz daemon start): server/server.ts loads .env via
  load_env_file. .env.production is NOT loaded by the compiled daemon
  (only by deno task preview's --env=.env.production flag), so writing
  there would be invisible on restart.

ErrorMessage
#

ErrorMessage.svelte view source

ErrorMessageInline
#

ErrorMessageInline.svelte view source

`glyph?`

type string | null

optional

`children`

type Snippet

estimate_token_count
#

(text: string): number

Quick and dirty token count estimate using ESTIMATED_CHARS_PER_TOKEN.
Real tokenizers are heavy and of little benefit for our cases right now,
especially because each LLM may tokenize differently.

`text`

type string

returns

number

ESTIMATED_CHARS_PER_TOKEN
#

ExternalLink.svelte view source

3

ExternalLink
#

`href`

type string

`new_tab?`

Set to false to open in the same tab.

type boolean | undefined

optional

`icon?`

type Snippet<[known_logo: SvgData | null]> | undefined

optional

ExternalLinkIcon
#

ExternalLinkIcon.svelte view source

`children?`

type Snippet<[text_icon: string]>

optional

extract_global_flags
#

(unparsed: ParsedArgs) => { flags: { help: boolean; version: boolean; }; remaining: ParsedArgs; }

Extract global flags from parsed args.

extract_hostname
#

(host: string): string

Extract the hostname portion from a Host header value.
Handles IPv6 brackets: [::1]:3000 → [::1]
Handles regular: localhost:3000 → localhost

`host`

the raw Host header value

type string

returns

string

the hostname without port

extract_parameter_count
#

(parameter_size: string | undefined): number | undefined

Extract parameter count from parameter size string like "7B", "13B", etc.

`parameter_size`

type string | undefined

returns

number | undefined

FailedMessage
#

FailedMessage

Failed message that exceeded retry count.

inheritance

extends:

QueuedMessage

`failed`

type number

`reason`

type string

FallbackPtyProcess
#

FallbackPtyProcess

Fallback PTY process — Deno.Command with piped stdin/stdout/stderr.

`kind`

type 'fallback'

`process`

type Deno.ChildProcess

`terminal_id`

type Uuid

`command`

type string

`args`

type Array<string>

`stdin_writer`

type WritableStreamDefaultWriter<Uint8Array>

FfiPtyProcess
#

FfiPtyProcess

FFI-backed PTY process — real terminal via forkpty.

`kind`

type 'ffi'

`pid`

type number

`master_fd`

type number

`terminal_id`

type Uuid

`command`

type string

`args`

type Array<string>

`reading`

type boolean

FILE_DATETIME_FORMAT
#

"MMM d, yyyy h:mm:ss a"

FILE_SHORT_DATE_FORMAT
#

"MMM d, p"

FILE_TIME_FORMAT
#

"HH:mm:ss"

filer_change_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ change: ZodObject<{ type: ZodEnum<{ add: "add"; change: "change"; delete: "delete"; }>; path: $ZodBranded<...>; }, $strict>; disknode: ZodObject<...>; }, $strict>; output: ZodVoid; async: true; des...

FilerChangeHandler
#

FilerChangeHandler

Function type for handling file system changes.

FilerChangeInput
#

ZodObject<{ change: ZodObject<{ type: ZodEnum<{ add: "add"; change: "change"; delete: "delete"; }>; path: $ZodBranded<ZodString, "DiskfilePath", "out">; }, $strict>; disknode: ZodObject<...>; }, $strict>

Input for filer_change.

FilerInstance
#

FilerInstance

Structure to hold a Filer and its cleanup function.

`filer`

type Filer

`cleanup_promise`

type Promise<() => void>

FilesystemCapabilityData
#

FilesystemCapabilityData

`zzz_dir`

type DiskfileDirectoryPath | null | undefined

`scoped_dirs`

type ReadonlyArray<DiskfileDirectoryPath>

Footer
#

format_bytes
#

(bytes: number, decimals?: number): string

Format bytes to human readable string.

`bytes`

type number

`decimals`

type number

default 1

returns

string

format_datetime
#

(value: TimeValue | null | undefined, fallback?: string): string

`value`

type TimeValue | null | undefined

`fallback`

type string

default ''

returns

string

format_duration
#

(ms: number): string

Format duration in milliseconds to human readable string.

`ms`

type number

returns

string

format_gigabytes
#

(gb: number): string

`gb`

type number

returns

string

format_ms_to_readable
#

(ms: number, decimals?: number): string

`ms`

type number

`decimals`

type number

default 0

returns

string

format_percentage
#

prompt_helpers.ts view source

(value: number, total: number, decimals?: number): string

Format a number as a percentage.

`value`

type number

`total`

type number

`decimals`

type number

default 1

returns

string

format_prompt_content
#

(parts: PartUnion[]): string

Formats a collection of parts into a prompt string,
applying XML tags and attributes where specified.

`parts`

type PartUnion[]

returns

string

format_short_date
#

(value: TimeValue | null | undefined, fallback?: string): string

`value`

type TimeValue | null | undefined

`fallback`

type string

default ''

returns

string

format_time
#

(value: TimeValue | null | undefined, fallback?: string): string

`value`

type TimeValue | null | undefined

`fallback`

type string

default ''

returns

string

format_timestamp
#

(value: TimeValue | null | undefined, fallback?: string): string

`value`

type TimeValue | null | undefined

`fallback`

type string

default ''

returns

string

FREQUENCY_PENALTY_DEFAULT
#

number | undefined

Frontend
#

The base frontend app, typically used by creating your own App extends Frontend.
Gettable with frontend_context.get() inside a FrontendRoot.

inheritance

extends:

Cell<typeof FrontendJson>

implements:

ActionEventEnvironment

`executor`

type ActionExecutor

readonly

`cell_registry`

App-wide cell registry, maps class names to constructor and tracks registered instances.

type CellRegistry

readonly

`action_registry`

type ActionRegistry

readonly

`action_handlers`

type FrontendActionHandlers

readonly

`api`

type FrontendActionsApi

readonly

`peer`

type ActionPeer

readonly

`time`

type Time

readonly

`ui`

type Ui

readonly

`models`

type Models

readonly

`chats`

type Chats

readonly

`threads`

type Threads

readonly

`providers`

type Providers

readonly

`prompts`

type Prompts

readonly

`parts`

type Parts

readonly

`diskfiles`

type Diskfiles

readonly

`actions`

type Actions

readonly

`socket`

type Socket

readonly

`capabilities`

type Capabilities

readonly

`ollama`

type Ollama

readonly

`spaces`

type Spaces

readonly

`workspaces`

type Workspaces

readonly

`bots`

type ZzzOptions['bots']

readonly

`terminal_writers`

Callback registry for terminal data routing.
TerminalView components register their write callback on mount.

type Map<Uuid, (data: string) => void>

readonly

`terminal_exit_handlers`

Callback registry for terminal exit notifications.
TerminalView components register their exit callback on mount.

type Map<Uuid, (exit_code: number | null) => void>

readonly

`provider_status`

Tracks which providers are available (configured with API keys).

type Array<ProviderStatus>

`tags`

type Set<string>

readonly

`diskfile_histories`

type SvelteMap<DiskfilePath, DiskfileHistory>

readonly

`futuremode`

See into Zzz's future.

`constructor`

type new (options?: FrontendOptions): Frontend

`options`

type FrontendOptions

default EMPTY_OBJECT

`receive_session`

type (data: { zzz_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; scoped_dirs: readonly (string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">)[]; files: { ...; }[]; provider_status: ({ ...; } | { ...; })[]; workspaces: { ...; }[]; }): void

`data`

type

{ zzz_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; scoped_dirs: readonly (string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">)[]; files: { ...; }[]; provider_status: ({ ...; } | { ...; })[]; workspaces: { ...; }[]; }

returns void

`add_providers`

type (providers_json: { name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }[]): void

`providers_json`

type

{ name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }[]

returns void

`add_provider`

type (provider_json: { name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }): void

`provider_json`

type

{ name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

returns void

`lookup_provider_status`

type (provider_name: string): { name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; } | null

`provider_name`

type string

returns

{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; } | null

`update_provider_status`

type (status: { name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }): void

`status`

type

{ name: string; available: true; checked_at: number; } | { name: string; available: false; error: string; checked_at: number; }

returns void

`get_diskfile_history`

type (path: string & $brand<"DiskfilePath">): DiskfileHistory | undefined

`path`

type string & $brand<"DiskfilePath">

returns DiskfileHistory | undefined

`create_diskfile_history`

type (path: string & $brand<"DiskfilePath">): DiskfileHistory

`path`

type string & $brand<"DiskfilePath">

returns DiskfileHistory

`lookup_action_handler`

`method`

type string

`phase`

type

"send_request" | "receive_request" | "send_response" | "receive_response" | "send_error" | "receive_error" | "send" | "receive" | "execute"

returns ((event: any) => any) | undefined

`lookup_action_spec`

`method`

type string

returns

{ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; }...

`lookup_action_input_schema`

type <TMethod extends ActionMethod>(method: TMethod): { readonly heartbeat: ZodDefault<ZodObject<{}, $strict>>; readonly cancel: ZodObject<{ request_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 29 more ...; readonly workspace_changed: ZodObject<...>; }[TMethod] | undefined

`method`

type TMethod

returns

{ readonly heartbeat: ZodDefault<ZodObject<{}, $strict>>; readonly cancel: ZodObject<{ request_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 29 more ...; readonly workspace_changed: ZodObject<...>; }[TMethod] | undefined

`lookup_action_output_schema`

type <TMethod extends ActionMethod>(method: TMethod): { readonly heartbeat: ZodObject<{}, $strict>; readonly cancel: ZodVoid; readonly ping: ZodObject<{ ping_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 28 more ...; readonly workspace_changed: ZodVoid; }[TMethod] | undefined

`method`

type TMethod

returns

{ readonly heartbeat: ZodObject<{}, $strict>; readonly cancel: ZodVoid; readonly ping: ZodObject<{ ping_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; ... 28 more ...; readonly workspace_changed: ZodVoid; }[TMethod] | undefined

`is_valid_phase_for_method`

`method`

type

"ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"

`phase`

type

"send_request" | "receive_request" | "send_response" | "receive_response" | "send_error" | "receive_error" | "send" | "receive" | "execute"

returns boolean

frontend_context
#

frontend_action_types.ts view source

{ get: (error_message?: string | undefined) => Frontend; get_maybe: () => Frontend | undefined; set: (value: Frontend) => Frontend; }

FrontendActionHandlers
#

FrontendActionHandlers

Frontend action handlers organized by method and phase.
Generated using spec.initiator to determine valid phases:
- initiator: 'frontend' → send/execute phases
- initiator: 'backend' → receive phases
- initiator: 'both' → all valid phases

`heartbeat`

type

{
		send_request?: (
			action_event: TypedActionEvent<'heartbeat', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'heartbeat', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'heartbeat', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'heartbeat', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`cancel`

type

{
		send?: (action_event: TypedActionEvent<'cancel', 'send', 'handling'>) => void | Promise<void>;
	}

`ping`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ping', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ping', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ping', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ping', 'receive_error', 'handling'>,
		) => void | Promise<void>;
		receive_request?: (
			action_event: TypedActionEvent<'ping', 'receive_request', 'handling'>,
		) => ActionOutputs['ping'] | Promise<ActionOutputs['ping']>;
		send_response?: (
			action_event: TypedActionEvent<'ping', 'send_response', 'handling'>,
		) => void | Promise<void>;
	}

`session_load`

type

{
		send_request?: (
			action_event: TypedActionEvent<'session_load', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'session_load', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'session_load', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'session_load', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`filer_change`

type

{
		receive?: (
			action_event: TypedActionEvent<'filer_change', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

`diskfile_update`

type

{
		send_request?: (
			action_event: TypedActionEvent<'diskfile_update', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'diskfile_update', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'diskfile_update', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'diskfile_update', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`diskfile_delete`

type

{
		send_request?: (
			action_event: TypedActionEvent<'diskfile_delete', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'diskfile_delete', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'diskfile_delete', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'diskfile_delete', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`directory_create`

type

{
		send_request?: (
			action_event: TypedActionEvent<'directory_create', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'directory_create', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'directory_create', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'directory_create', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`completion_create`

type

{
		send_request?: (
			action_event: TypedActionEvent<'completion_create', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'completion_create', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'completion_create', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'completion_create', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`completion_progress`

type

{
		receive?: (
			action_event: TypedActionEvent<'completion_progress', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_progress`

type

{
		receive?: (
			action_event: TypedActionEvent<'ollama_progress', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

`toggle_main_menu`

type

{
		execute?: (
			action_event: TypedActionEvent<'toggle_main_menu', 'execute', 'handling'>,
		) => ActionOutputs['toggle_main_menu'];
	}

`ollama_list`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_list', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_list', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_list', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_list', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_ps`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_ps', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_ps', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_ps', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_ps', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_show`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_show', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_show', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_show', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_show', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_pull`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_pull', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_pull', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_pull', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_pull', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_delete`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_delete', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_delete', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_delete', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_delete', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_copy`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_copy', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_copy', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_copy', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_copy', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_create`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_create', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_create', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_create', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_create', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`ollama_unload`

type

{
		send_request?: (
			action_event: TypedActionEvent<'ollama_unload', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'ollama_unload', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'ollama_unload', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'ollama_unload', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`provider_load_status`

type

{
		send_request?: (
			action_event: TypedActionEvent<'provider_load_status', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'provider_load_status', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'provider_load_status', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'provider_load_status', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`provider_update_api_key`

type

{
		send_request?: (
			action_event: TypedActionEvent<'provider_update_api_key', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'provider_update_api_key', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'provider_update_api_key', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'provider_update_api_key', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_create`

type

{
		send_request?: (
			action_event: TypedActionEvent<'terminal_create', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'terminal_create', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'terminal_create', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'terminal_create', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_data_send`

type

{
		send_request?: (
			action_event: TypedActionEvent<'terminal_data_send', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'terminal_data_send', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'terminal_data_send', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'terminal_data_send', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_data`

type

{
		receive?: (
			action_event: TypedActionEvent<'terminal_data', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_resize`

type

{
		send_request?: (
			action_event: TypedActionEvent<'terminal_resize', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'terminal_resize', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'terminal_resize', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'terminal_resize', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_close`

type

{
		send_request?: (
			action_event: TypedActionEvent<'terminal_close', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'terminal_close', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'terminal_close', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'terminal_close', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`terminal_exited`

type

{
		receive?: (
			action_event: TypedActionEvent<'terminal_exited', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

`workspace_open`

type

{
		send_request?: (
			action_event: TypedActionEvent<'workspace_open', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'workspace_open', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'workspace_open', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'workspace_open', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`workspace_close`

type

{
		send_request?: (
			action_event: TypedActionEvent<'workspace_close', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'workspace_close', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'workspace_close', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'workspace_close', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`workspace_list`

type

{
		send_request?: (
			action_event: TypedActionEvent<'workspace_list', 'send_request', 'handling'>,
		) => void | Promise<void>;
		receive_response?: (
			action_event: TypedActionEvent<'workspace_list', 'receive_response', 'handling'>,
		) => void | Promise<void>;
		send_error?: (
			action_event: TypedActionEvent<'workspace_list', 'send_error', 'handling'>,
		) => void | Promise<void>;
		receive_error?: (
			action_event: TypedActionEvent<'workspace_list', 'receive_error', 'handling'>,
		) => void | Promise<void>;
	}

`workspace_changed`

type

{
		receive?: (
			action_event: TypedActionEvent<'workspace_changed', 'receive', 'handling'>,
		) => void | Promise<void>;
	}

FrontendActionMethod
#

ZodEnum<{ ping: "ping"; session_load: "session_load"; filer_change: "filer_change"; diskfile_update: "diskfile_update"; diskfile_delete: "diskfile_delete"; directory_create: "directory_create"; ... 25 more ...; cancel: "cancel"; }>

Names of all actions in the typed FrontendActionsApi surface — every spec the frontend may encounter (call, receive, or execute locally).

FrontendActionsApi
#

FrontendActionsApi

Typed dispatch surface for the frontend's RPC client. Symmetric counterpart
of BackendActionsApi. Async methods (request_response, remote_notification,
async local_call) return Promise<Result<...>> and accept an optional
RpcClientCallOptions second arg that threads signal, transport_name,
and queue through to the peer. Sync local_call methods return values
directly.

`heartbeat`

type

(
		input?: ActionInputs['heartbeat'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['heartbeat']}, {error: JsonrpcErrorObject}>>

`cancel`

type

(
		input: ActionInputs['cancel'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['cancel']}, {error: JsonrpcErrorObject}>>

`ping`

type

(
		input?: void,
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ping']}, {error: JsonrpcErrorObject}>>

`session_load`

type

(
		input?: void,
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['session_load']}, {error: JsonrpcErrorObject}>>

`filer_change`

type

(
		input: ActionInputs['filer_change'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['filer_change']}, {error: JsonrpcErrorObject}>>

`diskfile_update`

type

(
		input: ActionInputs['diskfile_update'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['diskfile_update']}, {error: JsonrpcErrorObject}>>

`diskfile_delete`

type

(
		input: ActionInputs['diskfile_delete'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['diskfile_delete']}, {error: JsonrpcErrorObject}>>

`directory_create`

type

(
		input: ActionInputs['directory_create'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['directory_create']}, {error: JsonrpcErrorObject}>>

`completion_create`

type

(
		input: ActionInputs['completion_create'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['completion_create']}, {error: JsonrpcErrorObject}>>

`completion_progress`

type

(
		input?: ActionInputs['completion_progress'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['completion_progress']}, {error: JsonrpcErrorObject}>>

`ollama_progress`

type

(
		input: ActionInputs['ollama_progress'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_progress']}, {error: JsonrpcErrorObject}>>

`toggle_main_menu`

type (input?: ActionInputs['toggle_main_menu']) => ActionOutputs['toggle_main_menu']

`ollama_list`

type

(
		input?: void,
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_list']}, {error: JsonrpcErrorObject}>>

`ollama_ps`

type

(
		input?: void,
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_ps']}, {error: JsonrpcErrorObject}>>

`ollama_show`

type

(
		input: ActionInputs['ollama_show'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_show']}, {error: JsonrpcErrorObject}>>

`ollama_pull`

type

(
		input: ActionInputs['ollama_pull'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_pull']}, {error: JsonrpcErrorObject}>>

`ollama_delete`

type

(
		input: ActionInputs['ollama_delete'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_delete']}, {error: JsonrpcErrorObject}>>

`ollama_copy`

type

(
		input: ActionInputs['ollama_copy'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_copy']}, {error: JsonrpcErrorObject}>>

`ollama_create`

type

(
		input: ActionInputs['ollama_create'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_create']}, {error: JsonrpcErrorObject}>>

`ollama_unload`

type

(
		input: ActionInputs['ollama_unload'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['ollama_unload']}, {error: JsonrpcErrorObject}>>

`provider_load_status`

type

(
		input: ActionInputs['provider_load_status'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['provider_load_status']}, {error: JsonrpcErrorObject}>>

`provider_update_api_key`

type

(
		input: ActionInputs['provider_update_api_key'],
		options?: RpcClientCallOptions,
	) => Promise<
		Result<{value: ActionOutputs['provider_update_api_key']}, {error: JsonrpcErrorObject}>
	>

`terminal_create`

type

(
		input: ActionInputs['terminal_create'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_create']}, {error: JsonrpcErrorObject}>>

`terminal_data_send`

type

(
		input: ActionInputs['terminal_data_send'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_data_send']}, {error: JsonrpcErrorObject}>>

`terminal_data`

type

(
		input: ActionInputs['terminal_data'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_data']}, {error: JsonrpcErrorObject}>>

`terminal_resize`

type

(
		input: ActionInputs['terminal_resize'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_resize']}, {error: JsonrpcErrorObject}>>

`terminal_close`

type

(
		input: ActionInputs['terminal_close'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_close']}, {error: JsonrpcErrorObject}>>

`terminal_exited`

type

(
		input: ActionInputs['terminal_exited'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['terminal_exited']}, {error: JsonrpcErrorObject}>>

`workspace_open`

type

(
		input: ActionInputs['workspace_open'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['workspace_open']}, {error: JsonrpcErrorObject}>>

`workspace_close`

type

(
		input: ActionInputs['workspace_close'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['workspace_close']}, {error: JsonrpcErrorObject}>>

`workspace_list`

type

(
		input?: void,
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['workspace_list']}, {error: JsonrpcErrorObject}>>

`workspace_changed`

type

(
		input: ActionInputs['workspace_changed'],
		options?: RpcClientCallOptions,
	) => Promise<Result<{value: ActionOutputs['workspace_changed']}, {error: JsonrpcErrorObject}>>

FrontendJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; ui: ZodDefault<...>; }, $strict>

FrontendJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; ui?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; show_main_dialog?: boolean | undefined; ... 6 more ...; desk_pinned?: boolean | undefined; } | undefined; }

FrontendOptions
#

FrontendOptions

inheritance

extends:

OmitStrict<CellOptions<typeof FrontendJson>, 'app'>

`app`

Do not use - optional to avoid circular reference problem.

type never

`models`

type Array<ModelJsonInput>

`bots`

type ZzzOptions['bots']

`providers`

type Array<ProviderJsonInput>

`cell_classes`

type Record<string, ClassConstructor<Cell<any>>>

`action_specs`

type Array<ActionSpecUnion>

`action_handlers`

type FrontendActionHandlers

`http_rpc_url`

type string | null

`http_headers`

type Record<string, string>

`socket_url`

type string | null

FrontendRequestResponseMethod
#

FrontendRoot.svelte view source

ZodEnum<{ ping: "ping"; }>

Names of request_response actions the frontend handles (initiator excludes frontend).

FrontendRoot
#

`app`

type Frontend

`children`

type Snippet<[zzz: Frontend]>

gen
#

action_metatypes.gen.ts view source

generate_command_help
#

(command: string, meta: CommandMeta<string>) => string

generate_main_help
#

server/zzz_action_handlers.ts view source

() => string

get_action_handler
#

(handlers: BackendActionHandlers, method: string): ActionHandler | undefined

Look up a handler in the typed map by method name.
Centralizes the unavoidable string-key → typed-handler cast that both
transports (zzz_rpc_actions.ts, register_websocket_actions.ts) need.
Returns undefined for methods the factory doesn't produce — e.g.,
fuz_app's cancel (handler lives in protocol_actions) or
notification specs (no request_response handler).

`handlers`

type BackendActionHandlers

`method`

type string

returns

ActionHandler | undefined

get_cell_class_names
#

cell.svelte.ts view source

(): ("Action" | "Actions" | "Capabilities" | "Parts" | "Chat" | "Chats" | "Diskfile" | "DiskfileTab" | "DiskfileTabs" | "DiskfilePart" | "DiskfileHistory" | "Diskfiles" | "DiskfilesEditor" | ... 17 more ... | "Workspaces")[]

Get a list of all registered cell class names.

returns

("Action" | "Actions" | "Capabilities" | "Parts" | "Chat" | "Chats" | "Diskfile" | "DiskfileTab" | "DiskfileTabs" | "DiskfilePart" | "DiskfileHistory" | "Diskfiles" | "DiskfilesEditor" | ... 17 more ... | "Workspaces")[]

get_global_cell_count
#

(): number

A monotonic id for cell instances on the client.
This is not reactive and never changes on the instance,
whereas id can change. It's useful for ordering -
the motivating usecase was correctly sorting objects with the same created millisecond.
This may cause issues based on how data gets queried, but at least it's stable once loaded.
However we may need to revisit this if it causes problems.

returns

number

get_glyph_for_action_kind
#

(kind: "request_response" | "remote_notification" | "local_call"): string

`kind`

type "request_response" | "remote_notification" | "local_call"

returns

string

get_glyph_for_action_method
#

(method: "ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"): string

`method`

type

"ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"

returns

string

get_help_text
#

part_helpers.ts view source

(command?: string | undefined, subcommand?: string | undefined) => string

get_part_type_glyph
#

(part: PartUnion): string

`part`

type PartUnion

returns

string

get_reorderable_drop_position
#

(direction: ReorderableDirection, source_index: number, target_index: number): ReorderableValidDropPosition

Determine the drop position based on source and target indices and layout direction.

`direction`

type ReorderableDirection

`source_index`

type number

`target_index`

type number

returns

ReorderableValidDropPosition

get_schema_class_info
#

(schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | null | undefined): SchemaClassInfo | null

Get schema class information from a Zod schema.
This helps determine how to decode values based on their schema definition.

`schema`

type ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | null | undefined

returns

SchemaClassInfo | null

get_unique_name
#

(name: string, existing_names: { has: (name: string) => boolean; } | { includes: (name: string) => boolean; }): string

`name`

type string

`existing_names`

type { has: (name: string) => boolean; } | { includes: (name: string) => boolean; }

returns

string

get_zzz_config_path
#

(runtime: Pick<EnvDeps, "env_get">): string | null

Get the CLI config file path (~/.zzz/config.json).

`runtime`

runtime with env_get capability

type Pick<EnvDeps, "env_get">

returns

string | null

path to config.json, or null if $HOME is not set

get_zzz_dir
#

schema_registry.ts view source

(runtime: Pick<EnvDeps, "env_get">): string | null

Get the CLI config directory path (~/.zzz).

`runtime`

runtime with env_get capability

type Pick<EnvDeps, "env_get">

returns

string | null

path to config directory, or null if $HOME is not set

global_schema_registry
#

SchemaRegistry

Global instance of the schema registry for convenience.

Glyph
#

Glyph.svelte view source

`glyph`

type string

`size?`

type string | undefined

optional

GLYPH_ACTION
#

"⍾"

GLYPH_ACTION_TYPE_LOCAL_CALL
#

"⤳"

GLYPH_ACTION_TYPE_REMOTE_NOTIFICATION
#

"⥙"

GLYPH_ACTION_TYPE_REQUEST_RESPONSE
#

"⥮"

GLYPH_ADD
#

"✛"

GLYPH_ARROW_LEFT
#

"←"

GLYPH_ARROW_RIGHT
#

"→"

GLYPH_BACKEND
#

"🜢"

GLYPH_CANCEL
#

"⦸"

GLYPH_CAPABILITY
#

"⧰"

GLYPH_CHAT
#

"⌸"

GLYPH_CHECKMARK
#

"✓"

GLYPH_CHEVRON_DOWN
#

"⮟"

GLYPH_CHEVRON_LEFT
#

"⮜"

GLYPH_CHEVRON_RIGHT
#

"⮞"

GLYPH_CHEVRON_UP
#

"⮝"

GLYPH_CLEAR
#

"⌫"

GLYPH_CONNECT
#

"⭍"

GLYPH_COPY
#

"⧉"

GLYPH_CREATE_FILE
#

"🗎"

GLYPH_CREATE_FOLDER
#

"🗁"

GLYPH_DELETE
#

"⌧"

GLYPH_DESK
#

"⍟"

GLYPH_DIRECTORY
#

"▦"

GLYPH_DISCONNECT
#

"⊝"

GLYPH_DOMAIN
#

"⟡"

GLYPH_DOUBLE_CHEVRON_LEFT
#

"«"

GLYPH_DOUBLE_CHEVRON_RIGHT
#

"»"

GLYPH_DOWNLOAD
#

"⭳"

GLYPH_DRAG
#

"≡"

GLYPH_EDIT
#

"✎"

GLYPH_ERROR
#

"‼"

GLYPH_EXTERNAL_LINK
#

"🡵"

GLYPH_FILE
#

"⧈"

GLYPH_HEARTBEAT
#

"∽"

GLYPH_IDEA
#

"⌆"

GLYPH_IMPORTANT
#

"⁈"

GLYPH_INFO
#

"ⓘ"

GLYPH_LIST
#

"▤"

GLYPH_LOG
#

"⎙"

GLYPH_MODEL
#

"⊛"

GLYPH_PAGE
#

"⌺"

GLYPH_PART
#

"┊"

GLYPH_PASTE
#

"⎌"

GLYPH_PAUSE
#

"❙❙"

GLYPH_PIN
#

"⏍"

GLYPH_PING
#

"⥀"

GLYPH_PLACEHOLDER
#

"↳"

GLYPH_PLAY
#

"▶︎"

GLYPH_PREVIEW
#

"⦾"

GLYPH_PROJECT
#

"⌬"

GLYPH_PROMPT
#

"⌇"

GLYPH_PROVIDER
#

"⨕"

GLYPH_REFRESH
#

"⟳"

GLYPH_REMOVE
#

"🗙"

GLYPH_RESET
#

"⤺"

GLYPH_RESPONSE
#

"⮑"

GLYPH_RESTORE
#

"⤻"

GLYPH_RETRY
#

"↺"

GLYPH_SEND
#

"⮥"

GLYPH_SESSION
#

"⏣"

GLYPH_SETTINGS
#

"⛮"

GLYPH_SORT
#

"⇅"

GLYPH_SPACE
#

"⌂"

GLYPH_STOP
#

"⏹"

GLYPH_TAB
#

"⛶"

GLYPH_TERMINAL
#

"⌨"

GLYPH_THREAD
#

"☷"

GLYPH_TURN
#

"⎍"

GLYPH_UNKNOWN
#

"⁇"

GLYPH_VIEW
#

"⍜"

GLYPH_WORKSPACE
#

"⊞"

GLYPH_XMARK
#

"✗"

GLYPH_XMARK_HEAVY
#

navigation_helpers.ts view source

"✘"

goto_unless_current
#

(path: string | URL, options?: { replaceState?: boolean | undefined; noScroll?: boolean | undefined; keepFocus?: boolean | undefined; invalidateAll?: boolean | undefined; invalidate?: (string | ... 1 more ... | ((url: URL) => boolean))[] | undefined; state?: PageState | undefined; } | undefined): Promise<...>

Navigate to a path only if we're not already on that path.
This avoids unnecessary navigation history changes when already at the destination.

`path`

type string | URL

`options?`

type

{ replaceState?: boolean | undefined; noScroll?: boolean | undefined; keepFocus?: boolean | undefined; invalidateAll?: boolean | undefined; invalidate?: (string | URL | ((url: URL) => boolean))[] | undefined; state?: PageState | undefined; } | undefined

optional

returns

Promise<void>

handle_filer_change
#

server/backend_actions_api.ts view source

(change: WatcherChange, disknode: Disknode, backend: Backend, dir: string, filer: Filer): void

Handle file system changes and notify clients.

`change`

type WatcherChange

`disknode`

type Disknode

`backend`

type Backend

`dir`

type string

`filer`

type Filer

returns

void

handle_test_emit_notifications
#

(input: { count: number; }, ctx: ActionContext): { count: number; } | Promise<{ count: number; }>

Handler for _test_emit_notifications. Emits count notifications via ctx.notify.

`input`

type { count: number; }

`ctx`

type ActionContext

returns

{ count: number; } | Promise<{ count: number; }>

HANDLED
#

unique symbol

Sentinel value to indicate a parser has completely handled a property.

has_dependencies
#

(diskfile: Diskfile): boolean

`diskfile`

type Diskfile

returns

boolean

HISTORY_LIMIT_DEFAULT
#

512

HistoryEntry
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodNumber; content: ZodString; label: ZodString; is_disk_change: ZodDefault<...>; is_unsaved_edit: ZodDefault<...>; is_original_state: ZodDefault<...>; }, $strict>

Schema for history entries.

HttpStatus
#

ZodNumber

IndexDefinition
#

IndexDefinition<T, TResult, TQuery>

Generic index definition with full flexibility.

generics

`T`

constraint IndexedItem

`TResult`

default any

`TQuery`

default any

`key`

Unique identifier for this index.

type string

`type`

Optional index type for simpler creation.

type IndexType

`extractor`

Optional extractor function for single/multi indexes.

type (item: T) => any

`compute`

Function to compute the index value from scratch.

type (collection: IndexedCollection<T>) => TResult

`query_schema`

Schema for validating query parameters.

type z.ZodType<TQuery>

`matches`

Optional predicate to determine if an item is relevant to this index.

type (item: T) => boolean

`onadd`

Optional function to update the index when an item is added.

type (result: TResult, item: T, collection: IndexedCollection<T>) => TResult

`onremove`

Optional function to update the index when an item is removed.

type (result: TResult, item: T, collection: IndexedCollection<T>) => TResult

IndexedCollection
#

A helper class for managing collections with incremental updates,
efficient querying, and automatic index maintenance.

generics

`T`

constraint IndexedItem

`TKeySingle`

constraint string

default string

`TKeyMulti`

constraint string

default string

`TKeyDerived`

constraint string

default string

`TKeyDynamic`

constraint string

default string

`by_id`

The main source of truth, the full collection keyed by Uuid.

type SvelteMap<Uuid, T>

readonly

`values`

type Array<T>

readonly

`keys`

type Array<Uuid>

readonly

`size`

Get the current count of items.

type number

readonly

`indexes`

Stores all index values in a reactive object.

type Record<string, any>

readonly

`constructor`

type new <T extends IndexedItem, TKeySingle extends string = string, TKeyMulti extends string = string, TKeyDerived extends string = string, TKeyDynamic extends string = string>(options?: IndexedCollectionOptions<T, TKeySingle, TKeyMulti, TKeyDerived, TKeyDynamic> | undefined): IndexedCollection<...>

`options?`

type IndexedCollectionOptions<T, TKeySingle, TKeyMulti, TKeyDerived, TKeyDynamic> | undefined

optional

`toJSON`

type (): readonly any[]

returns readonly any[]

`get_index`

Get a typed index value by key.

type <TResult = any>(key: TKeySingle | TKeyMulti | TKeyDerived | TKeyDynamic): TResult

`key`

type TKeySingle | TKeyMulti | TKeyDerived | TKeyDynamic

returns TResult

`single_index`

Get a single-value index with proper typing.

type (key: TKeySingle): SvelteMap<any, T>

`key`

type TKeySingle

returns SvelteMap<any, T>

`multi_index`

Get a multi-value index with proper typing.

type (key: TKeyMulti): SvelteMap<any, T[]>

`key`

type TKeyMulti

returns SvelteMap<any, T[]>

`derived_index`

Get a derived index with proper typing.

type (key: TKeyDerived): T[]

`key`

type TKeyDerived

returns T[]

`dynamic_index`

Get a dynamic (function) index with proper typing.

type <Q = any>(key: TKeyDynamic): (query: Q) => T

`key`

type TKeyDynamic

returns (query: Q) => T

`query`

Query an index with parameters.
This method is type-aware when the index has a query_schema that defines TQuery.

type <TResult = any, TQuery = any>(key: TKeySingle | TKeyMulti | TKeyDerived | TKeyDynamic, query: TQuery): TResult

`key`

type TKeySingle | TKeyMulti | TKeyDerived | TKeyDynamic

`query`

type TQuery

returns TResult

`add`

Add an item to the collection and update all indexes.

type (item: T): void

`item`

type T

returns void

`add_many`

Add multiple items to the collection at once with improved performance.

type (items: T[]): void

`items`

type T[]

returns void

`remove`

Remove an item by its id and update all indexes.

type (id: string & $brand<"Uuid">): boolean

`id`

type string & $brand<"Uuid">

returns boolean

`remove_many`

Remove multiple items efficiently.

type (ids: (string & $brand<"Uuid">)[]): number

`ids`

type (string & $brand<"Uuid">)[]

returns number

`get`

Get an item by its id.

type (id: string & $brand<"Uuid">): T | undefined

`id`

type string & $brand<"Uuid">

returns T | undefined

`has`

Check if the collection has an item with the given id.

type (id: string & $brand<"Uuid">): boolean

`id`

type string & $brand<"Uuid">

returns boolean

`clear`

Clear all items and reset indexes.

type (): void

returns void

`where`

Get all items matching a multi-indexed property value.
Type-safe version that uses the TKeyMulti generic parameter.

type <V = any>(index_key: TKeyMulti, value: V): T[]

`index_key`

type TKeyMulti

`value`

type V

returns T[]

`first`

Get the first N items matching a multi-indexed property value.
Type-safe version that uses the TKeyMulti generic parameter.

type <V = any>(index_key: TKeyMulti, value: V, limit: number): T[]

`index_key`

type TKeyMulti

`value`

type V

`limit`

type number

returns T[]

`latest`

Get the latest N items matching a multi-indexed property value.
Type-safe version that uses the TKeyMulti generic parameter.

type <V = any>(index_key: TKeyMulti, value: V, limit: number): T[]

`index_key`

type TKeyMulti

`value`

type V

`limit`

type number

returns T[]

`by`

Get an item by a single-value index.
Returns the item or throws if no item is found.
Type-safe version that uses the TKeySingle generic parameter.

type <V = any>(index_key: TKeySingle, value: V): T

`index_key`

type TKeySingle

`value`

type V

returns T

`by_optional`

Get an item by a single-value index, returning undefined if not found.
Type-safe version that uses the TKeySingle generic parameter.

type <V = any>(index_key: TKeySingle, value: V): T | undefined

`index_key`

type TKeySingle

`value`

type V

returns T | undefined

IndexedCollectionOptions
#

IndexedCollectionOptions<T, TKeySingle, TKeyMulti, TKeyDerived, TKeyDynamic>

generics

`T`

constraint IndexedItem

`TKeySingle`

constraint string

default string

`TKeyMulti`

constraint string

default string

`TKeyDerived`

constraint string

default string

`TKeyDynamic`

constraint string

default string

`indexes`

type Array<IndexDefinition<T>>

`initial_items`

type Array<T>

`validate`

type boolean

`index_types`

type

{
		single?: Array<TKeySingle>;
		multi?: Array<TKeyMulti>;
		derived?: Array<TKeyDerived>;
		dynamic?: Array<TKeyDynamic>;
	}

IndexedItem
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $strict>

Interface for objects that can be stored in an IndexedCollection.

IndexOptions
#

IndexOptions<T, TQuery>

Common options interface for all index types.

generics

`T`

constraint IndexedItem

`TQuery`

default any

`key`

Unique key for this index.

type string

`matches`

Optional predicate to determine if an item is relevant to this index.

type (item: T) => boolean

`query_schema`

Schema for query input validation and typing.

type z.ZodType<TQuery>

IndexType
#

zzz/commands/init.ts view source

IndexType

String literals for index types.

init
#

(runtime: RuntimeDeps, args: { _: string[]; port?: number | undefined; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Initialize zzz configuration (~/.zzz/).
Creates the config directory and config.json.

`runtime`

type RuntimeDeps

`args`

type { _: string[]; port?: number | undefined; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

init_zzz_schema
#

server/db/zzz_schema.ts view source

(_db: Db): Promise<void>

Initialize the zzz database schema.
Currently only auth tables (from create_app_backend).
Zzz-specific tables will be added here when persistent state is needed.

`_db`

type Db

returns

Promise<void>

InitArgs
#

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; port: ZodOptional<ZodNumber>; }, $strict>

Init command arguments.

INVALID_DROP_CLASS_DEFAULT
#

"invalid_drop"

is_cell_type
#

<K extends CellClassNames>(cell: Cell<any> | null | undefined, class_name: K): cell is CellRegistryMap[K]

Type guard to check if a cell is an instance of a specific cell class.

`cell`

type Cell<any> | null | undefined

`class_name`

type K

returns

boolean

is_ffi_available
#

(): boolean

Check if the FFI library is available.

returns

boolean

is_open_host
#

(host: string): boolean

Check whether a bind address is a wildcard that exposes to the network.

`host`

the bind address to check

type string

returns

boolean

true if the host binds to all interfaces

is_path_absolute
#

(path: string): boolean

`path`

type string

returns

boolean

is_reorder_allowed
#

(can_reorder: ((from_index: number, to_index: number) => boolean) | undefined, source_index: number, target_index: number): boolean

Check if reordering is allowed between two indices.

`can_reorder`

type ((from_index: number, to_index: number) => boolean) | undefined

`source_index`

type number

`target_index`

type number

returns

boolean

ITEM_CLASS_DEFAULT
#

"reorderable-item"

JSONRPC_ERROR_CODES
#

{ readonly ai_provider_error: -32700 | -32600 | -32601 | -32602 | -32603 | (number & $brand<"JsonrpcServerErrorCode">); readonly parse_error: -32700 | -32600 | -32601 | -32602 | -32603 | (number & $brand<...>); ... 13 more ...; readonly request_cancelled: -32700 | ... 4 more ... | (number & $brand<...>); }

Extended error codes with zzz-specific AI provider error.

jsonrpc_error_messages
#

{ readonly ai_provider_error: (provider?: string | undefined, message?: string | undefined, data?: unknown) => { [x: string]: unknown; code: -32700 | -32600 | -32601 | -32602 | -32603 | (number & $brand<"JsonrpcServerErrorCode">); message: string; data?: unknown; }; ... 14 more ...; readonly request_cancelled: (...a...

Extended error message constructors.

jsonrpc_errors
#

{ readonly ai_provider_error: (provider?: string | undefined, message?: string | undefined, data?: unknown) => ThrownJsonrpcError; readonly parse_error: (...args: any[]) => ThrownJsonrpcError; ... 13 more ...; readonly request_cancelled: (...args: any[]) => ThrownJsonrpcError; }

Extended error throwers.

JsonrpcErrorName
#

JsonrpcErrorName

zzz error names — extends fuz_app's base set with AI provider errors.

library_context
#

library.ts view source

{ get: (error_message?: string | undefined) => Library; get_maybe: () => Library | undefined; set: (value: Library) => Library; }

LIST_CLASS_DEFAULT
#

server/server_env.ts view source

"reorderable-list"

load_server_env
#

(get_env: (key: string) => string | undefined, overrides?: Partial<ZzzServerConfig> | undefined): ZzzServerConfig

Load and validate server env, then derive the config callers need.
Uses load_env from fuz_app for Zod-validated loading.
The overrides parameter lets CLI flags and startup defaults
take precedence over env vars.

`get_env`

function to read environment variables

type (key: string) => string | undefined

`overrides?`

values that take precedence over env vars

type Partial<ZzzServerConfig> | undefined

optional

returns

ZzzServerConfig

load_zzz_cli_config
#

(runtime: Pick<EnvDeps, "env_get"> & FsReadDeps & LogDeps): Promise<{ zzz_config_port: number; } | null>

Load CLI configuration from ~/.zzz/config.json.

`runtime`

runtime with file read capability

type Pick<EnvDeps, "env_get"> & FsReadDeps & LogDeps

returns

Promise<{ zzz_config_port: number; } | null>

parsed config, or null if file doesn't exist or is invalid

LOCAL_HOSTNAMES
#

ReadonlySet<string>

Default set of hostnames considered safe for local-only binding.
Includes all common ways to address localhost.

LocalCallActionMethod
#

ZodEnum<{ toggle_main_menu: "toggle_main_menu"; }>

Names of all local_call actions.

log
#

zzz/log.ts view source

CliLogger

logger
#

zzz/log.ts view source

Logger

logo_chatgpt
#

{ label: string; paths: { d: string; }[]; }

logo_claude
#

{ label: string; fill: string; paths: { d: string; }[]; }

logo_gemini
#

{ label: string; fill: string; raw: string; paths: { d: string; }[]; }

logo_zzz
#

{ label: string; fill: string; paths: { d: string; }[]; }

main_nav_items_default
#

MainDialog.svelte view source

NavItem[]

MainDialog
#

`disabled?`

type boolean | undefined

optional

map_watcher_change_to_diskfile_change
#

(type: WatcherChangeType): "add" | "change" | "delete"

Maps watcher change types to diskfile change types.

`type`

type WatcherChangeType

returns

"add" | "change" | "delete"

Model
#

ModelContextmenu.svelte view source

inheritance

extends:

Cell<typeof ModelJson>

`name`

type ModelName

`provider_name`

type ProviderName

`tags`

type Array<string>

`architecture`

type string | undefined

`parameter_count`

type number | undefined

`context_window`

type number | undefined

`output_token_limit`

type number | undefined

`embedding_length`

type number | undefined

`filesize`

Size in gigabytes.

type number | undefined

`cost_input`

type number | undefined

`cost_output`

type number | undefined

`training_cutoff`

type string | undefined

`ollama_list_response_item`

type OllamaListResponseItem | undefined

`ollama_show_response`

type OllamaShowResponse | undefined

`ollama_show_response_loaded`

type boolean

`ollama_show_response_loading`

type boolean

`ollama_show_response_error`

type string | undefined

`downloaded`

For models that run locally, this is a boolean indicating if the model is downloaded.
Is undefined for non-local models.

type boolean | undefined

readonly

`provider`

Lookup the provider for this model.

type Provider | undefined

readonly

`context_window_formatted`

type string | null

readonly

`ollama_modified_at`

Get the modified date from Ollama data if available.

type Date | undefined

readonly

`needs_ollama_details`

Check if this model needs its details loaded.

type boolean

readonly

`loaded`

Check if this model is currently loaded/running.
For Ollama models, this checks if the model is in the running models set.

type boolean

readonly

`constructor`

type new (options: ModelOptions): Model

`options`

type ModelOptions

`navigate_to_download`

Download this model. Currently only works for Ollama models.

type (): Promise<void>

returns Promise<void>

`navigate_to_provider_model_view`

Navigate to the model view. Currently only works for Ollama models.

type (): Promise<void>

returns Promise<void>

ModelContextmenu
#

`model`

type Model

`children`

type Snippet

ModelDetail
#

ModelDetail.svelte view source

`model`

type Model

`attrs?`

type SvelteHTMLElements['span'] | undefined

optional

ModelJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 17 more ...; ollama_show_response_error: ZodOptional<...>; }, $strict>

ModelJsonInput
#

ModelLink.svelte view source

{ name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }

ModelLink
#

`model`

type Model

`icon?`

true is equivalent to 'svg'

type boolean | 'svg' | 'glyph' | undefined

optional

`name?`

type Snippet | undefined

optional

ModelListitem
#

ModelListitem.svelte view source

`model`

type Model

`show_tags?`

type boolean | undefined

optional

ModelName
#

ZodString

ModelOptions
#

ModelPicker.svelte view source

ModelOptions

inheritance

extends:

CellOptions<typeof ModelJson>

ModelPicker
#

`onpick`

type (model: Model | undefined) => boolean | void

`items?`

type Array<Model>

optional

`filter?`

type ((model: Model) => boolean) | undefined

optional

`heading?`

type string | null

optional

ModelPickerDialog
#

ModelPickerDialog.svelte view source

`show`

type boolean

bindable

`onpick`

type (model: Model | undefined) => boolean | void

`filter?`

type ((model: Model) => boolean) | undefined

optional

`dialog_props?`

type OmitStrict<ComponentProps<typeof Dialog>, 'children'> | undefined

optional

`children?`

type Snippet | undefined

optional

Models
#

inheritance

extends:

Cell<typeof ModelsJson>

`items`

type IndexedCollection<Model>

readonly

`ordered_by_name`

Get all models ordered alphabetically by name.

type Array<Model>

readonly

`constructor`

type new (options: ModelsOptions): Models

`options`

type ModelsOptions

`add`

type (model_json: { name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }): void

`model_json`

type

{ name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }

returns void

`add_many`

type (models_json: { name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }[]): void

`models_json`

type

{ name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }[]

returns void

`find_by_name`

type (name: string): Model | undefined

`name`

type string

returns Model | undefined

`filter_by_names`

type (names: string[]): Model[] | undefined

`names`

type string[]

returns Model[] | undefined

`filter_by_tag`

type (tag: string): Model[]

`tag`

type string

returns Model[]

`remove_by_name`

type (name: string): void

`name`

type string

returns void

`clear`

type (): void

returns void

models_default
#

{ name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; created?: string | undefined; updated?: string | undefined; tags?: string[] | undefined; ... 13 more ...; ollama_show_response_error?: string | undefined; }[]

ModelSchema
#

ModelSelect.svelte view source

ZodCustom<Model, Model>

ModelSelect
#

`selected_model`

type Model

`models?`

type Array<Model> | undefined

optional

ModelsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; }, $strict>

ModelsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { name: string; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; id?: string | undefined; ... 16 more ...; ollama_show_response_error?: string | undefined; }[] | undefined; }

ModelsOptions
#

ModelSummary.svelte view source

ModelsOptions

inheritance

extends:

CellOptions<typeof ModelsJson>

ModelSummary
#

`model`

type Model

`omit_provider?`

type boolean | undefined

optional

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

MultiIndexOptions
#

zzz/build_info.ts view source

MultiIndexOptions<T, K>

Options for multi-value indexes.

generics

`T`

constraint IndexedItem

`K`

inheritance

extends:

IndexOptions<T, K>

`extractor`

Function that extracts the key(s) from an item.

type (item: T) => K | Array<K> | undefined

`sort`

Optional sort function for items in each bucket.

type (a: T, b: T) => number

NAME
#

"zzz"

NavItem
#

NavLink.svelte view source

NavItem

`group`

type string

`items`

type Array<NavLinkItem>

NavLink
#

`href`

type string

`selected?`

type boolean | undefined

optional

`show_selected_descendent?`

type boolean | undefined

optional

`children`

type Snippet<[selected: boolean, selected_descendent: boolean]>

NavLinkItem
#

NavLinkItem

`label`

type string

`href`

type string

`icon`

type string | SvgData

Ollama
#

Ollama client state management with simplified API.
Model data is stored in app.models, not here.
Status Display PatternFor unified status display (available/unavailable/checking), components should use:
- app.capabilities.ollama.status - unified status (prioritizes provider status)
- app.capabilities.ollama.error_message - unified error message
This ensures consistency with other providers (Claude, ChatGPT, Gemini) and maintains
a single source of truth. The Capabilities layer prioritizes backend provider status
(authoritative - checks if Ollama is installed) over action-level status (checks if API responds).
The lower-level properties here (list_status, list_error, provider_error, etc.) are
operational state that capabilities.ollama derives from. Use these for:
- Operational state (models, pulling, creating, etc.)
- Action-specific error handling
- Internal state management

inheritance

extends:

Cell<typeof OllamaJson>

`list_response`

type OllamaListResponse | null

`list_status`

type AsyncStatus

`list_error`

type string | null

`list_last_updated`

type number | null

`list_round_trip_time`

type number | null

`last_refreshed`

type string | null

`ever_responded`

type boolean

`ps_response`

type OllamaPsResponse | null

`ps_status`

type AsyncStatus

`ps_error`

type string | null

`ps_polling_enabled`

type boolean

`pull_model_name`

type string

`pull_insecure`

type boolean

`pulling_models`

type SvelteSet<string>

readonly

`copy_source_model`

type string

`copy_destination_model`

type string

`copy_is_copying`

type boolean

`create_model_name`

type string

`create_from_model`

type string

`create_system_prompt`

type string

`create_template`

type string

`create_is_creating`

type boolean

`manager_selected_view`

type 'configure' | 'model' | 'pull' | 'copy' | 'create'

`manager_selected_model`

type Model | null

`manager_last_active_view`

type {view: string; model: Model | null} | null

`show_read_actions`

type boolean

`available`

type boolean

readonly

`actions`

readonly

`pending_actions`

readonly

`completed_actions`

readonly

`filtered_actions`

readonly

`models`

type Array<Model>

readonly

`models_downloaded`

readonly

`models_not_downloaded`

readonly

`model_by_name`

type Map<ModelName, Model>

readonly

`model_names`

type Array<ModelName>

readonly

`running_models`

type Array<OllamaPsResponseItem>

readonly

`running_model_names`

type Set<ModelName>

readonly

`pull_parsed_model_name`

type ModelName

readonly

`pull_already_downloaded`

type boolean

readonly

`pull_can_pull`

type boolean

readonly

`pull_is_pulling`

type (model_name: string): boolean

`model_name`

type string

returns boolean

`copy_parsed_source_model`

type ModelName

readonly

`copy_parsed_destination_model`

type ModelName

readonly

`copy_is_duplicate_name`

type boolean

readonly

`copy_destination_model_changed`

type boolean

readonly

`create_parsed_model_name`

type ModelName

readonly

`create_is_duplicate_name`

type boolean

readonly

`create_can_create`

type boolean

readonly

`constructor`

type new (options: OllamaOptions): Ollama

`options`

type OllamaOptions

`dispose`

type (): void

returns void

`refresh`

Refresh the list of models and ps info and update the refresh timestamp.
Error handlers update state automatically.
If Ollama provider status indicates unavailability, skip API calls to avoid
overwriting the provider status with action error messages.

type (): Promise<{ list_response: { [x: string]: unknown; models: { [x: string]: unknown; digest: string; model: string; modified_at: string; name: string; size: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } | undefined; }[]; } | null; ps_response: { ...; } | null; }>

returns

Promise<{ list_response: { [x: string]: unknown; models: { [x: string]: unknown; digest: string; model: string; modified_at: string; name: string; size: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: stri...

`start_ps_polling`

Start polling for running models status.
Default interval is 10 seconds.

type (options?: { immediate?: boolean | undefined; interval?: number | undefined; } | undefined): void

`options?`

type { immediate?: boolean | undefined; interval?: number | undefined; } | undefined

optional

returns void

`stop_ps_polling`

Stop polling for running models status.

type (): void

returns void

`handle_ollama_list_start`

Handle the start of a list operation.

type (): void

returns void

`handle_ollama_list_complete`

List all models available on the Ollama server and sync with app.models.

type (response: { [x: string]: unknown; models: { [x: string]: unknown; digest: string; model: string; modified_at: string; name: string; size: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } | undefined; }[]; } | null): void

`response`

type

{ [x: string]: unknown; models: { [x: string]: unknown; digest: string; model: string; modified_at: string; name: string; size: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } | undefined; }[]; }...

returns void

`handle_ollama_ps_start`

Handle the start of a ps operation.

type (): void

returns void

`handle_ollama_ps_complete`

Get the list of currently running models.

type (response: { [x: string]: unknown; models: { [x: string]: unknown; digest: string; expires_at: string; model: string; name: string; size: number; size_vram: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } | undefined; }[]; } | null): void

`response`

type

{ [x: string]: unknown; models: { [x: string]: unknown; digest: string; expires_at: string; model: string; name: string; size: number; size_vram: number; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } |...

returns void

`handle_ollama_show`

Get detailed information about a specific model.

type (request: { [x: string]: unknown; model: string; system?: string | undefined; template?: string | undefined; options?: any; }, response: { [x: string]: unknown; capabilities?: string[] | undefined; details?: { [x: string]: unknown; ... 5 more ...; quantization_level: string; } | undefined; ... 5 more ...; tensors?: any[] | undefined; } | null): void

`request`

type { [x: string]: unknown; model: string; system?: string | undefined; template?: string | undefined; options?: any; }

`response`

type

{ [x: string]: unknown; capabilities?: string[] | undefined; details?: { [x: string]: unknown; families: string[]; family: string; format: string; parameter_size: string; parent_model: string; quantization_level: string; } | undefined; ... 5 more ...; tensors?: any[] | undefined; } | null

returns void

`handle_ollama_delete`

Delete a model from the Ollama server.

type (request: { [x: string]: unknown; model: string; }): Promise<void>

`request`

type { [x: string]: unknown; model: string; }

returns Promise<void>

`clear_model_details`

Clear details for a specific model.

type (model: Model): void

`model`

type Model

returns void

`clear_all_model_details`

Clear all model details.

type (): void

returns void

`pull`

Submit pull model form.

type (): Promise<void>

returns Promise<void>

`copy`

Submit copy model form.

type (): Promise<void>

returns Promise<void>

`create`

Submit create model form.

type (): Promise<void>

returns Promise<void>

`delete`

Submit delete model form.

type (model_name: string): Promise<void>

`model_name`

type string

returns Promise<void>

`unload`

Unload a model from memory.

type (model_name: string): Promise<void>

`model_name`

type string

returns Promise<void>

`select`

Select model in manager.

type (model: Model): Promise<void>

`model`

type Model

returns Promise<void>

`close_form`

Handle close form in manager.

type (): void

returns void

`set_manager_view`

Set the manager view and optionally the selected model.

`view`

type "model" | "configure" | "pull" | "copy" | "create"

`model?`

type Model | null | undefined

optional

returns void

`manager_back_to_last_view`

Navigate back to the last active view.

type (): void

returns void

ollama_copy_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ source: ZodString; destination: ZodString; }, $loose>; output: ZodNull; async: true; description: string; }

ollama_create_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; ... 9 more ...; adapters: ZodOptional<...>; }, $strict>...

ollama_delete_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ model: ZodString; }, $loose>; output: ZodNull; async: true; description: string; }

ollama_list_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodOptional<ZodVoid>; output: ZodUnion<...>; async: true; description: string; }

ollama_logo
#

{ label: string; paths: { d: string; }[]; }

ollama_progress_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; status: ZodString; digest: ZodOptional<...>; total: ZodOptional<...>; completed: ZodOpti...

ollama_ps_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodOptional<ZodVoid>; output: ZodUnion<...>; async: true; description: string; }

ollama_pull_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; model: ZodString; insecure: ZodOptional<...>; stream: Z...

ollama_show_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodObject<{ model: ZodString; system: ZodOptional<ZodString>; template: ZodOptional<...>; options: ZodOptional<...>; }, $loose>; output: ZodUnion<...>; async: true; descriptio...

ollama_unload_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ model: ZodString; }, $strict>; output: ZodNull; async: true; description: string; }

OLLAMA_URL
#

OllamaActionItem.svelte view source

"http://127.0.0.1:11434"

OllamaActionItem
#

`action`

type Action

OllamaActions
#

OllamaActions.svelte view source

`ollama`

type Ollama

OllamaCapabilityData
#

OllamaConfigure.svelte view source

OllamaCapabilityData

`list_response`

type OllamaListResponse | null

`ps_response`

type OllamaPsResponse | null

`round_trip_time`

type number | null

OllamaConfigure
#

`ollama`

type Ollama

`last_active_view`

type string | null

`onshowpull`

type () => void

`onback?`

type () => void

optional

OllamaCopyModel
#

OllamaCopyModel.svelte view source

`ollama`

type Ollama

`onclose`

type () => void

OllamaCopyRequest
#

ZodObject<{ source: ZodString; destination: ZodString; }, $loose>

OllamaCreateInput
#

OllamaCreateModel.svelte view source

ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; ... 9 more ...; adapters: ZodOptional<...>; }, $strict>

Input for ollama_create. Composes the Ollama create request with the streaming _meta envelope.
Re-wraps with z.strictObject because OllamaCreateRequest is a
z.looseObject (Ollama API passthrough). Action-spec inputs must reject
unknown keys per the canonical convention.

OllamaCreateModel
#

`ollama`

type Ollama

`onclose`

type () => void

`onshowpull`

type () => void

OllamaCreateRequest
#

ZodObject<{ model: ZodString; from: ZodOptional<ZodString>; stream: ZodOptional<ZodBoolean>; quantize: ZodOptional<ZodString>; ... 5 more ...; adapters: ZodOptional<...>; }, $loose>

OllamaDeleteRequest
#

ZodObject<{ model: ZodString; }, $loose>

OllamaJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; host: ZodDefault<...>; }, $strict>

OllamaJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; host?: string | undefined; }

OllamaListRequest
#

ZodOptional<ZodVoid>

OllamaListResponse
#

ZodObject<{ models: ZodArray<ZodObject<{ details: ZodOptional<ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>>; ... 4 more ...; size: ZodNumber; }, $loose>>; }, $loose>

OllamaListResponseItem
#

OllamaManager.svelte view source

ZodObject<{ details: ZodOptional<ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>>; ... 4 more ...; size: ZodNumber; }, $loose>

OllamaManager
#

`ollama`

type Ollama

OllamaModelDetail
#

OllamaModelDetail.svelte view source

`model`

type Model

`onshow`

type (model: Model) => void

`onclose?`

type (model: Model) => void

optional

`ondelete?`

type (model: Model) => void

optional

`header?`

type Snippet

optional

OllamaModelDetails
#

OllamaModelListitem.svelte view source

ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>

OllamaModelListitem
#

`model`

type Model

`onclick?`

type () => void

optional

OllamaModelStatus
#

OllamaModelStatus.svelte view source

`model`

type Model

`ollama`

type Ollama

OllamaOptions
#

OllamaOptions

OllamaProgressInput
#

ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; status: ZodString; digest: ZodOptional<...>; total: ZodOptional<...>; completed: ZodOptional<...>; }, $strict>

Input for ollama_progress. Composes the Ollama progress payload with the shared _meta envelope.
Re-wraps with z.strictObject because OllamaProgressResponse is a
z.looseObject (Ollama API passthrough). Action-spec inputs must reject
unknown keys per the canonical convention.

OllamaProgressResponse
#

ZodObject<{ status: ZodString; digest: ZodOptional<ZodString>; total: ZodOptional<ZodNumber>; completed: ZodOptional<ZodNumber>; }, $loose>

OllamaPsRequest
#

ZodOptional<ZodVoid>

OllamaPsResponse
#

ZodObject<{ models: ZodArray<ZodObject<{ details: ZodOptional<ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>>; ... 5 more ...; size_vram: ZodNumber; }, $loose>>; }, $loose>

OllamaPsResponseItem
#

OllamaPsStatus.svelte view source

ZodObject<{ details: ZodOptional<ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>>; ... 5 more ...; size_vram: ZodNumber; }, $loose>

OllamaPsStatus
#

`ollama`

type Ollama

OllamaPullInput
#

OllamaPullModel.svelte view source

ZodObject<{ _meta: ZodOptional<ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>>; model: ZodString; insecure: ZodOptional<...>; stream: ZodOptional<...>; }, $strict>

Input for ollama_pull. Composes the Ollama pull request with the streaming _meta envelope.
Re-wraps with z.strictObject because OllamaPullRequest is a
z.looseObject (Ollama API passthrough). Action-spec inputs must reject
unknown keys per the canonical convention.

OllamaPullModel
#

`ollama`

type Ollama

`onclose?`

type () => void

optional

`oncancel?`

type () => void

optional

OllamaPullRequest
#

ZodObject<{ model: ZodString; insecure: ZodOptional<ZodBoolean>; stream: ZodOptional<ZodBoolean>; }, $loose>

OllamaPushRequest
#

ZodObject<{ model: ZodString; insecure: ZodOptional<ZodBoolean>; stream: ZodOptional<ZodBoolean>; }, $loose>

OllamaShowRequest
#

ZodObject<{ model: ZodString; system: ZodOptional<ZodString>; template: ZodOptional<ZodString>; options: ZodOptional<ZodAny>; }, $loose>

OllamaShowResponse
#

ZodObject<{ capabilities: ZodOptional<ZodArray<ZodString>>; details: ZodOptional<ZodObject<{ families: ZodArray<ZodString>; family: ZodString; format: ZodString; parameter_size: ZodString; parent_model: ZodString; quantization_level: ZodString; }, $loose>>; ... 5 more ...; tensors: ZodOptional<...>; }, $loose>

OllamaStatusResponse
#

ZodObject<{ status: ZodString; }, $loose>

OllamaUnloadInput
#

ZodObject<{ model: ZodString; }, $strict>

Input for ollama_unload.

OnCompletionProgress
#

zzz/commands/open.ts view source

OnCompletionProgress

open
#

(runtime: RuntimeDeps, args: { _: string[]; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Open the zzz UI in a browser, auto-starting the daemon if needed.

`runtime`

type RuntimeDeps

`args`

type { _: string[]; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

OPEN_HOST_ADDRESSES
#

ReadonlySet<string>

Addresses that bind to all network interfaces.
These are dangerous without authentication because they expose the daemon to the LAN.

OpenArgs
#

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; }, $strict>

Open command arguments (default command).
Handles: zzz, zzz <file>, zzz <dir>.

OUTPUT_TOKEN_MAX_DEFAULT
#

url_params_helpers.ts view source

1000

parse_url_param_uuid
#

(value: unknown): (string & $brand<"Uuid">) | null

Parse and validate a UUID parameter value from the URL.

`value`

type unknown

returns

(string & $brand<"Uuid">) | null

parse_zzz_args
#

(args: string[]): ZzzParsedArgs

Parse zzz CLI arguments.
Phase 1: argv_parse for raw tokenization.
Phase 2: extract_global_flags for --help/-h, --version/-v.
Phase 3: Extract command and subcommand from positionals.

`args`

raw CLI arguments from Deno.args

type string[]

returns

ZzzParsedArgs

parsed argument structure

Part
#

part_helpers.ts view source

Abstract base class for all part types.

generics

`T`

constraint z.ZodType

default typeof PartJsonBase

inheritance

extends:

Cell<T>

`type`

type string

abstractreadonly

`start`

type number | null

`end`

type number | null

`length`

type number | null | undefined

readonly

`token_count`

type number | null | undefined

readonly

`content_preview`

content with a max length.

readonly

`name`

type string

`has_xml_tag`

type boolean

`xml_tag_name`

type string

`attributes`

type Array<XmlAttributeWithDefaults>

`enabled`

type boolean

`title`

type string | null

`summary`

type string | null

`xml_tag_name_default`

type string

readonly

`add_attribute`

type (partial?: { id?: string | undefined; key?: string | undefined; value?: string | undefined; }): void

`partial`

type { id?: string | undefined; key?: string | undefined; value?: string | undefined; }

default EMPTY_OBJECT

returns void

`update_attribute`

type (id: string & $brand<"Uuid">, updates: Partial<OmitStrict<{ id: string & $brand<"Uuid">; key: string; value: string; }, "id">>): boolean

`id`

type string & $brand<"Uuid">

`updates`

type Partial<OmitStrict<{ id: string & $brand<"Uuid">; key: string; value: string; }, "id">>

returns boolean

true if the attribute was updated, false if the attribute was not found

`remove_attribute`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`create`

type (app: Frontend, json: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | ... 1 more ... | undefined; ... 7 more ...; content?: string | undefined; }, options?: TextPartOptions | undefined): TextPart

static

`app`

type Frontend

`json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; has_xml_tag?: boolean | undefined; ... 6 more ...; content?: string | undefined; }

`options?`

type TextPartOptions | undefined

optional

returns TextPart

`create`

static

`app`

type Frontend

`json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; has_xml_tag?: boolean | undefined; ... 6 more ...; content?: string | undefined; }

`options?`

type TextPartOptions | undefined

optional

returns TextPart

`create`

static

`app`

type Frontend

`json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; has_xml_tag?: boolean | undefined; ... 6 more ...; content?: string | undefined; }

`options?`

type TextPartOptions | undefined

optional

returns TextPart

`create`

static

`app`

type Frontend

`json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; has_xml_tag?: boolean | undefined; ... 6 more ...; content?: string | undefined; }

`options?`

type TextPartOptions | undefined

optional

returns TextPart

PART_GLYPHS
#

{ text: string; diskfile: string; }

PartContextmenu
#

PartContextmenu.svelte view source

`part`

type PartUnion

`children`

type Snippet

PartEditorForDiskfile
#

PartEditorForDiskfile.svelte view source

`diskfile_part`

type DiskfilePart

`show_actions?`

type boolean | undefined

optional

PartEditorForText
#

PartEditorForText.svelte view source

`text_part`

type TextPart

PartJson
#

ZodDiscriminatedUnion<[ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 11 more ...; content: ZodDefault<...>; }, $strict>, ZodObject<...>], "type">

Union of all part types for deserialization.

PartJsonBase
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 10 more ...; summary: ZodDefault<...>; }, $strict>

Common properties for all part types.

PartJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; ... 7 more ...; content?: string | undefined; } | { ...; }

PartJsonType
#

PartList.svelte view source

PartJsonType

PartList
#

`parts`

type Array<PartUnion>

`prompt?`

type Prompt | undefined

optional

`onreorder?`

type ((from_index: number, to_index: number) => void) | undefined

optional

`reorderable_options?`

type ReorderableOptions | undefined

optional

`item_attrs?`

type SvelteHTMLElements['li'] | undefined

optional

`attrs?`

type SvelteHTMLElements['ul'] | undefined

optional

`empty?`

type Snippet | undefined

optional

PartListitem
#

PartListitem.svelte view source

`part`

type PartUnion

`selected?`

type boolean | undefined

optional

`onclick?`

type ((part: PartUnion) => void) | undefined

optional

`sm?`

type boolean | undefined

optional

`attrs?`

type SvelteHTMLElements['button'] | undefined

optional

PartOptions
#

PartOptions<T>

generics

`T`

constraint z.ZodType

default typeof PartJsonBase

inheritance

extends:

CellOptions<T>

`json`

type z.input<T>

PartOptionsUnion
#

PartPicker.svelte view source

PartOptionsUnion

PartPicker
#

`onpick`

type (part: PartUnion | undefined) => boolean | void

`filter?`

type ((part: PartUnion) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

PartPickerDialog
#

PartPickerDialog.svelte view source

`onpick`

type (part: PartUnion | undefined) => boolean | void

`show?`

type boolean | undefined

optional bindable

`filter?`

type ((part: PartUnion) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

`dialog_props?`

type OmitStrict<ComponentProps<typeof Dialog>, 'children'> | undefined

optional

PartRemoveButton
#

PartRemoveButton.svelte view source

`part`

type PartUnion

`prompt?`

type Prompt | undefined

optional

`prompts?`

type Prompts | undefined

optional

Parts
#

inheritance

extends:

Cell<typeof PartsJson>

`items`

type IndexedCollection<PartUnion>

readonly

`constructor`

type new (options: PartsOptions): Parts

`options`

type PartsOptions

`add`

Add a part to the collection.

type (json: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; ... 7 more ...; content?: string | undefined; } | { ...; }): PartUnion

`json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; ... 7 more ...; content?: string | undefined; } | { ...; }

returns PartUnion

`generate_unique_name`

Generate a unique name for a part.

type (base_name?: string): string

`base_name`

type string

default 'new part'

returns string

`remove`

Remove a part by id.

type (id: string & $brand<"Uuid">): boolean

`id`

type string & $brand<"Uuid">

returns boolean

`find_part_by_diskfile_path`

Find a part that references a specific file path.

type (path: string): PartUnion | undefined

`path`

type string

returns PartUnion | undefined

PartSchema
#

ZodCustom<Part<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>, Part<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>>

PartsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; }, $strict>

PartsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: ({ id?: string | undefined; created?: string | undefined; updated?: string | undefined; ... 10 more ...; content?: string | undefined; } | { ...; })[] | undefined; }

PartsOptions
#

PartStats.svelte view source

PartsOptions

inheritance

extends:

CellOptions<typeof PartsJson>

PartStats
#

`part`

type PartUnion

PartSummary
#

PartSummary.svelte view source

`part`

type PartUnion

`prompt?`

type Prompt | undefined

optional

PartToggleButton
#

PartToggleButton.svelte view source

`part`

type PartUnion

`attrs?`

type SvelteHTMLElements['input'] | undefined

optional

PartUnion
#

PartView.svelte view source

PartUnion

PartView
#

`part`

type PartUnion

`show_actions?`

type boolean | undefined

optional

PathNotAllowedError
#

Error thrown when a path is not allowed

inheritance

extends:

Error

`name`

`constructor`

type new (path: string, options?: ErrorOptions | undefined): PathNotAllowedError

`path`

type string

`options?`

type ErrorOptions | undefined

optional

PathWithLeadingSlash
#

ZodPipe<ZodString, ZodTransform<string, string>>

PathWithoutLeadingSlash
#

ZodPipe<ZodString, ZodTransform<string, string>>

PathWithoutTrailingSlash
#

ZodPipe<ZodString, ZodTransform<string, string>>

PathWithTrailingSlash
#

Picker.svelte view source

ZodPipe<ZodString, ZodTransform<string, string>>

Picker
#

PickerDialog
#

PickerDialog.svelte view source

ping_action_spec
#

{ method: string; kind: "request_response"; initiator: "both"; auth: { account: "none"; actor: "none"; }; side_effects: false; input: ZodVoid; output: ZodObject<{ ping_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>; async: true; description: string; }

PING_HISTORY_MAX
#

6

Maximum number of ping records to keep.

PingData
#

PingForm.svelte view source

PingData

`ping_id`

type JsonrpcRequestId

`completed`

type boolean

`sent_time`

type number

`received_time`

type number | null

`round_trip_time`

type number | null

PingForm
#

`children?`

type Snippet | undefined

optional

PingOutput
#

poller.svelte.ts view source

ZodObject<{ ping_id: ZodUnion<readonly [ZodString, ZodNumber]>; }, $strict>

Output for ping. Echoes the JSON-RPC request id back as ping_id.

Poller
#

Helper class to manage polling intervals.
Automatically cleans up on disposal.

`DEFAULT_INTERVAL`

static

`constructor`

type new (options: PollerOptions): Poller

`options`

type PollerOptions

`start`

Start polling with optional overrides.

type (options?: { immediate?: boolean | undefined; interval?: number | undefined; } | undefined): void

`options?`

type { immediate?: boolean | undefined; interval?: number | undefined; } | undefined

optional

returns void

`stop`

Stop polling.

type (): void

returns void

`set_interval`

Update the polling interval. If polling is active, it will restart with the new interval.
No-op if the interval is already set to the same value.

type (interval: number | undefined): void

`interval`

type number | undefined

returns void

`dispose`

Dispose of the poller, stopping any active polling.

type (): void

returns void

PollerOptions
#

poller.svelte.ts view source

PollerOptions

`poll_fn`

Function to call on each poll interval.

type () => void | Promise<void>

`interval`

Polling interval in milliseconds.

type number

`immediate`

Whether to run the poll function immediately on start, defaults to true.

type boolean

PONG_DISPLAY_LIMIT
#

6

PRESENCE_PENALTY_DEFAULT
#

ProgressBar.svelte view source

number | undefined

ProgressBar
#

`value`

The percentage value of the progress bar, 0-100.

type number

`text?`

type Snippet

optional

ProgressMeta
#

ZodObject<{ progressToken: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $loose>

Progress-token envelope shared by streaming actions. Carries the caller's
progressToken so streamed *_progress notifications can be correlated
with the originating request. looseObject lets transports tack on
additional MCP-style metadata without a schema bump.

Prompt
#

inheritance

extends:

Cell<typeof PromptJson>

`name`

type string

`parts`

type Array<PartUnion>

`content`

type string

readonly

`length`

type number

readonly

`token_count`

type number

readonly

`content_preview`

type string

readonly

`constructor`

type new (options: PromptOptions): Prompt

`options`

type PromptOptions

`add_part`

Add a part to this prompt.

type (part: PartUnion): PartUnion

`part`

type PartUnion

returns PartUnion

`remove_part`

type (id: string & $brand<"Uuid">): boolean

`id`

type string & $brand<"Uuid">

returns boolean

`remove_all_parts`

type (): void

returns void

`reorder_parts`

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

PromptActionContent
#

PromptContextmenu.svelte view source

string

PromptContextmenu
#

`prompt`

type Prompt

`children`

type Snippet

PromptJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; name: ZodDefault<...>; parts: ZodDefault<...>; }, $strict>

PromptJsonInput
#

PromptList.svelte view source

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ id?: string | undefined; created?: string | undefined; updated?: string | undefined; ... 10 more ...; content?: string | undefined; } | { ...; })[] | undefined; }

PromptList
#

PromptListitem
#

PromptListitem.svelte view source

`prompt`

type Prompt

`selected?`

type boolean | undefined

optional

PromptMessage
#

PromptMessage

`role`

type 'user' | 'system'

`content`

type Array<PromptActionContent>

PromptOptions
#

PromptPicker.svelte view source

PromptOptions

inheritance

extends:

CellOptions<typeof PromptJson>

`name`

type string

PromptPicker
#

`onpick`

type (prompt: Prompt | undefined) => boolean | void

`filter?`

type ((prompt: Prompt) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

`selected_ids?`

type Array<Uuid> | undefined

optional

PromptPickerDialog
#

PromptPickerDialog.svelte view source

`onpick`

type (prompt: Prompt | undefined) => boolean | void

`show?`

type boolean | undefined

optional bindable

`filter?`

type ((prompt: Prompt) => boolean) | undefined

optional

`exclude_ids?`

type Array<Uuid> | undefined

optional

`selected_ids?`

type Array<Uuid> | undefined

optional

`dialog_props?`

type OmitStrict<ComponentProps<typeof Dialog>, 'children'> | undefined

optional

Prompts
#

inheritance

extends:

Cell<typeof PromptsJson>

`items`

type IndexedCollection<Prompt>

readonly

`selected_id_last_non_null`

type Uuid | null

`selected`

type Prompt | undefined

readonly

`show_sort_controls`

Controls visibility of sort controls in the prompts list.

type boolean

`ordered_items`

Ordered array of prompts derived from the manual_order index.

type Array<Prompt>

readonly

`constructor`

type new (options: PromptsOptions): Prompts

`options`

type PromptsOptions

`filter_by_part`

type (part: PartUnion): Prompt[]

`part`

type PartUnion

returns Prompt[]

`add`

type (json?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ id?: string | undefined; created?: string | undefined; ... 11 more ...; content?: string | undefined; } | { ...; })[] | undefined; } | undefined): Prompt

`json?`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ id?: string | undefined; created?: string | undefined; ... 11 more ...; content?: string | undefined; } | { ...; })[] | undefined; } | undefined

optional

returns Prompt

`generate_unique_name`

type (base_name?: string): string

`base_name`

type string

default 'new prompt'

returns string

`add_many`

type (prompts_json: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ id?: string | undefined; created?: string | undefined; ... 11 more ...; content?: string | undefined; } | { ...; })[] | undefined; }[]): Prompt[]

`prompts_json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ id?: string | undefined; created?: string | undefined; updated?: string | undefined; ... 10 more ...; content?: string | undefined; } | { ...; })[] | undefined; }[]

returns Prompt[]

`remove`

type (prompt: Prompt): void

`prompt`

type Prompt

returns void

`remove_many`

type (prompt_ids: (string & $brand<"Uuid">)[]): number

`prompt_ids`

type (string & $brand<"Uuid">)[]

returns number

`select`

type (prompt_id: (string & $brand<"Uuid">) | null): Promise<void>

`prompt_id`

type (string & $brand<"Uuid">) | null

returns Promise<void>

`select_next`

type (): Promise<void>

returns Promise<void>

`navigate_to`

type (prompt_id: (string & $brand<"Uuid">) | null, force?: boolean): Promise<void>

`prompt_id`

type (string & $brand<"Uuid">) | null

`force`

type boolean

default false

returns Promise<void>

`reorder_prompts`

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

`remove_part`

type (part_id: string & $brand<"Uuid">): void

`part_id`

type string & $brand<"Uuid">

returns void

`toggle_sort_controls`

Toggles the visibility of sort controls in the prompts list.

type (value?: boolean): void

`value`

type boolean

default !this.show_sort_controls

returns void

PromptSchema
#

ZodCustom<Prompt, Prompt>

PromptsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; selected_id: ZodDefault<...>; show_sort_controls: ZodDefault<...>; }, $strict>

PromptsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; parts?: ({ ...; } | { ...; })[] | undefined; }[] | undefined; selected_id?: string | ... 1 more ... | undefi...

PromptsOptions
#

PromptsOptions

inheritance

extends:

CellOptions<typeof PromptsJson>

PromptsSchema
#

PromptStats.svelte view source

ZodCustom<Prompts, Prompts>

PromptStats
#

`prompt`

type Prompt

PromptSummary
#

PromptSummary.svelte view source

`prompt`

type Prompt

Provider
#

inheritance

extends:

Cell<typeof ProviderJson>

`name`

type ProviderName

`title`

type string

`url`

type string

`homepage`

type string

`company`

type string

`api_key_url`

type string | null

`models`

type Array<Model>

readonly

`status`

Status for this provider (availability, error messages, etc.).

type ProviderStatus | null

readonly

`available`

Whether this provider is available (configured with API keys, etc.).

type boolean

readonly

`constructor`

type new (options: ProviderOptions): Provider

`options`

type ProviderOptions

PROVIDER_ERROR_NEEDS_API_KEY
#

"needs API key"

PROVIDER_ERROR_NOT_INSTALLED
#

"not installed"

provider_load_status_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodObject<{ provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; reload: ZodOptional<...>; }, $strict>; output: ZodObject<......

provider_update_api_key_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "required"; roles: string[]; credential_types: string[]; }; side_effects: true; input: ZodObject<{ provider_name: ZodEnum<...>; api_key: ZodString; acting: ZodOptional<...>; }, $strict>; output: ZodObject<...>; asy...

ProviderData
#

{ type: "ollama"; value: any; } | { type: "claude"; value: any; } | { type: "chatgpt"; value: any; } | { type: "gemini"; value: { text: string; candidates?: any[] | null | undefined; function_calls?: any[] | null | undefined; prompt_feedback?: any; usage_metadata?: any; }; }

ProviderDataChatgpt
#

ZodObject<{ type: ZodLiteral<"chatgpt">; value: ZodDefault<ZodOptional<ZodAny>>; }, $strict>

ProviderDataClaude
#

ZodObject<{ type: ZodLiteral<"claude">; value: ZodDefault<ZodOptional<ZodAny>>; }, $strict>

ProviderDataGemini
#

ZodObject<{ type: ZodLiteral<"gemini">; value: ZodObject<{ text: ZodString; candidates: ZodOptional<ZodNullable<ZodArray<ZodAny>>>; function_calls: ZodOptional<...>; prompt_feedback: ZodOptional<...>; usage_metadata: ZodOptional<...>; }, $strict>; }, $strict>

ProviderDataOllama
#

ZodObject<{ type: ZodLiteral<"ollama">; value: ZodDefault<ZodOptional<ZodAny>>; }, $strict>

ProviderDataSchema
#

ProviderDetail.svelte view source

ZodDiscriminatedUnion<[ZodObject<{ type: ZodLiteral<"ollama">; value: ZodDefault<ZodOptional<ZodAny>>; }, $strict>, ZodObject<{ type: ZodLiteral<...>; value: ZodDefault<...>; }, $strict>, ZodObject<...>, ZodObject<...>], "type">

ProviderDetail
#

`provider`

type Provider

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

ProviderJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 6 more ...; api_key_url: ZodNullable<...>; }, $strict>

ProviderJsonInput
#

ProviderLink.svelte view source

{ name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

ProviderLink
#

`provider`

type Provider | null | undefined

`icon?`

type 'glyph' | 'svg' | Snippet<[provider: Provider, glyph: string]> | undefined

optional

`icon_props?`

type Record<string, any> | undefined

optional

`show_name?`

type boolean | undefined

optional

`fallback_attrs?`

type SvelteHTMLElements['span'] | undefined

optional

`fallback?`

type Snippet | undefined

optional

ProviderLoadStatusInput
#

ZodObject<{ provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; reload: ZodOptional<ZodDefault<ZodBoolean>>; }, $strict>

Input for provider_load_status.

ProviderLoadStatusOutput
#

ProviderLogo.svelte view source

ZodObject<{ status: ZodDiscriminatedUnion<[ZodObject<{ name: ZodString; available: ZodLiteral<true>; checked_at: ZodNumber; }, $strict>, ZodObject<{ name: ZodString; available: ZodLiteral<...>; error: ZodString; checked_at: ZodNumber; }, $strict>], "available">; }, $strict>

Output for provider_load_status.

ProviderLogo
#

`name`

type ProviderName

`fill?`

type string | null | undefined

optional

`size?`

type string | undefined

optional

`inline?`

type boolean | undefined

optional

ProviderName
#

ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>

See app.providers.names for the available names at runtime.

ProviderOptions
#

ProviderOptions

inheritance

extends:

CellOptions<typeof ProviderJson>

Providers
#

inheritance

extends:

Cell<typeof ProvidersJson>

`items`

type Array<Provider>

`names`

type ReadonlyArray<ProviderName>

readonly

`constructor`

type new (options: ProvidersOptions): Providers

`options`

type ProvidersOptions

`add`

type (provider: Provider): void

`provider`

type Provider

returns void

`find_by_name`

type (name: string): Provider | undefined

`name`

type string

returns Provider | undefined

`remove_by_name`

type (name: string): void

`name`

type string

returns void

`clear`

type (): void

returns void

providers_default
#

{ name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; company: string; api_key_url: string | null; id?: string | undefined; created?: string | undefined; updated?: string | undefined; }[]

ProvidersJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; }, $strict>

ProvidersJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { name: "ollama" | "claude" | "chatgpt" | "gemini"; title: string; url: string; homepage: string; ... 4 more ...; updated?: string | undefined; }[] | undefined; }

ProvidersOptions
#

ProvidersOptions

inheritance

extends:

CellOptions<typeof ProvidersJson>

ProviderStatus
#

ProviderSummary.svelte view source

ZodDiscriminatedUnion<[ZodObject<{ name: ZodString; available: ZodLiteral<true>; checked_at: ZodNumber; }, $strict>, ZodObject<{ name: ZodString; available: ZodLiteral<...>; error: ZodString; checked_at: ZodNumber; }, $strict>], "available">

ProviderSummary
#

`provider`

type Provider

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

ProviderUpdateApiKeyInput
#

ZodObject<{ provider_name: ZodEnum<{ ollama: "ollama"; claude: "claude"; chatgpt: "chatgpt"; gemini: "gemini"; }>; api_key: ZodString; acting: ZodOptional<$ZodBranded<ZodUUID, "Uuid", "out">>; }, $strict>

Input for provider_update_api_key.

ProviderUpdateApiKeyOutput
#

ZodObject<{ status: ZodDiscriminatedUnion<[ZodObject<{ name: ZodString; available: ZodLiteral<true>; checked_at: ZodNumber; }, $strict>, ZodObject<{ name: ZodString; available: ZodLiteral<...>; error: ZodString; checked_at: ZodNumber; }, $strict>], "available">; }, $strict>

Output for provider_update_api_key.

pty_close
#

(master_fd: number): void

Close the PTY master fd.

`master_fd`

type number

returns

void

pty_kill
#

(pid: number, signal?: number): void

Send a signal to a process. Defaults to SIGTERM.

`pid`

type number

`signal`

type number

default SIGTERM

returns

void

pty_read
#

(master_fd: number): Uint8Array<ArrayBufferLike> | null

Read available data from the PTY. Returns null when no data (EAGAIN) or on EOF/error.

`master_fd`

type number

returns

Uint8Array<ArrayBufferLike> | null

pty_read_status
#

(master_fd: number): Uint8Array<ArrayBufferLike> | "eagain" | "eof"

Read from PTY, distinguishing EAGAIN (no data yet) from EOF/error.
Returns: bytes read (Uint8Array), 'eagain', or 'eof'.

`master_fd`

type number

returns

Uint8Array<ArrayBufferLike> | "eagain" | "eof"

pty_resize
#

(master_fd: number, cols: number, rows: number): void

Resize the PTY window.

`master_fd`

type number

`cols`

type number

`rows`

type number

returns

void

pty_spawn
#

(command: string, args: string[], cwd?: string | undefined, cols?: number, rows?: number): PtySpawnResult

Spawn a process in a new PTY.

`command`

type string

`args`

type string[]

`cwd?`

type string | undefined

optional

`cols`

type number

default 80

`rows`

type number

default 24

returns

PtySpawnResult

pty_waitpid
#

(pid: number): PtyWaitResult

Non-blocking waitpid. Returns whether the process has exited and its status.

`pid`

type number

returns

PtyWaitResult

pty_write
#

(master_fd: number, data: Uint8Array<ArrayBufferLike>): number

Write data to the PTY.

`master_fd`

type number

`data`

type Uint8Array<ArrayBufferLike>

returns

number

PtyManager
#

Manages spawned PTY processes keyed by terminal_id.
Uses real PTY via FFI when available, falls back to Deno.Command pipes.

`log`

type Logger | null

readonly

`use_ffi`

type boolean

readonly

`constructor`

type new (options: PtyManagerOptions): PtyManager

`options`

type PtyManagerOptions

`spawn`

Spawn a new PTY process and begin streaming its output.

type (terminal_id: string & $brand<"Uuid">, command: string, args: string[], cwd?: string | undefined, cols?: number, rows?: number): void

`terminal_id`

type string & $brand<"Uuid">

`command`

type string

`args`

type string[]

`cwd?`

type string | undefined

optional

`cols`

type number

default 80

`rows`

type number

default 24

returns void

`write`

Write data to a terminal's stdin.

type (terminal_id: string & $brand<"Uuid">, data: string): Promise<void>

`terminal_id`

type string & $brand<"Uuid">

`data`

type string

returns Promise<void>

`resize`

Resize the PTY window. Only works in FFI mode.

type (terminal_id: string & $brand<"Uuid">, cols: number, rows: number): void

`terminal_id`

type string & $brand<"Uuid">

`cols`

type number

`rows`

type number

returns void

`kill`

Kill a terminal process.

type (terminal_id: string & $brand<"Uuid">, signal?: string | undefined): Promise<number | null>

`terminal_id`

type string & $brand<"Uuid">

`signal?`

type string | undefined

optional

returns Promise<number | null>

`has`

Check if a terminal exists and is tracked.

type (terminal_id: string & $brand<"Uuid">): boolean

`terminal_id`

type string & $brand<"Uuid">

returns boolean

`destroy`

Kill all terminal processes. Called on backend shutdown.

type (): Promise<void>

returns Promise<void>

PtyManagerOptions
#

PtyManagerOptions

`api`

type BackendActionsApi

`log`

type Logger | null

PtyProcess
#

PtyProcess

PtySpawnResult
#

PtySpawnResult

`pid`

type number

`master_fd`

type number

PtyWaitResult
#

PtyWaitResult

`exited`

type boolean

`status`

type number

QueuedMessage
#

server/register_websocket_actions.ts view source

QueuedMessage

Queued message that couldn't be sent immediately.

`id`

type Uuid

`data`

type any

`created`

type number

register_websocket_actions
#

({ path, app, backend, db, upgradeWebSocket, allowed_origins, artificial_delay, transport, extra_actions, }: RegisterWebsocketActionsOptions): void

Registers the WebSocket endpoint for all zzz request/response actions.
Per-action auth, Zod validation, transaction scope, and socket-scoped
notify / signal come from fuz_app. zzz domain state reaches handlers
through the Backend closure baked into the handler map at boot.

`__0`

type RegisterWebsocketActionsOptions

returns

void

RegisterWebsocketActionsOptions
#

server/register_websocket_actions.ts view source

RegisterWebsocketActionsOptions

`path`

type string

`app`

type Hono

`backend`

type Backend

`db`

Pool-level DB — the dispatcher wraps in db.transaction for side_effects: true actions.

type Db

`upgradeWebSocket`

type UpgradeWebSocket

`allowed_origins`

Origin allowlist regexes — applied to the upgrade by register_ws_endpoint.

type Array<RegExp>

`artificial_delay`

Artificial response delay in ms (testing).

type number

`transport`

type BackendWebsocketTransport

`extra_actions`

Extra actions to register alongside zzz's production actions — used by
integration tests to opt in _test_* specs via ZZZ_ENABLE_TEST_ACTIONS.
Production callers leave this empty.

type ReadonlyArray<Action>

RemoteNotificationActionMethod
#

thread_helpers.ts view source

ZodEnum<{ filer_change: "filer_change"; completion_progress: "completion_progress"; ollama_progress: "ollama_progress"; terminal_data: "terminal_data"; terminal_exited: "terminal_exited"; workspace_changed: "workspace_changed"; cancel: "cancel"; }>

Names of all remote_notification actions.

render_completion_messages
#

(turns: Iterable<Turn>, completion_messages?: { [x: string]: unknown; role: string; content: string; }[]): { [x: string]: unknown; role: string; content: string; }[]

Creates a thread history array for model consumption from a collection of turns.
Normalizes content for assistant turns with responses.

`turns`

type Iterable<Turn>

`completion_messages`

type { [x: string]: unknown; role: string; content: string; }[]

default []

returns

{ [x: string]: unknown; role: string; content: string; }[]

render_message_with_role
#

thread_helpers.ts view source

(role: string, content: string, tag?: string): string

Renders a single message with an XML tag that includes the role attribute.

`role`

type string

`content`

type string

`tag`

type string

default 'message'

returns

string

render_messages_to_string
#

thread_helpers.ts view source

(turns: Iterable<{ role: string; content: string; enabled?: boolean | undefined; }>, tag?: string): string

`turns`

type Iterable<{ role: string; content: string; enabled?: boolean | undefined; }>

`tag`

type string

default 'message'

returns

string

reorder_list
#

list_helpers.ts view source

(items: any[], from_index: number, to_index: number): void

Reorders an array, mutating it by moving an item from one index to another.

`items`

type any[]

`from_index`

type number

`to_index`

type number

returns

void

Reorderable
#

inheritance

implements:

ReorderableStyleOptions

`initialized`

`source_index`

`source_item_id`

type ReorderableItemId | null

`active_indicator_item_id`

type ReorderableItemId | null

readonly

`list_class`

type string | null

readonly

`item_class`

type string | null

readonly

`dragging_class`

type string | null

readonly

`drag_over_class`

type string | null

readonly

`drag_over_top_class`

type string | null

readonly

`drag_over_bottom_class`

type string | null

readonly

`drag_over_left_class`

type string | null

readonly

`drag_over_right_class`

type string | null

readonly

`invalid_drop_class`

type string | null

readonly

`list_node`

type HTMLElement | null

`list_params`

type ReorderableListParams | null

`indices`

type Map<ReorderableItemId, number>

readonly

`elements`

type Map<ReorderableItemId, HTMLElement>

readonly

`pending_items`

type Array<{ id: ReorderableItemId; index: number; element: HTMLElement; }>

`constructor`

type new (options?: ReorderableOptions): Reorderable

`options`

type ReorderableOptions

default EMPTY_OBJECT

`init`

Made public for testing purposes.

type (): void

returns void

`clear_indicators`

type (): void

returns void

`update_indicator`

type (item_id: ReorderableItemId, new_indicator: ReorderableDropPosition, is_valid?: boolean): void

`item_id`

type ReorderableItemId

`new_indicator`

type ReorderableDropPosition

`is_valid`

type boolean

default true

returns void

`list`

`item`

ReorderableDirection
#

ReorderableDirection

ReorderableDropPosition
#

ReorderableDropPosition

ReorderableId
#

ReorderableId

ReorderableItemId
#

ReorderableItemId

ReorderableItemParams
#

ReorderableItemParams

Parameters for item attachment.

`index`

type number

ReorderableListParams
#

ReorderableListParams

Parameters for list attachment.

`onreorder`

type (from_index: number, to_index: number) => void

`can_reorder`

type (from_index: number, to_index: number) => boolean

`direction`

type ReorderableDirection

ReorderableOptions
#

ReorderableOptions

Additional configuration options for Reorderable.

`direction`

Forces a specific direction for the reorderable list.
Defaults to auto-detection, 'vertical' as the fallback.

type ReorderableDirection

`list_class`

type string | null

`item_class`

type string | null

`dragging_class`

type string | null

`drag_over_class`

type string | null

`drag_over_top_class`

type string | null

`drag_over_bottom_class`

type string | null

`drag_over_left_class`

type string | null

`drag_over_right_class`

type string | null

`invalid_drop_class`

type string | null

ReorderableStyleOptions
#

ReorderableStyleOptions

Styling configuration for reorderable components.

`list_class`

type string | null

`item_class`

type string | null

`dragging_class`

type string | null

`drag_over_class`

type string | null

`drag_over_top_class`

type string | null

`drag_over_bottom_class`

type string | null

`drag_over_left_class`

type string | null

`drag_over_right_class`

type string | null

`invalid_drop_class`

type string | null

ReorderableValidDropPosition
#

ReorderableValidDropPosition

RequestResponseActionMethod
#

server/helpers.ts view source

ZodEnum<{ ping: "ping"; session_load: "session_load"; diskfile_update: "diskfile_update"; diskfile_delete: "diskfile_delete"; directory_create: "directory_create"; completion_create: "completion_create"; ... 17 more ...; heartbeat: "heartbeat"; }>

Names of all request_response actions.

save_completion_response_to_disk
#

(input: { completion_request: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; prompt: string; completion_messages?: { ...; }[] | undefined; }; _meta?: { ...; } | undefined; }, output: { ...; }, zzz_dir: string, scoped_fs: ScopedFs): Promise<...>

`input`

type

{ completion_request: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; prompt: string; completion_messages?: { ...; }[] | undefined; }; _meta?: { ...; } | undefined; }

`output`

type

{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }

`zzz_dir`

type string

`scoped_fs`

type ScopedFs

returns

Promise<void>

save_zzz_cli_config
#

(runtime: Pick<EnvDeps, "env_get"> & FsWriteDeps, config: { zzz_config_port: number; }): Promise<void>

Save CLI configuration to ~/.zzz/config.json.

`runtime`

runtime with file write capability

type Pick<EnvDeps, "env_get"> & FsWriteDeps

`config`

configuration to save

type { zzz_config_port: number; }

returns

Promise<void>

SchemaClassInfo
#

SchemaClassInfo

Schema class information extracted from a Zod schema.

`type`

type string

`is_array`

type boolean

`class_name`

type string

`element_class`

type string

SchemaKeys
#

schema_registry.ts view source

SchemaKeys<T>

Get keys from a Zod schema object.

generics

`T`

constraint z.ZodType

SchemaRegistry
#

A central registry for schemas and actions.
Provides a single source of truth for schema definitions.

`schemas`

All schemas, including model schemas, action params, and responses.

type Array<z.ZodType>

`model_schemas`

Model schemas are distinct from the action schemas.
Models are the nouns compared to the Action verbs,
and compared to Views they are data not Svelte components.

type Array<z.ZodType>

`action_params_schemas`

Action parameter schemas.

type Array<z.ZodType>

`action_response_schemas`

Action response schemas.

type Array<z.ZodType>

`schema_by_name`

Map of schema names to schemas.

type Map<VocabName, z.ZodType>

`name_by_schema`

Map of schemas to their names, for reverse lookup.
Zod schemas don't have a name property and we don't want to abuse description.

type Map<z.ZodType, VocabName>

`action_specs`

Collection of all action specs.

type Array<ActionSpecUnion>

`request_response_action_specs`

Collection of 'request_response' action specs.

type Array<RequestResponseActionSpec>

`remote_notification_action_specs`

Collection of 'remote_notification' action specs.

type Array<RemoteNotificationActionSpec>

`local_call_action_specs`

Collection of 'local_call' action specs.

type Array<LocalCallActionSpec>

`action_spec_by_name_map`

Map of action spec names to action specs.

type Map<ActionMethod, ActionSpecUnion>

`add_schema`

Add a schema to the appropriate registries.

type (name: VocabName, schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | { method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; ... 8 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; }): void

`name`

type VocabName

`schema`

type

ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | { method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 7 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; }

returns void

`register_many`

Register multiple schemas at once.

type (schemas: Record<string, any>): void

`schemas`

type Record<string, any>

returns void

`lookup_schema_name`

Lookup a schema name, guaranteed to return a string, or throws.

type (schema: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>): VocabName

`schema`

type ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>

returns VocabName

`get_action_spec`

Get an action specification by method name.

`method`

type

"ping" | "session_load" | "filer_change" | "diskfile_update" | "diskfile_delete" | "directory_create" | "completion_create" | "completion_progress" | "ollama_progress" | ... 22 more ... | "cancel"

returns

{ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; }...

`get_schema`

Get a schema by name.

type (name: VocabName): ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | undefined

`name`

type VocabName

returns ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>> | undefined

SchemaValue
#

SchemaValue<T, K>

Get value type for a specific key in a Zod schema.

generics

`T`

constraint z.ZodType

`K`

constraint SchemaKeys<T>

ScopedFs
#

Provides a secure wrapper around filesystem operations to prevent path traversal attacks and
unauthorized file access.
Security features:
- Restricts operations to specified allowed paths
- Prevents path traversal attacks by normalizing all paths
- Blocks access to symlinks to avoid arbitrary file access
- Requires absolute paths to avoid relative path confusion
- Validates the entire path hierarchy for each operation
ScopedFs should be used whenever performing filesystem operations on
user-provided or untrusted input paths to ensure proper access boundaries.

`constructor`

Create a new ScopedFs instance with the specified allowed paths.

type new (allowed_paths: string[] | readonly string[]): ScopedFs

`allowed_paths`

array of absolute paths that operations will be restricted to

type string[] | readonly string[]

`add_path`

Add a path to the allowed set. No-op if already present.

type (path: string): boolean

`path`

absolute directory path to allow

type string

returns boolean

true if the path was added, false if already allowed

`remove_path`

Remove a path from the allowed set.

type (path: string): boolean

`path`

absolute directory path to remove

type string

returns boolean

true if the path was removed, false if not found

`has_path`

Check if a directory path is in the allowed set.

type (path: string): boolean

`path`

absolute directory path to check

type string

returns boolean

true if the path is an allowed root

`is_path_allowed`

Checks if the given path is allowed based on the paths provided during instantiation.

type (path_to_check: string): boolean

`path_to_check`

type string

returns boolean

`is_path_safe`

Performs a complete security check on a path, including symlink validation

type (path_to_check: string): Promise<boolean>

`path_to_check`

type string

returns Promise<boolean>

`read_file`

type (file_path: string, options?: (ObjectEncodingOptions & Abortable & { flag?: OpenMode | undefined; }) | BufferEncoding | null | undefined): Promise<...>

`file_path`

type string

`options`

type (ObjectEncodingOptions & Abortable & { flag?: OpenMode | undefined; }) | BufferEncoding | null | undefined

default 'utf8'

returns Promise<string | Buffer<ArrayBufferLike>>

`write_file`

`file_path`

type string

`data`

type

string | ArrayBufferView<ArrayBufferLike> | Iterable<string | ArrayBufferView<ArrayBufferLike>> | AsyncIterable<...> | Stream

`options`

type

BufferEncoding | (ObjectEncodingOptions & { mode?: Mode | undefined; flag?: OpenMode | undefined; flush?: boolean | undefined; } & Abortable) | null | undefined

default 'utf8'

returns Promise<void>

`rm`

type (path_to_remove: string, options?: RmOptions | undefined): Promise<void>

`path_to_remove`

type string

`options?`

type RmOptions | undefined

optional

returns Promise<void>

`mkdir`

type (dir_path: string, options?: MakeDirectoryOptions | undefined): Promise<string | undefined>

`dir_path`

type string

`options?`

type MakeDirectoryOptions | undefined

optional

returns Promise<string | undefined>

`readdir`

type (path: string, options?: BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined): Promise<...>

`path`

type string

`options?`

type

BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined

optional

returns Promise<string[]>

`readdir`

type (path: string, options?: BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined): Promise<...>

`path`

type string

`options?`

type

BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined

optional

returns Promise<string[]>

`readdir`

type (path: string, options?: BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined): Promise<...>

`path`

type string

`options?`

type

BufferEncoding | (ObjectEncodingOptions & { withFileTypes?: false | undefined; recursive?: boolean | undefined; }) | null | undefined

optional

returns Promise<string[]>

`stat`

type (path_to_stat: string, options?: StatOptions | undefined): Promise<Stats>

`path_to_stat`

type string

`options?`

type StatOptions | undefined

optional

returns Promise<Stats>

`stat`

type (path_to_stat: string, options?: StatOptions | undefined): Promise<Stats>

`path_to_stat`

type string

`options?`

type StatOptions | undefined

optional

returns Promise<Stats>

`stat`

type (path_to_stat: string, options?: StatOptions | undefined): Promise<Stats>

`path_to_stat`

type string

`options?`

type StatOptions | undefined

optional

returns Promise<Stats>

`copy_file`

type (source: string, destination: string, mode?: number | undefined): Promise<void>

`source`

type string

`destination`

type string

`mode?`

type number | undefined

optional

returns Promise<void>

`exists`

type (path_to_check: string): Promise<boolean>

`path_to_check`

type string

returns Promise<boolean>

ScopedFsPath
#

$ZodBranded<ZodPipe<ZodString, ZodTransform<string, string>>, "ScopedFsPath", "out">

A branded type for representing safely normalized filesystem paths

SCRATCHPAD_NAME
#

scrollable.svelte.ts view source

"scratchpad"

Scrollable
#

Manages scroll state and provides attachments for scroll detection and styling.

`target_class`

CSS class name to apply when scrolled.

type string

`threshold`

Threshold in pixels before considering the element scrolled.

type number

`scroll_y`

The current scroll Y position.

type number

`scrolled`

Whether element is scrolled past threshold.

type boolean

readonly

`constructor`

type new (params?: ScrollableParameters | undefined): Scrollable

`params?`

type ScrollableParameters | undefined

optional

`container`

Attachment for the scrollable container - detects scrolling and updates state.

type Attachment

`target`

Attachment for the element that should receive the scrolled class.
Since attachments run in effects, the class updates will be reactive automatically.

type Attachment

ScrollableParameters
#

scrollable.svelte.ts view source

ScrollableParameters

`target_class`

CSS class to apply to the target element when scrolled. Defaults to 'scrolled'.

type string

`threshold`

Threshold in pixels before considering the element scrolled. Defaults to 0.

type number

SEED_DEFAULT
#

number | undefined

SerializableDisknode
#

ZodObject<{ id: $ZodBranded<ZodString, "DiskfilePath", "out">; source_dir: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<...>>, "DiskfileDirectoryPath", "out">; ... 4 more ...; dependencies: ZodArray<...>; }, $strict>

SERVER_HOST
#

string

SERVER_PROTOCOL
#

string

SERVER_PROXIED_PORT
#

number

SERVER_URL
#

string

ServerCapabilityData
#

ServerCapabilityData

`round_trip_time`

type number

session_load_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodVoid; output: ZodObject<{ data: ZodObject<{ zzz_dir: $ZodBranded<ZodPipe<ZodPipe<...>, $ZodBranded<...>>, "DiskfileDirectoryPath", "out">; scoped_dirs: ZodReadonly<...>; fi...

SessionLoadData
#

ZodObject<{ zzz_dir: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; scoped_dirs: ZodReadonly<...>; files: ZodArray<...>; provider_status: ZodArray<...>; workspaces: ZodArray<...>; }, $strict>

Inner payload of session_load. The fields here are the actual session
snapshot — files, scoped dirs, provider status, workspaces.
TODO extract to diskfile_types.ts (or a session-specific module) once
the Rust backend grows its own typed session response and we can move
this schema to the shared boundary.

SessionLoadOutput
#

ZodObject<{ data: ZodObject<{ zzz_dir: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; scoped_dirs: ZodReadonly<...>; files: ZodArray<...>; provider_status: ZodArray<...>; workspaces: ZodArray<...>; }, $strict>; },...

Output for session_load. The data wrapper is historical and kept for
cross-backend parity: the Rust backend serializes this exact shape
(crates/zzz_server/src/handlers.rs::SessionLoadResult) and three
integration tests in test/integration/tests.ts read result.data.*
directly. Flattening would break parity in both places, so the wrapper
stays until the Rust side moves alongside.

set_reorderable_drag_data_transfer
#

Settings.svelte view source

(dataTransfer: DataTransfer, item_id: ReorderableItemId): void

Set up drag data transfer with consistent properties and formats
This centralizes the dataTransfer setup logic used in multiple places.

`dataTransfer`

type DataTransfer

`item_id`

type ReorderableItemId

returns

void

Settings
#

show_help
#

(command?: string | undefined, subcommand?: string | undefined): void

Display help message.

`command?`

type string | undefined

optional

`subcommand?`

type string | undefined

optional

returns

void

show_version
#

(): void

Display version.

returns

void

SIGKILL
#

9

SIGTERM
#

15

SingleIndexOptions
#

SingleIndexOptions<T, K>

Options for single-value indexes.

generics

`T`

constraint IndexedItem

`K`

inheritance

extends:

IndexOptions<T, K>

`extractor`

Function that extracts the key from an item.

type (item: T) => K

Socket
#

SocketMessageQueue.svelte view source

Wraps FrontendWebsocketClient with zzz-specific concerns: a
retryable fire-and-forget send queue (distinct from fuz_app's
request-level durable queue), URL input tracking, and a mapping from
fuz_app's SocketStatus onto zzz's AsyncStatus. Plain reactive class
— not a Cell. Implements WebsocketRpcConnection so it can back
FrontendWebsocketTransport; the request method is a one-line
delegate to the underlying FrontendWebsocketClient, keeping the
pending-request map in one canonical place.
The bespoke heartbeat timer has been retired — fuz_app's
FrontendWebsocketClient now ships an activity-aware heartbeat that
sends the shared heartbeat_action at heartbeat_interval idle.
Assigning heartbeat_interval pushes the new policy into the live
client immediately (the timer is restarted in place when connected).
Reconnect settings (reconnect_delay, reconnect_delay_max,
auto_reconnect) propagate to the underlying client on assignment
via apply_reconnect_policy() — in-flight waits are monotonically
shortened (never extended).

inheritance

implements:

WebsocketRpcConnection

`app`

type Frontend

readonly

`url_input`

type string

`last_send_time`

UI timestamps for the "last send" / "last receive" diagnostics in
CapabilityWebsocket. Not used for heartbeat scheduling —
fuz_app's client owns that.

type number | null

`last_receive_time`

type number | null

`message_queue`

type Array<QueuedMessage>

`failed_messages`

type SvelteMap<string, FailedMessage>

`ws`

type WebSocket | null

readonly

`url`

type string | null

readonly

`reconnect_count`

type number

readonly

`current_reconnect_delay`

type number

readonly

`last_connect_time`

type number | null

readonly

`reconnect_attempt`

Changes each time a close fires — used by the UI as an animation key so
each reconnect wait restarts the progress bar.

type number

readonly

`is_reconnect_pending`

type boolean

readonly

`status`

type AsyncStatus

readonly

`connected`

type boolean

readonly

`open`

type boolean

readonly

`can_send`

type boolean

readonly

`has_queued_messages`

type boolean

readonly

`queued_message_count`

type number

readonly

`failed_message_count`

type number

readonly

`connection_duration`

type number | null

readonly

`connection_duration_rounded`

type number | null

readonly

`constructor`

type new (options: SocketOptions): Socket

`options`

type SocketOptions

`connect`

type (url?: string | null): void

`url`

type string | null

default null

returns void

`disconnect`

type (): void

returns void

`request`

Delegate to the underlying FrontendWebsocketClient.request — keeps the
pending-request map, durable queue, and AbortSignal cancel in one
canonical place. Rejects when there is no client (call connect() first).

type (method: string, params?: unknown, options?: { signal?: AbortSignal | undefined; queue?: boolean | undefined; id?: string | number | undefined; } | undefined): Promise<unknown>

`method`

type string

`params?`

type unknown

optional

`options?`

type { signal?: AbortSignal | undefined; queue?: boolean | undefined; id?: string | number | undefined; } | undefined

optional

returns Promise<unknown>

`send`

type (data: object): boolean

`data`

type object

returns boolean

`update_url`

type (url: string): void

`url`

type string

returns void

`retry_queued_messages`

type (): void

returns void

`clear_failed_messages`

type (): void

returns void

`cancel_reconnect`

type (): void

returns void

`apply_reconnect_policy`

Push the current auto_reconnect / reconnect_delay /
reconnect_delay_max fields to the underlying client. No-op when
there is no client (next connect() picks them up from construction).

type (): void

returns void

`add_message_handler`

type (handler: SocketMessageHandler): () => void

`handler`

type SocketMessageHandler

returns () => void

`add_error_handler`

type (handler: SocketErrorHandler): () => void

`handler`

type SocketErrorHandler

returns () => void

SocketMessageQueue
#

`socket`

type Socket

`type`

type 'queued' | 'failed'

SocketOptions
#

SocketOptions

`app`

type Frontend

sort_by_numeric
#

<T extends Cell<any>>(key: string, label: string, field: keyof T, direction?: "asc" | "desc"): Sorter<T>

Creates a numeric sorter with optional direction.
Falls back to cell's cid for equal values.

`key`

type string

`label`

type string

`field`

type keyof T

`direction`

type "asc" | "desc"

default 'asc'

returns

Sorter<T>

sort_by_text
#

<T extends Cell<any>>(key: string, label: string, field: keyof T, direction?: "asc" | "desc"): Sorter<T>

Creates a text sorter with optional direction.
Falls back to cell's cid for equal values.

`key`

type string

`label`

type string

`field`

type keyof T

`direction`

type "asc" | "desc"

default 'asc'

returns

Sorter<T>

Sortable
#

SortableList.svelte view source

Manages the sortable state for a collection of items with reactive data sources.

generics

`T`

`items`

type Array<T>

readonly

`sorters`

type Array<Sorter<T>>

readonly

`default_key`

type string | undefined

readonly

`active_key`

Current active sort key.

type string

`active_sorter`

The currently active sorter.

type Sorter<T> | undefined

readonly

`active_sort_fn`

The sort function from the active sorter.

type ((a: T, b: T) => number) | undefined

readonly

`sorted_items`

Sorted items based on the current active sorter.

type Array<T>

readonly

`constructor`

Creates a new Sortable instance with reactive sources.

type new <T>(items_getter: Thunk<T[]>, sorters_getter: Thunk<Sorter<T>[]>, key_getter_default?: Thunk<string | undefined> | undefined): Sortable<T>

`items_getter`

function that returns the current items array

type Thunk<T[]>

`sorters_getter`

function that returns the current sorters

type Thunk<Sorter<T>[]>

`key_getter_default?`

optional function that returns the current default sort key

type Thunk<string | undefined> | undefined

optional

`update_active_key`

Updates the active key based on sorters and default key.
Called automatically on initialization and when sorters change.

type (): void

returns void

SortableList
#

Sorter
#

Sorter<T>

generics

`T`

`key`

type string

`label`

type string

`fn`

type (a: T, b: T) => number

Space
#

inheritance

extends:

Cell<typeof SpaceJson>

`name`

type string

`directory_paths`

type Array<DiskfileDirectoryPath>

`directory_count`

type number

readonly

`active_directory_paths`

Directory paths filtered to only include those backed by an open workspace.
Stale entries (from closed workspaces) are excluded.

type Array<DiskfileDirectoryPath>

readonly

`constructor`

type new (options: SpaceOptions): Space

`options`

type SpaceOptions

`add_directory`

type (path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">): void

`path`

type string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">

returns void

`remove_directory`

type (path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">): void

`path`

type string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">

returns void

SpaceJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; name: ZodDefault<...>; directory_paths: ZodDefault<...>; }, $strict>

SpaceJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; directory_paths?: string[] | undefined; }

SpaceOptions
#

SpaceOptions

inheritance

extends:

CellOptions<typeof SpaceJson>

Spaces
#

inheritance

extends:

Cell<typeof SpacesJson>

`items`

type IndexedCollection<Space>

readonly

`active_id`

type Uuid | null

`active`

type Space | undefined

readonly

`scratchpad`

type Space | undefined

readonly

`constructor`

type new (options: SpacesOptions): Spaces

`options`

type SpacesOptions

`ensure_scratchpad`

type (): Space

returns Space

`add`

type (json?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; directory_paths?: string[] | undefined; } | undefined): Space

`json?`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; directory_paths?: string[] | undefined; } | undefined

optional

returns Space

`generate_unique_name`

type (base_name?: string): string

`base_name`

type string

default 'new space'

returns string

`remove`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`activate`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

SpacesJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; active_id: ZodDefault<...>; }, $strict>

SpacesJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; directory_paths?: string[] | undefined; }[] | undefined; active_id?: string | ... 1 more ... | undefined; }

SpacesOptions
#

server/server.ts view source

SpacesOptions

inheritance

extends:

CellOptions<typeof SpacesJson>

start_server
#

(): Promise<void>

Start the zzz server using Deno runtime.
Creates the full backend with auth, database, providers, WebSocket, and HTTP RPC
endpoints via create_zzz_app, then serves with Deno.serve.

returns

Promise<void>

status
#

zzz/commands/status.ts view source

(runtime: RuntimeDeps, args: { _: string[]; json: boolean; }, _flags: { help: boolean; version: boolean; }): Promise<void>

Show current system state.

`runtime`

type RuntimeDeps

`args`

type { _: string[]; json: boolean; }

`_flags`

type { help: boolean; version: boolean; }

returns

Promise<void>

StatusArgs
#

ZodObject<{ _: ZodDefault<ZodArray<ZodString>>; json: ZodDefault<ZodBoolean>; }, $strict>

Status command arguments.

STOP_SEQUENCES_DEFAULT
#

string[] | undefined

SubcommandRoute
#

SubcommandRoute<TContext>

Route definition for subcommand routing.

generics

`TContext`

`schema`

type z.ZodType<any>

`handler`

type (ctx: TContext, args: any, flags: ZzzGlobalArgs) => Promise<void>

SUPPORTED_CODE_FILETYPE_MATCHER
#

RegExp

SvelteMapSchema
#

ZodCustom<SvelteMap<unknown, unknown>, SvelteMap<unknown, unknown>>

SymlinkNotAllowedError
#

Error thrown when a path is a symlink

inheritance

extends:

Error

`name`

`constructor`

type new (path: string, options?: ErrorOptions | undefined): SymlinkNotAllowedError

`path`

type string

`options?`

type ErrorOptions | undefined

optional

SYSTEM_MESSAGE_DEFAULT
#

"You are a helpful assistant that responds succinctly unless asked for more."

TEMPERATURE_DEFAULT
#

number | undefined

Terminal
#

inheritance

extends:

Cell<typeof TerminalJson>

`name`

type string

`command`

type string

`args`

type Array<string>

`cwd`

type string | undefined

`status`

type TerminalStatus

`exit_code`

type number | null

`preset_id`

type Uuid | null

`constructor`

type new (options: TerminalOptions): Terminal

`options`

type TerminalOptions

terminal_close_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; signal: ZodOptional<...>; }, $strict>; output: ZodObject<...>; async: true; description: string; }

terminal_create_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ command: ZodString; args: ZodDefault<ZodArray<ZodString>>; cwd: ZodOptional<...>; preset_id: ZodOptional<...>; }, $strict>; output: ZodObject<...>; async: true; des...

terminal_data_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; data: ZodString; }, $strict>; output: ZodVoid; async: true; description: string; }

terminal_data_send_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; data: ZodString; }, $strict>; output: ZodNull; async: true; description: string; }

terminal_exited_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; exit_code: ZodNullable<...>; }, $strict>; output: ZodVoid; async: true; description: string; }

terminal_resize_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; cols: ZodNumber; rows: ZodNumber; }, $strict>; output: ZodNull; async: true; description: string; }

TerminalCloseInput
#

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; signal: ZodOptional<ZodDefault<ZodString>>; }, $strict>

Input for terminal_close.

TerminalCloseOutput
#

TerminalCommandInput.svelte view source

ZodObject<{ exit_code: ZodNullable<ZodNumber>; }, $strict>

Output for terminal_close.

TerminalCommandInput
#

`onsend`

type (command_text: string) => void

TerminalContextmenu
#

TerminalContextmenu.svelte view source

`get_terminal_text`

type Thunk<string> | null

`display_command`

type string

`children`

type Snippet

TerminalCreateInput
#

ZodObject<{ command: ZodString; args: ZodDefault<ZodArray<ZodString>>; cwd: ZodOptional<ZodString>; preset_id: ZodOptional<$ZodBranded<...>>; }, $strict>

Input for terminal_create.

TerminalCreateOutput
#

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; }, $strict>

Output for terminal_create.

TerminalDataInput
#

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; data: ZodString; }, $strict>

Input for terminal_data (backend → frontend stdout/stderr stream).

TerminalDataSendInput
#

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; data: ZodString; }, $strict>

Input for terminal_data_send.

TerminalExitedInput
#

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; exit_code: ZodNullable<ZodNumber>; }, $strict>

Input for terminal_exited.

TerminalJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 7 more ...; preset_id: ZodDefault<...>; }, $strict>

TerminalJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; command?: string | undefined; args?: string[] | undefined; cwd?: string | undefined; status?: "running" | ... 2 more ... | undefined; exit_code?: number | ... 1 more ... | undefined; preset_id?: string |...

TerminalOptions
#

TerminalOptions

inheritance

extends:

CellOptions<typeof TerminalJson>

TerminalPreset
#

TerminalPresetBar.svelte view source

inheritance

extends:

Cell<typeof TerminalPresetJson>

`name`

type string

`command`

type string

`args`

type Array<string>

`cwd`

type string | undefined

`constructor`

type new (options: TerminalPresetOptions): TerminalPreset

`options`

type TerminalPresetOptions

TerminalPresetBar
#

`presets`

type Array<TerminalPreset>

`onrun`

type (preset: TerminalPreset) => void

`oncreate?`

type (name: string, command: string, args: Array<string>) => void

optional

`ondelete?`

type (preset: TerminalPreset) => void

optional

TerminalPresetJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 4 more ...; cwd: ZodOptional<...>; }, $strict>

TerminalPresetJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; command?: string | undefined; args?: string[] | undefined; cwd?: string | undefined; }

TerminalPresetOptions
#

TerminalPresetOptions

inheritance

extends:

CellOptions<typeof TerminalPresetJson>

TerminalResizeInput
#

TerminalRunItem.svelte view source

ZodObject<{ terminal_id: $ZodBranded<ZodUUID, "Uuid", "out">; cols: ZodNumber; rows: ZodNumber; }, $strict>

Input for terminal_resize.

TerminalRunItem
#

`terminal_id`

type Uuid

`command`

type string

`args`

type Array<string>

`onclose`

type (exit_code: number | null) => void

`onrestart?`

type () => void

optional

TerminalRunner
#

TerminalRunner.svelte view source

TerminalStatus
#

TerminalView.svelte view source

ZodEnum<{ running: "running"; stopped: "stopped"; exited: "exited"; }>

TerminalView
#

`terminal_id`

type Uuid

`onclose?`

type (exit_code: number | null) => void

optional

`get_text?`

type (fn: () => string) => void

optional

test_action_specs
#

({ method: string; initiator: "both" | "frontend" | "backend"; side_effects: boolean; input: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; output: ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>; ... 6 more ...; rate_limit?: "both" | ... 2 more ... | undefined; } | { ...; } | { ...; ...

Both test specs as a single array — splice into all_action_specs when test mode is on.

TestEmitNotificationsInput
#

ZodObject<{ count: ZodNumber; }, $strict>

Input for _test_emit_notifications.

TestEmitNotificationsOutput
#

ZodObject<{ count: ZodNumber; }, $strict>

Output for _test_emit_notifications.

TestNotificationInput
#

ZodObject<{ index: ZodNumber; }, $strict>

Input for _test_notification.

TextPart
#

Text part - stores content directly.

inheritance

extends:

Part<typeof TextPartJson>

`type`

readonly

`content`

type string

`constructor`

type new (options: TextPartOptions): TextPart

`options`

type TextPartOptions

TextPartJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 11 more ...; content: ZodDefault<...>; }, $strict>

Text part schema - direct content storage.

TextPartJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; start?: number | null | undefined; end?: number | null | undefined; has_xml_tag?: boolean | undefined; ... 6 more ...; content?: string | undefined; }

TextPartOptions
#

TextPartOptions

TextPartSchema
#

thread.svelte.ts view source

ZodCustom<TextPart, TextPart>

Thread
#

A thread is a linear sequence of turns that maintains a chronological
record of interactions between the user and the AI.

inheritance

extends:

Cell<typeof ThreadJson>

`model_name`

type string

`model`

type Model

readonly

`turns`

type IndexedCollection<Turn>

readonly

`enabled`

type boolean

`content`

type string

readonly

`length`

type number

readonly

`token_count`

type number

readonly

`content_preview`

type string

readonly

`pending`

Reactive flag: true while send_message has an in-flight completion_create.
Owned by the thread so multiple views of the same thread stay in sync.
Callers that bypass send_message and call app.api.completion_create
directly will not update this flag.

type boolean

`constructor`

type new (options: ThreadOptions): Thread

`options`

type ThreadOptions

`add_turn`

Add a turn to this thread.

type (turn: Turn): void

`turn`

type Turn

returns void

`add_user_turn`

Create and add a user turn with the given content.

type (content: string, request?: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; prompt: string; completion_messages?: { ...; }[] | undefined; } | undefined): Turn

`content`

type string

`request?`

type

{ created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; prompt: string; completion_messages?: { [x: string]: unknown; role: string; content: string; }[] | undefined; } | undefined

optional

returns Turn

`add_assistant_turn`

Create and add an assistant turn with the given content.

type (content: string, json?: Partial<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<...>)[]; ... 4 more ...; error_message?: string | undefined; }> | undefined): Turn

`content`

type string

`json?`

type

Partial<{ id: string & $brand<"Uuid">; created: string & $brand<"Datetime">; updated: string & $brand<"Datetime">; part_ids: (string & $brand<"Uuid">)[]; ... 4 more ...; error_message?: string | undefined; }> | undefined

optional

returns Turn

`add_system_turn`

Create and add a system turn with the given content.

type (content: string): Turn

`content`

type string

returns Turn

`add_turn_from_part`

Create and add a turn from a part.

type (part: PartUnion, role: string): Turn

`part`

type PartUnion

`role`

type string

returns Turn

`remove_all_turns`

Remove all turns from this thread.

type (): void

returns void

`send_message`

Send a message to the AI and create corresponding turns.
Returns null if provider is unavailable (defensive check - UI should prevent this).

type (content: string): Promise<Turn | null>

`content`

type string

returns Promise<Turn | null>

`cancel_pending`

Abort the in-flight completion_create call (if any). Safe to call when
nothing is pending — no-op. The frontend WS client rejects the pending
promise with request_cancelled and fires a cancel notification so the
server can stop its provider stream.

type (): void

returns void

`switch_model`

type (model_id: string & $brand<"Uuid">): void

`model_id`

type string & $brand<"Uuid">

returns void

ThreadContextmenu
#

ThreadContextmenu.svelte view source

`thread`

type Thread

`children`

type Snippet

ThreadJson
#

thread_types.ts view source

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; model_name: ZodDefault<...>; turns: ZodDefault<...>; enabled: ZodDefault<...>; }, $strict>

ThreadJsonInput
#

thread_types.ts view source

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { role: string; id?: string | undefined; created?: string | undefined; ... 5 more ...; error_message?: string | undefined; }[] | undefined; enabled?: boolean | undefined; }

ThreadList
#

ThreadList.svelte view source

`chat?`

type Chat | undefined

optional

ThreadListitem
#

ThreadListitem.svelte view source

`thread`

type Thread

`chat`

type Chat

ThreadOptions
#

thread.svelte.ts view source

ThreadOptions

inheritance

extends:

CellOptions<typeof ThreadJson>

Threads
#

inheritance

extends:

Cell<typeof ThreadsJson>

`items`

type IndexedCollection<Thread>

readonly

`selected_id`

type Uuid | null

`selected`

type Thread | undefined

readonly

`selected_id_error`

type boolean

readonly

`ordered_items`

Ordered array of threads derived from the manual_order index.

type Array<Thread>

readonly

`constructor`

type new (options: ThreadsOptions): Threads

`options`

type ThreadsOptions

`add`

type (json?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { role: string; id?: string | undefined; created?: string | undefined; ... 5 more ...; error_message?: string | undefined; }[] | undefined; enabled?: boolean | undefined; } | undefined, select?: boolean | undefined): Thread

`json?`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { role: string; id?: string | undefined; created?: string | undefined; ... 5 more ...; error_message?: string | undefined; }[] | undefined; enabled?: boolean | undefined; } | undefined

optional

`select?`

type boolean | undefined

optional

returns Thread

`add_thread`

type (thread: Thread, select?: boolean | undefined): Thread

`thread`

type Thread

`select?`

type boolean | undefined

optional

returns Thread

`add_many`

type (threads_json: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { role: string; id?: string | undefined; created?: string | undefined; ... 5 more ...; error_message?: string | undefined; }[] | undefined; enabled?: boolean | undefined; }[], select?: number | ... 1 more ... | undefined): Thread[]

`threads_json`

type

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { role: string; id?: string | undefined; created?: string | undefined; ... 5 more ...; error_message?: string | undefined; }[] | undefined; enabled?: boolean | undefined; }[]

`select?`

type number | boolean | undefined

optional

returns Thread[]

`remove`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`remove_many`

type (ids: (string & $brand<"Uuid">)[]): number

`ids`

type (string & $brand<"Uuid">)[]

returns number

`select`

type (thread_id: (string & $brand<"Uuid">) | null): void

`thread_id`

type (string & $brand<"Uuid">) | null

returns void

`select_next`

type (): void

returns void

`reorder_threads`

type (from_index: number, to_index: number): void

`from_index`

type number

`to_index`

type number

returns void

ThreadsJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; selected_id: ZodDefault<...>; }, $strict>

ThreadsJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { id?: string | undefined; created?: string | undefined; updated?: string | undefined; model_name?: string | undefined; turns?: { ...; }[] | undefined; enabled?: boolean | undefined; }[] | undefined; selected_id?: string |...

ThreadsOptions
#

ThreadToggleButton.svelte view source

ThreadsOptions

inheritance

extends:

CellOptions<typeof ThreadsJson>

ThreadToggleButton
#

`thread`

type Thread

`attrs?`

type SvelteHTMLElements['input'] | undefined

optional

Time
#

Reactive time management class that provides time-related utilities.
Has a configurable update interval that defaults to
a full minute to minimize wasteful reactivity,
so it's suitable for any cases that need at best 1-minute precision, unless reconfigured.

inheritance

extends:

Cell<typeof TimeJson>

`DEFAULT_INTERVAL`

Default update interval in milliseconds (1 minute).
The idea is to minimize reactivity and CPU usage for a common use case.

static

`now`

Current time that updates on the configured interval.
This is reactive and can be used in derived computations.

type SvelteDate

readonly

`now_ms`

type number

readonly

`now_timestamp`

readonly

`now_formatted_short_date`

type string

readonly

`now_formatted_datetime`

type string

readonly

`now_formatted_time`

type string

readonly

`interval`

The interval in milliseconds between time updates.

type number

`running`

Whether the interval timer is currently running.

type boolean

`constructor`

type new (options: TimeOptions): Time

`options`

type TimeOptions

`start`

Starts the interval timer if it's not already running.

type (): boolean

returns boolean

`stop`

Stops the interval timer if it's running.

type (): boolean

returns boolean

`restart`

Restarts the interval timer with a new interval.

type (interval?: number | undefined): void

`interval?`

type number | undefined

optional

returns void

`update_now`

Updates the now to the current time immediately.

type (value?: number): void

`value`

type number

default Date.now()

returns void

`destroy`

Override Cell's destroy method to ensure timer cleanup.

type (): void

returns void

TimeJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; }, $strict>

TimeJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; }

TimeOptions
#

TimeOptions

Options for configuring a Time instance.

inheritance

extends:

CellOptions<typeof TimeJson>

`interval`

Interval in milliseconds for updating now.

type number

`autostart`

Whether to automatically start the timer on initialization.

type boolean

TimeValue
#

TimeWidget.svelte view source

TimeValue

TimeWidget
#

`value`

type Date

to_chats_url
#

nav_helpers.ts view source

(chat_id: (string & $brand<"Uuid">) | null): string

`chat_id`

type (string & $brand<"Uuid">) | null

returns

string

to_completion_response_text
#

response_helpers.ts view source

(completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { type: "claude"; value: any; } | { ...; } | { ...; }; } | null | undefined): string | null

Extracts the text content from a completion response.

`completion_response`

type

{ created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { type: "claude"; value: any; } | { ...; } | { ...; }; } | null | undefined

returns

string | null

to_completion_result
#

response_helpers.ts view source

(provider_name: "ollama" | "claude" | "chatgpt" | "gemini", model: string, api_response: unknown, progress_token?: (string & $brand<"Uuid">) | undefined): { completion_response: { ...; }; _meta?: { ...; } | undefined; }

Creates a standardized CompletionResponse message from provider-specific responses.

`provider_name`

type "ollama" | "claude" | "chatgpt" | "gemini"

`model`

type string

`api_response`

type unknown

`progress_token?`

type (string & $brand<"Uuid">) | undefined

optional

returns

{ completion_response: { created: string & $brand<"Datetime">; provider_name: "ollama" | "claude" | "chatgpt" | "gemini"; model: string; data: { type: "ollama"; value: any; } | { ...; } | { ...; } | { ...; }; }; _meta?: { ...; } | undefined; }

to_nav_link_href
#

(app: Frontend, label: string, href: string): string

`app`

type Frontend

`label`

type string

`href`

type string

returns

string

to_preview
#

nav_helpers.ts view source

(content: string | null | undefined, max_length?: number): string

`content`

type string | null | undefined

`max_length`

type number

default CONTENT_PREVIEW_LENGTH

returns

string

to_prompts_url
#

(chat_id: (string & $brand<"Uuid">) | null): string

`chat_id`

type (string & $brand<"Uuid">) | null

returns

string

to_relative_path
#

list_helpers.ts view source

(path: string, parent: string): string

`path`

type string

`parent`

type string

returns

string

to_reordered_list
#

<T>(items: T[], from_index: number, to_index: number): T[]

Creates a new reordered array without modifying the original.

`items`

type T[]

`from_index`

type number

`to_index`

type number

returns

T[]

to_serializable_disknode
#

(disknode: Disknode, dir: string): { id: string & $brand<"DiskfilePath">; source_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; ... 4 more ...; dependencies: [...][]; }

`disknode`

type Disknode

`dir`

type string

returns

{ id: string & $brand<"DiskfilePath">; source_dir: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">; contents: string | null; ctime: number | null; mtime: number | null; dependents: [...][]; dependencies: [...][]; }

toggle_main_menu_action_spec
#

ToggleButton.svelte view source

{ method: string; kind: "local_call"; initiator: "frontend"; auth: null; side_effects: true; input: ZodOptional<ZodObject<{ show: ZodOptional<ZodBoolean>; }, $strict>>; output: ZodObject<...>; async: false; description: string; }

ToggleButton
#

`active`

Current state of the toggle

type boolean

bindable

`active_content`

Content to display when toggle is active

type Snippet | string

`inactive_content`

Content to display when toggle is inactive

type Snippet | string

ToggleMainMenuInput
#

ZodOptional<ZodObject<{ show: ZodOptional<ZodBoolean>; }, $strict>>

Input for toggle_main_menu. Optional — omit to toggle, pass {show} to set explicitly.

ToggleMainMenuOutput
#

ZodObject<{ show: ZodBoolean; }, $strict>

Output for toggle_main_menu.

TOP_K_DEFAULT
#

number | undefined

TOP_P_DEFAULT
#

number | undefined

Turn
#

TurnContextmenu.svelte view source

Turn represents a conversation turn (like A2A Message).
Contextualizes parts within a conversation, providing role, metadata, and ordering.

inheritance

extends:

Cell<typeof TurnJson>

`part_ids`

type Array<Uuid>

`thread_id`

type Uuid | null | undefined

`role`

type CompletionRole

`request`

type CompletionRequest | undefined

`response`

type CompletionResponse | undefined

`error_message`

type string | undefined

`parts`

type Array<PartUnion>

readonly

`length`

type number

readonly

`token_count`

type number

readonly

`raw_content`

type string | null | undefined

readonly

`is_content_loaded`

type boolean

readonly

`is_content_empty`

type boolean

readonly

`pending`

type boolean

readonly

`constructor`

type new (options: TurnOptions): Turn

`options`

type TurnOptions

`set_part`

type (part: PartUnion): void

`part`

type PartUnion

returns void

`add_part`

type (part: PartUnion): void

`part`

type PartUnion

returns void

`remove_part`

type (part_id: string & $brand<"Uuid">): boolean

`part_id`

type string & $brand<"Uuid">

returns boolean

TurnContextmenu
#

`turn`

type Turn

`children`

type Snippet

TurnJson
#

turn_types.ts view source

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 6 more ...; error_message: ZodOptional<...>; }, $strict>

Turn is a conversation turn (like A2A Message) that references one or more parts (content entities).
Turns contextualize reusable content within conversations, providing role, metadata, and ordering.

TurnJsonInput
#

turn_types.ts view source

{ role: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; part_ids?: string[] | undefined; thread_id?: string | null | undefined; request?: { provider_name: "ollama" | ... 2 more ... | "gemini"; model: string; prompt: string; created?: string | undefined; completion_message...

TurnList
#

TurnList.svelte view source

`thread`

type Thread

`attrs?`

type SvelteHTMLElements['div'] | undefined

optional

TurnListitem
#

TurnListitem.svelte view source

`turn`

type Turn

TurnOptions
#

turn_types.ts view source

TurnOptions

inheritance

extends:

CellOptions<typeof TurnJson>

TurnSchema
#

ZodCustom<Cell<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>, Cell<ZodType<unknown, unknown, $ZodTypeInternals<unknown, unknown>>>>

TurnView
#

TurnView.svelte view source

`turn`

type Turn

`show_actions?`

type boolean | undefined

optional

TutorialForChats
#

TutorialForChats.svelte view source

TutorialForDatabase
#

TutorialForDatabase.svelte view source

TutorialForDiskfiles
#

TutorialForDiskfiles.svelte view source

TutorialForPrompts
#

TutorialForPrompts.svelte view source

TypeLiteral
#

$ZodBranded<ZodString, "TypeLiteral", "out">

Ui
#

inheritance

extends:

Cell<typeof UiJson>

`show_main_dialog`

type boolean

`show_sidebar`

type boolean

`tutorial_for_database`

type boolean

`tutorial_for_chats`

type boolean

`tutorial_for_prompts`

type boolean

`tutorial_for_diskfiles`

type boolean

`show_desk_menu`

type boolean

`desk_pinned`

type boolean

`pending_element_to_focus_key`

Consumed by components like ContentEditor for focusing elements.

type string | number | null

`constructor`

type new (options: UiOptions): Ui

`options`

type UiOptions

`toggle_main_menu`

Toggle the main menu visibility.

type (value?: boolean): boolean

`value`

type boolean

default !this.show_main_dialog

returns boolean

`toggle_sidebar`

Toggle the sidebar visibility.

type (value?: boolean): boolean

`value`

type boolean

default !this.show_sidebar

returns boolean

`toggle_desk_menu`

Toggle the desk menu visibility.

type (value?: boolean): boolean

`value`

type boolean

default !this.show_desk_menu

returns boolean

`toggle_desk_pinned`

Toggle the desk menu pinned state.

type (value?: boolean): boolean

`value`

type boolean

default !this.desk_pinned

returns boolean

UiJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; ... 8 more ...; desk_pinned: ZodDefault<...>; }, $strict>

UiJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; show_main_dialog?: boolean | undefined; show_sidebar?: boolean | undefined; tutorial_for_database?: boolean | undefined; ... 4 more ...; desk_pinned?: boolean | undefined; }

UiOptions
#

UiOptions

inheritance

extends:

CellOptions<typeof UiJson>

validate_reorderable_target_index
#

(target_index: number, max_index: number): number

Validate and adjust a target index to ensure it's within bounds

`target_index`

type number

`max_index`

type number

returns

number

ValueParser
#

zzz/build_info.ts view source

ValueParser<TSchema, TKey>

generics

`TSchema`

constraint z.ZodType

`TKey`

constraint keyof z.infer<TSchema>

default keyof z.infer<TSchema>

VERSION
#

"0.0.1"

VocabName
#

schema_registry.ts view source

VocabName

WEBSOCKET_PATH
#

string | undefined

WEBSOCKET_URL
#

string

WEBSOCKET_URL_OBJECT
#

URL | null

WebsocketCapabilityData
#

WebsocketCapabilityData

`url`

type string | null

`connected`

type boolean

`reconnect_count`

type number

`last_connect_time`

type number | null

`last_send_time`

type number | null

`last_receive_time`

type number | null

`connection_duration`

type number | null

`pending_pings`

type number

Workspace
#

A workspace represents an open directory that zzz is watching and serving.
Workspaces are the primary unit of file access — each workspace registers
its directory with ScopedFs and starts a Filer for file watching.

inheritance

extends:

Cell<typeof WorkspaceJson>

`path`

type DiskfileDirectoryPath

`name`

type string

`opened_at`

type Datetime

`constructor`

type new (options: WorkspaceOptions): Workspace

`options`

type WorkspaceOptions

workspace_changed_action_spec
#

{ method: string; kind: "remote_notification"; initiator: "backend"; auth: null; side_effects: true; input: ZodObject<{ type: ZodEnum<{ open: "open"; close: "close"; }>; workspace: ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<...>, $ZodBranded<...>>, "DiskfileDirectoryPath", "out">; name: ZodString; opened_at: ZodS...

workspace_close_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<...>>, "DiskfileDirectoryPath", "out">; }, $strict>; output: ZodNull; async:...

workspace_list_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: false; input: ZodVoid; output: ZodObject<{ workspaces: ZodArray<ZodObject<{ path: $ZodBranded<...>; name: ZodString; opened_at: ZodString; }, $strict>>; }, $strict>; async: true; descriptio...

workspace_open_action_spec
#

{ method: string; kind: "request_response"; initiator: "frontend"; auth: { account: "required"; actor: "none"; }; side_effects: true; input: ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<...>>, "DiskfileDirectoryPath", "out">; }, $strict>; output: ZodObject<...>;...

WorkspaceChangedInput
#

ZodObject<{ type: ZodEnum<{ open: "open"; close: "close"; }>; workspace: ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; name: ZodString; opened_at: ZodString; }, $strict>; }, $strict>

Input for workspace_changed.

WorkspaceCloseInput
#

ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; }, $strict>

Input for workspace_close.

WorkspaceInfoJson
#

ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; name: ZodString; opened_at: ZodString; }, $strict>

The wire format for workspace info shared between frontend and backend.
Used in action spec inputs/outputs and for JSON persistence.

WorkspaceJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; path: $ZodBranded<...>; name: ZodDefault<...>; opened_at: ZodDefault<...>; }, $strict>

WorkspaceJsonInput
#

{ path: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; opened_at?: string | undefined; }

WorkspaceListOutput
#

ZodObject<{ workspaces: ZodArray<ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; name: ZodString; opened_at: ZodString; }, $strict>>; }, $strict>

Output for workspace_list.

WorkspaceOpenInput
#

ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; }, $strict>

Input for workspace_open.

WorkspaceOpenOutput
#

ZodObject<{ workspace: ZodObject<{ path: $ZodBranded<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, $ZodBranded<ZodString, "DiskfilePath", "out">>, "DiskfileDirectoryPath", "out">; name: ZodString; opened_at: ZodString; }, $strict>; files: ZodArray<...>; }, $strict>

Output for workspace_open.

WorkspaceOptions
#

WorkspaceOptions

inheritance

extends:

CellOptions<typeof WorkspaceJson>

Workspaces
#

Collection of open workspaces.
Manages the set of directories the daemon is watching and serving.
Each workspace has a unique path used as the index key.

inheritance

extends:

Cell<typeof WorkspacesJson>

`items`

type IndexedCollection<Workspace>

readonly

`active_id`

type Uuid | null

`active`

type Workspace | undefined

readonly

`constructor`

type new (options: WorkspacesOptions): Workspaces

`options`

type WorkspacesOptions

`add`

Add a workspace. If a workspace with the same path already exists, returns it.

type (json: { path: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; opened_at?: string | undefined; }): Workspace

`json`

type

{ path: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; opened_at?: string | undefined; }

returns Workspace

`remove`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

`get_by_path`

type (path: string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">): Workspace | undefined

`path`

type string & $brand<"DiskfilePath"> & $brand<"DiskfileDirectoryPath">

returns Workspace | undefined

`activate`

type (id: string & $brand<"Uuid">): void

`id`

type string & $brand<"Uuid">

returns void

WorkspacesJson
#

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; created: ZodDefault<$ZodBranded<ZodISODateTime, "Datetime", "out">>; updated: ZodDefault<...>; items: ZodDefault<...>; active_id: ZodDefault<...>; }, $strict>

WorkspacesJsonInput
#

{ id?: string | undefined; created?: string | undefined; updated?: string | undefined; items?: { path: string; id?: string | undefined; created?: string | undefined; updated?: string | undefined; name?: string | undefined; opened_at?: string | undefined; }[] | undefined; active_id?: string | ... 1 more ... | undefin...

WorkspacesOptions
#

WorkspacesOptions

inheritance

extends:

CellOptions<typeof WorkspacesJson>

XmlAttribute
#

XmlAttributeEditor.svelte view source

ZodObject<{ id: $ZodBranded<ZodUUID, "Uuid", "out">; key: ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, ZodString>; value: ZodString; }, $strict>

XmlAttributeEditor
#

`attribute`

type XmlAttributeWithDefaults

`dormant?`

type boolean | undefined

optional

`onupdate`

type (updates: Partial<OmitStrict<XmlAttributeWithDefaults, 'id'>>) => void

`onremove`

type () => void

XmlAttributeKey
#

ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, ZodString>

XmlAttributeKeyWithDefault
#

ZodDefault<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, ZodString>>

XmlAttributeValue
#

ZodString

XmlAttributeValueWithDefault
#

ZodDefault<ZodString>

XmlAttributeWithDefaults
#

XmlTagControls.svelte view source

ZodObject<{ id: ZodDefault<$ZodBranded<ZodUUID, "Uuid", "out">>; key: ZodDefault<ZodPipe<ZodPipe<ZodString, ZodTransform<string, string>>, ZodString>>; value: ZodDefault<...>; }, $strict>

XmlTagControls
#

`part`

type PartUnion

ZZZ_COMMANDS
#

Record<string, CommandMeta<ZzzCommandCategory>>

Command registry for help generation.

ZZZ_DEFAULT_PORT
#

4460

Default port for the zzz daemon.

ZZZ_DIR
#

string

ZZZ_DIR_CACHE
#

"cache"

ZZZ_DIR_RUN
#

"run"

ZZZ_DIR_STATE
#

"state"

ZZZ_DIR_STATE_COMPLETIONS
#

"completions"

ZZZ_HELP_CATEGORIES
#

HelpCategory<ZzzCommandCategory>[]

Category display order for main help.

ZZZ_HELP_EXAMPLES
#

string[]

Example commands for main help.

ZZZ_SCOPED_DIRS
#

server/routes/account.ts view source

string[]

Comma-separated list of filesystem paths that Zzz can access.
Empty array means no scoped filesystem access.

zzz_session_config
#

SessionOptions<string>

ZzzApp
#

server/create_zzz_app.ts view source

ZzzApp

The created zzz app and related instances.

`app`

Configured Hono app with all middleware and routes.

type Hono

`backend`

zzz domain Backend instance for lifecycle management.

type Backend

`app_backend`

fuz_app backend for database and auth.

type AppBackend

`surface`

Generated attack surface.

type AppSurface

`env`

Validated environment.

type ZzzServerEnv

`allowed_origins`

Parsed allowed origin patterns (from validate_server_env).

type Array<RegExp>

`extra_ws_actions`

WebSocket-side test actions to register when ZZZ_ENABLE_TEST_ACTIONS=1.
Empty in production. Callers that mount the WS endpoint pass these
through to register_websocket_actions.

type ReadonlyArray<Action>

`close`

Close database connection.

type () => Promise<void>

ZzzAppRouteDeps
#

server/zzz_route_specs.ts view source

ZzzAppRouteDeps

zzz-specific deps not available in AppServerContext.

`zzz`

type ZzzRpcDeps

`version`

type string

`get_uptime_ms`

type () => number

`audit_sse`

Audit log SSE stream config.

type AuditLogRouteOptions['stream']

ZzzCliOptions
#

ZodObject<{ zzz_config_port: ZodDefault<ZodNumber>; }, $strict>

Schema for ~/.zzz/config.json.
Uses zzz_config_ prefix so field names are self-documenting:
const { zzz_config_port } = load_zzz_cli_config();
// Variable name tells you exactly what this is and where it came from

ZzzCommandCategory
#

ZzzCommandCategory

Command category for help organization.

ZzzGlobalArgs
#

config_helpers.ts view source

ZodObject<{ help: ZodDefault<ZodBoolean>; version: ZodDefault<ZodBoolean>; }, $strict>

Global CLI flags.
Extracted before command-specific parsing.

ZzzOptions
#

ZzzOptions

`providers`

type Array<ProviderJsonInput>

`models`

type Array<ModelJsonInput>

`system_message`

type string

`output_token_max`

type number

`temperature`

type number | undefined

`seed`

type number | undefined

`top_k`

type number | undefined

`top_p`

type number | undefined

`frequency_penalty`

type number | undefined

`presence_penalty`

type number | undefined

`stop_sequences`

type Array<string> | undefined

`bots`

type

{
		/**
		 * Names things.
		 */
		namerbot: ModelName;
	}

ZzzOptionsCreator
#

config_helpers.ts view source

ZzzOptionsCreator

ZzzParsedArgs
#