Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@examples/code-editor/package.json`:
- Line 32: Update the TypeScript dependency in package.json to match the
workspace standard by changing the "typescript" entry currently set to "5.9.2"
to "5.9.3"; locate the "typescript" dependency line in examples/code-editor's
package.json and update the version string so the project uses the repo-standard
TypeScript version.

In `@examples/code-editor/src/index.css`:
- Around line 5-9: Stylelint is flagging Tailwind v4's `@source` directive as an
unknown at-rule; update the stylelint config (the .stylelintrc.json) to allow
Tailwind directives by adding an at-rule-no-unknown rule that ignores "source"
(and also "tailwind", "apply", "layer") so files using `@source` (e.g., the
directives in examples/code-editor/src/index.css) no longer fail CI; modify
.stylelintrc.json to include "rules": { "at-rule-no-unknown": [true, {
"ignoreAtRules": ["source","tailwind","apply","layer"] }] }.

In `@examples/code-editor/src/JsonEditor.tsx`:
- Line 13: The component signature uses React.FC<JsonEditorProps> but React
isn’t imported, causing TS errors; fix by importing the React types and/or FC
from 'react' and updating the top of the file accordingly (e.g., add an import
for React or import type { FC } and use FC<JsonEditorProps>), ensuring the
JsonEditor and JsonEditorProps references resolve for the TypeScript compiler.

In `@examples/code-editor/src/SqlEditor.tsx`:
- Around line 1-4: The file uses the React.FC type (React.FC) but does not
import React; add an explicit React import at the top of SqlEditor.tsx (e.g.,
import React from 'react') so the React symbol is defined, or alternatively
remove the React. prefix and import the FC type (import type { FC } from
'react') and update the component signature accordingly; locate usages of
React.FC in this file (the SqlEditor component declaration) and apply one of
these two fixes to keep imports consistent with the component signature.

In `@examples/code-editor/vite.config.ts`:
- Around line 6-8: Introduce a Zod schema named ConfigSchema that matches the
shape passed to defineConfig (plugins: array etc.), parse the config object
using ConfigSchema.parse(...) and infer the exported type with z.infer<typeof
ConfigSchema>, then pass the parsed/typed config into defineConfig instead of
the raw object; update the export to use the parsedConfig variable and ensure
imports include z from "zod" and any needed types so the final export is export
default defineConfig(parsedConfig) with type safety via z.infer.

In `@packages/cells/src/components/InputCellContent.tsx`:
- Line 106: The EditableText instance in InputCellContent has classes "ring-0"
and "outline-none" which remove visible focus; update the component's className
to preserve an accessible focus indicator by replacing or augmenting those
styles with a focus-visible utility (e.g., add a "focus-visible:ring-2
focus-visible:ring-blue-500 focus-visible:outline-none" or equivalent) so
keyboard users see a clear focus when not actively editing; locate the
EditableText usage in InputCellContent (className on the EditableText element)
and add the focus-visible classes while keeping existing editing-focused styles
such as focus:border-blue-500 focus:ring-blue-500 intact.

In `@packages/codemirror/CHANGELOG.md`:
- Line 10: Changelog entry wording is redundant: update the line mentioning the
CodeMirrorEditor component to replace "SQL language support" with "SQL support"
so it reads "CodeMirrorEditor component with JavaScript, JSON, and SQL support";
locate the entry referencing `CodeMirrorEditor` in CHANGELOG.md and make this
phrasing change.

In `@packages/codemirror/README.md`:
- Around line 204-235: The example's MyJsonEditor initializes json state as an
object but JsonCodeMirrorEditor.onChange supplies a string (raw JSON), causing a
type mismatch; fix by making the state type and handler agree: either initialize
useState with a JSON string (e.g., JSON.stringify({...})) and keep
onChange={setJson} or keep object state and change onChange to parse the
incoming string and call setJson(JSON.parse(value)) (also handle parse errors) —
update references in MyJsonEditor, the useState call, and the
JsonCodeMirrorEditor onChange handler accordingly.

In `@packages/codemirror/src/extensions/json-schema-autocomplete.ts`:
- Around line 43-51: The computed JSON path returned by getJsonPath sometimes
already contains the current property key, so when extractValueCompletions (and
the later propertySchema lookup) resolves that key again it ends up at the wrong
schema level and returns null; fix this by normalizing the path before resolving
the property schema: when propertyName is present, strip the trailing property
segment from the path (or otherwise ensure you pass the parent path) before
calling extractValueCompletions / resolving propertySchema in the logic around
getJsonPath, getPropertyName and extractValueCompletions so the schema lookup
uses the parent object schema rather than the property key itself.

In `@packages/codemirror/src/utils/validate-json-schema.ts`:
- Around line 99-108: The issue: path segments from error.instancePath are left
as strings so findNodeAtLocation fails for array indices; fix by converting
numeric-looking segments to numbers before calling findNodeAtLocation. Update
the pathSegments creation (derived from error.instancePath) to map each segment:
if /^[0-9]+$/ then convert to Number(segment) else keep as string, then pass
that array into findNodeAtLocation(tree, pathSegments) so array items resolve
correctly; check symbols pathSegments, error.instancePath, findNodeAtLocation,
Node and tree when making the change.
- Around line 21-32: The current implementation recreates Ajv and recompiles the
schema on every lint pass (inside the hot path where `ajv`, `addFormats(ajv)`,
and `validate = ajv.compile(schema)` are executed), causing performance issues;
refactor by moving Ajv initialization and format registration out of the
per-change path and implement a cache (e.g., a Map or WeakMap) keyed by schema
identity or a stable schema hash to store compiled validators, so lookup returns
the cached `validate` function when the same schema is used and only compiles
once per unique schema.

In `@packages/data-table/src/useArrowDataTable.tsx`:
- Around line 199-200: Remove the unnecessary cast: pass parsedJson directly to
the JsonCodeMirrorEditor value prop instead of using "parsedJson as any". In the
useArrowDataTable file update the usage in the JsonCodeMirrorEditor component
(symbol: JsonCodeMirrorEditor and variable: parsedJson) so the prop is
value={parsedJson}; if TypeScript complains, tighten the parsedJson
declaration/return type where it’s produced (the JSON parsing logic in
useArrowDataTable) to be string | object to match the component's value?: string
| object signature.

In `@packages/sql-editor/src/codemirror/extensions/duckdb-completion.ts`:
- Around line 67-83: Add cancellation support by changing getFunctionSuggestions
to accept an optional signal?: AbortSignal and threading that signal into any
connector.query() calls; update the implementation in
duckdb-function-suggestions.ts (e.g., getFunctionSuggestionsImpl /
getFunctionSuggestions) to accept signal and pass { signal } to
connector.query(), then update callers in duckdb-completion.ts (where
getFunctionSuggestions is invoked) and SqlMonacoEditor.tsx to create an
AbortController per completion request and pass controller.signal, aborting
previous controllers on new requests so stale async lookups are cancelled.

In `@packages/sql-editor/src/components/DuckdbCodeMirrorEditor.tsx`:
- Around line 59-64: The memoization of currentSchemas using useMemo causes
getLatestSchemas().tableSchemas to become stale; change currentSchemas to call
getLatestSchemas() directly each render (or fall back to tableSchemas) instead
of caching its result—replace the useMemo block that defines currentSchemas with
a simple conditional that invokes getLatestSchemas() when present (referencing
getLatestSchemas and tableSchemas and the currentSchemas variable) so the
component always reads the latest schemas.

In `@packages/sql-editor/src/SqlMonacoEditor.tsx`:
- Around line 339-360: Shortcut binding for Ctrl/Cmd+Enter in SqlMonacoEditor is
registered only once using editor.onKeyDown and can become stale if onRunQuery
changes; replace the one-time bind with a controlled effect: either store the
latest onRunQuery in a ref and call that ref from a single persistent keydown
listener, or register the listener inside a useEffect that depends on onRunQuery
and disposes the previous listener on cleanup. Ensure the listener created via
editor.onKeyDown still calls editor.getModel(), editor.getSelection(),
editor.getValue(), and computes selectedValue/isSelectionEmpty as before, but
that it always invokes the current onRunQuery and properly disposes the
disposable to avoid duplicates or leaks.

---

Nitpick comments:
In `@examples/code-editor/src/EditorTypeSwitch.tsx`:
- Around line 15-31: The toggle buttons in EditorTypeSwitch (the two Button
elements that call onChange('monaco') and onChange('codemirror')) only convey
selection visually; add accessible pressed-state semantics by setting
aria-pressed on each Button to a boolean that reflects whether value ===
'monaco' (for the Monaco button) and value === 'codemirror' (for the CodeMirror
button), so screen readers get the current toggle state while preserving the
existing onClick/variant behavior.

In `@examples/code-editor/src/SqlEditor.tsx`:
- Line 42: The onChange prop in SqlEditor.tsx currently wraps the incoming
string in a redundant arrow (onChange={(value: string) => onChange(value)});
replace this with a direct reference to the handler to remove the unnecessary
wrapper — use the existing onChange prop directly (onChange={onChange}) so the
component forwards the string value without creating an extra function; update
the prop usage where the SqlEditor component renders the input/CodeEditor to
reference the onChange handler directly.

In `@packages/ai-core/src/components/PromptSuggestions.tsx`:
- Line 65: In PromptSuggestions.tsx update the conflicting Tailwind utility
strings (currently containing 'h-18 max-h-14 min-h-14 w-48 max-w-48 min-w-48')
to the cleaned, non-conflicting utilities 'h-14 w-48' in both places where these
classes appear (the className used in the PromptSuggestions component around the
occurrences noted by the reviewer), ensuring you replace both occurrences (the
one near the first block and the other at the later occurrence) so height and
width are explicit and not redundant.

In `@packages/codemirror/src/components/CodeMirrorEditor.tsx`:
- Around line 198-209: The reconfigure effect (useEffect watching extensions
that calls view.dispatch(StateEffect.reconfigure.of(extensions))) runs on
initial mount and redundantly reapplies the same extensions; add a guard flag
(e.g., an initializedRef boolean) to skip the first run: set
initializedRef.current = true when the editor is created in the initialization
effect, and in the extensions effect only call
view.dispatch(StateEffect.reconfigure.of(extensions)) if initializedRef.current
is true (and viewRef.current exists), thereby avoiding the unnecessary
reconfigure on mount.
- Around line 151-152: The extensions prop (userExtensions) passed into the
useMemo that builds the editor config (in CodeMirrorEditor) must be documented
as needing memoization or stabilized; update the JSDoc for the extensions prop
to recommend callers memoize (e.g., useMemo) and, to harden against un-memoized
callers, wrap the existing useMemo dependency (userExtensions) with a cheap
ref-based equality check inside CodeMirrorEditor (useRef + shallow/deep
comparison) so the memo only invalidates when actual extension identities
change; reference the userExtensions variable and the useMemo that includes
options.autocompletion and userExtensions when making the change.

In `@packages/codemirror/src/components/JavascriptCodeMirrorEditor.tsx`:
- Around line 19-35: The default parameter sets userExtensions = [] causing a
new array each render and busting the useMemo for extensions; remove the default
in the function signature (stop defaulting userExtensions to a new array) and
instead handle a possibly undefined value inside the useMemo (e.g., const
extensions = useMemo(() => [ javascript({jsx:true}),
createSqlroomsTheme({isDark}), ...(userExtensions ?? []) ], [userExtensions,
isDark]) ) so the dependency check and memoization work correctly while still
supporting omitted props in the JavascriptCodeMirrorEditor component.

In `@packages/codemirror/src/components/JsonCodeMirrorEditor.tsx`:
- Around line 29-57: The component currently sets a default parameter
userExtensions = [] which creates a new array each render and breaks useMemo
stability for the extensions variable; remove the "= []" default from the
function signature so userExtensions can be nullable/undefined, then inside the
useMemo (where extensions is built) use a stable expression like
...(userExtensions ?? []) to spread extensions only when provided, ensuring
useMemo can properly memoize based on the userExtensions reference; update any
TypeScript prop typing for userExtensions to allow undefined/null if necessary.

In `@packages/codemirror/src/extensions/auto-trigger.ts`:
- Around line 20-26: The iterChanges callback currently continues processing
even after a quote is found; modify update.changes.iterChanges in
auto-trigger.ts to short-circuit the callback by checking the outer boolean flag
(insertedQuote) at the start of the callback and returning early if it's already
true, so once insertedQuote is set by the /^["']$/ test no further change bodies
are processed; ensure the outer variable (insertedQuote) is declared/initialized
before calling update.changes.iterChanges and used inside the callback to skip
work.

In `@packages/sql-editor/src/codemirror/utils/keyword-docs.ts`:
- Around line 6-17: getKeywordDocs currently re-merges
commonKeywords.default.keywords and duckdbKeywords.default.keywords on every
call; add a module-level cache (e.g., let cachedKeywordDocs:
Promise<Record<string, KeywordDoc>> | null) and return it if present to avoid
repeated spreads. In getKeywordDocs, if cachedKeywordDocs is null assign it to
the Promise that imports both JSONs and returns the merged object (using
commonKeywords and duckdbKeywords), otherwise return the cached promise; this
also ensures concurrent callers share the same in-flight load. Use the existing
symbols getKeywordDocs, commonKeywords, and duckdbKeywords to locate where to
add the cache.

In `@packages/sql-editor/src/codemirror/utils/schema-converter.ts`:
- Around line 8-10: The current loop assigns namespace[table.table.table] which
can collide for identical table names across schemas/catalogs; change the key to
a fully-qualified identifier using available metadata (e.g., include
table.table.schema and/or table.table.catalog) so each entry is unique (for
example build a key from table.table.catalog + '.' + table.table.schema + '.' +
table.table.table) while keeping the value as table.columns.map(col =>
col.name); update any consumers that expect the old key format if needed.

In `@packages/sql-editor/src/components/QueryEditorPanelEditor.tsx`:
- Around line 19-21: The code is directly accessing DuckDB state via
useStoreWithSqlEditor ((s) => s.db.tables and (s) => s.db.connector); replace
those direct accesses with the package's DuckDB-specific selectors (e.g.,
useDuckDb(), useSql(), or useDuckDbQuery()) so state access is decoupled.
Specifically, change the tableSchemas selector to use the DuckDB table/schema
selector (e.g., useDuckDb() or useDuckDbQuery() to get tables) and replace
connector usage with the DuckDB connector selector (e.g., useDuckDb().connector
or the dedicated connector selector); leave runQuery (parseAndRunQuery) wired to
the sql editor selector or migrate it to useSql() if available. Ensure you
import the appropriate hook(s) and remove direct (s).db.* references in
QueryEditorPanelEditor.tsx.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/cells/eslint.config.js`:
- Around line 3-5: The file exports a flat-config array but the JSDoc uses
Linter.Config (singular); update the top JSDoc to reflect an array type such as
import("eslint").Linter.Config[] (or the appropriate FlatConfig type) so
editor/type-checker sees that export default [...] is an array of config
objects; modify the JSDoc comment above the export (the line with /** `@type`
{import("eslint").Linter.Config} */) to use the array type while leaving the
existing export default [...config,] and config identifier unchanged.

In `@packages/codemirror/src/components/JsonCodeMirrorEditor.tsx`:
- Around line 16-17: The component JsonCodeMirrorEditor currently types the prop
value as `string | object` and directly JSON.stringify()s it during render which
will throw for circular refs or non-JSON-safe values; update the prop type to a
JSON-safe type (e.g., JSONValue union: null | string | number | boolean |
JSONObject | JSONArray) or else wrap the serialization in a safeSerializer with
try/catch inside the component (e.g., in the render path where `value` is used)
to fall back to a safe representation (original string, a preview, or an
error-safe placeholder) and avoid throwing; adjust the prop/type alias and the
serialization logic used by JsonCodeMirrorEditor so any runtime serialization
failure is caught and handled gracefully.

In `@packages/duckdb-core/src/duckdb-function-utils.ts`:
- Around line 48-49: The code calls Array.from(parameters) and
Array.from(parameterTypes) which will throw if those values are null/undefined;
update the serialization in duckdb-function-utils by guarding these fields
(e.g., use parameters == null ? null : Array.from(parameters) and parameterTypes
== null ? null : Array.from(parameterTypes), or the equivalent nullish checks)
so nullable DuckDB functions without parameters remain null instead of causing a
runtime error, referencing the parameters and parameterTypes symbols to locate
the change.

In `@packages/duckdb-core/src/get-function-suggestions.ts`:
- Around line 15-33: The SQL builds a query with the variable limit interpolated
directly into connector.query, which can allow non-numeric or malicious input;
before calling connector.query (in the get-function-suggestions query block),
validate and sanitize limit by coercing to a safe integer (e.g., const safeLimit
= Math.max(1, Math.min(Number(limit) || 0, MAX_LIMIT))) or parseInt and clamp to
a reasonable MAX_LIMIT, and then use safeLimit in the SQL string (or better, use
a parameterized query for limit if connector.query supports parameters) so only
a validated numeric value is inserted into the SQL.

In `@packages/monaco-editor/src/components/MonacoEditor.tsx`:
- Line 169: Replace the non-reactive getTheme() call with the reactive
useTheme() hook so the component re-renders on theme changes: import and call
useTheme() (from theme-provider) in MonacoEditor, derive isDark from the
returned theme value (e.g., theme === 'dark'), and update the existing effect
dependency to use that reactive value (isDark or theme) instead of the one-time
getTheme() result; if you intentionally want non-reactive behavior,
alternatively document this limitation or add a consumer-facing key/refresh
mechanism to MonacoEditor.
- Around line 63-65: Update the README entry that documents the MonacoEditor
component's theme prop to include the missing 'system' option: find the Theme
type and the theme?: Theme prop in MonacoEditor (where Theme = 'dark' | 'light'
| 'system') and add 'system' to the listed supported values and any usage
examples or prop tables so the docs match the component API.

In `@packages/sql-editor/src/codemirror/extensions/completion.ts`:
- Line 19: The WeakMap completionContextByView is never populated and therefore
dead code; either remove it or populate it correctly—preferably remove the
unused declaration and any lookups that reference completionContextByView (so
the code relies on the existing local/context variable), or if the original
intent was to cache per-view CompletionContext then add logic to set
completionContextByView.set(view, ctx) whenever a view's CompletionContext is
created or updated (ensure lookups use completionContextByView.get(view)
consistently). Target symbols: completionContextByView and CompletionContext
(and any lookup that falls back to context).

In `@packages/sql-editor/src/components/FunctionDocumentation.tsx`:
- Around line 72-75: The JSX in the FunctionDocumentation component always
renders "overload" regardless of count; update the JSX that uses
moreOverloadsCount to pluralize the label (e.g., use a conditional or plural
helper: moreOverloadsCount === 1 ? 'overload' : 'overloads') so the rendered
text becomes "(+N more overload)" for 1 and "(+N more overloads)" for any other
count; locate the fragment that references moreOverloadsCount in
FunctionDocumentation.tsx and replace the static string with the conditional
pluralization.
- Around line 88-90: The current guard in the FunctionDocumentation component
that returns null when (!parameterTypes && !parameters && !returnType)
suppresses the function signature entirely; update the render logic so that when
metadata is partial/missing you still render a fallback signature using the
function name (e.g., render name() or `${name}()`), instead of returning null.
Locate the conditional in FunctionDocumentation (the block checking
parameterTypes/parameters/returnType) and replace the early return with code
that builds and renders a minimal signature from the name prop (empty parameter
list and no return type) while keeping the existing richer rendering when
metadata is present.

In `@packages/sql-editor/src/components/SqlColumnTooltip.tsx`:
- Around line 58-71: The lookup currently uses case-sensitive comparisons for
databaseName, schemaName, tableName and columnName against table.table and
column.name; change the comparisons in the loop (the checks that reference
databaseName, schemaName, tableName and the column lookup that uses
table.columns.find) to perform case-insensitive matching (e.g., normalize both
sides with toLowerCase() or a locale-insensitive compare) so that identifiers
are matched regardless of casing; ensure you handle potential undefined values
safely before normalizing.

In `@packages/sql-editor/src/components/SqlTableTooltip.tsx`:
- Line 16: The table lookup in SqlTableTooltip.tsx currently uses
tables.find((table) => table.table.table === tableName) which fails for schema-
or db-qualified names; parse the incoming qualified tableName (from data.word)
into database/schema/table components (like SqlColumnTooltip.tsx does) or reuse
its findTable-style logic, then match against table.table.database,
table.table.schema and table.table.table (or the equivalent properties) to
locate the correct entry; update the tables.find call and any dependent variable
names to use the parsed parts so qualified names resolve correctly.

---

Outside diff comments:
In `@packages/sql-editor/src/components/QueryEditorPanelEditor.tsx`:
- Around line 27-33: The change handler handleUpdateQuery currently ignores
empty-string updates due to the guard "if (!value) return", so clearing the
SqlCodeMirrorEditor (which emits '') won't update the controlled query; remove
or change that falsy check to allow '' (e.g., check for value === undefined or
value == null instead) and ensure you still call updateQueryText(queryId, value)
when value is '' ; apply the same fix to the other analogous update handler in
this file that uses the same falsy guard so empty-string editor clears are
propagated.

In `@packages/sql-editor/src/SqlMonacoEditor.tsx`:
- Around line 165-198: The autocomplete currently pushes static DUCKDB functions
(the variable/functions array) and then pushes connector-enriched functions from
getFunctionSuggestions when ctx.connector exists, causing duplicates; fix by
deduplicating by label before pushing: when ctx.connector is present call
getFunctionSuggestions(ctx.connector, word.word) first, collect the returned
names into a Set (e.g., connectorNames), then when iterating the static
functions array (functions) skip any func whose label/name exists in
connectorNames (or vice-versa choose to skip the static branch entirely if
connector results are non-empty); ensure this logic is applied around the
suggestions.push blocks so only unique labels are added.

---

Duplicate comments:
In `@packages/sql-editor/src/SqlCodeMirrorEditor.tsx`:
- Around line 58-64: The memoization of getLatestSchemas in the currentSchemas
useMemo freezes tableSchemas when the getLatestSchemas callback identity is
stable, causing stale completions/hover info; change currentSchemas to call
getLatestSchemas() (or prefer getLatestSchemas().tableSchemas) on each render
when getLatestSchemas is provided instead of caching it in useMemo, or include
tableSchemas and any dynamic values returned by getLatestSchemas in the
dependency array so currentSchemas always reflects updated schemas (update the
useMemo/logic around getLatestSchemas and tableSchemas in
SqlCodeMirrorEditor.tsx accordingly).

In `@packages/sql-editor/src/SqlMonacoEditor.tsx`:
- Around line 354-375: The keyboard shortcut handler registered via
editor.onKeyDown captures a stale onRunQuery closure because it's only added
once at mount; update the registration so the listener always uses the latest
onRunQuery by either (a) moving the editor.onKeyDown registration into a
useEffect that depends on onRunQuery and disposes the previous listener on
cleanup, or (b) keep a stable handler that reads a ref to the current
onRunQuery; ensure you call dispose() on the returned disposable when unmounting
or when onRunQuery changes so editor.onKeyDown doesn't call an outdated or
undefined callback (refer to editor.onKeyDown, onRunQuery, editor.getModel,
editor.getSelection).

---

Nitpick comments:
In `@packages/codemirror/src/components/JavascriptCodeMirrorEditor.tsx`:
- Around line 29-35: The options merging is redundant and order-sensitive:
remove the per-key nullish coalescing and instead supply sensible defaults
first, then spread the incoming options (e.g., set default lineNumbers: false,
lineWrapping: true, foldGutter: false, ...options) so user options override
defaults; if autocompletion must be forced true, place autocompletion after the
spread (or if it should be user-configurable leave it before the spread). Update
the options object in JavascriptCodeMirrorEditor (the options prop construction)
accordingly.

In `@packages/codemirror/src/components/JsonCodeMirrorEditor.tsx`:
- Around line 41-49: The unconditional autoTriggerOnQuote() causes
startCompletion() to fire with no completion source when
jsonSchemaAutocomplete(schema) isn't registered; update the extensions assembly
so autoTriggerOnQuote() is only included when either a schema is provided
(jsonSchemaAutocomplete(schema) is present) or when userExtensions contains an
explicit completion provider. Concretely, inside the component where extensions
are built, wrap autoTriggerOnQuote() behind a condition: include it if schema is
truthy OR if a helper check (e.g., hasCompletionExtension(userExtensions))
detects a completion-related extension in userExtensions (match on known
completion extension shapes or metadata), otherwise omit autoTriggerOnQuote().

In `@packages/sql-editor/src/codemirror/extensions/completion.ts`:
- Around line 56-59: The completion popup currently sets unsafe HTML by
assigning renderComponentToString(FunctionDocumentation...) to dom.innerHTML;
instead, change this to a DOM-based render like in hover.ts: create a container
element (or DocumentFragment), programmatically build or mount the
FunctionDocumentation markup as DOM nodes (using the same helper used in
hover.ts), and append those nodes to the existing dom variable instead of
assigning innerHTML; update the code around the const dom and
renderComponentToString(FunctionDocumentation, { functions: overloads }) call to
produce and attach safe DOM children (or use the hover.ts DOM-render helper) to
avoid injecting raw HTML.

In `@packages/sql-editor/src/codemirror/extensions/hover.ts`:
- Around line 50-54: Replace the unsafe innerHTML assignment that uses
renderComponentToString by mounting the React component into the tooltip DOM
using React's createRoot API: create a DOM element (dom), call
createRoot(dom).render with the FunctionDocumentation component and its
functions prop (functionGroup.overloads), import createRoot from
'react-dom/client', and ensure you track the created root to call root.unmount
when the tooltip is removed so we don't leak mounts; this replaces
renderComponentToString + dom.innerHTML and prevents XSS via string HTML
injection.

In `@packages/sql-editor/src/codemirror/themes/sql-tooltip-theme.ts`:
- Around line 9-25: The theme boolean is captured once by getTheme() in
createSqlTooltipTheme(), so EditorView.theme(..., {dark: theme === 'dark'}) will
become stale if the user toggles light/dark; to fix, stop baking the dark flag
into the extension—remove the second argument (or pass no {dark: ...}) from the
EditorView.theme call so the tooltip styling relies on CSS variables;
alternatively, if you prefer explicit reactivity, recreate the extension when
getTheme() changes (i.e., regenerate createSqlTooltipTheme() and reconfigure the
editor) rather than using a single captured theme value.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@examples/code-editor/src/SqlEditor.tsx`:
- Around line 68-80: The Monaco branch is not passing the onRunQuery callback to
SqlMonacoEditor, so Cmd/Ctrl+Enter works only in SqlCodeMirrorEditor; update the
monaco return to forward the onRunQuery prop (the same function passed to
SqlCodeMirrorEditor) into the SqlMonacoEditor component so its built-in
Cmd/Ctrl+Enter handler can invoke it (ensure the prop name onRunQuery and the
handler signature match the existing SqlMonacoEditor implementation).

In `@packages/sql-editor/src/SqlMonacoEditor.tsx`:
- Around line 361-382: The keyboard handler registered via editor.onKeyDown
closes over the stale onRunQuery prop; update the handler to call
onRunQueryRef.current(...) instead of onRunQuery, and remove onRunQuery from the
handleEditorDidMount dependency array so updates are driven by the ref; also
capture the disposable returned by editor.onKeyDown (in handleEditorDidMount)
and ensure you dispose it when unmounting or before re-registering to avoid
duplicate listeners.

In `@packages/sql-editor/src/utils/qualified-name-parser.ts`:
- Around line 83-129: findTableAndColumn currently treats a bare columnName as
"first match wins", causing ambiguous results when multiple tables contain the
same column; change the logic in findTableAndColumn to collect all matching
{table, column} pairs (searching tables by columnName using the existing
localeCompare logic) and if more than one match is found when
tableName/schemaName/databaseName are all undefined, return undefined (only
return the single match if matches.length === 1). Use the existing symbols
DataTable, TableColumn, columnName, tableName, schemaName, databaseName and the
function findTableAndColumn to locate where to replace the one-pass return with
the collection-and-disambiguation approach.

---

Duplicate comments:
In `@examples/code-editor/src/SqlEditor.tsx`:
- Around line 22-25: The nested qualified table objects are missing their schema
and have incorrect toString values; update the inner table object so its schema
is set to 'main' (i.e., populate table.table.schema = 'main') and change the
toString() implementations to return the fully qualified name ('main.users' and
the other table's 'main.<name>') so consumers receive a complete
QualifiedTableName; apply this change for the table object at the shown location
and the similar table object at lines 39-42.

---

Nitpick comments:
In `@packages/duckdb-core/src/get-function-suggestions.ts`:
- Around line 44-45: The current export uses memoizeOnce which only caches the
last call, causing frequent cache misses as users type; replace this with an
LRU-style memoization keyed by the function input (wordBeforeCursor) so previous
partial-query results are retained; update the export of getFunctionSuggestions
to wrap getFunctionSuggestionsImpl with an LRU memoizer (e.g., memoizeLRU or
lru-cache) with a small bounded size (e.g., 32–100) and appropriate keying based
on the wordBeforeCursor parameter to avoid unbounded memory growth and improve
autocomplete responsiveness.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/codemirror/src/utils/validate-json-schema.ts`:
- Around line 5-10: Update the JSDoc for the validateJsonSchema function to
reflect the current signature: replace the outdated `@param` schema entry with
`@param` validate - the precompiled ValidateFunction (from ajv) used to validate
the JSON text; keep the `@param` text description and the `@returns` description,
and ensure types and wording mention that validation uses the provided
ValidateFunction rather than a schema object. Reference the function name
validateJsonSchema and the parameter validate: ValidateFunction when making the
change.
- Around line 142-149: The pathSegments construction is not decoding JSON
Pointer escape sequences (~0 and ~1) per RFC 6901, so properties with '/' or '~'
in their names won't be resolved; update the mapping for error.instancePath to
first replace "~1" with "/" and "~0" with "~" on each segment (before numeric
conversion), then parseInt and convert numeric strings to numbers as currently
done; reference the error.instancePath split/map block (pathSegments) and ensure
the replace order is "~1" then "~0" to correctly decode pointers.

---

Nitpick comments:
In `@packages/codemirror/src/utils/validate-json-schema.ts`:
- Around line 53-55: The current extraction of the JSON parse error position
relies solely on the V8-specific regex /position (\d+)/ using error.message,
which can fail on other engines; update the logic around error, error.message,
errorMatch and position to try multiple sources and patterns: first check
structured fields like (error as any).loc?.start?.column, (error as
any).lineNumber or (error as any).columnNumber, then try several regexes (e.g.,
/position (\d+)/, /at position (\d+)/i, /char (\d+)/, /column (\d+)/i) against
error.message and parseInt the match, and only then fall back to 0; ensure you
update the code that sets position (the position constant) to use this
prioritized extraction sequence so non‑V8 engines get more accurate locations.

In `@packages/vega/src/editor/VegaCodeMirrorEditor.tsx`:
- Around line 33-42: The effect in VegaCodeMirrorEditor that calls
loadVegaLiteSchema and then setSchema can call setState after unmount; update
the useEffect to add a mounted/aborted flag (e.g., let isMounted = true) before
awaiting loadVegaLiteSchema, check the flag before calling setSchema, and set
the flag to false in the cleanup function returned by useEffect; reference the
useEffect block that calls loadVegaLiteSchema and the setSchema state setter
when applying the change.

In `@packages/vega/src/editor/VegaSpecEditorPanel.tsx`:
- Around line 19-32: The JSDoc for VegaSpecEditorPanel incorrectly mentions
"Monaco editor"; update the comment to reflect the CodeMirror migration by
replacing references to "Monaco editor" with "CodeMirror editor" and adjust any
wording that implies Monaco-specific behavior; update the example reference if
it mentions editor-specific props—target the VegaSpecEditorPanel component and
the VegaLiteChart.SpecEditor mention in the comment.