duckfn-docs-kit 0.1.0

package/dist/sql/remark.js

@@ -0,0 +1,69 @@
+//#region src/sql/remark.ts
+var e = "dfk-sql";
+function t(e) {
+	if (!e) return null;
+	try {
+		let t = JSON.parse(e);
+		if (typeof t == "object" && t && t.type === "duckfn") return t;
+	} catch {}
+	return null;
+}
+function n(e) {
+	return Math.max(1, e.split("\n").length);
+}
+function r(e) {
+	return {
+		type: "mdxJsxFlowElement",
+		name: "div",
+		attributes: [{
+			type: "mdxJsxAttribute",
+			name: "className",
+			value: "dfk-sql-editor-skeleton"
+		}],
+		children: Array.from({ length: n(e) }, () => ({
+			type: "mdxJsxFlowElement",
+			name: "span",
+			attributes: [{
+				type: "mdxJsxAttribute",
+				name: "className",
+				value: "dfk-sql-editor-skeleton-line"
+			}],
+			children: []
+		}))
+	};
+}
+function i(t, n) {
+	let i = String(t.value ?? "");
+	return {
+		type: "mdxJsxFlowElement",
+		name: e,
+		attributes: [{
+			type: "mdxJsxAttribute",
+			name: "config",
+			value: JSON.stringify(n)
+		}, {
+			type: "mdxJsxAttribute",
+			name: "sql",
+			value: i
+		}],
+		children: [r(i), t]
+	};
+}
+var a = (e = {}) => (e) => {
+	let n = (e) => {
+		if (typeof e != "object" || !e) return;
+		let r = e;
+		Array.isArray(r.children) && (r.children = r.children.map((e) => {
+			if (typeof e != "object" || !e) return e;
+			let r = e;
+			if (r.type === "code" && r.lang === "sql") {
+				let e = t(r.meta);
+				if (e) return i(r, e);
+			}
+			return n(r), r;
+		}));
+	};
+	n(e);
+};
+//#endregion
+export { e as DFK_SQL_TAG, a as remarkRunnableSql };

package/dist/sql/renderers.d.ts

@@ -0,0 +1,44 @@
+import type { QueryResult } from './runtime';
+import type { RunnableSqlConfig } from './remark';
+/**
+ * Result renderers, keyed by the config's `show` field.
+ *
+ * The registry is the seam later phases plug into. It ships `table` (VisActor
+ * VTable), a `text` fallback, the markup previews `iframe` / `html` / `svg`,
+ * plus the `error` view every renderer shares.
+ *
+ * Heavy dependencies (`@visactor/vtable`) load through dynamic `import()`
+ * inside the renderer, so a page that never runs a query never pays for them,
+ * and Docusaurus' Node prerender never touches them.
+ */
+export interface RenderContext {
+    /** Container element in the light DOM, sized by `sql.css`. */
+    host: HTMLElement;
+    config: RunnableSqlConfig;
+    /** Localised strings resolved by the component (labels-by-html-lang). */
+    labels: Record<string, string>;
+    /**
+     * The component's fullscreen toggle, parked at the right end of the tab
+     * strip. `<dfk-sql>` owns the button's state and therefore the node; the
+     * renderer only borrows it so every result has the same chrome.
+     */
+    fullscreenButton: HTMLElement;
+}
+/**
+ * Renders `result` into `context.host`. Resolves with a disposer releasing any
+ * resources (table instances) the renderer created; it runs on the next render
+ * and when the element disconnects.
+ *
+ * Every renderer is async — the heavy ones await their dynamic `import()`, and
+ * the trivial ones just resolve immediately — so the caller has exactly one
+ * shape to handle.
+ */
+export type Renderer = (context: RenderContext, result: QueryResult) => Promise<void | (() => void)>;
+/** Shared error view: a styled block, never a thrown exception. */
+export declare const errorRenderer: Renderer;
+/**
+ * Picks the renderer for a result: the config's `show` wins, otherwise a
+ * single-column single-row result degrades to `text` (a bare scalar like
+ * `SELECT 1;` reads better as a line than as a 1×1 table), otherwise `table`.
+ */
+export declare function rendererFor(config: RunnableSqlConfig, result: QueryResult): Renderer;

package/dist/sql/runtime.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The browser-side DuckDB-Wasm runtime: one instance per docs-site frontend
+ * runtime (module-level singleton), *not* persisted across page loads.
+ *
+ * Design points:
+ *
+ * - `@duckdb/duckdb-wasm` is only ever reached through a dynamic `import()`,
+ *   so Docusaurus' Node prerender pass and the initial page load never touch
+ *   it. The wasm binary and the worker script come from the official jsDelivr
+ *   CDN (`getJsDelivrBundles` + `selectBundle`), which sidesteps any webpack
+ *   `asyncWebAssembly` / worker configuration on the consuming site.
+ *   `selectBundle` falls back to a non-`SharedArrayBuffer` bundle when the
+ *   page is not crossOrigin-isolated (GitHub Pages), so it works everywhere.
+ * - `init()` is idempotent and retryable: a failed init leaves `state` at
+ *   `'error'` and clears the memoised promise, so a later Run click can try
+ *   again.
+ * - `execute()` hands the whole string to DuckDB. Multi-statement queries
+ *   return the result of the **last** statement, which is exactly the
+ *   documented behaviour for runnable blocks.
+ * - Extensions get into the shared instance two ways, both through the same
+ *   memoised loader: the **site preload list** (the ordered `preload` array of
+ *   the JSON `<script>` tag the build-time plugin injects, loaded right after
+ *   `connect()` so a block can rely on the extension without naming it), and
+ *   the **per-block `extensions` config** loaded on demand by
+ *   {@link DuckDBRuntime.loadExtension}. Note that on WebAssembly `INSTALL` is
+ *   a no-op (there is no persistent storage to install *into*): it only
+ *   records where a later `LOAD` fetches a name from. A load by name fetches
+ *   `<repository>/duckdb-wasm/<revision>/<platform>/<name>.duckdb_extension.wasm`
+ *   and verifies the signature; a `{url}` preload fetches exactly that URL
+ *   (which is why the URL must be absolute — the worker runs from a blob URL
+ *   and cannot resolve relative paths). Either way, the text before the first
+ *   dot of the file name is the entry symbol DuckDB looks up, so a release
+ *   asset like `duckfn-wasm_eh.duckdb_extension.wasm` has to be renamed to
+ *   `duckfn.duckdb_extension.wasm` on the way in (enforced by validation).
+ * - Extension names, repositories and URLs are **validated, not escaped** (see
+ *   `sql/runtimeConfig`): `LOAD` cannot take them as parameters.
+ * - `allowUnsignedExtensions` is opt-in and per-instance: it is a database
+ *   setting fixed by `open()`, so it has to be known before the first
+ *   `connect()`. The site-wide value (from the injected config) and the first
+ *   caller's are merged by whichever `init()` actually creates the instance.
+ */
+export type RuntimeState = 'idle' | 'loading' | 'ready' | 'error';
+/**
+ * Options for {@link DuckDBRuntime.init}. They are merged with the site-wide
+ * injected config, and only read by the caller that actually creates the
+ * instance: `allowUnsignedExtensions` is fixed at `open()` time and later
+ * callers cannot retune a database that already exists.
+ */
+export interface RuntimeOptions {
+    /** Let `LOAD` accept an extension whose signature does not verify. */
+    allowUnsignedExtensions?: boolean;
+}
+/** Options for {@link DuckDBRuntime.loadExtension}. */
+export interface LoadExtensionOptions {
+    /** `community`, `core` or a repository URL, instead of the official default. */
+    repository?: string;
+}
+/** A normalised query result: column names plus row objects keyed by them. */
+export interface QueryResult {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    /** Set when the statement failed; `columns`/`rows` are then empty. */
+    error?: string;
+}
+export declare class DuckDBRuntime {
+    #private;
+    /** The per-frontend-runtime singleton; shared by every `<dfk-sql>` block. */
+    static getInstance(): DuckDBRuntime;
+    get state(): RuntimeState;
+    /** The last init failure's message, for the UI to display. */
+    get message(): string;
+    /**
+     * Creates the database in the background (first Run click triggers it; a
+     * consuming site may also call it early to warm the instance). Concurrent
+     * callers share one promise, and it only resolves once the site's preloads
+     * are loaded too.
+     *
+     * Options and the injected site config are only read by the caller that
+     * actually creates the instance: `allowUnsignedExtensions` is fixed at
+     * `open()` time, and later callers cannot retune a database that already
+     * exists. A malformed injected config fails here, before any download.
+     */
+    init(options?: RuntimeOptions): Promise<void>;
+    /** Runs `sql` and resolves with the (last statement's) result. */
+    execute(sql: string): Promise<QueryResult>;
+    /**
+     * Loads one extension on demand — what a runnable block's `extensions`
+     * config ends up doing.
+     *
+     * `LOAD` is the whole mechanism on WebAssembly: it fetches the extension's
+     * `.duckdb_extension.wasm` and verifies the signature before loading it.
+     * `INSTALL … FROM` only records *where* a later `LOAD` should fetch from
+     * (there is no persistent storage to install into), which is also why it is
+     * used for a non-default `repository` instead of the global
+     * `SET custom_extension_repository` — the recorded source stays attached to
+     * this one extension.
+     *
+     * The name and repository are validated rather than escaped — `LOAD` takes
+     * an identifier, not a parameter, so anything that could terminate the
+     * statement is rejected outright. Successful loads (and in-flight ones) are
+     * memoised per repository + name; a **failure** is not, so a Run click can
+     * retry.
+     */
+    loadExtension(name: string, options?: LoadExtensionOptions): Promise<void>;
+}

package/dist/sql/runtimeConfig.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The contract between the build-time plugin (`sql/extensions`) and the
+ * browser runtime (`sql/runtime`).
+ *
+ * The plugin writes one JSON `<script>` tag into every page carrying the
+ * site's runtime configuration; the runtime reads it once, when the shared
+ * DuckDB instance is first created. Tag id, entry shapes and the validators
+ * live together in this dependency-free module so the two sides cannot drift —
+ * and so the browser bundle never drags in Node code (or the Node plugin the
+ * DOM).
+ *
+ * This module must not import anything: it is bundled into both the browser
+ * and the Node entry points.
+ */
+/** Id of the JSON config `<script>` the build-time plugin injects per page. */
+export declare const DFK_SQL_RUNTIME_TAG_ID = "dfk-sql-runtime";
+/** A bare SQL identifier: `LOAD` / `INSTALL` cannot be parameterised, so this is the guard. */
+export declare const EXTENSION_NAME_PATTERN: RegExp;
+/** A repository URL with no character that could escape the SQL string literal. */
+export declare const REPOSITORY_URL_PATTERN: RegExp;
+/** Bare `FROM` keywords `INSTALL` accepts instead of a repository URL. */
+export declare const REPOSITORY_KEYWORDS: Set<string>;
+/** An extension preloaded by name, from the official repository or another one. */
+export interface NamedPreloadEntry {
+    /** The extension name, e.g. `duckfn`. */
+    name: string;
+    /** `community`, `core` or a repository URL; omitted = the official repository. */
+    repository?: string;
+}
+/** A GitHub release asset the build-time plugin copies to `url` at build time. */
+export interface PreloadReleaseSource {
+    /** The GitHub repository, `owner/name`. */
+    repository: string;
+    /** The asset name on that repository's latest release, e.g. `duckfn-wasm_eh.duckdb_extension.wasm`. */
+    asset: string;
+}
+/** An extension preloaded from a file, served by the site itself or remotely. */
+export interface UrlPreloadEntry {
+    /**
+     * A site-relative path (`duckdb-extensions/duckfn.duckdb_extension.wasm`),
+     * resolved against the site's baseUrl and served from `static/`; or an
+     * absolute `http(s)://` URL.
+     *
+     * The base name of the last path segment — the text before its first dot —
+     * must be the extension name: on WebAssembly that text is what DuckDB turns
+     * into the `<name>_init_c_api` entry symbol, which is exactly why a release
+     * asset like `duckfn-wasm_eh.duckdb_extension.wasm` has to be renamed to
+     * `duckfn.duckdb_extension.wasm` on the way in.
+     */
+    url: string;
+    /** Fetch the file from the repository's latest GitHub release at build time. */
+    release?: PreloadReleaseSource;
+}
+/** One entry of the ordered site-level preload list. */
+export type PreloadEntry = string | NamedPreloadEntry | UrlPreloadEntry;
+/** The config the build-time plugin injects and the browser runtime reads. */
+export interface SiteRuntimeConfig {
+    /** Let `LOAD` accept extensions without a valid signature; a site-wide opt-in. */
+    allowUnsignedExtensions?: boolean;
+    /** Ordered: every entry loads, one after another, before the instance is `ready`. */
+    preload: PreloadEntry[];
+}
+/** True for the only absolute URL form a preload may carry. */
+export declare function isAbsoluteHttpUrl(value: string): boolean;
+/**
+ * The entry-symbol base name of a served extension file: the text before the
+ * first dot in its last path segment. DuckDB loads a direct file by that name
+ * (`duckfn.duckdb_extension.wasm` -> `duckfn` -> `duckfn_init_c_api`), so a
+ * file still carrying a platform suffix cannot be loaded as-is.
+ */
+export declare function extensionBaseName(url: string): string;
+/**
+ * Validates and normalises one preload entry, dropping unknown keys and
+ * lower-casing repository keywords; throws with a readable message on
+ * anything that could not be turned into a safe `LOAD` / `INSTALL` statement
+ * or a static file path.
+ */
+export declare function normalizePreloadEntry(entry: unknown): PreloadEntry;
+/** Validates the injected config envelope and normalises every preload entry. */
+export declare function parseSiteRuntimeConfig(value: unknown): SiteRuntimeConfig;

package/dist/sql/styles.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The one parsed stylesheet shared by every `<dfk-sql>` shadow root.
+ * Created lazily: `CSSStyleSheet` does not exist during Docusaurus' Node
+ * prerender, and only the browser ever calls this.
+ */
+export declare function sqlStyles(): CSSStyleSheet;

package/dist/toc-toggle/TocToggle.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Adds a collapse/expand control to the desktop table of contents.
+ *
+ * Docusaurus only has `themeConfig.docs.sidebar.hideable` for the left sidebar;
+ * the right-hand TOC has no such option (`themeConfig.tableOfContents` only
+ * accepts `minHeadingLevel` / `maxHeadingLevel`). So the button is injected here
+ * and the layout is switched by the `toc-collapsed` class on `<body>`. The
+ * matching CSS lives in `TocToggle.css`, next to this file.
+ *
+ * This is the class-ified form of the original TOC glue: the button and TOC
+ * references are held in fields instead of being looked up with
+ * `document.querySelector` on every update, and all module-level mutable state
+ * now lives inside {@link TocToggle}. `client.ts` next to this file is the thin
+ * Docusaurus glue that the `toc-toggle/plugin` entry injects into a site.
+ */
+export interface TocToggleLabels {
+    hide: string;
+    show: string;
+}
+export interface TocToggleOptions {
+    /** Keyed by a lower-cased html-lang prefix; falls back to `en`. */
+    labels?: Record<string, TocToggleLabels>;
+    storageKey?: string;
+}
+export declare class TocToggle {
+    #private;
+    constructor(options?: TocToggleOptions);
+    /**
+     * Reconciles the button with the current page. The TOC is rendered by React,
+     * so it only exists on pages with headings and only on wide viewports; the
+     * button may also have been discarded by a re-render, so it is rebuilt when
+     * missing.
+     */
+    refresh(): void;
+    /**
+     * Reads the stored preference, applies it before React renders (so a collapsed
+     * TOC never flashes open) and wires up the viewport listener.
+     */
+    init(): void;
+}
+/**
+ * Builds a {@link TocToggle}. `client.ts` — the glue the `toc-toggle/plugin`
+ * entry injects — calls `init()` once (behind a `typeof window` guard) and
+ * exports `onRouteDidUpdate` bound to `refresh()`.
+ */
+export declare function createTocToggle(options?: TocToggleOptions): TocToggle;

package/dist/toc-toggle/TocToggle.js

@@ -0,0 +1,69 @@
+//#region src/toc-toggle/TocToggle.ts
+var e = {
+	en: {
+		hide: "Collapse table of contents",
+		show: "Expand table of contents"
+	},
+	"zh-hans": {
+		hide: "收起目录",
+		show: "展开目录"
+	}
+}, t = class {
+	#e;
+	#t;
+	#n = !1;
+	#r = null;
+	constructor(t = {}) {
+		this.#e = t.labels ?? e, this.#t = t.storageKey ?? "duckfn:toc-collapsed";
+	}
+	#i() {
+		let t = (document.documentElement.getAttribute("lang") ?? "en").toLowerCase();
+		return this.#e[t] ?? this.#e.en ?? e.en;
+	}
+	#a() {
+		try {
+			return window.localStorage.getItem(this.#t) === "true";
+		} catch {
+			return !1;
+		}
+	}
+	#o(e) {
+		try {
+			window.localStorage.setItem(this.#t, String(e));
+		} catch {}
+	}
+	#s() {
+		if (!this.#r) return;
+		let { hide: e, show: t } = this.#i(), n = this.#n ? t : e;
+		this.#r.setAttribute("aria-label", n), this.#r.setAttribute("title", n), this.#r.setAttribute("aria-expanded", String(!this.#n));
+	}
+	#c(e) {
+		e.id ||= "doc-toc";
+		let t = document.createElement("button");
+		return t.type = "button", t.className = "clean-btn toc-toggle", t.setAttribute("aria-controls", e.id), t.addEventListener("click", () => {
+			this.#n = !this.#n, this.#o(this.#n), this.#u();
+		}), t;
+	}
+	#l(e) {
+		document.body?.classList.toggle("toc-collapsed", e);
+	}
+	#u() {
+		this.#l(this.#n), this.#s();
+	}
+	refresh() {
+		let e = document.querySelector(".theme-doc-toc-desktop");
+		if (this.#r && !this.#r.isConnected && (this.#r = null), !e) {
+			this.#r?.remove(), this.#r = null, this.#l(!1);
+			return;
+		}
+		e.parentElement?.classList.add("toc-column"), this.#r || (this.#r = this.#c(e), e.parentElement?.insertBefore(this.#r, e)), this.#u();
+	}
+	init() {
+		this.#n = this.#a(), this.#l(this.#n), window.matchMedia("(min-width: 997px)").addEventListener("change", () => window.setTimeout(() => this.refresh(), 0));
+	}
+};
+function n(e) {
+	return new t(e);
+}
+//#endregion
+export { t as TocToggle, n as createTocToggle };

package/dist/toc-toggle/client.d.ts

@@ -0,0 +1 @@
+export declare function onRouteDidUpdate(): void;

package/dist/toc-toggle/client.js

@@ -0,0 +1,9 @@
+import { createTocToggle as e } from "./TocToggle.js";
+//#region src/toc-toggle/client.ts
+var t = e();
+typeof window < "u" && t.init();
+function n() {
+	t.refresh();
+}
+//#endregion
+export { n as onRouteDidUpdate };

package/dist/toc-toggle/plugin.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `duckfn-docs-kit/toc-toggle/plugin` — wires the kit's TOC collapse control
+ * into a Docusaurus site.
+ *
+ * The button and its behaviour live in `toc-toggle/TocToggle` +
+ * `TocToggle.css`; what a site used to hand-write as a client module is now
+ * injected by this plugin, so a site's own `clientModules` only carries client
+ * code the site itself owns.
+ *
+ * This is Node-side build code: it must not import any browser module, and the
+ * browser side must not import this file (the glue it injects is
+ * `./client.ts`, resolved through the package exports map).
+ */
+/**
+ * The slice of Docusaurus' plugin API this module touches, typed structurally
+ * (like `sql/extensions.ts`) so the kit keeps zero Docusaurus dependencies.
+ */
+export interface DfkTocToggleContext {
+    siteDir: string;
+}
+export interface DfkTocTogglePlugin {
+    name: string;
+    getClientModules(): string[];
+}
+/** The plugin module Docusaurus calls with its `LoadContext` and options. */
+export type DfkTocTogglePluginModule = (context: DfkTocToggleContext) => DfkTocTogglePlugin;
+/**
+ * Builds the plugin. Usage in `docusaurus.config.ts`:
+ *
+ * ```ts
+ * import {dfkTocToggle} from 'duckfn-docs-kit/toc-toggle/plugin';
+ *
+ * plugins: [dfkTocToggle()],
+ * ```
+ */
+export declare function dfkTocToggle(): DfkTocTogglePluginModule;

package/dist/toc-toggle/plugin.js

@@ -0,0 +1,13 @@
+import { createRequire as e } from "node:module";
+import t from "node:path";
+//#region src/toc-toggle/plugin.ts
+function n() {
+	return (n) => ({
+		name: "dfk-toc-toggle",
+		getClientModules() {
+			return [e(t.join(n.siteDir, "package.json")).resolve("duckfn-docs-kit/toc-toggle/client")];
+		}
+	});
+}
+//#endregion
+export { n as dfkTocToggle };

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Value types the home-page web components accept.
+ *
+ * Every string is already resolved for the *current* locale: a custom element
+ * cannot render Docusaurus' React `<Translate>`, so the docs site resolves the
+ * copy with the imperative `translate()` API and hands plain strings to the
+ * components' `set*` methods. Internal `href`s are baseUrl-resolved by the
+ * caller (`useBaseUrl`), because a raw `<a href>` inside a custom element gets
+ * no Docusaurus prefixing.
+ *
+ * Icon fields are Iconify icon *names* (e.g. `lucide:arrow-right`), rendered by
+ * the official `<iconify-icon>` web component, which fetches the glyph from the
+ * public Iconify API. This package ships no icon data of its own.
+ */
+/** A hero call-to-action. */
+export interface HeroLink {
+    label: string;
+    href: string;
+}
+/** The secondary hero action (the GitHub button), which also carries a glyph. */
+export interface HeroAction extends HeroLink {
+    /** Iconify icon name, e.g. `simple-icons:github`. */
+    icon: string;
+}
+/** A shields.io-style badge in the hero row. Always an external link. */
+export interface HeroBadge {
+    href: string;
+    src: string;
+    alt: string;
+}
+export interface FeatureItem {
+    /** Iconify icon name, e.g. `lucide:sparkles`. */
+    icon: string;
+    title: string;
+    details: string;
+}
+export interface NextStepItem {
+    /** Already baseUrl-resolved internal path. */
+    href: string;
+    title: string;
+    details: string;
+}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "duckfn-docs-kit",
+  "version": "0.1.0",
+  "description": "Shared Docusaurus building blocks (TOC toggle, home-page web components, brand tokens, remark version placeholder) for duckfn-family extension docs sites.",
+  "license": "MIT",
+  "keywords": [
+    "duckdb",
+    "duckdb-wasm",
+    "docusaurus",
+    "documentation",
+    "web-components",
+    "remark",
+    "sql"
+  ],
+  "homepage": "https://shijianjs.github.io/duckfn/docs/docs-kit",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shijianjs/duckfn.git",
+    "directory": "duckfn-docs-kit"
+  },
+  "bugs": {
+    "url": "https://github.com/shijianjs/duckfn/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./src/*": "./src/*",
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "AGENTS.md"
+  ],
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "prepack": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@codemirror/commands": "^6.11.1",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/state": "^6.7.6",
+    "@codemirror/view": "^6.43.13",
+    "@duckdb/duckdb-wasm": "1.33.1-dev64.0",
+    "@visactor/vtable": "^1.26.8",
+    "codemirror": "^6.0.2",
+    "iconify-icon": "^3.0.3",
+    "sql-formatter": "^15.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.3",
+    "@types/react": "^19.3.0",
+    "typescript": "~7.0.2",
+    "unified": "^11.0.5",
+    "vite": "^8.3.1"
+  },
+  "engines": {
+    "node": ">=20.0"
+  }
+}