toiljs 0.0.1

package/src/cli/create.ts

@@ -0,0 +1,272 @@
+/**
+ * `toiljs create` — an interactive project scaffolder (Clack-powered) that wires a new
+ * app to the enforced toiljs presets (tsconfig / eslint / prettier) and file-based routing.
+ * Supports a non-interactive path via flags (`--yes`, `--template`, …) for scripting/CI.
+ */
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { intro, outro, text, select, confirm, isCancel, cancel, spinner, note } from '@clack/prompts';
+import pc from 'picocolors';
+
+import { accent, dim, version } from './ui.js';
+
+export type Template = 'app' | 'minimal';
+
+/** A selectable template in the `create` wizard. */
+interface TemplateOption {
+    readonly value: Template;
+    readonly label: string;
+    readonly hint: string;
+}
+
+export interface CreateOptions {
+    readonly name?: string;
+    readonly template?: Template;
+    readonly install?: boolean;
+    readonly git?: boolean;
+    readonly pm?: string;
+    readonly yes?: boolean;
+    readonly cwd: string;
+}
+
+/** Aborts the wizard cleanly on Ctrl-C / cancel, narrowing the prompt result to its value type. */
+function bail<T>(value: T | symbol): asserts value is T {
+    if (isCancel(value)) {
+        cancel('Scaffolding cancelled.');
+        process.exit(0);
+    }
+}
+
+function isValidName(name: string): true | string {
+    if (!name.trim()) return 'Please enter a project name.';
+    if (!/^[a-z0-9._@/-]+$/i.test(name)) return 'Use letters, numbers, dashes, dots or slashes.';
+    return true;
+}
+
+async function isEmptyDir(dir: string): Promise<boolean> {
+    try {
+        const entries = await fs.readdir(dir);
+        return entries.length === 0;
+    } catch {
+        return true; // doesn't exist yet
+    }
+}
+
+/** Builds the full file map (relative path → contents) for a scaffolded project. */
+function scaffold(name: string, template: Template): Record<string, string> {
+    const toilVersion = version();
+    const pkg = {
+        name: path.basename(name),
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'toiljs dev',
+            build: 'toiljs build',
+            lint: 'eslint client',
+            typecheck: 'tsc --noEmit',
+            format: 'prettier --write "client/**/*.{ts,tsx}"',
+        },
+        dependencies: {
+            toiljs: `^${toilVersion}`,
+            react: '^19.2.6',
+            'react-dom': '^19.2.6',
+        },
+        devDependencies: {
+            '@types/react': '^19.2.15',
+            '@types/react-dom': '^19.2.3',
+            eslint: '^10.2.0',
+            prettier: '^3.8.1',
+            typescript: '^6.0.3',
+        },
+    };
+
+    const files: Record<string, string> = {
+        'package.json': JSON.stringify(pkg, null, 4) + '\n',
+        'toil.config.ts':
+            "import { defineConfig } from 'toiljs/compiler';\n\n" +
+            'export default defineConfig({\n    client: {\n        outDir: \'dist\',\n    },\n});\n',
+        'tsconfig.json':
+            '{\n    "extends": "toiljs/tsconfig",\n    "include": ["client", "toil-env.d.ts"]\n}\n',
+        'eslint.config.js': "import toiljs from 'toiljs/eslint';\n\nexport default toiljs;\n",
+        '.prettierrc': '"toiljs/prettier"\n',
+        '.gitignore': 'node_modules\ndist\n.toil\ntoil-env.d.ts\n',
+        'README.md': ['# ' + path.basename(name), '', 'A [toiljs](https://toil.org) app.', '', '## Develop', '', '    npm install', '    npm run dev', '', '## Build', '', '    npm run build', ''].join('\n'),
+        'client/layout.tsx':
+            "import { type ReactNode } from 'react';\n\n" +
+            "import { Link } from 'toiljs/client';\n\n" +
+            'export default function Layout({ children }: { children?: ReactNode }) {\n' +
+            '    return (\n' +
+            "        <div style={{ fontFamily: 'system-ui', maxWidth: 640, margin: '2rem auto' }}>\n" +
+            "            <header style={{ borderBottom: '1px solid #ddd', paddingBottom: 8, marginBottom: 16 }}>\n" +
+            '                <strong>' + path.basename(name) + '</strong> — <Link href="/">home</Link>' +
+            (template === 'app' ? ' · <Link href="/about">about</Link>' : '') +
+            '\n            </header>\n            {children}\n        </div>\n    );\n}\n',
+        'client/routes/index.tsx':
+            "import { Link } from 'toiljs/client';\n\n" +
+            'export default function Home() {\n' +
+            '    return (\n        <main>\n' +
+            '            <h1>Welcome to toiljs</h1>\n' +
+            '            <p>File-based routing, bundled by Vite, zero config.</p>\n' +
+            (template === 'app'
+                ? '            <p>\n                <Link href="/about">About</Link> · <Link href="/blog/42">Blog post 42</Link>\n            </p>\n'
+                : '') +
+            '        </main>\n    );\n}\n',
+    };
+
+    if (template === 'app') {
+        files['client/routes/about.tsx'] =
+            "import { Link } from 'toiljs/client';\n\n" +
+            'export default function About() {\n' +
+            '    return (\n        <main>\n            <h1>About</h1>\n' +
+            '            <p>\n                This page is served by <code>client/routes/about.tsx</code>.\n            </p>\n' +
+            '            <Link href="/">Back home</Link>\n        </main>\n    );\n}\n';
+        files['client/routes/blog/[id].tsx'] =
+            "import { Link, useParams } from 'toiljs/client';\n\n" +
+            'export default function BlogPost() {\n' +
+            '    const { id } = useParams();\n' +
+            '    return (\n        <main>\n            <h1>Blog post {id}</h1>\n' +
+            '            <p>\n                Dynamic route from <code>client/routes/blog/[id].tsx</code>.\n            </p>\n' +
+            '            <Link href="/">Back home</Link>\n        </main>\n    );\n}\n';
+    }
+
+    return files;
+}
+
+async function writeFiles(dir: string, files: Record<string, string>): Promise<void> {
+    for (const [rel, contents] of Object.entries(files)) {
+        const full = path.join(dir, rel);
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        await fs.writeFile(full, contents, 'utf8');
+    }
+}
+
+function run(cmd: string, args: string[], cwd: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { cwd, stdio: 'ignore', shell: process.platform === 'win32' });
+        child.on('error', reject);
+        child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${String(code)}`))));
+    });
+}
+
+/** Runs the create flow (interactive unless `--yes`). */
+export async function runCreate(opts: CreateOptions): Promise<void> {
+    intro(accent(' toiljs create '));
+
+    // 1. Project name
+    let name = opts.name;
+    if (!name) {
+        if (opts.yes) {
+            name = 'my-toil-app';
+        } else {
+            const answer = await text({
+                message: 'Project name',
+                placeholder: 'my-toil-app',
+                defaultValue: 'my-toil-app',
+                validate: (v) => {
+                    const result = isValidName(v || 'my-toil-app');
+                    return result === true ? undefined : result;
+                },
+            });
+            bail(answer);
+            name = answer.trim() || 'my-toil-app';
+        }
+    }
+    const valid = isValidName(name);
+    if (valid !== true) {
+        cancel(valid);
+        process.exit(1);
+    }
+
+    const targetDir = path.resolve(opts.cwd, name);
+    const rel = path.relative(opts.cwd, targetDir) || '.';
+
+    // 2. Guard against clobbering a non-empty dir
+    if (!(await isEmptyDir(targetDir))) {
+        if (opts.yes) {
+            cancel(`Directory ${pc.cyan(rel)} is not empty.`);
+            process.exit(1);
+        }
+        const proceed = await confirm({
+            message: `Directory ${pc.cyan(rel)} is not empty. Scaffold into it anyway?`,
+            initialValue: false,
+        });
+        bail(proceed);
+        if (!proceed) {
+            cancel('Scaffolding cancelled.');
+            process.exit(0);
+        }
+    }
+
+    // 3. Template
+    let template: Template = opts.template ?? 'app';
+    if (!opts.template && !opts.yes) {
+        const templateOptions: TemplateOption[] = [
+            { value: 'app', label: 'App', hint: 'layout + home/about + a dynamic /blog/[id] route' },
+            { value: 'minimal', label: 'Minimal', hint: 'just a layout and a home route' },
+        ];
+        const choice = await select({ message: 'Which template?', options: templateOptions, initialValue: 'app' });
+        bail(choice);
+        template = choice === 'minimal' ? 'minimal' : 'app';
+    }
+
+    // 4. Options: git + install
+    let initGit = opts.git ?? false;
+    let install = opts.install ?? false;
+    const pm = opts.pm ?? 'npm';
+    if (!opts.yes) {
+        if (opts.git === undefined) {
+            const g = await confirm({ message: 'Initialize a git repository?', initialValue: true });
+            bail(g);
+            initGit = g;
+        }
+        if (opts.install === undefined) {
+            const i = await confirm({ message: 'Install dependencies now?', initialValue: false });
+            bail(i);
+            install = i;
+        }
+    }
+
+    // 5. Scaffold
+    const s = spinner();
+    s.start('Scaffolding project');
+    await writeFiles(targetDir, scaffold(name, template));
+    s.stop(`Scaffolded ${pc.cyan(rel)}`);
+
+    // 6. git init (best-effort)
+    if (initGit) {
+        const g = spinner();
+        g.start('Initializing git repository');
+        try {
+            await run('git', ['init', '-q'], targetDir);
+            await run('git', ['add', '-A'], targetDir);
+            g.stop('Initialized git repository');
+        } catch {
+            g.stop(pc.yellow('Skipped git init (git not available)'));
+        }
+    }
+
+    // 7. Install (best-effort)
+    if (install) {
+        const i = spinner();
+        i.start(`Installing dependencies with ${pm}`);
+        try {
+            await run(pm, ['install'], targetDir);
+            i.stop('Installed dependencies');
+        } catch {
+            i.stop(pc.yellow(`Could not install with ${pm} — run it yourself later`));
+            install = false;
+        }
+    }
+
+    // 8. Next steps
+    const steps: string[] = [];
+    if (rel !== '.') steps.push(`cd ${rel}`);
+    if (!install) steps.push('npm install');
+    steps.push(`${accent('npm run dev')}   ${dim('start the dev server')}`);
+    steps.push(`${accent('npm run build')} ${dim('build for production')}`);
+    note(steps.map((l) => dim('  ') + l).join('\n'), 'Next steps');
+
+    outro(`Created ${accent(path.basename(name))} — happy building! ${dim('· v' + version())}`);
+}

package/src/cli/index.ts

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * toiljs CLI. Routes `create` / `dev` / `build` and wraps them in the toiljs brand banner.
+ * The compiler stays presentation-free (imported via the package's own `toiljs/compiler`
+ * export); the epic bits — banner, the Clack scaffolding wizard — live here.
+ */
+import { build, dev, start } from 'toiljs/compiler';
+
+import { runCreate, type Template } from './create.js';
+import { accent, banner, bold, dim, version } from './ui.js';
+
+interface Flags {
+    root?: string;
+    port?: number;
+    name?: string;
+    template?: Template;
+    install?: boolean;
+    git?: boolean;
+    pm?: string;
+    yes?: boolean;
+}
+
+function parseArgs(argv: string[]): Flags {
+    const flags: Flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--root':
+                flags.root = argv[++i];
+                break;
+            case '--port':
+                flags.port = Number(argv[++i]);
+                break;
+            case '--template':
+            case '-t': {
+                const t = argv[++i];
+                if (t === 'app' || t === 'minimal') flags.template = t;
+                break;
+            }
+            case '--pm':
+                flags.pm = argv[++i];
+                break;
+            case '--install':
+                flags.install = true;
+                break;
+            case '--no-install':
+                flags.install = false;
+                break;
+            case '--git':
+                flags.git = true;
+                break;
+            case '--no-git':
+                flags.git = false;
+                break;
+            case '-y':
+            case '--yes':
+                flags.yes = true;
+                break;
+            default:
+                // First bare (non-flag) token is the positional project name.
+                if (!arg.startsWith('-') && flags.name === undefined) flags.name = arg;
+        }
+    }
+    return flags;
+}
+
+function printHelp(): void {
+    const cmd = (name: string, desc: string): string => `  ${accent(name.padEnd(15))}${dim(desc)}`;
+    process.stdout.write(
+        [
+            `${bold('Usage')}  ${dim('toiljs')} <command> [options]`,
+            '',
+            bold('Commands'),
+            cmd('create [name]', 'scaffold a new toiljs app'),
+            cmd('dev', 'start the dev server with HMR'),
+            cmd('build', 'build the optimized production bundle'),
+            cmd('start', 'self-host the built app (hyper-express / uWS)'),
+            '',
+            bold('Options'),
+            cmd('--root <dir>', 'project root (default: current directory)'),
+            cmd('--port <n>', 'dev server port'),
+            cmd('-t, --template', 'create: app | minimal'),
+            cmd('-y, --yes', 'create: accept defaults (non-interactive)'),
+            cmd('--no-install', "create: don't install dependencies"),
+            cmd('-v, --version', 'print the toiljs version'),
+            '',
+        ].join('\n') + '\n',
+    );
+}
+
+async function main(): Promise<void> {
+    const [command, ...rest] = process.argv.slice(2);
+
+    if (command === '--version' || command === '-v') {
+        process.stdout.write(version() + '\n');
+        return;
+    }
+
+    const flags = parseArgs(rest);
+
+    switch (command) {
+        case 'create':
+            banner();
+            await runCreate({
+                name: flags.name,
+                template: flags.template,
+                install: flags.install,
+                git: flags.git,
+                pm: flags.pm,
+                yes: flags.yes,
+                cwd: process.cwd(),
+            });
+            break;
+
+        case 'dev':
+            banner();
+            process.stdout.write(dim('  starting dev server…') + '\n\n');
+            await dev({ root: flags.root, port: flags.port });
+            break;
+
+        case 'build':
+            banner();
+            process.stdout.write(dim('  building for production…') + '\n\n');
+            await build({ root: flags.root });
+            process.stdout.write('\n' + accent('  ✓ ') + bold('build complete') + '\n\n');
+            break;
+
+        case 'start': {
+            banner();
+            process.stdout.write(dim('  self-hosting the built app…') + '\n\n');
+            const server = await start({ root: flags.root, port: flags.port });
+            process.stdout.write(
+                accent('  ➜ ') +
+                    bold(`http://localhost:${String(server.port)}`) +
+                    dim(`   ws channel: ${server.wsPath}`) +
+                    '\n\n',
+            );
+            break;
+        }
+
+        case 'help':
+        case '--help':
+        case '-h':
+        case undefined:
+            banner();
+            printHelp();
+            break;
+
+        default:
+            banner();
+            process.stdout.write(dim(`  unknown command: ${command}`) + '\n\n');
+            printHelp();
+            process.exitCode = 1;
+    }
+}
+
+main().catch((err: unknown) => {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write('\n' + accent('  ✗ ') + message + '\n');
+    process.exitCode = 1;
+});

package/src/cli/ui.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared CLI presentation: the toiljs brand banner, gradient text, and small helpers.
+ * Kept dependency-light (only picocolors); the gradient is hand-rolled truecolor ANSI so
+ * the logo pops without pulling in a gradient library.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import pc from 'picocolors';
+
+type RGB = readonly [number, number, number];
+
+/** toiljs brand amber → deep gold. */
+const FROM: RGB = [250, 204, 80];
+const TO: RGB = [198, 112, 20];
+
+/** ANSI-shadow "TOIL" wordmark. */
+const ART: readonly string[] = [
+    '████████╗  ██████╗  ██╗ ██╗     ',
+    '╚══██╔══╝ ██╔═══██╗ ██║ ██║     ',
+    '   ██║    ██║   ██║ ██║ ██║     ',
+    '   ██║    ██║   ██║ ██║ ██║     ',
+    '   ██║    ╚██████╔╝ ██║ ███████╗',
+    '   ╚═╝     ╚═════╝  ╚═╝ ╚══════╝',
+];
+
+export const dim = pc.dim;
+export const bold = pc.bold;
+
+/** True when we should emit ANSI color (a TTY, and not disabled via NO_COLOR). */
+function colorEnabled(): boolean {
+    return process.stdout.isTTY && !process.env.NO_COLOR;
+}
+
+/** The amber brand accent (truecolor). No-ops to plain text when color is disabled. */
+export function brand(s: string): string {
+    return colorEnabled() ? `\x1b[38;2;203;152;32m${s}\x1b[39m` : s;
+}
+export const accent = brand;
+
+function lerp(a: number, b: number, t: number): number {
+    return Math.round(a + (b - a) * t);
+}
+
+/** Colors each character of `line` along a left→right truecolor gradient. */
+function gradientLine(line: string): string {
+    const n = line.length;
+    let out = '';
+    for (let i = 0; i < n; i++) {
+        const t = n > 1 ? i / (n - 1) : 0;
+        const r = lerp(FROM[0], TO[0], t);
+        const g = lerp(FROM[1], TO[1], t);
+        const b = lerp(FROM[2], TO[2], t);
+        out += `\x1b[38;2;${r};${g};${b}m${line[i]}`;
+    }
+    return out + '\x1b[39m';
+}
+
+/** Reads the toiljs package version (CLI lives at build/cli/, package root is two up). */
+export function version(): string {
+    try {
+        const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const match = /"version"\s*:\s*"([^"]+)"/.exec(raw);
+        if (match && match[1]) return match[1];
+    } catch {
+        /* fall through to default */
+    }
+    return '0.0.0';
+}
+
+/** Prints the brand banner: gradient logo + tagline + version. */
+export function banner(): void {
+    const lines = colorEnabled() ? ART.map(gradientLine) : ART.slice();
+    const tagline = `  the full-stack ${brand('WebAssembly')} framework`;
+    const ver = `${dim('  v')}${brand(version())}`;
+    process.stdout.write('\n' + lines.join('\n') + '\n\n' + tagline + '   ' + ver + '\n\n');
+}

package/src/client/channel.ts

@@ -0,0 +1,146 @@
+/**
+ * Client for the toil backend's WebSocket channel (served by the hyper-express/uWS backend at
+ * `/_toil`). Supports text and binary (`ArrayBuffer`) frames, auto-reconnect, and a React hook.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+/** A frame received from / sent to the channel. */
+export type ChannelData = string | ArrayBuffer;
+
+/** Whatever `WebSocket.send` accepts (string / BufferSource / Blob), per the DOM lib. */
+export type SendData = Parameters<WebSocket['send']>[0];
+
+export interface ChannelOptions {
+    /** Channel path on the toil backend. Default `/_toil`. */
+    readonly path?: string;
+    /** Full `ws(s)://` URL override (takes precedence over `path`). */
+    readonly url?: string;
+    /** Auto-reconnect after an unexpected close. Default `true`. */
+    readonly reconnect?: boolean;
+    /** Reconnect delay in ms. Default `1000`. */
+    readonly reconnectDelay?: number;
+}
+
+export interface Channel {
+    /** Sends a text or binary frame (no-op until the socket is open). */
+    send(data: SendData): void;
+    /** Closes the channel and stops reconnecting. */
+    close(): void;
+}
+
+/** Derives the channel's `ws(s)://` URL from the current page location. */
+export function resolveChannelUrl(
+    path: string = '/_toil',
+    location: { protocol: string; host: string } = window.location,
+): string {
+    const scheme = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const normalized = path.startsWith('/') ? path : `/${path}`;
+    return `${scheme}//${location.host}${normalized}`;
+}
+
+/**
+ * Opens a channel to the backend, invoking `onMessage` for each frame. Reconnects on unexpected
+ * close unless disabled. Returns a handle to `send()` and `close()`.
+ */
+export function connectChannel(
+    onMessage: (data: ChannelData) => void,
+    options: ChannelOptions = {},
+): Channel {
+    const url = options.url ?? resolveChannelUrl(options.path);
+    const reconnect = options.reconnect ?? true;
+    const delay = options.reconnectDelay ?? 1000;
+
+    let socket: WebSocket | null = null;
+    let stopped = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const open = (): void => {
+        const ws = new WebSocket(url);
+        ws.binaryType = 'arraybuffer';
+        socket = ws;
+        ws.addEventListener('message', (event: MessageEvent) => {
+            if (typeof event.data === 'string') onMessage(event.data);
+            else if (event.data instanceof ArrayBuffer) onMessage(event.data);
+        });
+        ws.addEventListener('close', () => {
+            if (!stopped && reconnect) timer = setTimeout(open, delay);
+        });
+    };
+    open();
+
+    return {
+        send: (data: SendData): void => {
+            if (socket && socket.readyState === WebSocket.OPEN) socket.send(data);
+        },
+        close: (): void => {
+            stopped = true;
+            if (timer !== undefined) clearTimeout(timer);
+            socket?.close();
+        },
+    };
+}
+
+export interface ChannelHook {
+    /** Whether the socket is currently open. */
+    readonly connected: boolean;
+    /** Frames received so far, in order. */
+    readonly messages: ChannelData[];
+    /** Sends a text or binary frame. */
+    send: (data: SendData) => void;
+}
+
+/**
+ * React hook wrapping {@link connectChannel}: connects on mount, tracks `connected` state and the
+ * received `messages`, and cleans up on unmount.
+ */
+export function useChannel(options: ChannelOptions = {}): ChannelHook {
+    const { path, url, reconnect, reconnectDelay } = options;
+    const [connected, setConnected] = useState<boolean>(false);
+    const [messages, setMessages] = useState<ChannelData[]>([]);
+    const socketRef = useRef<WebSocket | null>(null);
+
+    useEffect(() => {
+        const target = url ?? resolveChannelUrl(path);
+        const shouldReconnect = reconnect ?? true;
+        const delay = reconnectDelay ?? 1000;
+        let stopped = false;
+        let timer: ReturnType<typeof setTimeout> | undefined;
+
+        const open = (): void => {
+            const ws = new WebSocket(target);
+            ws.binaryType = 'arraybuffer';
+            socketRef.current = ws;
+            ws.addEventListener('open', () => {
+                if (!stopped) setConnected(true);
+            });
+            ws.addEventListener('message', (event: MessageEvent) => {
+                if (typeof event.data === 'string') {
+                    const data = event.data;
+                    setMessages((prev) => [...prev, data]);
+                } else if (event.data instanceof ArrayBuffer) {
+                    const data = event.data;
+                    setMessages((prev) => [...prev, data]);
+                }
+            });
+            ws.addEventListener('close', () => {
+                if (stopped) return;
+                setConnected(false);
+                if (shouldReconnect) timer = setTimeout(open, delay);
+            });
+        };
+        open();
+
+        return () => {
+            stopped = true;
+            if (timer !== undefined) clearTimeout(timer);
+            socketRef.current?.close();
+        };
+    }, [path, url, reconnect, reconnectDelay]);
+
+    const send = useCallback((data: SendData): void => {
+        const socket = socketRef.current;
+        if (socket && socket.readyState === WebSocket.OPEN) socket.send(data);
+    }, []);
+
+    return { connected, messages, send };
+}

package/src/client/index.ts

@@ -0,0 +1,12 @@
+/**
+ * toiljs client runtime, published as `toiljs/client`. Provides the router (mount/Router/Link),
+ * navigation hooks, and route types consumed by the compiler-generated entry. Zero imports
+ * needed in user route files beyond this package.
+ */
+
+export { mount, Router, Link, navigate, useParams, useNavigate, useLocation } from './runtime.js';
+export type { RouteDef, LayoutLoader, NotFoundLoader } from './runtime.js';
+export { matchRoute } from './match.js';
+export type { RouteParams } from './match.js';
+export { connectChannel, useChannel, resolveChannelUrl } from './channel.js';
+export type { Channel, ChannelOptions, ChannelHook, ChannelData } from './channel.js';