slexkit 0.2.0

package/dist/types/engine/renderer.d.ts

@@ -0,0 +1,6 @@
+import type { LayoutNode, ForContext, RenderContext, MountOptions, ComponentStateMap, ComponentTypeMap } from "./types";
+type RenderOptions = Required<Pick<MountOptions, "labels">> & {
+    dir: RenderContext["dir"];
+};
+export declare function renderTree(layout: LayoutNode, container: HTMLElement, g: Record<string, unknown>, components: ComponentStateMap, componentTypes: ComponentTypeMap, forCtx?: ForContext, ns?: string, api?: Record<string, unknown>, options?: RenderOptions, prepare?: boolean): void;
+export {};

package/dist/types/engine/sandbox-runner.d.ts

@@ -0,0 +1,2 @@
+export declare function hardenSchedulingGlobals(): void;
+export declare function startSlexKitSandboxRunner(): void;

package/dist/types/engine/secure-runtime.d.ts

@@ -0,0 +1,214 @@
+import type { MountOptions } from "./types";
+export type NetworkMethod = "GET" | "POST";
+export type RuntimeCredentials = "omit" | "same-origin" | "include";
+export type HostRuntimePolicy = {
+    network?: {
+        enabled: boolean;
+        methods: NetworkMethod[];
+        allowOrigins: string[];
+        allowHeaders?: string[];
+        allowContentTypes?: string[];
+        credentials: RuntimeCredentials;
+        timeoutMs: number;
+        maxBodyBytes: number;
+        maxResponseBytes?: number;
+    };
+    timer?: {
+        enabled: boolean;
+        maxTimers: number;
+        minIntervalMs: number;
+    };
+    animation?: {
+        enabled: boolean;
+    };
+    canvas?: {
+        enabled: boolean;
+        maxCanvases?: number;
+        maxPixels?: number;
+        allowedContexts?: RuntimeCanvasContextId[];
+    };
+    execution?: {
+        heartbeatIntervalMs?: number;
+        maxUnresponsiveMs?: number;
+    };
+};
+export type RuntimeCanvasContextId = "2d" | "webgl" | "webgl2" | "bitmaprenderer";
+export type RuntimeCanvasContext = CanvasRenderingContext2D | WebGLRenderingContext | WebGL2RenderingContext | ImageBitmapRenderingContext;
+export type NetworkOptions = {
+    method?: NetworkMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeoutMs?: number;
+    credentials?: RuntimeCredentials;
+};
+export type NetworkResult = {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    url: string;
+    headers: Record<string, string>;
+    text?: string;
+    data?: unknown;
+    elapsedMs: number;
+};
+export type TimerId = number;
+export type RafId = number;
+export type HostFetchRequest = {
+    method: NetworkMethod;
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    credentials: RuntimeCredentials;
+    timeoutMs: number;
+};
+export type RuntimeNetworkLogEvent = {
+    phase: "request" | "response" | "error";
+    request: HostFetchRequest;
+    result?: NetworkResult;
+    error?: SerializedRuntimeError;
+    elapsedMs?: number;
+};
+export type RuntimeErrorEvent = {
+    phase: "timer" | "interval" | "raf" | "dispose";
+    error: SerializedRuntimeError;
+};
+export type HostRuntimeAdapter = {
+    fetch?: (request: HostFetchRequest) => Promise<NetworkResult>;
+    onNetworkLog?: (event: RuntimeNetworkLogEvent) => void;
+    onRuntimeError?: (event: RuntimeErrorEvent) => void;
+    now?: () => number;
+    setTimeout?: (fn: () => void, ms: number) => TimerId;
+    clearTimeout?: (id: TimerId) => void;
+    setInterval?: (fn: () => void, ms: number) => TimerId;
+    clearInterval?: (id: TimerId) => void;
+    requestAnimationFrame?: (fn: (time: number) => void) => RafId;
+    cancelAnimationFrame?: (id: RafId) => void;
+};
+export type SlexKitRuntimeApi = {
+    now: () => number;
+    get: (url: string, options?: Omit<NetworkOptions, "method" | "body">) => Promise<NetworkResult>;
+    post: (url: string, body?: unknown, options?: Omit<NetworkOptions, "method" | "body">) => Promise<NetworkResult>;
+    fetch: (url: string, options?: NetworkOptions) => Promise<NetworkResult>;
+    setTimeout: (fn: () => void, ms: number) => TimerId;
+    clearTimeout: (id: TimerId) => void;
+    setInterval: (fn: () => void, ms: number) => TimerId;
+    clearInterval: (id: TimerId) => void;
+    raf: (fn: (time: number) => void) => RafId;
+    cancelRaf: (id: RafId) => void;
+    createCanvas: (width: number, height: number) => HTMLCanvasElement;
+    getCanvasContext: (canvas: HTMLCanvasElement, contextId?: RuntimeCanvasContextId, options?: CanvasRenderingContext2DSettings | WebGLContextAttributes | ImageBitmapRenderingContextSettings) => RuntimeCanvasContext;
+    onDispose: (fn: () => void) => void;
+    isTimeoutError: (error: unknown) => boolean;
+    isNetworkError: (error: unknown) => boolean;
+    isPolicyError: (error: unknown) => boolean;
+    errorMessage: (error: unknown) => string;
+};
+export type SecureRuntimeHandle = {
+    api: SlexKitRuntimeApi;
+    dispose: () => void;
+};
+export type SecureFrameOptions = {
+    className?: string;
+    title?: string;
+    sandbox?: string;
+    unsafeAllowSameOrigin?: boolean;
+    runtimeUrl?: string;
+    loadTimeoutMs?: number;
+    /**
+     * @deprecated Use runtimeUrl. The runner is now shipped inside the main SlexKit runtime module.
+     */
+    runnerUrl?: string;
+};
+export type SecureMountOptions = Omit<MountOptions, "api"> & {
+    policy: HostRuntimePolicy;
+    hostAdapter?: HostRuntimeAdapter;
+    frame?: boolean | SecureFrameOptions;
+    unsafeInlineExecution?: boolean;
+    artifactSlots?: SecureArtifactSlot[];
+};
+export type SecureArtifactSlot = {
+    id: string;
+    container: HTMLElement;
+};
+export type SandboxMountMessage = {
+    channel: "slexkit-secure";
+    type: "mount";
+    id: string;
+    token: string;
+    input: unknown;
+    policy: HostRuntimePolicy;
+    theme?: MountOptions["theme"];
+    colorMode?: "light" | "dark";
+    dir?: MountOptions["dir"];
+    labels?: MountOptions["labels"];
+};
+export type SandboxDisposeMessage = {
+    channel: "slexkit-secure";
+    type: "dispose";
+    id: string;
+    token: string;
+};
+export type SandboxFetchRequestMessage = {
+    channel: "slexkit-secure";
+    type: "fetch";
+    id: string;
+    token: string;
+    requestId: string;
+    request: HostFetchRequest;
+};
+export type SandboxFetchResponseMessage = {
+    channel: "slexkit-secure";
+    type: "fetch-result";
+    id: string;
+    token: string;
+    requestId: string;
+    result?: NetworkResult;
+    error?: SerializedRuntimeError;
+};
+export type SandboxSlotsMessage = {
+    channel: "slexkit-secure";
+    type: "slots";
+    id: string;
+    token: string;
+    slots: Array<{
+        id: string;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }>;
+};
+export type SandboxSlotSizeMessage = {
+    channel: "slexkit-secure";
+    type: "slot-size";
+    id: string;
+    token: string;
+    slotId: string;
+    height: number;
+};
+export type SandboxStatusMessage = {
+    channel: "slexkit-secure";
+    type: "ready" | "mounted" | "heartbeat" | "disposed" | "error";
+    id?: string;
+    token?: string;
+    error?: SerializedRuntimeError;
+};
+export type SandboxHostMessage = SandboxMountMessage | SandboxDisposeMessage | SandboxFetchResponseMessage | SandboxSlotsMessage;
+export type SandboxRunnerMessage = SandboxFetchRequestMessage | SandboxSlotSizeMessage | SandboxStatusMessage;
+export type SerializedRuntimeError = {
+    name: string;
+    message: string;
+    kind?: RuntimeErrorKind;
+    code?: string;
+    elapsedMs?: number;
+};
+export type RuntimeErrorKind = "policy" | "network" | "timeout";
+export declare class SlexKitRuntimeError extends Error {
+    kind: RuntimeErrorKind;
+    code: string;
+    elapsedMs?: number;
+    constructor(kind: RuntimeErrorKind, code: string, message: string, elapsedMs?: number);
+}
+export declare function serializeRuntimeError(error: unknown): SerializedRuntimeError;
+export declare function deserializeRuntimeError(error: SerializedRuntimeError): Error;
+export declare function createSecureRuntime(policy: HostRuntimePolicy, hostAdapter?: HostRuntimeAdapter): SecureRuntimeHandle;

package/dist/types/engine/store.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentStateMap, ComponentTypeMap, LayoutNode } from "./types";
+export type Store = {
+    g: Record<string, unknown>;
+    components: ComponentStateMap;
+    componentTypes: ComponentTypeMap;
+    layouts: LayoutNode[];
+    roots: Map<HTMLElement, HTMLElement>;
+    cleanups: Map<HTMLElement, () => void>;
+};
+export declare function getStore(ns: string): Store;
+export declare function peekStore(ns: string): Store | undefined;
+export declare function deleteStore(ns: string): boolean;

package/dist/types/engine/types.d.ts

@@ -0,0 +1,58 @@
+export type SlexExpression = {
+    slex?: string;
+    namespace?: string;
+    g?: Record<string, unknown>;
+    layout?: LayoutNode;
+    [key: string]: unknown;
+};
+/** @deprecated Use SlexExpression instead. */
+export type DSL = SlexExpression;
+export type LayoutNode = Record<string, unknown>;
+export type ComponentState = Record<string, unknown>;
+export type ComponentStateMap = Record<string, ComponentState>;
+export type ComponentTypeMap = Record<string, string>;
+export type ComponentStateMode = "value" | "checked" | "enabled" | "readable" | "none";
+export type ComponentRegistrationOptions = {
+    state?: ComponentStateMode;
+};
+export type ForContext = {
+    $item?: unknown;
+    $index?: number | (() => number);
+    $key?: unknown;
+    [identifier: string]: unknown;
+};
+export type ForSlot = {
+    key: unknown;
+    el: HTMLElement;
+    forCtx: ForContext;
+    index: number;
+    item: unknown;
+    props: Record<string, unknown>;
+    children: Record<string, unknown>;
+    indexSignal?: [() => number, (v: number) => void];
+    revision?: number;
+    revisionSignal?: [() => number, (v: number) => void];
+    dispose?: () => void;
+};
+export type ComponentRenderer = (props: Record<string, unknown>, name: string, ctx: RenderContext) => HTMLElement | void;
+export type ThemeMode = "auto" | "host-shadcn" | "uno" | "flowbite";
+export type DirectionMode = "ltr" | "rtl" | "auto";
+export type RuntimeLabels = Partial<Record<string, string>>;
+export type MountOptions = {
+    theme?: ThemeMode;
+    dir?: DirectionMode;
+    labels?: RuntimeLabels;
+    api?: Record<string, unknown>;
+};
+export type RenderContext = {
+    g: Record<string, unknown>;
+    api?: Record<string, unknown>;
+    dir: Exclude<DirectionMode, "auto">;
+    labels: RuntimeLabels;
+    document: Document;
+    forCtx?: ForContext;
+    children: Record<string, unknown>;
+    renderTree: (layout: LayoutNode, container: HTMLElement, forCtx?: ForContext) => void;
+    emit: (eventName: string, data?: unknown) => void;
+    id: string | null;
+};

package/dist/types/icons/manager.d.ts

@@ -0,0 +1,17 @@
+import { iconCacheKey, iconifySvgUrl, resolveIconifyIcon } from "./phosphor";
+import type { PhosphorIconState, PhosphorIconWeight } from "./phosphor";
+export type IconWeight = PhosphorIconWeight;
+export type IconState = PhosphorIconState;
+export interface RegisterIconOptions {
+    aliases?: string[];
+    weight?: IconWeight;
+}
+export declare function normalizeIconName(name: string): string;
+export declare function registerIcon(name: string, svg: string, options?: RegisterIconOptions): void;
+export declare function registerIcons(icons: Record<string, string>, options?: RegisterIconOptions): void;
+export declare function clearRegisteredIcons(): void;
+export declare function getRegisteredIcon(name: string, state?: IconWeight | IconState): string;
+export declare function getIcon(name: string, state?: IconWeight | IconState): string;
+export declare function loadIcon(name: string, state?: IconWeight | IconState): Promise<string>;
+export { iconCacheKey, iconifySvgUrl, resolveIconifyIcon };
+export declare function resolveIconWeight(state?: IconWeight | IconState): IconWeight;

package/dist/types/icons/phosphor.d.ts

@@ -0,0 +1,45 @@
+export declare const phosphorIcons: {
+    readonly "caret-down": string;
+    readonly check: string;
+    readonly "circle-half": string;
+    readonly list: string;
+    readonly moon: string;
+    readonly sun: string;
+    readonly code: string;
+    readonly "book-open-text": string;
+    readonly "cursor-click": string;
+    readonly "gear-six": string;
+    readonly nut: string;
+    readonly screwdriver: string;
+    readonly sparkle: string;
+    readonly "terminal-window": string;
+    readonly wrench: string;
+    readonly copy: string;
+    readonly eye: string;
+    readonly "arrow-square-out": string;
+    readonly "split-horizontal": string;
+    readonly "square-half": string;
+    readonly "square-split-horizontal": string;
+    readonly file: string;
+    readonly "markdown-logo": string;
+    readonly x: string;
+};
+export type PhosphorIconName = keyof typeof phosphorIcons;
+export type PhosphorIconWeight = "regular" | "duotone";
+export interface PhosphorIconState {
+    weight?: PhosphorIconWeight | null;
+    selected?: unknown;
+    active?: unknown;
+    pressed?: unknown;
+    current?: unknown;
+}
+export declare function normalizePhosphorIconName(name: string): string;
+export declare function resolveIconifyIcon(name: string, state?: PhosphorIconWeight | PhosphorIconState): {
+    prefix: string;
+    name: string;
+} | null;
+export declare function resolvePhosphorIconWeight(state?: PhosphorIconWeight | PhosphorIconState): PhosphorIconWeight;
+export declare function getPhosphorIcon(name: string, state?: PhosphorIconWeight | PhosphorIconState): string;
+export declare function iconCacheKey(name: string, state?: PhosphorIconWeight | PhosphorIconState): string;
+export declare function iconifySvgUrl(name: string, state?: PhosphorIconWeight | PhosphorIconState): string;
+export declare function loadPhosphorIcon(name: string, state?: PhosphorIconWeight | PhosphorIconState): Promise<string>;

package/dist/types/index.d.ts

@@ -0,0 +1,61 @@
+import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
+import { registerAll, registerSvelteComponent, registerSubset } from "./components/index";
+import { renderToolCall, registerToolTemplate } from "./toolhost/index";
+import { startSlexKitSandboxRunner } from "./engine/sandbox-runner";
+import { clearRegisteredIcons, getIcon, getRegisteredIcon, iconifySvgUrl, loadIcon, normalizeIconName, registerIcon, registerIcons, resolveIconifyIcon, resolveIconWeight } from "./icons/manager";
+import { attachComponentDisposer, configureComponentScope } from "./engine/component-scope";
+import { getSlexKitInfo, SLEXKIT_COMPONENTS_VERSION, SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION } from "./version";
+declare const mountApi: typeof mount;
+declare const ingestApi: typeof ingest;
+declare const bootApi: typeof boot;
+declare const disposeNamespaceApi: typeof disposeNamespace;
+declare const registerApi: typeof register;
+declare const getRendererApi: typeof getRenderer;
+declare const diagnoseSlexKitSourceApi: typeof diagnoseSlexKitSource;
+declare const SlexKitSyntaxErrorApi: typeof SlexKitSyntaxError;
+declare const formatSlexKitDiagnosticApi: typeof formatSlexKitDiagnostic;
+declare const mountSecureArtifactApi: typeof mountSecureArtifact;
+declare const parseSlexSourceApi: typeof parseSlexSource;
+declare const parseSlexKitDslApi: typeof parseSlexSource;
+declare const createSecureRuntimeApi: typeof createSecureRuntime;
+declare const SlexKitRuntimeErrorApi: typeof SlexKitRuntimeError;
+declare const getSlexKitRuntimeUrlApi: typeof getSlexKitRuntimeUrl;
+declare const setSlexKitRuntimeUrlApi: typeof setSlexKitRuntimeUrl;
+declare const createSlexKitMarkdownRuntimeHostApi: typeof createSlexKitMarkdownRuntimeHost;
+declare const getSlexKitMarkdownRuntimeHostApi: typeof getSlexKitMarkdownRuntimeHost;
+declare const installSlexKitMarkdownRuntimeHostApi: typeof installSlexKitMarkdownRuntimeHost;
+declare const registerAllApi: typeof registerAll;
+declare const registerSvelteComponentApi: typeof registerSvelteComponent;
+declare const registerSubsetApi: typeof registerSubset;
+declare const renderToolCallApi: typeof renderToolCall;
+declare const registerToolTemplateApi: typeof registerToolTemplate;
+declare const startSlexKitSandboxRunnerApi: typeof startSlexKitSandboxRunner;
+declare const clearRegisteredIconsApi: typeof clearRegisteredIcons;
+declare const getIconApi: typeof getIcon;
+declare const getRegisteredIconApi: typeof getRegisteredIcon;
+declare const loadIconApi: typeof loadIcon;
+declare const normalizeIconNameApi: typeof normalizeIconName;
+declare const registerIconApi: typeof registerIcon;
+declare const registerIconsApi: typeof registerIcons;
+declare const resolveIconifyIconApi: typeof resolveIconifyIcon;
+declare const iconifySvgUrlApi: typeof iconifySvgUrl;
+declare const resolveIconWeightApi: typeof resolveIconWeight;
+declare const attachComponentDisposerApi: typeof attachComponentDisposer;
+declare const configureComponentScopeApi: typeof configureComponentScope;
+declare const getSlexKitInfoApi: typeof getSlexKitInfo;
+export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, };
+export type { BootOptions } from "./engine/index";
+export type { SlexKitParseResult, SlexKitSourceDiagnostic } from "./engine/index";
+export type { SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, } from "./engine/index";
+export type { SlexKitMarkdownBlock, SlexKitMarkdownRuntimeHost, SlexKitMarkdownRuntimeMode, SlexKitMarkdownRuntimeOptions, } from "./engine/index";
+export type { ComponentRenderer, RenderContext, SlexExpression, DSL } from "./engine/types";
+export { registerAllApi as registerAll, registerSvelteComponentApi as registerSvelteComponent, registerSubsetApi as registerSubset, };
+export { renderToolCallApi as renderToolCall, registerToolTemplateApi as registerToolTemplate };
+export { startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner };
+export { clearRegisteredIconsApi as clearRegisteredIcons, getIconApi as getIcon, getRegisteredIconApi as getRegisteredIcon, iconifySvgUrlApi as iconifySvgUrl, loadIconApi as loadIcon, normalizeIconNameApi as normalizeIconName, registerIconApi as registerIcon, registerIconsApi as registerIcons, resolveIconifyIconApi as resolveIconifyIcon, resolveIconWeightApi as resolveIconWeight, };
+export { attachComponentDisposerApi as attachComponentDisposer, configureComponentScopeApi as configureComponentScope, };
+export type { IconState, IconWeight, RegisterIconOptions } from "./icons/manager";
+export { componentSpecs, getComponentSpec, getLocalizedComponentSpec, hashSpecText, localizeComponentSpec, localizeComponentSpecs, publicComponentTypes, } from "./components/spec-registry";
+export type { ChildrenSpec, ComponentDocsSpec, ComponentExampleSpec, ComponentSpec, ComponentSpecCategory, ComponentSpecLocaleEntry, ComponentSpecLocaleOverlay, ComponentSpecStatus, LocalizedComponentSpec, LocalizedChildrenSpec, LocalizedPropSpec, LocalizedText, PropSpec, } from "./components/spec-schema";
+export type { ChooseOptionsArguments, ConfirmActionArguments, FillFormArguments, FormField, FormFieldType, ToolCall, ToolRenderHandle, ToolResult, ToolResultStatus, ToolRuntime, ToolTemplateCompiler, OptionListArguments, OptionListItem, } from "./toolhost/index";
+import "./components/index";

package/dist/types/runtime.d.ts

@@ -0,0 +1,32 @@
+import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
+import { attachComponentDisposer, configureComponentScope } from "./engine/component-scope";
+import { startSlexKitSandboxRunner } from "./engine/sandbox-runner";
+import { getSlexKitInfo, SLEXKIT_COMPONENTS_VERSION, SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION } from "./version";
+export type { BootOptions } from "./engine/index";
+export type { SlexKitParseResult, SlexKitSourceDiagnostic } from "./engine/index";
+export type { ComponentRenderer, ComponentRegistrationOptions, ComponentStateMode, RenderContext, SlexExpression, DSL, SlexKitRuntimeApi, HostFetchRequest, HostRuntimeAdapter, HostRuntimePolicy, NetworkOptions, NetworkResult, RafId, RuntimeCanvasContext, RuntimeCanvasContextId, RuntimeErrorEvent, RuntimeErrorKind, RuntimeNetworkLogEvent, SandboxSlotSizeMessage, SandboxSlotsMessage, SandboxFetchRequestMessage, SandboxFetchResponseMessage, SandboxHostMessage, SandboxMountMessage, SandboxRunnerMessage, SandboxStatusMessage, SecureFrameOptions, SecureArtifactSlot, SecureMountOptions, SecureRuntimeHandle, SerializedRuntimeError, TimerId, } from "./engine/index";
+export type { SlexKitMarkdownBlock, SlexKitMarkdownRuntimeHost, SlexKitMarkdownRuntimeMode, SlexKitMarkdownRuntimeOptions, } from "./engine/index";
+declare const mountApi: typeof mount;
+declare const ingestApi: typeof ingest;
+declare const bootApi: typeof boot;
+declare const disposeNamespaceApi: typeof disposeNamespace;
+declare const registerApi: typeof register;
+declare const getRendererApi: typeof getRenderer;
+declare const diagnoseSlexKitSourceApi: typeof diagnoseSlexKitSource;
+declare const SlexKitSyntaxErrorApi: typeof SlexKitSyntaxError;
+declare const formatSlexKitDiagnosticApi: typeof formatSlexKitDiagnostic;
+declare const mountSecureArtifactApi: typeof mountSecureArtifact;
+declare const parseSlexSourceApi: typeof parseSlexSource;
+declare const parseSlexKitDslApi: typeof parseSlexSource;
+declare const createSecureRuntimeApi: typeof createSecureRuntime;
+declare const SlexKitRuntimeErrorApi: typeof SlexKitRuntimeError;
+declare const getSlexKitRuntimeUrlApi: typeof getSlexKitRuntimeUrl;
+declare const setSlexKitRuntimeUrlApi: typeof setSlexKitRuntimeUrl;
+declare const createSlexKitMarkdownRuntimeHostApi: typeof createSlexKitMarkdownRuntimeHost;
+declare const getSlexKitMarkdownRuntimeHostApi: typeof getSlexKitMarkdownRuntimeHost;
+declare const installSlexKitMarkdownRuntimeHostApi: typeof installSlexKitMarkdownRuntimeHost;
+declare const attachComponentDisposerApi: typeof attachComponentDisposer;
+declare const configureComponentScopeApi: typeof configureComponentScope;
+declare const startSlexKitSandboxRunnerApi: typeof startSlexKitSandboxRunner;
+declare const getSlexKitInfoApi: typeof getSlexKitInfo;
+export { SLEXKIT_VERSION, SLEX_PROTOCOL_VERSION, SLEXKIT_COMPONENTS_VERSION, getSlexKitInfoApi as getSlexKitInfo, mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, attachComponentDisposerApi as attachComponentDisposer, configureComponentScopeApi as configureComponentScope, startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner, };

package/dist/types/toolhost/index.d.ts

@@ -0,0 +1,78 @@
+import type { SlexExpression } from "../engine/types";
+export type ToolCall = {
+    id?: string;
+    name: string;
+    arguments?: Record<string, unknown>;
+};
+export type ToolResultStatus = "submitted" | "ignored";
+export type ToolResult = {
+    toolCallId?: string;
+    toolName: string;
+    status: ToolResultStatus;
+    value: Record<string, unknown> | null;
+};
+export type ToolRenderHandle = {
+    promise: Promise<ToolResult>;
+    dispose: () => void;
+};
+export type ToolRuntime = {
+    submit: (value: Record<string, unknown>) => void;
+    ignore: () => void;
+};
+export type ToolTemplateCompiler<TArgs extends Record<string, unknown> = Record<string, unknown>> = (args: TArgs, runtime: ToolRuntime, call: ToolCall) => SlexExpression;
+export type OptionListItem = {
+    id?: string;
+    value?: string;
+    label: string;
+    description?: string;
+    selected?: boolean;
+    disabled?: boolean;
+};
+export type ChooseOptionsArguments = {
+    title?: string;
+    description?: string;
+    options?: OptionListItem[];
+    items?: OptionListItem[];
+    multiple?: boolean;
+    selected?: string[];
+    minSelected?: number;
+    maxSelected?: number;
+    submitLabel?: string;
+    ignoreLabel?: string;
+};
+export type OptionListArguments = ChooseOptionsArguments;
+export type ConfirmActionArguments = {
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    ignoreLabel?: string;
+    requireReason?: boolean;
+    reasonLabel?: string;
+    reasonPlaceholder?: string;
+};
+export type FormFieldType = "text" | "number" | "engineering" | "select" | "checkbox" | "switch";
+export type FormField = {
+    name: string;
+    label?: string;
+    type?: FormFieldType;
+    description?: string;
+    placeholder?: string;
+    required?: boolean;
+    disabled?: boolean;
+    value?: unknown;
+    options?: Array<{
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }>;
+};
+export type FillFormArguments = {
+    title?: string;
+    description?: string;
+    fields?: FormField[];
+    values?: Record<string, unknown>;
+    submitLabel?: string;
+    ignoreLabel?: string;
+};
+export declare function registerToolTemplate(name: string, compiler: ToolTemplateCompiler): void;
+export declare function renderToolCall(call: ToolCall, container: HTMLElement): ToolRenderHandle;

package/dist/types/tooling-umd.d.ts

@@ -0,0 +1,47 @@
+import { mount, ingest, boot, disposeNamespace, register, getRenderer, diagnoseSlexKitSource, SlexKitSyntaxError, formatSlexKitDiagnostic, mountSecureArtifact, parseSlexSource, createSecureRuntime, SlexKitRuntimeError, getSlexKitRuntimeUrl, setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHost } from "./engine/index";
+import { registerAll, registerSvelteComponent, registerSubset } from "./components/index";
+import { registerTooling } from "./components/tooling";
+import { renderToolCall, registerToolTemplate } from "./toolhost/index";
+import { startSlexKitSandboxRunner } from "./engine/sandbox-runner";
+import { clearRegisteredIcons, getIcon, getRegisteredIcon, iconifySvgUrl, loadIcon, normalizeIconName, registerIcon, registerIcons, resolveIconifyIcon, resolveIconWeight } from "./icons/manager";
+import { attachComponentDisposer } from "./engine/component-scope";
+import "./components/index";
+import "./components/tooling";
+declare const mountApi: typeof mount;
+declare const ingestApi: typeof ingest;
+declare const bootApi: typeof boot;
+declare const disposeNamespaceApi: typeof disposeNamespace;
+declare const registerApi: typeof register;
+declare const getRendererApi: typeof getRenderer;
+declare const diagnoseSlexKitSourceApi: typeof diagnoseSlexKitSource;
+declare const SlexKitSyntaxErrorApi: typeof SlexKitSyntaxError;
+declare const formatSlexKitDiagnosticApi: typeof formatSlexKitDiagnostic;
+declare const mountSecureArtifactApi: typeof mountSecureArtifact;
+declare const parseSlexSourceApi: typeof parseSlexSource;
+declare const parseSlexKitDslApi: typeof parseSlexSource;
+declare const createSecureRuntimeApi: typeof createSecureRuntime;
+declare const SlexKitRuntimeErrorApi: typeof SlexKitRuntimeError;
+declare const getSlexKitRuntimeUrlApi: typeof getSlexKitRuntimeUrl;
+declare const setSlexKitRuntimeUrlApi: typeof setSlexKitRuntimeUrl;
+declare const createSlexKitMarkdownRuntimeHostApi: typeof createSlexKitMarkdownRuntimeHost;
+declare const getSlexKitMarkdownRuntimeHostApi: typeof getSlexKitMarkdownRuntimeHost;
+declare const installSlexKitMarkdownRuntimeHostApi: typeof installSlexKitMarkdownRuntimeHost;
+declare const registerAllApi: typeof registerAll;
+declare const registerSvelteComponentApi: typeof registerSvelteComponent;
+declare const registerSubsetApi: typeof registerSubset;
+declare const registerToolingApi: typeof registerTooling;
+declare const renderToolCallApi: typeof renderToolCall;
+declare const registerToolTemplateApi: typeof registerToolTemplate;
+declare const startSlexKitSandboxRunnerApi: typeof startSlexKitSandboxRunner;
+declare const clearRegisteredIconsApi: typeof clearRegisteredIcons;
+declare const getIconApi: typeof getIcon;
+declare const getRegisteredIconApi: typeof getRegisteredIcon;
+declare const iconifySvgUrlApi: typeof iconifySvgUrl;
+declare const loadIconApi: typeof loadIcon;
+declare const normalizeIconNameApi: typeof normalizeIconName;
+declare const registerIconApi: typeof registerIcon;
+declare const registerIconsApi: typeof registerIcons;
+declare const resolveIconifyIconApi: typeof resolveIconifyIcon;
+declare const resolveIconWeightApi: typeof resolveIconWeight;
+declare const attachComponentDisposerApi: typeof attachComponentDisposer;
+export { mountApi as mount, ingestApi as ingest, bootApi as boot, disposeNamespaceApi as disposeNamespace, registerApi as register, getRendererApi as getRenderer, diagnoseSlexKitSourceApi as diagnoseSlexKitSource, SlexKitSyntaxErrorApi as SlexKitSyntaxError, formatSlexKitDiagnosticApi as formatSlexKitDiagnostic, mountSecureArtifactApi as mountSecureArtifact, parseSlexSourceApi as parseSlexSource, parseSlexKitDslApi as parseSlexKitDsl, createSecureRuntimeApi as createSecureRuntime, SlexKitRuntimeErrorApi as SlexKitRuntimeError, getSlexKitRuntimeUrlApi as getSlexKitRuntimeUrl, setSlexKitRuntimeUrlApi as setSlexKitRuntimeUrl, createSlexKitMarkdownRuntimeHostApi as createSlexKitMarkdownRuntimeHost, getSlexKitMarkdownRuntimeHostApi as getSlexKitMarkdownRuntimeHost, installSlexKitMarkdownRuntimeHostApi as installSlexKitMarkdownRuntimeHost, registerAllApi as registerAll, registerSvelteComponentApi as registerSvelteComponent, registerSubsetApi as registerSubset, registerToolingApi as registerTooling, renderToolCallApi as renderToolCall, registerToolTemplateApi as registerToolTemplate, startSlexKitSandboxRunnerApi as startSlexKitSandboxRunner, clearRegisteredIconsApi as clearRegisteredIcons, getIconApi as getIcon, getRegisteredIconApi as getRegisteredIcon, iconifySvgUrlApi as iconifySvgUrl, loadIconApi as loadIcon, normalizeIconNameApi as normalizeIconName, registerIconApi as registerIcon, registerIconsApi as registerIcons, resolveIconifyIconApi as resolveIconifyIcon, resolveIconWeightApi as resolveIconWeight, attachComponentDisposerApi as attachComponentDisposer, };

package/dist/types/version.d.ts

@@ -0,0 +1,8 @@
+export declare const SLEXKIT_VERSION = "0.2.0";
+export declare const SLEX_PROTOCOL_VERSION = "0.1";
+export declare const SLEXKIT_COMPONENTS_VERSION = "0.2.0";
+export declare function getSlexKitInfo(): {
+    version: string;
+    protocolVersion: string;
+    componentsVersion: string;
+};