@open-pencil/cli 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-pencil/cli",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -19,12 +19,12 @@
     "provenance": true
   },
   "dependencies": {
+    "@open-pencil/core": "^0.10.0",
     "agentfmt": "^0.1.3",
     "canvaskit-wasm": "^0.40.0",
-    "citty": "^0.1.6",
-    "@open-pencil/core": "0.8.0"
+    "citty": "^0.1.6"
   },
   "devDependencies": {
     "@types/bun": "^1.2.9"
   }
-}
+}

package/src/commands/analyze/clusters.ts

@@ -9,7 +9,7 @@ import type { AnalyzeClustersResult } from '@open-pencil/core'
 
 function calcConfidence(nodes: Array<{ width: number; height: number; childCount: number }>): number {
   if (nodes.length < 2) return 100
-  const base = nodes[0]!
+  const base = nodes[0]
   let score = 0
   for (const node of nodes.slice(1)) {
     const sizeDiff = Math.abs(node.width - base.width) + Math.abs(node.height - base.height)
@@ -24,7 +24,7 @@ function calcConfidence(nodes: Array<{ width: number; height: number; childCount
 
 function formatSignature(sig: string): string {
   const [typeSize, children] = sig.split('|')
-  const type = typeSize?.split(':')[0]
+  const type = typeSize.split(':')[0]
   if (!type) return sig
   const typeName = type.charAt(0) + type.slice(1).toLowerCase()
   if (!children) return typeName
@@ -73,7 +73,7 @@ export default defineCommand({
     console.log('')
 
     const items = data.clusters.map((c) => {
-      const first = c.nodes[0]!
+      const first = c.nodes[0]
       const confidence = calcConfidence(c.nodes)
 
       const widths = c.nodes.map((n) => n.width)
@@ -102,10 +102,11 @@ export default defineCommand({
 
     const clusteredNodes = data.clusters.reduce((sum, c) => sum + c.nodes.length, 0)
     console.log('')
-    console.log(
-      fmtSummary({ clusters: data.clusters.length }) +
-        ` from ${data.totalNodes} nodes (${clusteredNodes} clustered)`
-    )
+    console.log(fmtSummary({
+      clusters: data.clusters.length,
+      'total nodes': data.totalNodes,
+      clustered: clusteredNodes
+    }))
     console.log('')
   }
 })

package/src/commands/analyze/typography.ts

@@ -91,7 +91,7 @@ export default defineCommand({
     }
 
     console.log('')
-    console.log(fmtSummary({ 'unique styles': data.styles.length }) + ` from ${data.totalTextNodes} text nodes`)
+    console.log(fmtSummary({ 'unique styles': data.styles.length, 'text nodes': data.totalTextNodes }))
     console.log('')
   }
 })

package/src/commands/eval.ts

@@ -6,9 +6,17 @@ import { loadDocument } from '../headless'
 import { isAppMode, requireFile, rpc } from '../app-client'
 import { printError } from '../format'
 
+function printResult(value: unknown, json: boolean) {
+  if (json || !process.stdout.isTTY) {
+    console.log(JSON.stringify(value, null, 2))
+  } else {
+    console.log(value)
+  }
+}
+
 function serializeResult(value: unknown): unknown {
   if (value === undefined || value === null) return value
-  if (typeof value === 'object' && value !== null && 'toJSON' in value && typeof value.toJSON === 'function') {
+  if (typeof value === 'object' && 'toJSON' in value && typeof value.toJSON === 'function') {
     return value.toJSON()
   }
   if (Array.isArray(value)) return value.map(serializeResult)
@@ -22,7 +30,7 @@ export default defineCommand({
     code: { type: 'string', alias: 'c', description: 'JavaScript code to execute' },
     stdin: { type: 'boolean', description: 'Read code from stdin' },
     write: { type: 'boolean', alias: 'w', description: 'Write changes back to the input file' },
-    output: { type: 'string', alias: 'o', description: 'Write to a different file' },
+    output: { type: 'string', alias: 'o', description: 'Write to a different file', required: false },
     json: { type: 'boolean', description: 'Output as JSON' },
     quiet: { type: 'boolean', alias: 'q', description: 'Suppress output' },
   },
@@ -41,13 +49,9 @@ export default defineCommand({
     }
 
     if (isAppMode(args.file)) {
-      const result = await rpc<unknown>('eval', { code })
+      const result = await rpc('eval', { code })
       if (!args.quiet && result !== undefined && result !== null) {
-        if (args.json || !process.stdout.isTTY) {
-          console.log(JSON.stringify(result, null, 2))
-        } else {
-          console.log(result)
-        }
+        printResult(result, !!args.json)
       }
       return
     }
@@ -56,6 +60,7 @@ export default defineCommand({
     const graph = await loadDocument(file)
     const figma = new FigmaAPI(graph)
 
+    // eslint-disable-next-line no-empty-function -- needed to get AsyncFunction constructor
     const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
     const wrappedCode = code.trim().startsWith('return')
       ? code
@@ -71,17 +76,12 @@ export default defineCommand({
     }
 
     if (!args.quiet && result !== undefined) {
-      const serialized = serializeResult(result)
-      if (args.json || !process.stdout.isTTY) {
-        console.log(JSON.stringify(serialized, null, 2))
-      } else {
-        console.log(serialized)
-      }
+      printResult(serializeResult(result), !!args.json)
     }
 
     if (args.write || args.output) {
       const { exportFigFile } = await import('@open-pencil/core')
-      const outPath = args.output ?? file
+      const outPath = args.output ? args.output : file
       const data = await exportFigFile(graph)
       await Bun.write(outPath, new Uint8Array(data))
       if (!args.quiet) {

package/src/commands/export.ts

@@ -3,7 +3,7 @@ import { basename, extname, resolve } from 'node:path'
 
 import { renderNodesToSVG, sceneNodeToJSX, selectionToJSX } from '@open-pencil/core'
 
-import { loadDocument, loadFonts, exportNodes, exportThumbnail } from '../headless'
+import { loadDocument, exportNodes, exportThumbnail } from '../headless'
 import { isAppMode, requireFile, rpc } from '../app-client'
 import { ok, printError } from '../format'
 import type { ExportFormat, JSXFormat } from '@open-pencil/core'
@@ -12,16 +12,108 @@ const RASTER_FORMATS = ['PNG', 'JPG', 'WEBP']
 const ALL_FORMATS = [...RASTER_FORMATS, 'SVG', 'JSX']
 const JSX_STYLES = ['openpencil', 'tailwind']
 
+interface ExportArgs {
+  file?: string
+  output?: string
+  format: string
+  scale: string
+  quality?: string
+  page?: string
+  node?: string
+  style: string
+  thumbnail?: boolean
+  width: string
+  height: string
+}
+
+async function writeAndLog(path: string, content: string | Uint8Array) {
+  await Bun.write(path, content)
+  const size = typeof content === 'string' ? content.length : content.length
+  console.log(ok(`Exported ${path} (${(size / 1024).toFixed(1)} KB)`))
+}
+
+async function exportViaApp(format: string, args: ExportArgs) {
+  if (format === 'SVG') {
+    const result = await rpc<{ svg: string }>('tool', { name: 'export_svg', args: { ids: args.node ? [args.node] : undefined } })
+    if (!result.svg) { printError('Nothing to export.'); process.exit(1) }
+    await writeAndLog(resolve(args.output ?? 'export.svg'), result.svg)
+    return
+  }
+
+  if (format === 'JSX') {
+    const result = await rpc<{ jsx: string }>('export_jsx', { nodeIds: args.node ? [args.node] : undefined, style: args.style })
+    if (!result.jsx) { printError('Nothing to export.'); process.exit(1) }
+    await writeAndLog(resolve(args.output ?? 'export.jsx'), result.jsx)
+    return
+  }
+
+  const result = await rpc<{ base64: string }>('export', {
+    nodeIds: args.node ? [args.node] : undefined,
+    scale: Number(args.scale),
+    format: format.toLowerCase()
+  })
+  const data = Uint8Array.from(atob(result.base64), (c) => c.charCodeAt(0))
+  const ext = format.toLowerCase() === 'jpg' ? 'jpg' : format.toLowerCase()
+  await writeAndLog(resolve(args.output ?? `export.${ext}`), data)
+}
+
+async function exportFromFile(format: string, args: ExportArgs) {
+  const file = requireFile(args.file)
+  const graph = await loadDocument(file)
+
+  const pages = graph.getPages()
+  const page = args.page ? pages.find((p) => p.name === args.page) : pages[0]
+  if (!page) { printError(`Page "${args.page}" not found.`); process.exit(1) }
+
+  const defaultName = basename(file, extname(file))
+
+  if (format === 'JSX') {
+    const nodeIds = args.node ? [args.node] : page.childIds
+    const jsxStr = nodeIds.length === 1
+      ? sceneNodeToJSX(nodeIds[0], graph, args.style as JSXFormat)
+      : selectionToJSX(nodeIds, graph, args.style as JSXFormat)
+    if (!jsxStr) { printError('Nothing to export (empty page or no visible nodes).'); process.exit(1) }
+    await writeAndLog(resolve(args.output ?? `${defaultName}.jsx`), jsxStr)
+    return
+  }
+
+  const ext = format.toLowerCase() === 'jpg' ? 'jpg' : format.toLowerCase()
+  const output = resolve(args.output ?? `${defaultName}.${ext}`)
+
+  if (format === 'SVG') {
+    const nodeIds = args.node ? [args.node] : page.childIds
+    const svgStr = renderNodesToSVG(graph, page.id, nodeIds)
+    if (!svgStr) { printError('Nothing to export (empty page or no visible nodes).'); process.exit(1) }
+    await writeAndLog(output, svgStr)
+    return
+  }
+
+  let data: Uint8Array | null
+  if (args.thumbnail) {
+    data = await exportThumbnail(graph, page.id, Number(args.width), Number(args.height))
+  } else {
+    const nodeIds = args.node ? [args.node] : page.childIds
+    data = await exportNodes(graph, page.id, nodeIds, {
+      scale: Number(args.scale),
+      format: format as ExportFormat,
+      quality: args.quality ? Number(args.quality) : undefined
+    })
+  }
+
+  if (!data) { printError('Nothing to export (empty page or no visible nodes).'); process.exit(1) }
+  await writeAndLog(output, data)
+}
+
 export default defineCommand({
   meta: { description: 'Export a .fig file to PNG, JPG, WEBP, SVG, or JSX' },
   args: {
     file: { type: 'positional', description: '.fig file path (omit to connect to running app)', required: false },
-    output: { type: 'string', alias: 'o', description: 'Output file path (default: <name>.<format>)' },
+    output: { type: 'string', alias: 'o', description: 'Output file path (default: <name>.<format>)', required: false },
     format: { type: 'string', alias: 'f', description: 'Export format: png, jpg, webp, svg, jsx (default: png)', default: 'png' },
     scale: { type: 'string', alias: 's', description: 'Export scale (default: 1)', default: '1' },
-    quality: { type: 'string', alias: 'q', description: 'Quality 0-100 for JPG/WEBP (default: 90)' },
-    page: { type: 'string', description: 'Page name (default: first page)' },
-    node: { type: 'string', description: 'Node ID to export (default: all top-level nodes)' },
+    quality: { type: 'string', alias: 'q', description: 'Quality 0-100 for JPG/WEBP (default: 90)', required: false },
+    page: { type: 'string', description: 'Page name (default: first page)', required: false },
+    node: { type: 'string', description: 'Node ID to export (default: all top-level nodes)', required: false },
     style: { type: 'string', description: 'JSX style: openpencil, tailwind (default: openpencil)', default: 'openpencil' },
     thumbnail: { type: 'boolean', description: 'Export page thumbnail instead of full render' },
     width: { type: 'string', description: 'Thumbnail width (default: 1920)', default: '1920' },
@@ -40,114 +132,9 @@ export default defineCommand({
     }
 
     if (isAppMode(args.file)) {
-      if (format === 'SVG') {
-        const result = await rpc<{ svg: string }>('tool', { name: 'export_svg', args: { ids: args.node ? [args.node] : undefined } })
-        if (!result.svg) {
-          printError('Nothing to export.')
-          process.exit(1)
-        }
-        const output = resolve(args.output ?? 'export.svg')
-        await Bun.write(output, result.svg)
-        console.log(ok(`Exported ${output} (${(result.svg.length / 1024).toFixed(1)} KB)`))
-        return
-      }
-
-      if (format === 'JSX') {
-        const result = await rpc<{ jsx: string }>('export_jsx', {
-          nodeIds: args.node ? [args.node] : undefined,
-          style: args.style
-        })
-        if (!result.jsx) {
-          printError('Nothing to export.')
-          process.exit(1)
-        }
-        const output = resolve(args.output ?? 'export.jsx')
-        await Bun.write(output, result.jsx)
-        console.log(ok(`Exported ${output} (${(result.jsx.length / 1024).toFixed(1)} KB)`))
-        return
-      }
-
-      const result = await rpc<{ base64: string }>('export', {
-        nodeIds: args.node ? [args.node] : undefined,
-        scale: Number(args.scale),
-        format: format.toLowerCase()
-      })
-      const data = Uint8Array.from(atob(result.base64), (c) => c.charCodeAt(0))
-      const ext = format.toLowerCase() === 'jpg' ? 'jpg' : format.toLowerCase()
-      const output = resolve(args.output ?? `export.${ext}`)
-      await Bun.write(output, data)
-      console.log(ok(`Exported ${output} (${(data.length / 1024).toFixed(1)} KB)`))
-      return
-    }
-
-    const file = requireFile(args.file)
-    const graph = await loadDocument(file)
-    await loadFonts(graph)
-
-    const pages = graph.getPages()
-    const page = args.page
-      ? pages.find((p) => p.name === args.page)
-      : pages[0]
-
-    if (!page) {
-      printError(`Page "${args.page}" not found.`)
-      process.exit(1)
-    }
-
-    const defaultName = basename(file, extname(file))
-
-    if (format === 'JSX') {
-      const jsxFormat = args.style as JSXFormat
-      const nodeIds = args.node ? [args.node] : page.childIds
-      const jsxStr = nodeIds.length === 1
-        ? sceneNodeToJSX(nodeIds[0], graph, jsxFormat)
-        : selectionToJSX(nodeIds, graph, jsxFormat)
-
-      if (!jsxStr) {
-        printError('Nothing to export (empty page or no visible nodes).')
-        process.exit(1)
-      }
-
-      const output = resolve(args.output ?? `${defaultName}.jsx`)
-      await Bun.write(output, jsxStr)
-      console.log(ok(`Exported ${output} (${(jsxStr.length / 1024).toFixed(1)} KB)`))
-      return
-    }
-
-    const ext = format.toLowerCase() === 'jpg' ? 'jpg' : format.toLowerCase()
-    const output = resolve(args.output ?? `${defaultName}.${ext}`)
-
-    if (format === 'SVG') {
-      const nodeIds = args.node ? [args.node] : page.childIds
-      const svgStr = renderNodesToSVG(graph, page.id, nodeIds)
-      if (!svgStr) {
-        printError('Nothing to export (empty page or no visible nodes).')
-        process.exit(1)
-      }
-      await Bun.write(output, svgStr)
-      console.log(ok(`Exported ${output} (${(svgStr.length / 1024).toFixed(1)} KB)`))
-      return
-    }
-
-    let data: Uint8Array | null
-
-    if (args.thumbnail) {
-      data = await exportThumbnail(graph, page.id, Number(args.width), Number(args.height))
+      await exportViaApp(format, args)
     } else {
-      const nodeIds = args.node ? [args.node] : page.childIds
-      data = await exportNodes(graph, page.id, nodeIds, {
-        scale: Number(args.scale),
-        format,
-        quality: args.quality ? Number(args.quality) : undefined
-      })
+      await exportFromFile(format, args)
     }
-
-    if (!data) {
-      printError('Nothing to export (empty page or no visible nodes).')
-      process.exit(1)
-    }
-
-    await Bun.write(output, data)
-    console.log(ok(`Exported ${output} (${(data.length / 1024).toFixed(1)} KB)`))
   }
 })

package/src/commands/find.ts

@@ -2,7 +2,7 @@ import { defineCommand } from 'citty'
 
 import { loadDocument } from '../headless'
 import { isAppMode, requireFile, rpc } from '../app-client'
-import { fmtList, printError, bold, entity, formatType } from '../format'
+import { fmtList, bold, entity, formatType } from '../format'
 import { executeRpcCommand } from '@open-pencil/core'
 
 import type { FindNodeResult } from '@open-pencil/core'

package/src/commands/node.ts

@@ -5,7 +5,7 @@ import { isAppMode, requireFile, rpc } from '../app-client'
 import { fmtNode, printError, formatType } from '../format'
 import { executeRpcCommand, colorToHex } from '@open-pencil/core'
 
-import type { NodeResult } from '@open-pencil/core'
+import type { Color, NodeResult } from '@open-pencil/core'
 
 async function getData(file: string | undefined, id: string): Promise<NodeResult | { error: string }> {
   if (isAppMode(file)) return rpc<NodeResult>('node', { id })
@@ -47,7 +47,7 @@ export default defineCommand({
     if (data.parent) details.parent = `${data.parent.name} (${data.parent.id})`
     if (data.text) details.text = data.text
     if (data.fills.length > 0) {
-      const solid = (data.fills as Array<{ type: string; visible: boolean; color: { r: number; g: number; b: number; a: number }; opacity: number }>)
+      const solid = (data.fills as Array<{ type: string; visible: boolean; color: Color; opacity: number }>)
         .find((f) => f.type === 'SOLID' && f.visible)
       if (solid) {
         const hex = colorToHex(solid.color)

package/src/commands/pages.ts

@@ -2,7 +2,7 @@ import { defineCommand } from 'citty'
 
 import { loadDocument } from '../headless'
 import { isAppMode, requireFile, rpc } from '../app-client'
-import { bold, fmtList, entity, formatType } from '../format'
+import { bold, fmtList, entity } from '../format'
 
 import type { PageItem } from '@open-pencil/core'
 import { executeRpcCommand } from '@open-pencil/core'

package/src/commands/query.ts

@@ -0,0 +1,90 @@
+import { defineCommand } from 'citty'
+
+import { loadDocument } from '../headless'
+import { isAppMode, requireFile, rpc } from '../app-client'
+import { fmtList, printError, bold, entity, formatType } from '../format'
+import { executeRpcCommand } from '@open-pencil/core'
+
+import type { QueryNodeResult } from '@open-pencil/core'
+
+async function getData(
+  file: string | undefined,
+  args: { selector: string; page?: string; limit?: string }
+): Promise<QueryNodeResult[] | { error: string }> {
+  const rpcArgs = {
+    selector: args.selector,
+    page: args.page,
+    limit: args.limit ? Number(args.limit) : undefined
+  }
+  if (isAppMode(file)) return rpc<QueryNodeResult[]>('query', rpcArgs)
+  const graph = await loadDocument(requireFile(file))
+  return await executeRpcCommand(graph, 'query', rpcArgs) as QueryNodeResult[] | { error: string }
+}
+
+export default defineCommand({
+  meta: {
+    description: `Query nodes using XPath selectors
+
+Examples:
+  open-pencil query file.fig "//FRAME"                              # All frames
+  open-pencil query file.fig "//FRAME[@width < 300]"                # Frames narrower than 300px
+  open-pencil query file.fig "//COMPONENT[starts-with(@name, 'Button')]"  # Components starting with Button
+  open-pencil query file.fig "//SECTION/FRAME"                      # Direct frame children of sections
+  open-pencil query file.fig "//SECTION//TEXT"                       # All text inside sections
+  open-pencil query file.fig "//*[@cornerRadius > 0]"               # Any node with corner radius`
+  },
+  args: {
+    file: {
+      type: 'positional',
+      description: '.fig file path (omit to connect to running app)',
+      required: false
+    },
+    selector: {
+      type: 'positional',
+      description:
+        'XPath selector (e.g., //FRAME[@width < 300], //TEXT[contains(@name, "Label")])',
+      required: true
+    },
+    page: { type: 'string', description: 'Page name (default: all pages)' },
+    limit: { type: 'string', description: 'Max results (default: 1000)', default: '1000' },
+    json: { type: 'boolean', description: 'Output as JSON' }
+  },
+  async run({ args }) {
+    const results = await getData(args.file, {
+      selector: args.selector,
+      page: args.page,
+      limit: args.limit
+    })
+
+    if ('error' in results) {
+      printError(results.error)
+      process.exit(1)
+    }
+
+    if (args.json) {
+      console.log(JSON.stringify(results, null, 2))
+      return
+    }
+
+    if (results.length === 0) {
+      console.log('No nodes found.')
+      return
+    }
+
+    console.log('')
+    console.log(bold(`  Found ${results.length} node${results.length > 1 ? 's' : ''}`))
+    console.log('')
+    console.log(
+      fmtList(
+        results.map((n) => ({
+          header: entity(
+            formatType(n.type),
+            `${n.name}  ${n.width}×${n.height}`,
+            n.id
+          )
+        }))
+      )
+    )
+    console.log('')
+  }
+})

package/src/commands/variables.ts

@@ -2,7 +2,7 @@ import { defineCommand } from 'citty'
 
 import { loadDocument } from '../headless'
 import { isAppMode, requireFile, rpc } from '../app-client'
-import { bold, fmtList, fmtSummary } from '../format'
+import { bold, entity, fmtList, fmtSummary } from '../format'
 import { executeRpcCommand } from '@open-pencil/core'
 
 import type { VariablesResult } from '@open-pencil/core'
@@ -38,7 +38,7 @@ export default defineCommand({
     console.log('')
 
     for (const coll of data.collections) {
-      console.log(bold(`  ${coll.name}`) + ` (${coll.modes.join(', ')})`)
+      console.log(bold(entity(coll.name, coll.modes.join(', '))))
       console.log('')
       console.log(
         fmtList(

package/src/format.ts

@@ -48,7 +48,7 @@ export function formatBox(node: SceneNode): string {
 function formatFill(node: SceneNode): string | null {
   if (!node.fills.length) return null
   const solid = node.fills.find((f) => f.type === 'SOLID' && f.visible)
-  if (!solid || solid.type !== 'SOLID') return null
+  if (!solid?.color) return null
   const { r, g, b } = solid.color
   const hex = '#' + [r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')
   return solid.opacity < 1 ? `${hex} ${Math.round(solid.opacity * 100)}%` : hex
@@ -56,7 +56,7 @@ function formatFill(node: SceneNode): string | null {
 
 function formatStroke(node: SceneNode): string | null {
   if (!node.strokes.length) return null
-  const s = node.strokes[0]!
+  const s = node.strokes[0]
   const { r, g, b } = s.color
   const hex = '#' + [r, g, b].map((c) => Math.round(c * 255).toString(16).padStart(2, '0')).join('')
   return `${hex} ${s.weight}px`

package/src/headless.ts

@@ -1,27 +1,14 @@
-import CanvasKitInit from 'canvaskit-wasm/full'
-import type { CanvasKit } from 'canvaskit-wasm'
 import {
   parseFigFile,
-  SceneGraph,
-  SkiaRenderer,
+  initCanvasKit,
+  type SceneGraph,
+  type ExportFormat,
   computeAllLayouts,
-  loadFont,
-  renderNodesToImage,
-  renderThumbnail
+  headlessRenderNodes,
+  headlessRenderThumbnail
 } from '@open-pencil/core'
-import type { ExportFormat } from '@open-pencil/core'
 
-let ck: CanvasKit | null = null
-
-export async function initCanvasKit(): Promise<CanvasKit> {
-  if (ck) return ck
-  const ckPath = import.meta.resolve('canvaskit-wasm/full')
-  const binDir = new URL('.', ckPath).pathname
-  ck = await CanvasKitInit({
-    locateFile: (file) => binDir + file
-  })
-  return ck
-}
+export { initCanvasKit }
 
 export async function loadDocument(filePath: string): Promise<SceneGraph> {
   const data = await Bun.file(filePath).arrayBuffer()
@@ -30,38 +17,13 @@ export async function loadDocument(filePath: string): Promise<SceneGraph> {
   return graph
 }
 
-export async function loadFonts(graph: SceneGraph): Promise<void> {
-  const families = new Set<string>()
-  for (const node of graph.getAllNodes()) {
-    if (node.fontFamily) families.add(node.fontFamily)
-  }
-  for (const family of families) {
-    await loadFont(family)
-  }
-}
-
-function createRenderer(ckInstance: CanvasKit, width: number, height: number): SkiaRenderer {
-  const surface = ckInstance.MakeSurface(width, height)!
-  const renderer = new SkiaRenderer(ckInstance, surface)
-  renderer.viewportWidth = width
-  renderer.viewportHeight = height
-  renderer.dpr = 1
-  return renderer
-}
-
 export async function exportNodes(
   graph: SceneGraph,
   pageId: string,
   nodeIds: string[],
   options: { scale?: number; format?: ExportFormat; quality?: number }
 ): Promise<Uint8Array | null> {
-  const ckInstance = await initCanvasKit()
-  const renderer = createRenderer(ckInstance, 1, 1)
-  return renderNodesToImage(ckInstance, renderer, graph, pageId, nodeIds, {
-    scale: options.scale ?? 1,
-    format: options.format ?? 'PNG',
-    quality: options.quality
-  })
+  return headlessRenderNodes(graph, pageId, nodeIds, options)
 }
 
 export async function exportThumbnail(
@@ -70,7 +32,5 @@ export async function exportThumbnail(
   width: number,
   height: number
 ): Promise<Uint8Array | null> {
-  const ckInstance = await initCanvasKit()
-  const renderer = createRenderer(ckInstance, width, height)
-  return renderThumbnail(ckInstance, renderer, graph, pageId, width, height)
+  return headlessRenderThumbnail(graph, pageId, width, height)
 }

package/src/index.ts

@@ -6,6 +6,7 @@ import evalCmd from './commands/eval'
 import exportCmd from './commands/export'
 import find from './commands/find'
 import info from './commands/info'
+import query from './commands/query'
 import node from './commands/node'
 import pages from './commands/pages'
 import tree from './commands/tree'
@@ -25,6 +26,7 @@ const main = defineCommand({
     export: exportCmd,
     find,
     info,
+    query,
     node,
     pages,
     tree,
@@ -32,4 +34,4 @@ const main = defineCommand({
   }
 })
 
-runMain(main)
+void runMain(main)

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Danila Poyarkov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.